Convolutionary_Network_Tutorial_Pytorch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Convolutionary Network Tutorial - Pytorch.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/rubencg195/Pytorch-Tutorials/blob/master/Convolutionary_Network_Tutorial_Pytorch.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "metadata": {
        "id": "Bl5Fc8yv2ddb",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Convolutionary Network Tutorial\n",
        "\n",
        "Source: \n",
        "\n",
        "1. https://blog.algorithmia.com/convolutional-neural-nets-in-pytorch/\n",
        "\n",
        "2. https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html\n",
        "\n",
        "3. https://adeshpande3.github.io/A-Beginner%27s-Guide-To-Understanding-Convolutional-Neural-Networks-Part-2/\n",
        "\n",
        "Theory: https://blog.algorithmia.com/introduction-to-computer-vision/\n",
        "\n",
        "**Convolution**\n",
        "\n",
        "The process of **Convolution**, which is the first filter applied as part of the feature engineering step. Think of convolution as applying a filter to our image. We pass over a mini image, usually called a **kernel**, and output the resulting filtered subset of our image. \n",
        "\n",
        "![alt text](http://deeplearning.stanford.edu/wiki/images/6/6c/Convolution_schematic.gif)\n",
        "Source: [Stanford Deep Learning](http://deeplearning.stanford.edu/wiki/index.php/Feature_extraction_using_convolution)\n",
        "\n",
        "Since an image is just a bunch of pixel values, in practice this means multiplying small parts of our input images by the filter. There are a few parameters that get adjusted here:\n",
        "\n",
        "*Filter Parameters:*\n",
        "\n",
        "1. **Kernel Size** – the size of the filter.\n",
        "2. **Kernel Type** – the values of the actual filter. Some examples include identity, edge detection, and sharpen.\n",
        "3. **Stride** – the rate at which the kernel passes over the input image. A stride of 2 moves the kernel in 2 pixel increments.\n",
        "4. **Padding** – we can add layers of 0s to the outside of the image in order to make sure that the kernel properly passes over the edges of the image.\n",
        "5. **Output Layers** – how many different kernels are applied to the image.\n",
        "\n",
        "\n",
        "The output of the convolution process is called the “**convolved feature**” or “**feature map**.” \n",
        "\n",
        "*Code: you’ll see the convolution step through the use of the torch.nn.Conv2d() function in Pytorch.*\n",
        "\n",
        "The resulting feature map can be viewed as a more optimal representation of the input image that’s more informative to the eventual neural network that the image will be passed through. In practice, convolution combined with the next two steps has been shown to greatly increase the accuracy of neural networks on images.\n",
        "\n",
        "**ReLU**\n",
        "\n",
        "Since the neural network forward pass is essentially a linear function (just multiplying inputs by weights and adding a bias), CNNs often add in a nonlinear function to help approximate such a relationship in the underlying data.\n",
        "\n",
        "![alt text](https://)\n",
        "\n",
        "The function most popular with CNNs is called ReLU and it’s extremely simple. ReLU stands for Rectified Linear Unit, and it just **converts all negative pixel values to 0**. The function itself is output = Max(0, input). There are other functions that can be used to add non-linearity, like tanh or softmax. But in CNNs, **ReLU is the most commonly used.**\n",
        "\n",
        "*Code: you’ll see the ReLU step through the use of the torch.nn.relu() function in Pytorch.*\n",
        "\n",
        "**Max Pooling**\n",
        "\n",
        "The last part of the feature engineering step in CNNs is pooling, and the name describes it pretty well: **we pass over sections of our image and pool them into the highest value in the section**. Depending on the size of the pool, this can greatly reduce the size of the feature set that we pass into the neural network.\n",
        "\n",
        "![Stanford](https://blog.algorithmia.com/wp-content/uploads/2018/03/word-image-5.png)\n",
        "\n",
        "*Note*: Max pooling also has a few of the same parameters as convolution that can be adjusted, like stride and padding. There are also other types of pooling that can be applied, like sum pooling or average pooling.\n",
        "\n",
        "*Code: you’ll see the Max Pooling step through the use of the torch.nn.MaxPool2d() function in Pytorch.*\n",
        "\n",
        "**Fully Connected Layers**\n",
        "\n",
        "After the above preprocessing steps are applied, the resulting image (which may end up looking nothing like the original!) is passed into the traditional neural network architecture. Designing the optimal neural network is beyond the scope of this post, and we’ll be using a simple 2 layer format with one hidden layer and one output layer.\n",
        "\n",
        "This part of the CNN is almost identical to any other standard neural network. The key to understanding CNNs is this: the driver of better accuracy is the steps we take to engineer better features, not the classifier we end up passing those values through. Convolution, ReLU, and max pooling prepare our data for the neural network in a way that extracts all the useful information they have in an efficient manner.\n",
        "\n",
        "*Code: you’ll see the forward pass step through the use of the torch.nn.Linear() function in Pytorch.*\n"
      ]
    },
    {
      "metadata": {
        "id": "ShQqs6xmc8Rv",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# http://pytorch.org/\n",
        "from os.path import exists\n",
        "from wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag\n",
        "platform = '{}{}-{}'.format(get_abbr_impl(), get_impl_ver(), get_abi_tag())\n",
        "cuda_output = !ldconfig -p|grep cudart.so|sed -e 's/.*\\.\\([0-9]*\\)\\.\\([0-9]*\\)$/cu\\1\\2/'\n",
        "accelerator = cuda_output[0] if exists('/dev/nvidia0') else 'cpu'\n",
        "\n",
        "!pip install -q http://download.pytorch.org/whl/{accelerator}/torch-0.4.1-{platform}-linux_x86_64.whl torchvision\n",
        "import torch"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "JcYHL3Im-WD2",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Imports Hyperparameters\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "mp-1IBez-lPr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "2364202b-6f17-4dcf-c534-e3428cc6792b"
      },
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "#For reproducible results\n",
        "seed = 42\n",
        "np.random.seed(seed)\n",
        "torch.manual_seed(seed)"
      ],
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<torch._C.Generator at 0x7f8e01376ab0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 82
        }
      ]
    },
    {
      "metadata": {
        "id": "y7uMxH4J-STf",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "#Gathering Data\n",
        "\n",
        "As with most Machine Learning projects, a minority of the code you end up writing has to do with actual statistics––*most is spent on gathering, cleaning, and readying your data for analysis. CNNs in Pytorch are no exception.*\n",
        "\n",
        "Things to have in mind:\n",
        "\n",
        "1. The **Compose()** Function allow for multiple transforms.\n",
        "2. **Transforms.ToTensor()** convert our PILImage to a tensor of shape\n",
        "3. **Transforms.Normalize(mean, std)** normalizes a tensor to a (mean, std) for (R, G, B)\n",
        "\n",
        "Steps: \n",
        "1. Download and transform the data.\n",
        "2. Define the labels for each imge (10).\n",
        "3. Define samplers for our images. These Pytorch objects will split all of the available training examples into training, test, and cross validation sets when we train our model later on."
      ]
    },
    {
      "metadata": {
        "id": "6esAJp73kOmM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "164252ac-723a-4d86-bd4a-451fc0c0fe25"
      },
      "cell_type": "code",
      "source": [
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(), \n",
        "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
        "])\n",
        "\n",
        "train_set = torchvision.datasets.CIFAR10(\n",
        "    root='./cifardata', \n",
        "    train=True, \n",
        "    download=True, \n",
        "    transform=transform\n",
        ")\n",
        "\n",
        "test_set = torchvision.datasets.CIFAR10(\n",
        "    root='./cifardata', \n",
        "    train=False, \n",
        "    download=True, \n",
        "    transform=transform\n",
        ")\n",
        "\n",
        "classes = ('plane', 'car', 'bird', 'cat',\n",
        "           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
        "\n",
        "\n",
        "\n",
        "from torch.utils.data.sampler import SubsetRandomSampler\n",
        "\n",
        "#Training\n",
        "n_training_samples = 20000\n",
        "train_sampler = SubsetRandomSampler(np.arange(n_training_samples, dtype=np.int64))\n",
        "\n",
        "#Validation\n",
        "n_val_samples = 5000\n",
        "val_sampler = SubsetRandomSampler(np.arange(n_training_samples, n_training_samples + n_val_samples, dtype=np.int64))\n",
        "\n",
        "#Test\n",
        "n_test_samples = 5000\n",
        "test_sampler = SubsetRandomSampler(np.arange(n_test_samples, dtype=np.int64))"
      ],
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "bJeo1yXgZq90",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#DataLoader takes in a dataset and a sampler for loading (num_workers deals with system level memory) \n",
        "def get_train_loader(batch_size):\n",
        "    train_loader = torch.utils.data.DataLoader(\n",
        "        train_set, \n",
        "        batch_size=batch_size,\n",
        "        sampler=train_sampler, num_workers=2\n",
        "    )\n",
        "    return(train_loader)\n",
        "\n",
        "#Test and validation loaders have constant batch sizes, so we can define them directly\n",
        "test_loader = torch.utils.data.DataLoader(test_set, batch_size=4, sampler=test_sampler, num_workers=2)\n",
        "val_loader = torch.utils.data.DataLoader(train_set, batch_size=128, sampler=val_sampler, num_workers=2)\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "ClIHV1Xsw5CV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 658
        },
        "outputId": "b7acead4-6e62-4b77-950b-23e3850218da"
      },
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# functions to show an image\n",
        "\n",
        "\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",
        "\n",
        "\n",
        "# get some random training images\n",
        "dataiter = iter(get_train_loader(10))\n",
        "images, labels = dataiter.next()\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(4)))"
      ],
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "horse horse   dog  deer\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "Exception ignored in: <bound method _DataLoaderIter.__del__ of <torch.utils.data.dataloader._DataLoaderIter object at 0x7f8dc9e2d1d0>>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.6/dist-packages/torch/utils/data/dataloader.py\", line 399, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.6/dist-packages/torch/utils/data/dataloader.py\", line 378, in _shutdown_workers\n",
            "    self.worker_result_queue.get()\n",
            "  File \"/usr/lib/python3.6/multiprocessing/queues.py\", line 337, in get\n",
            "    return _ForkingPickler.loads(res)\n",
            "  File \"/usr/local/lib/python3.6/dist-packages/torch/multiprocessing/reductions.py\", line 151, in rebuild_storage_fd\n",
            "    fd = df.detach()\n",
            "  File \"/usr/lib/python3.6/multiprocessing/resource_sharer.py\", line 57, in detach\n",
            "    with _resource_sharer.get_connection(self._id) as conn:\n",
            "  File \"/usr/lib/python3.6/multiprocessing/resource_sharer.py\", line 87, in get_connection\n",
            "    c = Client(address, authkey=process.current_process().authkey)\n",
            "  File \"/usr/lib/python3.6/multiprocessing/connection.py\", line 493, in Client\n",
            "    answer_challenge(c, authkey)\n",
            "  File \"/usr/lib/python3.6/multiprocessing/connection.py\", line 737, in answer_challenge\n",
            "    response = connection.recv_bytes(256)        # reject large message\n",
            "  File \"/usr/lib/python3.6/multiprocessing/connection.py\", line 216, in recv_bytes\n",
            "    buf = self._recv_bytes(maxlength)\n",
            "  File \"/usr/lib/python3.6/multiprocessing/connection.py\", line 407, in _recv_bytes\n",
            "    buf = self._recv(4)\n",
            "  File \"/usr/lib/python3.6/multiprocessing/connection.py\", line 379, in _recv\n",
            "    chunk = read(handle, remaining)\n",
            "ConnectionResetError: [Errno 104] Connection reset by peer\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAd8AAACUCAYAAADS6CNDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nvuQQGgAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x7f8dc9da4f28>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "metadata": {
        "id": "WpqeaAexAuWS",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Designing a Neural Net in Pytorch\n",
        "\n",
        "Pytorch makes it pretty easy to implement all of those feature engineering steps that we described above. We’ll be making use of 4 major functions in our CNN class:\n",
        "\n",
        "1. **torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)** – applies convolution\n",
        "2. **torch.nn.relu(x)** – applies ReLU\n",
        "3. **torch.nn.MaxPool2d(kernel_size, stride, padding)** – applies Max Pooling\n",
        "4.**torch.nn.Linear(in_features, out_features)** – fully connected layer (multiply inputs by learned weights)\n",
        "\n",
        "Writing CNN code in Pytorch can get a little complex, since everything is defined inside of one class. We’ll create a SimpleCNN class which inherits from the master torch.nn.Module class.\n",
        "\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "LG55TXzaAGpx",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from torch.autograd import Variable\n",
        "import torch.nn.functional as F\n",
        "\n",
        "class SimpleCNN(torch.nn.Module):\n",
        "    \n",
        "    #Our batch shape for input x is (3, 32, 32)\n",
        "    \n",
        "    def __init__(self):\n",
        "        super(SimpleCNN, self).__init__()\n",
        "        \n",
        "        #Input channels = 3, output channels = 18\n",
        "        self.conv1 = torch.nn.Conv2d(3, 18, kernel_size=3, stride=1, padding=1)\n",
        "        self.pool = torch.nn.MaxPool2d(kernel_size=2, stride=2, padding=0)\n",
        "        \n",
        "        #4608 input features, 64 output features (see sizing flow below)\n",
        "        self.fc1 = torch.nn.Linear(18 * 16 * 16, 64)\n",
        "        \n",
        "        #64 input features, 10 output features for our 10 defined classes\n",
        "        self.fc2 = torch.nn.Linear(64, 10)\n",
        "        \n",
        "    def forward(self, x):\n",
        "        \n",
        "        #Computes the activation of the first convolution\n",
        "        #Size changes from (3, 32, 32) to (18, 32, 32)\n",
        "        x = F.relu(self.conv1(x))\n",
        "        \n",
        "        #Size changes from (18, 32, 32) to (18, 16, 16)\n",
        "        x = self.pool(x)\n",
        "        \n",
        "        #Reshape data to input to the input layer of the neural net\n",
        "        #Size changes from (18, 16, 16) to (1, 4608)\n",
        "        #Recall that the -1 infers this dimension from the other given dimension\n",
        "        x = x.view(-1, 18 * 16 *16)\n",
        "        \n",
        "        #Computes the activation of the first fully connected layer\n",
        "        #Size changes from (1, 4608) to (1, 64)\n",
        "        x = F.relu(self.fc1(x))\n",
        "        \n",
        "        #Computes the second fully connected layer (activation applied later)\n",
        "        #Size changes from (1, 64) to (1, 10)\n",
        "        x = self.fc2(x)\n",
        "        return(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "9WJyGEI8UI4e",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We’re creating a SimpleCNN class with one class method: **forward**. The** forward()** *method computes a forward pass of the CNN, which includes the preprocessing steps we outlined above.* When an instance of the SimpleCNN class is created, we define internal functions to represent the layers of the net. During the forward pass we call these internal functions.\n",
        "\n",
        "One of the pesky parts about manually defining neural nets is that we need to specify the sizes of inputs and outputs at each part of the process. The comments should give some direction as to what’s happening with size changes at each step. In general, the output size for any dimension in our input set can be defined as:"
      ]
    },
    {
      "metadata": {
        "id": "9pWmE3rYU-TP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 74
        },
        "outputId": "015c0401-4988-4c3e-aa57-1d10189ac729"
      },
      "cell_type": "code",
      "source": [
        "def outputSize(in_size, kernel_size, stride, padding):\n",
        "    \n",
        "    output = int((in_size - kernel_size + 2*(padding)) / stride) + 1\n",
        "    \n",
        "    return (output)\n",
        "\n",
        " \n",
        "#Input (3, 32, 32) Conv, Output specified = 18 for batch size\n",
        "print((18,\n",
        "       outputSize(in_size=32, kernel_size=3, stride=1, padding=1),\n",
        "       outputSize(in_size=32, kernel_size=3, stride=1, padding=1),\n",
        "      ))\n",
        "\n",
        "#Input (18, 32, 32) MaxPooling\n",
        "print((18,\n",
        "       outputSize(in_size=32, kernel_size=2, stride=2, padding=0),\n",
        "       outputSize(in_size=32, kernel_size=2, stride=2, padding=0),\n",
        "      ))\n"
      ],
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(18, 32, 32)\n",
            "(18, 16, 16)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "BpG8EXZSVf7O",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "To use an example from our CNN, look at the max pooling layer. *The input dimension is (18, 32, 32*)–– using our formula applied to each of the final two dimensions (**the first dimension, or number of feature maps, remains unchanged during any pooling operation**), we get an *output size of (18, 16, 16).*"
      ]
    },
    {
      "metadata": {
        "id": "I_mw9zHmZab3",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Training\n",
        "\n",
        "Once we’ve defined the class for our CNN, we need to train the net itself. This is where neural network code gets interesting. If you’re working with more basic types of Machine Learning algorithms, you can usually get meaningful output in just a few lines of code. For example, implementing a Support Vector Machine in the sklearn Python package is as easy as:"
      ]
    },
    {
      "metadata": {
        "id": "vM8TZWbGZnrh",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#Import the support vector machine module from the sklearn framework\n",
        "from sklearn import svm\n",
        "\n",
        "#Label x and y variables from our dataset\n",
        "#x = ourData.features\n",
        "#y = ourData.labels\n",
        "\n",
        "#Initialize our algorithm\n",
        "#classifier = svm.SVC()\n",
        "\n",
        "#Fit model to our data\n",
        "#classifier.fit(x,y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "y-FnhNQlZoqm",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "With neural networks in **Pytorch (and TensorFlow)** though, it takes a bunch more code than that. Our basic flow is a \n",
        "1. training loop: each time we pass through the loop (called and “epoch”), we compute a forward pass on the network \n",
        "2. And implement backpropagation to adjust the weights. \n",
        "3. We’ll also record some other measurements like loss and time passed, so that we can analyze them as the net trains itself.\n",
        "\n",
        "To start, we’ll define our data loaders using the samplers we created above."
      ]
    },
    {
      "metadata": {
        "id": "7WEx9BqCZ8BW",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We’ll also define our **loss and optimizer functions** that the CNN will use to find the right weights. We’ll be using \n",
        "\n",
        "1. **Cross Entropy Loss (Log Loss) as our loss function**, which ***strongly penalizes high confidence in the wrong answer.*** \n",
        "2. The optimizer is the popular **Adam algorithm**.\n",
        "\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "QfXtXjrGaavh",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import torch.optim as optim\n",
        "\n",
        "def createLossAndOptimizer(net, learning_rate=0.001):\n",
        "    \n",
        "    #Loss function\n",
        "    loss = torch.nn.CrossEntropyLoss()\n",
        "    \n",
        "    #Optimizer\n",
        "    optimizer = optim.Adam(net.parameters(), lr=learning_rate)\n",
        "    \n",
        "    return(loss, optimizer)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "nIrm7a-HaaAy",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Finally, we’ll define a function to train our CNN using a simple for loop."
      ]
    },
    {
      "metadata": {
        "id": "HxOGinI1af8z",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import time\n",
        "\n",
        "def trainNet(net, batch_size, n_epochs, learning_rate):\n",
        "    \n",
        "    #Traning on GPU\n",
        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "    # Assume that we are on a CUDA machine, then this should print a CUDA device:\n",
        "    print(device)\n",
        "    \n",
        "    #For GPU Processing\n",
        "    net.to(device)\n",
        "    \n",
        "    \n",
        "    #Print all of the hyperparameters of the training iteration:\n",
        "    print(\"===== HYPERPARAMETERS =====\")\n",
        "    print(\"batch_size=\", batch_size)\n",
        "    print(\"epochs=\", n_epochs)\n",
        "    print(\"learning_rate=\", learning_rate)\n",
        "    print(\"=\" * 30)\n",
        "    \n",
        "    #Get training data\n",
        "    train_loader = get_train_loader(batch_size)\n",
        "    n_batches = len(train_loader)\n",
        "    \n",
        "    #Create our loss and optimizer functions\n",
        "    loss, optimizer = createLossAndOptimizer(net, learning_rate)\n",
        "    \n",
        "    #Time for printing\n",
        "    training_start_time = time.time()\n",
        "    \n",
        "    #Loop for n_epochs\n",
        "    for epoch in range(n_epochs):\n",
        " \n",
        "        running_loss = 0.0\n",
        "        print_every = n_batches // 10\n",
        "        start_time = time.time()\n",
        "        total_train_loss = 0\n",
        "        \n",
        "        for i, data in enumerate(train_loader, 0):\n",
        "            \n",
        "            \n",
        "            #Get inputs\n",
        "            inputs, labels = data\n",
        "            \n",
        "            #For GPU Processsing\n",
        "            inputs, labels = inputs.to(device), labels.to(device)\n",
        "            \n",
        "            #Wrap them in a Variable object\n",
        "            inputs, labels = Variable(inputs), Variable(labels)\n",
        "            \n",
        "            #Set the parameter gradients to zero\n",
        "            optimizer.zero_grad()\n",
        "            \n",
        "            #Forward pass, backward pass, optimize\n",
        "            outputs = net(inputs)\n",
        "            loss_size = loss(outputs, labels)\n",
        "            loss_size.backward()\n",
        "            optimizer.step()\n",
        "            \n",
        "            #Print statistics\n",
        "            running_loss += loss_size.data[0]\n",
        "            total_train_loss += loss_size.data[0]\n",
        "            \n",
        "            #Print every 10th batch of an epoch\n",
        "            if (i + 1) % (print_every + 1) == 0:\n",
        "                print(\"Epoch {}, {:d}% \\t train_loss: {:.2f} took: {:.2f}s\".format(\n",
        "                        epoch+1, int(100 * (i+1) / n_batches), running_loss / print_every, time.time() - start_time))\n",
        "                #Reset running loss and time\n",
        "                running_loss = 0.0\n",
        "                start_time = time.time()\n",
        "            \n",
        "        #At the end of the epoch, do a pass on the validation set\n",
        "        total_val_loss = 0\n",
        "        for inputs, labels in val_loader:\n",
        "            \n",
        "            #Wrap tensors in Variables\n",
        "            inputs, labels = Variable(inputs), Variable(labels)\n",
        "            \n",
        "            #For GPU Processsing\n",
        "            inputs, labels = inputs.to(device), labels.to(device)\n",
        "            \n",
        "            #Forward pass\n",
        "            val_outputs = net(inputs)\n",
        "            val_loss_size = loss(val_outputs, labels)\n",
        "            total_val_loss += val_loss_size.data[0]\n",
        "            \n",
        "        print(\"Validation loss = {:.2f}\".format(total_val_loss / len(val_loader)))\n",
        "        \n",
        "    print(\"Training finished, took {:.2f}s\".format(time.time() - training_start_time))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "chGqe2k-aaFJ",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "During each epoch of training, we pass data to the model in batches whose size we define when we call the training loop. Data is feature engineered using the SimpleCNN class we’ve defined, and then basic metrics are printed after a few passes. During each loop, we also calculate the loss on our validation set.\n",
        "\n",
        "\n",
        "To actually train the net now only requires two lines of code:\n",
        "\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "wc79YFcfaupI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1128
        },
        "outputId": "429ec2b5-7c0f-4660-f413-fd184ac25d6d"
      },
      "cell_type": "code",
      "source": [
        "CNN = SimpleCNN()\n",
        "trainNet(CNN, batch_size=32, n_epochs=5, learning_rate=0.001)"
      ],
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "cuda:0\n",
            "===== HYPERPARAMETERS =====\n",
            "batch_size= 32\n",
            "epochs= 5\n",
            "learning_rate= 0.001\n",
            "==============================\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:61: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:62: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 1, 10% \t train_loss: 2.06 took: 0.72s\n",
            "Epoch 1, 20% \t train_loss: 1.87 took: 0.62s\n",
            "Epoch 1, 30% \t train_loss: 1.79 took: 0.60s\n",
            "Epoch 1, 40% \t train_loss: 1.70 took: 0.63s\n",
            "Epoch 1, 50% \t train_loss: 1.63 took: 0.60s\n",
            "Epoch 1, 60% \t train_loss: 1.58 took: 0.63s\n",
            "Epoch 1, 70% \t train_loss: 1.52 took: 0.63s\n",
            "Epoch 1, 80% \t train_loss: 1.47 took: 0.62s\n",
            "Epoch 1, 90% \t train_loss: 1.46 took: 0.63s\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:85: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Validation loss = 1.33\n",
            "Epoch 2, 10% \t train_loss: 1.40 took: 0.74s\n",
            "Epoch 2, 20% \t train_loss: 1.41 took: 0.62s\n",
            "Epoch 2, 30% \t train_loss: 1.31 took: 0.62s\n",
            "Epoch 2, 40% \t train_loss: 1.32 took: 0.61s\n",
            "Epoch 2, 50% \t train_loss: 1.35 took: 0.61s\n",
            "Epoch 2, 60% \t train_loss: 1.31 took: 0.63s\n",
            "Epoch 2, 70% \t train_loss: 1.30 took: 0.63s\n",
            "Epoch 2, 80% \t train_loss: 1.23 took: 0.60s\n",
            "Epoch 2, 90% \t train_loss: 1.31 took: 0.62s\n",
            "Validation loss = 1.28\n",
            "Epoch 3, 10% \t train_loss: 1.20 took: 0.72s\n",
            "Epoch 3, 20% \t train_loss: 1.16 took: 0.60s\n",
            "Epoch 3, 30% \t train_loss: 1.23 took: 0.59s\n",
            "Epoch 3, 40% \t train_loss: 1.23 took: 0.61s\n",
            "Epoch 3, 50% \t train_loss: 1.18 took: 0.60s\n",
            "Epoch 3, 60% \t train_loss: 1.18 took: 0.59s\n",
            "Epoch 3, 70% \t train_loss: 1.19 took: 0.60s\n",
            "Epoch 3, 80% \t train_loss: 1.18 took: 0.62s\n",
            "Epoch 3, 90% \t train_loss: 1.21 took: 0.60s\n",
            "Validation loss = 1.27\n",
            "Epoch 4, 10% \t train_loss: 1.11 took: 0.72s\n",
            "Epoch 4, 20% \t train_loss: 1.07 took: 0.61s\n",
            "Epoch 4, 30% \t train_loss: 1.09 took: 0.60s\n",
            "Epoch 4, 40% \t train_loss: 1.08 took: 0.60s\n",
            "Epoch 4, 50% \t train_loss: 1.12 took: 0.60s\n",
            "Epoch 4, 60% \t train_loss: 1.10 took: 0.59s\n",
            "Epoch 4, 70% \t train_loss: 1.14 took: 0.61s\n",
            "Epoch 4, 80% \t train_loss: 1.10 took: 0.61s\n",
            "Epoch 4, 90% \t train_loss: 1.06 took: 0.59s\n",
            "Validation loss = 1.21\n",
            "Epoch 5, 10% \t train_loss: 0.92 took: 0.73s\n",
            "Epoch 5, 20% \t train_loss: 1.00 took: 0.59s\n",
            "Epoch 5, 30% \t train_loss: 0.98 took: 0.61s\n",
            "Epoch 5, 40% \t train_loss: 1.01 took: 0.58s\n",
            "Epoch 5, 50% \t train_loss: 1.00 took: 0.60s\n",
            "Epoch 5, 60% \t train_loss: 1.06 took: 0.60s\n",
            "Epoch 5, 70% \t train_loss: 1.01 took: 0.58s\n",
            "Epoch 5, 80% \t train_loss: 1.02 took: 0.60s\n",
            "Epoch 5, 90% \t train_loss: 1.04 took: 0.60s\n",
            "Validation loss = 1.19\n",
            "Training finished, took 35.59s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "8OFe6H9nnWMo",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Second CNN Network"
      ]
    },
    {
      "metadata": {
        "id": "suWjNnj_pcIU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "2db249e8-af62-4fce-cd2c-d6d7ca4d11df"
      },
      "cell_type": "code",
      "source": [
        "#Input (18, 16, 16) Conv, Output specified = 18 for batch size\n",
        "print((18,\n",
        "       outputSize(in_size=16, kernel_size=3, stride=1, padding=1),\n",
        "       outputSize(in_size=16, kernel_size=3, stride=1, padding=1),\n",
        "      ))\n",
        "\n",
        "#Input (18, 16, 16) MaxPooling\n",
        "print((32,\n",
        "       outputSize(in_size=16, kernel_size=2, stride=2, padding=0),\n",
        "       outputSize(in_size=16, kernel_size=2, stride=2, padding=0),\n",
        "      ))"
      ],
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(18, 16, 16)\n",
            "(32, 8, 8)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "NpodJlTFoLks",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from torch.autograd import Variable\n",
        "import torch.nn.functional as F\n",
        "\n",
        "class LessSimpleCNN(torch.nn.Module):\n",
        "    \n",
        "    #Our batch shape for input x is (3, 32, 32)\n",
        "    \n",
        "    def __init__(self):\n",
        "        super(LessSimpleCNN, self).__init__()\n",
        "        \n",
        "        #Input channels = 3, output channels = 18\n",
        "        self.conv1 = torch.nn.Conv2d(3, 18, kernel_size=3, stride=1, padding=1)\n",
        "        self.pool1 = torch.nn.MaxPool2d(kernel_size=2, stride=2, padding=0)\n",
        "        \n",
        "        #Input channels = 3, output channels = 18\n",
        "        self.conv2 = torch.nn.Conv2d(18, 18, kernel_size=3, stride=1, padding=1)\n",
        "        self.pool2 = torch.nn.MaxPool2d(kernel_size=2, stride=2, padding=0)\n",
        "        \n",
        "        #4608 input features, 64 output features (see sizing flow below)\n",
        "        self.fc1 = torch.nn.Linear(18 * 8 * 8, 120)\n",
        "        \n",
        "         #4608 input features, 64 output features (see sizing flow below)\n",
        "        self.fc2 = torch.nn.Linear(120, 200)\n",
        "        \n",
        "        #64 input features, 10 output features for our 10 defined classes\n",
        "        self.fc3 = torch.nn.Linear(200, 10)\n",
        "        \n",
        "    def forward(self, x):\n",
        "        \n",
        "        #Computes the activation of the first convolution\n",
        "        \n",
        "        #Size changes from (3, 32, 32) to (18, 32, 32)\n",
        "        x = F.relu(self.conv1(x))\n",
        "        #Size changes from (18, 32, 32) to (18, 16, 16)\n",
        "        x = self.pool1(x)\n",
        "        \n",
        "        #Size changes from (3, 32, 32) to (18, 32, 32)\n",
        "        x = F.relu(self.conv2(x))\n",
        "        #Size changes from (18, 32, 32) to (18, 8, 8)\n",
        "        x = self.pool2(x)\n",
        "        \n",
        "        #Reshape data to input to the input layer of the neural net\n",
        "        #Size changes from (18, 8, 8) to (1, 1152)\n",
        "        #Recall that the -1 infers this dimension from the other given dimension\n",
        "        x = x.view(-1, 18 * 8 * 8)\n",
        "        \n",
        "        #Computes the activation of the first fully connected layer\n",
        "        #Size changes from (1, 1152) to (1, 200)\n",
        "        x = F.relu(self.fc1(x))\n",
        "        \n",
        "        #Size changes from (1, 200) to (1, 120)\n",
        "        x = F.relu(self.fc2(x))\n",
        "        \n",
        "        #Computes the second fully connected layer (activation applied later)\n",
        "        #Size changes from (1, 120) to (1, 10)\n",
        "        x = self.fc3(x)\n",
        "        return(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "9bipAPZwoCPa",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1128
        },
        "outputId": "6757df0c-56b1-47a5-f9e4-afb177dedf5f"
      },
      "cell_type": "code",
      "source": [
        "CNN = LessSimpleCNN()\n",
        "trainNet(CNN, batch_size=32, n_epochs=5, learning_rate=0.001)"
      ],
      "execution_count": 117,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "cuda:0\n",
            "===== HYPERPARAMETERS =====\n",
            "batch_size= 32\n",
            "epochs= 5\n",
            "learning_rate= 0.001\n",
            "==============================\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:61: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:62: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 1, 10% \t train_loss: 2.17 took: 0.60s\n",
            "Epoch 1, 20% \t train_loss: 1.97 took: 0.56s\n",
            "Epoch 1, 30% \t train_loss: 1.77 took: 0.75s\n",
            "Epoch 1, 40% \t train_loss: 1.65 took: 0.74s\n",
            "Epoch 1, 50% \t train_loss: 1.61 took: 0.71s\n",
            "Epoch 1, 60% \t train_loss: 1.54 took: 0.71s\n",
            "Epoch 1, 70% \t train_loss: 1.55 took: 0.70s\n",
            "Epoch 1, 80% \t train_loss: 1.49 took: 0.70s\n",
            "Epoch 1, 90% \t train_loss: 1.44 took: 0.72s\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:85: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Validation loss = 1.37\n",
            "Epoch 2, 10% \t train_loss: 1.40 took: 0.83s\n",
            "Epoch 2, 20% \t train_loss: 1.36 took: 0.70s\n",
            "Epoch 2, 30% \t train_loss: 1.27 took: 0.70s\n",
            "Epoch 2, 40% \t train_loss: 1.29 took: 0.68s\n",
            "Epoch 2, 50% \t train_loss: 1.30 took: 0.69s\n",
            "Epoch 2, 60% \t train_loss: 1.29 took: 0.69s\n",
            "Epoch 2, 70% \t train_loss: 1.30 took: 0.67s\n",
            "Epoch 2, 80% \t train_loss: 1.25 took: 0.72s\n",
            "Epoch 2, 90% \t train_loss: 1.23 took: 0.73s\n",
            "Validation loss = 1.22\n",
            "Epoch 3, 10% \t train_loss: 1.17 took: 0.81s\n",
            "Epoch 3, 20% \t train_loss: 1.15 took: 0.69s\n",
            "Epoch 3, 30% \t train_loss: 1.15 took: 0.68s\n",
            "Epoch 3, 40% \t train_loss: 1.16 took: 0.72s\n",
            "Epoch 3, 50% \t train_loss: 1.14 took: 0.69s\n",
            "Epoch 3, 60% \t train_loss: 1.15 took: 0.69s\n",
            "Epoch 3, 70% \t train_loss: 1.13 took: 0.70s\n",
            "Epoch 3, 80% \t train_loss: 1.17 took: 0.68s\n",
            "Epoch 3, 90% \t train_loss: 1.09 took: 0.69s\n",
            "Validation loss = 1.14\n",
            "Epoch 4, 10% \t train_loss: 1.03 took: 0.80s\n",
            "Epoch 4, 20% \t train_loss: 1.03 took: 0.67s\n",
            "Epoch 4, 30% \t train_loss: 1.02 took: 0.69s\n",
            "Epoch 4, 40% \t train_loss: 1.03 took: 0.69s\n",
            "Epoch 4, 50% \t train_loss: 1.06 took: 0.69s\n",
            "Epoch 4, 60% \t train_loss: 1.00 took: 0.70s\n",
            "Epoch 4, 70% \t train_loss: 1.01 took: 0.69s\n",
            "Epoch 4, 80% \t train_loss: 1.03 took: 0.70s\n",
            "Epoch 4, 90% \t train_loss: 1.01 took: 0.69s\n",
            "Validation loss = 1.06\n",
            "Epoch 5, 10% \t train_loss: 0.90 took: 0.81s\n",
            "Epoch 5, 20% \t train_loss: 0.92 took: 0.69s\n",
            "Epoch 5, 30% \t train_loss: 0.94 took: 0.70s\n",
            "Epoch 5, 40% \t train_loss: 0.93 took: 0.68s\n",
            "Epoch 5, 50% \t train_loss: 0.93 took: 0.69s\n",
            "Epoch 5, 60% \t train_loss: 0.91 took: 0.69s\n",
            "Epoch 5, 70% \t train_loss: 0.95 took: 0.68s\n",
            "Epoch 5, 80% \t train_loss: 0.91 took: 0.69s\n",
            "Epoch 5, 90% \t train_loss: 0.94 took: 0.69s\n",
            "Validation loss = 1.07\n",
            "Training finished, took 39.63s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "7zdlNMjiyPeu",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#Test the Network"
      ]
    },
    {
      "metadata": {
        "id": "CzgECBsT2-p_",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#Tensorboard - Pytorch (Soon)\n",
        "#https://github.com/lanpa/tensorboard-pytorch-examples/blob/master/imagenet/main.py"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "wWiO-5doyOHA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 185
        },
        "outputId": "3d60abae-13a6-4125-e369-52c157eed58d"
      },
      "cell_type": "code",
      "source": [
        "dataiter = iter(test_loader)\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)))"
      ],
      "execution_count": 123,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "GroundTruth:   deer plane  ship  frog\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAd8AAACWCAYAAACfIIJIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x7f8dc5d7c080>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "metadata": {
        "id": "BCA0C3g0zomY",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "89db3062-c26b-472a-be82-6cdb7af4950e"
      },
      "cell_type": "code",
      "source": [
        "net = SimpleCNN()\n",
        "outputs = net(images)\n",
        "_, predicted = torch.max(outputs, 1)\n",
        "print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]\n",
        "                              for j in range(4)))"
      ],
      "execution_count": 127,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Predicted:   deer plane plane  deer\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "2yEJcZIJ0DCb",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "462a7a50-14af-4b41-e4f2-b4cc9424fb35"
      },
      "cell_type": "code",
      "source": [
        "#Test in the whole dataset\n",
        "#Better than chance is 10% accuracy (randomly picking a class out of 10 classes). \n",
        "\n",
        "correct = 0\n",
        "total = 0\n",
        "with torch.no_grad():\n",
        "    for data in test_loader:\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 %%' % (\n",
        "    100 * correct / total))"
      ],
      "execution_count": 128,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy of the network on the 10000 test images: 11 %\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "uJtytfAs0FRy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 199
        },
        "outputId": "fdb5542e-8a0b-456d-d4f8-43071292b0d7"
      },
      "cell_type": "code",
      "source": [
        "#Classes that performed well, and the classes that did not perform well:\n",
        "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 test_loader:\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]))"
      ],
      "execution_count": 129,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy of plane : 76 %\n",
            "Accuracy of   car :  0 %\n",
            "Accuracy of  bird :  0 %\n",
            "Accuracy of   cat :  0 %\n",
            "Accuracy of  deer : 36 %\n",
            "Accuracy of   dog :  0 %\n",
            "Accuracy of  frog :  0 %\n",
            "Accuracy of horse :  0 %\n",
            "Accuracy of  ship :  0 %\n",
            "Accuracy of truck :  2 %\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}