{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training AlexNet with tips and checks on how to train CNNs: Practical CNNs in PyTorch(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torchvision.utils import make_grid\n",
    "from torchvision.datasets import ImageFolder\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n",
    "\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0)\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 1 Create Data Pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "My Data dirs explained. For my train dataset I use the validation dataset provided by Imagenet i.e. 50000 images. All these images are stored under the train folder. One preprocessing step that I done is to rescale all these images, so that their shorter side is 256. To do this you can either add a transform.Resize(256) or from the terminal run this command and all their images would be rescaled to 256 and stored on disk\n",
    "```(python)\n",
    "    find . -name \"*.JPEG\" | xargs -I {} convert {} -resize \"256^>\" {}\n",
    "```\n",
    "\n",
    "For my validation data, I use 10 images from each class from the train dataset of Imagenet. Below I give the script I used to do so. These images are also rescaled to 256 on the shorter side using the above command. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell to get 10 images from train folder and place them in your val folder\n",
    "import os\n",
    "import shutil\n",
    "\n",
    "source_dir = '../../../Data/ILSVRC/Data/CLS-LOC/train/'\n",
    "dest_dir = '../../../Data/ILSVRC2012/val/'\n",
    "dirs = os.listdir(source_dir)\n",
    "dirs.sort()\n",
    "\n",
    "for dir in dirs:\n",
    "    os.makedirs(dest_dir + dir)\n",
    "    path_source = source_dir + dir\n",
    "    path_dest = dest_dir + dir\n",
    "    images = os.listdir(path_source)\n",
    "    \n",
    "    for i in range(10):\n",
    "        shutil.copy(path_source + '/' + images[i], path_dest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Create the dataloaders"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the transforms we first need to crop our images, as the input size for our model is 224. For the training dataset I use RandomHorizontalFlip as a data augmentation technique. Another technique that is useful is the FiveCrop transform. But I did not use that here. The images are normalized using the standard values of mean and std computed over the entire ImageNet.\n",
    "\n",
    "For the validation I did not use data augmentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dir = '../../../Data/ILSVRC2012/train'\n",
    "val_dir = '../../../Data/ILSVRC2012/val'\n",
    "\n",
    "size = 224\n",
    "batch_size = 32\n",
    "num_workers = 8\n",
    "\n",
    "data_transforms = {\n",
    "    'train': transforms.Compose([\n",
    "        transforms.CenterCrop(size),\n",
    "        transforms.RandomHorizontalFlip(),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n",
    "    ]),\n",
    "    'val': transforms.Compose([\n",
    "        transforms.CenterCrop(size),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n",
    "    ])\n",
    "}\n",
    "\n",
    "image_datasets = {\n",
    "    'train': ImageFolder(train_dir, transform=data_transforms['train']),\n",
    "    'val': ImageFolder(val_dir, transform=data_transforms['val']),\n",
    "}\n",
    "\n",
    "data_loader = {\n",
    "    x: torch.utils.data.DataLoader(image_datasets[x],\n",
    "                                   batch_size=batch_size,\n",
    "                                   shuffle=True,\n",
    "                                   num_workers=num_workers) for x in ['train', 'val']\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Plot some images to test everything is working"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Labels dict:-\n",
      "n01440764 tench, Tinca tinca\n",
      "n01443537 goldfish, Carassius auratus\n",
      "n01484850 great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias\n",
      "n01491361 tiger shark, Galeocerdo cuvieri\n",
      "n01494475 hammerhead, hammerhead shark\n",
      "\n",
      "Labels list (just 0 indexed instead of file names)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['tench, Tinca tinca',\n",
       " 'goldfish, Carassius auratus',\n",
       " 'great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias',\n",
       " 'tiger shark, Galeocerdo cuvieri']"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# For imagenet we need to do some preprocessing for the labels\n",
    "f = open(\"../../../Data/LOC_synset_mapping.txt\", \"r\")\n",
    "labels_dict = {}\n",
    "labels_list = []\n",
    "for line in f:\n",
    "    split = line.split(' ', maxsplit=1)\n",
    "    split[1] = split[1][:-1]\n",
    "    label_id, label = split[0], split[1]\n",
    "    labels_dict[label_id] = label\n",
    "    labels_list.append(split[1])\n",
    "   \n",
    "print('Labels dict:-')\n",
    "for idx, (key, value) in enumerate(labels_dict.items()):\n",
    "    print(key, value)\n",
    "    if (idx > 3):\n",
    "        break\n",
    "        \n",
    "print('\\nLabels list (just 0 indexed instead of file names)')\n",
    "labels_list[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "# Our images are normalized so denormalize then and convert them to numpy\n",
    "def imshow(img, title=None):\n",
    "    img = img.numpy().transpose((1, 2, 0))\n",
    "    mean = np.array([0.485, 0.456, 0.406])\n",
    "    std = np.array([0.229, 0.224, 0.225])\n",
    "    img = std*img + mean\n",
    "    img = np.clip(img, 0, 1)\n",
    "    plt.imshow(img)\n",
    "    if title is not None:\n",
    "        plt.title(title)\n",
    "    plt.pause(0.001)\n",
    "    \n",
    "images, labels = next(iter(data_loader['train']))\n",
    "grid_img = make_grid(images[:4], nrow=4)\n",
    "imshow(grid_img, title = [labels_list[x] for x in labels[:4]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 2 Model Construction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Activation function:- ReLU is the default choice. But LeakyReLU is also good. Use LeakyReLU in GANs always.\n",
    "2. Weight Initialization:- Use He initialization as default with ReLU. \n",
    "3. Preprocess data:- There are two choices normalizing between [-1,1] or using (x-mean)/std approch. Your choice for this.\n",
    "4. Batch Normalization:- Apply before non-linearity i.e. ReLU. For the values of the mean and variance use the running average of the values while training as test time. PyTorch automatically maintains this for you. Note: In a recent review paper for ICLR 2019, FixUp initialization was introduced. Using it, you don't need batchnorm layers in your model.\n",
    "5. Pooling layers:- Apply after non-linearity i.e. ReLU. Different tasks would require different pooling methods for classification max-pool is default.\n",
    "6. Optimizer:- Adam is a good choice, SDG+momentum+nesterov is also good. fast.ai recently announced a new opitimizer AdamW. Choice of optiimzer comes to experimentation and the task at hand. Look for some benchmarks for different optimizers that can guide your choice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AlexNet(\n",
       "  (conv_base): Sequential(\n",
       "    (0): Conv2d(3, 96, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))\n",
       "    (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU(inplace)\n",
       "    (3): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (4): Conv2d(96, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    (5): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (6): ReLU(inplace)\n",
       "    (7): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (8): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (9): ReLU(inplace)\n",
       "    (10): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (11): ReLU(inplace)\n",
       "    (12): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (13): ReLU(inplace)\n",
       "    (14): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (fc_base): Sequential(\n",
       "    (0): Dropout(p=0.5)\n",
       "    (1): Linear(in_features=9216, out_features=4096, bias=True)\n",
       "    (2): ReLU(inplace)\n",
       "    (3): Dropout(p=0.5)\n",
       "    (4): Linear(in_features=4096, out_features=4096, bias=True)\n",
       "    (5): ReLU(inplace)\n",
       "    (6): Linear(in_features=4096, out_features=1000, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class AlexNet(nn.Module):\n",
    "    def __init__(self, num_classes=1000):\n",
    "        super(AlexNet, self).__init__()\n",
    "        self.conv_base = nn.Sequential(\n",
    "            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2, bias=False),\n",
    "            nn.BatchNorm2d(96),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
    "            \n",
    "            nn.Conv2d(96, 256, kernel_size=5, stride=1, padding=2, bias=False),\n",
    "            nn.BatchNorm2d(256),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
    "            \n",
    "            nn.Conv2d(256, 384, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            \n",
    "            nn.Conv2d(384, 384, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            \n",
    "            nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
    "        )\n",
    "        self.fc_base = nn.Sequential(\n",
    "            nn.Dropout(),\n",
    "            nn.Linear(256*6*6, 4096),\n",
    "            nn.ReLU(inplace=True),\n",
    "            \n",
    "            nn.Dropout(),\n",
    "            nn.Linear(4096, 4096),\n",
    "            nn.ReLU(inplace=True),\n",
    "            \n",
    "            nn.Linear(4096, num_classes),\n",
    "        )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.conv_base(x)\n",
    "        x = x.view(x.size(0), 256*6*6)\n",
    "        x = self.fc_base(x)\n",
    "        return x\n",
    "    \n",
    "model = AlexNet()\n",
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Weight Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here we use indexing to index the layers, but in future cases we would name the layers\n",
    "conv_list = [0, 4, 8, 10, 12]\n",
    "fc_list = [1, 4, 6]\n",
    "for i in conv_list:\n",
    "    torch.nn.init.kaiming_normal_(model.conv_base[i].weight)\n",
    "for i in fc_list:\n",
    "    torch.nn.init.kaiming_normal_(model.fc_base[i].weight)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Create opimizer, learning_rate scheduler, loss function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# We train everything on GPU\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "print(device)\n",
    "\n",
    "# Cross entropy loss takes the logits directly, so we don't need to apply softmax in our CNN\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=0.0005)\n",
    "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', verbose=True)\n",
    "\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the train loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A simple train loop that you can use. You can seperate different train and val functions also.\n",
    "def train(model, data_loader, criterion, optimizer, scheduler, num_epochs=25):\n",
    "    since = time.time()\n",
    "    \n",
    "    train_batch_loss = []\n",
    "    train_epoch_loss = []\n",
    "    val_epoch_loss = []\n",
    "    \n",
    "    for epoch in range(num_epochs):\n",
    "        print('Epoch {}/{}'.format(epoch+1, num_epochs))\n",
    "        print('-'*15)\n",
    "        \n",
    "        # You perform validation test after every epoch\n",
    "        for phase in ['train', 'val']:\n",
    "            if phase == 'train':\n",
    "                model.train()\n",
    "            else:\n",
    "                model.eval()\n",
    "                \n",
    "            for idx, (inputs, labels) in enumerate(data_loader[phase]):\n",
    "                inputs = inputs.to(device)\n",
    "                labels = labels.to(device)\n",
    "                \n",
    "                # zero accumulated gradients\n",
    "                optimizer.zero_grad()\n",
    "                \n",
    "                # During train phase we want to remember history for grads\n",
    "                # and during val we do not want history of grads\n",
    "                with torch.set_grad_enabled(phase == 'train'):\n",
    "                    outputs = model(inputs)\n",
    "                    loss = criterion(outputs, labels)\n",
    "                    \n",
    "                    _, preds = torch.max(outputs, 1)\n",
    "                    \n",
    "                    if idx%200 == 0:\n",
    "                        train_batch_loss.append(loss.item())\n",
    "                        print('Epoch {}: {}/{} step in progress'.format(epoch+1, idx, len(data_loader)))\n",
    "                        \n",
    "                    if phase == 'train':\n",
    "                        loss.backward()\n",
    "                        optimizer.step()\n",
    "                        \n",
    "                running_loss += loss.item() * inputs.size(0)\n",
    "                running_corrects += torch.sum(preds == labels.data)\n",
    "                \n",
    "            epoch_loss = running_loss / len(data_loader[phase].dataset)\n",
    "            epoch_acc = running_corrects.double() / len(data_loader[phase].dataset)\n",
    "            \n",
    "            print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))\n",
    "            \n",
    "            if phase == 'val':\n",
    "                val_epoch_loss.append((epoch_loss, epoch_acc))\n",
    "                scheduler.step(loss.item())\n",
    "            else:\n",
    "                train_epoch_loss.append((epoch_loss, epoch_acc))\n",
    "                \n",
    "        print()\n",
    "        \n",
    "    time_elapsed = time.time() - since\n",
    "    print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Checks to do"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Try to overfit a small mini-batch\n",
    "We do this step to check the capacity of our model. If our model is not able to overfit a small mini-batch it would not be able to generalize over the dataset. So if your model is not able to overfit, you should try checking the loss and criterion to see if you have made a mistake or not. If your model is still not able to overfit, then you have to change your model, by increasing the capacity the model.\n",
    "\n",
    "__Note__ :- Remember to reinitialize your weights after this step. Turn off regularization and use vanilla SGD. Here you should also avoid Dropout and other regularizations. But you can move without the previous step also."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1: Loss = 10.85702133178711 Accuracy = 0\n",
      "Epoch 11: Loss = 6.088886737823486 Accuracy = 0\n",
      "Epoch 21: Loss = 5.023783206939697 Accuracy = 2\n",
      "Epoch 31: Loss = 3.3892719745635986 Accuracy = 13\n",
      "Epoch 41: Loss = 3.0263545513153076 Accuracy = 11\n",
      "Epoch 51: Loss = 2.010768413543701 Accuracy = 19\n",
      "Epoch 61: Loss = 1.818111777305603 Accuracy = 20\n",
      "Epoch 71: Loss = 1.7510178089141846 Accuracy = 21\n",
      "Epoch 81: Loss = 1.2449636459350586 Accuracy = 23\n",
      "Epoch 91: Loss = 0.8979728817939758 Accuracy = 29\n",
      "Epoch 101: Loss = 1.0456411838531494 Accuracy = 26\n",
      "Epoch 111: Loss = 0.692730188369751 Accuracy = 30\n",
      "Epoch 121: Loss = 0.5408506393432617 Accuracy = 30\n",
      "Epoch 131: Loss = 0.4986892342567444 Accuracy = 30\n",
      "Epoch 141: Loss = 0.5481717586517334 Accuracy = 29\n",
      "Epoch 151: Loss = 0.47915372252464294 Accuracy = 30\n",
      "Epoch 161: Loss = 0.37656792998313904 Accuracy = 31\n",
      "Epoch 171: Loss = 0.354257732629776 Accuracy = 30\n",
      "Epoch 181: Loss = 0.4068177342414856 Accuracy = 31\n",
      "Epoch 191: Loss = 0.2683148980140686 Accuracy = 32\n"
     ]
    }
   ],
   "source": [
    "inputs, labels = next(iter(data_loader['train']))\n",
    "inputs = inputs.to(device)\n",
    "labels = labels.to(device)\n",
    "\n",
    "criterion_check1 = nn.CrossEntropyLoss()\n",
    "optimizer_check1 = optim.SGD(model.parameters(), lr=0.001)\n",
    "\n",
    "model.train()\n",
    "for epoch in range(200):\n",
    "    optimizer_check1.zero_grad()\n",
    "    outputs = model(inputs)\n",
    "    loss = criterion_check1(outputs, labels)\n",
    "    _, preds = torch.max(outputs, 1)\n",
    "    loss.backward()\n",
    "    optimizer_check1.step()\n",
    "    \n",
    "    if epoch%10 == 0:\n",
    "        print('Epoch {}: Loss = {} Accuracy = {}'.format(epoch+1, loss.item(), torch.sum(preds == labels)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model clearly overfitted out mini-batch of 32 training examples. So now we know our model is atleast capable of modeling this type of data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reinitialize weights\n",
    "conv_list = [0, 4, 8, 10, 12]\n",
    "fc_list = [1, 4, 6]\n",
    "for i in conv_list:\n",
    "    torch.nn.init.kaiming_normal_(model.conv_base[i].weight)\n",
    "for i in fc_list:\n",
    "    torch.nn.init.kaiming_normal_(model.fc_base[i].weight)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Double check loss\n",
    "In this step you check the loss values directly. This can give an intutition as to whether your model is correct or not. For example suppose we are doing binary classification, so on the first stpe seeing a loss of 2.3 is good but if you see a loss value of 100 then you can clearly see that there is something wrong. If you are seeing some large loss values you should double check your weight values or some connections in between which may be making your loss large.\n",
    "\n",
    "For our case, you can see the loss was 10.85 in the first step. Which is very good seeing that we have 1000 classes.\n",
    "\n",
    "__Note__ :- Do this step with regularization off then again do this step with regularization on. When there is regularization you would see a large loss value, due to the regularized terms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1: Loss = 11.014405250549316 Accuracy = 0\n"
     ]
    }
   ],
   "source": [
    "# Carrying over the above case with regularization on\n",
    "criterion_check1 = nn.CrossEntropyLoss()\n",
    "optimizer_check1 = optim.SGD(model.parameters(), lr=0.001, weight_decay=0.05)\n",
    "\n",
    "model.train()\n",
    "for epoch in range(1):\n",
    "    optimizer_check1.zero_grad()\n",
    "    outputs = model(inputs)\n",
    "    loss = criterion_check1(outputs, labels)\n",
    "    _, preds = torch.max(outputs, 1)\n",
    "    loss.backward()\n",
    "    optimizer_check1.step()\n",
    "    print('Epoch {}: Loss = {} Accuracy = {}'.format(epoch+1, loss.item(), torch.sum(preds == labels)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The loss is still ok as for 1000 classes with regularization it is still around 11. In case you are wondering that the loss values are still close to each other, remember that BatchNormalization and Dropout are also a form of regularization and we did not remove them in Check 1.\n",
    "\n",
    "So now we do a simple test by removing these layers from the model and comparing the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AlexNet_check(nn.Module):\n",
    "    def __init__(self, num_classes=1000):\n",
    "        super(AlexNet_check, self).__init__()\n",
    "        self.conv_base = nn.Sequential(\n",
    "            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2),\n",
    "#             nn.BatchNorm2d(96),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
    "            \n",
    "            nn.Conv2d(96, 256, kernel_size=5, stride=1, padding=2),\n",
    "#             nn.BatchNorm2d(256),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
    "            \n",
    "            nn.Conv2d(256, 384, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            \n",
    "            nn.Conv2d(384, 384, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            \n",
    "            nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
    "        )\n",
    "        self.fc_base = nn.Sequential(\n",
    "#             nn.Dropout(),\n",
    "            nn.Linear(256*6*6, 4096),\n",
    "            nn.ReLU(inplace=True),\n",
    "            \n",
    "#             nn.Dropout(),\n",
    "            nn.Linear(4096, 4096),\n",
    "            nn.ReLU(inplace=True),\n",
    "            \n",
    "            nn.Linear(4096, num_classes),\n",
    "        )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.conv_base(x)\n",
    "        x = x.view(x.size(0), 256*6*6)\n",
    "        x = self.fc_base(x)\n",
    "        return x\n",
    "    \n",
    "model_check2 = AlexNet_check()\n",
    "model_check2 = model_check2.to(device)\n",
    "\n",
    "# Initialize weights\n",
    "conv_list = [0, 3, 6, 8, 10]\n",
    "fc_list = [0, 2, 4]\n",
    "for i in conv_list:\n",
    "    torch.nn.init.kaiming_normal_(model_check2.conv_base[i].weight)\n",
    "for i in fc_list:\n",
    "    torch.nn.init.kaiming_normal_(model_check2.fc_base[i].weight)\n",
    "    \n",
    "criterion_check = nn.CrossEntropyLoss()\n",
    "optimizer_check = optim.Adam(model_check2.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1: Loss = 9.063738822937012 Accuracy = 0\n"
     ]
    }
   ],
   "source": [
    "model_check2.train()\n",
    "for epoch in range(1):\n",
    "    optimizer_check.zero_grad()\n",
    "    outputs = model(inputs)\n",
    "    loss = criterion_check(outputs, labels)\n",
    "    _, preds = torch.max(outputs, 1)\n",
    "    loss.backward()\n",
    "    optimizer_check.step()\n",
    "    print('Epoch {}: Loss = {} Accuracy = {}'.format(epoch+1, loss.item(), torch.sum(preds == labels)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see a small difference but this difference is not much significant due to random noise. But as the model size increases regularization becomes even more important and this difference becomes more significant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyperparameter optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An important step which can significantly imporve the accuracy of your model. There are 3 main methods to do hyperparameter optimization Grid Search, Random Search and Population based Training (PBT). PBT was released by Deepmind and it uses multiple GPUs to do the optimization. I have a single GPU, so we focus more on the other two options. Always prefer Random Search over Grid Search as you can get better results, by using less resources. There are bayesian methods also available. You can find libraries dedicated to hyperparameter optimization in PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When it comes to hyperparameter optimization you have to first do course and then fine optimization. By course and fine I am referring to the depth of the optimization. Suppose you want to tune your weight_decay. You choose some values, now rather than training long hours and seeing which values is best, you train only a few epochs with different weight decay values and see which is performing good. (You can do this by manually seeing the loss function). After selecting the better performing values, you now do a finer search where you train your model for more epochs and choose which value gives the best value. \n",
    "\n",
    "__Note__ :- If cost > 3*original_cost at any point break out early"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transfer learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To do transfer learning you have two options:-\n",
    "1. Finetuning -> Start with a pretrained model and learn all the weights again\n",
    "2. Feature extraction -> Start with a pretrained model and learn only the last FC layers.\n",
    "\n",
    "The conv_base in your model essentially learns to detect edges in the starting layers and then learns complex structures as the depth increases. In general these features are same across different datasets, so you don't have to always retrain this part. But in case you have to, use a small learning rate for the starting layers as detecting edges is same across different datasets and you don't want to loose your prior knowledge. \n",
    "\n",
    "The last FC layers are more concerned with optimizing the output according to our requirements. These layers are more dataset dependent and these layers must be learnt again, specific to your dataset. You should remove the last layer. In case of Imagenet models, the last layer is 1000 fully connected layer and you should remove this layer and create a new FC layer with the number of classes equal to number of classes in your dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([50000, 32, 32, 3])\n",
      "torch.Size([50000])\n",
      "torch.Size([10000, 32, 32, 3])\n",
      "torch.Size([10000])\n"
     ]
    }
   ],
   "source": [
    "data = np.load('../../../Data/cifar_10.npz')\n",
    "alexnet = torch.load('../../../Data/Pytorch Trained Models/alexnet.pth')\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "\n",
    "x_train = torch.from_numpy(data['train_data'])\n",
    "y_train = torch.from_numpy(data['train_labels'])\n",
    "x_test = torch.from_numpy(data['test_data'])\n",
    "y_test = torch.from_numpy(data['test_labels'])\n",
    "\n",
    "print(x_train.shape)\n",
    "print(y_train.shape)\n",
    "print(x_test.shape)\n",
    "print(y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create data loader\n",
    "class CIFAR_Dataset(torch.utils.data.Dataset):\n",
    "    \"\"\"\n",
    "    Generally you would not load images in the __init__ as it forces the images\n",
    "    to load into memory. Instead you should load the images in getitem function,\n",
    "    but as CIFAR is small dataset I load all the images in memory.\n",
    "    \"\"\"\n",
    "    def __init__(self, x, y, transform=None):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.transform = transform\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.x.size(0)\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        image =  self.x[idx]\n",
    "        label = self.y[idx].item()\n",
    "        \n",
    "        if self.transform:\n",
    "            image = self.transform(image)\n",
    "        return (image, label)\n",
    "            \n",
    "data_transforms = transforms.Compose([\n",
    "    transforms.ToPILImage(),\n",
    "    transforms.Resize((224, 224)),\n",
    "    transforms.Resize(224),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n",
    "])\n",
    "\n",
    "datasets = {\n",
    "    'train': CIFAR_Dataset(x_train, y_train, transform=data_transforms),\n",
    "    'test': CIFAR_Dataset(x_test, y_test, transform=data_transforms)\n",
    "}\n",
    "\n",
    "data_loader = {\n",
    "    x: torch.utils.data.DataLoader(datasets[x],\n",
    "                                   batch_size=64,\n",
    "                                   shuffle=True,\n",
    "                                   num_workers=8) for x in ['train', 'test']\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Freeze conv layers\n",
    "for param in alexnet.parameters():\n",
    "    param.requires_grad = False\n",
    "    \n",
    "# Initialize the last layer of alexnet model for out 10 class dataset\n",
    "alexnet.classifier[6] = nn.Linear(4096, 10)\n",
    "alexnet = alexnet.to(device)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "# Create list of params to learn\n",
    "params_to_learn = []\n",
    "for name,param in alexnet.named_parameters():\n",
    "    if param.requires_grad == True:\n",
    "        params_to_learn.append(param)\n",
    "        \n",
    "optimizer = optim.SGD(params_to_learn, lr=0.001, momentum=0.9, nesterov=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0. Loss: 2.2627 Acc: 0.2076\n",
      "1. Loss: 2.1685 Acc: 0.2054\n",
      "2. Loss: 2.0822 Acc: 0.2573\n",
      "3. Loss: 2.1001 Acc: 0.2472\n",
      "4. Loss: 2.1214 Acc: 0.2412\n",
      "5. Loss: 2.1106 Acc: 0.2499\n",
      "6. Loss: 2.0988 Acc: 0.2429\n",
      "7. Loss: 2.0620 Acc: 0.2702\n",
      "8. Loss: 2.1272 Acc: 0.2409\n",
      "9. Loss: 2.0644 Acc: 0.2502\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-6-fd9794967be4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_loader\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'train'\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      6\u001b[0m         \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\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----> 7\u001b[0;31m         \u001b[0minputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\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      8\u001b[0m         \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Train the model\n",
    "for epoch in range(20):\n",
    "    # Train phase\n",
    "    alexnet.train()\n",
    "    for idx, (inputs, labels) in enumerate(data_loader['train']):\n",
    "        optimizer.zero_grad()\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "        \n",
    "        output = alexnet(inputs)\n",
    "        loss = criterion(output, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "    \n",
    "    # Val phase\n",
    "    alexnet.eval()\n",
    "    running_loss = 0.0\n",
    "    running_corrects = 0\n",
    "    for inputs, labels in data_loader['test']:\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "        \n",
    "        with torch.set_grad_enabled(False):\n",
    "            output = alexnet(inputs)\n",
    "            loss = criterion(output, labels)\n",
    "            \n",
    "            _, preds = torch.max(output, 1)\n",
    "            running_loss += loss.item() * inputs.size(0)\n",
    "            running_corrects += torch.sum(preds == labels.data)\n",
    "            \n",
    "    epoch_loss = running_loss / len(data_loader['test'].dataset)\n",
    "    epoch_acc = running_corrects.double() / len(data_loader['test'].dataset)\n",
    "    \n",
    "    print('{}. Loss: {:.4f} Acc: {:.4f}'.format(epoch, epoch_loss, epoch_acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}