SimpleNeuralNetwork(ImageClassification)_Pytorch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mdabir1203/42_WOB_AI_Community/blob/main/SimpleNeuralNetwork(ImageClassification)_Pytorch.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Building a simple neural Network with FashionMNIST database**"
      ],
      "metadata": {
        "id": "YAfnc1Ke3nBS"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WU9et4t83lE2",
        "outputId": "521ab9bf-4b1e-423b-ffac-665b0cece070"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz to F_MNIST_data/FashionMNIST/raw/train-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 26421880/26421880 [00:01<00:00, 16504851.60it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting F_MNIST_data/FashionMNIST/raw/train-images-idx3-ubyte.gz to F_MNIST_data/FashionMNIST/raw\n",
            "\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz to F_MNIST_data/FashionMNIST/raw/train-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 29515/29515 [00:00<00:00, 306285.00it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting F_MNIST_data/FashionMNIST/raw/train-labels-idx1-ubyte.gz to F_MNIST_data/FashionMNIST/raw\n",
            "\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz to F_MNIST_data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 4422102/4422102 [00:00<00:00, 5530945.96it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting F_MNIST_data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz to F_MNIST_data/FashionMNIST/raw\n",
            "\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz to F_MNIST_data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5148/5148 [00:00<00:00, 4214772.01it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting F_MNIST_data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to F_MNIST_data/FashionMNIST/raw\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torchvision import datasets, transforms\n",
        "import matplotlib.pyplot as plt\n",
        "from collections import OrderedDict\n",
        "\n",
        "# Download training and testing data\n",
        "transform = transforms.Compose([transforms.ToTensor(),\n",
        "                                transforms.Normalize((0.5,), (0.5,))])\n",
        "train_ds = datasets.FashionMNIST('F_MNIST_data', download=True, train=True, transform=transform)\n",
        "test_ds = datasets.FashionMNIST('F_MNIST_data', download=True, train=False, transform=transform)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# split train set into training (80%) and validation set (20%)\n",
        "# Good read: https://stackoverflow.com/questions/68104922/optimal-split-for-training-validation-and-testing-sets\n",
        "\n",
        "train_num = len(train_ds)\n",
        "indices = list(range(train_num))\n",
        "np.random.shuffle(indices)\n",
        "split = int(np.floor(0.2 * train_num))\n",
        "val_idx, train_idx = indices[:split], indices[split:]\n",
        "len(val_idx), len(train_idx)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pOmHafXE31BF",
        "outputId": "4d29a8b5-4f9f-4b6b-e3a0-1e66e3a048cd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(12000, 48000)"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# prepare dataloaders\n",
        "## code block that shows how to load and display an image from the Fashion-MNIST dataset, which is a collection of 70,000 grayscale images of 10 different types of clothing items.\n",
        "#Would show different colors for different intensities, which would not reflect the original image. Grayscale is a common choice for plotting images that have one channel.\n",
        "\n",
        "## Batch Size --> How many examples you use to train your model at one time .  It is not too small or too large, and it can fit well in the memory of your CPU or GPU\n",
        "\n",
        "train_sampler = torch.utils.data.sampler.SubsetRandomSampler(train_idx)\n",
        "train_dl = torch.utils.data.DataLoader(train_ds, batch_size=64, sampler=train_sampler)\n",
        "val_sampler = torch.utils.data.sampler.SubsetRandomSampler(val_idx)\n",
        "val_dl = torch.utils.data.DataLoader(train_ds, batch_size=64, sampler=val_sampler)\n",
        "test_dl = torch.utils.data.DataLoader(test_ds, batch_size=64, shuffle=True)"
      ],
      "metadata": {
        "id": "NKMvQPuu4A80"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "image, label = next(iter(train_dl))\n",
        "print(image[0].shape, label.shape)\n",
        "desc = ['T-shirt/top','Trouser','Pullover','Dress','Coat','Sandal','Shirt','Sneaker','Bag','Ankle Boot']\n",
        "print(desc[label[0].item()])\n",
        "plt.imshow(image[0].numpy().squeeze(), cmap='gray');"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 465
        },
        "id": "_-7ax5bu4ekb",
        "outputId": "959ad230-ff21-435f-94c3-a33bfe943a2f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([1, 28, 28]) torch.Size([64])\n",
            "Trouser\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Build the Network\n",
        "\n",
        "## 3 layers -> nn.Linear -> **Linear Regression**\n",
        "## **dropout layer** -> \n",
        "A dropout layer is a layer that randomly drops out some of the neurons in the previous layer during training, to prevent overfitting12. Overfitting occurs when the model learns the noise or specific patterns in the training data, and fails to generalize well to new or unseen data\n",
        "\n",
        "## Activation Function -> ReLu , Softmax, tanh \n",
        "\n",
        "## Optimizer -> Adam , CrossEntropyLoss"
      ],
      "metadata": {
        "id": "_yeaQHvY5XxQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def network():\n",
        "    model = nn.Sequential(OrderedDict([('fc1', nn.Linear(784, 128)),\n",
        "                                       ('relu1', nn.ReLU()),\n",
        "                                       ('drop1', nn.Dropout(0.25)),                                       \n",
        "                                       ('fc2', nn.Linear(128, 64)),\n",
        "                                       ('relu2', nn.ReLU()),\n",
        "                                       ('drop1', nn.Dropout(0.25)),                                       \n",
        "                                       ('output', nn.Linear(64, 10)),\n",
        "                                       ('logsoftmax', nn.LogSoftmax(dim=1))]))\n",
        "    # Use GPU if available\n",
        "    device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "    model = model.to(device)\n",
        "\n",
        "    # define the criterion and optimizer\n",
        "    loss_fn = nn.NLLLoss()\n",
        "    optimizer = optim.Adam(model.parameters(), lr=0.003)\n",
        "\n",
        "    return model, loss_fn, optimizer, device        "
      ],
      "metadata": {
        "id": "2zEmRQgn5gKj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the Model \n",
        "\n",
        "model, loss_fn, optimizer, device = network()\n",
        "print(model)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4tjHSxBU7Sz5",
        "outputId": "2ec6bd99-20c6-47be-af38-291399594b70"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sequential(\n",
            "  (fc1): Linear(in_features=784, out_features=128, bias=True)\n",
            "  (relu1): ReLU()\n",
            "  (drop1): Dropout(p=0.25, inplace=False)\n",
            "  (fc2): Linear(in_features=128, out_features=64, bias=True)\n",
            "  (relu2): ReLU()\n",
            "  (output): Linear(in_features=64, out_features=10, bias=True)\n",
            "  (logsoftmax): LogSoftmax(dim=1)\n",
            ")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Train the Network"
      ],
      "metadata": {
        "id": "yGzfFadJ6nvk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Epoch\n",
        "An epoch is one complete pass through the entire training dataset.\n",
        "-- Metrics --\n",
        "#train_loss: \n",
        "The average loss function value over the training dataset. This measures how well the model fits the training data. A lower value means a better fit.\n",
        "#val_loss:\n",
        "The average loss function value over the validation dataset. This measures how well the model generalizes to new data that it has not seen during training. A lower value means a better generalization.\n",
        "#val_acc:\n",
        "The accuracy of the model on the validation dataset. This is the percentage of correct predictions out of all predictions. A higher value means a better accuracy."
      ],
      "metadata": {
        "id": "O182d61b8oIX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def train_validate(model, loss_fn, optimizer, trainloader, testloader, device, n_epochs=25):\n",
        "    train_losses = []\n",
        "    test_losses = []\n",
        "    for epoch in range(n_epochs):\n",
        "        # Set mode to training - Dropouts will be used here\n",
        "        model.train()\n",
        "        train_epoch_loss = 0\n",
        "        for images, labels in trainloader:\n",
        "            images, labels = images.to(device), labels.to(device)\n",
        "            # flatten the images to batch_size x 784\n",
        "            images = images.view(images.shape[0], -1)\n",
        "            # forward pass\n",
        "            outputs = model(images)\n",
        "            # backpropogation\n",
        "            train_batch_loss = loss_fn(outputs, labels)\n",
        "            optimizer.zero_grad()\n",
        "            train_batch_loss.backward()\n",
        "            # Weight updates\n",
        "            optimizer.step()\n",
        "            train_epoch_loss += train_batch_loss.item()\n",
        "        else:\n",
        "            # One epoch of training complete\n",
        "            # calculate average training epoch loss\n",
        "            train_epoch_loss = train_epoch_loss/len(trainloader)\n",
        "\n",
        "            # Now Validate on testset\n",
        "            with torch.no_grad():\n",
        "                test_epoch_acc = 0\n",
        "                test_epoch_loss = 0\n",
        "                # Set mode to eval - Dropouts will NOT be used here\n",
        "                model.eval()\n",
        "                for images, labels in testloader:\n",
        "                    images, labels = images.to(device), labels.to(device)                    \n",
        "                    # flatten images to batch_size x 784\n",
        "                    #By flattening the images, we are transforming them from a\n",
        "                    #28x28 matrix of pixels to a vector of 784 pixel values. \n",
        "                    #This way, the linear layer can perform a matrix multiplication with the input and the weight matrix.\n",
        "                    images = images.view(images.shape[0], -1)\n",
        "                    # make predictions \n",
        "                    test_outputs = model(images)\n",
        "                    # calculate test loss\n",
        "                    test_batch_loss = loss_fn(test_outputs, labels)\n",
        "                    test_epoch_loss += test_batch_loss\n",
        "                    \n",
        "                    # get probabilities, extract the class associated with highest probability\n",
        "                    proba = torch.exp(test_outputs)\n",
        "                    _, pred_labels = proba.topk(1, dim=1)\n",
        "                    \n",
        "                    # compare actual labels and predicted labels\n",
        "                    result = pred_labels == labels.view(pred_labels.shape)\n",
        "                    batch_acc = torch.mean(result.type(torch.FloatTensor))\n",
        "                    test_epoch_acc += batch_acc.item()\n",
        "                else:\n",
        "                    # One epoch of training and validation done\n",
        "                    # calculate average testing epoch loss\n",
        "                    test_epoch_loss = test_epoch_loss/len(testloader)\n",
        "                    # calculate accuracy as correct_pred/total_samples\n",
        "                    test_epoch_acc = test_epoch_acc/len(testloader)\n",
        "                    # save epoch losses for plotting\n",
        "                    train_losses.append(train_epoch_loss)\n",
        "                    test_losses.append(test_epoch_loss)\n",
        "                    # print stats for this epoch\n",
        "                    print(f'Epoch: {epoch} -> train_loss: {train_epoch_loss:.19f}, val_loss: {test_epoch_loss:.19f}, ',\n",
        "                          f'val_acc: {test_epoch_acc*100:.2f}%')\n",
        "    # Finally plot losses\n",
        "    plt.plot(train_losses, label='train-loss')\n",
        "    plt.plot(test_losses, label='val-loss')\n",
        "    plt.legend()\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "train_validate(model, loss_fn, optimizer, train_dl, val_dl, device)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 864
        },
        "id": "Wpp9DoV66nYx",
        "outputId": "d374e3f3-d6bc-484a-8978-a2c01a6f21da"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0 -> train_loss: 0.5786475836435953646, val_loss: 0.4539201259613037109,  val_acc: 83.54%\n",
            "Epoch: 1 -> train_loss: 0.4564162440498669704, val_loss: 0.3978396058082580566,  val_acc: 85.54%\n",
            "Epoch: 2 -> train_loss: 0.4217991570035616311, val_loss: 0.3857934772968292236,  val_acc: 86.10%\n",
            "Epoch: 3 -> train_loss: 0.4028816065390904977, val_loss: 0.3817302584648132324,  val_acc: 86.61%\n",
            "Epoch: 4 -> train_loss: 0.3885207303563753545, val_loss: 0.3665890693664550781,  val_acc: 86.39%\n",
            "Epoch: 5 -> train_loss: 0.3790938361088435071, val_loss: 0.3923982679843902588,  val_acc: 85.58%\n",
            "Epoch: 6 -> train_loss: 0.3666848312914371411, val_loss: 0.3555256724357604980,  val_acc: 87.06%\n",
            "Epoch: 7 -> train_loss: 0.3618107124169667732, val_loss: 0.3723082840442657471,  val_acc: 86.54%\n",
            "Epoch: 8 -> train_loss: 0.3553915840685367700, val_loss: 0.3540603518486022949,  val_acc: 87.16%\n",
            "Epoch: 9 -> train_loss: 0.3490855130652586458, val_loss: 0.3419536054134368896,  val_acc: 87.76%\n",
            "Epoch: 10 -> train_loss: 0.3436417883237202764, val_loss: 0.3594471216201782227,  val_acc: 87.07%\n",
            "Epoch: 11 -> train_loss: 0.3379073093632857239, val_loss: 0.3635777831077575684,  val_acc: 87.16%\n",
            "Epoch: 12 -> train_loss: 0.3351385676960150217, val_loss: 0.3467468619346618652,  val_acc: 87.44%\n",
            "Epoch: 13 -> train_loss: 0.3272868826289971889, val_loss: 0.3638184368610382080,  val_acc: 87.13%\n",
            "Epoch: 14 -> train_loss: 0.3229215342303117242, val_loss: 0.3333231210708618164,  val_acc: 88.00%\n",
            "Epoch: 15 -> train_loss: 0.3186292738715807427, val_loss: 0.3426152765750885010,  val_acc: 87.82%\n",
            "Epoch: 16 -> train_loss: 0.3176319881876309981, val_loss: 0.3511054217815399170,  val_acc: 87.43%\n",
            "Epoch: 17 -> train_loss: 0.3146216356356938415, val_loss: 0.3675571680068969727,  val_acc: 86.81%\n",
            "Epoch: 18 -> train_loss: 0.3140079226096471054, val_loss: 0.3432052433490753174,  val_acc: 88.04%\n",
            "Epoch: 19 -> train_loss: 0.3093562892278035603, val_loss: 0.3471860587596893311,  val_acc: 87.77%\n",
            "Epoch: 20 -> train_loss: 0.3078292595346768801, val_loss: 0.3332746922969818115,  val_acc: 88.21%\n",
            "Epoch: 21 -> train_loss: 0.2997354889909426556, val_loss: 0.3227475881576538086,  val_acc: 88.55%\n",
            "Epoch: 22 -> train_loss: 0.2989073414206505075, val_loss: 0.3508322238922119141,  val_acc: 87.08%\n",
            "Epoch: 23 -> train_loss: 0.2960051813026269296, val_loss: 0.3385807871818542480,  val_acc: 88.06%\n",
            "Epoch: 24 -> train_loss: 0.2890875630577405264, val_loss: 0.3324531316757202148,  val_acc: 88.33%\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Train and validate\n",
        "##The data value change shows how your scores change over time as you teaching the machine to recognize image. \n",
        "#It tells you how well you are doing and what you need to work on. There are many things that can affect your performance,\n",
        "#like the image quality, shape, color, and size.\n",
        "train_validate(model, loss_fn, optimizer, train_dl, val_dl, device)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 222
        },
        "id": "Q1Whf0kg61bd",
        "outputId": "0b283813-7d8d-42ab-9685-1b11cf34dfee"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-2-c7daa134a8cb>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m##The data value change shows how your scores change over time as you teaching the machine to recognize image.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m#It tells you how well you are doing and what you need to work on. There are many things that can affect your performance, like the weather, the road, the bike, and your mood.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mtrain_validate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss_fn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain_dl\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_dl\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'train_validate' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Predict a Single Image\n",
        "\n",
        "\n",
        "## Problem solve with : images, labels = dataiter.__next__() -> older pytorch used dataiter.next()\n",
        "\n",
        "##Change the index value to recognize different image size"
      ],
      "metadata": {
        "id": "vmQ6anrO7qiZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%matplotlib inline\n",
        "%config InlineBackend.figure_format = 'retina'\n",
        "\n",
        "# Test out the network!\n",
        "dataiter = iter(test_dl)\n",
        "images, labels = dataiter.__next__()  #tunpacking the tuples #\n",
        "images, labels = images.to(device), labels.to(device)\n",
        "index = 44 ## The index can be any integer between 0 and 63, as the batch size is 64.This will change the image to recognize or you can run next batch to load new one\n",
        "img, label = images[index], labels[index]\n",
        "# Convert 2D image to 1D vector\n",
        "img = img.view(img.shape[0], -1)\n",
        "\n",
        "# Calculate the class probabilities (softmax) for img\n",
        "proba = torch.exp(model(img))\n",
        "\n",
        "# Plot the image and probabilities\n",
        "desc = ['T-shirt/top','Trouser','Pullover','Dress','Coat','Sandal','Shirt','Sneaker','Bag','Ankle Boot']\n",
        "fig, (ax1, ax2) =  plt.subplots(figsize=(13, 6), nrows=1, ncols=2)\n",
        "ax1.axis('off')\n",
        "ax1.imshow(images[index].cpu().numpy().squeeze())\n",
        "ax1.set_title(desc[label.item()])\n",
        "ax2.bar(range(10), proba.detach().cpu().numpy().squeeze())\n",
        "ax2.set_xticks(range(10))\n",
        "ax2.set_xticklabels(desc, size='small')\n",
        "ax2.set_title('Predicted Probabilities')\n",
        "plt.tight_layout()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 240
        },
        "id": "A1CXwSiu7k1a",
        "outputId": "98e71f8a-9d11-4d46-c819-75b38c220456"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-edd5b2f3c825>\u001b[0m in \u001b[0;36m<cell line: 5>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# Test out the network!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mdataiter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0miter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_dl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0mimages\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdataiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__next__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m#tunpacking the tuples #\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mimages\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimages\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'test_dl' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Validate on Test Set "
      ],
      "metadata": {
        "id": "pwMXIw9m73jo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Validate\n",
        "with torch.no_grad():\n",
        "    batch_acc = []\n",
        "    model.eval()\n",
        "    for images, labels in test_dl:\n",
        "        images, labels = images.to(device), labels.to(device)\n",
        "        # flatten images to batch_size x 784\n",
        "        images = images.view(images.shape[0], -1)\n",
        "        # make predictions and get probabilities\n",
        "        proba = torch.exp(model(images))\n",
        "        # extract the class associted with highest probability\n",
        "        _, pred_labels = proba.topk(1, dim=1)\n",
        "        # compare actual labels and predicted labels\n",
        "        result = pred_labels == labels.view(pred_labels.shape)\n",
        "        acc = torch.mean(result.type(torch.FloatTensor))\n",
        "        batch_acc.append(acc.item())\n",
        "    else:\n",
        "        print(f'Test Accuracy: {torch.mean(torch.tensor(batch_acc))*100:.2f}%')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_kNkxabb73KY",
        "outputId": "ce72062e-7031-42e0-9bac-973e61bbb216"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracy: 87.70%\n"
          ]
        }
      ]
    }
  ]
}