main1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "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 FGSM import FGSM\n",
    "from BIM import BIM\n",
    "from visualize import visualise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %matplotlib inline\n",
    "# %matplotlib qt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "device  = torch.device('cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = get_model(device)                  # loads a pretrained vgg11 model\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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": 6,
   "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": 7,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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",
      "Unpert Top 1 Accuracy : 1.0\n",
      "Unpert Top 5 Accuracy : 1.0\n",
      "Top 1 FGSM Accuracy : 0.6\n",
      "Top 5 FGSM Accuracy : 0.9\n",
      "Top 1 BIM Accuracy : 0.6\n",
      "Top 5 BIM Accuracy : 1.0\n",
      "Top 1 PGD Accuracy : 0.6\n",
      "Top 5 PGD Accuracy : 0.9\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "Unpert Top 1 Accuracy : 1.0\n",
      "Unpert Top 5 Accuracy : 1.0\n",
      "Top 1 FGSM Accuracy : 0.19999999999999996\n",
      "Top 5 FGSM Accuracy : 0.8\n",
      "Top 1 BIM Accuracy : 0.6\n",
      "Top 5 BIM Accuracy : 0.9\n",
      "Top 1 PGD Accuracy : 0.5\n",
      "Top 5 PGD Accuracy : 0.9\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "Unpert Top 1 Accuracy : 1.0\n",
      "Unpert Top 5 Accuracy : 1.0\n",
      "Top 1 FGSM Accuracy : 0.0\n",
      "Top 5 FGSM Accuracy : 0.30000000000000004\n",
      "Top 1 BIM Accuracy : 0.0\n",
      "Top 5 BIM Accuracy : 0.4\n",
      "Top 1 PGD Accuracy : 0.4\n",
      "Top 5 PGD Accuracy : 0.8\n"
     ]
    }
   ],
   "source": [
    "imgs = os.listdir('imagenet_imgs/')\n",
    "\n",
    "# epsilon_arr = list(np.linspace(0,1,21))\n",
    "epsilon_arr = [0.005,0.01,0.05,0.1,0.3,0.6]\n",
    "batch_size = len(os.listdir('imagenet_imgs/'))\n",
    "fg_top_one_acc_arr = []\n",
    "fg_top_five_acc_arr = []\n",
    "bim_top_one_acc_arr = []\n",
    "bim_top_five_acc_arr = []\n",
    "pgd_top_one_acc_arr = []\n",
    "pgd_top_five_acc_arr = []\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['bim'] = 0\n",
    "    top_one_misclassfns['pgd'] = 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['bim'] = 0\n",
    "    top_five_misclassfns['pgd'] = 0\n",
    "    \n",
    "    # top_five_misclassfn['llc'] = 0\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",
    "            fgsm = FGSM(model,criterion,img_tsor,label,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",
    "            model.zero_grad()\n",
    "            ################ BIM ##############################\n",
    "            bim = BIM(model,criterion,img_tsor,label,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",
    "            model.zero_grad()\n",
    "            ########################## PGD  #####################\n",
    "            \n",
    "            pgd = BIM(model,criterion,img_tsor,label,epsilon,0.001,num_iters=6,random_state=True)\n",
    "            \n",
    "            pgd_adv_img,pgd_perturbation,pgd_loss = pgd.attack()\n",
    "            \n",
    "            pgd_output_adv,pgd_pred_adv, pgd_op_adv_probs, pgd_adv_pred_prob  = getPredictionInfo(model,pgd_adv_img)\n",
    "            \n",
    "            pgd_top_probs,pgd_top_labels = predict_top_five(model,pgd_adv_img,k=5)\n",
    "\n",
    "\n",
    "            top_one_misclassfns['pgd'] = checkMatchingLabels(label,pgd_pred_adv,top_one_misclassfns['pgd'])\n",
    "            top_five_misclassfns['pgd'] = checkMatchingLabelsTop_five(label,pgd_top_labels,top_five_misclassfns['pgd'])\n",
    "            \n",
    "            model.zero_grad()\n",
    "            \n",
    "            \n",
    "            \n",
    "#             if (int(label) not in unpert_top_labels.astype(int)):\n",
    "#                 unpert_top_five_misclassfns+=1\n",
    "            \n",
    "#             if (int(label)!=int(pred_adv)):\n",
    "#                 top_one_misclassfns+=1\n",
    "\n",
    "#             if(int(label) not in top_labels.astype(int)):\n",
    "#                 top_five_misclassfns+=1\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",
    "    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",
    "    pgd_top_one_acc_arr.append(1-(top_one_misclassfns['pgd']/batch_size))\n",
    "    pgd_top_five_acc_arr.append(1-(top_five_misclassfns['pgd']/batch_size))\n",
    "    \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 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 PGD Accuracy :',1-(top_one_misclassfns['pgd']/batch_size))\n",
    "    print('Top 5 PGD Accuracy :',1-(top_five_misclassfns['pgd']/batch_size))\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": 12,
   "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.005, 0.01, 0.05]\n",
      "Unperturbed\n",
      "[1.0, 1.0, 1.0]\n",
      "[1.0, 1.0, 1.0]\n",
      "FGSM\n",
      "[0.6, 0.19999999999999996, 0.0]\n",
      "[0.9, 0.8, 0.30000000000000004]\n",
      "BIM\n",
      "[0.6, 0.6, 0.0]\n",
      "[1.0, 0.9, 0.4]\n",
      "PGD\n",
      "[0.6, 0.5, 0.4]\n",
      "[0.9, 0.9, 0.8]\n",
      "DONE DONA DONE\n"
     ]
    }
   ],
   "source": [
    "# epsilon_arr = [0.05]\n",
    "plt.figure()\n",
    "plt.title('Top-1 Accuracy for FGSM,BIM,PGD 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,pgd_top_one_acc_arr,label='PGD',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,PGD 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,pgd_top_five_acc_arr,label='PGD',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('PGD')\n",
    "print(pgd_top_one_acc_arr)\n",
    "print(pgd_top_five_acc_arr)\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
}