fgsm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch, torchvision\n",
    "from torchvision import datasets, models, transforms\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader\n",
    "import time\n",
    "from torchsummary import summary\n",
    "import pathlib\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Discovered 129998 images in 200 classes\n",
      "{0: 'n01443537', 1: 'n01629819', 2: 'n01641577', 3: 'n01644900', 4: 'n01698640', 5: 'n01742172', 6: 'n01768244', 7: 'n01770393', 8: 'n01774384', 9: 'n01774750', 10: 'n01784675', 11: 'n01855672', 12: 'n01882714', 13: 'n01910747', 14: 'n01917289', 15: 'n01944390', 16: 'n01945685', 17: 'n01950731', 18: 'n01983481', 19: 'n01984695', 20: 'n02002724', 21: 'n02056570', 22: 'n02058221', 23: 'n02074367', 24: 'n02085620', 25: 'n02094433', 26: 'n02099601', 27: 'n02099712', 28: 'n02106662', 29: 'n02113799', 30: 'n02123045', 31: 'n02123394', 32: 'n02124075', 33: 'n02125311', 34: 'n02129165', 35: 'n02132136', 36: 'n02165456', 37: 'n02190166', 38: 'n02206856', 39: 'n02226429', 40: 'n02231487', 41: 'n02233338', 42: 'n02236044', 43: 'n02268443', 44: 'n02279972', 45: 'n02281406', 46: 'n02321529', 47: 'n02364673', 48: 'n02395406', 49: 'n02403003', 50: 'n02410509', 51: 'n02415577', 52: 'n02423022', 53: 'n02437312', 54: 'n02480495', 55: 'n02481823', 56: 'n02486410', 57: 'n02504458', 58: 'n02509815', 59: 'n02666196', 60: 'n02669723', 61: 'n02699494', 62: 'n02730930', 63: 'n02769748', 64: 'n02788148', 65: 'n02791270', 66: 'n02793495', 67: 'n02795169', 68: 'n02802426', 69: 'n02808440', 70: 'n02814533', 71: 'n02814860', 72: 'n02815834', 73: 'n02823428', 74: 'n02837789', 75: 'n02841315', 76: 'n02843684', 77: 'n02883205', 78: 'n02892201', 79: 'n02906734', 80: 'n02909870', 81: 'n02917067', 82: 'n02927161', 83: 'n02948072', 84: 'n02950826', 85: 'n02963159', 86: 'n02977058', 87: 'n02988304', 88: 'n02999410', 89: 'n03014705', 90: 'n03026506', 91: 'n03042490', 92: 'n03085013', 93: 'n03089624', 94: 'n03100240', 95: 'n03126707', 96: 'n03160309', 97: 'n03179701', 98: 'n03201208', 99: 'n03250847', 100: 'n03255030', 101: 'n03355925', 102: 'n03388043', 103: 'n03393912', 104: 'n03400231', 105: 'n03404251', 106: 'n03424325', 107: 'n03444034', 108: 'n03447447', 109: 'n03544143', 110: 'n03584254', 111: 'n03599486', 112: 'n03617480', 113: 'n03637318', 114: 'n03649909', 115: 'n03662601', 116: 'n03670208', 117: 'n03706229', 118: 'n03733131', 119: 'n03763968', 120: 'n03770439', 121: 'n03796401', 122: 'n03804744', 123: 'n03814639', 124: 'n03837869', 125: 'n03838899', 126: 'n03854065', 127: 'n03891332', 128: 'n03902125', 129: 'n03930313', 130: 'n03937543', 131: 'n03970156', 132: 'n03976657', 133: 'n03977966', 134: 'n03980874', 135: 'n03983396', 136: 'n03992509', 137: 'n04008634', 138: 'n04023962', 139: 'n04067472', 140: 'n04070727', 141: 'n04074963', 142: 'n04099969', 143: 'n04118538', 144: 'n04133789', 145: 'n04146614', 146: 'n04149813', 147: 'n04179913', 148: 'n04251144', 149: 'n04254777', 150: 'n04259630', 151: 'n04265275', 152: 'n04275548', 153: 'n04285008', 154: 'n04311004', 155: 'n04328186', 156: 'n04356056', 157: 'n04366367', 158: 'n04371430', 159: 'n04376876', 160: 'n04398044', 161: 'n04399382', 162: 'n04417672', 163: 'n04456115', 164: 'n04465501', 165: 'n04486054', 166: 'n04487081', 167: 'n04501370', 168: 'n04507155', 169: 'n04532106', 170: 'n04532670', 171: 'n04540053', 172: 'n04560804', 173: 'n04562935', 174: 'n04596742', 175: 'n04597913', 176: 'n06596364', 177: 'n07579787', 178: 'n07583066', 179: 'n07614500', 180: 'n07615774', 181: 'n07695742', 182: 'n07711569', 183: 'n07715103', 184: 'n07720875', 185: 'n07734744', 186: 'n07747607', 187: 'n07749582', 188: 'n07753592', 189: 'n07768694', 190: 'n07871810', 191: 'n07873807', 192: 'n07875152', 193: 'n07920052', 194: 'n09193705', 195: 'n09246464', 196: 'n09256479', 197: 'n09332890', 198: 'n09428293', 199: 'n12267677'}\n",
      "CUDA Available:  True\n"
     ]
    }
   ],
   "source": [
    "# Load the Data\n",
    "\n",
    "data_dir = pathlib.Path('./data/tiny-imagenet-200')\n",
    "image_count = len(list(data_dir.glob('**/*.JPEG')))\n",
    "CLASS_NAMES = np.array([item.name for item in (data_dir / 'train').glob('*')])\n",
    "num_classes = len(CLASS_NAMES)\n",
    "print('Discovered {} images in {} classes'.format(image_count, num_classes))\n",
    "\n",
    "# Create the training data generator\n",
    "batch_size = 32\n",
    "im_height = 64\n",
    "im_width = 64\n",
    "num_epochs = 1\n",
    "\n",
    "data_transforms = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0, 0, 0), tuple(np.sqrt((255, 255, 255)))),\n",
    "])\n",
    "\n",
    "# Load Data from folders\n",
    "data = {\n",
    "    'train': datasets.ImageFolder(root=data_dir / 'train', transform=data_transforms),\n",
    "    'valid': datasets.ImageFolder(root=data_dir / 'val', transform=data_transforms),\n",
    "    'test': datasets.ImageFolder(root=data_dir / 'test', transform=data_transforms)\n",
    "}\n",
    "\n",
    "# Get a mapping of the indices to the class names, in order to see the output classes of the test images.\n",
    "idx_to_class = {v: k for k, v in data['train'].class_to_idx.items()}\n",
    "print(idx_to_class)\n",
    "\n",
    "# Size of Data, to be used for calculating Average Loss and Accuracy\n",
    "train_data_size = len(data['train'])\n",
    "valid_data_size = len(data['valid'])\n",
    "test_data_size = len(data['test'])\n",
    "\n",
    "# Create iterators for the Data loaded using DataLoader module\n",
    "train_data_loader = DataLoader(data['train'], batch_size=batch_size, shuffle=True)\n",
    "valid_data_loader = DataLoader(data['valid'], batch_size=batch_size, shuffle=True)\n",
    "test_data_loader = DataLoader(data['test'], batch_size=batch_size, shuffle=True)\n",
    "\n",
    "# Define what device we are using\n",
    "print(\"CUDA Available: \",torch.cuda.is_available())\n",
    "device = torch.device(\"cuda\" if (torch.cuda.is_available()) else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ResNet(\n",
       "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
       "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (relu): ReLU(inplace=True)\n",
       "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "  (layer1): Sequential(\n",
       "    (0): Bottleneck(\n",
       "      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (downsample): Sequential(\n",
       "        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): Bottleneck(\n",
       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (2): Bottleneck(\n",
       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "  )\n",
       "  (layer2): Sequential(\n",
       "    (0): Bottleneck(\n",
       "      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (downsample): Sequential(\n",
       "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): Bottleneck(\n",
       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (2): Bottleneck(\n",
       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (3): Bottleneck(\n",
       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "  )\n",
       "  (layer3): Sequential(\n",
       "    (0): Bottleneck(\n",
       "      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (downsample): Sequential(\n",
       "        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): Bottleneck(\n",
       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (2): Bottleneck(\n",
       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (3): Bottleneck(\n",
       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (4): Bottleneck(\n",
       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (5): Bottleneck(\n",
       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "  )\n",
       "  (layer4): Sequential(\n",
       "    (0): Bottleneck(\n",
       "      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (downsample): Sequential(\n",
       "        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): Bottleneck(\n",
       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (2): Bottleneck(\n",
       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "  )\n",
       "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
       "  (fc): Sequential(\n",
       "    (0): Linear(in_features=2048, out_features=256, bias=True)\n",
       "    (1): ReLU()\n",
       "    (2): Dropout(p=0.4, inplace=False)\n",
       "    (3): Linear(in_features=256, out_features=200, bias=True)\n",
       "    (4): LogSoftmax()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load pretrained ResNet50 Model\n",
    "model = models.resnet50(pretrained=False)\n",
    "\n",
    "# Change the final layer of ResNet50 Model for Transfer Learning\n",
    "fc_inputs = model.fc.in_features\n",
    "\n",
    "model.fc = nn.Sequential(\n",
    "    nn.Linear(fc_inputs, 256),\n",
    "    nn.ReLU(),\n",
    "    nn.Dropout(0.4),\n",
    "    nn.Linear(256, num_classes), # Since 10 possible outputs\n",
    "    nn.LogSoftmax(dim=1) # For using NLLLoss()\n",
    ")\n",
    "\n",
    "# Convert model to be used on GPU\n",
    "model = model.to('cuda:0')\n",
    "\n",
    "# Freeze model parameters\n",
    "for param in model.parameters():\n",
    "    param.requires_grad = False\n",
    "\n",
    "best_model_path = \"./model_best_resnet50.pth\"\n",
    "# model = torch.load(best_model_path)\n",
    "state_dict = torch.load(best_model_path)['state_dict']\n",
    "model.load_state_dict({k[7:]: v for k, v in state_dict.items()})\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FGSM attack code, from https://pytorch.org/tutorials/beginner/fgsm_tutorial.html\n",
    "def fgsm_attack(image, epsilon, data_grad):\n",
    "    # Collect the element-wise sign of the data gradient\n",
    "    sign_data_grad = data_grad.sign()\n",
    "    # Create the perturbed image by adjusting each pixel of the input image\n",
    "    perturbed_image = image + epsilon*sign_data_grad\n",
    "    # Adding clipping to maintain [0,1] range\n",
    "    perturbed_image = torch.clamp(perturbed_image, 0, 1)\n",
    "    # Return the perturbed image\n",
    "    return perturbed_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AverageMeter(object):\n",
    "    \"\"\"Computes and stores the average and current value\"\"\"\n",
    "    def __init__(self, name, fmt=':f'):\n",
    "        self.name = name\n",
    "        self.fmt = fmt\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        self.val = 0\n",
    "        self.avg = 0\n",
    "        self.sum = 0\n",
    "        self.count = 0\n",
    "\n",
    "    def update(self, val, n=1):\n",
    "        self.val = val\n",
    "        self.sum += val * n\n",
    "        self.count += n\n",
    "        self.avg = self.sum / self.count\n",
    "\n",
    "    def __str__(self):\n",
    "        fmtstr = '{name} {val' + self.fmt + '} ({avg' + self.fmt + '})'\n",
    "        return fmtstr.format(**self.__dict__)\n",
    "\n",
    "\n",
    "class ProgressMeter(object):\n",
    "    def __init__(self, num_batches, meters, prefix=\"\"):\n",
    "        self.batch_fmtstr = self._get_batch_fmtstr(num_batches)\n",
    "        self.meters = meters\n",
    "        self.prefix = prefix\n",
    "\n",
    "    def display(self, batch):\n",
    "        entries = [self.prefix + self.batch_fmtstr.format(batch)]\n",
    "        entries += [str(meter) for meter in self.meters]\n",
    "        print('\\t'.join(entries))\n",
    "\n",
    "    def _get_batch_fmtstr(self, num_batches):\n",
    "        num_digits = len(str(num_batches // 1))\n",
    "        fmt = '{:' + str(num_digits) + 'd}'\n",
    "        return '[' + fmt + '/' + fmt.format(num_batches) + ']'\n",
    "\n",
    "top1 = AverageMeter('Acc@1', ':6.2f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accuracy(output, target, topk=(1,)):\n",
    "    \"\"\"Computes the accuracy over the k top predictions for the specified values of k\"\"\"\n",
    "    with torch.no_grad():\n",
    "        maxk = max(topk)\n",
    "        batch_size = target.size(0)\n",
    "\n",
    "        _, pred = output.topk(maxk, 1, True, True)\n",
    "        pred = pred.t()\n",
    "        correct = pred.eq(target.view(1, -1).expand_as(pred))\n",
    "\n",
    "        res = []\n",
    "        for k in topk:\n",
    "            correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n",
    "            res.append(correct_k.mul_(100.0 / batch_size))\n",
    "        return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(model, device, loss_func, test_loader, epsilon):\n",
    "\n",
    "    # Accuracy counter\n",
    "    correct = 0\n",
    "    adv_examples = []\n",
    "    \n",
    "    progress = ProgressMeter(\n",
    "        len(test_loader),\n",
    "        [top1])\n",
    "    print_freq = 500\n",
    "\n",
    "    # Loop over all examples in test set\n",
    "    for i, (data, target) in enumerate(test_loader):\n",
    "        # Send the data and label to the device\n",
    "        data, target = data.to(device), target.to(device)\n",
    "\n",
    "        # Set requires_grad attribute of tensor. Important for Attack\n",
    "        data.requires_grad = True\n",
    "\n",
    "        # Forward pass the data through the model\n",
    "        output = model(data)\n",
    "        init_pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n",
    "\n",
    "        # If the initial prediction is wrong, dont bother attacking, just move on\n",
    "#         if init_pred.item() != target.item():\n",
    "#             continue\n",
    "\n",
    "        # Calculate the loss\n",
    "        loss = loss_func(output, target)\n",
    "\n",
    "        # Zero all existing gradients\n",
    "        model.zero_grad()\n",
    "\n",
    "        # Calculate gradients of model in backward pass\n",
    "        loss.backward()\n",
    "\n",
    "        # Collect datagrad\n",
    "        data_grad = data.grad.data\n",
    "\n",
    "        # Call FGSM Attack\n",
    "        perturbed_data = fgsm_attack(data, epsilon, data_grad)\n",
    "\n",
    "        # Re-classify the perturbed image\n",
    "        output = model(perturbed_data)\n",
    "\n",
    "        # Check for success\n",
    "        acc1 = accuracy(output, target, topk=(1,))\n",
    "        top1.update(acc1[0].item(), data.size(0))\n",
    "        \n",
    "        if len(adv_examples) < 3:\n",
    "            final_pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n",
    "            adv_ex = perturbed_data.squeeze().detach().cpu().numpy()\n",
    "            adv_examples.append( (init_pred.detach().cpu().numpy(), final_pred.detach().cpu().numpy(), adv_ex) )\n",
    "        \n",
    "#         if i % print_freq == 0:\n",
    "#             print(i, top1.avg)\n",
    "#         final_pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n",
    "#         if final_pred.item() == target.item():\n",
    "#             correct += 1\n",
    "#             # Special case for saving 0 epsilon examples\n",
    "#             if (epsilon == 0) and (len(adv_examples) < 5):\n",
    "#                 adv_ex = perturbed_data.squeeze().detach().cpu().numpy()\n",
    "#                 adv_examples.append( (init_pred.item(), final_pred.item(), adv_ex) )\n",
    "#         else:\n",
    "#             # Save some adv examples for visualization later\n",
    "#             if len(adv_examples) < 5:\n",
    "#                 adv_ex = perturbed_data.squeeze().detach().cpu().numpy()\n",
    "#                 adv_examples.append( (init_pred.item(), final_pred.item(), adv_ex) )\n",
    "\n",
    "    # Calculate final accuracy for this epsilon\n",
    "#     final_acc = correct/float(len(test_loader))\n",
    "    final_acc = top1.avg\n",
    "    print(\"Epsilon: {}\\tTest Accuracy = {} / {} = {}\".format(epsilon, top1.sum, len(test_loader), final_acc))\n",
    "\n",
    "    # Return the accuracy and an adversarial example\n",
    "    return final_acc, adv_examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epsilon: 0\tTest Accuracy = tensor([33600.], device='cuda:0') / 313 = tensor([0.7153], device='cuda:0')\n",
      "Epsilon: 0.05\tTest Accuracy = tensor([37700.], device='cuda:0') / 313 = tensor([0.6617], device='cuda:0')\n",
      "Epsilon: 0.1\tTest Accuracy = tensor([43200.], device='cuda:0') / 313 = tensor([0.6451], device='cuda:0')\n",
      "Epsilon: 0.15\tTest Accuracy = tensor([48800.], device='cuda:0') / 313 = tensor([0.6340], device='cuda:0')\n",
      "Epsilon: 0.2\tTest Accuracy = tensor([54000.], device='cuda:0') / 313 = tensor([0.6209], device='cuda:0')\n",
      "Epsilon: 0.25\tTest Accuracy = tensor([59100.], device='cuda:0') / 313 = tensor([0.6095], device='cuda:0')\n",
      "Epsilon: 0.3\tTest Accuracy = tensor([64600.], device='cuda:0') / 313 = tensor([0.6039], device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "accuracies = []\n",
    "examples = []\n",
    "epsilons = [0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3]\n",
    "\n",
    "loss_func = nn.CrossEntropyLoss().cuda(device)\n",
    "optimizer = optim.Adam(model.parameters())\n",
    "\n",
    "# Run test for each epsilon\n",
    "for eps in epsilons:\n",
    "    acc, ex = test(model, device, loss_func, valid_data_loader, eps)\n",
    "    accuracies.append(acc)\n",
    "    examples.append(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epsilon: 0\tTest Accuracy = 6500.0 / 313 = 0.65006500650065\n",
      "Epsilon: 0.05\tTest Accuracy = 11300.0 / 313 = 0.5650565056505651\n",
      "Epsilon: 0.1\tTest Accuracy = 16100.0 / 313 = 0.5367203387005367\n",
      "Epsilon: 0.15\tTest Accuracy = 21300.0 / 313 = 0.5325532553255325\n",
      "Epsilon: 0.2\tTest Accuracy = 26400.0 / 313 = 0.528052805280528\n",
      "Epsilon: 0.25\tTest Accuracy = 31300.0 / 313 = 0.5217188385505217\n",
      "Epsilon: 0.3\tTest Accuracy = 36300.0 / 313 = 0.5186232909005186\n"
     ]
    }
   ],
   "source": [
    "accuracies = []\n",
    "examples = []\n",
    "epsilons = [0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3]\n",
    "\n",
    "loss_func = nn.CrossEntropyLoss().cuda(device)\n",
    "optimizer = optim.Adam(model.parameters())\n",
    "\n",
    "# Run test for each epsilon\n",
    "for eps in epsilons:\n",
    "    acc, ex = test(model, device, loss_func, valid_data_loader, eps)\n",
    "    accuracies.append(acc)\n",
    "    examples.append(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(5,5))\n",
    "plt.plot(epsilons, accuracies, \"*-\")\n",
    "plt.yticks(np.arange(0, 1.1, step=0.1))\n",
    "plt.xticks(np.arange(0, .35, step=0.05))\n",
    "plt.title(\"Accuracy vs Epsilon\")\n",
    "plt.xlabel(\"Epsilon\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 64, 64)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(examples[0][0][2][0,:,:,:]).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.01645374, 0.01547142, 0.0213653 , ..., 0.01669932,\n",
       "         0.01940067, 0.01178775],\n",
       "        [0.01743605, 0.0135068 , 0.0213653 , ..., 0.00736734,\n",
       "         0.01719047, 0.01989183],\n",
       "        [0.01596258, 0.01620816, 0.015717  , ..., 0.01252449,\n",
       "         0.01964625, 0.01227891],\n",
       "        ...,\n",
       "        [0.05230815, 0.05476393, 0.04665985, ..., 0.02431224,\n",
       "         0.03806461, 0.02332992],\n",
       "        [0.04739659, 0.04985237, 0.05206257, ..., 0.02554013,\n",
       "         0.02652244, 0.02578571],\n",
       "        [0.05893876, 0.04297618, 0.04911563, ..., 0.02062857,\n",
       "         0.03388979, 0.02775033]],\n",
       "\n",
       "       [[0.01620816, 0.01522585, 0.02111972, ..., 0.01277006,\n",
       "         0.01547142, 0.00761292],\n",
       "        [0.01645374, 0.01326122, 0.02111972, ..., 0.00343809,\n",
       "         0.01326122, 0.01645374],\n",
       "        [0.01498027, 0.01522585, 0.01547142, ..., 0.00859524,\n",
       "         0.01620816, 0.00884081],\n",
       "        ...,\n",
       "        [0.04739659, 0.04936121, 0.04101155, ..., 0.02332992,\n",
       "         0.03609999, 0.0213653 ],\n",
       "        [0.04125713, 0.04371291, 0.04592311, ..., 0.02455782,\n",
       "         0.02455782, 0.0235755 ],\n",
       "        [0.05255372, 0.03659115, 0.04199386, ..., 0.01964625,\n",
       "         0.03192516, 0.02554013]],\n",
       "\n",
       "       [[0.00884081, 0.0078585 , 0.01375238, ..., 0.00908639,\n",
       "         0.01227891, 0.00515714],\n",
       "        [0.00933197, 0.00589388, 0.01375238, ..., 0.        ,\n",
       "         0.0100687 , 0.01375238],\n",
       "        [0.0078585 , 0.00810408, 0.00810408, ..., 0.00491156,\n",
       "         0.01301564, 0.00613945],\n",
       "        ...,\n",
       "        [0.04076597, 0.04371291, 0.0370823 , ..., 0.00515714,\n",
       "         0.02013741, 0.00613945],\n",
       "        [0.03953809, 0.04248502, 0.04469522, ..., 0.00663061,\n",
       "         0.00908639, 0.00957755],\n",
       "        [0.05329046, 0.03732788, 0.04297618, ..., 0.0022102 ,\n",
       "         0.01669932, 0.01154217]]], dtype=float32)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "examples[0][0][2][0,:,:,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fba89d25910>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(np.transpose(examples[0][0][2][2,:,:,:] * 10, (1, 2, 0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: [   0/3125]\tTime  0.793 ( 0.793)\tLoss 8.2536e+00 (8.2536e+00)\tAcc@1   6.25 (  6.25)\tAcc@5   9.38 (  9.38)\n",
      "Test: [ 500/3125]\tTime  0.863 ( 0.719)\tLoss 8.7623e+00 (9.3959e+00)\tAcc@1   3.12 (  0.63)\tAcc@5   6.25 (  3.18)\n",
      "Test: [1000/3125]\tTime  0.643 ( 0.719)\tLoss 9.3307e+00 (9.4031e+00)\tAcc@1   0.00 (  0.72)\tAcc@5   9.38 (  3.15)\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-103-1ce45c204b15>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     44\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mtop1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mavg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     45\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 46\u001b[0;31m \u001b[0mvalidate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_data_loader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"cuda\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-103-1ce45c204b15>\u001b[0m in \u001b[0;36mvalidate\u001b[0;34m(val_loader, model, criterion, gpu)\u001b[0m\n\u001b[1;32m     16\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mno_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m         \u001b[0mend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m         \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mimages\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval_loader\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     19\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mgpu\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m                 \u001b[0mimages\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimages\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgpu\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_blocking\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m__next__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    343\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    344\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__next__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 345\u001b[0;31m         \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_next_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    346\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_num_yielded\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    347\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dataset_kind\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0m_DatasetKind\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mIterable\u001b[0m \u001b[0;32mand\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_next_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    383\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_next_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    384\u001b[0m         \u001b[0mindex\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_next_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# may raise StopIteration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 385\u001b[0;31m         \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dataset_fetcher\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfetch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# may raise StopIteration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    386\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_pin_memory\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    387\u001b[0m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpin_memory\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpin_memory\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/torch/utils/data/_utils/fetch.py\u001b[0m in \u001b[0;36mfetch\u001b[0;34m(self, possibly_batched_index)\u001b[0m\n\u001b[1;32m     42\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mfetch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     43\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mauto_collation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 44\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     45\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     46\u001b[0m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/torch/utils/data/_utils/fetch.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     42\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mfetch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     43\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mauto_collation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 44\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     45\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     46\u001b[0m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/torchvision/datasets/folder.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, index)\u001b[0m\n\u001b[1;32m    136\u001b[0m         \"\"\"\n\u001b[1;32m    137\u001b[0m         \u001b[0mpath\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 138\u001b[0;31m         \u001b[0msample\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloader\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    139\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    140\u001b[0m             \u001b[0msample\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msample\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/torchvision/datasets/folder.py\u001b[0m in \u001b[0;36mdefault_loader\u001b[0;34m(path)\u001b[0m\n\u001b[1;32m    172\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0maccimage_loader\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    173\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 174\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mpil_loader\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    175\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    176\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/torchvision/datasets/folder.py\u001b[0m in \u001b[0;36mpil_loader\u001b[0;34m(path)\u001b[0m\n\u001b[1;32m    154\u001b[0m     \u001b[0;31m# open path as file to avoid ResourceWarning (https://github.com/python-pillow/Pillow/issues/835)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    155\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'rb'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 156\u001b[0;31m         \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mImage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    157\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconvert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'RGB'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    158\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/PIL/Image.py\u001b[0m in \u001b[0;36mopen\u001b[0;34m(fp, mode)\u001b[0m\n\u001b[1;32m   2773\u001b[0m         \u001b[0mexclusive_fp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2774\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2775\u001b[0;31m     \u001b[0mprefix\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m16\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2776\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2777\u001b[0m     \u001b[0mpreinit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def validate(val_loader, model, criterion, gpu):\n",
    "    batch_time = AverageMeter('Time', ':6.3f')\n",
    "    losses = AverageMeter('Loss', ':.4e')\n",
    "    top1 = AverageMeter('Acc@1', ':6.2f')\n",
    "    top5 = AverageMeter('Acc@5', ':6.2f')\n",
    "    progress = ProgressMeter(\n",
    "        len(val_loader),\n",
    "        [batch_time, losses, top1, top5],\n",
    "        prefix='Test: ')\n",
    "\n",
    "    # switch to evaluate mode\n",
    "    model.eval()\n",
    "\n",
    "    with torch.no_grad():\n",
    "        end = time.time()\n",
    "        for i, (images, target) in enumerate(val_loader):\n",
    "            if gpu is not None:\n",
    "                images = images.cuda(gpu, non_blocking=True)\n",
    "            target = target.cuda(gpu, non_blocking=True)\n",
    "\n",
    "            # compute output\n",
    "            output = model(images)\n",
    "            loss = criterion(output, target)\n",
    "\n",
    "            # measure accuracy and record loss\n",
    "            acc1, acc5 = accuracy(output, target, topk=(1, 5))\n",
    "            losses.update(loss.item(), images.size(0))\n",
    "            top1.update(acc1[0], images.size(0))\n",
    "            top5.update(acc5[0], images.size(0))\n",
    "\n",
    "            # measure elapsed time\n",
    "            batch_time.update(time.time() - end)\n",
    "            end = time.time()\n",
    "\n",
    "            if i % 500 == 0:\n",
    "                progress.display(i)\n",
    "\n",
    "\n",
    "        print(' * Acc@1 {top1.avg:.3f} Acc@5 {top5.avg:.3f}'\n",
    "              .format(top1=top1, top5=top5))\n",
    "\n",
    "    return top1.avg\n",
    "\n",
    "validate(train_data_loader, model, loss_func, \"cuda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def testv2(model, device, loss_func, test_loader, epsilon):\n",
    "\n",
    "    # Accuracy counter\n",
    "    correct = 0\n",
    "    adv_examples = []\n",
    "    \n",
    "    progress = ProgressMeter(\n",
    "        len(test_loader),\n",
    "        [top1])\n",
    "    print_freq = 500\n",
    "\n",
    "    # Loop over all examples in test set\n",
    "    for i, (data, target) in enumerate(test_loader):\n",
    "        # Send the data and label to the device\n",
    "        data, target = data.to(device), target.to(device)\n",
    "\n",
    "        # Set requires_grad attribute of tensor. Important for Attack\n",
    "        data.requires_grad = True\n",
    "\n",
    "        # Forward pass the data through the model\n",
    "        output = model(data)\n",
    "        init_pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n",
    "\n",
    "        # Calculate the loss\n",
    "        loss = loss_func(output, target)\n",
    "\n",
    "        # Zero all existing gradients\n",
    "        model.zero_grad()\n",
    "\n",
    "        # Calculate gradients of model in backward pass\n",
    "        loss.backward()\n",
    "\n",
    "        # Collect datagrad\n",
    "        data_grad = data.grad.data\n",
    "\n",
    "        # Call FGSM Attack\n",
    "        perturbed_data = fgsm_attack(data, epsilon, data_grad)\n",
    "\n",
    "        # Re-classify the perturbed image\n",
    "        output = model(perturbed_data)\n",
    "\n",
    "        # Check for success\n",
    "        acc1 = accuracy(output, target, topk=(1,))\n",
    "        top1.update(acc1[0].item(), data.size(0))\n",
    "        \n",
    "        if len(adv_examples) < 3:\n",
    "            final_pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n",
    "            orig = data.squeeze().detach().cpu().numpy()\n",
    "            adv_ex = perturbed_data.squeeze().detach().cpu().numpy()\n",
    "            adv_examples.append( (init_pred.detach().cpu().numpy(), final_pred.detach().cpu().numpy(), orig, adv_ex) )\n",
    "        else:\n",
    "            return top1.avg, adv_examples\n",
    "\n",
    "    # Calculate final accuracy for this epsilon\n",
    "#     final_acc = correct/float(len(test_loader))\n",
    "    final_acc = top1.avg\n",
    "    print(\"Epsilon: {}\\tTest Accuracy = {} / {} = {}\".format(epsilon, top1.sum, len(test_loader), final_acc))\n",
    "\n",
    "    # Return the accuracy and an adversarial example\n",
    "    return final_acc, adv_examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracies = []\n",
    "examples = []\n",
    "epsilons = [0, 0.05]\n",
    "\n",
    "loss_func = nn.CrossEntropyLoss().cuda(device)\n",
    "optimizer = optim.Adam(model.parameters())\n",
    "\n",
    "# Run test for each epsilon\n",
    "for eps in epsilons:\n",
    "    acc, ex = testv2(model, device, loss_func, valid_data_loader, eps)\n",
    "    accuracies.append(acc)\n",
    "    examples.append(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "tuple index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-7b965c11dc09>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0max1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0max2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubplots\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msharey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0max1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0max2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: tuple index out of range"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, (ax1, ax2) = plt.subplots(1, 2, sharey=True, figsize=(10,10))\n",
    "ax1.imshow(np.transpose(examples[1][0][2][2,:,:,:] * 10, (1, 2, 0)))\n",
    "ax2.imshow(np.transpose(examples[1][0][3][2,:,:,:] * 10, (1, 2, 0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_result(x_scale, tr, val, title, y_label, ax=plt):\n",
    "    ax.set_title(title)\n",
    "    if title == 'loss':\n",
    "        ax.plot(x_scale, tr, label='training loss')\n",
    "        ax.plot(x_scale, val, label='validation loss')\n",
    "    else:\n",
    "        ax.plot(x_scale, tr, label='training accuracy')\n",
    "        ax.plot(x_scale, val, label='validation accuracy')\n",
    "    ax.set_xlabel(\"Epochs\")\n",
    "    ax.set_ylabel(y_label)\n",
    "    ax.legend()\n",
    "\n",
    "def train_model(model, criterion, optimizer, scheduler, dataloaders, num_epochs=10, verbose=True, save=True):\n",
    "    since = time.time()\n",
    "\n",
    "    best_model_wts = copy.deepcopy(model.state_dict())\n",
    "    best_acc = 0.0\n",
    "    tr_acc, val_acc = [], []\n",
    "    tr_loss, val_loss  = [], []\n",
    "    \n",
    "    for epoch in range(num_epochs):\n",
    "        if verbose:\n",
    "            print('Epoch {}/{}'.format(epoch, num_epochs - 1), end=\": \")\n",
    "        \n",
    "        # Each epoch has a training and validation phase\n",
    "        for phase in ['train', 'val']:\n",
    "            if phase == 'train':\n",
    "                model.train()  # Set model to training mode\n",
    "            else:\n",
    "                model.eval()   # Set model to evaluate mode\n",
    "\n",
    "            running_loss = 0.0\n",
    "            running_corrects = 0\n",
    "\n",
    "            # Iterate over data.\n",
    "            for inputs, labels in dataloaders[phase]:\n",
    "                inputs = inputs.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                # zero the parameter gradients\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "                # forward\n",
    "                # track history if only in train\n",
    "#                 with torch.set_grad_enabled(phase == 'train'):\n",
    "                if phase == 'train':\n",
    "                    outputs = model(inputs)\n",
    "                    _, preds = torch.max(outputs, 1)\n",
    "                    loss = criterion(outputs, labels)\n",
    "                    # backward + optimize only if in training phase\n",
    "                    loss.backward()\n",
    "                    optimizer.step()\n",
    "                else:\n",
    "                    with torch.no_grad():\n",
    "                        outputs = model(inputs)\n",
    "                        _, preds = torch.max(outputs, 1)\n",
    "                        loss = criterion(outputs, labels)\n",
    "                # statistics\n",
    "                running_loss += loss.item() * inputs.size(0)\n",
    "                running_corrects += torch.sum(preds == labels.data)\n",
    "                \n",
    "            if phase == 'train':\n",
    "                scheduler.step()\n",
    "\n",
    "            epoch_loss = running_loss / dataset_sizes[phase]\n",
    "            epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
    "            if phase == 'train':\n",
    "                tr_acc.append(epoch_acc)\n",
    "                tr_loss.append(epoch_loss)\n",
    "            elif phase == 'val':\n",
    "                val_acc.append(epoch_acc)\n",
    "                val_loss.append(epoch_loss)\n",
    "\n",
    "            # deep copy the model\n",
    "            if phase == 'val' and epoch_acc > best_acc:\n",
    "                best_acc = epoch_acc\n",
    "                best_model_wts = copy.deepcopy(model.state_dict())\n",
    "        \n",
    "        if verbose:        \n",
    "            print('Training Loss: {:.4f}, Acc: {:.4f}; Validation Loss: {:.4f}, Acc: {:.4f}'.format(\n",
    "                tr_loss[-1], tr_acc[-1], val_loss[-1], val_acc[-1]))\n",
    "        if save:\n",
    "            torch.save(model.state_dict(), './models/resnet152_best_model_epoch_' + str(epoch) + '.pth')\n",
    "            np.save('full_training.npy', np.array([tr_acc, val_acc, tr_loss, val_loss]))\n",
    "\n",
    "    time_elapsed = time.time() - since\n",
    "#     print('Training complete in {:.0f}m {:.0f}s'.format(\n",
    "#         time_elapsed // 60, time_elapsed % 60))\n",
    "    print('Best val Acc: {:4f}'.format(best_acc))\n",
    "\n",
    "    # load best model weights\n",
    "    model.load_state_dict(best_model_wts)\n",
    "    return model, tr_acc, val_acc, tr_loss, val_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import resnet_modified\n",
    "model = resnet_modified.resnet152(pretrained=False, decay_factor=0.04278)\n",
    "num_ftrs = model.fc.in_features\n",
    "model.fc = nn.Linear(num_ftrs, num_classes)\n",
    "model = model.to(device)\n",
    "\n",
    "# Freeze model parameters\n",
    "# for param in model.parameters():\n",
    "#     param.requires_grad = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_model_path = \"./models/resnet152_best_model_state_dict.pth\"\n",
    "model.load_state_dict(torch.load(best_model_path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validate_fgsm(model, criterion, optimizer, scheduler, dataloaders, epsilon, num_epochs=1, verbose=True, save=True):\n",
    "    since = time.time()\n",
    "\n",
    "    tr_acc, val_acc = [], []\n",
    "    tr_loss, val_loss  = [], []\n",
    "    \n",
    "    adv_examples = []\n",
    "    \n",
    "    dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val', 'test']}\n",
    "    \n",
    "    for epoch in range(num_epochs):\n",
    "        if verbose:\n",
    "            print('Epoch {}/{}'.format(epoch, num_epochs - 1), end=\": \")\n",
    "        \n",
    "        # Each epoch has a training and validation phase\n",
    "        phase = 'val'\n",
    "        if phase == 'train':\n",
    "            model.train()  # Set model to training mode\n",
    "        else:\n",
    "            model.eval()   # Set model to evaluate mode\n",
    "\n",
    "        running_loss = 0.0\n",
    "        running_corrects = 0\n",
    "\n",
    "        # Iterate over data.\n",
    "        for inputs, labels in dataloaders[phase]:\n",
    "            inputs = inputs.to(device)\n",
    "            labels = labels.to(device)\n",
    "            inputs.requires_grad = True\n",
    "\n",
    "            # zero the parameter gradients\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            # forward\n",
    "            # track history if only in train\n",
    "#                 with torch.set_grad_enabled(phase == 'train'):\n",
    "            if phase == 'train':\n",
    "                outputs = model(inputs)\n",
    "                _, preds = torch.max(outputs, 1)\n",
    "                loss = criterion(outputs, labels)\n",
    "                # backward + optimize only if in training phase\n",
    "                loss.backward()\n",
    "                optimizer.step()\n",
    "            else:\n",
    "                outputs = model(inputs)\n",
    "                _, preds = torch.max(outputs, 1)\n",
    "                loss = criterion(outputs, labels)\n",
    "\n",
    "                init_pred = outputs.max(1, keepdim=True)[1] # get the index of the max log-probability\n",
    "\n",
    "                # Zero all existing gradients\n",
    "                model.zero_grad()\n",
    "\n",
    "                # Calculate gradients of model in backward pass\n",
    "                loss.backward()\n",
    "\n",
    "                # Collect datagrad\n",
    "                data_grad = inputs.grad.data\n",
    "\n",
    "                # Call FGSM Attack\n",
    "                perturbed_data = fgsm_attack(inputs, epsilon, data_grad)\n",
    "\n",
    "                # Re-classify the perturbed image\n",
    "                outputs = model(perturbed_data)\n",
    "                _, preds = torch.max(outputs, 1)\n",
    "                loss = criterion(outputs, labels)\n",
    "\n",
    "                if len(adv_examples) < 3:\n",
    "                    final_pred = outputs.max(1, keepdim=True)[1] # get the index of the max log-probability\n",
    "                    adv_ex = perturbed_data.squeeze().detach().cpu().numpy()\n",
    "                    adv_examples.append( (init_pred.detach().cpu().numpy(), final_pred.detach().cpu().numpy(), adv_ex) )\n",
    "            # statistics\n",
    "            running_loss += loss.item() * inputs.size(0)\n",
    "            running_corrects += torch.sum(preds == labels.data)\n",
    "            \n",
    "        if phase == 'train':\n",
    "            scheduler.step()\n",
    "\n",
    "        epoch_loss = running_loss / dataset_sizes[phase]\n",
    "        epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
    "        if phase == 'train':\n",
    "            tr_acc.append(epoch_acc)\n",
    "            tr_loss.append(epoch_loss)\n",
    "        elif phase == 'val':\n",
    "            val_acc.append(epoch_acc)\n",
    "            val_loss.append(epoch_loss)\n",
    "        \n",
    "        if verbose:        \n",
    "            print('Validation Loss: {:.4f}, Acc: {:.4f}'.format(\n",
    "                val_loss[-1], val_acc[-1]))\n",
    "\n",
    "    time_elapsed = time.time() - since\n",
    "    print('Training complete in {:.0f}m {:.0f}s'.format(\n",
    "        time_elapsed // 60, time_elapsed % 60))\n",
    "\n",
    "    return val_acc[0], val_loss[0], adv_examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_transforms = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0, 0, 0), tuple(np.sqrt((255, 255, 255)))),\n",
    "])\n",
    "\n",
    "# Load Data from folders\n",
    "image_datasets = {\n",
    "    'train': datasets.ImageFolder(os.path.join(data_dir, 'train'), transform=data_transforms),\n",
    "    'val': datasets.ImageFolder(os.path.join(data_dir, 'val'), transform=data_transforms),\n",
    "    'test': datasets.ImageFolder(os.path.join(data_dir, 'test'), transform=data_transforms)\n",
    "}\n",
    "\n",
    "phases = ['train', 'val', 'test']\n",
    "\n",
    "dataloaders = {'train': DataLoader(image_datasets['train'], batch_size=batch_size, shuffle=True),\n",
    "              'val': DataLoader(image_datasets['val'], batch_size=batch_size, shuffle=True),\n",
    "              'test': DataLoader(image_datasets['test'], batch_size=batch_size, shuffle=False)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training complete in 3m 2s\n",
      "Epsilon: 0, Accuracy: 0.6374637463746374, Loss: 1.510921383490621\n",
      "Training complete in 3m 1s\n",
      "Epsilon: 0.005, Accuracy: 0.05310531053105311, Loss: 6.958281991815362\n",
      "Training complete in 3m 1s\n",
      "Epsilon: 0.01, Accuracy: 0.024102410241024105, Loss: 7.787095042273621\n",
      "Training complete in 3m 1s\n",
      "Epsilon: 0.015, Accuracy: 0.0098009800980098, Loss: 8.507041253594354\n",
      "Training complete in 3m 2s\n",
      "Epsilon: 0.02, Accuracy: 0.0079007900790079, Loss: 8.48033754123856\n",
      "Training complete in 3m 1s\n",
      "Epsilon: 0.025, Accuracy: 0.007600760076007601, Loss: 7.9797646121175685\n"
     ]
    }
   ],
   "source": [
    "accuracies = []\n",
    "losses = []\n",
    "examples = []\n",
    "epsilons = [0, 5e-3, 1e-2, 1.5e-2, 2e-2, 2.5e-2]\n",
    "\n",
    "lr = 2.61e-5\n",
    "loss_func = nn.CrossEntropyLoss().cuda(device)\n",
    "optimizer_ft = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=lr)\n",
    "# optimizer_ft = optim.Adam(model.parameters(), lr=lr)\n",
    "\n",
    "# Run test for each epsilon\n",
    "for eps in epsilons:\n",
    "    acc, loss, ex = validate_fgsm(model, loss_func, optimizer_ft, None, dataloaders, eps, verbose=False)\n",
    "    accuracies.append(acc)\n",
    "    losses.append(loss)\n",
    "    examples.append(ex)\n",
    "    print('Epsilon: {}, Accuracy: {}, Loss: {}'.format(eps, acc, loss))\n",
    "    np.save('fgsm_data.npy', np.array([eps, accuracies, losses, examples]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f02337d1410>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(np.transpose(examples[4][0][2][2,:,:,:] * 10, (1, 2, 0)))"
   ]
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}