MNIST_interboundary.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "74b6f3ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import General Libraries\n",
    "import os\n",
    "import argparse\n",
    "import torch\n",
    "import copy\n",
    "import pickle\n",
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "# Import FedEM based Libraries\n",
    "from utils.utils import *\n",
    "from utils.constants import *\n",
    "from utils.args import *\n",
    "from run_experiment import *\n",
    "from models import *\n",
    "\n",
    "# Import Transfer Attack\n",
    "from transfer_attacks.Personalized_NN import *\n",
    "from transfer_attacks.Params import *\n",
    "from transfer_attacks.Transferer import *\n",
    "from transfer_attacks.Args import *\n",
    "from transfer_attacks.TA_utils import *\n",
    "from transfer_attacks.Boundary_Transferer import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "67d38773",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==> Clients initialization..\n",
      "===> Building data iterators..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 80/80 [00:00<00:00, 155.95it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===> Initializing clients..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 80/80 [00:17<00:00,  4.62it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==> Test Clients initialization..\n",
      "===> Building data iterators..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0it [00:00, ?it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===> Initializing clients..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0it [00:00, ?it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "++++++++++++++++++++++++++++++\n",
      "Global..\n",
      "Train Loss: 4.610 | Train Acc: 1.100% |Test Loss: 4.613 | Test Acc: 1.268% |\n",
      "++++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "################################################################################\n"
     ]
    }
   ],
   "source": [
    "# Generating Empty Aggregator to be loaded \n",
    "\n",
    "setting = 'local'\n",
    "\n",
    "if setting == 'FedEM':\n",
    "    nL = 3\n",
    "else:\n",
    "    nL = 1\n",
    "\n",
    "# Manually set argument parameters\n",
    "args_ = Args()\n",
    "args_.experiment = \"cifar100\"\n",
    "args_.method = setting\n",
    "args_.decentralized = False\n",
    "args_.sampling_rate = 1.0\n",
    "args_.input_dimension = None\n",
    "args_.output_dimension = None\n",
    "args_.n_learners= nL\n",
    "args_.n_rounds = 10\n",
    "args_.bz = 128\n",
    "args_.local_steps = 1\n",
    "args_.lr_lambda = 0\n",
    "args_.lr =0.03\n",
    "args_.lr_scheduler = 'multi_step'\n",
    "args_.log_freq = 10\n",
    "args_.device = 'cuda'\n",
    "args_.optimizer = 'sgd'\n",
    "args_.mu = 0\n",
    "args_.communication_probability = 0.1\n",
    "args_.q = 1\n",
    "args_.locally_tune_clients = False\n",
    "args_.seed = 1234\n",
    "args_.verbose = 1\n",
    "args_.save_path = 'weights/cifar100/benign/'\n",
    "args_.validation = False\n",
    "\n",
    "# Generate the dummy values here\n",
    "aggregator, clients = dummy_aggregator(args_, num_user=40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e6194931",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compiling Dataset from Clients\n",
    "# Combine Validation Data across all clients as test\n",
    "data_x = []\n",
    "data_y = []\n",
    "\n",
    "for i in range(len(clients)):\n",
    "    daniloader = clients[i].test_iterator\n",
    "    for (x,y,idx) in daniloader.dataset:\n",
    "        data_x.append(x)\n",
    "        data_y.append(y)\n",
    "\n",
    "data_x = torch.stack(data_x)\n",
    "try:\n",
    "    data_y = torch.stack(data_y)        \n",
    "except:\n",
    "    data_y = torch.FloatTensor(data_y) \n",
    "    \n",
    "dataloader = Custom_Dataloader(data_x, data_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f81eaafd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import Model Weights\n",
    "num_models = 40\n",
    "\n",
    "np.set_printoptions(formatter={'float': lambda x: \"{0:0.2f}\".format(x)})\n",
    "\n",
    "if setting == 'local':\n",
    "\n",
    "#     args_.save_path = 'weights/final/femnist/fig1_take3/local_benign/'\n",
    "#     args_.save_path ='weights/final/femnist/fig1_take3/local_adv/'\n",
    "    aggregator.load_state(args_.save_path)\n",
    "    \n",
    "    model_weights = []\n",
    "#     weights = np.load(\"weights/final/femnist/fig1_take3/local_benign/train_client_weights.npy\")\n",
    "    weights = np.load(args_.save_path + 'train_client_weights.npy')\n",
    "    \n",
    "    for i in range(num_models):\n",
    "        model_weights += [weights[i]]\n",
    "\n",
    "    # Generate the weights to test on as linear combinations of the model_weights\n",
    "    models_test = []\n",
    "\n",
    "    for i in range(num_models):\n",
    "        new_model = copy.deepcopy(aggregator.clients[i].learners_ensemble.learners[0].model)\n",
    "        new_model.eval()\n",
    "        models_test += [new_model]\n",
    "\n",
    "elif setting == 'FedAvg':\n",
    "    \n",
    "#     args_.save_path = 'weights/final/femnist/fig1_take3/fedavg_benign/'\n",
    "#     args_.save_path = 'weights/final/femnist/fig1_take3/FedAvg_adv/'\n",
    "    aggregator.load_state(args_.save_path)\n",
    "    \n",
    "    # This is where the models are stored -- one for each mixture --> learner.model for nn\n",
    "    hypotheses = aggregator.global_learners_ensemble.learners\n",
    "\n",
    "    # obtain the state dict for each of the weights \n",
    "    weights_h = []\n",
    "\n",
    "    for h in hypotheses:\n",
    "        weights_h += [h.model.state_dict()]\n",
    "\n",
    "#     weights = np.load(\"weights/final/femnist/fig1_take3/fedavg_benign/train_client_weights.npy\")\n",
    "    weights = np.load(args_.save_path + 'train_client_weights.npy')\n",
    "    \n",
    "    # Set model weights\n",
    "    model_weights = []\n",
    "\n",
    "    for i in range(num_models):\n",
    "        model_weights += [weights[i]]\n",
    "\n",
    "    # Generate the weights to test on as linear combinations of the model_weights\n",
    "    models_test = []\n",
    "\n",
    "    for (w0) in model_weights:\n",
    "        # first make the model with empty weights\n",
    "        new_model = copy.deepcopy(hypotheses[0].model)\n",
    "        new_model.eval()\n",
    "        new_weight_dict = copy.deepcopy(weights_h[0])\n",
    "        for key in weights_h[0]:\n",
    "            new_weight_dict[key] = w0[0]*weights_h[0][key] \n",
    "        new_model.load_state_dict(new_weight_dict)\n",
    "        models_test += [new_model]\n",
    "\n",
    "elif setting == 'FedEM':\n",
    "    \n",
    "#     args_.save_path = 'weights/cifar/21_12_30_feddef_n40_linf0_5_G0_0/'\n",
    "#     args_.save_path = 'weights/final/femnist/fig1_take3/fedem_adv/'\n",
    "#     args_.save_path = 'weights/final/femnist/figperturb/fedem_avg_p0_1/'\n",
    "    aggregator.load_state(args_.save_path)\n",
    "    \n",
    "    # This is where the models are stored -- one for each mixture --> learner.model for nn\n",
    "    hypotheses = aggregator.global_learners_ensemble.learners\n",
    "\n",
    "    # obtain the state dict for each of the weights \n",
    "    weights_h = []\n",
    "\n",
    "    for h in hypotheses:\n",
    "        weights_h += [h.model.state_dict()]\n",
    "\n",
    "#     weights = np.load(\"weights/cifar/21_12_30_feddef_n40_linf0_5_G0_0/train_client_weights.npy\")\n",
    "    weights = np.load(args_.save_path+\"train_client_weights.npy\")\n",
    "#     weights = np.load(\"weights/final/femnist/fig1_take3/fedem_adv/train_client_weights.npy\")\n",
    "#     weights = np.load(\"weights/final/femnist/figperturb/fedem_avg_p0_1/train_client_weights.npy\")\n",
    "\n",
    "    # Set model weights\n",
    "    model_weights = []\n",
    "\n",
    "    for i in range(num_models):\n",
    "        model_weights += [weights[i]]\n",
    "\n",
    "\n",
    "    # Generate the weights to test on as linear combinations of the model_weights\n",
    "    models_test = []\n",
    "\n",
    "    for (w0,w1,w2) in model_weights:\n",
    "        # first make the model with empty weights\n",
    "        new_model = copy.deepcopy(hypotheses[0].model)\n",
    "        new_model.eval()\n",
    "        new_weight_dict = copy.deepcopy(weights_h[0])\n",
    "        for key in weights_h[0]:\n",
    "            new_weight_dict[key] = w0*weights_h[0][key] + w1*weights_h[1][key] + w2*weights_h[2][key]\n",
    "        new_model.load_state_dict(new_weight_dict)\n",
    "        models_test += [new_model]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "451b5ab3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set trials \n",
    "num_trials = 50\n",
    "batch_size = 500\n",
    "adv_idx = 0\n",
    "adv_idxs = [0,1]\n",
    "# model_idx_max = 8\n",
    "model_idx_max = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "69d80c1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num_trial: 0\n",
      "num_trial: 1\n",
      "num_trial: 2\n",
      "num_trial: 3\n",
      "num_trial: 4\n",
      "num_trial: 5\n",
      "num_trial: 6\n",
      "num_trial: 7\n",
      "num_trial: 8\n",
      "num_trial: 9\n",
      "num_trial: 10\n",
      "num_trial: 11\n",
      "num_trial: 12\n",
      "num_trial: 13\n",
      "num_trial: 14\n",
      "num_trial: 15\n",
      "num_trial: 16\n",
      "num_trial: 17\n",
      "num_trial: 18\n",
      "num_trial: 19\n",
      "num_trial: 20\n",
      "num_trial: 21\n",
      "num_trial: 22\n",
      "num_trial: 23\n",
      "num_trial: 24\n",
      "num_trial: 25\n",
      "num_trial: 26\n",
      "num_trial: 27\n",
      "num_trial: 28\n",
      "num_trial: 29\n",
      "num_trial: 30\n",
      "num_trial: 31\n",
      "num_trial: 32\n",
      "num_trial: 33\n",
      "num_trial: 34\n",
      "num_trial: 35\n",
      "num_trial: 36\n",
      "num_trial: 37\n",
      "num_trial: 38\n",
      "num_trial: 39\n",
      "num_trial: 40\n",
      "num_trial: 41\n",
      "num_trial: 42\n",
      "num_trial: 43\n",
      "num_trial: 44\n",
      "num_trial: 45\n",
      "num_trial: 46\n",
      "num_trial: 47\n",
      "num_trial: 48\n",
      "num_trial: 49\n"
     ]
    }
   ],
   "source": [
    "dists_measure_legit = np.zeros([num_trials, model_idx_max])\n",
    "dists_measure_adv = np.zeros([num_trials, model_idx_max])\n",
    "dists_measure_adv_ensemble = np.zeros([num_trials, model_idx_max])\n",
    "\n",
    "\n",
    "# attack parameters\n",
    "eps = 4.5\n",
    "iteration = 10\n",
    "target = -1\n",
    "eps_norm = 2\n",
    "step_size = 0.01\n",
    "\n",
    "for i in range(num_trials):\n",
    "    print(\"num_trial:\", i)\n",
    "    t1 = Boundary_Transferer(models_list=models_test[:model_idx_max], dataloader=dataloader)\n",
    "    t1.base_nn_idx = 0\n",
    "    t1.victim_idx = range(model_idx_max)\n",
    "\n",
    "    t1.atk_params = IFSGM_Params()\n",
    "    t1.atk_params.set_params(batch_size=1, eps=0.1, alpha=0.01, iteration = 30,\n",
    "                       target = -1, x_val_min = torch.min(data_x), x_val_max = torch.max(data_x))\n",
    "    \n",
    "    t1.set_adv_NN(t1.base_nn_idx)\n",
    "\n",
    "    base_ep_legit, victim_eps_legit = t1.legitimate_direction(batch_size=batch_size, ep_granularity = 0.1, \n",
    "                                                              rep_padding = 1000, new_point = True,print_res = False)\n",
    "    \n",
    "    base_ep_adv, victim_eps_adv = t1.adversarial_direction(ep_granularity = 0.1, \n",
    "                                                              rep_padding = 1000, new_point = False,print_res = False)\n",
    "\n",
    "    t1.set_ensemble_adv_NN(adv_idxs)\n",
    "    base_ep_Eadv, victim_eps_Eadv = t1.ensemble_adversarial_direction(ep_granularity = 0.1, \n",
    "                                                              rep_padding = 1000, new_point = False,print_res = False)\n",
    "    \n",
    "    idx = 0\n",
    "    for key, value in victim_eps_legit.items():\n",
    "        dists_measure_legit[i,idx] = np.abs(base_ep_legit-value)\n",
    "        idx+=1\n",
    "        \n",
    "    idx = 0\n",
    "    for key, value in victim_eps_adv.items():\n",
    "        dists_measure_adv[i,idx] = np.abs(base_ep_adv - value)\n",
    "        idx+=1\n",
    "        \n",
    "    idx = 0\n",
    "    for key, value in victim_eps_Eadv.items():\n",
    "        dists_measure_adv_ensemble[i,idx] = np.abs(base_ep_Eadv - value)\n",
    "        idx+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5750842e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.00, 19.59, 5.69, 23.60])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.average(dists_measure_legit,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a86044e1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.49, 10.49, 10.65, 9.50])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.average(dists_measure_adv,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "76a9db15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.61, 6.64, 7.57, 10.52])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.average(dists_measure_adv_ensemble,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d18dcb7",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "FedEM_env",
   "language": "python",
   "name": "fedem_env"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}