main2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch \n",
    "import torch.nn as nn\n",
    "import os\n",
    "import argparse\n",
    "from torchvision import datasets, transforms\n",
    "import torchvision.transforms as transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch.optim as optim\n",
    "import torchvision\n",
    "import torch.nn.functional as F\n",
    "import sys\n",
    "from PIL import Image\n",
    "import requests\n",
    "from io import BytesIO\n",
    "import urllib.request as url_req\n",
    "import pickle\n",
    "from Model import get_model\n",
    "from utils import *\n",
    "import json\n",
    "from model_and_data import Data\n",
    "from targetedFGSM import FGSM_targeted\n",
    "from targetedBIM import BIM_targeted\n",
    "from visualize import visualise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %matplotlib inline\n",
    "# %matplotlib qt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "device  = torch.device('cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "VGG(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (1): ReLU(inplace)\n",
       "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (3): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (4): ReLU(inplace)\n",
       "    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (6): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (7): ReLU(inplace)\n",
       "    (8): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (9): ReLU(inplace)\n",
       "    (10): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (11): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (12): ReLU(inplace)\n",
       "    (13): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (14): ReLU(inplace)\n",
       "    (15): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (16): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (17): ReLU(inplace)\n",
       "    (18): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (19): ReLU(inplace)\n",
       "    (20): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (classifier): Sequential(\n",
       "    (0): Linear(in_features=25088, out_features=4096, bias=True)\n",
       "    (1): ReLU(inplace)\n",
       "    (2): Dropout(p=0.5)\n",
       "    (3): Linear(in_features=4096, out_features=4096, bias=True)\n",
       "    (4): ReLU(inplace)\n",
       "    (5): Dropout(p=0.5)\n",
       "    (6): Linear(in_features=4096, out_features=1000, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = get_model(device)                  # loads a pretrained vgg11 model\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def imshow(img,wnid,title=None):\n",
    "    img = img.cpu().detach().numpy().transpose((1,2,0))\n",
    "    mean=np.array([0.485, 0.456, 0.406])\n",
    "    std=np.array([0.229, 0.224, 0.225])\n",
    "    \n",
    "    img = img*std+mean\n",
    "#     img = np.clip(img,0,1)\n",
    "    plt.imshow(img)\n",
    "    \n",
    "#     title = getClassOfId(wnid)\n",
    "    \n",
    "    plt.title(title)\n",
    "    plt.pause(0.001)  # pause a bit so that plots are updated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# url_files = ['valid_urls1.txt','valid_urls2.txt','valid_urls3.txt','valid_urls4.txt','valid_urls5.txt']\n",
    "# # url_files = ['valid_urls1.txt']\n",
    " \n",
    "# key_to_label_map = pickle.load(open('pickled_id_label_imagenet_map', 'rb')) # load mapping as dict\n",
    "\n",
    "# for url_file in url_files:\n",
    "#     with open(url_file) as f:\n",
    "#         url_dict = json.load(f)\n",
    "        \n",
    "#         label_idxs = list(url_dict.keys())\n",
    "#         print(label_idxs)\n",
    "#         label = label_idxs[0]\n",
    "#         key = key_to_label_map[int(label)]['label']\n",
    "#         print(key,label)\n",
    "#         url_list = url_dict[label]\n",
    "#         test_url = url_list[0]\n",
    "#         test_img = urltoImg(test_url)\n",
    "        \n",
    "#         data = Data(model,device, None,None)\n",
    "#         img_tsor = data.preprocess_data(test_img)\n",
    "#         img_tsor.unsqueeze_(0)\n",
    "#         img_tsor = img_tsor.to(device)\n",
    "\n",
    "#         label = torch.tensor(float(label),requires_grad=False)\n",
    "#         label = label.to(device)\n",
    "\n",
    "#         criterion = nn.CrossEntropyLoss()\n",
    "#         print(img_tsor.size())\n",
    "#         output = model(img_tsor)\n",
    "#         _,pred = torch.max(output,1)\n",
    "#         img_tsor.squeeze_(0)\n",
    "#         imshow(img_tsor,key)\n",
    "#         print('Original label = ',float(label))\n",
    "#         print('Output idx and class =',float(pred.cpu()),',',key_to_label_map[float(pred.cpu())]['label'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save all images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# url_files = ['valid_urls1.txt','valid_urls2.txt','valid_urls3.txt','valid_urls4.txt','valid_urls5.txt']\n",
    "\n",
    "# for url_file in url_files:\n",
    "#     with open(url_file) as f:\n",
    "#         url_dict = json.load(f)\n",
    "        \n",
    "#     for label in url_dict.keys():\n",
    "#         save_imgs(label,url_dict[label])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['121' '130' '144' '148' '151' '21' '282' '293' '295' '298' '309' '31'\n",
      " '311' '314' '35' '360' '417' '430' '438' '457' '470' '480' '49' '491'\n",
      " '63' '75' '8' '84' '86' '9']\n"
     ]
    }
   ],
   "source": [
    "imgs = os.listdir('imagenet_imgs/')\n",
    "all_labels = [img_name.split('_')[0] for img_name in imgs]\n",
    "unique_labels = np.unique(all_labels)\n",
    "print(unique_labels)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n",
      "24\n",
      "25\n",
      "26\n",
      "27\n",
      "28\n",
      "29\n",
      "30\n",
      "31\n",
      "32\n",
      "33\n",
      "34\n",
      "35\n",
      "36\n",
      "37\n",
      "38\n",
      "39\n",
      "40\n",
      "41\n",
      "42\n",
      "43\n",
      "44\n",
      "45\n",
      "46\n",
      "47\n",
      "48\n",
      "49\n",
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n",
      "55\n",
      "56\n",
      "57\n",
      "58\n",
      "59\n",
      "60\n",
      "61\n",
      "62\n",
      "63\n",
      "64\n",
      "65\n",
      "66\n",
      "67\n",
      "68\n",
      "69\n",
      "70\n",
      "71\n",
      "72\n",
      "73\n",
      "74\n",
      "75\n",
      "76\n",
      "77\n",
      "78\n",
      "79\n",
      "80\n",
      "81\n",
      "82\n",
      "83\n",
      "84\n",
      "85\n",
      "86\n",
      "87\n",
      "88\n",
      "89\n",
      "90\n",
      "91\n",
      "92\n",
      "93\n",
      "94\n",
      "95\n",
      "96\n",
      "97\n",
      "98\n",
      "99\n",
      "100\n",
      "101\n",
      "102\n",
      "103\n",
      "104\n",
      "105\n",
      "106\n",
      "107\n",
      "108\n",
      "109\n",
      "110\n",
      "111\n",
      "112\n",
      "113\n",
      "114\n",
      "115\n",
      "116\n",
      "117\n",
      "118\n",
      "119\n",
      "120\n",
      "121\n",
      "122\n",
      "123\n",
      "124\n",
      "125\n",
      "126\n",
      "127\n",
      "128\n",
      "129\n",
      "130\n",
      "131\n",
      "132\n",
      "133\n",
      "134\n",
      "135\n",
      "136\n",
      "137\n",
      "138\n",
      "139\n",
      "140\n",
      "141\n",
      "142\n",
      "143\n",
      "144\n",
      "145\n",
      "146\n",
      "147\n",
      "148\n",
      "149\n",
      "Unpert Top 1 Accuracy : 1.0\n",
      "Unpert Top 5 Accuracy : 1.0\n",
      "Top 1 FGSM Accuracy : 0.5733333333333333\n",
      "Top 5 FGSM Accuracy : 0.7866666666666666\n",
      "Top 1 FGSM Accuracy(Class Changed) : 0.06000000000000005\n",
      "Top 5 FGSM Accuracy(Class Changed) : 0.10666666666666669\n",
      "Top 1 BIM Accuracy : 0.9466666666666667\n",
      "Top 5 BIM Accuracy : 1.0\n",
      "Top 1 BIM Accuracy(Class Changed) : 0.94\n",
      "Top 5 BIM Accuracy(Class Changed) : 0.033333333333333326\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n",
      "24\n",
      "25\n",
      "26\n",
      "27\n",
      "28\n",
      "29\n",
      "30\n",
      "31\n",
      "32\n",
      "33\n",
      "34\n",
      "35\n",
      "36\n",
      "37\n",
      "38\n",
      "39\n",
      "40\n",
      "41\n",
      "42\n",
      "43\n",
      "44\n",
      "45\n",
      "46\n",
      "47\n",
      "48\n",
      "49\n",
      "50\n",
      "51\n",
      "52\n",
      "53\n",
      "54\n",
      "55\n",
      "56\n",
      "57\n",
      "58\n",
      "59\n",
      "60\n",
      "61\n",
      "62\n",
      "63\n",
      "64\n",
      "65\n",
      "66\n",
      "67\n",
      "68\n",
      "69\n",
      "70\n",
      "71\n",
      "72\n",
      "73\n",
      "74\n",
      "75\n",
      "76\n",
      "77\n",
      "78\n",
      "79\n",
      "80\n",
      "81\n",
      "82\n",
      "83\n",
      "84\n",
      "85\n",
      "86\n",
      "87\n",
      "88\n",
      "89\n",
      "90\n",
      "91\n",
      "92\n",
      "93\n",
      "94\n",
      "95\n",
      "96\n",
      "97\n",
      "98\n",
      "99\n",
      "100\n",
      "101\n",
      "102\n",
      "103\n",
      "104\n",
      "105\n",
      "106\n",
      "107\n",
      "108\n",
      "109\n",
      "110\n",
      "111\n",
      "112\n",
      "113\n",
      "114\n",
      "115\n",
      "116\n",
      "117\n",
      "118\n",
      "119\n",
      "120\n",
      "121\n",
      "122\n",
      "123\n",
      "124\n",
      "125\n",
      "126\n",
      "127\n",
      "128\n",
      "129\n",
      "130\n",
      "131\n",
      "132\n",
      "133\n",
      "134\n",
      "135\n",
      "136\n",
      "137\n",
      "138\n",
      "139\n",
      "140\n",
      "141\n",
      "142\n",
      "143\n",
      "144\n",
      "145\n",
      "146\n",
      "147\n",
      "148\n",
      "149\n",
      "Unpert Top 1 Accuracy : 1.0\n",
      "Unpert Top 5 Accuracy : 1.0\n",
      "Top 1 FGSM Accuracy : 0.08666666666666667\n",
      "Top 5 FGSM Accuracy : 0.19333333333333336\n",
      "Top 1 FGSM Accuracy(Class Changed) : 0.11333333333333329\n",
      "Top 5 FGSM Accuracy(Class Changed) : 0.18666666666666665\n",
      "Top 1 BIM Accuracy : 0.9333333333333333\n",
      "Top 5 BIM Accuracy : 0.9733333333333334\n",
      "Top 1 BIM Accuracy(Class Changed) : 0.9266666666666666\n",
      "Top 5 BIM Accuracy(Class Changed) : 0.020000000000000018\n"
     ]
    }
   ],
   "source": [
    "imgs = os.listdir('imagenet_imgs/')\n",
    "\n",
    "# epsilon_arr = list(np.linspace(0,1,21))\n",
    "# epsilon_arr = [0.01,0.05,0.1,0.5,1]\n",
    "epsilon_arr = [0.01,0.05]\n",
    "\n",
    "batch_size = len(os.listdir('imagenet_imgs/'))\n",
    "fg_top_one_acc_arr = []\n",
    "fg_top_five_acc_arr = []\n",
    "\n",
    "fg_t1_local_acc = []             # local is for exact class change\n",
    "fg_t5_local_acc = []\n",
    "\n",
    "bim_top_one_acc_arr = []\n",
    "bim_top_five_acc_arr = []\n",
    "bim_t1_local_acc = []\n",
    "bim_t5_local_acc = []\n",
    "\n",
    "unpert_top_one_acc = []\n",
    "unpert_top_five_acc = []\n",
    "\n",
    "top_one_misclassfns = {}\n",
    "top_five_misclassfns = {}\n",
    "\n",
    "\n",
    "for epsilon in epsilon_arr:\n",
    "    top_one_misclassfns['unpert'] = 0\n",
    "    top_one_misclassfns['fgsm'] = 0\n",
    "    top_one_misclassfns['fgsm_local'] = 0\n",
    "    top_one_misclassfns['bim'] = 0\n",
    "    top_one_misclassfns['bim_local'] = 0\n",
    "    \n",
    "    # top_one_misclassfn['llc'] = 0\n",
    "\n",
    "    top_five_misclassfns['unpert'] = 0\n",
    "    top_five_misclassfns['fgsm'] = 0\n",
    "    top_five_misclassfns['fgsm_local'] = 0\n",
    "    top_five_misclassfns['bim'] = 0\n",
    "    top_five_misclassfns['bim_local'] = 0\n",
    "    \n",
    "    # top_five_misclassfn['llc'] = 0\n",
    "    \n",
    "    \n",
    "    # choose randomly a target class\n",
    "    targetLabel = unique_labels[np.random.randint(0,len(unique_labels))]\n",
    "    targetLabel = torch.tensor([int(targetLabel)],requires_grad=False)\n",
    "    targetLabel = targetLabel.to(device)\n",
    "    \n",
    "    for idx,img_name in enumerate(imgs):\n",
    "            print(idx)\n",
    "            img_path = os.path.join('imagenet_imgs/',img_name)\n",
    "            data = Data(model,device, None,None)\n",
    "            img_tsor = data.preprocess_data(Image.open(img_path))\n",
    "    #         imshow(img_tsor,'dgs')\n",
    "            img_tsor.unsqueeze_(0)\n",
    "            img_tsor = img_tsor.to(device)\n",
    "            img_tsor.requires_grad_(True)\n",
    "\n",
    "            label = img_name.split('_')[0]\n",
    "            label = torch.tensor([int(label)],requires_grad=False)\n",
    "            label = label.to(device)\n",
    "    #         print(label.shape)\n",
    "\n",
    "            criterion = nn.CrossEntropyLoss()\n",
    "            ############ Unperturbed Model ######################\n",
    "            unpert_output,unpert_pred, unpert_op_probs, unpert_pred_prob = getPredictionInfo(model,img_tsor)\n",
    "            unpert_top_probs, unpert_top_labels = predict_top_five(model,img_tsor,k=5)\n",
    "            \n",
    "            top_one_misclassfns['unpert'] = checkMatchingLabels(label,unpert_pred,top_one_misclassfns['unpert'])\n",
    "            top_five_misclassfns['unpert'] = checkMatchingLabelsTop_five(label,unpert_top_labels,top_five_misclassfns['unpert'])\n",
    "            model.zero_grad()\n",
    "            ############### FGSM ################################\n",
    "            \n",
    "            \n",
    "            fgsm = FGSM_targeted(model,criterion,img_tsor,label,targetLabel,epsilon)\n",
    "            fg_adv_img,fg_perturbation = fgsm.attack()\n",
    "            \n",
    "            fg_output_adv,fg_pred_adv, fg_op_adv_probs, fg_adv_pred_prob  = getPredictionInfo(model,fg_adv_img)\n",
    "#             output_adv = model(torch.tensor(adv_img))\n",
    "#             _,pred_adv = torch.max(output_adv.data,1)\n",
    "#         #     print(adv_img.data-img.data)\n",
    "#             op_adv_probs = F.softmax(output_adv, dim=1)                 #get probability distribution over classes\n",
    "#             adv_pred_prob =  ((torch.max(op_adv_probs.data, 1)[0][0]) * 100, 4)      #find probability (confidence) of a predicted class\n",
    "\n",
    "            fg_top_probs,fg_top_labels = predict_top_five(model,fg_adv_img,k=5)\n",
    "\n",
    "    #         print(int(label),int(pred_adv))\n",
    "            top_one_misclassfns['fgsm'] = checkMatchingLabels(label,fg_pred_adv,top_one_misclassfns['fgsm'])\n",
    "            top_five_misclassfns['fgsm'] = checkMatchingLabelsTop_five(label,fg_top_labels,top_five_misclassfns['fgsm'])\n",
    "            \n",
    "            top_one_misclassfns['fgsm_local'] = checkMatchingLabels(targetLabel,fg_pred_adv,top_one_misclassfns['fgsm_local'])\n",
    "            top_five_misclassfns['fgsm_local'] = checkMatchingLabelsTop_five(targetLabel,fg_top_labels,top_five_misclassfns['fgsm_local'])\n",
    "            \n",
    "            model.zero_grad()\n",
    "            ################ BIM ##############################\n",
    "            bim = BIM_targeted(model,criterion,img_tsor,label,targetLabel,epsilon,epsilon/2,num_iters=0,random_state=False)\n",
    "            \n",
    "            bim_adv_img,bim_perturbation,bim_loss = bim.attack()\n",
    "            \n",
    "            bim_output_adv,bim_pred_adv, bim_op_adv_probs, bim_adv_pred_prob  = getPredictionInfo(model,bim_adv_img)\n",
    "            \n",
    "            bim_top_probs,bim_top_labels = predict_top_five(model,bim_adv_img,k=5)\n",
    "\n",
    "\n",
    "            top_one_misclassfns['bim'] = checkMatchingLabels(label,bim_pred_adv,top_one_misclassfns['bim'])\n",
    "            top_five_misclassfns['bim'] = checkMatchingLabelsTop_five(label,bim_top_labels,top_five_misclassfns['bim'])\n",
    "            \n",
    "            top_one_misclassfns['bim_local'] = checkMatchingLabels(targetLabel,bim_pred_adv,top_one_misclassfns['bim_local'])\n",
    "            top_five_misclassfns['bim_local'] = checkMatchingLabelsTop_five(targetLabel,bim_top_labels,top_five_misclassfns['bim_local'])\n",
    "            model.zero_grad()\n",
    "            \n",
    "            \n",
    "\n",
    "                \n",
    "    unpert_top_one_acc.append(1-(top_one_misclassfns['unpert']/batch_size))\n",
    "    unpert_top_five_acc.append(1-(top_five_misclassfns['unpert']/batch_size))\n",
    "    fg_top_one_acc_arr.append(1-(top_one_misclassfns['fgsm']/batch_size))\n",
    "    fg_top_five_acc_arr.append(1-(top_five_misclassfns['fgsm']/batch_size))\n",
    "    fg_t1_local_acc.append(1-(top_one_misclassfns['fgsm_local']/batch_size))\n",
    "    fg_t5_local_acc.append(1-(top_five_misclassfns['fgsm_local']/batch_size))\n",
    "    bim_top_one_acc_arr.append(1-(top_one_misclassfns['bim']/batch_size))\n",
    "    bim_top_five_acc_arr.append(1-(top_five_misclassfns['bim']/batch_size))\n",
    "    bim_t1_local_acc.append(1-(top_one_misclassfns['bim_local']/batch_size))\n",
    "    bim_t5_local_acc.append(1-(top_five_misclassfns['bim_local']/batch_size))\n",
    "    \n",
    "    print('Unpert Top 1 Accuracy :',1-(top_one_misclassfns['unpert']/batch_size))\n",
    "    print('Unpert Top 5 Accuracy :',1-(top_five_misclassfns['unpert']/batch_size))\n",
    "    print('Top 1 FGSM Accuracy :',1-(top_one_misclassfns['fgsm']/batch_size))\n",
    "    print('Top 5 FGSM Accuracy :',1-(top_five_misclassfns['fgsm']/batch_size))\n",
    "    print('Top 1 FGSM Accuracy(Class Changed) :',1-(top_one_misclassfns['fgsm_local']/batch_size))\n",
    "    print('Top 5 FGSM Accuracy(Class Changed) :',1-(top_five_misclassfns['fgsm_local']/batch_size))\n",
    "    print('Top 1 BIM Accuracy :',1-(top_one_misclassfns['bim']/batch_size))\n",
    "    print('Top 5 BIM Accuracy :',1-(top_five_misclassfns['bim']/batch_size))\n",
    "    print('Top 1 BIM Accuracy(Class Changed) :',1-(top_one_misclassfns['bim_local']/batch_size))\n",
    "    print('Top 5 BIM Accuracy(Class Changed) :',1-(top_five_misclassfns['bim_local']/batch_size))\n",
    "    \n",
    "    \n",
    "\n",
    "# plt.figure()\n",
    "# plt.title('Top-1 Accuracy for FGSM and BIM vs Epsilon')\n",
    "# plt.plot(epsilon_arr,unpert_top_one_acc, label='Unperturbed Model')\n",
    "# plt.plot(epsilon_arr,fg_top_one_acc_arr,label='FGSM')\n",
    "# plt.plot(epsilon_arr,bim_top_one_acc_arr,label='BIM')\n",
    "# plt.ylabel('Top-1 Accuracy')\n",
    "# plt.xlabel('Epsilon')\n",
    "# plt.legend()\n",
    "\n",
    "\n",
    "# plt.figure()\n",
    "# plt.title('Top-5 Accuracy for FGSM and BIM vs Epsilon')\n",
    "# plt.plot(epsilon_arr,unpert_top_five_acc)\n",
    "# plt.plot(epsilon_arr,top_five_acc_arr,label='FGSM')\n",
    "# plt.plot(epsilon_arr,bim_top_five_acc_arr,label='BIM')\n",
    "# plt.ylabel('Top-5 Accuracy')\n",
    "# plt.xlabel('Epsilon')\n",
    "# plt.legend()\n",
    "# plt.show()\n",
    "# #         visualise(img_tsor,perturbation,adv_img,label,label,pred_prob,pred_adv,adv_pred_prob,epsilon,topkProb=top_probs,topkLabel=top_labels)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epsilon [0.01, 0.05]\n",
      "Unperturbed\n",
      "[1.0, 1.0]\n",
      "[1.0, 1.0]\n",
      "FGSM\n",
      "[0.5733333333333333, 0.08666666666666667]\n",
      "[0.7866666666666666, 0.19333333333333336]\n",
      "BIM\n",
      "[0.9466666666666667, 0.9333333333333333]\n",
      "[1.0, 0.9733333333333334]\n",
      "FGSM_local\n",
      "[0.06000000000000005, 0.11333333333333329]\n",
      "[0.10666666666666669, 0.18666666666666665]\n",
      "BIM_local\n",
      "[0.94, 0.9266666666666666]\n",
      "[0.033333333333333326, 0.020000000000000018]\n",
      "DONE DONA DONE\n"
     ]
    }
   ],
   "source": [
    "# epsilon_arr = [0.05]\n",
    "plt.figure()\n",
    "plt.title('Top-1 Accuracy for FGSM,BIM(Targeted) vs Epsilon')\n",
    "plt.plot(epsilon_arr,unpert_top_one_acc, label='Unperturbed Model',marker='o')\n",
    "plt.plot(epsilon_arr,fg_top_one_acc_arr,label='FGSM',marker='o')\n",
    "plt.plot(epsilon_arr,bim_top_one_acc_arr,label='BIM',marker='o')\n",
    "plt.plot(epsilon_arr,fg_t1_local_acc,label='FGSM(changed_to_target)',marker='o')\n",
    "plt.plot(epsilon_arr,bim_t1_local_acc,label='BIM(changed_to_target)',marker='o')\n",
    "plt.ylabel('Top-1 Accuracy')\n",
    "plt.xlabel('Epsilon')\n",
    "plt.legend()\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.title('Top-5 Accuracy for FGSM,BIM(Targeted) vs Epsilon')\n",
    "plt.plot(epsilon_arr,unpert_top_five_acc,label='Unperturbed Model',marker='o')\n",
    "plt.plot(epsilon_arr,fg_top_five_acc_arr,label='FGSM',marker='o')\n",
    "plt.plot(epsilon_arr,bim_top_five_acc_arr,label='BIM',marker='o')\n",
    "plt.plot(epsilon_arr,fg_t5_local_acc,label='FGSM(changed_to_target)',marker='o')\n",
    "plt.plot(epsilon_arr,bim_t5_local_acc,label='BIM(changed_to_target)',marker='o')\n",
    "plt.ylabel('Top-5 Accuracy')\n",
    "plt.xlabel('Epsilon')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "#         visualise(img_tsor,perturbation,adv_img,label,label,pred_prob,pred_adv,adv_pred_prob,epsilon,topkProb=top_probs,topkLabel=top_labels)\n",
    "print('Epsilon',epsilon_arr)\n",
    "print('Unperturbed')\n",
    "print(unpert_top_one_acc)\n",
    "print(unpert_top_five_acc)\n",
    "print('FGSM')\n",
    "print(fg_top_one_acc_arr)\n",
    "print(fg_top_five_acc_arr)\n",
    "print('BIM')\n",
    "print(bim_top_one_acc_arr)\n",
    "print(bim_top_five_acc_arr)\n",
    "print('FGSM_local')\n",
    "print(fg_t1_local_acc)\n",
    "print(fg_t5_local_acc)\n",
    "print('BIM_local')\n",
    "print(bim_t1_local_acc)\n",
    "print(bim_t5_local_acc)\n",
    "print('DONE DONA DONE')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}