03_pytorch_computer_vision.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Lab-of-Infinity/PyTorch-for-Deep-Learning-Zero-to-Mastery/blob/main/03_pytorch_computer_vision.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "08f47c6a-3318-4e3f-8bb3-c520e00e63dd",
      "metadata": {
        "id": "08f47c6a-3318-4e3f-8bb3-c520e00e63dd"
      },
      "source": [
        "# 03. PyTorch Computer Vision\n",
        "\n",
        "[Computer vision](https://en.wikipedia.org/wiki/Computer_vision) is the art of teaching a computer to see.\n",
        "\n",
        "For example, it could involve building a model to classify whether a photo is of a cat or a dog ([binary classification](https://developers.google.com/machine-learning/glossary#binary-classification)).\n",
        "\n",
        "Or whether a photo is of a cat, dog or chicken ([multi-class classification](https://developers.google.com/machine-learning/glossary#multi-class-classification)).\n",
        "\n",
        "Or identifying where a car appears in a video frame ([object detection](https://en.wikipedia.org/wiki/Object_detection)).\n",
        "\n",
        "Or figuring out where different objects in an image can be separated ([panoptic segmentation](https://arxiv.org/abs/1801.00868)).\n",
        "\n",
        "![example computer vision problems](https://raw.githubusercontent.com/mrdbourke/pytorch-deep-learning/main/images/03-computer-vision-problems.png)\n",
        "*Example computer vision problems for binary classification, multiclass classification, object detection and segmentation.*"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "412e8bd1-0e6b-4ad6-8506-b28a8f669dc1",
      "metadata": {
        "id": "412e8bd1-0e6b-4ad6-8506-b28a8f669dc1"
      },
      "source": [
        "## What we're going to cover\n",
        "\n",
        "We're going to apply the PyTorch Workflow we've been learning in the past couple of sections to computer vision.\n",
        "\n",
        "![a PyTorch workflow with a computer vision focus](https://raw.githubusercontent.com/mrdbourke/pytorch-deep-learning/main/images/03-pytorch-computer-vision-workflow.png)\n",
        "\n",
        "Specifically, we're going to cover:\n",
        "\n",
        "| **Topic** | **Contents** |\n",
        "| ----- | ----- |\n",
        "| **0. Computer vision libraries in PyTorch** | PyTorch has a bunch of built-in helpful computer vision libraries, let's check them out.  |\n",
        "| **1. Load data** | To practice computer vision, we'll start with some images of different pieces of clothing from [FashionMNIST](https://github.com/zalandoresearch/fashion-mnist). |\n",
        "| **2. Prepare data** | We've got some images, let's load them in with a [PyTorch `DataLoader`](https://pytorch.org/docs/stable/data.html) so we can use them with our training loop. |\n",
        "| **3. Model 0: Building a baseline model** | Here we'll create a multi-class classification model to learn patterns in the data, we'll also choose a **loss function**, **optimizer** and build a **training loop**. | \n",
        "| **4. Making predictions and evaluting model 0** | Let's make some predictions with our baseline model and evaluate them. |\n",
        "| **5. Setup device agnostic code for future models** | It's best practice to write device-agnostic code, so let's set it up. |\n",
        "| **6. Model 1: Adding non-linearity** | Experimenting is a large part of machine learning, let's try and improve upon our baseline model by adding non-linear layers. |\n",
        "| **7. Model 2: Convolutional Neural Network (CNN)** | Time to get computer vision specific and introduce the powerful convolutional neural network architecture. |\n",
        "| **8. Comparing our models** | We've built three different models, let's compare them. |\n",
        "| **9. Evaluating our best model** | Let's make some predictons on random images and evaluate our best model. |\n",
        "| **10. Making a confusion matrix** | A confusion matrix is a great way to evaluate a classification model, let's see how we can make one. |\n",
        "| **11. Saving and loading the best performing model** | Since we might want to use our model for later, let's save it and make sure it loads back in correctly. |"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a0bedcfc-e12a-4a81-9913-84c6a888742a",
      "metadata": {
        "id": "a0bedcfc-e12a-4a81-9913-84c6a888742a"
      },
      "source": [
        "## 0. Computer vision libraries in PyTorch\n",
        "\n",
        "Before we get started writing code, let's talk about some PyTorch computer vision libraries you should be aware of.\n",
        "\n",
        "| PyTorch module | What does it do? |\n",
        "| ----- | ----- |\n",
        "| [`torchvision`](https://pytorch.org/vision/stable/index.html) | Contains datasets, model architectures and image transformations often used for computer vision problems. |\n",
        "| [`torchvision.datasets`](https://pytorch.org/vision/stable/datasets.html) | Here you'll find many example computer vision datasets for a range of problems from image classification, object detection, image captioning, video classification and more. It also contains [a series of base classes for making custom datasets](https://pytorch.org/vision/stable/datasets.html#base-classes-for-custom-datasets). |\n",
        "| [`torchvision.models`](https://pytorch.org/vision/stable/models.html) | This module contains well-performing and commonly used computer vision model architectures implemented in PyTorch, you can use these with your own problems. | \n",
        "| [`torchvision.transforms`](https://pytorch.org/vision/stable/transforms.html) | Often images need to be transformed (turned into numbers/processed/augmented) before being used with a model, common image transformations are found here. | \n",
        "| [`torch.utils.data.Dataset`](https://pytorch.org/docs/stable/data.html#torch.utils.data.Dataset) | Base dataset class for PyTorch.  | \n",
        "| [`torch.utils.data.DataLoader`](https://pytorch.org/docs/stable/data.html#module-torch.utils.data) | Creates a Python iteralbe over a dataset (created with `torch.utils.data.Dataset`). |\n",
        "\n",
        "> **Note:** The `torch.utils.data.Dataset` and `torch.utils.data.DataLoader` classes aren't only for computer vision in PyTorch, they are capable of dealing with many different types of data.\n",
        "\n",
        "Now we've covered some of the most important PyTorch computer vision libraries, let's import the relevant dependencies.\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Import PyTorch\n",
        "import torch\n",
        "from torch import nn\n",
        "\n",
        "# Import torchvision\n",
        "import torchvision\n",
        "from torchvision import datasets\n",
        "from torchvision.transforms import ToTensor\n",
        "\n",
        "# Import matplotlib for visualization\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Version Check\n",
        "print(f\"PyTorch version: {torch.__version__}\\ntorchvision version: {torchvision.__version__}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yVWAjd_MIlB6",
        "outputId": "a69dcf32-64fb-4b2f-f4f7-9a78ac3da8de"
      },
      "id": "yVWAjd_MIlB6",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "PyTorch version: 1.13.1+cu116\n",
            "torchvision version: 0.14.1+cu116\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "48d6bfe7-91da-44eb-9ab6-7c41c1e9fa8e",
      "metadata": {
        "id": "48d6bfe7-91da-44eb-9ab6-7c41c1e9fa8e"
      },
      "source": [
        "## 1. Getting a dataset\n",
        "\n",
        "We're going to start with FashionMNIST.\n",
        "\n",
        "[FashionMNIST](https://github.com/zalandoresearch/fashion-mnist), made by Zalando Research, it contains grayscale images of 10 different kinds of clothing.\n",
        "\n",
        "![example image of FashionMNIST](https://raw.githubusercontent.com/mrdbourke/pytorch-deep-learning/main/images/03-fashion-mnist-slide.png)\n",
        "*`torchvision.datasets` contains a lot of example datasets you can use to practice writing computer vision code on. FashionMNIST is one of those datasets. And since it has 10 different image classes (different types of clothing), it's a multi-class classification problem.*\n",
        "\n",
        "Later, we'll be building a computer vision neural network to identify the different styles of clothing in these images.\n",
        "\n",
        "PyTorch has a bunch of common computer vision datasets stored in `torchvision.datasets`.\n",
        "\n",
        "Including FashionMNIST in [`torchvision.datasets.FashionMNIST()`](https://pytorch.org/vision/main/generated/torchvision.datasets.FashionMNIST.html).\n",
        "\n",
        "To download it, we provide the following parameters:\n",
        "* `root: str` - which folder do you want to download the data to?\n",
        "* `train: Bool` - do you want the training or test split?\n",
        "* `download: Bool` - should the data be downloaded?\n",
        "* `transform: torchvision.transforms` - what transformations would you like to do on the data?\n",
        "* `target_transform` - you can transform the targets (labels) if you like too.\n",
        "\n",
        "Many other datasets in `torchvision` have these parameter options."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "94RjR9EhLCaE",
        "outputId": "64d87b9e-cafa-48cf-ad16-9cace7f09703"
      },
      "id": "94RjR9EhLCaE",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!cd '/content/drive/MyDrive/Zero to Mastery Learn PyTorch for Deep Learning'"
      ],
      "metadata": {
        "id": "LBBzFpxnLQFR"
      },
      "id": "LBBzFpxnLQFR",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup training data\n",
        "train_data = datasets.FashionMNIST(\n",
        "    root = 'data', # where to download data\n",
        "    train = True, # get training data\n",
        "    download = True, # download data if it doesn't exist on disk\n",
        "    transform = ToTensor(),\n",
        "    target_transform = None\n",
        ")\n",
        "\n",
        "# Setup Testing Data\n",
        "test_data = datasets.FashionMNIST(\n",
        "    root = 'data',\n",
        "    train = False, # get test data\n",
        "    download = True,\n",
        "    transform = ToTensor()\n",
        ")"
      ],
      "metadata": {
        "id": "00QN0fFqKmxP"
      },
      "id": "00QN0fFqKmxP",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "9ad9d782-06cb-4591-ae3c-3a8b2389a1b2",
      "metadata": {
        "id": "9ad9d782-06cb-4591-ae3c-3a8b2389a1b2"
      },
      "source": [
        "### 1.1 Input and output shapes of a computer vision model\n",
        "\n",
        "We've got a big tensor of values (the image) leading to a single value for the target (the label).\n",
        "\n",
        "Let's see the image shape."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "image,train = train_data[0]"
      ],
      "metadata": {
        "id": "wOmohVuHufZi"
      },
      "id": "wOmohVuHufZi",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c2997d9f-b574-4d23-aa34-1a4df1751226",
      "metadata": {
        "id": "c2997d9f-b574-4d23-aa34-1a4df1751226",
        "outputId": "825613c7-53ba-43e5-b9e3-9fe0b7d29acd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 28, 28])"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ],
      "source": [
        "# What's the shape of the image?\n",
        "image.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b5326a05-f807-448d-99a3-6d03fc8739f8",
      "metadata": {
        "id": "b5326a05-f807-448d-99a3-6d03fc8739f8"
      },
      "source": [
        "The shape of the image tensor is `[1, 28, 28]` or more specifically:\n",
        "\n",
        "```\n",
        "[color_channels=1, height=28, width=28]\n",
        "```\n",
        "\n",
        "Having `color_channels=1` means the image is grayscale.\n",
        "\n",
        "![example input and output shapes of the fashionMNIST problem](https://raw.githubusercontent.com/mrdbourke/pytorch-deep-learning/main/images/03-computer-vision-input-and-output-shapes.png)\n",
        "*Various problems will have various input and output shapes. But the premise reamins: encode data into numbers, build a model to find patterns in those numbers, convert those patterns into something meaningful.*\n",
        "\n",
        "If `color_channels=3`, the image comes in pixel values for red, green and blue (this is also known a the [RGB color model](https://en.wikipedia.org/wiki/RGB_color_model)).\n",
        "\n",
        "The order of our current tensor is often referred to as `CHW` (Color Channels, Height, Width).\n",
        "\n",
        "There's debate on whether images should be represented as `CHW` (color channels first) or `HWC` (color channels last).\n",
        "\n",
        "> **Note:** You'll also see `NCHW` and `NHWC` formats where `N` stands for *number of images*. For example if you have a `batch_size=32`, your tensor shape may be `[32, 1, 28, 28]`. We'll cover batch sizes later.\n",
        "\n",
        "PyTorch generally accepts `NCHW` (channels first) as the default for many operators.\n",
        "\n",
        "However, PyTorch also explains that `NHWC` (channels last) performs better and is [considered best practice](https://pytorch.org/blog/tensor-memory-format-matters/#pytorch-best-practice). \n",
        "\n",
        "For now, since our dataset and models are relatively small, this won't make too much of a difference.\n",
        "\n",
        "But keep it in mind for when you're working on larger image datasets and using convolutional neural networks (we'll see these later).\n",
        "\n",
        "Let's check out more shapes of our data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "fc4f768c-c3f6-454d-a633-673ad1d6eca0",
      "metadata": {
        "id": "fc4f768c-c3f6-454d-a633-673ad1d6eca0",
        "outputId": "6a1b41a9-07e6-4788-8cbb-9d29ae8ddb4e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(60000, 60000, 10000, 10000)"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ],
      "source": [
        "# How many samples are there? \n",
        "len(train_data.data), len(train_data.targets), len(test_data.data), len(test_data.targets)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6e0267d5-946b-4c53-af69-61acd3527972",
      "metadata": {
        "id": "6e0267d5-946b-4c53-af69-61acd3527972"
      },
      "source": [
        "So we've got 60,000 training samples and 10,000 testing samples.\n",
        "\n",
        "What classes are there?\n",
        "\n",
        "We can find these via the `.classes` attribute."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Classes names\n",
        "class_names = train_data.classes\n",
        "class_names"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iaByFPcfvTD8",
        "outputId": "b1dd5482-d28f-4573-ece5-b59c24b97196"
      },
      "id": "iaByFPcfvTD8",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['T-shirt/top',\n",
              " 'Trouser',\n",
              " 'Pullover',\n",
              " 'Dress',\n",
              " 'Coat',\n",
              " 'Sandal',\n",
              " 'Shirt',\n",
              " 'Sneaker',\n",
              " 'Bag',\n",
              " 'Ankle boot']"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "abdd225c-5742-4d9c-8e8d-fb30a9c3cb6e",
      "metadata": {
        "id": "abdd225c-5742-4d9c-8e8d-fb30a9c3cb6e"
      },
      "source": [
        "Sweet! It looks like we're dealing with 10 different kinds of clothes.\n",
        "\n",
        "Because we're working with 10 different classes, it means our problem is **multi-class classification**.\n",
        "\n",
        "Let's get visual."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "fb625d80-6a98-471e-a758-4de0ce0f3a64",
      "metadata": {
        "id": "fb625d80-6a98-471e-a758-4de0ce0f3a64"
      },
      "source": [
        "### 1.2 Visualizing our data"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "image.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K74OsMcywMkt",
        "outputId": "89161166-2472-41b5-c08e-ccedf698d18a"
      },
      "id": "K74OsMcywMkt",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 28, 28])"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "image.squeeze().shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N44Er-BiwPXT",
        "outputId": "b2523d54-0ab3-4561-a403-181e110ebdef"
      },
      "id": "N44Er-BiwPXT",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([28, 28])"
            ]
          },
          "metadata": {},
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "image, label = train_data[0]\n",
        "print(f\"Image Shape: {image.shape}\")\n",
        "plt.imshow(image.squeeze(),cmap = 'gray') # image shape is [1,28,28] is squeeze to [28,28]  2.image into grayscale using the cmap parameter\n",
        "plt.title(label)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "Qkb62y8KvlJy",
        "outputId": "3d712320-c68a-403a-ba12-1e0a32f10056"
      },
      "id": "Qkb62y8KvlJy",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Image Shape: torch.Size([1, 28, 28])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "adb19c5c-2f2b-4aaf-8300-256f3594e2db",
      "metadata": {
        "id": "adb19c5c-2f2b-4aaf-8300-256f3594e2db"
      },
      "source": [
        "We can turn the image into grayscale using the `cmap` parameter of `plt.imshow()`."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9a09388a-d754-485f-aa26-4e7a0f782967",
      "metadata": {
        "id": "9a09388a-d754-485f-aa26-4e7a0f782967"
      },
      "source": [
        "Beautiful, well as beautiful as a pixelated grayscale ankle boot can get.\n",
        "\n",
        "Let's view a few more."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7188ed7a-5959-48c4-ac7f-19129a2adc83",
      "metadata": {
        "id": "7188ed7a-5959-48c4-ac7f-19129a2adc83",
        "outputId": "9599063f-144d-40d7-f08e-9d949d5182a4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 536
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 648x648 with 16 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Plot more images\n",
        "torch.manual_seed(42)\n",
        "fig = plt.figure(figsize=(9, 9))\n",
        "rows, cols = 4, 4\n",
        "for i in range(1, rows * cols + 1):\n",
        "    random_idx = torch.randint(0, len(train_data), size=[1]).item()\n",
        "    img, label = train_data[random_idx]\n",
        "    fig.add_subplot(rows, cols, i)\n",
        "    plt.imshow(img.squeeze(), cmap=\"gray\")\n",
        "    plt.title(class_names[label])\n",
        "    plt.axis(False);"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f356fbe9-95b1-4f81-a82d-dc15b3adc06a",
      "metadata": {
        "id": "f356fbe9-95b1-4f81-a82d-dc15b3adc06a"
      },
      "source": [
        "\n",
        "Hmmm, this dataset doesn't look too aesthetic.\n",
        "\n",
        "But the principles we're going to learn on how to build a model for it will be similar across a wide range of computer vision problems.\n",
        "\n",
        "In essence, taking pixel values and building a model to find patterns in them to use on future pixel values.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "43cdd23d-bd1f-4e8c-ba20-22d2b6ac14b1",
      "metadata": {
        "id": "43cdd23d-bd1f-4e8c-ba20-22d2b6ac14b1"
      },
      "source": [
        "## 2. Prepare DataLoader\n",
        "\n",
        "Now we've got a dataset ready to go.\n",
        "\n",
        "- The next step is to prepare it with a [`torch.utils.data.DataLoader`](https://pytorch.org/docs/stable/data.html#torch.utils.data.Dataset) or `DataLoader` for short.\n",
        "\n",
        "- The `DataLoader` helps load data into a model For training and for inference.\n",
        "It turns a large `Dataset` into a Python iterable of smaller chunks.\n",
        "\n",
        "- These smaller chunks are called **batches** or **mini-batches** and can be set by the `batch_size` parameter.\n",
        "\n",
        "\n",
        "- With **mini-batches** (small portions of the data), gradient descent is performed more often per epoch (once per mini-batch rather than once per epoch).\n",
        "\n",
        "What's a good batch size?\n",
        "\n",
        "[32 is a good place to start](https://twitter.com/ylecun/status/989610208497360896?s=20&t=N96J_jotN--PYuJk2WcjMw) for a fair amount of problems.\n",
        "\n",
        "But since this is a value you can set (a **hyperparameter**) you can try all different kinds of values, though generally powers of 2 are used most often (e.g. 32, 64, 128, 256, 512).\n",
        "\n",
        "![an example of what a batched dataset looks like](https://raw.githubusercontent.com/mrdbourke/pytorch-deep-learning/main/images/03-batching-fashionmnist.png)\n",
        "*Batching FashionMNIST with a batch size of 32 and shuffle turned on. A similar batching process will occur for other datasets but will differ depending on the batch size.*\n",
        "\n",
        "Let's create `DataLoader`'s for our training and test sets. "
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from torch.utils.data import DataLoader\n",
        "\n",
        "# Setup the batch size hyperparameter\n",
        "BATCH_SIZE = 32\n",
        "\n",
        "# Turn datasets into iterables\n",
        "train_dataloader = DataLoader(train_data, batch_size = BATCH_SIZE, shuffle = True)\n",
        "test_dataloader = DataLoader(test_data, batch_size = BATCH_SIZE, shuffle = False)\n",
        "\n",
        "# Let's Check out what we created\n",
        "print(f'Dataloaders: {train_dataloader, test_dataloader}')\n",
        "print(f\"Length of train dataloader: {len(train_dataloader)} batches of {BATCH_SIZE}\")\n",
        "print(f\"Length of test dataloader: {len(test_dataloader)} batches of {BATCH_SIZE} \")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fp0cCieM1Afd",
        "outputId": "625e4137-b95f-46db-c9d6-ff9feb356f48"
      },
      "id": "Fp0cCieM1Afd",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dataloaders: (<torch.utils.data.dataloader.DataLoader object at 0x7f37b8380e80>, <torch.utils.data.dataloader.DataLoader object at 0x7f37b8380c70>)\n",
            "Length of train dataloader: 1875 batches of 32\n",
            "Length of test dataloader: 313 batches of 32 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check out whats inside the training dataloader\n",
        "train_features_batch, train_labels_batch = next(iter(train_dataloader))\n",
        "train_features_batch.shape, train_labels_batch.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F2qnj0Ld21EL",
        "outputId": "88109d74-4d3f-4825-d66e-a67141a046ba"
      },
      "id": "F2qnj0Ld21EL",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(torch.Size([32, 1, 28, 28]), torch.Size([32]))"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "db1695cf-f53d-4c7c-ad39-dfed76533125",
      "metadata": {
        "id": "db1695cf-f53d-4c7c-ad39-dfed76533125"
      },
      "source": [
        "## 3. Model 0: Build a baseline model\n",
        "\n",
        "Data loaded and prepared!\n",
        "\n",
        "Time to build a **baseline model** by subclassing `nn.Module`.\n",
        "\n",
        "- A **baseline model** is one of the simplest models you can imagine.\n",
        "\n",
        "- You use the baseline as a starting point and try to improve upon it with subsequent, more complicated models.\n",
        "\n",
        "- Our baseline will consist of two [`nn.Linear()`](https://pytorch.org/docs/stable/generated/torch.nn.Linear.html) layers.\n",
        "\n",
        "- Because we're working with image data, we're going to use a different layer to start things off. And that's the [`nn.Flatten()`](https://pytorch.org/docs/stable/generated/torch.nn.Flatten.html) layer.\n",
        "\n",
        "- `nn.Flatten()` compresses the dimensions of a tensor into a single vector.\n",
        "\n",
        "This is easier to understand when you see it."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a flatten layer\n",
        "flatten_model = nn.Flatten()\n",
        "\n",
        "# Get a single sample\n",
        "x= train_features_batch[0]\n",
        "\n",
        "# Flatten the sample\n",
        "output = flatten_model(x)\n",
        "\n",
        "# Print Shape change\n",
        "print(f\"Shape before flattening: {x.shape} -> [color_channels, height, width]\")\n",
        "print(f\"Shape after flattening: {output.shape} -> [color_channels, height*width]\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HjV__nby4YrI",
        "outputId": "db349720-52b5-41aa-edc9-ca8481885447"
      },
      "id": "HjV__nby4YrI",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Shape before flattening: torch.Size([1, 28, 28]) -> [color_channels, height, width]\n",
            "Shape after flattening: torch.Size([1, 784]) -> [color_channels, height*width]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "86bb7806-fca6-45af-8111-3e00e38f5be9",
      "metadata": {
        "id": "86bb7806-fca6-45af-8111-3e00e38f5be9"
      },
      "source": [
        "The `nn.Flatten()` layer took our shape from `[color_channels, height, width]` to `[color_channels, height*width]`.\n",
        "\n",
        "Why do this?\n",
        "\n",
        "Because we've now turned our pixel data from height and width dimensions into one long **feature vector**.\n",
        "\n",
        "And `nn.Linear()` layers like their inputs to be in the form of feature vectors.\n",
        "\n",
        "Let's create our first model using `nn.Flatten()` as the first layer. "
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from torch import nn\n",
        "class FashionMNISTModelV0(nn.Module):\n",
        "  def __init__(self,input_shape: int, hidden_units: int, output_shape:int):\n",
        "    super().__init__()\n",
        "    self.layer_stack = nn.Sequential(\n",
        "        nn.Flatten(),\n",
        "        nn.Linear(in_features = input_shape, out_features = hidden_units),\n",
        "        nn.Linear(in_features= hidden_units, out_features = output_shape)\n",
        "    )\n",
        "\n",
        "  def forward(self,x):\n",
        "    return self.layer_stack(x)"
      ],
      "metadata": {
        "id": "K_q33SMVCTqw"
      },
      "id": "K_q33SMVCTqw",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "4d1b50bf-d00b-485c-be00-b3e4de156fab",
      "metadata": {
        "id": "4d1b50bf-d00b-485c-be00-b3e4de156fab"
      },
      "source": [
        "Wonderful!\n",
        "\n",
        "We've got a baseline model class we can use, now let's instantiate a model.\n",
        "\n",
        "We'll need to set the following parameters:\n",
        "* `input_shape=784` - this is how many features you've got going in the model, in our case, it's one for every pixel in the target image (28 pixels high by 28 pixels wide = 784 features).\n",
        "* `hidden_units=10` - number of units/neurons in the hidden layer(s), this number could be whatever you want but to keep the model small we'll start with `10`.\n",
        "* `output_shape=len(class_names)` - since we're working with a multi-class classification problem, we need an output neuron per class in our dataset.\n",
        "\n",
        "Let's create an instance of our model and send to the CPU for now (we'll run a small test for running `model_0` on CPU vs. a similar model on GPU soon)."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "# Need to setup model with input parameters\n",
        "\n",
        "model_0 = FashionMNISTModelV0(input_shape = 784,\n",
        "                              hidden_units = 10,\n",
        "                              output_shape = len(class_names))\n",
        "\n",
        "model_0.to('cpu')  # keep model on CPU to begin with "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n3KnMOkkDhGY",
        "outputId": "647f3b54-25e2-449b-e7ed-d8c58c1445ca"
      },
      "id": "n3KnMOkkDhGY",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "FashionMNISTModelV0(\n",
              "  (layer_stack): Sequential(\n",
              "    (0): Flatten(start_dim=1, end_dim=-1)\n",
              "    (1): Linear(in_features=784, out_features=10, bias=True)\n",
              "    (2): Linear(in_features=10, out_features=10, bias=True)\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "03243179-1cdc-45d9-8b8c-82538ac02e9c",
      "metadata": {
        "id": "03243179-1cdc-45d9-8b8c-82538ac02e9c"
      },
      "source": [
        "### 3.1 Setup loss, optimizer and evaluation metrics\n",
        "\n",
        "Since we're working on a classification problem, let's bring in our [`helper_functions.py` script](https://github.com/mrdbourke/pytorch-deep-learning/blob/main/helper_functions.py) and subsequently the `accuracy_fn()` \n",
        "\n",
        "> **Note:** Rather than importing and using our own accuracy function or evaluation metric(s), you could import various evaluation metrics from the [TorchMetrics package](https://torchmetrics.readthedocs.io/en/latest/)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "31c91f17-d810-46a4-97c3-c734f93430b1",
      "metadata": {
        "id": "31c91f17-d810-46a4-97c3-c734f93430b1",
        "outputId": "50f85de6-82b8-4ed0-ba06-3bc2c03bd1a8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "helper_functions.py already exists, skipping download\n"
          ]
        }
      ],
      "source": [
        "import requests\n",
        "from pathlib import Path \n",
        "\n",
        "# Download helper functions from Learn PyTorch repo (if not already downloaded)\n",
        "if Path(\"helper_functions.py\").is_file():\n",
        "  print(\"helper_functions.py already exists, skipping download\")\n",
        "else:\n",
        "  print(\"Downloading helper_functions.py\")\n",
        "  # Note: you need the \"raw\" GitHub URL for this to work\n",
        "  request = requests.get(\"https://raw.githubusercontent.com/mrdbourke/pytorch-deep-learning/main/helper_functions.py\")\n",
        "  with open(\"helper_functions.py\", \"wb\") as f:\n",
        "    f.write(request.content)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup loss function and optimizer\n",
        "loss_fn = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.SGD(params = model_0.parameters(),lr = 0.1)\n",
        "\n",
        "# Import accuracy metric\n",
        "from helper_functions import accuracy_fn\n",
        "# Note: could also use torchmetrics.Accuracy(task = 'multiclass', num_classes=len(class_names)).to(device)"
      ],
      "metadata": {
        "id": "9nbLDw8CF03v"
      },
      "id": "9nbLDw8CF03v",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "4109f867-83f2-4394-a925-8acdc63ccffe",
      "metadata": {
        "id": "4109f867-83f2-4394-a925-8acdc63ccffe"
      },
      "source": [
        "### 3.2 Creating a function to time our experiments\n",
        "\n",
        "Loss function and optimizer ready!\n",
        "\n",
        "It's time to start training a model.\n",
        "\n",
        "But how about we do a little experiment while we train.\n",
        "\n",
        "I mean, let's make a timing function to measure the time it takes our model to train on CPU versus using a GPU.\n",
        "\n",
        "We'll train this model on the CPU but the next one on the GPU and see what happens.\n",
        "\n",
        "Our timing function will import the [`timeit.default_timer()` function](https://docs.python.org/3/library/timeit.html#timeit.default_timer) from the Python [`timeit` module](https://docs.python.org/3/library/timeit.html)."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from timeit import default_timer as timer\n",
        "def print_train_time(start: float, end: float, device: torch.device = None):\n",
        "    \"\"\"Prints difference between start and end time.\n",
        "\n",
        "    Args:\n",
        "        start (float): Start time of computation (preferred in timeit format). \n",
        "        end (float): End time of computation.\n",
        "        device ([type], optional): Device that compute is running on. Defaults to None.\n",
        "\n",
        "    Returns:\n",
        "        float: time between start and end in seconds (higher is longer).\n",
        "    \"\"\"\n",
        "    total_time = end- start\n",
        "    print(f'Train time on {device} : {total_time:.3f} seconds')\n",
        "    return total_time"
      ],
      "metadata": {
        "id": "JKqguwTaHb5o"
      },
      "id": "JKqguwTaHb5o",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "07b9560e-f5dc-45d6-b3b2-ddae17a71b34",
      "metadata": {
        "id": "07b9560e-f5dc-45d6-b3b2-ddae17a71b34"
      },
      "source": [
        "### 3.3 Creating a training loop and training a model on batches of data\n",
        "\n",
        "Let's step through it: \n",
        "1. Loop through epochs.\n",
        "2. Loop through training batches, perform training steps, calculate the train loss *per batch*.\n",
        "3. Loop through testing batches, perform testing steps, calculate the test loss *per batch*.\n",
        "4. Print out what's happening.\n",
        "5. Time it all (for fun).\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Import tqdm for progress bar\n",
        "from tqdm.auto import tqdm\n",
        "\n",
        "# Set the seed and start the timer\n",
        "torch.manual_seed(42)\n",
        "train_time_start_on_cpu = timer()\n",
        "\n",
        "# Set the number of epochs\n",
        "epochs = 3\n",
        "\n",
        "# Create training and testing loop\n",
        "for epoch in tqdm(range(epochs)):\n",
        "  print(f\"Epoch: {epoch}\\n---------------\")\n",
        "\n",
        "  ### Training\n",
        "  train_loss = 0\n",
        "\n",
        "  # Add a loop to loop through training batches\n",
        "  for batch, (X,y) in enumerate(train_dataloader):\n",
        "\n",
        "    model_0.train()\n",
        "\n",
        "    # 1. Forward Pass\n",
        "    y_pred = model_0(X)\n",
        "\n",
        "    # 2. Calculate loss (per batch)\n",
        "    loss = loss_fn(y_pred,y)\n",
        "    train_loss += loss # accumulatively add up the loss per epoch \n",
        "\n",
        "    # 3. Optimizer Zero Grad\n",
        "    optimizer.zero_grad()\n",
        "\n",
        "    # 4. Loss Backward\n",
        "    loss.backward()\n",
        "\n",
        "    # 5. Optimizer step\n",
        "    optimizer.step()\n",
        "\n",
        "    # Print out how many samples are seen\n",
        "    if batch % 400 ==0:\n",
        "      print(f\"Looked at {batch * len(X)}/{len(train_dataloader.dataset)} samples\")\n",
        "\n",
        "  # Divide train loss by length of dataloader\n",
        "  train_loss /= len(train_dataloader)\n",
        "\n",
        "  ### Testing Loop\n",
        "  test_loss,test_acc = 0,0\n",
        "  model_0.eval()\n",
        "\n",
        "  with torch.inference_mode():\n",
        "    for X,y in test_dataloader:\n",
        "       # 1. Forward Pass\n",
        "       test_pred = model_0(X)\n",
        "\n",
        "       # 2. Calculate loss\n",
        "       test_loss += loss_fn(test_pred, y)\n",
        "\n",
        "       # 3. Calculate Accuracy\n",
        "       test_acc += accuracy_fn(y_true = y, y_pred = test_pred.argmax(dim = 1))\n",
        "    \n",
        "    # Calculate total test loss by dividing by length of dataloader\n",
        "    test_loss /= len(test_dataloader)\n",
        "\n",
        "    # Divide total accuracy by length of test dataloader\n",
        "    test_acc /= len(test_dataloader)\n",
        "  ## Print out what's happening\n",
        "    print(f\"\\nTrain loss: {train_loss:.5f} | Test loss: {test_loss:.5f}, Test acc: {test_acc:.2f}%\\n\")\n",
        "\n",
        "# Calculate training time      \n",
        "train_time_end_on_cpu = timer()\n",
        "total_train_time_model_0 = print_train_time(start=train_time_start_on_cpu, \n",
        "                                           end=train_time_end_on_cpu,\n",
        "                                           device=str(next(model_0.parameters()).device))\n"
      ],
      "metadata": {
        "id": "ka4YKrlleRl4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 587,
          "referenced_widgets": [
            "b4c7693e8efb4e7db7c5deb65e6793a4",
            "267c6fb7bb2c4a1d96bbed36d3916a38",
            "45ca5ce08efc492498072933d9662939",
            "9453805c41cf4548b6e0e70522012299",
            "a62b718a5eca4e46a720928a671d6fd8",
            "1f4c714dc5b3450fbed8afd4e7f92780",
            "44c6f1378c8a4b00bb5f56bf5eb33c75",
            "5b211a8a1cee47328228ec63613094c0",
            "45139436dcfb44bf90265b37d8500608",
            "67352f0133ad4dc3975373488d2a5b58",
            "4f507816e91c4d02af4643813911c5b6"
          ]
        },
        "outputId": "d9835321-5414-43e0-ef9e-75542ee2ebff"
      },
      "id": "ka4YKrlleRl4",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/3 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "b4c7693e8efb4e7db7c5deb65e6793a4"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0\n",
            "---------------\n",
            "Looked at 0/60000 samples\n",
            "Looked at 12800/60000 samples\n",
            "Looked at 25600/60000 samples\n",
            "Looked at 38400/60000 samples\n",
            "Looked at 51200/60000 samples\n",
            "\n",
            "Train loss: 0.59039 | Test loss: 0.50954, Test acc: 82.04%\n",
            "\n",
            "Epoch: 1\n",
            "---------------\n",
            "Looked at 0/60000 samples\n",
            "Looked at 12800/60000 samples\n",
            "Looked at 25600/60000 samples\n",
            "Looked at 38400/60000 samples\n",
            "Looked at 51200/60000 samples\n",
            "\n",
            "Train loss: 0.47633 | Test loss: 0.47989, Test acc: 83.20%\n",
            "\n",
            "Epoch: 2\n",
            "---------------\n",
            "Looked at 0/60000 samples\n",
            "Looked at 12800/60000 samples\n",
            "Looked at 25600/60000 samples\n",
            "Looked at 38400/60000 samples\n",
            "Looked at 51200/60000 samples\n",
            "\n",
            "Train loss: 0.45503 | Test loss: 0.47664, Test acc: 83.43%\n",
            "\n",
            "Train time on cpu : 29.967 seconds\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7b02a939-a3a1-4a9d-bb9d-62928def2ded",
      "metadata": {
        "id": "7b02a939-a3a1-4a9d-bb9d-62928def2ded"
      },
      "source": [
        "Nice! Looks like our baseline model did fairly well.\n",
        "\n",
        "Let's write some code to evaluate our model."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7442511b-bfe9-4ec7-9f5b-9c808f8e560b",
      "metadata": {
        "id": "7442511b-bfe9-4ec7-9f5b-9c808f8e560b"
      },
      "source": [
        "## 4. Make predictions and get Model 0 results\n",
        "\n",
        "- Namely, let's create a function that takes in a trained model, a `DataLoader`, a loss function and an accuracy function.\n",
        "\n",
        "- The function will use the model to make predictions on the data in the `DataLoader` and then we can evaluate those predictions using the loss function and accuracy function."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "def eval_model(model: torch.nn.Module,\n",
        "               data_loader: torch.utils.data.DataLoader,\n",
        "               loss_fn: torch.nn.Module,\n",
        "               accuracy_fn):\n",
        "    \"\"\"Returns a dictionary containing the results of model predicting on data_loader.\n",
        "\n",
        "    Args:\n",
        "        model (torch.nn.Module): A PyTorch model capable of making predictions on data_loader.\n",
        "        data_loader (torch.utils.data.DataLoader): The target dataset to predict on.\n",
        "        loss_fn (torch.nn.Module): The loss function of model.\n",
        "        accuracy_fn: An accuracy function to compare the models predictions to the truth labels.\n",
        "\n",
        "    Returns:\n",
        "        (dict): Results of model making predictions on data_loader.\n",
        "    \"\"\"\n",
        "\n",
        "    loss,acc = 0,0\n",
        "    model.eval()\n",
        "    with torch.inference_mode():\n",
        "      for X,y in data_loader:\n",
        "        # Make Predictions with the model\n",
        "        y_pred = model_0(X)\n",
        "        # Accumlate the loss and accuracy values per batch\n",
        "        loss += loss_fn(y_pred, y)\n",
        "        acc += accuracy_fn(y_true = y, \n",
        "                           y_pred = y_pred.argmax(dim=1)) # For accuracy, need the prediction labels (logits -> pred_prob -> pred_labels)\n",
        "      \n",
        "      # Scale loss and acc to find the average loss per batch\n",
        "      loss /= len(data_loader)\n",
        "      acc /= len(data_loader)\n",
        "\n",
        "    return {\"model_name\" : model.__class__.__name__ , # only works when model created with class\n",
        "            \"model_loss\" : loss.item(),\n",
        "            \"model_acc\" : acc }\n",
        "\n",
        "# Calculate model 0 results on test dataset\n",
        "model_0_results = eval_model(model = model_0, data_loader = test_dataloader,\n",
        "                             loss_fn = loss_fn, accuracy_fn = accuracy_fn)\n",
        "\n",
        "model_0_results"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n88myXjjTzDz",
        "outputId": "4e8d6759-58b4-4275-eea9-eda3d79593b3"
      },
      "id": "n88myXjjTzDz",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'model_name': 'FashionMNISTModelV0',\n",
              " 'model_loss': 0.47663894295692444,\n",
              " 'model_acc': 83.42651757188499}"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a39c3042-1262-4d1f-b33e-c8e2ba6781d3",
      "metadata": {
        "id": "a39c3042-1262-4d1f-b33e-c8e2ba6781d3"
      },
      "source": [
        "Looking good!\n",
        "\n",
        "We can use this dictionary to compare the baseline model results to other models later on."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3b76784d-4cdb-43d2-a6da-8e4da9a812a9",
      "metadata": {
        "id": "3b76784d-4cdb-43d2-a6da-8e4da9a812a9"
      },
      "source": [
        "## 5. Setup device agnostic-code (for using a GPU if there is one)\n",
        "We've seen how long it takes to train ma PyTorch model on 60,000 samples on CPU.\n",
        "\n",
        "> **Note:** Model training time is dependent on hardware used. Generally, more processors means faster training and smaller models on smaller datasets will often train faster than large models and large datasets.\n",
        "\n",
        "Now let's setup some [device-agnostic code](https://pytorch.org/docs/stable/notes/cuda.html#best-practices) for our models and data to run on GPU if it's available.\n",
        "\n",
        "If you're running this notebook on Google Colab, and you don't a GPU turned on yet, it's now time to turn one on via `Runtime -> Change runtime type -> Hardware accelerator -> GPU`. If you do this, your runtime will likely reset and you'll have to run all of the cells above by going `Runtime -> Run before`."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup device agnostic code\n",
        "import torch\n",
        "device = \"cuda\" if torch.cuda.is_available() else 'cpu'\n",
        "device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "ByQLS_IMYWCd",
        "outputId": "71d25bfc-1799-434b-ca64-1113609ba161"
      },
      "id": "ByQLS_IMYWCd",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'cuda'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "514021a8-d6f2-47f3-ab50-55f844e42310",
      "metadata": {
        "id": "514021a8-d6f2-47f3-ab50-55f844e42310"
      },
      "source": [
        "Beautiful!\n",
        "\n",
        "Let's build another model."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d7893907-5f82-4c5e-8fde-fa542a9f25af",
      "metadata": {
        "id": "d7893907-5f82-4c5e-8fde-fa542a9f25af"
      },
      "source": [
        "## 6. Model 1: Building a better model with non-linearity\n",
        "\n",
        "We'll do so by recreating a similar model to before, except this time we'll put non-linear functions (`nn.ReLU()`) in between each linear layer."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a model with non-linear and linear layers\n",
        "class FashionMNISTModelV1(nn.Module):\n",
        "  \n",
        "  def __init__(self, input_shape: int, hidden_units: int, output_shape: int):\n",
        "    super().__init__()\n",
        "    self.layer_stack = nn.Sequential(\n",
        "        nn.Flatten(), # flatten inputs into single vector\n",
        "        nn.Linear(in_features=input_shape, out_features = hidden_units),\n",
        "        nn.ReLU(),\n",
        "        nn.Linear(in_features = hidden_units, out_features = output_shape),\n",
        "        nn.ReLU()\n",
        "    )\n",
        "\n",
        "  def forward(self, x: torch.Tensor):\n",
        "    return self.layer_stack(x)"
      ],
      "metadata": {
        "id": "A2q4NKT-Y3XQ"
      },
      "id": "A2q4NKT-Y3XQ",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "4b4b7a2f-4834-4aa1-a8e2-b6e3e2b49224",
      "metadata": {
        "id": "4b4b7a2f-4834-4aa1-a8e2-b6e3e2b49224"
      },
      "source": [
        "That looks good.\n",
        "\n",
        "Now let's instantiate it with the same settings we used before.\n",
        "\n",
        "We'll need `input_shape=784` (equal to the number of features of our image data), `hidden_units=10` (starting small and the same as our baseline model) and `output_shape=len(class_names)` (one output unit per class).\n",
        "\n",
        "> **Note:** Notice how we kept most of the settings of our model the same except for one change: adding non-linear layers. This is a standard practice for running a series of machine learning experiments, change one thing and see what happens, then do it again, again, again."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "model_1 = FashionMNISTModelV1(input_shape = 784, # number of input features\n",
        "                              hidden_units = 10,\n",
        "                              output_shape = len(class_names) # number of output classes desired\n",
        "                              ).to(device) # send model to GPU if it's available\n",
        "\n",
        "next(model_1.parameters()).device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "72kOSQFf3AKB",
        "outputId": "94434977-5bb6-4bd4-8107-e90bde0cd5ae"
      },
      "id": "72kOSQFf3AKB",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cuda', index=0)"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b54a4e9d-a7ad-404c-920f-485fcff18a92",
      "metadata": {
        "id": "b54a4e9d-a7ad-404c-920f-485fcff18a92"
      },
      "source": [
        "### 6.1 Setup loss, optimizer and evaluation metrics\n",
        "\n",
        "As usual, we'll setup a loss function, an optimizer and an evaluation metric (we could do multiple evaluation metrics but we'll stick with accuracy for now)."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from helper_functions import accuracy_fn\n",
        "loss_fn = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.SGD(params = model_1.parameters(),\n",
        "                            lr = 0.1)"
      ],
      "metadata": {
        "id": "0mfuRzrm3o0c"
      },
      "id": "0mfuRzrm3o0c",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "1eb30af6-a355-49a2-a59f-25169fd27a6e",
      "metadata": {
        "id": "1eb30af6-a355-49a2-a59f-25169fd27a6e"
      },
      "source": [
        "### 6.2 Functionizing training and test loops\n",
        "\n",
        "\n",
        "- we'll put training and test loops in functions so they can be called again and again.\n",
        "\n",
        "- we're using device-agnostic code now, we'll be sure to call `.to(device)` on our feature (`X`) and target (`y`) tensors.\n",
        "\n",
        "- For the training loop we'll create a function called `train_step()` which takes in a model, a `DataLoader` a loss function and an optimizer.\n",
        "\n",
        "- The testing loop will be similar but it'll be called `test_step()` and it'll take in a model, a `DataLoader`, a loss function and an evaluation function.\n",
        "\n",
        "> **Note:** Since these are functions, you can customize them in any way you like. What we're making here can be considered barebones training and testing functions for our specific classification use case."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def train_step(model: torch.nn.Module,\n",
        "               data_loader: torch.utils.data.DataLoader,\n",
        "               loss_fn: torch.nn.Module,\n",
        "               optimizer: torch.optim.Optimizer,\n",
        "               accuracy_fn,\n",
        "               device: torch.device = device):\n",
        "    train_loss, train_acc = 0, 0\n",
        "    for batch, (X,y) in enumerate(data_loader):\n",
        "      # Send data to GPU\n",
        "      X,y = X.to(device), y.to(device)\n",
        "\n",
        "      # 1. Forward Pass\n",
        "      y_pred = model(X)\n",
        "      # 2. Calculate loss\n",
        "      loss = loss_fn(y_pred,y)\n",
        "      train_loss += loss\n",
        "      train_acc += accuracy_fn(y_true=y,\n",
        "                                y_pred = y_pred.argmax(dim = 1))\n",
        "      \n",
        "      # 3. Optimizer zero step\n",
        "      optimizer.zero_grad()\n",
        "      # 4. Backward Loss\n",
        "      loss.backward()\n",
        "      # 5. Optimizer step\n",
        "      optimizer.step()\n",
        "\n",
        "    # Calculate loss and accuracy per batch\n",
        "    train_loss /=len(data_loader)\n",
        "    train_acc /= len(data_loader)\n",
        "    print(f\"Train loss: {train_loss:.5f} | Train Accuracy: {train_acc:.2f}%\")"
      ],
      "metadata": {
        "id": "YgiSgahn6LOL"
      },
      "id": "YgiSgahn6LOL",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def test_step(data_loader: torch.utils.data.DataLoader,\n",
        "              model: torch.nn.Module,\n",
        "              loss_fn: torch.nn.Module,\n",
        "              accuracy_fn,\n",
        "              device:torch.device = device):\n",
        "    test_loss, test_acc = 0, 0\n",
        "    model.eval()\n",
        "    # Turn on interence \n",
        "    with torch.inference_mode():\n",
        "      for X,y in data_loader:\n",
        "        # Send data to GPU\n",
        "        X, y = X.to(device), y.to(device)\n",
        "\n",
        "        # 1. Forward pass\n",
        "        test_pred = model(X)\n",
        "\n",
        "        # 2. calculate loss and accuracy\n",
        "        test_loss +=loss_fn(test_pred,y)\n",
        "        test_acc += accuracy_fn(y_true =y,\n",
        "                                y_pred = test_pred.argmax(dim=1)) # Go from logits -> pred labels\n",
        "\n",
        "      # calculate test loss and accuracy by dividing dataloader length\n",
        "      test_loss /= len(data_loader)\n",
        "      test_acc /= len(data_loader)\n",
        "      print(f\"Test loss: {test_loss:.5f} | Test accuracy: {test_acc:.2f}%\\n\")"
      ],
      "metadata": {
        "id": "TjNSWmN5_Txf"
      },
      "id": "TjNSWmN5_Txf",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "e44121b6-c4be-4909-9175-dc9bd8dc6273",
      "metadata": {
        "id": "e44121b6-c4be-4909-9175-dc9bd8dc6273"
      },
      "source": [
        "Woohoo!\n",
        "\n",
        "Now we've got some functions for training and testing our model, let's run them.\n",
        "\n",
        "We'll do so inside another loop for each epoch.\n",
        "\n",
        "That way for each epoch we're going a training and a testing step.\n",
        "\n",
        "> **Note:** You can customize how often you do a testing step. Sometimes people do them every five epochs or 10 epochs or in our case, every epoch.\n",
        "\n",
        "Let's also time things to see how long our code takes to run on the GPU."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "# Measure time\n",
        "from timeit import default_timer as timer\n",
        "train_time_start_on_gpu = timer()\n",
        "epochs = 3 \n",
        "for epoch in tqdm(range(epochs)):\n",
        "  print(f'Epoch: {epoch}\\n--------- ')\n",
        "  train_step(data_loader = train_dataloader,\n",
        "             model = model_1,\n",
        "             loss_fn = loss_fn,\n",
        "             optimizer = optimizer,\n",
        "             accuracy_fn = accuracy_fn\n",
        "             )\n",
        "  test_step(data_loader = test_dataloader,\n",
        "             model = model_1,\n",
        "             loss_fn = loss_fn,\n",
        "             accuracy_fn = accuracy_fn\n",
        "             )\n",
        "  \n",
        "\n",
        "train_time_end_on_gpu = timer()\n",
        "total_train_time_model_1 = print_train_time(start=train_time_start_on_gpu,\n",
        "                                            end=train_time_end_on_gpu,\n",
        "                                            device=device)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 327,
          "referenced_widgets": [
            "c5ea9efeb1894b4fba02021d0bd49171",
            "ce24dad2ae94464b90609ad5d3f5a97e",
            "ddf45dbb0bf4402c8662b9cb509bc321",
            "758bd27ac7414ababee46bf7c51f593a",
            "e7a54e57735846f484b409a74af06208",
            "9d76675851a4441c93f841062ba6de84",
            "9e6a1b18c7cf4608a529e77155c8fb7c",
            "9cd996bb165546eda136a558f7fd5a31",
            "77493f09f46e463f8e5ffe5741b902e9",
            "4b19bce7bbd54bf9804d0aed4ea5db8d",
            "10fa97b220ff44de86515de0f7092b4f"
          ]
        },
        "id": "Ndu4aqIUD2kF",
        "outputId": "f81b1015-28f0-4c7b-cf92-6fdb9aa0fc8f"
      },
      "id": "Ndu4aqIUD2kF",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/3 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "c5ea9efeb1894b4fba02021d0bd49171"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0\n",
            "--------- \n",
            "Train loss: 0.80838 | Train Accuracy: 70.84%\n",
            "Test loss: 0.71562 | Test accuracy: 74.49%\n",
            "\n",
            "Epoch: 1\n",
            "--------- \n",
            "Train loss: 0.67008 | Train Accuracy: 75.81%\n",
            "Test loss: 0.69731 | Test accuracy: 74.74%\n",
            "\n",
            "Epoch: 2\n",
            "--------- \n",
            "Train loss: 0.64269 | Train Accuracy: 76.63%\n",
            "Test loss: 0.66914 | Test accuracy: 75.87%\n",
            "\n",
            "Train time on cuda : 33.267 seconds\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "719b8eb9-9a7f-42ed-a49f-5eedc6fdd720",
      "metadata": {
        "id": "719b8eb9-9a7f-42ed-a49f-5eedc6fdd720"
      },
      "source": [
        "Excellent!\n",
        "\n",
        "Our model trained but the training time took longer?\n",
        "\n",
        "> **Note:** The training time on CUDA vs CPU will depend largely on the quality of the CPU/GPU you're using. Read on for a more explained answer.\n",
        "\n",
        "> **Question:** \"I used a a GPU but my model didn't train faster, why might that be?\"\n",
        ">\n",
        "> **Answer:** Well, one reason could be because your dataset and model are both so small (like the dataset and model we're working with) the benefits of using a GPU are outweighed by the time it actually takes to transfer the data there.\n",
        "> \n",
        "> There's a small bottleneck between copying data from the CPU memory (default) to the GPU memory.\n",
        ">\n",
        "> So for smaller models and datasets, the CPU might actually be the optimal place to compute on.\n",
        ">\n",
        "> But for larger datasets and models, the speed of computing the GPU can offer usually far outweighs the cost of getting the data there.\n",
        ">\n",
        "> However, this is largely dependant on the hardware you're using. With practice, you will get used to where the best place to train your models is. \n",
        "\n",
        "Let's evaluate our trained `model_1` using our `eval_model()` function and see how it went."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "32a544e3-9dbe-4aa1-b074-22e28b8f2f2a",
      "metadata": {
        "id": "32a544e3-9dbe-4aa1-b074-22e28b8f2f2a",
        "outputId": "3582d0f4-d80e-45ac-ec43-eeb935a7e353",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'model_name': 'FashionMNISTModelV1',\n",
              " 'model_loss': 0.47663894295692444,\n",
              " 'model_acc': 83.42651757188499}"
            ]
          },
          "metadata": {},
          "execution_count": 80
        }
      ],
      "source": [
        "torch.manual_seed(42)\n",
        "\n",
        "# Note: This will error due to `eval_model()` not using device agnostic code \n",
        "model_1_results = eval_model(model=model_1, \n",
        "    data_loader=test_dataloader,\n",
        "    loss_fn=loss_fn, \n",
        "    accuracy_fn=accuracy_fn) \n",
        "model_1_results "
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6a3481a5-489d-4db9-ac95-c3ce385978b7",
      "metadata": {
        "id": "6a3481a5-489d-4db9-ac95-c3ce385978b7"
      },
      "source": [
        "Oh no! \n",
        "\n",
        "It looks like our `eval_model()` function errors out with:\n",
        "\n",
        "> `RuntimeError: Expected all tensors to be on the same device, but found at least two devices, cuda:0 and cpu! (when checking argument for argument mat1 in method wrapper_addmm)`\n",
        "\n",
        "It's because we've setup our data and model to use device-agnostic code but not our evaluation function.\n",
        "\n",
        "How about we fix that by passing a target `device` parameter to our `eval_model()` function?\n",
        "\n",
        "Then we'll try calculating the results again."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f3665d99-1adc-4d9f-bfc6-e5601a80691c",
      "metadata": {
        "id": "f3665d99-1adc-4d9f-bfc6-e5601a80691c",
        "outputId": "6c3ea3c4-19ae-4902-8afd-54eb546d13a3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'model_name': 'FashionMNISTModelV1',\n",
              " 'model_loss': 0.6470412611961365,\n",
              " 'model_acc': 76.61741214057508}"
            ]
          },
          "metadata": {},
          "execution_count": 81
        }
      ],
      "source": [
        "# Move values to device\n",
        "torch.manual_seed(42)\n",
        "def eval_model(model: torch.nn.Module, \n",
        "               data_loader: torch.utils.data.DataLoader, \n",
        "               loss_fn: torch.nn.Module, \n",
        "               accuracy_fn, \n",
        "               device: torch.device = device):\n",
        "    \"\"\"Evaluates a given model on a given dataset.\n",
        "\n",
        "    Args:\n",
        "        model (torch.nn.Module): A PyTorch model capable of making predictions on data_loader.\n",
        "        data_loader (torch.utils.data.DataLoader): The target dataset to predict on.\n",
        "        loss_fn (torch.nn.Module): The loss function of model.\n",
        "        accuracy_fn: An accuracy function to compare the models predictions to the truth labels.\n",
        "        device (str, optional): Target device to compute on. Defaults to device.\n",
        "\n",
        "    Returns:\n",
        "        (dict): Results of model making predictions on data_loader.\n",
        "    \"\"\"\n",
        "    loss, acc = 0, 0\n",
        "    model.eval()\n",
        "    with torch.inference_mode():\n",
        "        for X, y in data_loader:\n",
        "            # Send data to the target device\n",
        "            X, y = X.to(device), y.to(device)\n",
        "            y_pred = model(X)\n",
        "            loss += loss_fn(y_pred, y)\n",
        "            acc += accuracy_fn(y_true=y, y_pred=y_pred.argmax(dim=1))\n",
        "        \n",
        "        # Scale loss and acc\n",
        "        loss /= len(data_loader)\n",
        "        acc /= len(data_loader)\n",
        "    return {\"model_name\": model.__class__.__name__, # only works when model was created with a class\n",
        "            \"model_loss\": loss.item(),\n",
        "            \"model_acc\": acc}\n",
        "\n",
        "# Calculate model 1 results with device-agnostic code \n",
        "model_1_results = eval_model(model=model_1, data_loader=test_dataloader,\n",
        "    loss_fn=loss_fn, accuracy_fn=accuracy_fn,\n",
        "    device=device\n",
        ")\n",
        "model_1_results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a9e916cf-f873-4481-a983-bac26ce4cac2",
      "metadata": {
        "id": "a9e916cf-f873-4481-a983-bac26ce4cac2",
        "outputId": "186fb932-11bf-4851-8873-d28d3d6344f2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'model_name': 'FashionMNISTModelV0',\n",
              " 'model_loss': 0.47663894295692444,\n",
              " 'model_acc': 83.42651757188499}"
            ]
          },
          "metadata": {},
          "execution_count": 82
        }
      ],
      "source": [
        "# Check baseline results\n",
        "model_0_results"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "340cbf14-e83f-4981-8a93-5fedb6b51418",
      "metadata": {
        "id": "340cbf14-e83f-4981-8a93-5fedb6b51418"
      },
      "source": [
        "Woah, in this case, it looks like adding non-linearities to our model made it perform worse than the baseline.\n",
        "\n",
        "\n",
        "In the meantime, let's take a look at number 1: using a different model."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ac22d685-1b8d-4215-90de-c0476cb0fbdf",
      "metadata": {
        "id": "ac22d685-1b8d-4215-90de-c0476cb0fbdf"
      },
      "source": [
        "## 7. Model 2: Building a Convolutional Neural Network (CNN)\n",
        "\n",
        "- It's time to create a [Convolutional Neural Network](https://en.wikipedia.org/wiki/Convolutional_neural_network) (CNN or ConvNet).\n",
        "\n",
        "- CNN's are known for their capabilities to find patterns in visual data. And since we're dealing with visual data, let's see if using a CNN model can improve upon our baseline.\n",
        "\n",
        "- The CNN model we're going to be using is known as TinyVGG from the [CNN Explainer](https://poloclub.github.io/cnn-explainer/) website.\n",
        "\n",
        "- It follows the typical structure of a convolutional neural network:\n",
        "\n",
        "`Input layer -> [Convolutional layer -> activation layer -> pooling layer] -> Output layer`\n",
        "\n",
        "Where the contents of `[Convolutional layer -> activation layer -> pooling layer]` can be upscaled and repeated multiple times, depending on requirements. "
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9c358955-1d20-4903-b872-a239d2753d88",
      "metadata": {
        "id": "9c358955-1d20-4903-b872-a239d2753d88"
      },
      "source": [
        "### What model should I use?\n",
        "\n",
        "> **Question:** Wait, you say CNN's are good for images, are there any other model types I should be aware of?\n",
        "\n",
        "Good question.\n",
        "\n",
        "This table is a good general guide for which model to use (though there are exceptions).\n",
        "\n",
        "| **Problem type** | **Model to use (generally)** | **Code example** |\n",
        "| ----- | ----- | ----- |\n",
        "| Structured data (Excel spreadsheets, row and column data) | Gradient boosted models, Random Forests, XGBoost | [`sklearn.ensemble`](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.ensemble), [XGBoost library](https://xgboost.readthedocs.io/en/stable/) |\n",
        "| Unstructured data (images, audio, language) | Convolutional Neural Networks, Transformers | [`torchvision.models`](https://pytorch.org/vision/stable/models.html), [HuggingFace Transformers](https://huggingface.co/docs/transformers/index) | \n",
        "\n",
        "> **Note:** The table above is only for reference, the model you end up using will be highly dependant on the problem you're working on and the constraints you have (amount of data, latency requirements).\n",
        "\n",
        "Enough talking about models, let's now build a CNN that replicates the model on the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/).\n",
        "\n",
        "![TinyVGG architecture, as setup by CNN explainer website](https://raw.githubusercontent.com/mrdbourke/pytorch-deep-learning/main/images/03-cnn-explainer-model.png)\n",
        "\n",
        "To do so, we'll leverage the [`nn.Conv2d()`](https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html) and [`nn.MaxPool2d()`](https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html) layers from `torch.nn`.\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a convolutional neural Network\n",
        "class FashionMNISTModelV2(nn.Module):\n",
        "    \"\"\"\n",
        "    Model architecture copying TinyVGG from: \n",
        "    https://poloclub.github.io/cnn-explainer/\n",
        "    \"\"\"\n",
        "    def __init__(self, input_shape: int, hidden_units: int, output_shape: int):\n",
        "      super().__init__()\n",
        "      self.block_1 = nn.Sequential(\n",
        "          nn.Conv2d(in_channels=input_shape,\n",
        "                    out_channels=hidden_units,\n",
        "                    kernel_size = 3,\n",
        "                    stride = 1,\n",
        "                    padding = 1),\n",
        "          nn.ReLU(),\n",
        "          nn.Conv2d(in_channels = hidden_units,\n",
        "                    out_channels = hidden_units,\n",
        "                    kernel_size = 3,\n",
        "                    stride = 1,\n",
        "                    padding = 1),\n",
        "          nn.ReLU(),\n",
        "          nn.MaxPool2d(kernel_size = 2,\n",
        "                       stride = 2)\n",
        "      )\n",
        "\n",
        "      self.block_2 = nn.Sequential(\n",
        "          nn.Conv2d(hidden_units,hidden_units, kernel_size =3 ,padding=1),\n",
        "          nn.ReLU(),\n",
        "          nn.Conv2d(hidden_units,hidden_units, kernel_size=3,padding = 1),\n",
        "          nn.ReLU(),\n",
        "          nn.MaxPool2d(2)\n",
        "      )\n",
        "      self.classifier = nn.Sequential(\n",
        "          nn.Flatten(),\n",
        "          nn.Linear(in_features = hidden_units*7*7,\n",
        "                    out_features = output_shape)\n",
        "      )\n",
        "\n",
        "    def forward(self, x:torch.Tensor):\n",
        "      x = self.block_1(x)\n",
        "      x = self.block_2(x)\n",
        "      x = self.classifier(x)\n",
        "      return x"
      ],
      "metadata": {
        "id": "lj_eeWx0wpni"
      },
      "id": "lj_eeWx0wpni",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "model_2 = FashionMNISTModelV2(input_shape = 1,\n",
        "                              hidden_units = 10,\n",
        "                              output_shape = len(class_names)).to(device)\n",
        "model_2 "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f-znUT2ZI6KV",
        "outputId": "af6cf2d8-f5b1-4388-968a-1af25143202b"
      },
      "id": "f-znUT2ZI6KV",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "FashionMNISTModelV2(\n",
              "  (block_1): Sequential(\n",
              "    (0): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (1): ReLU()\n",
              "    (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (3): ReLU()\n",
              "    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
              "  )\n",
              "  (block_2): Sequential(\n",
              "    (0): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (1): ReLU()\n",
              "    (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (3): ReLU()\n",
              "    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
              "  )\n",
              "  (classifier): Sequential(\n",
              "    (0): Flatten(start_dim=1, end_dim=-1)\n",
              "    (1): Linear(in_features=490, out_features=10, bias=True)\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6478cc5a-7b33-425d-9ab3-6d40168a1aee",
      "metadata": {
        "id": "6478cc5a-7b33-425d-9ab3-6d40168a1aee"
      },
      "source": [
        "### 7.1 Stepping through `nn.Conv2d()`\n",
        "\n",
        "We could start using our model above and see what happens but let's first step through the two new layers we've added:\n",
        "* [`nn.Conv2d()`](https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html), also known as a convolutional layer.\n",
        "* [`nn.MaxPool2d()`](https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html), also known as a max pooling layer.\n",
        "\n",
        "> **Question:** What does the \"2d\" in `nn.Conv2d()` stand for?\n",
        ">\n",
        "> The 2d is for 2-dimensional data. As in, our images have two dimensions: height and width. Yes, there's color channel dimension but each of the color channel dimensions have two dimensions too: height and width.\n",
        ">\n",
        "> For other dimensional data (such as 1D for text or 3D for 3D objects) there's also `nn.Conv1d()` and `nn.Conv3d()`. \n",
        "\n",
        "To test the layers out, let's create some toy data just like the data used on CNN Explainer."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "058b01ac-3f6a-4472-bcbf-3377974e3254",
      "metadata": {
        "id": "058b01ac-3f6a-4472-bcbf-3377974e3254",
        "outputId": "71fcc5d6-5637-413f-b629-d60420f72e6e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Image batch shape: torch.Size([32, 3, 64, 64]) -> [batch_size, color_channels, height, width]\n",
            "Single image shape: torch.Size([3, 64, 64]) -> [color_channels, height, width]\n",
            "Single image pixel values:\n",
            "tensor([[[ 1.9269,  1.4873,  0.9007,  ...,  1.8446, -1.1845,  1.3835],\n",
            "         [ 1.4451,  0.8564,  2.2181,  ...,  0.3399,  0.7200,  0.4114],\n",
            "         [ 1.9312,  1.0119, -1.4364,  ..., -0.5558,  0.7043,  0.7099],\n",
            "         ...,\n",
            "         [-0.5610, -0.4830,  0.4770,  ..., -0.2713, -0.9537, -0.6737],\n",
            "         [ 0.3076, -0.1277,  0.0366,  ..., -2.0060,  0.2824, -0.8111],\n",
            "         [-1.5486,  0.0485, -0.7712,  ..., -0.1403,  0.9416, -0.0118]],\n",
            "\n",
            "        [[-0.5197,  1.8524,  1.8365,  ...,  0.8935, -1.5114, -0.8515],\n",
            "         [ 2.0818,  1.0677, -1.4277,  ...,  1.6612, -2.6223, -0.4319],\n",
            "         [-0.1010, -0.4388, -1.9775,  ...,  0.2106,  0.2536, -0.7318],\n",
            "         ...,\n",
            "         [ 0.2779,  0.7342, -0.3736,  ..., -0.4601,  0.1815,  0.1850],\n",
            "         [ 0.7205, -0.2833,  0.0937,  ..., -0.1002, -2.3609,  2.2465],\n",
            "         [-1.3242, -0.1973,  0.2920,  ...,  0.5409,  0.6940,  1.8563]],\n",
            "\n",
            "        [[-0.7978,  1.0261,  1.1465,  ...,  1.2134,  0.9354, -0.0780],\n",
            "         [-1.4647, -1.9571,  0.1017,  ..., -1.9986, -0.7409,  0.7011],\n",
            "         [-1.3938,  0.8466, -1.7191,  ..., -1.1867,  0.1320,  0.3407],\n",
            "         ...,\n",
            "         [ 0.8206, -0.3745,  1.2499,  ..., -0.0676,  0.0385,  0.6335],\n",
            "         [-0.5589, -0.3393,  0.2347,  ...,  2.1181,  2.4569,  1.3083],\n",
            "         [-0.4092,  1.5199,  0.2401,  ..., -0.2558,  0.7870,  0.9924]]])\n"
          ]
        }
      ],
      "source": [
        "torch.manual_seed(42)\n",
        "\n",
        "# Create sample batch of random numbers with same size as image batch\n",
        "images = torch.randn(size=(32, 3, 64, 64)) # [batch_size, color_channels, height, width]\n",
        "test_image = images[0] # get a single image for testing\n",
        "print(f\"Image batch shape: {images.shape} -> [batch_size, color_channels, height, width]\")\n",
        "print(f\"Single image shape: {test_image.shape} -> [color_channels, height, width]\") \n",
        "print(f\"Single image pixel values:\\n{test_image}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bd3291c2-854e-4d0c-97b9-8bf46085fc43",
      "metadata": {
        "id": "bd3291c2-854e-4d0c-97b9-8bf46085fc43"
      },
      "source": [
        "Let's create an example `nn.Conv2d()` with various parameters:\n",
        "* `in_channels` (int) - Number of channels in the input image.\n",
        "* `out_channels` (int) - Number of channels produced by the convolution.\n",
        "* `kernel_size` (int or tuple) - Size of the convolving kernel/filter.\n",
        "* `stride` (int or tuple, optional) - How big of a step the convolving kernel takes at a time. Default: 1.\n",
        "* `padding` (int, tuple, str) - Padding added to all four sides of input. Default: 0.\n",
        "\n",
        "![example of going through the different parameters of a Conv2d layer](https://raw.githubusercontent.com/mrdbourke/pytorch-deep-learning/main/images/03-conv2d-layer.gif)\n",
        "\n",
        "*Example of what happens when you change the hyperparameters of a `nn.Conv2d()` layer.*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ebd39562-1dad-40e3-90f5-750a5dac24e2",
      "metadata": {
        "id": "ebd39562-1dad-40e3-90f5-750a5dac24e2",
        "outputId": "5ef92fd8-7963-41a2-c555-2c1c071bc994",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[ 1.5396,  0.0516,  0.6454,  ..., -0.3673,  0.8711,  0.4256],\n",
              "         [ 0.3662,  1.0114, -0.5997,  ...,  0.8983,  0.2809, -0.2741],\n",
              "         [ 1.2664, -1.4054,  0.3727,  ..., -0.3409,  1.2191, -0.0463],\n",
              "         ...,\n",
              "         [-0.1541,  0.5132, -0.3624,  ..., -0.2360, -0.4609, -0.0035],\n",
              "         [ 0.2981, -0.2432,  1.5012,  ..., -0.6289, -0.7283, -0.5767],\n",
              "         [-0.0386, -0.0781, -0.0388,  ...,  0.2842,  0.4228, -0.1802]],\n",
              "\n",
              "        [[-0.2840, -0.0319, -0.4455,  ..., -0.7956,  1.5599, -1.2449],\n",
              "         [ 0.2753, -0.1262, -0.6541,  ..., -0.2211,  0.1999, -0.8856],\n",
              "         [-0.5404, -1.5489,  0.0249,  ..., -0.5932, -1.0913, -0.3849],\n",
              "         ...,\n",
              "         [ 0.3870, -0.4064, -0.8236,  ...,  0.1734, -0.4330, -0.4951],\n",
              "         [-0.1984, -0.6386,  1.0263,  ..., -0.9401, -0.0585, -0.7833],\n",
              "         [-0.6306, -0.2052, -0.3694,  ..., -1.3248,  0.2456, -0.7134]],\n",
              "\n",
              "        [[ 0.4414,  0.5100,  0.4846,  ..., -0.8484,  0.2638,  1.1258],\n",
              "         [ 0.8117,  0.3191, -0.0157,  ...,  1.2686,  0.2319,  0.5003],\n",
              "         [ 0.3212,  0.0485, -0.2581,  ...,  0.2258,  0.2587, -0.8804],\n",
              "         ...,\n",
              "         [-0.1144, -0.1869,  0.0160,  ..., -0.8346,  0.0974,  0.8421],\n",
              "         [ 0.2941,  0.4417,  0.5866,  ..., -0.1224,  0.4814, -0.4799],\n",
              "         [ 0.6059, -0.0415, -0.2028,  ...,  0.1170,  0.2521, -0.4372]],\n",
              "\n",
              "        ...,\n",
              "\n",
              "        [[-0.2560, -0.0477,  0.6380,  ...,  0.6436,  0.7553, -0.7055],\n",
              "         [ 1.5595, -0.2209, -0.9486,  ..., -0.4876,  0.7754,  0.0750],\n",
              "         [-0.0797,  0.2471,  1.1300,  ...,  0.1505,  0.2354,  0.9576],\n",
              "         ...,\n",
              "         [ 1.1065,  0.6839,  1.2183,  ...,  0.3015, -0.1910, -0.1902],\n",
              "         [-0.3486, -0.7173, -0.3582,  ...,  0.4917,  0.7219,  0.1513],\n",
              "         [ 0.0119,  0.1017,  0.7839,  ..., -0.3752, -0.8127, -0.1257]],\n",
              "\n",
              "        [[ 0.3841,  1.1322,  0.1620,  ...,  0.7010,  0.0109,  0.6058],\n",
              "         [ 0.1664,  0.1873,  1.5924,  ...,  0.3733,  0.9096, -0.5399],\n",
              "         [ 0.4094, -0.0861, -0.7935,  ..., -0.1285, -0.9932, -0.3013],\n",
              "         ...,\n",
              "         [ 0.2688, -0.5630, -1.1902,  ...,  0.4493,  0.5404, -0.0103],\n",
              "         [ 0.0535,  0.4411,  0.5313,  ...,  0.0148, -1.0056,  0.3759],\n",
              "         [ 0.3031, -0.1590, -0.1316,  ..., -0.5384, -0.4271, -0.4876]],\n",
              "\n",
              "        [[-1.1865, -0.7280, -1.2331,  ..., -0.9013, -0.0542, -1.5949],\n",
              "         [-0.6345, -0.5920,  0.5326,  ..., -1.0395, -0.7963, -0.0647],\n",
              "         [-0.1132,  0.5166,  0.2569,  ...,  0.5595, -1.6881,  0.9485],\n",
              "         ...,\n",
              "         [-0.0254, -0.2669,  0.1927,  ..., -0.2917,  0.1088, -0.4807],\n",
              "         [-0.2609, -0.2328,  0.1404,  ..., -0.1325, -0.8436, -0.7524],\n",
              "         [-1.1399, -0.1751, -0.8705,  ...,  0.1589,  0.3377,  0.3493]]],\n",
              "       grad_fn=<SqueezeBackward1>)"
            ]
          },
          "metadata": {},
          "execution_count": 86
        }
      ],
      "source": [
        "torch.manual_seed(42)\n",
        "\n",
        "# Create a convolutional layer with same dimensions as TinyVGG \n",
        "# (try changing any of the parameters and see what happens)\n",
        "conv_layer = nn.Conv2d(in_channels=3,\n",
        "                       out_channels=10,\n",
        "                       kernel_size=3,\n",
        "                       stride=1,\n",
        "                       padding=0) # also try using \"valid\" or \"same\" here \n",
        "\n",
        "# Pass the data through the convolutional layer\n",
        "conv_layer(test_image) # Note: If running PyTorch <1.11.0, this will error because of shape issues (nn.Conv.2d() expects a 4d tensor as input) "
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cb0184ad-5c16-4e1c-bcfa-70ecf15377da",
      "metadata": {
        "id": "cb0184ad-5c16-4e1c-bcfa-70ecf15377da"
      },
      "source": [
        "If we try to pass a single image in, we get a shape mismatch error:\n",
        "\n",
        "> `RuntimeError: Expected 4-dimensional input for 4-dimensional weight [10, 3, 3, 3], but got 3-dimensional input of size [3, 64, 64] instead`\n",
        ">\n",
        "> **Note:** If you're running PyTorch 1.11.0+, this error won't occur.\n",
        "\n",
        "This is because our `nn.Conv2d()` layer expects a 4-dimensional tensor as input with size `(N, C, H, W)` or `[batch_size, color_channels, height, width]`.\n",
        "\n",
        "Right now our single image `test_image` only has a shape of `[color_channels, height, width]` or `[3, 64, 64]`.\n",
        "\n",
        "We can fix this for a single image using `test_image.unsqueeze(dim=0)` to add an extra dimension for `N`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "abba741d-a1ed-44ed-ba53-41d589433a2c",
      "metadata": {
        "id": "abba741d-a1ed-44ed-ba53-41d589433a2c",
        "outputId": "a4555d97-f55f-4bd0-a61d-332994c653d9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 3, 64, 64])"
            ]
          },
          "metadata": {},
          "execution_count": 87
        }
      ],
      "source": [
        "# Add extra dimension to test image\n",
        "test_image.unsqueeze(dim=0).shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c7280a49-4ee0-452b-a514-61115b6a444c",
      "metadata": {
        "id": "c7280a49-4ee0-452b-a514-61115b6a444c",
        "outputId": "d4278189-7769-4dfd-a0e0-f681aebd6217",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 10, 62, 62])"
            ]
          },
          "metadata": {},
          "execution_count": 88
        }
      ],
      "source": [
        "# Pass test image with extra dimension through conv_layer\n",
        "conv_layer(test_image.unsqueeze(dim=0)).shape"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "181df81b-7c5a-46cc-b8d5-a592bf755a13",
      "metadata": {
        "id": "181df81b-7c5a-46cc-b8d5-a592bf755a13"
      },
      "source": [
        "Hmm, notice what happens to our shape (the same shape as the first layer of TinyVGG on [CNN Explainer](https://poloclub.github.io/cnn-explainer/)), we get different channel sizes as well as different pixel sizes.\n",
        "\n",
        "What if we changed the values of `conv_layer`?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "04445d45-cf2f-4c1d-b215-bc50865a207a",
      "metadata": {
        "id": "04445d45-cf2f-4c1d-b215-bc50865a207a",
        "outputId": "c354eb88-e906-41a4-c285-563d5598c0dc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 10, 30, 30])"
            ]
          },
          "metadata": {},
          "execution_count": 89
        }
      ],
      "source": [
        "torch.manual_seed(42)\n",
        "# Create a new conv_layer with different values (try setting these to whatever you like)\n",
        "conv_layer_2 = nn.Conv2d(in_channels=3, # same number of color channels as our input image\n",
        "                         out_channels=10,\n",
        "                         kernel_size=(5, 5), # kernel is usually a square so a tuple also works\n",
        "                         stride=2,\n",
        "                         padding=0)\n",
        "\n",
        "# Pass single image through new conv_layer_2 (this calls nn.Conv2d()'s forward() method on the input)\n",
        "conv_layer_2(test_image.unsqueeze(dim=0)).shape"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b27dbdbb-3e32-4ffa-803e-cf943d96c72b",
      "metadata": {
        "id": "b27dbdbb-3e32-4ffa-803e-cf943d96c72b"
      },
      "source": [
        "Woah, we get another shape change.\n",
        "\n",
        "Now our image is of shape `[1, 10, 30, 30]` (it will be different if you use different values) or `[batch_size=1, color_channels=10, height=30, width=30]`.\n",
        "\n",
        "What's going on here?\n",
        "\n",
        "Behind the scenes, our `nn.Conv2d()` is compressing the information stored in the image.\n",
        "\n",
        "It does this by performing operations on the input (our test image) against its internal parameters.\n",
        "\n",
        "The goal of this is similar to all of the other neural networks we've been building.\n",
        "\n",
        "Data goes in and the layers try to update their internal parameters (patterns) to lower the loss function thanks to some help of the optimizer.\n",
        "\n",
        "The only difference is *how* the different layers calculate their parameter updates or in PyTorch terms, the operation present in the layer `forward()` method.\n",
        "\n",
        "If we check out our `conv_layer_2.state_dict()` we'll find a similar weight and bias setup as we've seen before."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "46027ed1-c3a7-46bd-bab7-17f8c20e354b",
      "metadata": {
        "id": "46027ed1-c3a7-46bd-bab7-17f8c20e354b",
        "outputId": "b92dd516-5953-4e83-b01f-a87bf99026e2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "OrderedDict([('weight', tensor([[[[ 0.0883,  0.0958, -0.0271,  0.1061, -0.0253],\n",
            "          [ 0.0233, -0.0562,  0.0678,  0.1018, -0.0847],\n",
            "          [ 0.1004,  0.0216,  0.0853,  0.0156,  0.0557],\n",
            "          [-0.0163,  0.0890,  0.0171, -0.0539,  0.0294],\n",
            "          [-0.0532, -0.0135, -0.0469,  0.0766, -0.0911]],\n",
            "\n",
            "         [[-0.0532, -0.0326, -0.0694,  0.0109, -0.1140],\n",
            "          [ 0.1043, -0.0981,  0.0891,  0.0192, -0.0375],\n",
            "          [ 0.0714,  0.0180,  0.0933,  0.0126, -0.0364],\n",
            "          [ 0.0310, -0.0313,  0.0486,  0.1031,  0.0667],\n",
            "          [-0.0505,  0.0667,  0.0207,  0.0586, -0.0704]],\n",
            "\n",
            "         [[-0.1143, -0.0446, -0.0886,  0.0947,  0.0333],\n",
            "          [ 0.0478,  0.0365, -0.0020,  0.0904, -0.0820],\n",
            "          [ 0.0073, -0.0788,  0.0356, -0.0398,  0.0354],\n",
            "          [-0.0241,  0.0958, -0.0684, -0.0689, -0.0689],\n",
            "          [ 0.1039,  0.0385,  0.1111, -0.0953, -0.1145]]],\n",
            "\n",
            "\n",
            "        [[[-0.0903, -0.0777,  0.0468,  0.0413,  0.0959],\n",
            "          [-0.0596, -0.0787,  0.0613, -0.0467,  0.0701],\n",
            "          [-0.0274,  0.0661, -0.0897, -0.0583,  0.0352],\n",
            "          [ 0.0244, -0.0294,  0.0688,  0.0785, -0.0837],\n",
            "          [-0.0616,  0.1057, -0.0390, -0.0409, -0.1117]],\n",
            "\n",
            "         [[-0.0661,  0.0288, -0.0152, -0.0838,  0.0027],\n",
            "          [-0.0789, -0.0980, -0.0636, -0.1011, -0.0735],\n",
            "          [ 0.1154,  0.0218,  0.0356, -0.1077, -0.0758],\n",
            "          [-0.0384,  0.0181, -0.1016, -0.0498, -0.0691],\n",
            "          [ 0.0003, -0.0430, -0.0080, -0.0782, -0.0793]],\n",
            "\n",
            "         [[-0.0674, -0.0395, -0.0911,  0.0968, -0.0229],\n",
            "          [ 0.0994,  0.0360, -0.0978,  0.0799, -0.0318],\n",
            "          [-0.0443, -0.0958, -0.1148,  0.0330, -0.0252],\n",
            "          [ 0.0450, -0.0948,  0.0857, -0.0848, -0.0199],\n",
            "          [ 0.0241,  0.0596,  0.0932,  0.1052, -0.0916]]],\n",
            "\n",
            "\n",
            "        [[[ 0.0291, -0.0497, -0.0127, -0.0864,  0.1052],\n",
            "          [-0.0847,  0.0617,  0.0406,  0.0375, -0.0624],\n",
            "          [ 0.1050,  0.0254,  0.0149, -0.1018,  0.0485],\n",
            "          [-0.0173, -0.0529,  0.0992,  0.0257, -0.0639],\n",
            "          [-0.0584, -0.0055,  0.0645, -0.0295, -0.0659]],\n",
            "\n",
            "         [[-0.0395, -0.0863,  0.0412,  0.0894, -0.1087],\n",
            "          [ 0.0268,  0.0597,  0.0209, -0.0411,  0.0603],\n",
            "          [ 0.0607,  0.0432, -0.0203, -0.0306,  0.0124],\n",
            "          [-0.0204, -0.0344,  0.0738,  0.0992, -0.0114],\n",
            "          [-0.0259,  0.0017, -0.0069,  0.0278,  0.0324]],\n",
            "\n",
            "         [[-0.1049, -0.0426,  0.0972,  0.0450, -0.0057],\n",
            "          [-0.0696, -0.0706, -0.1034, -0.0376,  0.0390],\n",
            "          [ 0.0736,  0.0533, -0.1021, -0.0694, -0.0182],\n",
            "          [ 0.1117,  0.0167, -0.0299,  0.0478, -0.0440],\n",
            "          [-0.0747,  0.0843, -0.0525, -0.0231, -0.1149]]],\n",
            "\n",
            "\n",
            "        [[[ 0.0773,  0.0875,  0.0421, -0.0805, -0.1140],\n",
            "          [-0.0938,  0.0861,  0.0554,  0.0972,  0.0605],\n",
            "          [ 0.0292, -0.0011, -0.0878, -0.0989, -0.1080],\n",
            "          [ 0.0473, -0.0567, -0.0232, -0.0665, -0.0210],\n",
            "          [-0.0813, -0.0754,  0.0383, -0.0343,  0.0713]],\n",
            "\n",
            "         [[-0.0370, -0.0847, -0.0204, -0.0560, -0.0353],\n",
            "          [-0.1099,  0.0646, -0.0804,  0.0580,  0.0524],\n",
            "          [ 0.0825, -0.0886,  0.0830, -0.0546,  0.0428],\n",
            "          [ 0.1084, -0.0163, -0.0009, -0.0266, -0.0964],\n",
            "          [ 0.0554, -0.1146,  0.0717,  0.0864,  0.1092]],\n",
            "\n",
            "         [[-0.0272, -0.0949,  0.0260,  0.0638, -0.1149],\n",
            "          [-0.0262, -0.0692, -0.0101, -0.0568, -0.0472],\n",
            "          [-0.0367, -0.1097,  0.0947,  0.0968, -0.0181],\n",
            "          [-0.0131, -0.0471, -0.1043, -0.1124,  0.0429],\n",
            "          [-0.0634, -0.0742, -0.0090, -0.0385, -0.0374]]],\n",
            "\n",
            "\n",
            "        [[[ 0.0037, -0.0245, -0.0398, -0.0553, -0.0940],\n",
            "          [ 0.0968, -0.0462,  0.0306, -0.0401,  0.0094],\n",
            "          [ 0.1077,  0.0532, -0.1001,  0.0458,  0.1096],\n",
            "          [ 0.0304,  0.0774,  0.1138, -0.0177,  0.0240],\n",
            "          [-0.0803, -0.0238,  0.0855,  0.0592, -0.0731]],\n",
            "\n",
            "         [[-0.0926, -0.0789, -0.1140, -0.0891, -0.0286],\n",
            "          [ 0.0779,  0.0193, -0.0878, -0.0926,  0.0574],\n",
            "          [-0.0859, -0.0142,  0.0554, -0.0534, -0.0126],\n",
            "          [-0.0101, -0.0273, -0.0585, -0.1029, -0.0933],\n",
            "          [-0.0618,  0.1115, -0.0558, -0.0775,  0.0280]],\n",
            "\n",
            "         [[ 0.0318,  0.0633,  0.0878,  0.0643, -0.1145],\n",
            "          [ 0.0102,  0.0699, -0.0107, -0.0680,  0.1101],\n",
            "          [-0.0432, -0.0657, -0.1041,  0.0052,  0.0512],\n",
            "          [ 0.0256,  0.0228, -0.0876, -0.1078,  0.0020],\n",
            "          [ 0.1053,  0.0666, -0.0672, -0.0150, -0.0851]]],\n",
            "\n",
            "\n",
            "        [[[-0.0557,  0.0209,  0.0629,  0.0957, -0.1060],\n",
            "          [ 0.0772, -0.0814,  0.0432,  0.0977,  0.0016],\n",
            "          [ 0.1051, -0.0984, -0.0441,  0.0673, -0.0252],\n",
            "          [-0.0236, -0.0481,  0.0796,  0.0566,  0.0370],\n",
            "          [-0.0649, -0.0937,  0.0125,  0.0342, -0.0533]],\n",
            "\n",
            "         [[-0.0323,  0.0780,  0.0092,  0.0052, -0.0284],\n",
            "          [-0.1046, -0.1086, -0.0552, -0.0587,  0.0360],\n",
            "          [-0.0336, -0.0452,  0.1101,  0.0402,  0.0823],\n",
            "          [-0.0559, -0.0472,  0.0424, -0.0769, -0.0755],\n",
            "          [-0.0056, -0.0422, -0.0866,  0.0685,  0.0929]],\n",
            "\n",
            "         [[ 0.0187, -0.0201, -0.1070, -0.0421,  0.0294],\n",
            "          [ 0.0544, -0.0146, -0.0457,  0.0643, -0.0920],\n",
            "          [ 0.0730, -0.0448,  0.0018, -0.0228,  0.0140],\n",
            "          [-0.0349,  0.0840, -0.0030,  0.0901,  0.1110],\n",
            "          [-0.0563, -0.0842,  0.0926,  0.0905, -0.0882]]],\n",
            "\n",
            "\n",
            "        [[[-0.0089, -0.1139, -0.0945,  0.0223,  0.0307],\n",
            "          [ 0.0245, -0.0314,  0.1065,  0.0165, -0.0681],\n",
            "          [-0.0065,  0.0277,  0.0404, -0.0816,  0.0433],\n",
            "          [-0.0590, -0.0959, -0.0631,  0.1114,  0.0987],\n",
            "          [ 0.1034,  0.0678,  0.0872, -0.0155, -0.0635]],\n",
            "\n",
            "         [[ 0.0577, -0.0598, -0.0779, -0.0369,  0.0242],\n",
            "          [ 0.0594, -0.0448, -0.0680,  0.0156, -0.0681],\n",
            "          [-0.0752,  0.0602, -0.0194,  0.1055,  0.1123],\n",
            "          [ 0.0345,  0.0397,  0.0266,  0.0018, -0.0084],\n",
            "          [ 0.0016,  0.0431,  0.1074, -0.0299, -0.0488]],\n",
            "\n",
            "         [[-0.0280, -0.0558,  0.0196,  0.0862,  0.0903],\n",
            "          [ 0.0530, -0.0850, -0.0620, -0.0254, -0.0213],\n",
            "          [ 0.0095, -0.1060,  0.0359, -0.0881, -0.0731],\n",
            "          [-0.0960,  0.1006, -0.1093,  0.0871, -0.0039],\n",
            "          [-0.0134,  0.0722, -0.0107,  0.0724,  0.0835]]],\n",
            "\n",
            "\n",
            "        [[[-0.1003,  0.0444,  0.0218,  0.0248,  0.0169],\n",
            "          [ 0.0316, -0.0555, -0.0148,  0.1097,  0.0776],\n",
            "          [-0.0043, -0.1086,  0.0051, -0.0786,  0.0939],\n",
            "          [-0.0701, -0.0083, -0.0256,  0.0205,  0.1087],\n",
            "          [ 0.0110,  0.0669,  0.0896,  0.0932, -0.0399]],\n",
            "\n",
            "         [[-0.0258,  0.0556, -0.0315,  0.0541, -0.0252],\n",
            "          [-0.0783,  0.0470,  0.0177,  0.0515,  0.1147],\n",
            "          [ 0.0788,  0.1095,  0.0062, -0.0993, -0.0810],\n",
            "          [-0.0717, -0.1018, -0.0579, -0.1063, -0.1065],\n",
            "          [-0.0690, -0.1138, -0.0709,  0.0440,  0.0963]],\n",
            "\n",
            "         [[-0.0343, -0.0336,  0.0617, -0.0570, -0.0546],\n",
            "          [ 0.0711, -0.1006,  0.0141,  0.1020,  0.0198],\n",
            "          [ 0.0314, -0.0672, -0.0016,  0.0063,  0.0283],\n",
            "          [ 0.0449,  0.1003, -0.0881,  0.0035, -0.0577],\n",
            "          [-0.0913, -0.0092, -0.1016,  0.0806,  0.0134]]],\n",
            "\n",
            "\n",
            "        [[[-0.0622,  0.0603, -0.1093, -0.0447, -0.0225],\n",
            "          [-0.0981, -0.0734, -0.0188,  0.0876,  0.1115],\n",
            "          [ 0.0735, -0.0689, -0.0755,  0.1008,  0.0408],\n",
            "          [ 0.0031,  0.0156, -0.0928, -0.0386,  0.1112],\n",
            "          [-0.0285, -0.0058, -0.0959, -0.0646, -0.0024]],\n",
            "\n",
            "         [[-0.0717, -0.0143,  0.0470, -0.1130,  0.0343],\n",
            "          [-0.0763, -0.0564,  0.0443,  0.0918, -0.0316],\n",
            "          [-0.0474, -0.1044, -0.0595, -0.1011, -0.0264],\n",
            "          [ 0.0236, -0.1082,  0.1008,  0.0724, -0.1130],\n",
            "          [-0.0552,  0.0377, -0.0237, -0.0126, -0.0521]],\n",
            "\n",
            "         [[ 0.0927, -0.0645,  0.0958,  0.0075,  0.0232],\n",
            "          [ 0.0901, -0.0190, -0.0657, -0.0187,  0.0937],\n",
            "          [-0.0857,  0.0262, -0.1135,  0.0605,  0.0427],\n",
            "          [ 0.0049,  0.0496,  0.0001,  0.0639, -0.0914],\n",
            "          [-0.0170,  0.0512,  0.1150,  0.0588, -0.0840]]],\n",
            "\n",
            "\n",
            "        [[[ 0.0888, -0.0257, -0.0247, -0.1050, -0.0182],\n",
            "          [ 0.0817,  0.0161, -0.0673,  0.0355, -0.0370],\n",
            "          [ 0.1054, -0.1002, -0.0365, -0.1115, -0.0455],\n",
            "          [ 0.0364,  0.1112,  0.0194,  0.1132,  0.0226],\n",
            "          [ 0.0667,  0.0926,  0.0965, -0.0646,  0.1062]],\n",
            "\n",
            "         [[ 0.0699, -0.0540, -0.0551, -0.0969,  0.0290],\n",
            "          [-0.0936,  0.0488,  0.0365, -0.1003,  0.0315],\n",
            "          [-0.0094,  0.0527,  0.0663, -0.1148,  0.1059],\n",
            "          [ 0.0968,  0.0459, -0.1055, -0.0412, -0.0335],\n",
            "          [-0.0297,  0.0651,  0.0420,  0.0915, -0.0432]],\n",
            "\n",
            "         [[ 0.0389,  0.0411, -0.0961, -0.1120, -0.0599],\n",
            "          [ 0.0790, -0.1087, -0.1005,  0.0647,  0.0623],\n",
            "          [ 0.0950, -0.0872, -0.0845,  0.0592,  0.1004],\n",
            "          [ 0.0691,  0.0181,  0.0381,  0.1096, -0.0745],\n",
            "          [-0.0524,  0.0808, -0.0790, -0.0637,  0.0843]]]])), ('bias', tensor([ 0.0364,  0.0373, -0.0489, -0.0016,  0.1057, -0.0693,  0.0009,  0.0549,\n",
            "        -0.0797,  0.1121]))])\n"
          ]
        }
      ],
      "source": [
        "# Check out the conv_layer_2 internal parameters\n",
        "print(conv_layer_2.state_dict())"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8b708eb6-ae46-4d8c-a8a4-1392827d3e37",
      "metadata": {
        "id": "8b708eb6-ae46-4d8c-a8a4-1392827d3e37"
      },
      "source": [
        "Look at that! A bunch of random numbers for a weight and bias tensor.\n",
        "\n",
        "The shapes of these are manipulated by the inputs we passed to `nn.Conv2d()` when we set it up.\n",
        "\n",
        "Let's check them out."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e5518d61-c0b7-4351-b5ea-4d6b6144291a",
      "metadata": {
        "id": "e5518d61-c0b7-4351-b5ea-4d6b6144291a",
        "outputId": "5c0a5f84-5b50-4f7e-bed7-fd4976ea2c12",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "conv_layer_2 weight shape: \n",
            "torch.Size([10, 3, 5, 5]) -> [out_channels=10, in_channels=3, kernel_size=5, kernel_size=5]\n",
            "\n",
            "conv_layer_2 bias shape: \n",
            "torch.Size([10]) -> [out_channels=10]\n"
          ]
        }
      ],
      "source": [
        "# Get shapes of weight and bias tensors within conv_layer_2\n",
        "print(f\"conv_layer_2 weight shape: \\n{conv_layer_2.weight.shape} -> [out_channels=10, in_channels=3, kernel_size=5, kernel_size=5]\")\n",
        "print(f\"\\nconv_layer_2 bias shape: \\n{conv_layer_2.bias.shape} -> [out_channels=10]\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f0de23c7-4501-4156-80a4-ac889a636a42",
      "metadata": {
        "id": "f0de23c7-4501-4156-80a4-ac889a636a42"
      },
      "source": [
        "> **Question:** What should we set the parameters of our `nn.Conv2d()` layers?\n",
        ">\n",
        "> That's a good one. But similar to many other things in machine learning, the values of these aren't set in stone (and recall, because these values are ones we can set ourselves, they're referred to as \"**hyperparameters**\"). \n",
        ">\n",
        "> The best way to find out is to try out different values and see how they effect your model's performance.\n",
        ">\n",
        "> Or even better, find a working example on a problem similar to yours (like we've done with TinyVGG) and copy it. \n",
        "\n",
        "We're working with a different of layer here to what we've seen before.\n",
        "\n",
        "But the premise remains the same: start with random numbers and update them to better represent the data."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6370d45d-ca44-4fa0-a2d7-efaf0a207b91",
      "metadata": {
        "id": "6370d45d-ca44-4fa0-a2d7-efaf0a207b91"
      },
      "source": [
        "### 7.2 Stepping through `nn.MaxPool2d()`\n",
        "Now let's check out what happens when we move data through `nn.MaxPool2d()`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1164c753-19d9-43b7-a04f-017d0f7188c3",
      "metadata": {
        "id": "1164c753-19d9-43b7-a04f-017d0f7188c3",
        "outputId": "6746f3d8-4197-4512-dc53-c4ad875e0f2d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test image original shape: torch.Size([3, 64, 64])\n",
            "Test image with unsqueezed dimension: torch.Size([1, 3, 64, 64])\n",
            "Shape after going through conv_layer(): torch.Size([1, 10, 62, 62])\n",
            "Shape after going through conv_layer() and max_pool_layer(): torch.Size([1, 10, 31, 31])\n"
          ]
        }
      ],
      "source": [
        "# Print out original image shape without and with unsqueezed dimension\n",
        "print(f\"Test image original shape: {test_image.shape}\")\n",
        "print(f\"Test image with unsqueezed dimension: {test_image.unsqueeze(dim=0).shape}\")\n",
        "\n",
        "# Create a sample nn.MaxPoo2d() layer\n",
        "max_pool_layer = nn.MaxPool2d(kernel_size=2)\n",
        "\n",
        "# Pass data through just the conv_layer\n",
        "test_image_through_conv = conv_layer(test_image.unsqueeze(dim=0))\n",
        "print(f\"Shape after going through conv_layer(): {test_image_through_conv.shape}\")\n",
        "\n",
        "# Pass data through the max pool layer\n",
        "test_image_through_conv_and_max_pool = max_pool_layer(test_image_through_conv)\n",
        "print(f\"Shape after going through conv_layer() and max_pool_layer(): {test_image_through_conv_and_max_pool.shape}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "de029abd-6674-4bfa-99ab-322f339f89f4",
      "metadata": {
        "id": "de029abd-6674-4bfa-99ab-322f339f89f4"
      },
      "source": [
        "Notice the change in the shapes of what's happening in and out of a `nn.MaxPool2d()` layer.\n",
        "\n",
        "The `kernel_size` of the `nn.MaxPool2d()` layer will effects the size of the output shape.\n",
        "\n",
        "In our case, the shape halves from a `62x62` image to `31x31` image.\n",
        "\n",
        "Let's see this work with a smaller tensor."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e6a2b196-4845-4b40-9212-e75406e88875",
      "metadata": {
        "id": "e6a2b196-4845-4b40-9212-e75406e88875",
        "outputId": "0bb60815-4b01-4a06-897d-b822cb81b8f1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Random tensor:\n",
            "tensor([[[[0.3367, 0.1288],\n",
            "          [0.2345, 0.2303]]]])\n",
            "Random tensor shape: torch.Size([1, 1, 2, 2])\n",
            "\n",
            "Max pool tensor:\n",
            "tensor([[[[0.3367]]]]) <- this is the maximum value from random_tensor\n",
            "Max pool tensor shape: torch.Size([1, 1, 1, 1])\n"
          ]
        }
      ],
      "source": [
        "torch.manual_seed(42)\n",
        "# Create a random tensor with a similiar number of dimensions to our images\n",
        "random_tensor = torch.randn(size=(1, 1, 2, 2))\n",
        "print(f\"Random tensor:\\n{random_tensor}\")\n",
        "print(f\"Random tensor shape: {random_tensor.shape}\")\n",
        "\n",
        "# Create a max pool layer\n",
        "max_pool_layer = nn.MaxPool2d(kernel_size=2) # see what happens when you change the kernel_size value \n",
        "\n",
        "# Pass the random tensor through the max pool layer\n",
        "max_pool_tensor = max_pool_layer(random_tensor)\n",
        "print(f\"\\nMax pool tensor:\\n{max_pool_tensor} <- this is the maximum value from random_tensor\")\n",
        "print(f\"Max pool tensor shape: {max_pool_tensor.shape}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "002e586e-dcb3-40fe-a7dd-a1c18a3b8da0",
      "metadata": {
        "id": "002e586e-dcb3-40fe-a7dd-a1c18a3b8da0"
      },
      "source": [
        "Notice the final two dimensions between `random_tensor` and `max_pool_tensor`, they go from `[2, 2]` to `[1, 1]`.\n",
        "\n",
        "In essence, they get halved.\n",
        "\n",
        "And the change would be different for different values of `kernel_size` for `nn.MaxPool2d()`.\n",
        "\n",
        "Also notice the value leftover in `max_pool_tensor` is the **maximum** value from `random_tensor`.\n",
        "\n",
        "What's happening here?\n",
        "\n",
        "This is another important piece of the puzzle of neural networks.\n",
        "\n",
        "Essentially, **every layer in a neural network is trying to compress data from higher dimensional space to lower dimensional space**. \n",
        "\n",
        "In other words, take a lot of numbers (raw data) and learn patterns in those numbers, patterns that are predictive whilst also being *smaller* in size than the original values.\n",
        "\n",
        "From an artificial intelligence perspective, you could consider the whole goal of a neural network to *compress* information.\n",
        "\n",
        "![each layer of a neural network compresses the original input data into a smaller representation that is (hopefully) capable of making predictions on future input data](https://raw.githubusercontent.com/mrdbourke/pytorch-deep-learning/main/images/03-conv-net-as-compression.png)\n",
        "\n",
        "This means, that from the point of view of a neural network, intelligence is compression.\n",
        "\n",
        "This is the idea of the use of a `nn.MaxPool2d()` layer: take the maximum value from a portion of a tensor and disregard the rest.\n",
        "\n",
        "In essence, lowering the dimensionality of a tensor whilst still retaining a (hopefully) significant portion of the information.\n",
        "\n",
        "It is the same story for a `nn.Conv2d()` layer.\n",
        "\n",
        "Except instead of just taking the maximum, the `nn.Conv2d()` performs a convolutional operation on the data (see this in action on the [CNN Explainer webpage](https://poloclub.github.io/cnn-explainer/)).\n",
        "\n",
        "> **Exercise:** What do you think the [`nn.AvgPool2d()`](https://pytorch.org/docs/stable/generated/torch.nn.AvgPool2d.html) layer does? Try making a random tensor like we did above and passing it through. Check the input and output shapes as well as the input and output values.\n",
        "\n",
        "> **Extra-curriculum:** Lookup \"most common convolutional neural networks\", what architectures do you find? Are any of them contained within the [`torchvision.models`](https://pytorch.org/vision/stable/models.html) library? What do you think you could do with these?"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "39a3c646-52f0-4f4b-8527-2fc33d0dfb13",
      "metadata": {
        "id": "39a3c646-52f0-4f4b-8527-2fc33d0dfb13"
      },
      "source": [
        "### 7.3 Setup a loss function and optimizer for `model_2`\n",
        "\n",
        "We've stepped through the layers in our first CNN enough.\n",
        "\n",
        "But remember, if something still isn't clear, try starting small.\n",
        "\n",
        "Pick a single layer of a model, pass some data through it and see what happens.\n",
        "\n",
        "Now it's time to move forward and get to training!\n",
        "\n",
        "Let's setup a loss function and an optimizer.\n",
        "\n",
        "We'll use the functions as before, `nn.CrossEntropyLoss()` as the loss function (since we're working with multi-class classification data).\n",
        "\n",
        "And `torch.optim.SGD()` as the optimizer to optimize `model_2.parameters()` with a learning rate of `0.1`."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup loss and optimizer\n",
        "loss_fn = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.SGD(params = model_2.parameters(),\n",
        "                            lr = 0.1)"
      ],
      "metadata": {
        "id": "tkDzYeD4LETo"
      },
      "id": "tkDzYeD4LETo",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "758bc223-a244-4604-a07a-e2fc2f96c2f6",
      "metadata": {
        "id": "758bc223-a244-4604-a07a-e2fc2f96c2f6"
      },
      "source": [
        "### 7.4 Training and testing `model_2` using our training and test functions\n",
        "\n",
        "Loss and optimizer ready!\n",
        "\n",
        "Time to train and test.\n",
        "\n",
        "We'll use our `train_step()` and `test_step()` functions we created before.\n",
        "\n",
        "We'll also measure the time to compare it to our other models."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "861d126e-d876-40b3-9b7a-66cfc2f1bf05",
      "metadata": {
        "id": "861d126e-d876-40b3-9b7a-66cfc2f1bf05",
        "outputId": "ef5cfc6b-b1b6-4f8d-e83e-82596f8b560a",
        "colab": {
          "referenced_widgets": [
            "e93238a5ee664ab8b48b514bc04398da",
            "de459fb05e4c49ebaf891faca70baf5a",
            "1bad74ad8efc41e6bc992f6da213e0e7",
            "e95b237a50894808ade9140e46b48b65",
            "36df2624afac42b599910c887f11273f",
            "9ebdc8a1e1794afc8551d0be016bdee8",
            "124f726e963f431ea101765773a2ff3f",
            "7e5a10811df64fabbeb9963603698bb8",
            "f807c3b917dc4f5986c7f68f0c10a6dd",
            "f9a435411e8d47eab00a96db2ad9a7d0",
            "80634df59618471380a8fb6ae6986b55"
          ],
          "base_uri": "https://localhost:8080/",
          "height": 327
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/3 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "e93238a5ee664ab8b48b514bc04398da"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0\n",
            "---------\n",
            "Train loss: 0.59499 | Train Accuracy: 78.45%\n",
            "Test loss: 0.39467 | Test accuracy: 85.84%\n",
            "\n",
            "Epoch: 1\n",
            "---------\n",
            "Train loss: 0.35917 | Train Accuracy: 87.10%\n",
            "Test loss: 0.35755 | Test accuracy: 86.56%\n",
            "\n",
            "Epoch: 2\n",
            "---------\n",
            "Train loss: 0.32329 | Train Accuracy: 88.27%\n",
            "Test loss: 0.34102 | Test accuracy: 87.81%\n",
            "\n",
            "Train time on cuda : 40.901 seconds\n"
          ]
        }
      ],
      "source": [
        "torch.manual_seed(42)\n",
        "\n",
        "# Measure time\n",
        "from timeit import default_timer as timer\n",
        "train_time_start_model_2 = timer()\n",
        "\n",
        "# Train and test model \n",
        "epochs = 3\n",
        "for epoch in tqdm(range(epochs)):\n",
        "    print(f\"Epoch: {epoch}\\n---------\")\n",
        "    train_step(data_loader=train_dataloader, \n",
        "        model=model_2, \n",
        "        loss_fn=loss_fn,\n",
        "        optimizer=optimizer,\n",
        "        accuracy_fn=accuracy_fn,\n",
        "        device=device\n",
        "    )\n",
        "    test_step(data_loader=test_dataloader,\n",
        "        model=model_2,\n",
        "        loss_fn=loss_fn,\n",
        "        accuracy_fn=accuracy_fn,\n",
        "        device=device\n",
        "    )\n",
        "\n",
        "train_time_end_model_2 = timer()\n",
        "total_train_time_model_2 = print_train_time(start=train_time_start_model_2,\n",
        "                                           end=train_time_end_model_2,\n",
        "                                           device=device)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cfec7b7e-4dba-4016-957a-a29c6c10fde0",
      "metadata": {
        "id": "cfec7b7e-4dba-4016-957a-a29c6c10fde0"
      },
      "source": [
        "Woah! Looks like the convolutional and max pooling layers helped improve performance a little.\n",
        "\n",
        "Let's evaluate `model_2`'s results with our `eval_model()` function."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c1bf8b89-1389-4395-a1c4-9c6e94d9e71c",
      "metadata": {
        "id": "c1bf8b89-1389-4395-a1c4-9c6e94d9e71c",
        "outputId": "7d848d9c-4275-45fd-af96-e64f0cd54657",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'model_name': 'FashionMNISTModelV2',\n",
              " 'model_loss': 0.341015487909317,\n",
              " 'model_acc': 87.80950479233226}"
            ]
          },
          "metadata": {},
          "execution_count": 96
        }
      ],
      "source": [
        "# Get model_2 results \n",
        "model_2_results = eval_model(\n",
        "    model=model_2,\n",
        "    data_loader=test_dataloader,\n",
        "    loss_fn=loss_fn,\n",
        "    accuracy_fn=accuracy_fn\n",
        ")\n",
        "model_2_results"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "24c5ff68-b0bc-4b09-9da6-696736bc262d",
      "metadata": {
        "id": "24c5ff68-b0bc-4b09-9da6-696736bc262d"
      },
      "source": [
        "## 8. Compare model results and training time\n",
        "\n",
        "We've trained three different models.\n",
        "\n",
        "1. `model_0` - our baseline model with two `nn.Linear()` layers.\n",
        "2. `model_1` - the same setup as our baseline model except with `nn.ReLU()` layers in between the `nn.Linear()` layers.\n",
        "3. `model_2` - our first CNN model that mimics the TinyVGG architecture on the CNN Explainer website.\n",
        "\n",
        "This is a regular practice in machine learning.\n",
        "\n",
        "Building multiple models and performing multiple training experiments to see which performs best.\n",
        "\n",
        "Let's combine our model results dictionaries into a DataFrame and find out."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "52d84ee1-1ad4-4860-b147-f8912c1febc7",
      "metadata": {
        "id": "52d84ee1-1ad4-4860-b147-f8912c1febc7",
        "outputId": "9e751f6f-8ed0-4ae5-db4e-504a6997b857",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 143
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "            model_name  model_loss  model_acc\n",
              "0  FashionMNISTModelV0    0.476639  83.426518\n",
              "1  FashionMNISTModelV1    0.647041  76.617412\n",
              "2  FashionMNISTModelV2    0.341015  87.809505"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-e71f4792-ac0c-49ee-9113-7e0b77e616a2\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>model_name</th>\n",
              "      <th>model_loss</th>\n",
              "      <th>model_acc</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>FashionMNISTModelV0</td>\n",
              "      <td>0.476639</td>\n",
              "      <td>83.426518</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>FashionMNISTModelV1</td>\n",
              "      <td>0.647041</td>\n",
              "      <td>76.617412</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>FashionMNISTModelV2</td>\n",
              "      <td>0.341015</td>\n",
              "      <td>87.809505</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-e71f4792-ac0c-49ee-9113-7e0b77e616a2')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-e71f4792-ac0c-49ee-9113-7e0b77e616a2 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-e71f4792-ac0c-49ee-9113-7e0b77e616a2');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 97
        }
      ],
      "source": [
        "import pandas as pd\n",
        "compare_results = pd.DataFrame([model_0_results, model_1_results, model_2_results])\n",
        "compare_results"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c67f3fb5-ce7b-40b8-86a0-2797492de0ef",
      "metadata": {
        "id": "c67f3fb5-ce7b-40b8-86a0-2797492de0ef"
      },
      "source": [
        "Nice!\n",
        "\n",
        "We can add the training time values too."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "297af38f-e69f-4c6f-9027-fcaf0482a55c",
      "metadata": {
        "id": "297af38f-e69f-4c6f-9027-fcaf0482a55c",
        "outputId": "e50a462e-fc1c-45a5-cd68-d2f6a33893bd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 143
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "            model_name  model_loss  model_acc  training_time\n",
              "0  FashionMNISTModelV0    0.476639  83.426518      29.967468\n",
              "1  FashionMNISTModelV1    0.647041  76.617412      33.038567\n",
              "2  FashionMNISTModelV2    0.341015  87.809505      40.901028"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-1a588ef9-1151-40ab-a36a-d90d008f2605\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>model_name</th>\n",
              "      <th>model_loss</th>\n",
              "      <th>model_acc</th>\n",
              "      <th>training_time</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>FashionMNISTModelV0</td>\n",
              "      <td>0.476639</td>\n",
              "      <td>83.426518</td>\n",
              "      <td>29.967468</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>FashionMNISTModelV1</td>\n",
              "      <td>0.647041</td>\n",
              "      <td>76.617412</td>\n",
              "      <td>33.038567</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>FashionMNISTModelV2</td>\n",
              "      <td>0.341015</td>\n",
              "      <td>87.809505</td>\n",
              "      <td>40.901028</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-1a588ef9-1151-40ab-a36a-d90d008f2605')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-1a588ef9-1151-40ab-a36a-d90d008f2605 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-1a588ef9-1151-40ab-a36a-d90d008f2605');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 98
        }
      ],
      "source": [
        "# Add training times to results comparison\n",
        "compare_results[\"training_time\"] = [total_train_time_model_0,\n",
        "                                    total_train_time_model_1,\n",
        "                                    total_train_time_model_2]\n",
        "compare_results"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "fbbe5832-1081-4c76-8d5b-06c7a06da7b9",
      "metadata": {
        "id": "fbbe5832-1081-4c76-8d5b-06c7a06da7b9"
      },
      "source": [
        "It looks like our CNN (`FashionMNISTModelV2`) model performed the best (lowest loss, highest accuracy) but had the longest training time.\n",
        "\n",
        "And our baseline model (`FashionMNISTModelV0`) performed better than `model_1` (`FashionMNISTModelV1`).\n",
        "\n",
        "### Performance-speed tradeoff\n",
        "\n",
        "Something to be aware of in machine learning is the **performance-speed** tradeoff.\n",
        "\n",
        "Generally, you get better performance out of a larger, more complex model (like we did with `model_2`).\n",
        "\n",
        "However, this performance increase often comes at a sacrifice of training speed and inference speed.\n",
        "\n",
        "> **Note:** The training times you get will be very dependant on the hardware you use. \n",
        ">\n",
        "> Generally, the more CPU cores you have, the faster your models will train on CPU. And similar for GPUs.\n",
        "> \n",
        "> Newer hardware (in terms of age) will also often train models faster due to incorporating technology advances.\n",
        "\n",
        "How about we get visual?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5eb0df60-9318-47d0-adce-f8788ed3999e",
      "metadata": {
        "id": "5eb0df60-9318-47d0-adce-f8788ed3999e",
        "outputId": "a7b78980-4165-45ae-f208-f2f471c65780",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Visualize our model results\n",
        "compare_results.set_index(\"model_name\")[\"model_acc\"].plot(kind=\"barh\")\n",
        "plt.xlabel(\"accuracy (%)\")\n",
        "plt.ylabel(\"model\");"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0ba50d51-adb3-4e49-9b9a-85173e747352",
      "metadata": {
        "id": "0ba50d51-adb3-4e49-9b9a-85173e747352"
      },
      "source": [
        "## 9. Make and evaluate random predictions with best model\n",
        "\n",
        "Alright, we've compared our models to each other, let's further evaluate our best performing model, `model_2`.\n",
        "\n",
        "To do so, let's create a function `make_predictions()` where we can pass the model and some data for it to predict on."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d1d5d3e7-9601-4141-8bd7-9abbd016bf6c",
      "metadata": {
        "id": "d1d5d3e7-9601-4141-8bd7-9abbd016bf6c"
      },
      "outputs": [],
      "source": [
        "def make_predictions(model: torch.nn.Module, data: list, device: torch.device = device):\n",
        "    pred_probs = []\n",
        "    model.eval()\n",
        "    with torch.inference_mode():\n",
        "        for sample in data:\n",
        "            # Prepare sample\n",
        "            sample = torch.unsqueeze(sample, dim=0).to(device) # Add an extra dimension and send sample to device\n",
        "\n",
        "            # Forward pass (model outputs raw logit)\n",
        "            pred_logit = model(sample)\n",
        "\n",
        "            # Get prediction probability (logit -> prediction probability)\n",
        "            pred_prob = torch.softmax(pred_logit.squeeze(), dim=0)\n",
        "\n",
        "            # Get pred_prob off GPU for further calculations\n",
        "            pred_probs.append(pred_prob.cpu())\n",
        "            \n",
        "    # Stack the pred_probs to turn list into a tensor\n",
        "    return torch.stack(pred_probs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "420c7461-eaa9-4459-9e68-53574c758765",
      "metadata": {
        "id": "420c7461-eaa9-4459-9e68-53574c758765",
        "outputId": "732f5ba9-69f7-4253-a17a-382b1a1e59b4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test sample image shape: torch.Size([1, 28, 28])\n",
            "Test sample label: 5 (Sandal)\n"
          ]
        }
      ],
      "source": [
        "import random\n",
        "random.seed(42)\n",
        "test_samples = []\n",
        "test_labels = []\n",
        "for sample, label in random.sample(list(test_data), k=9):\n",
        "    test_samples.append(sample)\n",
        "    test_labels.append(label)\n",
        "\n",
        "# View the first test sample shape and label\n",
        "print(f\"Test sample image shape: {test_samples[0].shape}\\nTest sample label: {test_labels[0]} ({class_names[test_labels[0]]})\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e9f40dd9-7987-42a9-84cc-65dc912a6345",
      "metadata": {
        "id": "e9f40dd9-7987-42a9-84cc-65dc912a6345"
      },
      "source": [
        "And now we can use our `make_predictions()` function to predict on `test_samples`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "79de2ac1-7d4b-4f81-ae8a-90099bca2a3d",
      "metadata": {
        "id": "79de2ac1-7d4b-4f81-ae8a-90099bca2a3d",
        "outputId": "c6050fbb-9d8b-4045-c3a1-fa0222e906fd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[3.0063e-06, 9.5719e-07, 2.9404e-06, 6.5358e-06, 5.7589e-07, 9.9671e-01,\n",
              "         1.1007e-05, 2.6250e-04, 1.9558e-04, 2.8053e-03],\n",
              "        [1.0755e-01, 4.4569e-01, 5.8107e-03, 2.1467e-01, 9.7188e-02, 2.2930e-03,\n",
              "         1.2251e-01, 1.9176e-03, 3.4325e-04, 2.0411e-03]])"
            ]
          },
          "metadata": {},
          "execution_count": 102
        }
      ],
      "source": [
        "# Make predictions on test samples with model 2\n",
        "pred_probs= make_predictions(model=model_2, \n",
        "                             data=test_samples)\n",
        "\n",
        "# View first two prediction probabilities list\n",
        "pred_probs[:2]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "22d3c080-4eb6-4b5d-a5c4-2319e78228af",
      "metadata": {
        "id": "22d3c080-4eb6-4b5d-a5c4-2319e78228af"
      },
      "source": [
        "Excellent!\n",
        "\n",
        "And now we can go from prediction probabilities to prediction labels by taking the `torch.argmax()` of the output of the `torch.softmax()` activation function."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f9d97bcc-4310-4851-a1f8-6bcd757e9b26",
      "metadata": {
        "id": "f9d97bcc-4310-4851-a1f8-6bcd757e9b26",
        "outputId": "80b01d54-4d23-4fd7-dc35-ff175ec42c0f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([5, 1, 7, 4, 3, 0, 4, 7, 1])"
            ]
          },
          "metadata": {},
          "execution_count": 103
        }
      ],
      "source": [
        "# Turn the prediction probabilities into prediction labels by taking the argmax()\n",
        "pred_classes = pred_probs.argmax(dim=1)\n",
        "pred_classes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1141af97-0990-4920-83d4-c13cca3f9abc",
      "metadata": {
        "id": "1141af97-0990-4920-83d4-c13cca3f9abc",
        "outputId": "afa3cb21-d2dc-4028-bcb4-60bc1c38adfb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "([5, 1, 7, 4, 3, 0, 4, 7, 1], tensor([5, 1, 7, 4, 3, 0, 4, 7, 1]))"
            ]
          },
          "metadata": {},
          "execution_count": 104
        }
      ],
      "source": [
        "# Are our predictions in the same form as our test labels? \n",
        "test_labels, pred_classes"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4ea04387-c9ad-424f-8297-defd7b685683",
      "metadata": {
        "id": "4ea04387-c9ad-424f-8297-defd7b685683"
      },
      "source": [
        "Now our predicted classes are in the same format as our test labels, we can compare.\n",
        "\n",
        "Since we're dealing with image data, let's stay true to the data explorer's motto. \n",
        "\n",
        "\"Visualize, visualize, visualize!\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "679cb5f7-bb66-42dd-a4d6-400b27b7c019",
      "metadata": {
        "id": "679cb5f7-bb66-42dd-a4d6-400b27b7c019",
        "outputId": "84906a96-1420-49fd-b9bb-dc65daf21696",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 534
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 648x648 with 9 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Plot predictions\n",
        "plt.figure(figsize=(9, 9))\n",
        "nrows = 3\n",
        "ncols = 3\n",
        "for i, sample in enumerate(test_samples):\n",
        "  # Create a subplot\n",
        "  plt.subplot(nrows, ncols, i+1)\n",
        "\n",
        "  # Plot the target image\n",
        "  plt.imshow(sample.squeeze(), cmap=\"gray\")\n",
        "\n",
        "  # Find the prediction label (in text form, e.g. \"Sandal\")\n",
        "  pred_label = class_names[pred_classes[i]]\n",
        "\n",
        "  # Get the truth label (in text form, e.g. \"T-shirt\")\n",
        "  truth_label = class_names[test_labels[i]] \n",
        "\n",
        "  # Create the title text of the plot\n",
        "  title_text = f\"Pred: {pred_label} | Truth: {truth_label}\"\n",
        "  \n",
        "  # Check for equality and change title colour accordingly\n",
        "  if pred_label == truth_label:\n",
        "      plt.title(title_text, fontsize=10, c=\"g\") # green text if correct\n",
        "  else:\n",
        "      plt.title(title_text, fontsize=10, c=\"r\") # red text if wrong\n",
        "  plt.axis(False);"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5ce6dc44-90a5-48c3-91a5-810fa084d98b",
      "metadata": {
        "id": "5ce6dc44-90a5-48c3-91a5-810fa084d98b"
      },
      "source": [
        "Well, well, well, doesn't that look good!\n",
        "\n",
        "Not bad for a couple dozen lines of PyTorch code!"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ab108078-6770-4cb9-ac62-a761ff159aba",
      "metadata": {
        "id": "ab108078-6770-4cb9-ac62-a761ff159aba"
      },
      "source": [
        "## 10. Making a confusion matrix for further prediction evaluation\n",
        "\n",
        "There are many [different evaluation metrics](https://www.learnpytorch.io/02_pytorch_classification/#9-more-classification-evaluation-metrics) we can use for classification problems. \n",
        "\n",
        "One of the most visual is a [confusion matrix](https://www.dataschool.io/simple-guide-to-confusion-matrix-terminology/).\n",
        "\n",
        "A confusion matrix shows you where your classification model got confused between predicitons and true labels.\n",
        "\n",
        "To make a confusion matrix, we'll go through three steps:\n",
        "1. Make predictions with our trained model, `model_2` (a confusion matrix compares predictions to true labels).\n",
        "2. Make a confusion matrix using [`torch.ConfusionMatrix`](https://torchmetrics.readthedocs.io/en/latest/references/modules.html?highlight=confusion#confusionmatrix).\n",
        "3. Plot the confusion matrix using [`mlxtend.plotting.plot_confusion_matrix()`](http://rasbt.github.io/mlxtend/user_guide/plotting/plot_confusion_matrix/).\n",
        "\n",
        "Let's start by making predictions with our trained model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "065b8090-c9c5-43df-b5c1-b45ba33af1be",
      "metadata": {
        "id": "065b8090-c9c5-43df-b5c1-b45ba33af1be",
        "outputId": "d98bf26d-b441-465f-daa2-0707156658a5",
        "colab": {
          "referenced_widgets": [
            "6a295779d604480e8c8fcc8ec9774384",
            "2ff401439f674c6bb8ba08bc60ee45f1",
            "2846f220ca2c4d50b90c73142da1a204",
            "2aa9d45430e542558b70fae7dcebbe1b",
            "a430407f834547a6989584720bec2b81",
            "af4cc41ef464496eb966567b52333ecf",
            "457e2289837b41f38a9e43b34ceaab3c",
            "94ffad8199d346dda5268295bbaaa0c8",
            "6b549dd0db7141e59582bb45c3b44eaa",
            "b084201b8bde4bd9a5f72146123e5805",
            "da5afadf535840538364278e35bfc1f5"
          ],
          "base_uri": "https://localhost:8080/",
          "height": 49
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Making predictions:   0%|          | 0/313 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "6a295779d604480e8c8fcc8ec9774384"
            }
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Import tqdm for progress bar\n",
        "from tqdm.auto import tqdm\n",
        "\n",
        "# 1. Make predictions with trained model\n",
        "y_preds = []\n",
        "model_2.eval()\n",
        "with torch.inference_mode():\n",
        "  for X, y in tqdm(test_dataloader, desc=\"Making predictions\"):\n",
        "    # Send data and targets to target device\n",
        "    X, y = X.to(device), y.to(device)\n",
        "    # Do the forward pass\n",
        "    y_logit = model_2(X)\n",
        "    # Turn predictions from logits -> prediction probabilities -> predictions labels\n",
        "    y_pred = torch.softmax(y_logit, dim=1).argmax(dim=1)\n",
        "    # Put predictions on CPU for evaluation\n",
        "    y_preds.append(y_pred.cpu())\n",
        "# Concatenate list of predictions into a tensor\n",
        "y_pred_tensor = torch.cat(y_preds)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "362002d9-ec41-4c74-a210-b5d4f53410c4",
      "metadata": {
        "id": "362002d9-ec41-4c74-a210-b5d4f53410c4"
      },
      "source": [
        "Wonderful!\n",
        "\n",
        "Now we've got predictions, let's go through steps 2 & 3:\n",
        "2. Make a confusion matrix using [`torchmetrics.ConfusionMatrix`](https://torchmetrics.readthedocs.io/en/latest/references/modules.html?highlight=confusion#confusionmatrix).\n",
        "3. Plot the confusion matrix using [`mlxtend.plotting.plot_confusion_matrix()`](http://rasbt.github.io/mlxtend/user_guide/plotting/plot_confusion_matrix/).\n",
        "\n",
        "First we'll need to make sure we've got `torchmetrics` and `mlxtend` installed (these two libraries will help us make and visual a confusion matrix).\n",
        "\n",
        "> **Note:** If you're using Google Colab, the default version of `mlxtend` installed is 0.14.0 (as of March 2022), however, for the parameters of the `plot_confusion_matrix()` function we'd like use, we need 0.19.0 or higher. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e6c0a05d-d3e0-4b86-9ef7-ee6ea5629b07",
      "metadata": {
        "id": "e6c0a05d-d3e0-4b86-9ef7-ee6ea5629b07",
        "outputId": "c35911c6-fb8a-4ae4-d00a-1e52b222e5c6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m519.2/519.2 KB\u001b[0m \u001b[31m24.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m62.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hmlxtend version: 0.21.0\n"
          ]
        }
      ],
      "source": [
        "# See if torchmetrics exists, if not, install it\n",
        "try:\n",
        "    import torchmetrics, mlxtend\n",
        "    print(f\"mlxtend version: {mlxtend.__version__}\")\n",
        "    assert int(mlxtend.__version__.split(\".\")[1]) >= 19, \"mlxtend verison should be 0.19.0 or higher\"\n",
        "except:\n",
        "    !pip install -q torchmetrics -U mlxtend # <- Note: If you're using Google Colab, this may require restarting the runtime\n",
        "    import torchmetrics, mlxtend\n",
        "    print(f\"mlxtend version: {mlxtend.__version__}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5245ede6-fd7f-40ad-a0b3-ae678544b84a",
      "metadata": {
        "id": "5245ede6-fd7f-40ad-a0b3-ae678544b84a"
      },
      "source": [
        "To plot the confusion matrix, we need to make sure we've got and [`mlxtend`](http://rasbt.github.io/mlxtend/) version of 0.19.0 or higher."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "21383f88-a2dd-4678-94c6-479c592da0ab",
      "metadata": {
        "id": "21383f88-a2dd-4678-94c6-479c592da0ab",
        "outputId": "70dc5433-f852-4157-86f6-3ad32ad1a767",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.21.0\n"
          ]
        }
      ],
      "source": [
        "# Import mlxtend upgraded version\n",
        "import mlxtend \n",
        "print(mlxtend.__version__)\n",
        "assert int(mlxtend.__version__.split(\".\")[1]) >= 19 # should be version 0.19.0 or higher"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c91b9346-e25f-48ab-967e-425649331dc6",
      "metadata": {
        "id": "c91b9346-e25f-48ab-967e-425649331dc6"
      },
      "source": [
        "`torchmetrics` and `mlxtend` installed, let's make a confusion matrix!\n",
        "\n",
        "First we'll create a `torchmetrics.ConfusionMatrix` instance telling it how many classes we're dealing with by setting `num_classes=len(class_names)`.\n",
        "\n",
        "Then we'll create a confusion matrix (in tensor format) by passing our instance our model's predictions (`preds=y_pred_tensor`) and targets (`target=test_data.targets`).\n",
        "\n",
        "Finally we can plot our confision matrix using the `plot_confusion_matrix()` function from `mlxtend.plotting`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7aed6d76-ad1c-429e-b8e0-c80572e3ebf4",
      "metadata": {
        "id": "7aed6d76-ad1c-429e-b8e0-c80572e3ebf4",
        "outputId": "36b1ea14-29f1-4be6-bf05-c2706da5982f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 477
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "from torchmetrics import ConfusionMatrix\n",
        "from mlxtend.plotting import plot_confusion_matrix\n",
        "\n",
        "# 2. Setup confusion matrix instance and compare predictions to targets\n",
        "confmat = ConfusionMatrix(num_classes=len(class_names), task='multiclass')\n",
        "confmat_tensor = confmat(preds=y_pred_tensor,\n",
        "                         target=test_data.targets)\n",
        "\n",
        "# 3. Plot the confusion matrix\n",
        "fig, ax = plot_confusion_matrix(\n",
        "    conf_mat=confmat_tensor.numpy(), # matplotlib likes working with NumPy \n",
        "    class_names=class_names, # turn the row and column labels into class names\n",
        "    figsize=(10, 7)\n",
        ");"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "381c1c93-df30-451c-b65e-5d4c1680dc30",
      "metadata": {
        "id": "381c1c93-df30-451c-b65e-5d4c1680dc30"
      },
      "source": [
        "Woah! Doesn't that look good?\n",
        "\n",
        "We can see our model does fairly well since most of the dark squares are down the diagonal from top left to bottom right (and ideal model will have only values in these squares and 0 everywhere else).\n",
        "\n",
        "The model gets most \"confused\" on classes that are similar, for example predicting \"Pullover\" for images that are actually labelled \"Shirt\".\n",
        "\n",
        "And the same for predicting \"Shirt\" for classes that are actually labelled \"T-shirt/top\".\n",
        "\n",
        "This kind of information is often more helpful than a single accuracy metric because it tells use *where* a model is getting things wrong.\n",
        "\n",
        "It also hints at *why* the model may be getting certain things wrong.\n",
        "\n",
        "It's understandable the model sometimes predicts \"Shirt\" for images labelled \"T-shirt/top\".\n",
        "\n",
        "We can use this kind of information to further inspect our models and data to see how it could be improved.\n",
        "\n",
        "> **Exercise:** Use the trained `model_2` to make predictions on the test FashionMNIST dataset. Then plot some predictions where the model was wrong alongside what the label of the image should've been. After visualing these predictions do you think it's more of a modelling error or a data error? As in, could the model do better or are the labels of the data too close to each other (e.g. a \"Shirt\" label is too close to \"T-shirt/top\")?"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "25818e83-89de-496d-8b56-af4fc9f2acc5",
      "metadata": {
        "id": "25818e83-89de-496d-8b56-af4fc9f2acc5"
      },
      "source": [
        "## 11. Save and load best performing model\n",
        "\n",
        "Let's finish this section off by saving and loading in our best performing model.\n",
        "\n",
        "Recall from [notebook 01](https://www.learnpytorch.io/01_pytorch_workflow/#5-saving-and-loading-a-pytorch-model) we can save and load a PyTorch model using a combination of:\n",
        "* `torch.save` - a function to save a whole PyTorch model or a model's `state_dict()`. \n",
        "* `torch.load` - a function to load in a saved PyTorch object.\n",
        "* `torch.nn.Module.load_state_dict()` - a function to load a saved `state_dict()` into an existing model instance.\n",
        "\n",
        "You can see more of these three in the [PyTorch saving and loading models documentation](https://pytorch.org/tutorials/beginner/saving_loading_models.html).\n",
        "\n",
        "For now, let's save our `model_2`'s `state_dict()` then load it back in and evaluate it to make sure the save and load went correctly. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d058e8fa-560f-4350-a154-49593ff403c9",
      "metadata": {
        "id": "d058e8fa-560f-4350-a154-49593ff403c9",
        "outputId": "1458fe8b-6e85-4b12-d1ff-ca44fc74fd7f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving model to: models/03_pytorch_computer_vision_model_2.pth\n"
          ]
        }
      ],
      "source": [
        "from pathlib import Path\n",
        "\n",
        "# Create models directory (if it doesn't already exist), see: https://docs.python.org/3/library/pathlib.html#pathlib.Path.mkdir\n",
        "MODEL_PATH = Path(\"models\")\n",
        "MODEL_PATH.mkdir(parents=True, # create parent directories if needed\n",
        "                 exist_ok=True # if models directory already exists, don't error\n",
        ")\n",
        "\n",
        "# Create model save path\n",
        "MODEL_NAME = \"03_pytorch_computer_vision_model_2.pth\"\n",
        "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n",
        "\n",
        "# Save the model state dict\n",
        "print(f\"Saving model to: {MODEL_SAVE_PATH}\")\n",
        "torch.save(obj=model_2.state_dict(), # only saving the state_dict() only saves the learned parameters\n",
        "           f=MODEL_SAVE_PATH)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a1542284-8132-42ba-b00d-57e9b9037e4e",
      "metadata": {
        "id": "a1542284-8132-42ba-b00d-57e9b9037e4e"
      },
      "source": [
        "Now we've got a saved model `state_dict()` we can load it back in using a combination of `load_state_dict()` and `torch.load()`.\n",
        "\n",
        "Since we're using `load_state_dict()`, we'll need to create a new instance of `FashionMNISTModelV2()` with the same input parameters as our saved model `state_dict()`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "634a8f7a-3013-4b45-b365-49b286d3c478",
      "metadata": {
        "id": "634a8f7a-3013-4b45-b365-49b286d3c478"
      },
      "outputs": [],
      "source": [
        "# Create a new instance of FashionMNISTModelV2 (the same class as our saved state_dict())\n",
        "# Note: loading model will error if the shapes here aren't the same as the saved version\n",
        "loaded_model_2 = FashionMNISTModelV2(input_shape=1, \n",
        "                                    hidden_units=10, # try changing this to 128 and seeing what happens \n",
        "                                    output_shape=10) \n",
        "\n",
        "# Load in the saved state_dict()\n",
        "loaded_model_2.load_state_dict(torch.load(f=MODEL_SAVE_PATH))\n",
        "\n",
        "# Send model to GPU\n",
        "loaded_model_2 = loaded_model_2.to(device)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "feeaebf4-6040-4fa5-852d-5eb8d2bbb94c",
      "metadata": {
        "id": "feeaebf4-6040-4fa5-852d-5eb8d2bbb94c"
      },
      "source": [
        "And now we've got a loaded model we can evaluate it with `eval_model()` to make sure its parameters work similarly to `model_2` prior to saving. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3e3bcd06-d99b-47bc-8828-9e3903285599",
      "metadata": {
        "id": "3e3bcd06-d99b-47bc-8828-9e3903285599",
        "outputId": "840587c7-5ce1-48e6-ed0e-9ad127f2931e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'model_name': 'FashionMNISTModelV2',\n",
              " 'model_loss': 0.341015487909317,\n",
              " 'model_acc': 87.80950479233226}"
            ]
          },
          "metadata": {},
          "execution_count": 112
        }
      ],
      "source": [
        "# Evaluate loaded model\n",
        "torch.manual_seed(42)\n",
        "\n",
        "loaded_model_2_results = eval_model(\n",
        "    model=loaded_model_2,\n",
        "    data_loader=test_dataloader,\n",
        "    loss_fn=loss_fn, \n",
        "    accuracy_fn=accuracy_fn\n",
        ")\n",
        "\n",
        "loaded_model_2_results"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c2b37855-c0da-4834-a2d4-a0faa8410b65",
      "metadata": {
        "id": "c2b37855-c0da-4834-a2d4-a0faa8410b65"
      },
      "source": [
        "Do these results look the same as `model_2_results`?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "68544254-c99a-47ec-a32f-9816c21a993e",
      "metadata": {
        "id": "68544254-c99a-47ec-a32f-9816c21a993e",
        "outputId": "0a67fd2d-915e-4f10-bbb6-8ca6671571a4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'model_name': 'FashionMNISTModelV2',\n",
              " 'model_loss': 0.341015487909317,\n",
              " 'model_acc': 87.80950479233226}"
            ]
          },
          "metadata": {},
          "execution_count": 113
        }
      ],
      "source": [
        "model_2_results"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0ee07f93-4344-4c7a-8b1d-92a56034e7b2",
      "metadata": {
        "id": "0ee07f93-4344-4c7a-8b1d-92a56034e7b2"
      },
      "source": [
        "We can find out if two tensors are close to each other using `torch.isclose()` and passing in a tolerance level of closeness via the parameters `atol` (absolute tolerance) and `rtol` (relative tolerance).\n",
        "\n",
        "If our model's results are close, the output of `torch.isclose()` should be true."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "48dcf0ba-7e00-4406-8aaa-41918856361a",
      "metadata": {
        "id": "48dcf0ba-7e00-4406-8aaa-41918856361a",
        "outputId": "7fcca70c-0487-4f58-8d81-79e93f32cd0c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(True)"
            ]
          },
          "metadata": {},
          "execution_count": 114
        }
      ],
      "source": [
        "# Check to see if results are close to each other (if they are very far away, there may be an error)\n",
        "torch.isclose(torch.tensor(model_2_results[\"model_loss\"]), \n",
        "              torch.tensor(loaded_model_2_results[\"model_loss\"]),\n",
        "              atol=1e-08, # absolute tolerance\n",
        "              rtol=0.0001) # relative tolerance"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c3969b7d-9955-4b6f-abf8-fe8eedf233a9",
      "metadata": {
        "id": "c3969b7d-9955-4b6f-abf8-fe8eedf233a9"
      },
      "source": [
        "## Exercises\n",
        "\n",
        "All of the exercises are focused on practicing the code in the sections above.\n",
        "\n",
        "You should be able to complete them by referencing each section or by following the resource(s) linked.\n",
        "\n",
        "All exercises should be completed using [device-agnostic code](https://pytorch.org/docs/stable/notes/cuda.html#device-agnostic-code).\n",
        "\n",
        "**Resources:**\n",
        "* [Exercise template notebook for 03](https://github.com/mrdbourke/pytorch-deep-learning/blob/main/extras/exercises/03_pytorch_computer_vision_exercises.ipynb)\n",
        "* [Example solutions notebook for 03](https://github.com/mrdbourke/pytorch-deep-learning/blob/main/extras/solutions/03_pytorch_computer_vision_exercise_solutions.ipynb) (try the exercises *before* looking at this)\n",
        "\n",
        "1. What are 3 areas in industry where computer vision is currently being used?\n",
        "2. Search \"what is overfitting in machine learning\" and write down a sentence about what you find. \n",
        "3. Search \"ways to prevent overfitting in machine learning\", write down 3 of the things you find and a sentence about each. **Note:** there are lots of these, so don't worry too much about all of them, just pick 3 and start with those.\n",
        "4. Spend 20-minutes reading and clicking through the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/).\n",
        "    * Upload your own example image using the \"upload\" button and see what happens in each layer of a CNN as your image passes through it.\n",
        "5. Load the [`torchvision.datasets.MNIST()`](https://pytorch.org/vision/stable/generated/torchvision.datasets.MNIST.html#torchvision.datasets.MNIST) train and test datasets.\n",
        "6. Visualize at least 5 different samples of the MNIST training dataset.\n",
        "7. Turn the MNIST train and test datasets into dataloaders using `torch.utils.data.DataLoader`, set the `batch_size=32`.\n",
        "8. Recreate `model_2` used in this notebook (the same model from the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/), also known as TinyVGG) capable of fitting on the MNIST dataset.\n",
        "9. Train the model you built in exercise 8. on CPU and GPU and see how long it takes on each.\n",
        "10. Make predictions using your trained model and visualize at least 5 of them comparing the prediciton to the target label.\n",
        "11. Plot a confusion matrix comparing your model's predictions to the truth labels.\n",
        "12. Create a random tensor of shape `[1, 3, 64, 64]` and pass it through a `nn.Conv2d()` layer with various hyperparameter settings (these can be any settings you choose), what do you notice if the `kernel_size` parameter goes up and down?\n",
        "13. Use a model similar to the trained `model_2` from this notebook to make predictions on the test [`torchvision.datasets.FashionMNIST`](https://pytorch.org/vision/main/generated/torchvision.datasets.FashionMNIST.html) dataset. \n",
        "    * Then plot some predictions where the model was wrong alongside what the label of the image should've been. \n",
        "    * After visualing these predictions do you think it's more of a modelling error or a data error? \n",
        "    * As in, could the model do better or are the labels of the data too close to each other (e.g. a \"Shirt\" label is too close to \"T-shirt/top\")?\n",
        "\n",
        "## Extra-curriculum\n",
        "* **Watch:** [MIT's Introduction to Deep Computer Vision](https://www.youtube.com/watch?v=iaSUYvmCekI&list=PLtBw6njQRU-rwp5__7C0oIVt26ZgjG9NI&index=3) lecture. This will give you a great intuition behind convolutional neural networks.\n",
        "* Spend 10-minutes clicking thorugh the different options of the [PyTorch vision library](https://pytorch.org/vision/stable/index.html), what different modules are available?\n",
        "* Lookup \"most common convolutional neural networks\", what architectures do you find? Are any of them contained within the [`torchvision.models`](https://pytorch.org/vision/stable/models.html) library? What do you think you could do with these?\n",
        "* For a large number of pretrained PyTorch computer vision models as well as many different extensions to PyTorch's computer vision functionalities check out the [PyTorch Image Models library `timm`](https://github.com/rwightman/pytorch-image-models/) (Torch Image Models) by Ross Wightman."
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3.8.13",
      "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.13"
    },
    "vscode": {
      "interpreter": {
        "hash": "3fbe1355223f7b2ffc113ba3ade6a2b520cadace5d5ec3e828c83ce02eb221bf"
      }
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "b4c7693e8efb4e7db7c5deb65e6793a4": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_267c6fb7bb2c4a1d96bbed36d3916a38",
              "IPY_MODEL_45ca5ce08efc492498072933d9662939",
              "IPY_MODEL_9453805c41cf4548b6e0e70522012299"
            ],
            "layout": "IPY_MODEL_a62b718a5eca4e46a720928a671d6fd8"
          }
        },
        "267c6fb7bb2c4a1d96bbed36d3916a38": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_1f4c714dc5b3450fbed8afd4e7f92780",
            "placeholder": "​",
            "style": "IPY_MODEL_44c6f1378c8a4b00bb5f56bf5eb33c75",
            "value": "100%"
          }
        },
        "45ca5ce08efc492498072933d9662939": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_5b211a8a1cee47328228ec63613094c0",
            "max": 3,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_45139436dcfb44bf90265b37d8500608",
            "value": 3
          }
        },
        "9453805c41cf4548b6e0e70522012299": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_67352f0133ad4dc3975373488d2a5b58",
            "placeholder": "​",
            "style": "IPY_MODEL_4f507816e91c4d02af4643813911c5b6",
            "value": " 3/3 [00:29&lt;00:00, 10.08s/it]"
          }
        },
        "a62b718a5eca4e46a720928a671d6fd8": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "1f4c714dc5b3450fbed8afd4e7f92780": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "44c6f1378c8a4b00bb5f56bf5eb33c75": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "5b211a8a1cee47328228ec63613094c0": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "45139436dcfb44bf90265b37d8500608": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "67352f0133ad4dc3975373488d2a5b58": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "4f507816e91c4d02af4643813911c5b6": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "c5ea9efeb1894b4fba02021d0bd49171": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_ce24dad2ae94464b90609ad5d3f5a97e",
              "IPY_MODEL_ddf45dbb0bf4402c8662b9cb509bc321",
              "IPY_MODEL_758bd27ac7414ababee46bf7c51f593a"
            ],
            "layout": "IPY_MODEL_e7a54e57735846f484b409a74af06208"
          }
        },
        "ce24dad2ae94464b90609ad5d3f5a97e": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_9d76675851a4441c93f841062ba6de84",
            "placeholder": "​",
            "style": "IPY_MODEL_9e6a1b18c7cf4608a529e77155c8fb7c",
            "value": "100%"
          }
        },
        "ddf45dbb0bf4402c8662b9cb509bc321": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_9cd996bb165546eda136a558f7fd5a31",
            "max": 3,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_77493f09f46e463f8e5ffe5741b902e9",
            "value": 3
          }
        },
        "758bd27ac7414ababee46bf7c51f593a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_4b19bce7bbd54bf9804d0aed4ea5db8d",
            "placeholder": "​",
            "style": "IPY_MODEL_10fa97b220ff44de86515de0f7092b4f",
            "value": " 3/3 [00:33&lt;00:00, 11.18s/it]"
          }
        },
        "e7a54e57735846f484b409a74af06208": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "9d76675851a4441c93f841062ba6de84": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "9e6a1b18c7cf4608a529e77155c8fb7c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "9cd996bb165546eda136a558f7fd5a31": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "77493f09f46e463f8e5ffe5741b902e9": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "4b19bce7bbd54bf9804d0aed4ea5db8d": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "10fa97b220ff44de86515de0f7092b4f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "e93238a5ee664ab8b48b514bc04398da": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_de459fb05e4c49ebaf891faca70baf5a",
              "IPY_MODEL_1bad74ad8efc41e6bc992f6da213e0e7",
              "IPY_MODEL_e95b237a50894808ade9140e46b48b65"
            ],
            "layout": "IPY_MODEL_36df2624afac42b599910c887f11273f"
          }
        },
        "de459fb05e4c49ebaf891faca70baf5a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_9ebdc8a1e1794afc8551d0be016bdee8",
            "placeholder": "​",
            "style": "IPY_MODEL_124f726e963f431ea101765773a2ff3f",
            "value": "100%"
          }
        },
        "1bad74ad8efc41e6bc992f6da213e0e7": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_7e5a10811df64fabbeb9963603698bb8",
            "max": 3,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_f807c3b917dc4f5986c7f68f0c10a6dd",
            "value": 3
          }
        },
        "e95b237a50894808ade9140e46b48b65": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_f9a435411e8d47eab00a96db2ad9a7d0",
            "placeholder": "​",
            "style": "IPY_MODEL_80634df59618471380a8fb6ae6986b55",
            "value": " 3/3 [00:40&lt;00:00, 13.63s/it]"
          }
        },
        "36df2624afac42b599910c887f11273f": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "9ebdc8a1e1794afc8551d0be016bdee8": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "124f726e963f431ea101765773a2ff3f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "7e5a10811df64fabbeb9963603698bb8": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "f807c3b917dc4f5986c7f68f0c10a6dd": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "f9a435411e8d47eab00a96db2ad9a7d0": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "80634df59618471380a8fb6ae6986b55": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "6a295779d604480e8c8fcc8ec9774384": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_2ff401439f674c6bb8ba08bc60ee45f1",
              "IPY_MODEL_2846f220ca2c4d50b90c73142da1a204",
              "IPY_MODEL_2aa9d45430e542558b70fae7dcebbe1b"
            ],
            "layout": "IPY_MODEL_a430407f834547a6989584720bec2b81"
          }
        },
        "2ff401439f674c6bb8ba08bc60ee45f1": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_af4cc41ef464496eb966567b52333ecf",
            "placeholder": "​",
            "style": "IPY_MODEL_457e2289837b41f38a9e43b34ceaab3c",
            "value": "Making predictions: 100%"
          }
        },
        "2846f220ca2c4d50b90c73142da1a204": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_94ffad8199d346dda5268295bbaaa0c8",
            "max": 313,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_6b549dd0db7141e59582bb45c3b44eaa",
            "value": 313
          }
        },
        "2aa9d45430e542558b70fae7dcebbe1b": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_b084201b8bde4bd9a5f72146123e5805",
            "placeholder": "​",
            "style": "IPY_MODEL_da5afadf535840538364278e35bfc1f5",
            "value": " 313/313 [00:02&lt;00:00, 105.79it/s]"
          }
        },
        "a430407f834547a6989584720bec2b81": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "af4cc41ef464496eb966567b52333ecf": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "457e2289837b41f38a9e43b34ceaab3c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "94ffad8199d346dda5268295bbaaa0c8": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "6b549dd0db7141e59582bb45c3b44eaa": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "b084201b8bde4bd9a5f72146123e5805": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "da5afadf535840538364278e35bfc1f5": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 5
}