--- a
+++ b/MNIST_with_CNN.ipynb
@@ -0,0 +1,1336 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "5qqJjXeFxkxK"
+      },
+      "source": [
+        "# MNIST Code Along with CNN\n",
+        "  <a href='https://en.wikipedia.org/wiki/MNIST_database'></a> let's work the same data with a <a href='https://en.wikipedia.org/wiki/Convolutional_neural_network'>Convolutional Neural Network</a> (CNN).\n",
+        "Make sure to watch the theory lectures! You'll want to be comfortable with:\n",
+        "* convolutional layers\n",
+        "* filters/kernels\n",
+        "* pooling\n",
+        "* depth, stride and zero-padding\n",
+        "\n",
+        "Note that in this exercise there is no need to flatten the MNIST data, as a CNN expects 2-dimensional data."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "pip install torchvision"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "V6dJ49t3x5PU",
+        "outputId": "b42a108c-fbdc-4634-843a-cfbe28895f25"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: torchvision in /usr/local/lib/python3.10/dist-packages (0.16.0+cu118)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from torchvision) (1.23.5)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from torchvision) (2.31.0)\n",
+            "Requirement already satisfied: torch==2.1.0 in /usr/local/lib/python3.10/dist-packages (from torchvision) (2.1.0+cu118)\n",
+            "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.10/dist-packages (from torchvision) (9.4.0)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch==2.1.0->torchvision) (3.13.1)\n",
+            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch==2.1.0->torchvision) (4.5.0)\n",
+            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch==2.1.0->torchvision) (1.12)\n",
+            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch==2.1.0->torchvision) (3.2.1)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch==2.1.0->torchvision) (3.1.2)\n",
+            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch==2.1.0->torchvision) (2023.6.0)\n",
+            "Requirement already satisfied: triton==2.1.0 in /usr/local/lib/python3.10/dist-packages (from torch==2.1.0->torchvision) (2.1.0)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision) (3.3.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision) (3.4)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision) (2.0.7)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision) (2023.7.22)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch==2.1.0->torchvision) (2.1.3)\n",
+            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch==2.1.0->torchvision) (1.3.0)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "I0gOt6sixkxL"
+      },
+      "source": [
+        "## Perform standard imports"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ZiYKA7vwxkxL"
+      },
+      "outputs": [],
+      "source": [
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "import torch.nn.functional as F\n",
+        "from torch.utils.data import DataLoader\n",
+        "from torchvision import datasets, transforms\n",
+        "from torchvision.utils import make_grid\n",
+        "\n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "from sklearn.metrics import confusion_matrix\n",
+        "import matplotlib.pyplot as plt\n",
+        "%matplotlib inline"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nBpZ5SyaxkxL"
+      },
+      "source": [
+        "## Load the MNIST dataset\n",
+        "PyTorch makes the MNIST train and test datasets available through <a href='https://pytorch.org/docs/stable/torchvision/index.html'><tt><strong>torchvision</strong></tt></a>. The first time they're called, the datasets will be downloaded onto your computer to the path specified. From that point, torchvision will always look for a local copy before attempting another download.\n",
+        "\n",
+        "Refer to the previous section for explanations of transformations, batch sizes and <a href='https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader'><tt><strong>DataLoader</strong></tt></a>."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "cOVtdy8OxkxM",
+        "outputId": "9c642f75-c165-43e0-d692-d6f0e53126b7"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
+            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ../Data/MNIST/raw/train-images-idx3-ubyte.gz\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "100%|██████████| 9912422/9912422 [00:00<00:00, 71259373.24it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Extracting ../Data/MNIST/raw/train-images-idx3-ubyte.gz to ../Data/MNIST/raw\n",
+            "\n",
+            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
+            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ../Data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "100%|██████████| 28881/28881 [00:00<00:00, 78455760.25it/s]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Extracting ../Data/MNIST/raw/train-labels-idx1-ubyte.gz to ../Data/MNIST/raw\n",
+            "\n",
+            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ../Data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "100%|██████████| 1648877/1648877 [00:00<00:00, 23057121.60it/s]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Extracting ../Data/MNIST/raw/t10k-images-idx3-ubyte.gz to ../Data/MNIST/raw\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
+            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ../Data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "100%|██████████| 4542/4542 [00:00<00:00, 13312738.48it/s]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Extracting ../Data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ../Data/MNIST/raw\n",
+            "\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "transform = transforms.ToTensor()\n",
+        "\n",
+        "train_data = datasets.MNIST(root='../Data', train=True, download=True, transform=transform)\n",
+        "test_data = datasets.MNIST(root='../Data', train=False, download=True, transform=transform)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ThZMPjBHxkxM",
+        "outputId": "32df1e42-2911-459a-ffb1-817b7462f659"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Dataset MNIST\n",
+              "    Number of datapoints: 60000\n",
+              "    Root location: ../Data\n",
+              "    Split: Train\n",
+              "    StandardTransform\n",
+              "Transform: ToTensor()"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 4
+        }
+      ],
+      "source": [
+        "train_data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "OgYyG1ZbxkxM",
+        "outputId": "acd87b03-4808-453e-8153-9b7535795c61"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Dataset MNIST\n",
+              "    Number of datapoints: 10000\n",
+              "    Root location: ../Data\n",
+              "    Split: Test\n",
+              "    StandardTransform\n",
+              "Transform: ToTensor()"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 5
+        }
+      ],
+      "source": [
+        "test_data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "PBXoRJuPxkxN"
+      },
+      "source": [
+        "### Create loaders\n",
+        "When working with images, we want relatively small batches; a batch size of 4 is not uncommon."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "s3wKS5klxkxN"
+      },
+      "outputs": [],
+      "source": [
+        "train_loader = DataLoader(train_data, batch_size=10, shuffle=True)\n",
+        "test_loader = DataLoader(test_data, batch_size=10, shuffle=False)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "31W9Nv8BxkxN"
+      },
+      "source": [
+        "## Define a convolutional model\n",
+        "In the previous section we used only fully connected layers, with an input layer of 784 (our flattened 28x28 images), hidden layers of 120 and 84 neurons, and an output size representing 10 possible digits.\n",
+        "\n",
+        "This time we'll employ two convolutional layers and two pooling layers before feeding data through fully connected hidden layers to our output. The model follows CONV/RELU/POOL/CONV/RELU/POOL/FC/RELU/FC."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "IhwT70wZxkxN"
+      },
+      "source": [
+        "<div class=\"alert alert-info\"><strong>Let's walk through the steps we're about to take.</strong><br>\n",
+        "\n",
+        "1. Extend the base Module class:\n",
+        "   \n",
+        "<tt><font color=black>class ConvolutionalNetwork(nn.Module):<br>\n",
+        "&nbsp;&nbsp;&nbsp;&nbsp;def \\_\\_init\\_\\_(self):<br>\n",
+        "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;super().\\_\\_init\\_\\_()</font></tt><br>\n",
+        "\n",
+        "2. Set up the convolutional layers with <a href='https://pytorch.org/docs/stable/nn.html#conv2d'><tt><strong>torch.nn.Conv2d()</strong></tt></a><br><br>The first layer has one input channel (the grayscale color channel). We'll assign 6 output channels for feature extraction. We'll set our kernel size to 3 to make a 3x3 filter, and set the step size to 1.<br>\n",
+        "<tt><font color=black>&nbsp;&nbsp;&nbsp;&nbsp;self.conv1 = nn.Conv2d(1, 6, 3, 1)</font></tt><br>\n",
+        "The second layer will take our 6 input channels and deliver 16 output channels.<br>\n",
+        "<tt><font color=black>&nbsp;&nbsp;&nbsp;&nbsp;self.conv2 = nn.Conv2d(6, 16, 3, 1)</font></tt><br><br>\n",
+        "\n",
+        "3. Set up the fully connected layers with <a href='https://pytorch.org/docs/stable/nn.html#linear'><tt><strong>torch.nn.Linear()</strong></tt></a>.<br><br>The input size of (5x5x16) is determined by the effect of our kernels on the input image size. A 3x3 filter applied to a 28x28 image leaves a 1-pixel edge on all four sides. In one layer the size changes from 28x28 to 26x26. We could address this with zero-padding, but since an MNIST image is mostly black at the edges, we should be safe ignoring these pixels. We'll apply the kernel twice, and apply pooling layers twice, so our resulting output will be\n",
+        "$\\;(((28-2)/2)-2)/2 = 5.5\\;$ which rounds down to 5 pixels per side.<br>\n",
+        "<tt><font color=black>&nbsp;&nbsp;&nbsp;&nbsp;self.fc1 = nn.Linear(5\\*5\\*16, 120)</font></tt><br>\n",
+        "<tt><font color=black>&nbsp;&nbsp;&nbsp;&nbsp;self.fc2 = nn.Linear(120, 84)</font></tt><br>\n",
+        "<tt><font color=black>&nbsp;&nbsp;&nbsp;&nbsp;self.fc3 = nn.Linear(84, 10)</font></tt><br>\n",
+        "See below for a more detailed look at this step.<br><br>\n",
+        "\n",
+        "4. Define the forward method.<br><br>Activations can be applied to the convolutions in one line using <a href='https://pytorch.org/docs/stable/nn.html#id27'><tt><strong>F.relu()</strong></tt></a> and pooling is done using <a href='https://pytorch.org/docs/stable/nn.html#maxpool2d'><tt><strong>F.max_pool2d()</strong></tt></a><br>\n",
+        "<tt><font color=black>def forward(self, X):<br>\n",
+        "&nbsp;&nbsp;&nbsp;&nbsp;X = F.relu(self.conv1(X))<br>\n",
+        "&nbsp;&nbsp;&nbsp;&nbsp;X = F.max_pool2d(X, 2, 2)<br>\n",
+        "&nbsp;&nbsp;&nbsp;&nbsp;X = F.relu(self.conv2(X))<br>\n",
+        "&nbsp;&nbsp;&nbsp;&nbsp;X = F.max_pool2d(X, 2, 2)<br>\n",
+        "</font></tt>Flatten the data for the fully connected layers:<br><tt><font color=black>\n",
+        "&nbsp;&nbsp;&nbsp;&nbsp;X = X.view(-1, 5\\*5\\*16)<br>\n",
+        "&nbsp;&nbsp;&nbsp;&nbsp;X = F.relu(self.fc1(X))<br>\n",
+        "&nbsp;&nbsp;&nbsp;&nbsp;X = self.fc2(X)<br>\n",
+        "&nbsp;&nbsp;&nbsp;&nbsp;return F.log_softmax(X, dim=1)</font></tt>\n",
+        "</div>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "jItof2UxxkxN"
+      },
+      "source": [
+        "<div class=\"alert alert-danger\"><strong>Breaking down the convolutional layers</strong> (this code is for illustration purposes only.)</div>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "3pFGRAjLxkxO"
+      },
+      "outputs": [],
+      "source": [
+        "# Define layers\n",
+        "#1 COLOR CHANNEL, 6 FILTERS (OUTPUT CHANNELS IN CONVOLUTIONAL LAYER), 3 by 3 KERNAL , STRIDE=1\n",
+        "#6 filters -->pooling --> conv2     So even after pooling, we're still going to have\n",
+        "#those six filters, although there'll be a little smaller being pooled. Next check 2nd layer\n",
+        "conv1 = nn.Conv2d(1, 6, 3, 1)#One that takes in the direct image input is going to be expanded so that it has\n",
+        "#the six filters and thats going into some pooling layers and then feeding into convolution\n",
+        "#layer number two. So even after pooling we're still going to have those six filters, although there'll be a little smaller after\n",
+        "#being pooled\n",
+        "\n",
+        "\n",
+        "#first layer has one input channel, the reason is because we\n",
+        "#are dealing with gray scale  images later on, we can expand on this for color images.\n",
+        "#So we have convolutional 2D its for one gray scale channel, thats our one input channel\n",
+        "\n",
+        "\n",
+        "#Step2 : then we assign 6 output channels for feature extraction, and these are known as feature maps, Essentially\n",
+        "#the filters that the convolutional neural network will figure out for us. And then since we have six of those, the next thing we\n",
+        "#need to say is, well,  how big are each of those.\n",
+        "\n",
+        "#And 3 represents kernal size comes into play. So we will say its three so we have\n",
+        "#a 3 by 3 filter.\n",
+        "\n",
+        "#And then this last one is the step size to one. So if you take a look at shift\n",
+        "#tab here again one more time and we expand on this, we have essentially our stepsize or our stride\n",
+        "#How big are we going....     And also you can also do thing like padding\n",
+        "\n",
+        "#this is another convolutional layer going to be with different numbers?\n",
+        "#Well, this convolutional layer is going to end up taking the result of the first\n",
+        "#convolutional layer after it's been passed through a pooling function.\n",
+        "#So eventually we'see when we actually build out our network, this convolution layer\n",
+        "#the first one that takes in the direct image input is going to be expanded so that  it has\n",
+        "#six filters and\n",
+        "conv2 = nn.Conv2d(6, 16, 3, 1)#that how first 6 comes from, So this convolutional layer, we dicided kind of arbitary that there will\n",
+        "#be six filters, you can definetly play around with number of filters, recall more outputs channels or more image\n",
+        "#kernels / filters the longer the trianing time will take. So here we have 6, that's\n",
+        "#Were this first six comes from and then 16 kind of another arbitory choice. So if we start defining this,we have those six\n",
+        "#input filters and that was from convolution layer number one. and then we can decide , well how many filters should convolutional layer number  2 expand to.\n",
+        "#So i will go ahead and say 16 filters, again this is kind of an arbitary choice.\n",
+        "#So its an arbitary choice for this number of six filters and an arbitary choice for these 16 filters, Hopefully you can experiment with them\n",
+        "#and see what is the optimal amount of filters..\n",
+        "#And next we need to decide , what kernel size should we use? 3 by 3\n",
+        "#And finally what is stride here? stride  =1"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "qjPATZHMxkxO"
+      },
+      "outputs": [],
+      "source": [
+        "# Grab the first MNIST record\n",
+        "for i, (X_train, y_train) in enumerate(train_data):\n",
+        "    break"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "mB8gD6p6xkxO",
+        "outputId": "25862723-f642-486a-a892-33eac1098fa9"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([1, 1, 28, 28])\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Create a rank-4 tensor to be passed into the model\n",
+        "# (train_loader will have done this already)\n",
+        "x = X_train.view(1,1,28,28)\n",
+        "print(x.shape)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "u6U3J6SLxkxO",
+        "outputId": "8543c752-4a61-49e7-a64a-2a2874d99229"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([1, 6, 26, 26])\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Perform the first convolution/activation\n",
+        "x = F.relu(conv1(x))\n",
+        "print(x.shape)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "JQd9AgMbxkxO",
+        "outputId": "abbb8db4-25e3-4c64-e077-43a6d76960d6"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([1, 6, 13, 13])\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Run the first pooling layer\n",
+        "x = F.max_pool2d(x, 2, 2)\n",
+        "print(x.shape)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "GJHfLdQ3xkxO",
+        "outputId": "74a47d61-9d30-4fdc-855f-0f8b8b52fb2d"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([1, 16, 11, 11])\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Perform the second convolution/activation\n",
+        "x = F.relu(conv2(x)) # rectified linear unit activation function\n",
+        "print(x.shape)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "TGd1AKY9xkxP",
+        "outputId": "748143c9-8665-4db1-b761-7c91cfc18481"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([1, 16, 5, 5])\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Run the second pooling layer\n",
+        "x = F.max_pool2d(x, 2, 2)\n",
+        "print(x.shape)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "uXBOU85ZxkxP",
+        "outputId": "9ce241c8-eaaf-486c-a123-441c578c5074"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([1, 400])\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Flatten the data\n",
+        "x = x.view(-1, 5*5*16)\n",
+        "print(x.shape)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "dB9HYsPGxkxP"
+      },
+      "source": [
+        "<div class=\"alert alert-danger\"><strong>This is how the convolution output is passed into the fully connected layers.</strong></div>\n",
+        "\n",
+        "Now let's run the code."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xr6P1vH5xkxP"
+      },
+      "outputs": [],
+      "source": [
+        "class ConvolutionalNetwork(nn.Module):\n",
+        "    def __init__(self):\n",
+        "        super().__init__()\n",
+        "        self.conv1 = nn.Conv2d(1, 6, 3, 1)\n",
+        "        self.conv2 = nn.Conv2d(6, 16, 3, 1)\n",
+        "        self.fc1 = nn.Linear(5*5*16, 120)\n",
+        "        self.fc2 = nn.Linear(120, 84)\n",
+        "        self.fc3 = nn.Linear(84,10)\n",
+        "\n",
+        "    def forward(self, X):\n",
+        "        X = F.relu(self.conv1(X))\n",
+        "        X = F.max_pool2d(X, 2, 2) # 2 * 2 kernal for the stride of 2\n",
+        "        X = F.relu(self.conv2(X))\n",
+        "        X = F.max_pool2d(X, 2, 2)\n",
+        "        X = X.view(-1, 5*5*16)\n",
+        "        X = F.relu(self.fc1(X))\n",
+        "        X = F.relu(self.fc2(X))\n",
+        "        X = self.fc3(X)\n",
+        "        return F.log_softmax(X, dim=1)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "gSxmhlwwxkxP",
+        "outputId": "e56384ec-6549-47ae-eaf7-347989e8b0b1"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "ConvolutionalNetwork(\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=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",
+              ")"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 16
+        }
+      ],
+      "source": [
+        "torch.manual_seed(42)\n",
+        "model = ConvolutionalNetwork()\n",
+        "model"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "jNPD9fnkxkxP"
+      },
+      "source": [
+        "Including the bias terms for each layer, the total number of parameters being trained is:<br>\n",
+        "\n",
+        "$\\quad\\begin{split}(1\\times6\\times3\\times3)+6+(6\\times16\\times3\\times3)+16+(400\\times120)+120+(120\\times84)+84+(84\\times10)+10 &=\\\\\n",
+        "54+6+864+16+48000+120+10080+84+840+10 &= 60,074\\end{split}$<br>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "T8t53Ae0xkxQ"
+      },
+      "outputs": [],
+      "source": [
+        "def count_parameters(model):\n",
+        "    params = [p.numel() for p in model.parameters() if p.requires_grad]\n",
+        "    for item in params:\n",
+        "        print(f'{item:>6}')\n",
+        "    print(f'______\\n{sum(params):>6}')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "i40IgWLvxkxQ",
+        "outputId": "dda995c6-3cc8-4335-e27f-82d499d247cf"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "    54\n",
+            "     6\n",
+            "   864\n",
+            "    16\n",
+            " 48000\n",
+            "   120\n",
+            " 10080\n",
+            "    84\n",
+            "   840\n",
+            "    10\n",
+            "______\n",
+            " 60074\n"
+          ]
+        }
+      ],
+      "source": [
+        "count_parameters(model)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "5jYEO3KPxkxQ"
+      },
+      "source": [
+        "## Define loss function & optimizer"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "6zR8yjZ1xkxQ"
+      },
+      "outputs": [],
+      "source": [
+        "criterion = nn.CrossEntropyLoss()\n",
+        "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "vAtiL_znxkxQ"
+      },
+      "source": [
+        "## Train the model\n",
+        "This time we'll feed the data directly into the model without flattening it first."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KAbf-7uFxkxQ",
+        "outputId": "6b69b27c-9592-430c-cda9-9cac6e2f7a18"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "epoch:  0  batch:  600 [  6000/60000]  loss: 0.04055627  accuracy:  78.417%\n",
+            "epoch:  0  batch: 1200 [ 12000/60000]  loss: 0.08253475  accuracy:  85.800%\n",
+            "epoch:  0  batch: 1800 [ 18000/60000]  loss: 0.36470491  accuracy:  88.689%\n",
+            "epoch:  0  batch: 2400 [ 24000/60000]  loss: 0.01825025  accuracy:  90.525%\n",
+            "epoch:  0  batch: 3000 [ 30000/60000]  loss: 0.00806704  accuracy:  91.650%\n",
+            "epoch:  0  batch: 3600 [ 36000/60000]  loss: 0.00116694  accuracy:  92.503%\n",
+            "epoch:  0  batch: 4200 [ 42000/60000]  loss: 0.52552539  accuracy:  93.152%\n",
+            "epoch:  0  batch: 4800 [ 48000/60000]  loss: 0.03260820  accuracy:  93.617%\n",
+            "epoch:  0  batch: 5400 [ 54000/60000]  loss: 0.00746816  accuracy:  94.028%\n",
+            "epoch:  0  batch: 6000 [ 60000/60000]  loss: 0.03889676  accuracy:  94.340%\n",
+            "epoch:  1  batch:  600 [  6000/60000]  loss: 0.03282820  accuracy:  97.817%\n",
+            "epoch:  1  batch: 1200 [ 12000/60000]  loss: 0.04554177  accuracy:  97.867%\n",
+            "epoch:  1  batch: 1800 [ 18000/60000]  loss: 0.00578480  accuracy:  97.939%\n",
+            "epoch:  1  batch: 2400 [ 24000/60000]  loss: 0.02235614  accuracy:  97.879%\n",
+            "epoch:  1  batch: 3000 [ 30000/60000]  loss: 0.21643038  accuracy:  97.897%\n",
+            "epoch:  1  batch: 3600 [ 36000/60000]  loss: 0.00501452  accuracy:  97.906%\n",
+            "epoch:  1  batch: 4200 [ 42000/60000]  loss: 0.00045869  accuracy:  97.974%\n",
+            "epoch:  1  batch: 4800 [ 48000/60000]  loss: 0.00192951  accuracy:  97.996%\n",
+            "epoch:  1  batch: 5400 [ 54000/60000]  loss: 0.00085962  accuracy:  98.004%\n",
+            "epoch:  1  batch: 6000 [ 60000/60000]  loss: 0.08304359  accuracy:  98.007%\n",
+            "epoch:  2  batch:  600 [  6000/60000]  loss: 0.00063734  accuracy:  98.683%\n",
+            "epoch:  2  batch: 1200 [ 12000/60000]  loss: 0.00153934  accuracy:  98.542%\n",
+            "epoch:  2  batch: 1800 [ 18000/60000]  loss: 0.00128017  accuracy:  98.478%\n",
+            "epoch:  2  batch: 2400 [ 24000/60000]  loss: 0.00139678  accuracy:  98.533%\n",
+            "epoch:  2  batch: 3000 [ 30000/60000]  loss: 0.30444741  accuracy:  98.467%\n",
+            "epoch:  2  batch: 3600 [ 36000/60000]  loss: 0.01445190  accuracy:  98.461%\n",
+            "epoch:  2  batch: 4200 [ 42000/60000]  loss: 0.02198282  accuracy:  98.483%\n",
+            "epoch:  2  batch: 4800 [ 48000/60000]  loss: 0.00078029  accuracy:  98.496%\n",
+            "epoch:  2  batch: 5400 [ 54000/60000]  loss: 0.00168332  accuracy:  98.498%\n",
+            "epoch:  2  batch: 6000 [ 60000/60000]  loss: 0.00020764  accuracy:  98.492%\n",
+            "epoch:  3  batch:  600 [  6000/60000]  loss: 0.00079474  accuracy:  98.883%\n",
+            "epoch:  3  batch: 1200 [ 12000/60000]  loss: 0.00203867  accuracy:  99.017%\n",
+            "epoch:  3  batch: 1800 [ 18000/60000]  loss: 0.00046899  accuracy:  99.028%\n",
+            "epoch:  3  batch: 2400 [ 24000/60000]  loss: 0.00021816  accuracy:  98.938%\n",
+            "epoch:  3  batch: 3000 [ 30000/60000]  loss: 0.03142365  accuracy:  98.933%\n",
+            "epoch:  3  batch: 3600 [ 36000/60000]  loss: 0.00734946  accuracy:  98.875%\n",
+            "epoch:  3  batch: 4200 [ 42000/60000]  loss: 0.00061036  accuracy:  98.893%\n",
+            "epoch:  3  batch: 4800 [ 48000/60000]  loss: 0.13828447  accuracy:  98.902%\n",
+            "epoch:  3  batch: 5400 [ 54000/60000]  loss: 0.00074584  accuracy:  98.898%\n",
+            "epoch:  3  batch: 6000 [ 60000/60000]  loss: 0.02092968  accuracy:  98.897%\n",
+            "epoch:  4  batch:  600 [  6000/60000]  loss: 0.00093785  accuracy:  99.250%\n",
+            "epoch:  4  batch: 1200 [ 12000/60000]  loss: 0.19402172  accuracy:  99.158%\n",
+            "epoch:  4  batch: 1800 [ 18000/60000]  loss: 0.00067582  accuracy:  99.067%\n",
+            "epoch:  4  batch: 2400 [ 24000/60000]  loss: 0.00019682  accuracy:  99.067%\n",
+            "epoch:  4  batch: 3000 [ 30000/60000]  loss: 0.00540381  accuracy:  99.033%\n",
+            "epoch:  4  batch: 3600 [ 36000/60000]  loss: 0.00058351  accuracy:  99.056%\n",
+            "epoch:  4  batch: 4200 [ 42000/60000]  loss: 0.00117376  accuracy:  99.069%\n",
+            "epoch:  4  batch: 4800 [ 48000/60000]  loss: 0.00185656  accuracy:  99.017%\n",
+            "epoch:  4  batch: 5400 [ 54000/60000]  loss: 0.00024844  accuracy:  98.993%\n",
+            "epoch:  4  batch: 6000 [ 60000/60000]  loss: 0.00652279  accuracy:  99.002%\n",
+            "\n",
+            "Duration: 230 seconds\n"
+          ]
+        }
+      ],
+      "source": [
+        "import time\n",
+        "start_time = time.time()\n",
+        "\n",
+        "epochs = 5\n",
+        "train_losses = []\n",
+        "test_losses = []\n",
+        "train_correct = []\n",
+        "test_correct = []\n",
+        "\n",
+        "for i in range(epochs):\n",
+        "    trn_corr = 0\n",
+        "    tst_corr = 0\n",
+        "\n",
+        "    # Run the training batches\n",
+        "    for b, (X_train, y_train) in enumerate(train_loader):\n",
+        "        b+=1\n",
+        "\n",
+        "        # Apply the model\n",
+        "        y_pred = model(X_train)  # we don't flatten X-train here\n",
+        "        loss = criterion(y_pred, y_train)\n",
+        "\n",
+        "        # Tally the number of correct predictions\n",
+        "        predicted = torch.max(y_pred.data, 1)[1]\n",
+        "        batch_corr = (predicted == y_train).sum()\n",
+        "        trn_corr += batch_corr\n",
+        "\n",
+        "        # Update parameters\n",
+        "        optimizer.zero_grad()\n",
+        "        loss.backward()\n",
+        "        optimizer.step()\n",
+        "\n",
+        "        # Print interim results\n",
+        "        if b%600 == 0:\n",
+        "            print(f'epoch: {i:2}  batch: {b:4} [{10*b:6}/60000]  loss: {loss.item():10.8f}  \\\n",
+        "accuracy: {trn_corr.item()*100/(10*b):7.3f}%')\n",
+        "\n",
+        "    train_losses.append(loss.item())\n",
+        "    train_correct.append(trn_corr.item())\n",
+        "\n",
+        "    # Run the testing batches\n",
+        "    with torch.no_grad():\n",
+        "        for b, (X_test, y_test) in enumerate(test_loader):\n",
+        "\n",
+        "            # Apply the model\n",
+        "            y_val = model(X_test)\n",
+        "\n",
+        "            # Tally the number of correct predictions\n",
+        "            predicted = torch.max(y_val.data, 1)[1]\n",
+        "            tst_corr += (predicted == y_test).sum()\n",
+        "\n",
+        "    loss = criterion(y_val, y_test)\n",
+        "    test_losses.append(loss)\n",
+        "    test_correct.append(tst_corr)\n",
+        "\n",
+        "print(f'\\nDuration: {time.time() - start_time:.0f} seconds') # print the time elapsed"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "7EFCbduwxkxQ"
+      },
+      "source": [
+        "## Plot the loss and accuracy comparisons"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 452
+        },
+        "id": "O57nu-zyxkxR",
+        "outputId": "508d4111-9f61-4762-84ee-f293070332a3"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "plt.plot(train_losses, label='training loss')\n",
+        "plt.plot(test_losses, label='validation loss')\n",
+        "plt.title('Loss at the end of each epoch')\n",
+        "plt.legend();"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "JdQiw0cxxkxR",
+        "outputId": "28696e72-9d1d-4d2d-d285-ee6cef2ff05d"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "[tensor(0.0036),\n",
+              " tensor(0.0037),\n",
+              " tensor(0.0016),\n",
+              " tensor(0.0003),\n",
+              " tensor(3.6928e-05)]"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 22
+        }
+      ],
+      "source": [
+        "test_losses"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "sXiMb_YexkxR"
+      },
+      "source": [
+        "While there may be some overfitting of the training data, there is far less than we saw with the ANN model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 452
+        },
+        "id": "7cVz6qMFxkxR",
+        "outputId": "337541fe-0819-46d4-a1c6-e84f93a717ee"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "plt.plot([t/600 for t in train_correct], label='training accuracy')\n",
+        "plt.plot([t/100 for t in test_correct], label='validation accuracy')\n",
+        "plt.title('Accuracy at the end of each epoch')\n",
+        "plt.legend();"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ccfn4VGGxkxR"
+      },
+      "source": [
+        "## Evaluate Test Data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "3MQViOr-xkxR"
+      },
+      "outputs": [],
+      "source": [
+        "# Extract the data all at once, not in batches\n",
+        "test_load_all = DataLoader(test_data, batch_size=10000, shuffle=False)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "dyHy1aK6xkxR",
+        "outputId": "346a8072-a19c-4cf2-9b72-2146bf405dc8"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Test accuracy: 9889/10000 =  98.890%\n"
+          ]
+        }
+      ],
+      "source": [
+        "with torch.no_grad():\n",
+        "    correct = 0\n",
+        "    for X_test, y_test in test_load_all:\n",
+        "        y_val = model(X_test)  # we don't flatten the data this time\n",
+        "        predicted = torch.max(y_val,1)[1]\n",
+        "        correct += (predicted == y_test).sum()\n",
+        "print(f'Test accuracy: {correct.item()}/{len(test_data)} = {correct.item()*100/(len(test_data)):7.3f}%')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "So recall that our artificial neural network returned an accuracy of 97.24% after ten epochs. How ever it has to use upto 100,000 parameters and we used around 60,000. So doing better with less parameters"
+      ],
+      "metadata": {
+        "id": "VOvawrikLD6a"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "zbj0W2tHxkxZ"
+      },
+      "source": [
+        "Recall that our [784,120,84,10] ANN returned an accuracy of 97.25% after 10 epochs. And it used 105,214 parameters to our current 60,074."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "goOpdbk2xkxa"
+      },
+      "source": [
+        "## Display the confusion matrix"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "7ovpy-FAxkxa",
+        "outputId": "5f0d6399-663f-458a-dcec-22330fec000c"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[[   0    1    2    3    4    5    6    7    8    9]]\n",
+            "\n",
+            "[[ 977    3    1    0    0    2    4    1    4    0]\n",
+            " [   0 1130    2    0    0    0    1    4    0    3]\n",
+            " [   0    1 1022    0    0    0    0    4    2    0]\n",
+            " [   0    0    3 1007    0    7    0    2    2    2]\n",
+            " [   0    0    1    0  971    0    1    0    0    5]\n",
+            " [   0    0    0    1    0  879    7    0    1    5]\n",
+            " [   1    1    0    0    4    2  944    0    1    0]\n",
+            " [   1    0    3    0    0    0    0 1013    1    2]\n",
+            " [   1    0    0    2    1    1    1    1  962    8]\n",
+            " [   0    0    0    0    6    1    0    3    1  984]]\n"
+          ]
+        }
+      ],
+      "source": [
+        "# print a row of values for reference\n",
+        "np.set_printoptions(formatter=dict(int=lambda x: f'{x:4}'))\n",
+        "print(np.arange(10).reshape(1,10))\n",
+        "print()\n",
+        "\n",
+        "# print the confusion matrix\n",
+        "print(confusion_matrix(predicted.view(-1), y_test.view(-1)))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BIJ01-8vxkxa"
+      },
+      "source": [
+        "## Examine the misses\n",
+        "We can track the index positions of \"missed\" predictions, and extract the corresponding image and label. We'll do this in batches to save screen space."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "h5FuulHExkxa",
+        "outputId": "a08162d0-6297-47e3-fc3d-d9fbabe97727"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "111"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 27
+        }
+      ],
+      "source": [
+        "misses = np.array([])\n",
+        "for i in range(len(predicted.view(-1))):\n",
+        "    if predicted[i] != y_test[i]:\n",
+        "        misses = np.append(misses,i).astype('int64')\n",
+        "\n",
+        "# Display the number of misses\n",
+        "len(misses)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "gFD7OZtaxkxa",
+        "outputId": "84924b05-0766-4c9b-d4f4-cb0d00f7fd4c"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "array([  18,   62,  184,  247,  320,  321,  340,  359,  445,  448])"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 28
+        }
+      ],
+      "source": [
+        "# Display the first 10 index positions\n",
+        "misses[:10]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "AnF8biN8xkxa"
+      },
+      "outputs": [],
+      "source": [
+        "# Set up an iterator to feed batched rows\n",
+        "r = 12   # row size\n",
+        "row = iter(np.array_split(misses,len(misses)//r+1))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Ptg2abWWxkxa"
+      },
+      "source": [
+        "Now that everything is set up, run and re-run the cell below to view all of the missed predictions.<br>\n",
+        "Use <kbd>Ctrl+Enter</kbd> to remain on the cell between runs. You'll see a <tt>StopIteration</tt> once all the misses have been seen."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 185
+        },
+        "id": "t3QCnUDZxkxb",
+        "outputId": "2dbe97f5-363c-4841-810a-da0bc9822534"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Index: [  18   62  184  247  320  321  340  359  445  448  495  582]\n",
+            "Label: [   3    9    8    4    9    2    5    9    6    9    8    8]\n",
+            "Guess: [   8    5    3    6    8    7    3    4    0    8    0    2]\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x400 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "nextrow = next(row)\n",
+        "print(\"Index:\", nextrow)\n",
+        "print(\"Label:\", y_test.index_select(0,torch.tensor(nextrow)).numpy())\n",
+        "print(\"Guess:\", predicted.index_select(0,torch.tensor(nextrow)).numpy())\n",
+        "\n",
+        "images = X_test.index_select(0,torch.tensor(nextrow))\n",
+        "im = make_grid(images, nrow=r)\n",
+        "plt.figure(figsize=(10,4))\n",
+        "plt.imshow(np.transpose(im.numpy(), (1, 2, 0)));"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "hMD2d-Clxkxb"
+      },
+      "source": [
+        "## Run a new image through the model\n",
+        "We can also pass a single image through the model to obtain a prediction.\n",
+        "Pick a number from 0 to 9999, assign it to \"x\", and we'll use that value to select a number from the MNIST test set."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 141
+        },
+        "id": "2_g1t1Vmxkxb",
+        "outputId": "fb44c4ba-9c3a-4d4c-cf13-8d5e62e60f2e"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 100x100 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "x = 2019\n",
+        "plt.figure(figsize=(1,1))\n",
+        "plt.imshow(test_data[x][0].reshape((28,28)), cmap=\"gist_yarg\");"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "YVJ8GY3pxkxb",
+        "outputId": "7b78fd93-3f88-486b-d2d6-744a3697b6fa"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Predicted value: 9\n"
+          ]
+        }
+      ],
+      "source": [
+        "model.eval()\n",
+        "with torch.no_grad():\n",
+        "    new_pred = model(test_data[x][0].view(1,1,28,28)).argmax()\n",
+        "print(\"Predicted value:\",new_pred.item())"
+      ]
+    }
+  ],
+  "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.0"
+    },
+    "colab": {
+      "provenance": []
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file