Labs/Lab 7 - Neural Networks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 7: Convolutional Neural Networks for Image Classification\n",
    "[**Haiping Lu**](http://staffwww.dcs.shef.ac.uk/people/H.Lu/) -  [COM4509/6509 MLAI2021](https://github.com/maalvarezl/MLAI) @ The University of Sheffield\n",
    "\n",
    "**Accompanying lectures**: [YouTube video lectures recorded in Year 2020/21.](https://www.youtube.com/watch?v=SHw_a3YGwZQ&list=PLuRoUKdWifzxmvxhjjFztwY1kbfp8Pav6)\n",
    "\n",
    "**Sources**: This notebook is based on [the CIFAR10 Pytorch tutorial](https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py), [the CNN notebook from Lisa Zhang](https://www.cs.toronto.edu/~lczhang/360/lec/w04/convnet.html), and Lab 2 and Lab 3 of my [SimplyDeep](https://github.com/haipinglu/SimplyDeep/) notebooks.\n",
    "\n",
    "There are *seven* questions in this notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objective\n",
    "\n",
    "* To perform image classification using convolutional neural network in PyTorch.\n",
    "\n",
    "**Suggested reading**: \n",
    "* [Autograd tutorial](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html#sphx-glr-beginner-blitz-autograd-tutorial-py)\n",
    "* [Convolutional neural network - Wikipedia](https://en.wikipedia.org/wiki/Convolutional_neural_network)\n",
    "* [Feature/representation learning - Wikipedia](https://en.wikipedia.org/wiki/Feature_learning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why\n",
    "\n",
    "The fast rising of [deep learning](https://en.wikipedia.org/wiki/Deep_learning) starts on 30 September 2012, when a convolutional neural network (CNN) called [AlexNet](https://en.wikipedia.org/wiki/AlexNet) achieved a top-5 error of 15.3% in the ImageNet 2012 Challenge, more than **10.8 percentage** points lower than that of the runner up. This is considered a breakthrough and has grabbed the attention of increasing number of researchers, practioners, and the general public. Since then, deep learning has penetrated to many research and application areas. AlexNet contained **eight layers**. In 2015, it was outperformed by a very deep CNN with **over 100 layers** from Microsoft in the ImageNet 2015 contest. It will be interesting to take a look at the image classification task and a CNN that can do the job well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Review of Autograd: Automatic Differentiation\n",
    "\n",
    "In the previous lab, we briefly covered **Tensor** and **Computational Graph**. We have actually used **Autograd** already. Here, we learn the basics below, a condensed and modified version of the original [PyTorch tutorial on Autograd](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html#sphx-glr-beginner-blitz-autograd-tutorial-py)\n",
    "\n",
    "#### Why differentiation is important? \n",
    "\n",
    "This is because it is a key procedure in **optimisation** to find the optimial solution of a loss function. The process of learning/training aims to minimise a predefined loss.\n",
    "\n",
    "#### How automatic differentiation is done in PyTorch?\n",
    "The PyTorch ``autograd`` package makes differentiation (almost) transparent to you by providing automatic differentiation for all operations on Tensors, unless you do not want it (to save time and space). \n",
    "\n",
    "A ``torch.Tensor`` type variable has an attribute ``.requires_grad``. Setting this attribute ``True`` tracks (but not computes yet) all operations on it. After we define the forward pass, and hence the *computational graph*, we call ``.backward()`` and all the gradients will be computed automatically and accumulated into the ``.grad`` attribute. \n",
    "\n",
    "This is made possible by the [**chain rule of differentiation**](https://en.wikipedia.org/wiki/Chain_rule).\n",
    "\n",
    "#### How to stop automatic differentiation (e.g., because it is not needed)\n",
    "Calling method ``.detach()`` of a tensor will detach it from the computation history. We can also wrap the code block in ``with torch.no_grad():`` so all tensors in the block do not track the gradients, e.g., in the test/evaluation stage. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Question 1\n",
    "\n",
    "What is the benefit of stopping automatic differentiation when it is not needed?\n",
    "\n",
    "**Answer**: \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Function\n",
    "\n",
    "``Tensor``s are connected by ``Function`` to build an acyclic *computational graph* to encode a complete history of computation. The ``.grad_fn`` attribute of a tensor references a ``Function`` created\n",
    "the ``Tensor``, i.e., this ``Tensor`` is the output of its ``.grad_fn`` in the computational graph.\n",
    "\n",
    "Learn more about autograd by referring to the [documentation on autograd](https://pytorch.org/docs/stable/autograd.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Load the Image Data - CIFAR10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Libraries \n",
    "\n",
    "Get ready by importing commonly used APIs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import torchvision\n",
    "from torchvision import datasets, transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data\n",
    "The [CIFAR10 dataset](https://www.cs.toronto.edu/~kriz/cifar.html) has ten classes: ‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’. The images in CIFAR-10 are of size 3x32x32, i.e. 3-channel color images of 32x32 pixels in size.\n",
    "\n",
    "#### Loading and normalizing CIFAR10\n",
    "\n",
    "The output of torchvision datasets (after loading) are PILImage images of range [0, 1]. \n",
    "\n",
    "Check out the `torchvision.transforms` API for [here](https://pytorch.org/docs/stable/torchvision/transforms.html) (search for `ToTensor` and `Normalize`).\n",
    "\n",
    "`transforms.ToTensor()` Convert a `PIL` Image or `numpy.ndarray` (H x W x C) in the range [0, 255]  to torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0].\n",
    "\n",
    "`transforms.Normalize` normalizes a tensor image with mean and standard deviation. Given mean: ($M1,...,Mn$) and std: ($S1,..,Sn$) for $n$ channels, this transform will normalize each channel of the input `torch.*Tensor` as $input[channel] = (input[channel] - mean[channel]) / std[channel]$\n",
    "\n",
    "`torch.utils.data.DataLoader` combines a dataset and a sampler, and provides an iterable over the given dataset. See [API here](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader)\n",
    "\n",
    "#### Batching\n",
    "\n",
    "We want to use more than one images at one time. That way, we can compute the *average* loss across a **mini-batch** of $n$ *multiple* images, and take a step to optimize the *average* loss. The average loss across multiple training inputs is going to be **less \"noisy\"** than the loss for a single input, and is less likely to provide \"bad information\" because of a \"bad\" input. The number $n$ is called the **batch size**.\n",
    "\n",
    "The actual batch size that we choose depends on many things. We want our batch\n",
    "size to be large enough to not be too \"noisy\", but not so large as to make each\n",
    "iteration too expensive to run.\n",
    "\n",
    "People often choose batch sizes of the form $n=2^k$ so that it is easy to half\n",
    "or double the batch size. \n",
    "\n",
    "####  Epoch\n",
    "The way `DataLoader` works is that it randomly groups the training data into **mini-batches**\n",
    "with the appropriate batch size. Each data point belongs to only one mini-batch. When there\n",
    "are no more mini-batches left, the loop terminates.\n",
    "\n",
    "In general, we may wish to train the network for longer. We may wish to use each training data\n",
    "point more than once. In other words, we may wish to train a neural network for more than\n",
    "**one epoch**. An **epoch** is a measure of the number of times all training data is used\n",
    "once to update the parameters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data\\cifar-10-python.tar.gz\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f8996b4a2c044f21989377543fd9eb3d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=170498071.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Extracting ./data\\cifar-10-python.tar.gz to ./data\n",
      "Files already downloaded and verified\n",
      "Training set size: 50000\n",
      "Test set size: 10000\n"
     ]
    }
   ],
   "source": [
    "batchSize=4\n",
    "transform = transforms.Compose([transforms.ToTensor(),\n",
    "                                transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
    "#Load the training data\n",
    "trainset = datasets.CIFAR10(root='./data', train=True,\n",
    "                                        download=True, transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batchSize,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "#Load the test data\n",
    "testset = datasets.CIFAR10(root='./data', train=False,\n",
    "                                       download=True, transform=transform)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=batchSize, \n",
    "                                         shuffle=False, num_workers=2)\n",
    "\n",
    "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
    "print('Training set size:', len(trainset))\n",
    "print('Test set size:',len(testset))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the data has been downloaded at the `data` directory. Because the filesize is large, we do not upload it to GitHub."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dataset CIFAR10\n",
       "    Number of datapoints: 50000\n",
       "    Root location: ./data\n",
       "    Split: Train\n",
       "    StandardTransform\n",
       "Transform: Compose(\n",
       "               ToTensor()\n",
       "               Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))\n",
       "           )"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dataset CIFAR10\n",
       "    Number of datapoints: 10000\n",
       "    Root location: ./data\n",
       "    Split: Test\n",
       "    StandardTransform\n",
       "Transform: Compose(\n",
       "               ToTensor()\n",
       "               Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))\n",
       "           )"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "testset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### View the images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " frog   cat  frog  frog\n"
     ]
    }
   ],
   "source": [
    "# functions to show an image\n",
    "def imshow(img):\n",
    "    img = img / 2 + 0.5     # unnormalize back to range [0, 1]\n",
    "    npimg = img.numpy()\n",
    "    plt.imshow(np.transpose(npimg, (1, 2, 0))) #rearrange dimensions to numpy format for disply\n",
    "    plt.show()\n",
    "\n",
    "# get some random training images\n",
    "dataiter = iter(trainloader)\n",
    "images, labels = dataiter.next() #Get one batch (4 here)\n",
    "\n",
    "# show images\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "# print labels\n",
    "print(' '.join('%5s' % classes[labels[j]] for j in range(batchSize)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Define the Architecture of a Convolutional Neural Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A typical CNN architecture:\n",
    "\n",
    "![Typical CNN architecture](https://upload.wikimedia.org/wikipedia/commons/6/63/Typical_cnn.png)\n",
    "\n",
    "Let us look at the CNN in detail."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convolution layer - with a shared kernel/filter\n",
    "<center>\n",
    "<img src=\"https://www.cs.toronto.edu/~lczhang/360/lec/w04/imgs/math_kernel.png\" width=\"100px\" style=\"margin:0; display:inline\">\n",
    "<img src=\"https://www.cs.toronto.edu/~lczhang/360/lec/w04/imgs/math_conv.png\" width=\"300px\" style=\"margin:0; display:inline\">\n",
    "</center>\n",
    "\n",
    "The light blue grid (middle) is the *input* that we are given, e.g., a 5 pixel by 5 pixel greyscale image. The grey grid (left) is a **convolutional kernel/filter** of size $3 \\times 3$, containing the *parameters* of this neural network layer.\n",
    "\n",
    "To compute the output, we superimpose the kernel on a region of the image. \n",
    "Let's start at the top left, in the dark blue region. The small numbers in the\n",
    "bottom right corner of each grid element corresponds to the number in the kernel.\n",
    "To compute the output at the corresponding location (top left), we \"dot\" the\n",
    "pixel intensities in the square region with the kernel. That is, we perform\n",
    "the computation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(3 * 0 + 3 * 1 + 2 * 2) + (0 * 2 + 0 * 2 + 1 * 0) + (3 * 0 + 1 * 1 + 2 * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The green grid (right) contains the *output* of this convolution layer.\n",
    "This output is also called an **output feature map**. The terms **feature**,\n",
    "and **activation** are interchangable. The output value on the top left\n",
    "of the green grid is consistent with the value we obtained by hand in Python.\n",
    "\n",
    "To compute the next activation value (say, one to the right of the previous output),\n",
    "we will shfit the superimposed kernel over by one pixel:\n",
    "\n",
    "<img src=\"https://www.cs.toronto.edu/~lczhang/360/lec/w04/imgs/math_conv2.png\" width=\"300px\">\n",
    "\n",
    "The dark blue region is moved to the right by one pixel. We again dot\n",
    "the pixel intensities in this region with the kernel to get another 12, and continues to get 17, ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Question 2\n",
    "\n",
    "Show how we get the value 19 in the output above (in cyan on the right of the figure in this section).\n",
    "\n",
    "**Answer**: \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note the shrinked output**: Here, we did not use **zero padding** (at the edges) so the output of this layers is shrinked by 1 on all sides. If the kernel size is $k=2m+1$, the output will be shrinked by $m$ on all sides so the width and height will be both reduced by $2m$.\n",
    "\n",
    "#### Convolutions with Multiple Input/Output Channels\n",
    "\n",
    "For a colour image, the kernel will be a **3-dimensional tensor**. This kernel will move through the input features just like before, and we \"dot\" the pixel intensities with the kernel at each region, exactly like before. This \"size of the 3rd (colour) dimension\" is called the **number of input channels** or **number of input feature maps**.\n",
    "\n",
    "We also want to detect multiple features, e.g., both horizontal edges and vertical edges. We would want to learn **many** convolutional filters on the same input. That is,\n",
    "we would want to make the same computation above using different kernels, like this:\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/6/68/Conv_layer.png\" width=\"200px\">\n",
    "\n",
    "Each circle on the right of the image represents the output of a different kernel dotted\n",
    "with the highlighted region on the right. So, the output feature is also a 3-dimensional tensor.\n",
    "The size of the new dimension\n",
    "is called the **number of output channels** or **number of output feature maps**.\n",
    "In the picture above, there are 5 output channels.\n",
    "\n",
    "The `conv2D` layer expects as input a tensor in the format \"NCHW\", meaning that the dimensions of the tensor should follow the order:\n",
    "\n",
    "* batch size\n",
    "* channel\n",
    "* height\n",
    "* width\n",
    "\n",
    "Let us create a convolutional layer using `nn.Conv2d`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "myconv1 = nn.Conv2d(in_channels=3,  # number of input channels\n",
    "                 out_channels=7, # number of output channels\n",
    "                 kernel_size=5)  # size of the kernel, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([32, 7, 124, 124])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Emulate a batch of 32 colour images, each of size 128x128, like this:\n",
    "x = torch.randn(32, 3, 128, 128)\n",
    "y = myconv1(x)\n",
    "y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output tensor is also in the \"NCHW\" format. We still have 32 images, and 7 channels\n",
    "(consistent with `out_channels` of `conv`), and of size 124x124. If we added the appropriate\n",
    "padding to `conv`, namely `padding` = $m$ (the kernel_size: $2m+1$), then our output width and height should be consistent with the input width and height:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([32, 7, 128, 128])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myconv2 = nn.Conv2d(in_channels=3,\n",
    "                  out_channels=7,\n",
    "                  kernel_size=5,\n",
    "                  padding=2)\n",
    "\n",
    "x = torch.randn(32, 3, 128, 128)\n",
    "y = myconv2(x)\n",
    "y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The parameters of `Conv2d`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len(conv_params): 2\n",
      "Filters: torch.Size([7, 3, 5, 5])\n",
      "Biases: torch.Size([7])\n"
     ]
    }
   ],
   "source": [
    "conv_params = list(myconv2.parameters())\n",
    "print(\"len(conv_params):\", len(conv_params))\n",
    "print(\"Filters:\", conv_params[0].shape)  #7 filters, each of size 3 x 5 x 5\n",
    "print(\"Biases:\", conv_params[1].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pooling Layers - Subsampling\n",
    "\n",
    "A pooling layer can be created like this: \n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/e/e9/Max_pooling.png\" width=\"300px\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([32, 7, 64, 64])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mypool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "y = myconv2(x)\n",
    "z = mypool(y)\n",
    "z.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usually, the kernel size and the stride length will be equal so each pixel is pooled only once. \n",
    "The pooling layer has **no trainable parameters**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(mypool.parameters())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Lab 6, we did not define a class for our linear regression NN. Here we do so and define a CNN class consisting of several layers as defined below (from the official the Pytorch tutorial)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(CNN, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(3, 6, 5) #3: #input channels; 6: #output channels; 5: kernel size\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
    "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
    "        self.fc2 = nn.Linear(120, 84)\n",
    "        self.fc3 = nn.Linear(84, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.pool(F.relu(self.conv1(x)))\n",
    "        x = self.pool(F.relu(self.conv2(x)))\n",
    "        x = x.view(-1, 16 * 5 * 5)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "myCNN = CNN()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`__init__()` defines the layers.  `forward()` defines the *forward pass* that transform the input to the output. `backward()` is automatically defined using `autograd`. `ReLu()` is the [rectified linear unit](https://en.wikipedia.org/wiki/Rectifier_(neural_networks)), a popular **activation function** that performs a *nonlinear* transformation/mapping of an input variable (element-wise operation). `Conv2d()` defines a convolution layer, as shown below where blue maps indicate inputs, and cyan maps indicate outputs.\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "    <td  style=\"text-align: left\"> Convolution with no padding, no strides.      <img src=\"https://raw.githubusercontent.com/vdumoulin/conv_arithmetic/master/gif/no_padding_no_strides.gif\" alt=\"Drawing\" style=\"width: 250px;\"/> </td>\n",
    "</tr>\n",
    "</table>\n",
    "\n",
    "More convolution layers are illustrated nicely at [Convolution arithmetic](https://github.com/vdumoulin/conv_arithmetic). \n",
    "\n",
    "\n",
    "This network `CNN()` defined above has **two** convolutional layers: `conv1` and `conv2`.\n",
    "\n",
    "- The first convolutional layer `conv1` requires an input with 3 channels,\n",
    "  outputs **6 channels**, and has a kernel size of `5x5`. We are not adding any zero-padding.\n",
    "- The second convolutional layer `conv2` requires an input with **6 channels** (note this **MUST match the output channel number of the previous layer**),  outputs 16 channels, and has a kernel size of (again) `5x5`. We are not adding any zero-padding.\n",
    "\n",
    "In the `forward` function we see that the convolution operations are always \n",
    "followed by the usual ReLU activation function, and a pooling operation.\n",
    "The pooling operation used is max pooling, so each pooling operation\n",
    "**reduces the width and height of the neurons in the layer by half**.\n",
    "\n",
    "\n",
    "\n",
    "Because we are not adding any zero padding, we end up with `16 * 5 * 5` hidden units\n",
    "after the second convolutional layer (`16` matches the output channel number of `conv2`, `5 * 5` is based on the input dimension `32x32`, see below). These units are then passed to two fully-connected\n",
    "layers, with the usual ReLU activation in between.\n",
    "\n",
    "Notice that the number of channels **grew** in later convolutional layers! However,\n",
    "the number of hidden units in each layer is still reduced because of the convolution and pooling operation:\n",
    "\n",
    "* Initial Image Size: $3 \\times 32 \\times 32 $\n",
    "* After `conv1`: $6 \\times 28 \\times 28$ ($32 \\times 32$ is reduced by `2` on each side)\n",
    "* After Pooling: $6 \\times 14 \\times 14 $ (image size halved)\n",
    "* After `conv2`: $16 \\times 10 \\times 10$ ($14 \\times 14$ is reduced by `2` on each side)\n",
    "* After Pooling: $16 \\times 5 \\times 5 $ (halved)\n",
    "* After `fc1`: $120$\n",
    "* After `fc2`: $84$\n",
    "* After `fc3`: $10$ (**= number of classes**)\n",
    "\n",
    "This pattern of **doubling the number of channels with every pooling / strided convolution**\n",
    "is common in modern convolutional architectures. It is used to avoid loss of too much information within\n",
    "a single reduction in resolution.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Question 3\n",
    "\n",
    "If the input image size is $3 \\times 64 \\times 64 $, can we use the same CNN defined above? If yes, show the feature sizes after each operation as above. If no, how shall we modify the network architecture to process such $3 \\times 64 \\times 64 $ images?\n",
    "\n",
    "**Answer**: \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inspect the NN architecture\n",
    "\n",
    "Now let's take a look at the CNN built. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CNN(\n",
      "  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
      "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
      "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(myCNN)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us check the (randomly initialised) parameters of this NN. Below, we check the first 2D convolution. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "torch.Size([6, 3, 5, 5])\n",
      "torch.Size([6])\n",
      "Parameter containing:\n",
      "tensor([-0.0076, -0.0963,  0.1009,  0.0014, -0.1064, -0.0263],\n",
      "       requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "params = list(myCNN.parameters())\n",
    "print(len(params))\n",
    "print(params[0].size())  # First Conv2d's .weight\n",
    "print(params[1].size())  # First Conv2d's .bias\n",
    "print(params[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Question 4\n",
    "\n",
    "From the above, we can see the length of `params` is 10, i.e. there are 10 sets of parameters. Set 0 is for the weights of `conv1`. Set 1 is the bias of `conv1`. What are the remaining 8 sets for?\n",
    "\n",
    "**Answer**: \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To learn more about these functions, refer to the [`torch.nn` documentation](https://pytorch.org/docs/stable/nn.html) (search for the function, e.g., search for `torch.nn.ReLu` and you will find its documentation [here](https://pytorch.org/docs/stable/nn.html?highlight=relu#torch.nn.ReLU)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Optimisation, Training and Testing\n",
    "\n",
    "### Choose a criterion (cross-entropy loss) and an optimizer (SGD with momentum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(myCNN.parameters(), lr=0.001, momentum=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the network\n",
    "\n",
    "Next, we will feed data to this CNN to train it, i.e., learn its parameters so that the criterion above (cross-entropy loss) is minimised, using the SGD optimiser. The dataset is loaded in batches to train the model. One `epoch` means one cycle through the full training dataset.  The steps are \n",
    "* Define the optimisation criterion and optimisation method.\n",
    "* Iterate through the whole dataset in batches, for a number of `epochs` till a maximum specified or a convergence criteria (e.g., successive change of loss < 0.000001)\n",
    "* In each batch processing, we \n",
    "    * do a forward pass\n",
    "    * compute the loss\n",
    "    * backpropagate the loss via `autograd`\n",
    "    * update the parameters\n",
    "\n",
    "Now, we loop over our data iterator, and feed the inputs to the network and optimize. Here, I set `max_epochs` to 2 for quick testing. In practice, more epochs typically lead to better performance. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1,  2000] loss: 2.224\n",
      "[1,  4000] loss: 1.870\n",
      "[1,  6000] loss: 1.661\n",
      "[1,  8000] loss: 1.580\n",
      "[1, 10000] loss: 1.520\n",
      "[1, 12000] loss: 1.453\n",
      "[2,  2000] loss: 1.402\n",
      "[2,  4000] loss: 1.375\n",
      "[2,  6000] loss: 1.358\n",
      "[2,  8000] loss: 1.338\n",
      "[2, 10000] loss: 1.326\n",
      "[2, 12000] loss: 1.291\n",
      "Finished Training!\n"
     ]
    }
   ],
   "source": [
    "max_epochs=2\n",
    "for epoch in range(max_epochs):  # loop over the dataset multiple times\n",
    "\n",
    "    running_loss = 0.0\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        # get the inputs; data is a list of [inputs, labels]\n",
    "        inputs, labels = data\n",
    "\n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward + backward + optimize\n",
    "        outputs = myCNN(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # print statistics\n",
    "        running_loss += loss.item()\n",
    "        if i % 2000 == 1999:    # print every 2000 mini-batches\n",
    "            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 2000))\n",
    "            running_loss = 0.0\n",
    "\n",
    "print('Finished Training!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Take a look at how `autograd` keeps track of the gradients for back propagation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<NllLossBackward0 object at 0x0000027A8E6FF850>\n",
      "<LogSoftmaxBackward0 object at 0x0000027A8E6FFB20>\n"
     ]
    }
   ],
   "source": [
    "print(loss.grad_fn)\n",
    "print(loss.grad_fn.next_functions[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save our trained model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH = 'data/cifar_net.pth'\n",
    "torch.save(myCNN.state_dict(), PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See [here](https://pytorch.org/docs/stable/notes/serialization.html)\n",
    "for more details on saving PyTorch models.\n",
    "\n",
    "### Test the network on the test data\n",
    "\n",
    "We will test the trained network by predicting the class label that the neural network outputs, and checking it against the ground-truth. Okay, first step. Let us display an image from the test set to get familiar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GroundTruth:    cat  ship  ship plane\n"
     ]
    }
   ],
   "source": [
    "dataiter = iter(testloader)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "# print images\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(batchSize)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's load back in our saved model (note: saving and re-loading wasn't necessary here, we only did it for illustration):\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loadCNN = CNN()\n",
    "loadCNN.load_state_dict(torch.load(PATH))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, now let us see what the neural network thinks these examples above are:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "outputs = loadCNN(images)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The outputs are energies for the 10 classes.\n",
    "The higher the energy for a class, the more the network\n",
    "thinks that the image is of the particular class.\n",
    "So, let's get the index of the highest energy:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted:    cat  ship  ship  ship\n"
     ]
    }
   ],
   "source": [
    "_, predicted = torch.max(outputs, 1)\n",
    "\n",
    "print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(batchSize)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How accurate do you get? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Question 5\n",
    "\n",
    "Note that the results are *random* because the batches are randomly formed. How to fix the randomness so that you can get the same results if you run your code multiple times? \n",
    "\n",
    "**Answer**: \n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us look at how the network performs on the whole dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on the 10000 test images: 54 %\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():  #testing phase, no need to compute the gradients to save time\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        outputs = loadCNN(images)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should get something around 50%. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Question 6\n",
    "\n",
    "What is the **chance level** accuracy (i.e. random classification)? How good is your CNN accuracy compared to the chance level?\n",
    "\n",
    "**Answer**: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If your network works better than chance, it seems like to have learnt something.\n",
    "\n",
    "Hmmm, what are the classes that performed well, and the classes that did not perform well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of plane : 66 %\n",
      "Accuracy of   car : 56 %\n",
      "Accuracy of  bird : 45 %\n",
      "Accuracy of   cat : 37 %\n",
      "Accuracy of  deer : 38 %\n",
      "Accuracy of   dog : 36 %\n",
      "Accuracy of  frog : 65 %\n",
      "Accuracy of horse : 76 %\n",
      "Accuracy of  ship : 74 %\n",
      "Accuracy of truck : 51 %\n"
     ]
    }
   ],
   "source": [
    "class_correct = list(0. for i in range(10))\n",
    "class_total = list(0. for i in range(10))\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        outputs = loadCNN(images)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        c = (predicted == labels).squeeze()\n",
    "        for i in range(batchSize):\n",
    "            label = labels[i]\n",
    "            class_correct[label] += c[i].item()\n",
    "            class_total[label] += 1\n",
    "\n",
    "\n",
    "for i in range(10):\n",
    "    print('Accuracy of %5s : %2d %%' % (classes[i], 100 * class_correct[i] / class_total[i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Question 7\n",
    "\n",
    "Run a [digits domain adaption / transfer learning example in Google Colab](https://colab.research.google.com/github/pykale/pykale/blob/main/examples/digits_dann_lightn/tutorial.ipynb) using the default hardware (CPU) and then using GPU (see the instruction in the notebook) to compare the difference in running time. Increase to max 10 epochs or more to see the difference again.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Additional ideas to explore\n",
    "\n",
    "* Change the [loss function](https://pytorch.org/docs/stable/nn.html#loss-functions) to different choices and compare the results.\n",
    "* Train the network for more passes (epochs) and/or other training settings (e.g., other patch sizes) to study performance variations.\n",
    "* Practice change the CNN architecture (pay attention to the size matching between different layers).\n",
    "* Try on GPU if you have one by following the end of the [the CIFAR10 Pytorch tutorial](https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py).\n",
    "* Try out the AlexNet `torchvision.models.alexnet` and other architectures from `torchvision.models` for image classification\n",
    "* Try out other pytorch computer vision datasets `torchvision.datasets` for image classification. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}