fgsm_dataset_augmentation.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 229998 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": 65,
   "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": 65,
     "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",
    "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": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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",
    "# best_model_path = \"./models/resnet152_best_model_epoch_34.pth\"\n",
    "best_model_path = \"./models/resnet152_best_model_state_dict_v2_50.pth\"\n",
    "model.load_state_dict(torch.load(best_model_path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "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\n",
    "\n",
    "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 = float(running_corrects) / 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": 68,
   "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": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training complete in 1m 14s\n",
      "Epsilon: 5e-05, Accuracy: 0.0032003200320032004, Loss: 8.874424336278233\n"
     ]
    }
   ],
   "source": [
    "# accuracies = []\n",
    "# losses = []\n",
    "# examples = []\n",
    "epsilons = [5e-5]\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_v2.npy', np.array([eps, accuracies, losses, examples]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f254d277dd0>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD7CAYAAACscuKmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO29aZBk13Ee+mXtVb33TE9Pz4bBMgSJdUCBAEGIJAhwgRW2+GRR75l2PDMciIc/eg7JS1ikHeGwvIRJR9iSw35PDoQpinbIoiguAkVxAQgR3ECRAAgQK4EBZgazT+9r7VXHP6q6cum+d2pmeqpBVn4RHX3uPeeee+5y6maezPySQghwOBy/+Ehs9wAcDkdv4JPd4egT+GR3OPoEPtkdjj6BT3aHo0/gk93h6BNc1mQnovuJ6BUieo2IPr5Vg3I4HFsPulQ7OxElAbwK4AMATgF4EsBHQwgvbd3wHA7HViF1GcfeAeC1EMJRACCizwH4MIDIyU5EgegyzngxiPsNixtDt8eFiP0XguqfIqso6lxmh72fCbGdSvLGQCGn2qVSLNRVK2VVR6LTRCLdKTebDdUunclyH9WaqiuVK51yvRF9U5vNyCqEqBt7Ue9Q2LR4UX3+HPmdBQAhhE2v5nIm+14AJ8X2KQB3xh1ABGRSF3/KS/l9iJVYtmSyc8NEIvqNbYZEzHbSnJpPICccBd0/gSdW1pw7x3MTE2OZTvkdt12v2k2MDXTKx47+zPTB4yoMT3bKK2trqt3efQc75RMnz6m6l1491inPzpc65Sbp+1Eq8/ib5nVsivuhrnLDD5zsU9+PpnwP1H00GuzPwWQPsV+YVl2t3kAULmeyb3Z7NtwWInoQwIOXcR6Hw7EFuJzJfgrAfrG9D8AZ2yiE8BCAhwAgkaAYmSr6pzXqh/XKaATibFZG7vIXPoivhj0k7rdZfs3jhpFOyMdWVXWFAovW2SyXJycnVbtEYDF79+7dqu7Y60c65VUh4dcb+qu5tLTYKWeyaVU3MFDolFeKfK5yVV9Mrc7lZEbfLSWcqbLuoxGj1pC4y73TIa8M1LXE1EXhclbjnwRwiIiuJqIMgL8D4CuX0Z/D4biCuOQvewihTkT/L4BvoqV8/mEI4cUtG5nD4dhSXI4YjxDC1wB8bYvG4nA4riAua7JfHi5ff4rV+jdfrOwCFz+ujXq53KM1JaWX23OJ1WKKsb3J/q0elsuxnj48NNgpp5P6UYsFdzz+pBbI3nJoqlOeWRAr6UZXnpub65QHh3eouqzQ4Qu5fKecSusR1wP3X62Z6xSnazTkfnPH1VKHvVeyLEyKMNjqFfdLfv+6RfdrXutwd1mHo0/gk93h6BNsoxi/9dCCzQYbTFSN7iOuUvUhzSD6oGbX7nXGWUY4h5AQVRPGQSgp6pKme/nrXciz+LxqHGKGCizHV7T1DulURtQtdMqNpj7ZWontcqlMQdU1hdzdDGxfC8bJiMQ9SCR0nbzspqiK9KzbBEqMD90+lxhcqvbZ7XFdivsUZUaMOY9/2R2OPoFPdoejT+CT3eHoE2yDzr6ulFy+6e1Se4h1WY1oZ/eEODfMLlVD6+Ko9HSxP2FGIiPWtOssINcB4iLb5susqP/6r71f1X39a9/ijYxcqNCBOzKoJ20WD/Iiyi63xueurekFgiDMjcmk0dkbm7vBxlq1NlikIp7opZrCLjVy7lJwKdGUMePzL7vD0Sfwye5w9Am2QYxfl00u3gPIwnpLUZf2tRgfttgRRZl8GlYcjzkmmq5Cb0qRfkMkV5NNWemMfoQpYb7KpNiLbWVlVbVLEveRye1VdUui6ciYiCk3TBOpjDTRafE8nWSRP5vhcZRrOt56ILC4X6zUVV1SfItkZFtoRj+1OO867ZIX2cXFocvXlmIUxBg+k+5Ptn7dbnpzOBw+2R2OPsE2rsZrUMwyYvcLp0L0vQQyjEtut0Eajwm4kHRT5gwJNX5ZtrRUwoPOnCCdYvFZURQJsgoAKIhAlfPTs6pukONnUK3xuWtaysZYgV+fNeOhF0iQWQjR2vLYJcUqfkov9iupOym96WBpwORNMIpSpEvkRSzHbznnRZzaF23KuVzmLP+yOxx9Ap/sDkefwCe7w9En6LnOvq5LW7PZxR6Pdi+I2LoYk1pUH93CqoWJOBZrSWe8wbYnyCtkNJhplxMmL+tdJ5uuLC93ylO7NblEo8l01Dfefoeqe+SbP+yUM8w4jVRaD2RiF5NcJBJa4U5mOeKuIb4pqyVtomtUWIdPGLOZvG5pfrTtFF00WT036q24iCe9BcFy3YM2KW3Epbyn/mV3OPoEPtkdjj5B78X4tmxyMaax6JbRpommyaKisoZI85cR+xIx3OKK/ECUyViCUtJjrFRUdUMFJnlYW9V1kp4tl+ON1AbTG9vAckJcBoCUsF8NDLIMvrqqTWNpESTz9Yf/UtWJjE+KsMLeq+VldrXbZbjnq8JTLim86YakXQ9Atc7c87m8TlFVF3zzaaFChLpWGcpFVklSxqMwl+E+y1XuL2FtlhLGlhqXXEixDcbI3erVucRomktVfdfhX3aHo0/gk93h6BP4ZHc4+gQ/d4ST3ZsjrrSNRESDBRNCJVxCrWoYRMSaUS8xmOMdJPq0ywgp0Wmtqt1gmw1WuOWyRSavdXuZiw1mfWNsB5vpqiK/m4xeA4D80Ah3Yb4b1RqPq1ZjndrqymMjY53y7PyiqkOQ/rl8b9Ipq5cLckvdAxoN7qNZl8/F3PxLVIeVMS/GRNetnh7/1ka7WrOLdnQPF/yyE9EfEtE0Eb0g9o0T0aNEdKT9fyyuD4fDsf3oRoz/IwD3m30fB/BYCOEQgMfa2w6H400MCnF2hfVGRAcBfDWEcFN7+xUA94QQzhLRFIDHQwjXX6ifRIJCLn3xmsOlODA1g/XG2vzIjfzb0tRkxhFxq0wwGFIpPrBR1yJ+Soim9sz5rOCMK7FAms/odjvH2KQ2MjKk6vbuYRPY6iqbxo4efV21K5f5YgoF/ZtfEObBurjoYqmk2sn7sWfPlKo7ePAgb4gbeebsedVuepYj7mqG2GJJmCZlVcKI4OWqjMzTgnxTfM/qQqRPUZwYH216i+Ml1LkEjFLZZbroy1U+y7U6ms3N2T0udYFuMoRwFgDa/3dd6uAcDkdvcMUX6IjoQQAPAj1wK3Y4HJHosRifCDm7BL2O2GFEVG749RBiVMx1KQ66GDF+w3EUsWEpkMVqfMquxteFt5cJ6FBthW4wuVOnVtq3jznjTp0+pccoVtaVF1tae50NDQ13ymtF7clXF2NcEdTPg4N6HFJsrde0VcAQ6nWKwyPDqtXevXwtM7MLqm5xeaVTXi0yHbWR1FET2V8rhmEjgK9bptcyHBpa7N7w6gjyjZg6DeOZGeteF111sSjXalsuxn8FwMfa5Y8BePgS+3E4HD1CN6a3PwHwQwDXE9EpInoAwCcBfICIjgD4QHvb4XC8iXFBnT2E8NGIqvu2eCwOh+MKoscedEHYMWKT+ESjSxNGt7CqPVGMoS/i1Enjt9UQ5rWUMRPJqKykCZdLCK+5HTtZtz2wT/O6NxusUw+aSLEg9NKGML2VilqnrtTYW61q9Nx8gU17koe9UtM3qyHGYU2buXy2U67XWO8/f35etZtf4HHs27dPjyPLfdSqIu1z1ZjXkiLlVUMLq02hZEvvvZp97oqXPpoUxZKFqHWiTfdeBrZ4Rdt94x2OPoFPdoejT9BjMZ5ixPDoYIDujBsXqg2blDbjq+/SRBLBjwbo1Ef211RmKk2YABppwds1sbNTzhqvwyNvHO2UKxUtnou4FW2iMhxx0rMMxpusWucLTUsuOWOvkiavRlOrAjVhvpPXnMnoO5IRfHp1o06k0xx4k81yu2aoqXaJpri2YAJyqtxWmiWJLEk9F8k8NC3V2wReIaJGI46sRfLqR6UYu1D/3RBb+Jfd4egT+GR3OPoEPtkdjj7Bzx15RRxiEuF2eQw0kWSXZj5rjpF6aKhrnnTFDW9II/I5Pm58jCkCZs6fiRxj3pBSrAkTmzIjGp29LhT6pjEPKjOXPrHayub43DJnG6DdgpuCo75e13r52hq7we7apceREWSR8tS16opqJ0dlgyobDcnFL8yS5tkq7n+TCEA+3w0pobfE1VWsV10yiQaZnjbCv+wOR5/AJ7vD0Sd404jxl+IsFCvxbGCekOe6fNlL9t4womlSmImqxlwlRcKUkTlHhpmIYucOFuOPHz2i2qVEeFw2pz3oVoVYLCP/LIlGRZjXsrmsqqvLKC+hadRqWiUJwuRlufYaIgoun2cT2uCgjnorCHF/YGBA1UlOfElKQUtajJf2xoR5k1JCfZEpqmrWhU4gzoxFNtdXZEbo7rnnewX/sjscfQKf7A5Hn+BNI8bHc1dEkVfEkcTFiFuqmU0hFZ3uSJNXcDFrSOKqYgU+kdC/p2kZjFHRYnFOBH5UKpyuaee4Jo2o1riPU6c14cPQMA9MxJhsoLvOy5X0lB5/rSrGLIJ6JDcdADQbLKqnktqyIDlKhgZEFte1ZdVu1wT3uX/fiKqTQTIh8HHZnD5XAF9bMIEwSfGwJSlHKmkywTaE6gLbf4y7pBDrI7KDATDqRayrXdxMiCHY6GIZ37/sDkefwCe7w9En8MnucPQJ3jQ6eyy6Jay4lHbWIUroPht721xprxjdOyn0dKuzk0ipnEnqdEoJES0nI8VGRkf1GIUePWdSJjWESU1Gb5lgM1SqPOZa3ZirpA7f5AOTdg1DkChKfRgAJgT5xvAgmwd37jBeeFmR3rqieekbDdbFZcrthPEGTIq3OGlMYw2xmaAYTzipp1sCDLVl3wpuq14rm4eqa9tyl+mcN4z/wifwL7vD0Sfwye5w9Al6L8ZHUdB1c4zd2Ao+ujiuihjzhpSi6g0ts6WlXGnJDkRTMiwJRcGNPr+w1CmnEtGi3dSUTsZTFkEs44IzfWFJi8jlCkXWpQXHvOJmgzbfkbhBVmwdHhrslIeEGD86or3kyiU2MRbXDH+9yP4qzaDZtFZ/GkLVaJhnIUX3pFA7Nt7RGBlcsldYZgvrURexu7mRcF70GWEyjnO7uzAHzAb4l93h6BP4ZHc4+gQ+2R2OPkFPdXZCtJodH8G2+UY8Ad9WwEQuNTc3fVjzmtTrGk2t/1UFMWPC2MOKJdbZZ2c4lfHwkI5KowT3mc5o/XVYmOmefPrVTjmb1Y/63Fkex9iOQVUnzXeNJpvomsYkFRpcN1DQ45Ckm8pkZ/TQpkij3DT6towmlLz0SRNil5TPwpik1LMRVQ2jl0szoo1si/sihghV377nOtdbl2Yz24nKMxCRgnzznlpjiKlrn4/2E9G3iehlInqRiH6rvX+ciB4loiPt/2MX6svhcGwfuhHj6wD+SQjhbQDeCeA3iegGAB8H8FgI4RCAx9rbDofjTYpucr2dBXC2XV4hopcB7AXwYQD3tJt9FsDjAH7niozyEnBFRPyIqLdgOMgl0YLlp5OmLBttlhAmu7LgOy80dLviMpvlxsZ1pNjqKhM7jAxzf0vLmmBjTBxGhvNdS8IioswQcaRTfBMmdu5QdQllLuTjVleWVDtNJGKfjIzyEvd0Q0SZKBvRNyk970Rd3fjF6YCyaG54C3mvtJkyOmKye274i3lTt9iDrp2n/TYAPwIw2f4hWP9B2BV9pMPh2G50vUBHRIMAvgjgt0MIy90yrxLRgwAeBLY8T53D4bgIdPVlJ6I0WhP9j0MIX2rvPk9EU+36KQDTmx0bQngohHB7COH2bn8gHA7H1uOCX3ZqzdBPA3g5hPCfRNVXAHwMwCfb/x/u6owRE75rvuxuA9vMdiSHTaxLotW7NjefkOVkF9FaKWOWkyafDS6Uom1VuIqWytqdtSnMeVWT660qotkOHjjQKS+tllW70GBT2eyc1qMXFlnv17q3Hu/YKCv+O8zaQbXC6aJTwlRWKq6pdoWCyCVXt26qm586BLsOwkjC6uyiO5nermmerbjOxIbnItxsY6LZQoyrq8wtt+EVJttpFOS7FLO+EYFuxPi7AfzfAJ4nomfb+/45WpP880T0AIATAH6ji74cDsc2oZvV+O8j+nt639YOx+FwXClsH3nFVri4xUngCSOmRR1m0wDFpH+K2rLRa0GQO6YNQUUQJI21miZ8aNRlW+6jVNIi+MgIe7zNz82qurEd453ysWOc2vm6Q29T7d5441ynfNWBfapudeXlTlmKt1U9XIzvYG+90DSVEWmupMdcqw6iTpv2JAlkkN51RkROKu86I8YrFkix374fUqw3fZAko0xE65HSw3KjuU7Z6GIQZ4qMatdd1+4b73D0CXyyOxx9gp8PDjqJrlft4zjlo/vr2jwo2jVNsIsM6EiYoI1m4FXZhln1lapHUnjTWZVkYX6+Ux4eGVJ1xSITQOzaxX5O587oTLBTu6fEmCwRn/QEE2PXUjYGCkxKsbqk+eulGlKv8zWHhj5XXaaUMnVyOzSjV6xlsMsGMV6K4LR5YA2gr9N66Mn4nw08IpI3XhhlQtOqdlugt8YEFHXkdyevcDgcPtkdjj6BT3aHo0/Qc52ddeIrkMM2RqeJOlusih5repOn0r2nMxylVqtpU5PM9ZYy+mVF2LaSWW5XN8qy9LyzZr+aTB9NbLJLZzQBRkHo26/87KiqkzpwU3i13XTTQTMOrmsYs1lGpJWWdamU8TaUqaTNQ1JrIaIuYb5RQdyDYKPZIggnN3jJiWdNlutfmA5jVHbtXWfWWS5FZY9fPzL3oIv55F92h6NP4JPd4egTbB9vfPehKuhe5I/uYyvi7aLCL8jUaDIF3UfsqISsJ81hTWOSSqb5sdWMR5pUKeo1IT4ntZi9usYBKTbtUlVwz4+Mc6DK6sqKalcps0ieTWuCjWyG6+o19hq0XnJDA5yy2Qb8KF+ymFdAiu72fkuJvBnHERfn4SY6sSZA5aAX8+lU545uFi+6S3dDS0xPF+7bv+wOR5/AJ7vD0Sfwye5w9Al6r7NHUWTHazKb7o1l3+5S7b8o9hxpnonpQ+qNG/T5EK3rB6H0SV3QWomqJUFYEYzJS6RATgtCy0Jec8MPCF352uuuU3UyZfORE693ysmUfl2yWTbfJY3JS64lJEimolbNsCbyu1m34KAsb4LLfgODhCCGMKbIhCCGkLygCUvtKH1dN5BJiPWTDess4jClR5vvaCKCiaN1pDgqOpchUdSG8JaNeZ/9y+5w9Al8sjscfYLee9BtYQdxov8GKZ6i6/SBXfYp2iWMWClFxA2mt5iTa1NT2LQMAEPDLJJLsxYAJAQfnjzKeuHNznHk3ML8sqqTXm0VkeJJiu0AMDTAKoNxjEO1LL3OhChtxOy6FPc3eIVF+izqLZWKS7eUoru0XNk0UVJV2vAFlKm6zQNVlriYDE9xap+9JzxGO45Nm6k+XYx3OBw+2R2OfsE2kFdciiAf51134SMALd5csioRISIlbeZQkh5dWr5V3nUxJgPlmWXEeEnHVjHEcHmxyj42ximZhod13s1KmcXnUkn3MTfHRBSSc+38Oc13Vymxx9ueqUlVl81x4E1Z0EdbC0RhiFUSSbxhoUg0bJATRcvgUjUgocrYBXcp/jeMx6JUF+Pzr0pd0WSJFaL6huSsXb6QKiNt19zr4viLPsLhcPxcwie7w9En8MnucPQJequzk9RPLOFfwOY1QNRvUpzWEq8HxdhIVB8xHOERvdlz25TNUoe3ZiK1qWw10eSFmZwmpchl2DzWEMr9sePHVbtikU1qszM6/ZPkgMwOcv81Qzg5t8C6eCo5p+p27WRO+UyWI+esqbBUFNsmJZMOWZMnt56H4t0xJkAJ+Twt4aRcBzAcoToLldXnZT+ybK9FNYsx78Z6yW3Ogb9J001xwS87EeWI6MdE9FMiepGIfre9/2oi+hERHSGiPyWizIX6cjgc24duxPgKgHtDCLcCOAzgfiJ6J4BPAfi9EMIhAAsAHrhyw3Q4HJeLbnK9BQDrKTnT7b8A4F4Af7e9/7MA/hWAP7jgGSPkjY1mqIjxqGMuBlEROJcYCKO4DqyZRQRmGDco6bm1IWhDcqQpcc6Y3oR4ns9rMT6ZYa+2Wp1NaidOzKh2Uioua8kag8IzrlxhmX5gIK/aBeH9VhHZYwGgKVwWB3KsWqyZlFeVGpvvMunutErLt6ZVwGgxW3va2bdHBLtYs5zkmbPE8ZI3XlZZdcKSTUScW5OiNCNbRRsBo9XSbvOzJ9sZXKcBPArgdQCLIYT1p30KwN5u+nI4HNuDriZ7CKERQjgMYB+AOwC8bbNmmx1LRA8S0VNE9NRWJMVwOByXhouShEMIiwAeB/BOAKNEtC537QNwJuKYh0IIt4cQbr8YidnhcGwtLqgkEdEEgFoIYZGI8gDej9bi3LcBfATA5wB8DMDDV3KgF424CCFRjhc2uuskYfQxrc9bGwn/vsb90mrzjO4jI3jpE2ZNoC546nNCVza08UiluK4yq1NCF4usV9dF9+m0tr3lsjyO8fFRVTc6yu65lTKb6Cy//JhotyZIMIEYs5ZBiDOERh4WTQyxIQpNrbNE92P55tUYm9Fms6gxxkvC1vwY17aFblZEpgB8llqrTgkAnw8hfJWIXgLwOSL6twCeAfDpLvpyOBzbhG5W458DcNsm+4+ipb87HI6fA9CWpJLtEqlkMgzlWlFZ1osoKC41K2LxGNOCB61W1+aeSpXF0WxWy60NYSZKi3TIScO6UBWmJmueSQnTULlcFvsLup3s05hq5PgzGX2dSfAYM8Si9GBOjzGX4j6zKWPaE+5fk7s4LfPiihaRpwVhRTI7oOqOHufll6ECj3fPHh3ZNjXF/ZdLmlNepmyWYnxOmAYBzRVfr2iznJR86w2+zqamykdDpEcOG8jb5feM+yjVS4iCjaqTZsr6Bno6aXoTabPMtKoLM6g1xyoPycTmu1ud8slrhoxk/f2enq+gWrPuexu6djgcv8jwye5w9Am2gbyihYZxU5Kib72u5TQp9ayurXbK+bzmRBseGu6Uq8ajS3lICc44amiJR5Iu2JXjSoVdzQYHBelCWZ+LJA+cVZMEqUHVZHgtpAXBgRDH08azjEjwtpmojZGRkU55cXGxU84PDqt20zMnO+VkRpNGSI86ubo/v3hatTtzjrevu+YgNPg6R8d4xf3M6ZOqVV5YDDY6mfGOpFSpUuYbJW5j3QTrNITM34zJsqqd1WyQDHdqWaxlRl3ZTno5AkAqzeqLfSUkNXYQekIwnpOKqNrSl7fVQyL73os2kTUOh+MXCj7ZHY4+gU92h6NP0GPyCuqkG65VdKhVWqUI0qYmqZsrPnWjdtWErm91ZUkakRKmt4oZRy4hUhqZcZSKZVEnTWhaUUwleWD1hvU6E9di9L/CAK8XVEtsGlte1WaisSGOPiOjs68J0kbpxXby7LRqNzzCfcwu6v4Hh7gs1caUtprhxptu7JQtD7uM2JJrJNmcjpyT6xFWz1Wkm8IO1dxgkxK6vbkf0rtR6uz1uvYalBY7m48gJb0ejalTPkNrbpOoK5tdtC4ut4LpUPHvG7PwlpBXOByOXwz4ZHc4+gQ9FeOJgFS6JRpngj61FMGb0KJvqMhAhDgxB5u2A4CEEMXyBfZ4q9a0qaJcYfFuaFBnPpXkCjXRbgPnQmBvqYbpv1blxtWqNnkNFlhOHhhgr7ZC1oxDmO8yWc0GlhYmHpky9bq36Eytt73jrk75hZdfU3V//pWvd8o50d3IiOae3znBHnWrK5rHrlgUasgye9cNSh0B+p7mBnSdSkNVFt51FW2ybAhvsrqxvUnRPagcYIbXTzRsGu80zeGvj1OqR4gOimkKE+AGz0xFnCdMeeYdbkgzn1EPQ3sccR6x/mV3OPoEPtkdjj6BT3aHo0/Q06i3ZDIZBgst05MkVrBY1+vXURX+mykZ9VbVZjN5LWljNiuKfGOjwqW03tCRVqUim6HyxkwUxFpCU+hqiYTuI51mE1rWXGdekDYuLy+qulxG6K9Z1tfySRMdJ9xlD161X9WVhent8C/d3il/7wc/Uu0m9hzolL/7xF+rukyO1zRKq+yebIkYC3n+VrzrrjtVHYl7Jc1wlbI2eS0vs65fN3nrJBrNzU1orToZ9aafe1MFgIn1HmNCky7aDUOQr6LvjItzrSrWmgSn/IbUzrIuxi1Y2vKa5kLl2kQwdtt1s9y5hSoqHvXmcPQ3fLI7HH2Cnorx2UwmTO3eCWATk5cU78yQZISP9FwLEQH8AJBJa3ev1RU2/0hVYGhQEzfURLScJcfICiI3ador5LTUtCLOlRvQ/Y+OMVdb0kaziaippBCDy8KMBQA3CDPau+58h6o7e+5cp/yd7/2gU379+IJqJzI2o2TIIMbG+d6trbBonTQmxopwvNsxruuWhIYiuTxuvUUzjifFfTx//ryqSwuXvYzwPExnjBee4NNjDtQWmvJ7Jt6rVUO2oaIwjZydTMh3TlUpshNphrOm32ZdRsTp91Z5Wapx6ImQFNGUtv91S+LxcysoV+suxjsc/Qyf7A5Hn6CnHnSZTBr7D+wBACwtaY8ruTq/vKTFVil2HxfZSAs5zf2WE8QTdZNmaO+ePZ3y9AyLi8WSDgIZGWJvtUpV/xZaEol1TO7aobZnZ1lEXCtr7rdiiS0IuyY1p1taBHGMjbFcnElrL7mJSRaFf/Lsi6ru69/4IR8nDAFls9C9a4otEjPz+lksCdFdctCVy1reHxwWnG4VLXJOTLKoLWNTmkGrV889d7xTNpwlysqRTLCVYUMcjDh1wxJDREjIhRHdSVJ6WOa1mjAgPPuslUeK/HqF3KgCyWhCk6QYGAmdx3pHZoRaY73w1rtMJvT7JuFfdoejT+CT3eHoE/hkdzj6BD3V2ZuhiWqlpVNcd+1Vqu5X/49f65SD8VJaWGCd8v//A84KXVzV+omMBLK2h0PXH+qUK8LzbnZmVrXLT050ykND2mwmUSqxDpkyOvXgIK8dDA2NqDrJYVAznlrHjjKB4/lhVrjrxuvs1Zff6JQbRs+VQ7nrXe/qlP/iL59Q7Y4e53s6OKLHD+GhJ8knbWpnuZYwvkNf59LCfKe8fy+vMQyP7FTt7rmX6779Vz9QdZIEsi7V3OuceHUAAB+HSURBVA26PZeTxj6YFjz1MhKtWtXvjgzClIShAJAVunMmrfMRJBJsetPWMBOxVpdRb0afF2OUUYt27UCaIq3ev252jktB1fWXvZ22+Rki+mp7+2oi+hERHSGiPyWizIX6cDgc24eLEeN/C8DLYvtTAH4vhHAIwAKAB7ZyYA6HY2vRlQcdEe0D8FkA/w7APwbwtwDMANgdQqgT0V0A/lUI4UNx/YyPDYcP3NcKzigUtIiydw8HdFRNQMQNN97CdSUWaf/9Jz+l2lUEf/vExC5VtzjPHmSSGOKACSSZmWaznOWeX15hk+CKIGRIGa+qpAhoKRpzlRRHbUCEtBZKK5+lSQ+iS6uuCCslPnj/fZ3yN7/1mGpXFSQMu/fqeyD5GMrCNFmrWK9HrmvUjIwvrlOa3oyErL42ZZORKRWhZGaMCbQuIlUsx11xTZCMCHG5VNUnk5K1yRymeO2mdu9WdXNzc53ygX2skti8CCURoJQxFzYyzCqQ5ES0z7YhdMCU8RBdXm69m6+dmkOxUrssD7rfB/DPwFrUDgCLIXReu1MA9m52oMPheHPggpOdiP4mgOkQwtNy9yZNNxURiOhBInqKiJ6qVKKzVTgcjiuLblbj7wbwq0T0KwByAIbR+tKPElGq/XXfB+DMZgeHEB4C8BDQEuO3ZNQOh+Oi0U1+9k8A+AQAENE9AP5pCOHvEdGfAfgIgM8B+BiAhy/UV7Vaxsk3WuSGlgRgaX6mU15Z1maR537CQsWx4yc65eKKdqsdGeGIsrNndE6xkgjtWlnl4yoVbdaaFTqYFV+iljdMqjckBCFiJmf0SxH9VK3ZdM7CtCIEpWpV3yvJ7WHHJG9rXQQ/mctEReiU0+e1+bEs1kwSMa8IqfzCGVMncpaJMTZNzmO5tWePNsudO8dc9zlhhrL88jJqrGn8ggP4ZtXE/bYmy7zg9LT39PDhWzvlO96howw/85nPdMpHjx7tlIdHtClyROQhTJu01fPCTDlQ4PUkq5dLgtIPvf9+VUdtd9+H/sefIQqX41TzOwD+MRG9hpYO/+nL6MvhcFxhXJRTTQjhcQCPt8tHAdyx9UNyOBxXAj31oKvVajjXTtn7lkPX6Loym7JmzunUwAeu4rbFVeH5VdA2kvPnWASf2Dmq6ggsAi0ts9xdKs6pdlJAzBk3IRmVJSW98RHNMze7JNJEGROM5C63WgElWWyrCrk7YRQKaWoy9HSa+0DwkQdj55MpqspGD5GppGWqZJlWG9DeWgQbhSW52eqinYbk889kdBRjVVxLWoj/NSPGSw4TyxufFt5vtZokN9HjIDGOYJ7ZU08+0ynfesutqq4s1IbJCY5+XFjU79WOHcy5v7SkiUQGB1iHWF7leWDTMteEevXKq6+quv379wHYyFsn4b7xDkefwCe7w9En6G0gTAMotqXwNOlV0+UFFm1OvaH5wUaGeaU+l2bR5uqrD6h2uydZHF1e0Sv6MvhA2vttcIfgv9jgqdUQoqlcsb3jDr1C+9h3vsfnqmmxioT3lP2lbQohtyGE/GxGqwl14f1luRRkn/LMSSPvyz4rRiyW4nk+z8QNNt1WU9BwW7IQtWIujrNxGjIzqeTuA4DxYV7BluJtMqllcOmVZ1f7NdFF2LTYOjcft3+vTnM1J7wvn332GVUnefgWl3hV3RJxLMyzWG9JS4qCvjwjdMeUuc7VIltNXj92VNWdOH2q1WZtFVHwL7vD0Sfwye5w9Al8sjscfYKe6uyFXAK33tQyr1BTu3TtFqaywXdoHbXZZKVsaZ5NKy8XX1HtZNqo1aI2wUjyPumBVjc/d1KnXClqxUtaNaRuXxjU480Kr7l60H2EhEi7u4EfX6T+URW6YUKEwW0gX0zwkeUKmxvrRi9PNFnHtqamtCClSIlz1UwUYEPo7E3jkibJFxVXg3FPa4rtsnHzu+GGGzrlp4UXZdqYAOtNybdv+NTFPU1nBKHnkE4PvbbG90pGNAJAWlzAMz/5qaq7//5f7pS/+/3vd8oTE9r0OzvLRPpTbTPZOobE2tDiIpuWB/LatHzr4cOd8vyCTh02Oto6X+rIpl7rAPzL7nD0DXyyOxx9gp6K8ZQA8m1RKp0yQSBC/KS6NuNIz61xYRWxzkLvueeeTvmRbz2u6mS6KSlJWqKCQRGw0GjqQJuKGJYUn5976Tl9LmF3SWf172lZeHgZK5FK+ZQQortNQ5UQQr7JJKRSLa0Kb0OTSUiJ4JYTLZXmxmtrfA/qxp4kRfeEsWUlBOFDQp7cELtL7aJieOFGR0V0irxmowI2RJ/ptHWN4xs0OMQeelYlKYhAm7q532URiDRoVDapajzxQ+b5K5i0X9k1vrabbrxR1T3//POd8tg4e+EVDAddVcyLw7cdVnXrqbPss5TwL7vD0Sfwye5w9Al8sjscfYKe6uzlUhMvPd/SAd919x5VV8izLvT8T99QdfkB1kMkT2DCjP6ag8xFf/2h61Td0TdOdcqrgm8+ndU62JhIqVw3KaEzgm8+KdxeT5zQqYYlqWQwOX6Vuc24utaaQgcW7q1NGLOZ6KNqdXZxT4oi1XPKqLJNqdoZhb5ZZ524ZEgv1DhkHxs+G2LMIbqd7MNk8cb5aU4/LcdfMXnl5FbOXGdN6LkZaXobnlDtZO7BoRHtLjvbYHftmiFd+cY3vtEp7xB5q9/z7nfr/hXRih7/4dtu65RlLsNgzIgjYlzVmjV1XpgEyr/sDkefwCe7w9En6KkYn80AVx9slfMZm45WEC0Yk1RdcIdJsS8YEfb559gENmhMH0lBBCCJCmzq25owL1l+urQYs+QYm62fU+2ENI5Vw4Uu+CSQTptzV4QHnajKGeJ4UnmRTP+iaU3IxSYrEoRGolMrQasaUi2wZApSHN1o2tusleaQt/03TffT0+wNViiwulWr6+eio/t0HyKgTJkwT5/WBCkkri2X16rdHsEVXzTk9uPCFnztIY5+TBpu+JtuYnPb93/wA1N3c6fcEKpjyuheA4P8TifsjVzf3vCMGP5ldzj6BD7ZHY4+QU/FeCTRYp0HMLJfy1sLi7xa2TDcb6eZURiDOV4tn9w1pdqdOcskAyZ5KrJZDnTIl0VwRFN7KeXrLCpNGlVgrcpjvPYAi5LntBQPEX+CnBEr5YrwWlHrKwVRlxDEBQ3jJletyuAOfYKiyAy7XApivx6HJHxIGrVJag1qtd+u+ErVyHw3SOhbTSGfm7ggSMq4jFFX5mZZZJ6Y5JXuWk1TXy8vc6drK/pCB8XjrZfZCpPXdHdqHHPL2rpyy223d8p/9Z2nVN2v//3/p1NOCLG7ZkwLp2d5XMM7dQbj03M8romr3tIpr4iUUQAwdOAg92+iqBaWWu9m3cV4h8Phk93h6BP4ZHc4+gS9jXojIN/Wxx995HVV9553s66yd8qQVwhTS3GFPZ0SiXHVLpFgxathoquKa6yY5gSpX3FZ60XTJbZJ/fpv6AzUf/alL3bKywuCux0a42N8WwcGNEnC+RleV8jntX5VKgldPMXjqBkTo4QlgZR2LhUVGGNe2+B8FUU9TrGbUcNQ7RJJSy4hUjIZAoyhEY5AzAiid0uUIbN/22tRNPKinDD39OZbD3XK1YYe49ISE0V8/OP/SNVlRdjk4gqTPco0zABQJn7P9u/XRKkzs+yhNzHJqcYXDXnkznGuOzereemnplp9ZtJmwUugq8lORMcBrKB1u+ohhNuJaBzAnwI4COA4gP8zhLAQ1YfD4dheXIwY/74QwuEQwvrS5McBPBZCOATgsfa2w+F4k+JyxPgPA7inXf4sWjngfifugGwmi4P7W2aHtWWdvmZ1ic0sN9/4NlU3NMimlhef5+ysY+Na3DpyhANo9u7foeqks1pVpDsaH9cBEaUii8/PPfO0qtslkoxOCJKBoUFNcrEm7FwzM1rYkVJsweSXSiVEptk1ljNzWf2YKhWZh8qml+KyUmWsGC8PM/J4VEzFRuleeNCZoCEV+6JSXumTyfRPTeg+1oqsst1+x02d8tLSjGq3usJq3tiYvqeSOENmT61VtPp2512ctvCz//NPVN3bbv6lTtmmwGqK+19cZbF7/17NM5cRHnW5rB7j668d65QHCiz+jwxpNTWXYnvhUF7fq4mdewEA3zKBXRLdftkDgEeI6GkierC9bzKEcBYA2v93RR7tcDi2Hd1+2e8OIZwhol0AHiWin3V7gvaPw4MAMDTQWx8eh8PB6OrLHkI40/4/DeDLaKVqPk9EUwDQ/j8dcexDIYTbQwi35607mcPh6Bku+KklogEAiRDCSrv8QQD/GsBXAHwMwCfb/x++UF/lUhU/e6GlV2dT2k117jybN0aGta5y5jTr6e9+D5tInnvuiGo3tZv7LJicvCODrCeNj+7tlNNmHLkc6zyDQ5qNcneNCRCLJR7v9Yc02UFJRMu99fobVN3nPvdIp5wa0FpwVuSxy+9g/Wx5ReuX6tKC/gHVhINcl0wYk4wIGSQTQSXT/sZ/DVgfDhRNsCFD4shy4Aui0YkJcx+Lkr+d1ynmZnXU28038fNcM+YqSSjxxjHWjW+57ZBqd/Ysk5uMjA6rul0iFfP0nHal3b2bXV8PHGCTWsqEGY4K4olaVY+/VuZnMTvNJrXrRvV6Ul2QduwY1Vrz+nNPUvQHtRu5ehLAl9shgCkA/yuE8A0iehLA54noAQAnAPxGF305HI5twgUnewjhKIBbN9k/B+C+KzEoh8Ox9ejtillIgBqtSLKlVZOWeZTFj0cf1Sl2rr6GhclURngpmci2kydFlJTWBJDLsGiWzbHobmm2z55nUW+oNKjqhoQ3XCrB5WEdHIeZaVY7mnUtgt98I4tm8wvaZLdjJ6fyPXaMxcq0kcyIRHop4wlGgphPSsyptFZJmiL9k00N3BAmMEkGYfn05HYwpjelJojdCZtiWmzL1MgA8KEPMY/bzHkWn995pxbB3zjBJteBnFbLVkUqp2HhkXf11Try7JFHv90pF4a0OvHkUz/ulPftv1bV7Z5kE9vUbn5+SYqZWiZZwf49rIZkMlyXMc8ll2bVTqp8ALDWthjHUdG5b7zD0Sfwye5w9Al8sjscfYKe6uylcgMvvDgPADh4tSGETLKu8hatkmF2gfX0/MDZTvnA1Vppv+oqNpEMZHRk0cKC4GQXJJMnz+jou7TwNlxZ0zrk7j2sn62tsk76N/4vvU75Xz/57zvlpaWzqg6BdfgD+7X55MiREzxGoZKNDGmz2coKu/taVVkSP8p8Zk2TGE8Sa5Ih4JcEn6Q0brPAIULnrKur9JeV5CnG8qa8fXPG0/OZp5/slK+5+mCnvLKi13ukC7IlasmL3Nrn32C36yee0KSPxRKPf2VNM+FkC6wrj41rfT4j0i3X6zJSUZvXsikeBxlWzB1jvJYwMMDluUWdlnmX9Nc2GGx3b3koJfzL7nD0CXyyOxx9gp6K8el0ApNTLdPI2XM6Pe/Ba9n8UKqeUnWS/yEvpP9Tp5dUuz0TbNZa1d1jbJTF+sPvYn7vL37+v6l2lRqLX7khbXorCRLBNUFa+ciX/liPt8C3lYIW53bs4D7n53T0lgyGkuLYzJwmL1RZiU0oWhCeZjUhVtrczgHSbKb7qIkdScUToWVwyV9vxWflQBejCcjtouHYTxDfu3pDXItRGVZXpVqjiS1k+uWsCH1cXdMnm5jglyyYaTG3JF8mfe7Tp0Wk5RSnNKsF/cwWF9l0OJDV5sGVZX4PVlfnO+WlVW223TnBamvDfKeHRlpErHFpoPzL7nD0CXyyOxx9gp6K8Y1mE6ullvhkaL7ws1eZzGJqv0m/s49XKBMpIUaRltVXBc/caEGv1BcGOIXPDx9nj6gDV2mPqIUi35IZI2Ync1y3NssqRKakV00PXMWr7KWiFuPnZjjQwdDkQWab2r+fr3llVXvaycXchl2Nl3zwST5BynhckZAyUyYNVUrlYeI6In0y5a1n+elEW6mS2PRMMvvW1KS2Onz4w7/aKT/85S91yiPDo6rdL9/NWVCf/+nzun9xj/NZ1n9W1iqq3cwMr/C/775fUnWrL7zSKX/3u4+ruve97/2d8vHj3C5JJrioxudbNg9tYY5TUS2IbLJj43r1fVp4dxZLevzDoy0rgQ2ykfAvu8PRJ/DJ7nD0CXyyOxx9gp7q7MlkAkNjLdNTpqzNCtkB1qfS1pVKRP9UqnxcWVs3sHOUQ92GRnUeuHqTPZhqTb7s22+/U7X7+mPsUVc17mlVcKRYyLAyuLKideqmiPhaNTbAHTvZdtg0CxcDOWFCEia0vVP6NzmbY33e3oNUmvt/4ySbe4pr2iQ1PMwmwMVl7ZGWz8sx8rnLVa0nDua4XaWs66RaemC/1LF1u1KJTWBrq/pizp1lXXZ4iE1j1Yo2m83N8HXeeONbVd3ZM+zBWFpjffajv/ZB1e4LX/yLTjkY893ePfwuVd/QZuF8jt/N8+e47loTVXderP9k03raZdL8Xl11gN/hSsXeU14bSiT1gs/CQusZSlOjhX/ZHY4+gU92h6NP0FMxvhmaWK20RN7BgvYiqgvRd9pwra8ISXhOxChcc3Cvard373WdcmlVi8g7d7N3XSLLJrqVkhZ7ZHqmck2Li2MNFrcGhjk4YjChTSRZQUCQN7mB11a5z2xOkxjMz3PAT0ZoMhO7dPBFOsXi8wsvn1B1ktAjLcxtGX0qLC3zuUaHdYqqBSXWp0Q7bfJaXGYzYi6jX6WPfORXOuUnvv94pzw7q+/poPCITBmaPMnDPiQaNutazWuIoJ75Wc17Krn5JwWX3JeF2N7qn2/Q7t1aBZydZzLlB/7B31d1Cwv8vsg0UXOzp1W7sTF+34vGlHr+/PFOeecEv0uDJoXUqRNsnr7xFk0eVa603uNUylM2Oxx9D5/sDkefwCe7w9En6KnOHgKnH84WNJleQvhUTk5qvuxyiXWcq/azbpXLaJ1GRm/tP7BH1Z07d65Tnl/k8snpedXuukOcU+zs+TdUHUS+rrlpEalU1X00BFFEoaB19uFB1o8nJzR5xbGjrAMrE0pT67mju1mv271L69GvHWW9cXxCuNyK/HMAMCgi86p17WIp9dxMhk10y8s6ynBogOsaDW0m+ou/+Ese7zDrq7t3a072+Rl+tk09RCwtsc4u8/ONGl73apnHPzeriSdyIvfZ5C7W2VPmM7eyzON/6Xntcru4zGP87B99WtXde9+9PI4Kr3Xs2HFQtRsQZP/z09p8NyjmwuzMGT5mSK9NTEzwsx4c0AscmWzLDzmZiP5++5fd4egT+GR3OPoEPRXjs7k0rn9LS3SdndERZXt3skj7wrNazNkto6ECm1nOl7TZ6cTrLEaVSz9WdSGwSFSVnOnaAoh33HVLp7wwr/NXTs+yiPzWt17fKR/5yRndTlzavfdco+pmptnbqzamQ8A+dD+LhEtLLDqOjmgS/Cee4Gubn9cRd9JzbWmR+ygUtNi3tCxNjvo3P6h2LLoXjLlU8saXy1oGV0moRHTi7Iz2/DogIhpHDQH/qrC5lte4nDFpk+fn+YaXS5qJY36Wr7NUeqFT3r9Pp/SW9+3UaW02yxZYdRwd0WOcOc/Pfs8U88YXl00ab6Hm7JnS6ttAnqdhQ9zTIyKVMwDcefcvd8qWU3BHO4V4MhU9pbv6shPRKBF9gYh+RkQvE9FdRDRORI8S0ZH2/7EL9+RwOLYL3Yrx/xnAN0IIb0UrFdTLAD4O4LEQwiEAj7W3HQ7HmxQUx1kFAEQ0DOCnAK4JojERvQLgnhDC2XbK5sdDCNdH9QMAhSyF69pszGm9GK/EozOnDYGckFiuOcgi0NHXtbdUNiu430iLrUmROmdphUWqYlkHPZREsMdv/9N/qOoGR7nPh7/6hU75wPhu1e6ll1/slPdM6bq65LFb1iJ4pcyr7nIVv1bTATnnp1lENIvPkPRme/bzuX/26jnVbmwHi8/La3o1fq3IY8yk+ZprJsgim+G6pGGvSArWiLU1Pu7wzZos5MgRDjzaPaE9+eQ7Ua3wyvyunVqI/OAHmcp7flZnWf3u977TKb/3PZxOatioDI9/74lOWXoXAkClwS/gjTffoup27GTLSFPoAtcc1FTmSfESnz55UtWdPs3qqDgVsnk9xqKwSLzjrrtVXaNN6/2f/8sXcPLU9KZudN182a8BMAPgM0T0DBH993bq5skQwlkAaP/fFdeJw+HYXnQz2VMA3g7gD0IItwFYw0WI7ET0IBE9RURP1ZsXbu9wOK4MupnspwCcCiH8qL39BbQm//m2+I72/+nNDg4hPBRCuD2EcLt1ZHA4HL1DN/nZzxHRSSK6PoTwClo52V9q/30MwCfb/x++UF+FfA5vv7kVmTY0rD3LZArhk68/o+r2TnHb4hLrl4cOan14tcgRSE3S+mVGeIVVhV4+UNAmmN1TrFOODk6quoJQoe57D5vJ1ua13n9cpBmaX9AmqZ1j7PVXz2sT0uI8mxwlSeO5c9qMMy707WpV1+0/sL9TfuUI64Z7pvR1njzN3nojo9oTsS7WCBqhJtppz7W1FdZtKxUttuUzm5NRzs7odQp5B9YJGNbxkb/9a53yZ/7wf3TK939Qp9t6+Ct/3infe8+7Vd1738vbX/riNzvlkuGo/+jffW+n/B2hvwNAEMygyYS+zpvfzuSUZ47x+sOCST+9ssD32+r9113L+c5ERi187RvfUu3eeiMfVyrqcXAa8uiot27t7P8QwB9Ta9XrKIB/gJZU8HkiegDACQC/0WVfDodjG9DVZA8hPAvg9k2q7ttkn8PheBPigqa3rcRwIRXufGvLvHL41pv1QIhF4aef/ImqGx3hhf6xYfYmm5vTnmvlOntSpQxZg+Roz2WY9GJ1VQeS3PHO+7m/mlYFmgkWmb/7g693yu99z99W7Z780V93ypYT7cd/zdlDC1ltfxwcZC+/l158qVM2FHe44SYmVxgc0KL1UcGRNj0rvM4MUcbiKqsydt10QOgry0XuwxIjNOtBHKO962Rm1XqFVYFqXas81x5gVWxlWYu+i4s8RnmrdmqNBPv3sfnrLYcOqrpJETQUmnzuXNZci1i+KlX0GAuDrOYsmzwAu6f4XTr6+vFOec+UJsDYtYfbnXldZw5OJvjisjlWWX/81E/1ufayOY+S+nnefFvrW/y7/+Y/4tjxk5dsenM4HL8A8MnucPQJfLI7HH2Cnka91WsNnD/bMr2c3akjiw4d4uiwkyc0EUJ1J7tANoR76+mzOnJuTPA+kskpJlNjLS/xuWvGZJROsIludEKTaDRTTNaQEHmI9+07qNrt3MFrDJMTmozyl27jdc7Q0Paf//gfPsXnEh6yaUPEmBb6GpkLLa4xr/7UFJ97ZlYTT8hf+XRKrx3UaoZFoo2kSdQmUyDbY2oiKisrfKP/1gffr9r97CUmiphf1M99QkQFVip8Q6yL8Ntv4+c0MKhNuvI6h8d4febcWR1Rlkrzesk5kY8PAKb28fjlegYAJIRdkcQ7kUroqfWaWINJmm9sTaQJL55jIpR8XqcMz4t8AYVBvdb0yNceBQAsL5kFHjnWyBqHw/ELBZ/sDkefoKemNyKaAfAGgJ0AZi/Q/ErjzTAGwMdh4ePQuNhxXBVCmNisoqeTvXNSoqdCCJs56fTVGHwcPo5ejsPFeIejT+CT3eHoE2zXZH9om84r8WYYA+DjsPBxaGzZOLZFZ3c4HL2Hi/EOR5+gp5OdiO4noleI6DUi6hkbLRH9IRFNE9ELYl/PqbCJaD8RfbtNx/0iEf3WdoyFiHJE9GMi+ml7HL/b3n81Ef2oPY4/JcvaeeXGk2zzG351u8ZBRMeJ6HkiepaInmrv24535IrRtvdsslPLr/P/A/A3ANwA4KNEdEOPTv9HAO43+7aDCrsO4J+EEN4G4J0AfrN9D3o9lgqAe0MItwI4DOB+InongE8B+L32OBYAPHCFx7GO30KLnnwd2zWO94UQDgtT13a8I1eOtj2E0JM/AHcB+KbY/gSAT/Tw/AcBvCC2XwEw1S5PAXilV2MRY3gYwAe2cywACgB+AuBOtJw3Ups9ryt4/n3tF/heAF9Fi1dpO8ZxHMBOs6+nzwXAMIBjaK+lbfU4einG7wUgCbNPtfdtF7aVCpuIDgK4DcCPtmMsbdH5WbSIQh8F8DqAxRA6+bV69Xx+H8A/A3No7NimcQQAjxDR00T0YHtfr5/LFaVt7+Vk34w9oy9NAUQ0COCLAH47hBAdpnQFEUJohBAOo/VlvQPA2zZrdiXHQER/E8B0COFpubvX42jj7hDC29FSM3+TiN7Tg3NaXBZt+4XQy8l+CsB+sb0PwJmItr1AV1TYWw0iSqM10f84hPCl7RwLAIQQFgE8jtYawigRrcdm9uL53A3gV4noOIDPoSXK//42jAMhhDPt/9MAvozWD2Cvn8tl0bZfCL2c7E8CONReac0A+DsAvtLD81t8BS0KbKBLKuzLBbUCnj8N4OUQwn/arrEQ0QQRjbbLeQDvR2sh6NsAPtKrcYQQPhFC2BdCOIjW+/BXIYS/1+txENEAEQ2tlwF8EMAL6PFzCSGcA3CSiNbTqK3Ttm/NOK70wodZaPgVAK+ipR/+ix6e908AnAVQQ+vX8wG0dMPHABxp/x/vwTh+GS2R9DkAz7b/fqXXYwFwC4Bn2uN4AcC/bO+/BsCPAbwG4M8AZHv4jO4B8NXtGEf7fD9t/724/m5u0ztyGMBT7Wfz5wDGtmoc7kHncPQJ3IPO4egT+GR3OPoEPtkdjj6BT3aHo0/gk93h6BP4ZHc4+gQ+2R2OPoFPdoejT/C/AUurcLNTDzkBAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(np.transpose(examples[0][1][2][2,:,:,:] * 10, (1, 2, 0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fb40f8b1d10>"
      ]
     },
     "execution_count": 3,
     "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": [
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "# image = Image.open(\"./data/tiny-imagenet-200/train_adversarial/n01770393/images/705777733081848.JPEG\")\n",
    "image = Image.open(\"./data/tiny-imagenet-200/train_adversarial/n02883205/images/112439404696180.JPEG\")\n",
    "plt.imshow(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import cv2\n",
    "img = np.transpose(examples[0][1][2][2,:,:,:] * 4096, (1, 2, 0))\n",
    "img = Image.fromarray(img.astype(np.uint8))\n",
    "img.save(\"test_image.JPEG\")\n",
    "img = cv2.imread(\"test_image.JPEG\")\n",
    "denoised_img = cv2.fastNlMeansDenoisingColored(img, None, 10, 7, 21)\n",
    "cv2.imwrite(\"test_image2.JPEG\", denoised_img)\n",
    "# img_dir = directory_name_folder_images_path + \"/\"\n",
    "# cv2.imwrite(img_dir + image_name, denoised_img)\n",
    "# cv2.imshow('asdf', img.astype(np.uint8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[2.85370678e-01, 3.12384248e-01, 2.97649562e-01],\n",
       "        [2.99105346e-01, 3.32030535e-01, 3.14840078e-01],\n",
       "        [3.06472689e-01, 3.49220991e-01, 3.24663192e-01],\n",
       "        ...,\n",
       "        [3.71323049e-01, 4.79377389e-01, 3.92425060e-01],\n",
       "        [4.13071334e-01, 5.28493047e-01, 4.40084904e-01],\n",
       "        [2.92738020e-01, 4.15527105e-01, 3.24663192e-01]],\n",
       "\n",
       "       [[2.94193774e-01, 3.16295803e-01, 3.05016905e-01],\n",
       "        [2.96649575e-01, 3.23663175e-01, 3.09928477e-01],\n",
       "        [2.91737974e-01, 3.31030518e-01, 3.07472706e-01],\n",
       "        ...,\n",
       "        [3.45765203e-01, 4.46452230e-01, 3.62955660e-01],\n",
       "        [4.08159763e-01, 5.16214132e-01, 4.30261791e-01],\n",
       "        [3.63955677e-01, 4.76921648e-01, 3.88513505e-01]],\n",
       "\n",
       "       [[2.94193774e-01, 3.08928460e-01, 3.00105363e-01],\n",
       "        [2.81914860e-01, 3.06472689e-01, 2.87826449e-01],\n",
       "        [2.72091746e-01, 2.99105346e-01, 2.80459106e-01],\n",
       "        ...,\n",
       "        [3.46765220e-01, 4.44996476e-01, 3.60499889e-01],\n",
       "        [3.50676775e-01, 4.49908048e-01, 3.65411460e-01],\n",
       "        [3.31030518e-01, 4.30261791e-01, 3.45765203e-01]],\n",
       "\n",
       "       ...,\n",
       "\n",
       "       [[0.00000000e+00, 1.10010169e-01, 3.18751603e-01],\n",
       "        [0.00000000e+00, 1.20833293e-01, 3.32030535e-01],\n",
       "        [6.86734496e-03, 1.34567976e-01, 3.40853631e-01],\n",
       "        ...,\n",
       "        [3.32030535e-01, 1.30656421e-01, 7.80850202e-02],\n",
       "        [2.90282249e-01, 1.52758449e-01, 8.64523575e-02],\n",
       "        [2.54901290e-01, 1.59125790e-01, 7.80850202e-02]],\n",
       "\n",
       "       [[4.99999966e-04, 1.08554393e-01, 2.95193791e-01],\n",
       "        [2.95578176e-03, 1.20833293e-01, 3.07472706e-01],\n",
       "        [1.42346891e-02, 1.27200648e-01, 3.12384248e-01],\n",
       "        ...,\n",
       "        [3.07472706e-01, 1.45391107e-01, 8.15407932e-02],\n",
       "        [2.54901290e-01, 1.59125790e-01, 7.90850148e-02],\n",
       "        [2.05785647e-01, 1.57670051e-01, 6.68061003e-02]],\n",
       "\n",
       "       [[4.99999966e-04, 1.02642834e-01, 2.72091746e-01],\n",
       "        [1.42346891e-02, 1.12465955e-01, 2.84370661e-01],\n",
       "        [2.16020364e-02, 1.18377514e-01, 2.87826449e-01],\n",
       "        ...,\n",
       "        [2.89282233e-01, 1.49302676e-01, 7.80850202e-02],\n",
       "        [2.22976118e-01, 1.54214233e-01, 6.33503199e-02],\n",
       "        [1.65037379e-01, 1.42935336e-01, 4.22482900e-02]]], dtype=float32)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.transpose(examples[0][0][2][2,:,:,:]) * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_fgsm(model, criterion, optimizer, scheduler, dataloaders, epsilon, idx_to_class_map, save_location,\n",
    "              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",
    "        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",
    "            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",
    "            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",
    "            \n",
    "            for i in range(32):\n",
    "                file_name = save_location + str(idx_to_class_map[int(labels[0].detach().cpu().numpy())]) + \"/images/\" + str(np.random.randint(0, 1e15)) + \".JPEG\"\n",
    "                \n",
    "                img = np.transpose(adv_ex[i] * 4096, (1, 2, 0))\n",
    "                img = Image.fromarray(img.astype(np.uint8))\n",
    "                img.save(file_name)\n",
    "                img = cv2.imread(file_name)\n",
    "                denoised_img = cv2.fastNlMeansDenoisingColored(img, None, 10, 7, 21)\n",
    "                cv2.imwrite(file_name, denoised_img)\n",
    "\n",
    "            # statistics\n",
    "            running_loss += loss.item() * inputs.size(0)\n",
    "            running_corrects += torch.sum(preds == labels.data)\n",
    "            \n",
    "            break\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": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./data/tiny-imagenet-200/train_adversarial/n01770393/images/705777733081848.JPEG\n",
      "Training complete in 0m 1s\n",
      "Epsilon: 5e-05, Accuracy: 0.0015001500150015003, Loss: 0.007928957568608423\n"
     ]
    }
   ],
   "source": [
    "epsilons = [5e-5]\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",
    "# \"./data/tiny-imagenet-200/train/n12267677/images/n12267677_139.JPEG\"\n",
    "image_location = \"./data/tiny-imagenet-200/train_adversarial/\"\n",
    "\n",
    "# Run test for each epsilon\n",
    "acc, loss, ex = save_fgsm(model, loss_func, optimizer_ft, None, dataloaders, eps, \n",
    "                          idx_to_class_map, image_location, verbose=False)\n",
    "print('Epsilon: {}, Accuracy: {}, Loss: {}'.format(eps, acc, loss))\n",
    "#     np.save('fgsm_data_v2.npy', np.array([eps, accuracies, losses, examples]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{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"
     ]
    }
   ],
   "source": [
    "import shutil\n",
    "import os\n",
    "\n",
    "# List of TinyImageNet classes\n",
    "tiny_imagenet_classes = os.listdir(\"./data/tiny-imagenet-200/train/\")\n",
    "\n",
    "idx_to_class_map = {}\n",
    "class_to_name_map = {}\n",
    "with open('./data/tiny-imagenet-200/words.txt', \"r\") as f:\n",
    "    i = 0\n",
    "    for line in f:\n",
    "        one_line = line.split()\n",
    "        if one_line[0] in tiny_imagenet_classes:\n",
    "            idx_to_class_map[i] = one_line[0]\n",
    "            class_name = \" \".join(one_line[1:]).split(',')[0]\n",
    "            class_to_name_map[one_line[0]] = class_name\n",
    "            i += 1\n",
    "# print({k: class_to_name_map[v] for k, v in idx_to_class_map.items()})\n",
    "print(idx_to_class_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}