0. PyTorch Basics (tuto from the website).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we will work on the PyTorch [first tutorial](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html) without considering GPU related stuff since I don't have one. Mainly we will cover the following topics :\n",
    "\n",
    "* Tensors and Autograd\n",
    "* Defining a neural network, a loss, an optimizer\n",
    "* Defining and training a neural network on an image classification task"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. [What is PyTorch ?](https://pytorch.org/tutorials/beginner/blitz/tensor_tutorial.html#sphx-glr-beginner-blitz-tensor-tutorial-py)\n",
    "### 1.1 Tensors\n",
    "\n",
    "Tensors are similar to numpy ndarrays, with the addition being that they can be used on GPUs to accelerate computing. They are multi dimensional matrices containing elements of a single data type. One can create tensors with different initalizations (zeros, random, empty tensor, from array value) or from another tensor (the source tensors properties will be reused unless they are overriden). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[9.8091e-45, 0.0000e+00],\n",
      "        [0.0000e+00, 0.0000e+00],\n",
      "        [0.0000e+00, 0.0000e+00]])\n",
      "tensor([[0, 0],\n",
      "        [0, 0],\n",
      "        [0, 0]])\n",
      "tensor([[1, 1],\n",
      "        [1, 1],\n",
      "        [1, 1]])\n",
      "tensor([[0.4124, 0.2444],\n",
      "        [0.8935, 0.9392],\n",
      "        [0.6305, 0.9676]])\n",
      "tensor([[-0.5739,  1.0469],\n",
      "        [ 0.8922, -0.6686],\n",
      "        [-1.2772, -0.5704]])\n"
     ]
    }
   ],
   "source": [
    "test_size = (3, 2)\n",
    "\n",
    "x = torch.empty(test_size) #empty initialization\n",
    "print(x)\n",
    "\n",
    "x = torch.zeros(test_size, dtype=torch.long) #zeros with specified dtype\n",
    "print(x)\n",
    "x = x.new_ones(test_size) #ones with dtype and device coming from the original tensor\n",
    "print(x)\n",
    "\n",
    "x = torch.rand(test_size) #random initialization\n",
    "print(x)\n",
    "x = torch.randn_like(x, dtype=torch.float) #random with the same size as the original tensor\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Operations\n",
    "\n",
    "Operations between tensors can be written in different ways. They also can be done in place or create a new result tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.5046,  1.2974],\n",
      "        [ 1.4541, -0.0604],\n",
      "        [-1.2025, -0.1590]])\n",
      "tensor([[-1.0785,  2.3443],\n",
      "        [ 2.3463, -0.7289],\n",
      "        [-2.4797, -0.7295]])\n",
      "tensor([[-1.0785,  2.3443],\n",
      "        [ 2.3463, -0.7289],\n",
      "        [-2.4797, -0.7295]])\n",
      "tensor([[-1.0785,  2.3443],\n",
      "        [ 2.3463, -0.7289],\n",
      "        [-2.4797, -0.7295]])\n"
     ]
    }
   ],
   "source": [
    "y = torch.rand(test_size)\n",
    "\n",
    "#Any operation that mutates a tensor in-place is post-fixed with an _\n",
    "y.add_(x)\n",
    "print(y)\n",
    "\n",
    "#Provide result tensor\n",
    "result = torch.empty(test_size) \n",
    "torch.add(x,y, out = result)\n",
    "print(result)\n",
    "\n",
    "result = x + y #Basic syntax 1\n",
    "print(result)\n",
    "\n",
    "result = torch.add(x,y) #Basic syntax 2\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also reshape tensors and slice them as in numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 1.4541, -0.0604])\n",
      "tensor([ 1.2974, -0.0604, -0.1590])\n",
      "tensor([-0.5046,  1.2974,  1.4541, -0.0604, -1.2025, -0.1590])\n",
      "tensor([[-0.5046,  1.2974,  1.4541],\n",
      "        [-0.0604, -1.2025, -0.1590]])\n"
     ]
    }
   ],
   "source": [
    "# Indexing\n",
    "print(y[1,:])\n",
    "print(y[:,1])\n",
    "\n",
    "# Reshaping\n",
    "z = y.view(6)\n",
    "print(z)\n",
    "z = y.view(-1, 3) #-1 infers the dimension\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. [Autograd : automatic differentiation](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"The autograd package provides automatic differentiation for all operations on Tensors. It is a define-by-run framework, which means that your backprop is defined by how your code is run, and that every single iteration can be different.\" There are several attributes of the tensor objects that we will examine here :\n",
    "\n",
    "* **.requires_grad** : \n",
    "\n",
    "A boolean that indicates if we want to start tracking computations on the tensor in order to be able to compute gradients; *if a tensor is a result of an operation applied on other tensors, it will have requires_grad = True if at least one of the original tensors as requires_grad = True*\n",
    "* **.grad_fn** : \n",
    "\n",
    "References a *Function* object which is the operation that created the tensor (if we don't track the gradient this will be None)\n",
    "* **.is_leaf** : \n",
    "\n",
    "A boolean indicating if the tensor is a leaf of the computational graph; a leaf variable is at the beginning of the graph so *it was not created by an autograd-tracked operation*. By default, gradients are only retained for leaf variables; non-leaf variables’ gradients are not retained to be inspected later. This was done by design, to save memory.\n",
    "\n",
    "* **.backward() function** : \n",
    "\n",
    "Computes the gradient of all variables (graph leaves with requires_grad=True) that contributed to the output variable (on which we call this function) using the chain rule. Keep in mind that it accumulates the gradients in the leaves, so we would need to clear them between the different passes on the data. \n",
    " \n",
    "  * By default this is expected to be called on the loss scalar so it takes no arguments : dloss/dx for all x leaves. \n",
    "  * If we call it on a non-scalar tensor, it means that we expect the final tensor to be somewhere \"upstream\" in the graph, so we need to provide the gradient of the output with respect to the non-scalar tensor as argument to the function. ([source](https://suzyahyah.github.io/calculus/pytorch/2018/07/01/Pytorch-Autograd-Backprop.html))\n",
    "\n",
    "\n",
    "A nice video explaining how the graph is constructed : https://www.youtube.com/watch?v=MswxJw-8PvE\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Chain of operations on tensor x ---\n",
      "x.grad_fn = None\n",
      "x.requires_grad =  True\n",
      "x.is_leaf =  True\n",
      "---\n",
      "y.grad_fn = <AddBackward0 object at 0x7fac7ab75670>\n",
      "y.requires_grad =  True\n",
      "y.is_leaf =  False\n",
      "---\n",
      "z.grad_fn = <MulBackward0 object at 0x7fac7ab75ac0>\n",
      "z.requires_grad =  True\n",
      "z.is_leaf =  False\n",
      "---\n",
      "result1.grad_fn = <MeanBackward0 object at 0x7fac7ab8c040>\n",
      "result1.requires_grad =  True\n",
      "result1.is_leaf =  False\n",
      "---\n",
      "result2.grad_fn = <PowBackward0 object at 0x7fac7ab08520>\n",
      "result2.requires_grad =  True\n",
      "result2.is_leaf =  False\n",
      "---\n",
      "tensor([[0.2500, 0.2500],\n",
      "        [0.2500, 0.2500]])\n",
      "\n",
      "--- Gradients ---\n",
      "tensor([[3., 3.],\n",
      "        [3., 3.]]) None None None\n"
     ]
    }
   ],
   "source": [
    "print('--- Chain of operations on tensor x ---')\n",
    "\n",
    "x = torch.ones(2, 2, requires_grad=True)\n",
    "print(\"x.grad_fn =\", x.grad_fn)\n",
    "print(\"x.requires_grad = \", x.requires_grad)\n",
    "print(\"x.is_leaf = \", x.is_leaf)\n",
    "print('---')\n",
    "\n",
    "y = x + 2\n",
    "print(\"y.grad_fn =\", y.grad_fn)\n",
    "print(\"y.requires_grad = \", y.requires_grad)\n",
    "print(\"y.is_leaf = \", y.is_leaf)\n",
    "print('---')\n",
    "\n",
    "z = y * y * 2\n",
    "print(\"z.grad_fn =\", z.grad_fn)\n",
    "print(\"z.requires_grad = \", z.requires_grad)\n",
    "print(\"z.is_leaf = \", z.is_leaf)\n",
    "print('---')\n",
    "\n",
    "result1 = z.mean()\n",
    "print(\"result1.grad_fn =\", result1.grad_fn)\n",
    "print(\"result1.requires_grad = \", result1.requires_grad)\n",
    "print(\"result1.is_leaf = \", result1.is_leaf)\n",
    "print('---')\n",
    "\n",
    "result2 = z**2\n",
    "print(\"result2.grad_fn =\", result2.grad_fn)\n",
    "print(\"result2.requires_grad = \", result2.requires_grad)\n",
    "print(\"result2.is_leaf = \", result2.is_leaf)\n",
    "print('---')\n",
    "\n",
    "# result 1 is a scalar\n",
    "result1.backward()\n",
    "\n",
    "# result 2 is a tensor\n",
    "#result2.backward()\n",
    "\n",
    "print('\\n--- Gradients ---')\n",
    "print(x.grad, y.grad, z.grad, result1.grad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. [Neural Networks](https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html#neural-networks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neural networks can be constructed using the torch.nn package. An nn.Module contains **layers** and a method **forward(input)** that returns the output. We just need to define the forward function, and **the backward function (where gradients are computed) is automatically defined using autograd**.\n",
    "\n",
    "torch.nn only supports mini-batches. The entire torch.nn package only supports inputs that are a mini-batch of samples, and not a single sample. For example, nn.Conv2d will take in a 4D Tensor of nSamples x nChannels x Height x Width."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Defining the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# DEFINE THE MODEL\n",
    "class Net(nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        # 1 input image channel, 6 output channels, 3x3 square convolution\n",
    "        # kernel\n",
    "        self.conv1 = nn.Conv2d(1, 6, 3)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 3)\n",
    "        # an affine operation: y = Wx + b\n",
    "        self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension\n",
    "        self.fc2 = nn.Linear(120, 84)\n",
    "        self.fc3 = nn.Linear(84, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Max pooling over a (2, 2) window\n",
    "        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))\n",
    "        # If the size is a square you can only specify a single number\n",
    "        x = F.max_pool2d(F.relu(self.conv2(x)), 2)\n",
    "        x = x.view(-1, self.num_flat_features(x))\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "    def num_flat_features(self, x):\n",
    "        size = x.size()[1:]  # all dimensions except the batch dimension\n",
    "        num_features = 1\n",
    "        for s in size:\n",
    "            num_features *= s\n",
    "        return num_features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (conv1): Conv2d(1, 6, kernel_size=(3, 3), stride=(1, 1))\n",
      "  (conv2): Conv2d(6, 16, kernel_size=(3, 3), stride=(1, 1))\n",
      "  (fc1): Linear(in_features=576, 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",
      "----------\n",
      "Number of parameters : 10\n",
      "torch.Size([6, 1, 3, 3])\n"
     ]
    }
   ],
   "source": [
    "# VISUALIZE THE MODEL\n",
    "net = Net()\n",
    "print(net, \"\\n----------\")\n",
    "\n",
    "# VISUALIZE THE MODELS PARAMETERS\n",
    "params = list(net.parameters())\n",
    "print(\"Number of parameters :\", len(params))\n",
    "print(params[0].size())  # conv1's .weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.0113, -0.0041,  0.0987, -0.1152, -0.0512,  0.0947,  0.0882,  0.0905,\n",
      "         -0.0059, -0.0999]], grad_fn=<AddmmBackward>) \n",
      "----------\n",
      "torch.Size([1, 10])\n",
      "tensor([[[[-6.6722e-04, -3.4722e-05,  4.2376e-04,  ...,  0.0000e+00,\n",
      "            0.0000e+00,  0.0000e+00],\n",
      "          [ 1.0378e-03,  6.8287e-04, -1.7135e-04,  ..., -2.4649e-05,\n",
      "            0.0000e+00,  0.0000e+00],\n",
      "          [-2.0751e-03,  1.2216e-03,  9.3350e-04,  ..., -5.6978e-04,\n",
      "            0.0000e+00,  0.0000e+00],\n",
      "          ...,\n",
      "          [ 8.4188e-04,  2.5364e-04,  9.1200e-04,  ...,  5.0849e-04,\n",
      "            0.0000e+00,  0.0000e+00],\n",
      "          [ 0.0000e+00,  0.0000e+00,  0.0000e+00,  ...,  0.0000e+00,\n",
      "            0.0000e+00,  0.0000e+00],\n",
      "          [ 0.0000e+00,  0.0000e+00,  0.0000e+00,  ...,  0.0000e+00,\n",
      "            0.0000e+00,  0.0000e+00]]]])\n"
     ]
    }
   ],
   "source": [
    "# FEEDFORWARD COMPUTATION\n",
    "input = torch.randn((1, 1, 32, 32), requires_grad=True)\n",
    "# Apply net as a function\n",
    "out = net(input)\n",
    "print(out, \"\\n----------\")\n",
    "\n",
    "# BQCKWARD COMPUTATION\n",
    "#Zero the gradient buffers of all parameters\n",
    "net.zero_grad() \n",
    "# Out is not the loss so not scalar \n",
    "print(out.shape)\n",
    "out.backward(torch.randn(1, 10)) \n",
    "print(input.grad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Loss function\n",
    "\n",
    "A loss function takes the (output, target) pair of inputs, and computes a value that estimates how far away the output is from the target."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "output = net(input)\n",
    "target = torch.randn(10)  # a dummy target, for example\n",
    "target = target.view(1, -1)  # make it the same shape as output\n",
    "criterion = nn.MSELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(1.2857, grad_fn=<MseLossBackward>)\n"
     ]
    }
   ],
   "source": [
    "loss = criterion(output, target)\n",
    "print(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<MseLossBackward object at 0x000001EB38BCA550>\n",
      "<AddmmBackward object at 0x000001EB38BCAE80>\n",
      "<AccumulateGrad object at 0x000001EB38BCA550>\n"
     ]
    }
   ],
   "source": [
    "# GRAPH COMPUTATIONS\n",
    "print(loss.grad_fn)  # MSELoss\n",
    "print(loss.grad_fn.next_functions[0][0])  # Linear\n",
    "print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Backpropagation\n",
    "\n",
    "To backpropagate the error all we have to do is to loss.backward(). We need to clear the existing gradients though, else gradients will be accumulated to existing gradients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conv1.bias.grad before backward\n",
      "tensor([0., 0., 0., 0., 0., 0.])\n",
      "conv1.bias.grad after backward\n",
      "tensor([-0.0226,  0.0208,  0.0057,  0.0020, -0.0262, -0.0281])\n"
     ]
    }
   ],
   "source": [
    "net.zero_grad()     # zeroes the gradient buffers of all parameters\n",
    "\n",
    "print('conv1.bias.grad before backward')\n",
    "print(net.conv1.bias.grad)\n",
    "\n",
    "# Option 1\n",
    "loss.backward(retain_graph=True)\n",
    "\n",
    "print('conv1.bias.grad after backward')\n",
    "print(net.conv1.bias.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# WEIGHT UPDATE\n",
    "learning_rate = 0.01\n",
    "\n",
    "for f in net.parameters():\n",
    "    f.data.sub_(f.grad.data * learning_rate) #in place subtract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "# USE TORCH.OPTIM FOR EASE AND ACCESS TO OTHER UPDATE RULES\n",
    "import torch.optim as optim\n",
    "\n",
    "# create your optimizer\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.01)\n",
    "\n",
    "# in your training loop:\n",
    "optimizer.zero_grad()   # zero the gradient buffers\n",
    "\n",
    "output = net(input)\n",
    "loss = criterion(output, target)\n",
    "\n",
    "# Back propagate\n",
    "loss.backward()\n",
    "\n",
    "# Does the update\n",
    "optimizer.step()   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. [Training a classifier](https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Specifically for vision, we have created a package called torchvision, that has data loaders for common datasets such as Imagenet, CIFAR10, MNIST, etc. and data transformers for images, viz., torchvision.datasets and torch.utils.data.DataLoader.\"\n",
    "\n",
    "Here we will use the CIFAR10 dataset. It has the 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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Loading and transforming the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "# CREATE DATA TRANSFORMATION PIPELINE\n",
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
    "\n",
    "# LOAD TRAIN DATA\n",
    "trainset = torchvision.datasets.CIFAR10(root='./data', train=True,\n",
    "                                        download=True, transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "\n",
    "# LOAD TEST DATA\n",
    "testset = torchvision.datasets.CIFAR10(root='./data', train=False,\n",
    "                                       download=True, transform=transform)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=4,\n",
    "                                         shuffle=False, num_workers=2)\n",
    "\n",
    "classes = ('plane', 'car', 'bird', 'cat',\n",
    "           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "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": [
      "  car  ship plane  frog\n"
     ]
    }
   ],
   "source": [
    "# functions to show an image\n",
    "def imshow(img):\n",
    "    img = img / 2 + 0.5     # unnormalize\n",
    "    npimg = img.numpy()\n",
    "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# get some random training images\n",
    "dataiter = iter(trainloader)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "# show images\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "\n",
    "# print labels\n",
    "print(' '.join('%5s' % classes[labels[j]] for j in range(4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Creating and training the network\n",
    "\n",
    "Let us reuse the network from section 3 by modifying it a bit for this data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1,  2000] loss: 2.214\n",
      "[1,  4000] loss: 1.886\n",
      "[1,  6000] loss: 1.710\n",
      "[1,  8000] loss: 1.615\n",
      "[1, 10000] loss: 1.541\n",
      "[1, 12000] loss: 1.499\n",
      "[2,  2000] loss: 1.424\n",
      "[2,  4000] loss: 1.392\n",
      "[2,  6000] loss: 1.374\n",
      "[2,  8000] loss: 1.343\n",
      "[2, 10000] loss: 1.308\n",
      "[2, 12000] loss: 1.306\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "# 1. Define network\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(3, 6, 5)\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",
    "net = Net()\n",
    "\n",
    "# 2. Define loss and optimizer \n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 3. Training \n",
    "for epoch in range(2):\n",
    "\n",
    "    running_loss = 0.0\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        \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 = net(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' %\n",
    "                  (epoch + 1, i + 1, running_loss / 2000))\n",
    "            running_loss = 0.0\n",
    "\n",
    "print('Finished Training')\n",
    "\n",
    "# 4. Save model\n",
    "PATH = './models/cifar_net.pth'\n",
    "torch.save(net.state_dict(), PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 Testing the network on the test set\n",
    "\n",
    "#### 4.3.1 Testing on some examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "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",
      "Predicted:    cat  ship  ship  ship\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(4)))\n",
    "\n",
    "# 1. Reload model \n",
    "net = Net()\n",
    "net.load_state_dict(torch.load(PATH))\n",
    "\n",
    "# 2. Get outputs \n",
    "outputs = net(images)\n",
    "_, predicted = torch.max(outputs, 1)\n",
    "print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.3.2 Testing on the whole test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on the 10000 test images: 56 %\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        outputs = net(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": [
    "#### 4.3.3 See performance per class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of plane : 69 %\n",
      "Accuracy of   car : 73 %\n",
      "Accuracy of  bird : 32 %\n",
      "Accuracy of   cat : 27 %\n",
      "Accuracy of  deer : 54 %\n",
      "Accuracy of   dog : 47 %\n",
      "Accuracy of  frog : 62 %\n",
      "Accuracy of horse : 63 %\n",
      "Accuracy of  ship : 73 %\n",
      "Accuracy of truck : 58 %\n"
     ]
    }
   ],
   "source": [
    "class_correct = list(0. for i in range(10))\n",
    "class_total = list(0. for i in range(10))\n",
    "\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        outputs = net(images)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        c = (predicted == labels).squeeze()\n",
    "        for i in range(4):\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 %%' % (\n",
    "        classes[i], 100 * class_correct[i] / class_total[i]))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}