pytorch_computer_vision.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/shark22k/computer-vision-notebooks/blob/master/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. Welcome To 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": "19179a39-0c6c-40f7-9891-09e17d107ecf",
   "metadata": {
    "id": "19179a39-0c6c-40f7-9891-09e17d107ecf"
   },
   "source": [
    "## Where does computer vision get used?\n",
    "\n",
    "If you use a smartphone, you've already used computer vision.\n",
    "\n",
    "Camera and photo apps use [computer vision to enhance](https://machinelearning.apple.com/research/panoptic-segmentation) and sort images.\n",
    "\n",
    "Modern cars use [computer vision](https://youtu.be/j0z4FweCy4M?t=2989) to avoid other cars and stay within lane lines.\n",
    "\n",
    "Manufacturers use computer vision to identify defects in various products.\n",
    "\n",
    "Security cameras use computer vision to detect potential intruders.\n",
    "\n",
    "In essence, anything that can be described in a visual sense can be a potential computer vision problem."
   ]
  },
  {
   "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 evaluating 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 predictions 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 iterable 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",
   "execution_count": 9,
   "id": "c263a60d-d788-482f-b9e7-9cab4f6b1f72",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c263a60d-d788-482f-b9e7-9cab4f6b1f72",
    "outputId": "df214cb6-fdea-446f-82de-71d44dec2d5f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PyTorch version: 2.5.0+cu121\n",
      "torchvision version: 0.20.0+cu121\n"
     ]
    }
   ],
   "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",
    "# Check versions\n",
    "# Note: your PyTorch version shouldn't be lower than 1.10.0 and torchvision version shouldn't be lower than 0.11\n",
    "print(f\"PyTorch version: {torch.__version__}\\ntorchvision version: {torchvision.__version__}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48d6bfe7-91da-44eb-9ab6-7c41c1e9fa8e",
   "metadata": {
    "id": "48d6bfe7-91da-44eb-9ab6-7c41c1e9fa8e"
   },
   "source": [
    "## 1. Getting a dataset\n",
    "\n",
    "To begin working on a computer vision problem, let's get a computer vision dataset.\n",
    "\n",
    "We're going to start with FashionMNIST.\n",
    "\n",
    "MNIST stands for Modified National Institute of Standards and Technology.\n",
    "\n",
    "The [original MNIST dataset](https://en.wikipedia.org/wiki/MNIST_database) contains thousands of examples of handwritten digits (from 0 to 9) and was used to build computer vision models to identify numbers for postal services.\n",
    "\n",
    "[FashionMNIST](https://github.com/zalandoresearch/fashion-mnist), made by Zalando Research, is a similar setup.\n",
    "\n",
    "Except 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",
   "execution_count": 2,
   "id": "486f8377-6810-4367-859d-69dccc7aef95",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "486f8377-6810-4367-859d-69dccc7aef95",
    "outputId": "d6347706-3652-4dbd-d134-fed6ec1c1e4d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz\n",
      "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz to data/FashionMNIST/raw/train-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 26.4M/26.4M [00:02<00:00, 10.3MB/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data/FashionMNIST/raw/train-images-idx3-ubyte.gz to data/FashionMNIST/raw\n",
      "\n",
      "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz\n",
      "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz to data/FashionMNIST/raw/train-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 29.5k/29.5k [00:00<00:00, 174kB/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data/FashionMNIST/raw/train-labels-idx1-ubyte.gz to data/FashionMNIST/raw\n",
      "\n",
      "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz\n",
      "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz to data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4.42M/4.42M [00:06<00:00, 689kB/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz to data/FashionMNIST/raw\n",
      "\n",
      "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz\n",
      "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz to data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5.15k/5.15k [00:00<00:00, 6.50MB/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to data/FashionMNIST/raw\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Setup training data\n",
    "train_data = datasets.FashionMNIST(\n",
    "    root=\"data\", # where to download data to?\n",
    "    train=True, # get training data\n",
    "    download=True, # download data if it doesn't exist on disk\n",
    "    transform=ToTensor(), # images come as PIL format, we want to turn into Torch tensors\n",
    "    target_transform=None # you can transform labels as well\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",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a63246f6-3645-49de-88fe-ec18e78bfbaf",
   "metadata": {
    "id": "a63246f6-3645-49de-88fe-ec18e78bfbaf"
   },
   "source": [
    "Let's check out the first sample of the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "43bfd3d9-a132-41e8-8ccd-5ae25a7da59a",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "43bfd3d9-a132-41e8-8ccd-5ae25a7da59a",
    "outputId": "dddbff57-d251-477a-cf85-16cd9c452cd0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image shape: torch.Size([1, 28, 28])\n",
      "Label: 9\n"
     ]
    }
   ],
   "source": [
    "# See first training sample\n",
    "image, label = train_data[0]\n",
    "print(f\"Image shape: {image.shape}\")\n",
    "print(f\"Label: {label}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "DKOHA98hO8X8",
   "metadata": {
    "id": "DKOHA98hO8X8"
   },
   "source": [
    "image is in form of colour channel, height, width i guess! :)"
   ]
  },
  {
   "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",
   "execution_count": null,
   "id": "c2997d9f-b574-4d23-aa34-1a4df1751226",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c2997d9f-b574-4d23-aa34-1a4df1751226",
    "outputId": "d9c4283b-aab8-410f-dd7f-03f08d943366"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 28, 28])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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 remains: 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 as 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": 5,
   "id": "fc4f768c-c3f6-454d-a633-673ad1d6eca0",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fc4f768c-c3f6-454d-a633-673ad1d6eca0",
    "outputId": "038968de-48c9-4a43-cd96-4ee15a44a514"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 60000, 10000, 10000)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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",
   "execution_count": 6,
   "id": "e22849c6-d93f-4b38-8403-5ebf0deaf008",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "e22849c6-d93f-4b38-8403-5ebf0deaf008",
    "outputId": "3f454e6c-af02-49f9-97b7-00feb346e122"
   },
   "outputs": [
    {
     "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']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# See classes\n",
    "class_names = train_data.classes\n",
    "class_names"
   ]
  },
  {
   "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",
   "execution_count": 7,
   "id": "b1df1f2c-28c9-43bf-aaef-cf996c9ae1c5",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 469
    },
    "id": "b1df1f2c-28c9-43bf-aaef-cf996c9ae1c5",
    "outputId": "f8e6ec26-7b35-4a60-c7cc-16c20c272e63"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image shape: torch.Size([1, 28, 28])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "image, label = train_data[0]\n",
    "print(f\"Image shape: {image.shape}\")\n",
    "plt.imshow(image.squeeze()) # image shape is [1, 28, 28] (colour channels, height, width)\n",
    "plt.title(label);"
   ]
  },
  {
   "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": "code",
   "execution_count": 8,
   "id": "92f09917-88f7-4446-b65f-baae586914c9",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 452
    },
    "id": "92f09917-88f7-4446-b65f-baae586914c9",
    "outputId": "a7865044-37f3-4850-abc4-510558ff2bd7"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(image.squeeze(), cmap=\"gray\")\n",
    "plt.title(class_names[label]);"
   ]
  },
  {
   "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": 10,
   "id": "7188ed7a-5959-48c4-ac7f-19129a2adc83",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 752
    },
    "id": "7188ed7a-5959-48c4-ac7f-19129a2adc83",
    "outputId": "c2a816a9-5846-4c51-e810-82d63ec3a710"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x900 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": [
    "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",
    "Plus, even for this small dataset (yes, even 60,000 images in deep learning is considered quite small), could you write a program to classify each one of them?\n",
    "\n",
    "You probably could.\n",
    "\n",
    "But I think coding a model in PyTorch would be faster.\n",
    "\n",
    "> **Question:** Do you think the above data can be modeled with only straight (linear) lines? Or do you think you'd also need non-straight (non-linear) lines?"
   ]
  },
  {
   "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` does what you think it might do.\n",
    "\n",
    "It helps load data into a model.\n",
    "\n",
    "For training and for inference.\n",
    "\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",
    "Why do this?\n",
    "\n",
    "Because it's more computationally efficient.\n",
    "\n",
    "In an ideal world you could do the forward pass and backward pass across all of your data at once.\n",
    "\n",
    "But once you start using really large datasets, unless you've got infinite computing power, it's easier to break them up into batches.\n",
    "\n",
    "It also gives your model more opportunities to improve.\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",
   "execution_count": 11,
   "id": "bb2dbf90-a326-43cb-b25b-71af142fafeb",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bb2dbf90-a326-43cb-b25b-71af142fafeb",
    "outputId": "c9f30499-3405-48f7-9428-2b1c38789725"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataloaders: (<torch.utils.data.dataloader.DataLoader object at 0x78cda1adbe50>, <torch.utils.data.dataloader.DataLoader object at 0x78cda1adba00>)\n",
      "Length of train dataloader: 1875 batches of 32\n",
      "Length of test dataloader: 313 batches of 32\n"
     ]
    }
   ],
   "source": [
    "from torch.utils.data import DataLoader\n",
    "\n",
    "# Setup the batch size hyperparameter\n",
    "BATCH_SIZE = 32\n",
    "\n",
    "# Turn datasets into iterables (batches)\n",
    "train_dataloader = DataLoader(train_data, # dataset to turn into iterable\n",
    "    batch_size=BATCH_SIZE, # how many samples per batch?\n",
    "    shuffle=True # shuffle data every epoch?\n",
    ")\n",
    "\n",
    "test_dataloader = DataLoader(test_data,\n",
    "    batch_size=BATCH_SIZE,\n",
    "    shuffle=False # don't necessarily have to shuffle the testing data\n",
    ")\n",
    "\n",
    "# Let's check out what we've 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}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7a925ee7-484b-4149-be8f-3ad790172a5f",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7a925ee7-484b-4149-be8f-3ad790172a5f",
    "outputId": "23afd29b-19c9-42d4-a068-0acbd748b647"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([32, 1, 28, 28]), torch.Size([32]))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check out what's inside the training dataloader\n",
    "train_features_batch, train_labels_batch = next(iter(train_dataloader))\n",
    "train_features_batch.shape, train_labels_batch.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fee4cf8-ab73-4c81-8e5e-3c81691e799c",
   "metadata": {
    "id": "4fee4cf8-ab73-4c81-8e5e-3c81691e799c"
   },
   "source": [
    "And we can see that the data remains unchanged by checking a single sample."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c863d66a-49be-43be-84dc-372a5d6fc2c2",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 463
    },
    "id": "c863d66a-49be-43be-84dc-372a5d6fc2c2",
    "outputId": "a195ea77-ff4f-4f35-fe09-025e97590eba"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image size: torch.Size([1, 28, 28])\n",
      "Label: 3, label size: torch.Size([])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Show a sample\n",
    "torch.manual_seed(2)\n",
    "random_idx = torch.randint(0, len(train_features_batch), size=[1]).item()\n",
    "img, label = train_features_batch[random_idx], train_labels_batch[random_idx]\n",
    "plt.imshow(img.squeeze(), cmap=\"gray\")\n",
    "plt.title(class_names[label])\n",
    "plt.axis(\"Off\");\n",
    "print(f\"Image size: {img.shape}\")\n",
    "print(f\"Label: {label}, label size: {label.shape}\")"
   ]
  },
  {
   "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",
    "We've done this in a previous section but there's going to be one slight difference.\n",
    "\n",
    "Because we're working with image data, we're going to use a different layer to start things off.\n",
    "\n",
    "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",
   "execution_count": 18,
   "id": "405319f1-f242-4bd9-90f5-3abdc50782ac",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "405319f1-f242-4bd9-90f5-3abdc50782ac",
    "outputId": "a4149877-1534-4442-9076-8997147b05b5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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"
     ]
    }
   ],
   "source": [
    "# Create a flatten layer\n",
    "flatten_model = nn.Flatten() # all nn modules function as a model (can do a forward pass)\n",
    "\n",
    "# Get a single sample\n",
    "x = train_features_batch[0]\n",
    "\n",
    "# Flatten the sample\n",
    "output = flatten_model(x) # perform forward pass\n",
    "\n",
    "# Print out what happened\n",
    "print(f\"Shape before flattening: {x.shape} -> [color_channels, height, width]\")\n",
    "print(f\"Shape after flattening: {output.shape} -> [color_channels, height*width]\")\n",
    "\n",
    "# Try uncommenting below and see what happens\n",
    "#print(x)\n",
    "#print(output)"
   ]
  },
  {
   "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",
   "execution_count": 19,
   "id": "1449f427-6859-41ae-8133-50b58ffbce72",
   "metadata": {
    "id": "1449f427-6859-41ae-8133-50b58ffbce72"
   },
   "outputs": [],
   "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(), # neural networks like their inputs in vector form\n",
    "            nn.Linear(in_features=input_shape, out_features=hidden_units), # in_features = number of features in a data sample (784 pixels)\n",
    "            nn.Linear(in_features=hidden_units, out_features=output_shape)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.layer_stack(x)"
   ]
  },
  {
   "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",
   "execution_count": 20,
   "id": "dd18384a-76f9-4b5a-a013-fda077f16865",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dd18384a-76f9-4b5a-a013-fda077f16865",
    "outputId": "5b0f7e4f-588d-4b39-e0a7-c58ad8945066"
   },
   "outputs": [
    {
     "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",
       ")"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.manual_seed(42)\n",
    "\n",
    "# Need to setup model with input parameters\n",
    "model_0 = FashionMNISTModelV0(input_shape=784, # one for every pixel (28x28)\n",
    "    hidden_units=10, # how many units in the hidden layer\n",
    "    output_shape=len(class_names) # one for every class\n",
    ")\n",
    "model_0.to(\"cpu\") # keep model on CPU to begin with"
   ]
  },
  {
   "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()` we defined in [notebook 02](https://www.learnpytorch.io/02_pytorch_classification/).\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": 21,
   "id": "31c91f17-d810-46a4-97c3-c734f93430b1",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "31c91f17-d810-46a4-97c3-c734f93430b1",
    "outputId": "6531a55e-56f5-4e54-b289-4ce695dc7d9c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading helper_functions.py\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",
   "execution_count": 22,
   "id": "ce3d13b8-f018-4b44-8bba-375074dc4c5f",
   "metadata": {
    "id": "ce3d13b8-f018-4b44-8bba-375074dc4c5f"
   },
   "outputs": [],
   "source": [
    "# Import accuracy metric\n",
    "from helper_functions import accuracy_fn # Note: could also use torchmetrics.Accuracy(task = 'multiclass', num_classes=len(class_names)).to(device)\n",
    "\n",
    "# Setup loss function and optimizer\n",
    "loss_fn = nn.CrossEntropyLoss() # this is also called \"criterion\"/\"cost function\" in some places\n",
    "optimizer = torch.optim.SGD(params=model_0.parameters(), lr=0.1)"
   ]
  },
  {
   "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",
   "execution_count": 23,
   "id": "31adc3fe-ce90-4b4e-b0d4-3613abae5714",
   "metadata": {
    "id": "31adc3fe-ce90-4b4e-b0d4-3613abae5714"
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "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",
    "Beautiful!\n",
    "\n",
    "Looks like we've got all of the pieces of the puzzle ready to go, a timer, a loss function, an optimizer, a model and most importantly, some data.\n",
    "\n",
    "Let's now create a training loop and a testing loop to train and evaluate our model.\n",
    "\n",
    "We'll be using the same steps as the previous notebook(s), though since our data is now in batch form, we'll add another loop to loop through our data batches.\n",
    "\n",
    "Our data batches are contained within our `DataLoader`s, `train_dataloader` and `test_dataloader` for the training and test data splits respectively.\n",
    "\n",
    "A batch is `BATCH_SIZE` samples of `X` (features) and `y` (labels), since we're using `BATCH_SIZE=32`, our batches have 32 samples of images and targets.\n",
    "\n",
    "And since we're computing on batches of data, our loss and evaluation metrics will be calculated **per batch** rather than across the whole dataset.\n",
    "\n",
    "This means we'll have to divide our loss and accuracy values by the number of batches in each dataset's respective dataloader.\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",
    "\n",
    "A fair few steps but...\n",
    "\n",
    "...if in doubt, code it out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c07bbf10-81e3-47f0-990d-9a4a838276ab",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 587,
     "referenced_widgets": [
      "6c8477b91d5e43cb9ce98d3c1fa63c00",
      "a77efb97769b407fbe49dcac0fa89136",
      "b2acd0ad92014e52a9a34582c21ef1d6",
      "ba784861bfcc4708944e93a149d6b3b4",
      "56ad754db89d42cc89d4a098155bec0e",
      "ebf4633360e945f09320825aa13dc84e",
      "e9886b40b5164e2c81f1e7b54dae66a4",
      "1f66d52b47174fe0a187af5314cd4591",
      "398ac7652fc74e498d743868a5ab963d",
      "7ce5bd4acb1b493d88d05324e1b46116",
      "882b6fa90348468499b6b7cc634148dc"
     ]
    },
    "id": "c07bbf10-81e3-47f0-990d-9a4a838276ab",
    "outputId": "d44d64ac-e111-4d26-98e8-77f84ce23ed7"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6c8477b91d5e43cb9ce98d3c1fa63c00",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/3 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "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: 28.797 seconds\n"
     ]
    }
   ],
   "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 (we'll keep this small for faster training times)\n",
    "epochs = 3\n",
    "\n",
    "# Create training and testing loop\n",
    "for epoch in tqdm(range(epochs)):\n",
    "    print(f\"Epoch: {epoch}\\n-------\")\n",
    "    ### Training\n",
    "    train_loss = 0\n",
    "    # Add a loop to loop through training batches\n",
    "    for batch, (X, y) in enumerate(train_dataloader):\n",
    "        model_0.train()\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 have been seen\n",
    "        if batch % 400 == 0:\n",
    "            print(f\"Looked at {batch * len(X)}/{len(train_dataloader.dataset)} samples\")\n",
    "\n",
    "    # Divide total train loss by length of train dataloader (average loss per batch per epoch)\n",
    "    train_loss /= len(train_dataloader)\n",
    "\n",
    "    ### Testing\n",
    "    # Setup variables for accumulatively adding up loss and accuracy\n",
    "    test_loss, test_acc = 0, 0\n",
    "    model_0.eval()\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 (accumulatively)\n",
    "            test_loss += loss_fn(test_pred, y) # accumulatively add up the loss per epoch\n",
    "\n",
    "            # 3. Calculate accuracy (preds need to be same as y_true)\n",
    "            test_acc += accuracy_fn(y_true=y, y_pred=test_pred.argmax(dim=1))\n",
    "\n",
    "        # Calculations on test metrics need to happen inside torch.inference_mode()\n",
    "        # Divide total test loss by length of test dataloader (per batch)\n",
    "        test_loss /= len(test_dataloader)\n",
    "\n",
    "        # Divide total accuracy by length of test dataloader (per batch)\n",
    "        test_acc /= len(test_dataloader)\n",
    "\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))"
   ]
  },
  {
   "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",
    "It didn't take too long to train either, even just on the CPU, I wonder if it'll speed up on the GPU?\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",
    "Since we're going to be building a few models, it's a good idea to write some code to evaluate them all in similar ways.\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",
   "execution_count": 25,
   "id": "8317dd04-9de2-4fd7-97bd-1e202621397d",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "8317dd04-9de2-4fd7-97bd-1e202621397d",
    "outputId": "fd641476-f6ed-4849-d83f-7fe0a234f27b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'model_name': 'FashionMNISTModelV0',\n",
       " 'model_loss': 0.47663894295692444,\n",
       " 'model_acc': 83.42651757188499}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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",
    "    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(X)\n",
    "\n",
    "            # Accumulate 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/acc per batch\n",
    "        loss /= len(data_loader)\n",
    "        acc /= len(data_loader)\n",
    "\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 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"
   ]
  },
  {
   "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 have 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",
   "execution_count": 26,
   "id": "17b69fe9-f974-4538-922c-20c5cc8220cc",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "17b69fe9-f974-4538-922c-20c5cc8220cc",
    "outputId": "d213b7fa-a602-4bf0-e5b2-0d3d78345761"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'cuda'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Setup device agnostic code\n",
    "import torch\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "device"
   ]
  },
  {
   "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 learned about [the power of non-linearity in notebook 02](https://www.learnpytorch.io/02_pytorch_classification/#6-the-missing-piece-non-linearity).\n",
    "\n",
    "Seeing the data we've been working with, do you think it needs non-linear functions?\n",
    "\n",
    "And remember, linear means straight and non-linear means non-straight.\n",
    "\n",
    "Let's find out.\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",
   "execution_count": 29,
   "id": "2ccce5f2-b1e5-47a6-a7f3-6bc096b35ffb",
   "metadata": {
    "id": "2ccce5f2-b1e5-47a6-a7f3-6bc096b35ffb"
   },
   "outputs": [],
   "source": [
    "# Create a model with non-linear and linear layers\n",
    "class FashionMNISTModelV1(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(), # 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",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        return self.layer_stack(x)"
   ]
  },
  {
   "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",
   "execution_count": 30,
   "id": "907091ec-7e46-470b-a305-788a3009b837",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "907091ec-7e46-470b-a305-788a3009b837",
    "outputId": "bf8a13bb-d964-42c2-91a5-d4bdfbf867d3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=0)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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",
    "next(model_1.parameters()).device # check model device"
   ]
  },
  {
   "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",
   "execution_count": 31,
   "id": "fe7e463b-d46c-4f00-853c-fdf0a28d74c8",
   "metadata": {
    "id": "fe7e463b-d46c-4f00-853c-fdf0a28d74c8"
   },
   "outputs": [],
   "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)"
   ]
  },
  {
   "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",
    "So far we've been writing train and test loops over and over.\n",
    "\n",
    "Let's write them again but this time we'll put them in functions so they can be called again and again.\n",
    "\n",
    "And because 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",
   "execution_count": 32,
   "id": "3d239ed2-4028-4603-8db3-ffca2b727819",
   "metadata": {
    "id": "3d239ed2-4028-4603-8db3-ffca2b727819"
   },
   "outputs": [],
   "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",
    "    model.to(device)\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",
    "\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)) # Go from logits -> pred labels\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",
    "    # Calculate loss and accuracy per epoch and print out what's happening\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}%\")\n",
    "\n",
    "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.to(device)\n",
    "    model.eval() # put model in eval mode\n",
    "    # Turn on inference context manager\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",
    "\n",
    "        # Adjust metrics and print out\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\")"
   ]
  },
  {
   "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 through a training step 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",
   "execution_count": 33,
   "id": "2bb8094b-01a0-4b84-9526-ba8888d04901",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 327,
     "referenced_widgets": [
      "3b05c7d67cd54c6db4ae5a3be8b2534b",
      "0cd547aae2cd49cd81074d28f2ccd200",
      "82c4cc5d9aba44aaa25586f6bfb171d2",
      "bd5131b2ea5f4644be17191d2ccbc89e",
      "26a074d9079f403dae5f8daa57018aa7",
      "bb842c06bef54b01bd668b42f780b001",
      "40c0f5e89e404063815446086ba629e5",
      "87370ff792344f20910c7c42624e618a",
      "ac303ef44ec842b69f51706ff3b153af",
      "a96e76a1acd24255a12ed04a83c0aab7",
      "fc089d60cd25438eb801da1881d51c84"
     ]
    },
    "id": "2bb8094b-01a0-4b84-9526-ba8888d04901",
    "outputId": "4b8f7f21-1474-40dc-fc98-ff980cba5d41"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3b05c7d67cd54c6db4ae5a3be8b2534b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/3 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0\n",
      "---------\n",
      "Train loss: 0.64607 | Train accuracy: 77.17%\n",
      "Test loss: 0.53855 | Test accuracy: 80.76%\n",
      "\n",
      "Epoch: 1\n",
      "---------\n",
      "Train loss: 0.48094 | Train accuracy: 82.94%\n",
      "Test loss: 0.49390 | Test accuracy: 82.46%\n",
      "\n",
      "Epoch: 2\n",
      "---------\n",
      "Train loss: 0.44689 | Train accuracy: 84.16%\n",
      "Test loss: 0.45746 | Test accuracy: 83.99%\n",
      "\n",
      "Train time on cuda: 31.748 seconds\n"
     ]
    }
   ],
   "source": [
    "torch.manual_seed(42)\n",
    "\n",
    "# Measure time\n",
    "from timeit import default_timer as timer\n",
    "train_time_start_on_gpu = timer()\n",
    "\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",
    "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)"
   ]
  },
  {
   "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 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 dependent 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": 34,
   "id": "32a544e3-9dbe-4aa1-b074-22e28b8f2f2a",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 373
    },
    "id": "32a544e3-9dbe-4aa1-b074-22e28b8f2f2a",
    "outputId": "068167c8-b4f1-4a1a-b65b-022aafb15d16"
   },
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "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_CUDA_addmm)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-34-93fed76e63a5>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# Note: This will error due to `eval_model()` not using device agnostic code\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m model_1_results = eval_model(model=model_1, \n\u001b[0m\u001b[1;32m      5\u001b[0m     \u001b[0mdata_loader\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtest_dataloader\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mloss_fn\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mloss_fn\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-25-885bc9be9cde>\u001b[0m in \u001b[0;36meval_model\u001b[0;34m(model, data_loader, loss_fn, accuracy_fn)\u001b[0m\n\u001b[1;32m     20\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdata_loader\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m             \u001b[0;31m# Make predictions with the model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m             \u001b[0my_pred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     23\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     24\u001b[0m             \u001b[0;31m# Accumulate the loss and accuracy values per batch\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1735\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1736\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1737\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1738\u001b[0m     \u001b[0;31m# torchrec tests the code consistency with the following code\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1745\u001b[0m                 \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1746\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1748\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1749\u001b[0m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-29-d77241d5127c>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayer_stack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1735\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1736\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1737\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1738\u001b[0m     \u001b[0;31m# torchrec tests the code consistency with the following code\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1745\u001b[0m                 \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1746\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1748\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1749\u001b[0m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/container.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    248\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    249\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mmodule\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 250\u001b[0;31m             \u001b[0minput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodule\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    251\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    252\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1735\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1736\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1737\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1738\u001b[0m     \u001b[0;31m# torchrec tests the code consistency with the following code\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1745\u001b[0m                 \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1746\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1748\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1749\u001b[0m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/linear.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    123\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    124\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 125\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinear\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbias\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    126\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    127\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mextra_repr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mRuntimeError\u001b[0m: 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_CUDA_addmm)"
     ]
    }
   ],
   "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": 35,
   "id": "f3665d99-1adc-4d9f-bfc6-e5601a80691c",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "f3665d99-1adc-4d9f-bfc6-e5601a80691c",
    "outputId": "faaf2639-4255-45ce-edb6-0306d37b99e7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'model_name': 'FashionMNISTModelV1',\n",
       " 'model_loss': 0.45746350288391113,\n",
       " 'model_acc': 83.98562300319489}"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 36,
   "id": "a9e916cf-f873-4481-a983-bac26ce4cac2",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "a9e916cf-f873-4481-a983-bac26ce4cac2",
    "outputId": "882385d5-6a04-4cc1-ba95-3483e5862b07"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'model_name': 'FashionMNISTModelV0',\n",
       " 'model_loss': 0.47663894295692444,\n",
       " 'model_acc': 83.42651757188499}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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",
    "That's a thing to note in machine learning, sometimes the thing you thought should work doesn't.\n",
    "\n",
    "And then the thing you thought might not work does.\n",
    "\n",
    "It's part science, part art.\n",
    "\n",
    "From the looks of things, it seems like our model is **overfitting** on the training data.\n",
    "\n",
    "Overfitting means our model is learning the training data well but those patterns aren't generalizing to the testing data.\n",
    "\n",
    "Two of the main ways to fix overfitting include:\n",
    "1. Using a smaller or different model (some models fit certain kinds of data better than others).\n",
    "2. Using a larger dataset (the more data, the more chance a model has to learn generalizable patterns).\n",
    "\n",
    "There are more, but I'm going to leave that as a challenge for you to explore.\n",
    "\n",
    "Try searching online, \"ways to prevent overfitting in machine learning\" and see what comes up.\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",
    "Alright, time to step things up a notch.\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.\n",
    "\n",
    "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 dependent 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",
   "execution_count": 37,
   "id": "dce60214-63fd-46e2-89ba-125445ac76b7",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dce60214-63fd-46e2-89ba-125445ac76b7",
    "outputId": "527b7bc4-9645-416d-a90d-a2b30971a4ec"
   },
   "outputs": [
    {
     "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",
       ")"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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, # how big is the square that's going over the image?\n",
    "                      stride=1, # default\n",
    "                      padding=1),# options = \"valid\" (no padding) or \"same\" (output has same shape as input) or int for specific number\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) # default stride value is same as kernel_size\n",
    "        )\n",
    "        self.block_2 = nn.Sequential(\n",
    "            nn.Conv2d(hidden_units, hidden_units, 3, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(hidden_units, hidden_units, 3, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(2)\n",
    "        )\n",
    "        self.classifier = nn.Sequential(\n",
    "            nn.Flatten(),\n",
    "            # Where did this in_features shape come from?\n",
    "            # It's because each layer of our network compresses and changes the shape of our input data.\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",
    "        # print(x.shape)\n",
    "        x = self.block_2(x)\n",
    "        # print(x.shape)\n",
    "        x = self.classifier(x)\n",
    "        # print(x.shape)\n",
    "        return x\n",
    "\n",
    "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"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a20f25e-cc16-4f85-a69b-62008c01d0ed",
   "metadata": {
    "id": "0a20f25e-cc16-4f85-a69b-62008c01d0ed"
   },
   "source": [
    "Nice!\n",
    "\n",
    "Our biggest model yet!\n",
    "\n",
    "What we've done is a common practice in machine learning.\n",
    "\n",
    "Find a model architecture somewhere and replicate it with code."
   ]
  },
  {
   "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": 41,
   "id": "058b01ac-3f6a-4472-bcbf-3377974e3254",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "058b01ac-3f6a-4472-bcbf-3377974e3254",
    "outputId": "d8264e1c-eaad-4d96-9545-857fc1739ee4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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": 43,
   "id": "ebd39562-1dad-40e3-90f5-750a5dac24e2",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ebd39562-1dad-40e3-90f5-750a5dac24e2",
    "outputId": "9549a77f-4864-4101-f50b-e6c07402cb93"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 64, 64])\n"
     ]
    }
   ],
   "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",
    "print(test_image.shape)\n",
    "\n",
    "\n",
    "# Pass the data through the convolutional layer\n",
    "image_after_conv = conv_layer(test_image)\n"
   ]
  },
  {
   "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": 44,
   "id": "abba741d-a1ed-44ed-ba53-41d589433a2c",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "abba741d-a1ed-44ed-ba53-41d589433a2c",
    "outputId": "5f288f40-20be-4491-f82d-fbc46da7d300"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 3, 64, 64])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add extra dimension to test image\n",
    "test_image.unsqueeze(dim=0).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "c7280a49-4ee0-452b-a514-61115b6a444c",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c7280a49-4ee0-452b-a514-61115b6a444c",
    "outputId": "10ef4d6d-6c2b-48c2-b38b-e81949012c35"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 10, 62, 62])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 46,
   "id": "04445d45-cf2f-4c1d-b215-bc50865a207a",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "04445d45-cf2f-4c1d-b215-bc50865a207a",
    "outputId": "90e14b71-4c5e-4c2c-8261-1a3d14dc599d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 10, 30, 30])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "46027ed1-c3a7-46bd-bab7-17f8c20e354b",
    "outputId": "bc493b18-1ef3-41c6-9de9-5dfeaa4c259e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "e5518d61-c0b7-4351-b5ea-4d6b6144291a",
    "outputId": "14ef701e-c82d-4fae-9dd6-e18352817cf2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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": 47,
   "id": "1164c753-19d9-43b7-a04f-017d0f7188c3",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1164c753-19d9-43b7-a04f-017d0f7188c3",
    "outputId": "d86d42a0-5e1b-4a30-ee66-caee200bee41"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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 affect 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": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "e6a2b196-4845-4b40-9212-e75406e88875",
    "outputId": "5a5e5df1-8e25-4061-d223-398ecfc7ef4c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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 similar 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",
   "execution_count": 48,
   "id": "06a76a1b-5f6f-4018-bf7b-8388b385476f",
   "metadata": {
    "id": "06a76a1b-5f6f-4018-bf7b-8388b385476f"
   },
   "outputs": [],
   "source": [
    "# Setup loss and optimizer\n",
    "loss_fn = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(params=model_2.parameters(),\n",
    "                             lr=0.1)"
   ]
  },
  {
   "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": 49,
   "id": "861d126e-d876-40b3-9b7a-66cfc2f1bf05",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 327,
     "referenced_widgets": [
      "b2041791a3204b8883d080ac22ece232",
      "61462d2ff08243cb8b631ca307c37d49",
      "4bc9170f713b44cdbf9f9380bede178f",
      "34bec9be3a8b410fa87f85d305447628",
      "043d95264d9e4d4b8ccd25bf3162f398",
      "2862c68d07324e15b0f023481160c9eb",
      "cb2a4fcf1c57403c9f1bc11334e87644",
      "5b37be19536044bb8659171600c2017e",
      "5a40017005cb4322ba943ff528623d1e",
      "63f492cc30dc4b25bc9051a79762d4cf",
      "a48a1d52984341c88fefb7c4672d18a5"
     ]
    },
    "id": "861d126e-d876-40b3-9b7a-66cfc2f1bf05",
    "outputId": "f175bdd8-d45c-4cb9-e176-bac1debafcd9"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b2041791a3204b8883d080ac22ece232",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/3 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0\n",
      "---------\n",
      "Train loss: 0.59610 | Train accuracy: 78.37%\n",
      "Test loss: 0.41392 | Test accuracy: 85.06%\n",
      "\n",
      "Epoch: 1\n",
      "---------\n",
      "Train loss: 0.36474 | Train accuracy: 86.82%\n",
      "Test loss: 0.35469 | Test accuracy: 86.81%\n",
      "\n",
      "Epoch: 2\n",
      "---------\n",
      "Train loss: 0.32534 | Train accuracy: 88.18%\n",
      "Test loss: 0.32616 | Test accuracy: 88.16%\n",
      "\n",
      "Train time on cuda: 37.599 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": 50,
   "id": "c1bf8b89-1389-4395-a1c4-9c6e94d9e71c",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c1bf8b89-1389-4395-a1c4-9c6e94d9e71c",
    "outputId": "c2d0fdf8-1388-4baa-8d76-16563296f460"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'model_name': 'FashionMNISTModelV2',\n",
       " 'model_loss': 0.3261563777923584,\n",
       " 'model_acc': 88.15894568690096}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 51,
   "id": "52d84ee1-1ad4-4860-b147-f8912c1febc7",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 143
    },
    "id": "52d84ee1-1ad4-4860-b147-f8912c1febc7",
    "outputId": "1a7acd8b-a251-4d1e-bb4b-0375415c8320"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "summary": "{\n  \"name\": \"compare_results\",\n  \"rows\": 3,\n  \"fields\": [\n    {\n      \"column\": \"model_name\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 3,\n        \"samples\": [\n          \"FashionMNISTModelV0\",\n          \"FashionMNISTModelV1\",\n          \"FashionMNISTModelV2\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"model_loss\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.08190875107938739,\n        \"min\": 0.3261563777923584,\n        \"max\": 0.47663894295692444,\n        \"num_unique_values\": 3,\n        \"samples\": [\n          0.47663894295692444,\n          0.45746350288391113,\n          0.3261563777923584\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"model_acc\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 2.586023232992104,\n        \"min\": 83.42651757188499,\n        \"max\": 88.15894568690096,\n        \"num_unique_values\": 3,\n        \"samples\": [\n          83.42651757188499,\n          83.98562300319489,\n          88.15894568690096\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}",
       "type": "dataframe",
       "variable_name": "compare_results"
      },
      "text/html": [
       "\n",
       "  <div id=\"df-d745897c-d829-4ac2-92a1-e4f4e3937e7c\" 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.457464</td>\n",
       "      <td>83.985623</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FashionMNISTModelV2</td>\n",
       "      <td>0.326156</td>\n",
       "      <td>88.158946</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    <div class=\"colab-df-buttons\">\n",
       "\n",
       "  <div class=\"colab-df-container\">\n",
       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-d745897c-d829-4ac2-92a1-e4f4e3937e7c')\"\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 -960 960 960\">\n",
       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
       "  </svg>\n",
       "    </button>\n",
       "\n",
       "  <style>\n",
       "    .colab-df-container {\n",
       "      display:flex;\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",
       "    .colab-df-buttons div {\n",
       "      margin-bottom: 4px;\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-d745897c-d829-4ac2-92a1-e4f4e3937e7c 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-d745897c-d829-4ac2-92a1-e4f4e3937e7c');\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",
       "\n",
       "\n",
       "<div id=\"df-919bbb0b-613c-49d6-8b58-884d599b54a3\">\n",
       "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-919bbb0b-613c-49d6-8b58-884d599b54a3')\"\n",
       "            title=\"Suggest charts\"\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",
       "    <g>\n",
       "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
       "    </g>\n",
       "</svg>\n",
       "  </button>\n",
       "\n",
       "<style>\n",
       "  .colab-df-quickchart {\n",
       "      --bg-color: #E8F0FE;\n",
       "      --fill-color: #1967D2;\n",
       "      --hover-bg-color: #E2EBFA;\n",
       "      --hover-fill-color: #174EA6;\n",
       "      --disabled-fill-color: #AAA;\n",
       "      --disabled-bg-color: #DDD;\n",
       "  }\n",
       "\n",
       "  [theme=dark] .colab-df-quickchart {\n",
       "      --bg-color: #3B4455;\n",
       "      --fill-color: #D2E3FC;\n",
       "      --hover-bg-color: #434B5C;\n",
       "      --hover-fill-color: #FFFFFF;\n",
       "      --disabled-bg-color: #3B4455;\n",
       "      --disabled-fill-color: #666;\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart {\n",
       "    background-color: var(--bg-color);\n",
       "    border: none;\n",
       "    border-radius: 50%;\n",
       "    cursor: pointer;\n",
       "    display: none;\n",
       "    fill: var(--fill-color);\n",
       "    height: 32px;\n",
       "    padding: 0;\n",
       "    width: 32px;\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart:hover {\n",
       "    background-color: var(--hover-bg-color);\n",
       "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
       "    fill: var(--button-hover-fill-color);\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart-complete:disabled,\n",
       "  .colab-df-quickchart-complete:disabled:hover {\n",
       "    background-color: var(--disabled-bg-color);\n",
       "    fill: var(--disabled-fill-color);\n",
       "    box-shadow: none;\n",
       "  }\n",
       "\n",
       "  .colab-df-spinner {\n",
       "    border: 2px solid var(--fill-color);\n",
       "    border-color: transparent;\n",
       "    border-bottom-color: var(--fill-color);\n",
       "    animation:\n",
       "      spin 1s steps(1) infinite;\n",
       "  }\n",
       "\n",
       "  @keyframes spin {\n",
       "    0% {\n",
       "      border-color: transparent;\n",
       "      border-bottom-color: var(--fill-color);\n",
       "      border-left-color: var(--fill-color);\n",
       "    }\n",
       "    20% {\n",
       "      border-color: transparent;\n",
       "      border-left-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "    }\n",
       "    30% {\n",
       "      border-color: transparent;\n",
       "      border-left-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "      border-right-color: var(--fill-color);\n",
       "    }\n",
       "    40% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "    }\n",
       "    60% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "    }\n",
       "    80% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "      border-bottom-color: var(--fill-color);\n",
       "    }\n",
       "    90% {\n",
       "      border-color: transparent;\n",
       "      border-bottom-color: var(--fill-color);\n",
       "    }\n",
       "  }\n",
       "</style>\n",
       "\n",
       "  <script>\n",
       "    async function quickchart(key) {\n",
       "      const quickchartButtonEl =\n",
       "        document.querySelector('#' + key + ' button');\n",
       "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
       "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
       "      try {\n",
       "        const charts = await google.colab.kernel.invokeFunction(\n",
       "            'suggestCharts', [key], {});\n",
       "      } catch (error) {\n",
       "        console.error('Error during call to suggestCharts:', error);\n",
       "      }\n",
       "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
       "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
       "    }\n",
       "    (() => {\n",
       "      let quickchartButtonEl =\n",
       "        document.querySelector('#df-919bbb0b-613c-49d6-8b58-884d599b54a3 button');\n",
       "      quickchartButtonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "    })();\n",
       "  </script>\n",
       "</div>\n",
       "\n",
       "  <div id=\"id_6eca4b13-2caa-4f1e-9d23-87e059ce4e5e\">\n",
       "    <style>\n",
       "      .colab-df-generate {\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-generate: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-generate {\n",
       "        background-color: #3B4455;\n",
       "        fill: #D2E3FC;\n",
       "      }\n",
       "\n",
       "      [theme=dark] .colab-df-generate: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",
       "    <button class=\"colab-df-generate\" onclick=\"generateWithVariable('compare_results')\"\n",
       "            title=\"Generate code using this dataframe.\"\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=\"M7,19H8.4L18.45,9,17,7.55,7,17.6ZM5,21V16.75L18.45,3.32a2,2,0,0,1,2.83,0l1.4,1.43a1.91,1.91,0,0,1,.58,1.4,1.91,1.91,0,0,1-.58,1.4L9.25,21ZM18.45,9,17,7.55Zm-12,3A5.31,5.31,0,0,0,4.9,8.1,5.31,5.31,0,0,0,1,6.5,5.31,5.31,0,0,0,4.9,4.9,5.31,5.31,0,0,0,6.5,1,5.31,5.31,0,0,0,8.1,4.9,5.31,5.31,0,0,0,12,6.5,5.46,5.46,0,0,0,6.5,12Z\"/>\n",
       "  </svg>\n",
       "    </button>\n",
       "    <script>\n",
       "      (() => {\n",
       "      const buttonEl =\n",
       "        document.querySelector('#id_6eca4b13-2caa-4f1e-9d23-87e059ce4e5e button.colab-df-generate');\n",
       "      buttonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "\n",
       "      buttonEl.onclick = () => {\n",
       "        google.colab.notebook.generateWithVariable('compare_results');\n",
       "      }\n",
       "      })();\n",
       "    </script>\n",
       "  </div>\n",
       "\n",
       "    </div>\n",
       "  </div>\n"
      ],
      "text/plain": [
       "            model_name  model_loss  model_acc\n",
       "0  FashionMNISTModelV0    0.476639  83.426518\n",
       "1  FashionMNISTModelV1    0.457464  83.985623\n",
       "2  FashionMNISTModelV2    0.326156  88.158946"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 52,
   "id": "297af38f-e69f-4c6f-9027-fcaf0482a55c",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 143
    },
    "id": "297af38f-e69f-4c6f-9027-fcaf0482a55c",
    "outputId": "3893e6d9-294d-4a0d-c4fe-ef12bd3e5654"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "summary": "{\n  \"name\": \"compare_results\",\n  \"rows\": 3,\n  \"fields\": [\n    {\n      \"column\": \"model_name\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 3,\n        \"samples\": [\n          \"FashionMNISTModelV0\",\n          \"FashionMNISTModelV1\",\n          \"FashionMNISTModelV2\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"model_loss\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.08190875107938739,\n        \"min\": 0.3261563777923584,\n        \"max\": 0.47663894295692444,\n        \"num_unique_values\": 3,\n        \"samples\": [\n          0.47663894295692444,\n          0.45746350288391113,\n          0.3261563777923584\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"model_acc\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 2.586023232992104,\n        \"min\": 83.42651757188499,\n        \"max\": 88.15894568690096,\n        \"num_unique_values\": 3,\n        \"samples\": [\n          83.42651757188499,\n          83.98562300319489,\n          88.15894568690096\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"training_time\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 4.480110546746795,\n        \"min\": 28.79693014400027,\n        \"max\": 37.599272520999875,\n        \"num_unique_values\": 3,\n        \"samples\": [\n          28.79693014400027,\n          31.747843410000314,\n          37.599272520999875\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}",
       "type": "dataframe",
       "variable_name": "compare_results"
      },
      "text/html": [
       "\n",
       "  <div id=\"df-30627836-e47a-4a19-8cbf-ac90a71b0fb8\" 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>28.796930</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>FashionMNISTModelV1</td>\n",
       "      <td>0.457464</td>\n",
       "      <td>83.985623</td>\n",
       "      <td>31.747843</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FashionMNISTModelV2</td>\n",
       "      <td>0.326156</td>\n",
       "      <td>88.158946</td>\n",
       "      <td>37.599273</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    <div class=\"colab-df-buttons\">\n",
       "\n",
       "  <div class=\"colab-df-container\">\n",
       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-30627836-e47a-4a19-8cbf-ac90a71b0fb8')\"\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 -960 960 960\">\n",
       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
       "  </svg>\n",
       "    </button>\n",
       "\n",
       "  <style>\n",
       "    .colab-df-container {\n",
       "      display:flex;\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",
       "    .colab-df-buttons div {\n",
       "      margin-bottom: 4px;\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-30627836-e47a-4a19-8cbf-ac90a71b0fb8 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-30627836-e47a-4a19-8cbf-ac90a71b0fb8');\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",
       "\n",
       "\n",
       "<div id=\"df-c035b90e-2d73-453d-b013-9fad00c50d4b\">\n",
       "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-c035b90e-2d73-453d-b013-9fad00c50d4b')\"\n",
       "            title=\"Suggest charts\"\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",
       "    <g>\n",
       "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
       "    </g>\n",
       "</svg>\n",
       "  </button>\n",
       "\n",
       "<style>\n",
       "  .colab-df-quickchart {\n",
       "      --bg-color: #E8F0FE;\n",
       "      --fill-color: #1967D2;\n",
       "      --hover-bg-color: #E2EBFA;\n",
       "      --hover-fill-color: #174EA6;\n",
       "      --disabled-fill-color: #AAA;\n",
       "      --disabled-bg-color: #DDD;\n",
       "  }\n",
       "\n",
       "  [theme=dark] .colab-df-quickchart {\n",
       "      --bg-color: #3B4455;\n",
       "      --fill-color: #D2E3FC;\n",
       "      --hover-bg-color: #434B5C;\n",
       "      --hover-fill-color: #FFFFFF;\n",
       "      --disabled-bg-color: #3B4455;\n",
       "      --disabled-fill-color: #666;\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart {\n",
       "    background-color: var(--bg-color);\n",
       "    border: none;\n",
       "    border-radius: 50%;\n",
       "    cursor: pointer;\n",
       "    display: none;\n",
       "    fill: var(--fill-color);\n",
       "    height: 32px;\n",
       "    padding: 0;\n",
       "    width: 32px;\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart:hover {\n",
       "    background-color: var(--hover-bg-color);\n",
       "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
       "    fill: var(--button-hover-fill-color);\n",
       "  }\n",
       "\n",
       "  .colab-df-quickchart-complete:disabled,\n",
       "  .colab-df-quickchart-complete:disabled:hover {\n",
       "    background-color: var(--disabled-bg-color);\n",
       "    fill: var(--disabled-fill-color);\n",
       "    box-shadow: none;\n",
       "  }\n",
       "\n",
       "  .colab-df-spinner {\n",
       "    border: 2px solid var(--fill-color);\n",
       "    border-color: transparent;\n",
       "    border-bottom-color: var(--fill-color);\n",
       "    animation:\n",
       "      spin 1s steps(1) infinite;\n",
       "  }\n",
       "\n",
       "  @keyframes spin {\n",
       "    0% {\n",
       "      border-color: transparent;\n",
       "      border-bottom-color: var(--fill-color);\n",
       "      border-left-color: var(--fill-color);\n",
       "    }\n",
       "    20% {\n",
       "      border-color: transparent;\n",
       "      border-left-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "    }\n",
       "    30% {\n",
       "      border-color: transparent;\n",
       "      border-left-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "      border-right-color: var(--fill-color);\n",
       "    }\n",
       "    40% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "      border-top-color: var(--fill-color);\n",
       "    }\n",
       "    60% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "    }\n",
       "    80% {\n",
       "      border-color: transparent;\n",
       "      border-right-color: var(--fill-color);\n",
       "      border-bottom-color: var(--fill-color);\n",
       "    }\n",
       "    90% {\n",
       "      border-color: transparent;\n",
       "      border-bottom-color: var(--fill-color);\n",
       "    }\n",
       "  }\n",
       "</style>\n",
       "\n",
       "  <script>\n",
       "    async function quickchart(key) {\n",
       "      const quickchartButtonEl =\n",
       "        document.querySelector('#' + key + ' button');\n",
       "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
       "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
       "      try {\n",
       "        const charts = await google.colab.kernel.invokeFunction(\n",
       "            'suggestCharts', [key], {});\n",
       "      } catch (error) {\n",
       "        console.error('Error during call to suggestCharts:', error);\n",
       "      }\n",
       "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
       "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
       "    }\n",
       "    (() => {\n",
       "      let quickchartButtonEl =\n",
       "        document.querySelector('#df-c035b90e-2d73-453d-b013-9fad00c50d4b button');\n",
       "      quickchartButtonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "    })();\n",
       "  </script>\n",
       "</div>\n",
       "\n",
       "  <div id=\"id_ab9b7b86-5b39-4e28-9227-afa4c901e44c\">\n",
       "    <style>\n",
       "      .colab-df-generate {\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-generate: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-generate {\n",
       "        background-color: #3B4455;\n",
       "        fill: #D2E3FC;\n",
       "      }\n",
       "\n",
       "      [theme=dark] .colab-df-generate: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",
       "    <button class=\"colab-df-generate\" onclick=\"generateWithVariable('compare_results')\"\n",
       "            title=\"Generate code using this dataframe.\"\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=\"M7,19H8.4L18.45,9,17,7.55,7,17.6ZM5,21V16.75L18.45,3.32a2,2,0,0,1,2.83,0l1.4,1.43a1.91,1.91,0,0,1,.58,1.4,1.91,1.91,0,0,1-.58,1.4L9.25,21ZM18.45,9,17,7.55Zm-12,3A5.31,5.31,0,0,0,4.9,8.1,5.31,5.31,0,0,0,1,6.5,5.31,5.31,0,0,0,4.9,4.9,5.31,5.31,0,0,0,6.5,1,5.31,5.31,0,0,0,8.1,4.9,5.31,5.31,0,0,0,12,6.5,5.46,5.46,0,0,0,6.5,12Z\"/>\n",
       "  </svg>\n",
       "    </button>\n",
       "    <script>\n",
       "      (() => {\n",
       "      const buttonEl =\n",
       "        document.querySelector('#id_ab9b7b86-5b39-4e28-9227-afa4c901e44c button.colab-df-generate');\n",
       "      buttonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "\n",
       "      buttonEl.onclick = () => {\n",
       "        google.colab.notebook.generateWithVariable('compare_results');\n",
       "      }\n",
       "      })();\n",
       "    </script>\n",
       "  </div>\n",
       "\n",
       "    </div>\n",
       "  </div>\n"
      ],
      "text/plain": [
       "            model_name  model_loss  model_acc  training_time\n",
       "0  FashionMNISTModelV0    0.476639  83.426518      28.796930\n",
       "1  FashionMNISTModelV1    0.457464  83.985623      31.747843\n",
       "2  FashionMNISTModelV2    0.326156  88.158946      37.599273"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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 dependent 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 technological advances.\n",
    "\n",
    "How about we get visual?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "5eb0df60-9318-47d0-adce-f8788ed3999e",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 449
    },
    "id": "5eb0df60-9318-47d0-adce-f8788ed3999e",
    "outputId": "c7980160-c6c3-45e1-b4a1-437da8743774"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": 54,
   "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) # note: perform softmax on the \"logits\" dimension, not \"batch\" dimension (in this case we have a batch size of 1, so can perform on 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": 55,
   "id": "420c7461-eaa9-4459-9e68-53574c758765",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "420c7461-eaa9-4459-9e68-53574c758765",
    "outputId": "3a44a35d-edfc-44c0-d367-e88c7eba3da4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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": "code",
   "execution_count": 57,
   "id": "1DYqA0r4SkrV",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1DYqA0r4SkrV",
    "outputId": "ef7da706-4f87-40b3-c6b9-4c1a8d8f8097"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1.0663e-07, 1.3469e-07, 9.3321e-08, 1.3084e-07, 1.8963e-07, 9.9962e-01,\n",
       "         4.0403e-07, 3.3402e-05, 5.7281e-05, 2.8471e-04],\n",
       "        [8.9521e-02, 6.9367e-01, 1.0950e-03, 8.7217e-02, 5.7398e-02, 5.0345e-05,\n",
       "         6.8435e-02, 1.0435e-03, 1.0274e-03, 5.4123e-04]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": "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": 58,
   "id": "79de2ac1-7d4b-4f81-ae8a-90099bca2a3d",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "79de2ac1-7d4b-4f81-ae8a-90099bca2a3d",
    "outputId": "501fba6a-92c7-47af-9549-2ae5be24c66b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1.0663e-07, 1.3469e-07, 9.3321e-08, 1.3084e-07, 1.8963e-07, 9.9962e-01,\n",
       "         4.0403e-07, 3.3402e-05, 5.7281e-05, 2.8471e-04],\n",
       "        [8.9521e-02, 6.9367e-01, 1.0950e-03, 8.7217e-02, 5.7398e-02, 5.0345e-05,\n",
       "         6.8435e-02, 1.0435e-03, 1.0274e-03, 5.4123e-04]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 59,
   "id": "f9d97bcc-4310-4851-a1f8-6bcd757e9b26",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "f9d97bcc-4310-4851-a1f8-6bcd757e9b26",
    "outputId": "90510860-cd96-4c0c-8ad1-aa9c530a584f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([5, 1, 7, 4, 3, 0, 4, 7, 1])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 60,
   "id": "1141af97-0990-4920-83d4-c13cca3f9abc",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1141af97-0990-4920-83d4-c13cca3f9abc",
    "outputId": "22fa81e6-2027-4d79-b955-87fb65e0f609"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([5, 1, 7, 4, 3, 0, 4, 7, 1], tensor([5, 1, 7, 4, 3, 0, 4, 7, 1]))"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 68,
   "id": "arKXixLtYv1z",
   "metadata": {
    "id": "arKXixLtYv1z"
   },
   "outputs": [],
   "source": [
    "random.seed(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "679cb5f7-bb66-42dd-a4d6-400b27b7c019",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 749
    },
    "id": "679cb5f7-bb66-42dd-a4d6-400b27b7c019",
    "outputId": "fd6717fb-a4b8-4292-f212-41835cb5f211"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x900 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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 predictions 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 [`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",
    "Let's start by making predictions with our trained model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "065b8090-c9c5-43df-b5c1-b45ba33af1be",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 49,
     "referenced_widgets": [
      "09b483589d7b4623a31ea645acf31f01",
      "e35d666f940e46569363e16ad5ac49cf",
      "2860ba1876df4b88beecfddab08ec30c",
      "ffe4ea9e54ed4fb79e085cf8f4eb70a0",
      "fb55efa8f0b64c59ab6b8036ac667a71",
      "8034607c9a094d2ea6a5d0d9cb4fcab4",
      "a624df7d7f6b4b4abf3fe1ffa6c61888",
      "e7cefdac24f84d6984b4edd909b4847f",
      "d60bf5a1f8114da2bc09a7189747709c",
      "160e8fefd7534ec8a1a3fe6eae7fac42",
      "bee3dc7c2f454eec9ade50dc94ce9630"
     ]
    },
    "id": "065b8090-c9c5-43df-b5c1-b45ba33af1be",
    "outputId": "48d15096-139d-4df2-d229-4c55312f2326"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "09b483589d7b4623a31ea645acf31f01",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Making predictions:   0%|          | 0/313 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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) # note: perform softmax on the \"logits\" dimension, not \"batch\" dimension (in this case we have a batch size of 32, so can perform on 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 visualize 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": 71,
   "id": "e6c0a05d-d3e0-4b86-9ef7-ee6ea5629b07",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "e6c0a05d-d3e0-4b86-9ef7-ee6ea5629b07",
    "outputId": "af11384b-5b43-4dfa-bb76-6658c8be02c2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[?25l   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/890.6 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m890.6/890.6 kB\u001b[0m \u001b[31m43.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hmlxtend version: 0.23.1\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": 72,
   "id": "21383f88-a2dd-4678-94c6-479c592da0ab",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "21383f88-a2dd-4678-94c6-479c592da0ab",
    "outputId": "f73784e0-f499-40c0-99cf-96af558e1c2b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.23.1\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 confusion matrix using the `plot_confusion_matrix()` function from `mlxtend.plotting`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "7aed6d76-ad1c-429e-b8e0-c80572e3ebf4",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 667
    },
    "id": "7aed6d76-ad1c-429e-b8e0-c80572e3ebf4",
    "outputId": "ecd25600-6d96-4069-a11c-10cd05589aa3"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApYAAAKKCAYAAACH5hvqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAADdzklEQVR4nOzdd3xN9x/H8dfNkpCNJEZib2Jvau9SatcKpa1asUdrF6WK2kVbdBlVs/YetXdRW6kRO5Egidz8/vDrbVNBwklukr6fj8d5PNwzP1/fO973nHO/MUVHR0cjIiIiIvKabKxdgIiIiIikDAqWIiIiImIIBUsRERERMYSCpYiIiIgYQsFSRERERAyhYCkiIiIihlCwFBERERFD2Fm7AHl9ZrOZa9eu4eLigslksnY5IiIiksJER0fz4MEDMmbMiI3N889LKlimANeuXcPX19faZYiIiEgKd+XKFTJnzvzc5QqWKYCLiwsADtVHY7J3tHI1xrr83bvWLiFBRJlT5h+8SqntsrdNeVcCUurVjfthEdYuIUG4p3GwdgkJIqX+8b+U+Pp6EBJCzmy+lszxPAqWKcBfT2CTvSMmeycrV2MsV1dXa5eQIFJqAEup7VKwTD6ibFNmsHRVsExWUurrC17eNv14R0REREQMoWApIiIiIoZQsBQRERERQyhYioiIiIghFCxFRERExBAKliIiIiJiCAVLERERETGEgqWIiIiIGELBUkREREQMoWApIiIiIoZQsBQRERERQyhYioiIiIghFCxFRERExBAKliIiIiJiCAVLERERETGEgqWIiIiIGELBUkREREQMoWApIiIiIoZQsBQRERERQ6TIYDls2DCKFCnywnUqV65MYGBgotSTlNnYmBjyTklOzXqHu4s6cmJmSwY0K/bMenkyu7P4o9rc+KE9txe+y87xb+ObztmyPJW9LRPfr8Cf3wZwa8G7/Ni/Jl5uTonZlFeyc8d2GjesTza/jDjZm1ixfJm1S4q3nTu207RRA3JmzYRzKhtW/qsNo0YOo2ihfHh5OJPZ25M3a9dg/7691ik2HubMmkG5kkXI7OVOZi93qlcqz4Z1ayzLHz9+TO/ArmTNlJ6M6Vxp3aIJN4OCrFjxq/lkxDBSO9jEmIoUzGftsl7bZ2PHUL5MSdJ7uOCX0YumjRty5vRpa5cVL1FRUYz7ZBil/XOT3ceNskXyMnHcaKKjoy3rjB8zkoolC5Ejowf5snjT7K3aHDqwz4pVv56Z06eRJ2dW3J0dqViuNPv3Jd+2AFy9epUO7dqQ2Scdnq6pKVnUn4MHD1i7LEMk1b5KEsHSZDK9cBo2bJjhx/z5558ZOXLkC9e5dOkSJpOJI0eOxLp8+PDhtG7dGnjahmXLlhlcZcLr/XYROtXJT88vd1Kk60I+nr+XXm8X4cM3C1rWyebjyqYxDTnz531qfbSCkj0WM2bRQR5HPrGsM+7dctQrmYVW49ZT86PlZPBMzYKBtazRpHgJCwujkH9hJk2eZu1SXtnDsDAK+vsz4YupsS7PlSs3EyZNYe/BY6zfsoMsWbPwVr1a3Lp1K5ErjZ9MmTIzbORotv26n6279vFG5Sq0bNqIUydPADCwXy/W/rKKed8v5Jf1W7hx/TqtWzSxctWvJn/+Aly4fM0ybdy6w9olvbYd27fxQecubNu5h1VrNvAkMpI369YkLCzM2qXF2bRJ45n39SxGfTaJbXuP8tHw0Uyf/Dlfffn3+0X2nLkY9dkkNv96kGVrt+Drl5WWb9fjzu2k/fqKzeJFC+nftxcffTyU3fsO4e9fmAb1anHz5k1rl/ZK7t27R7XKFbCzt2fpytUcOnqCMePG4+HuYe3SXltS7itT9D+/elnJjRs3LP9euHAhQ4YM4fQ/vtk6Ozvj7Owc26axGjZsGMuWLXtuIIyLiIgIrl27RrZs2Th8+HCsZ0CLFSvGgAEDaNasGSaTiaVLl9KwYcNXPuarCgkJwc3NjVR1JmCyj99ZwiUf1+Hm/Yd0nrrNMu/H/jV5FPGEDhM3AzC/T3Uin5h5d9LmWPfhmtqBK/PbETBhE0t/vQBA7kzuHJ3egkp9f2bfmVd/ot9b8sErbxtfTvYmFv60lAZvNUzwY0WZE+Zl55zKhh8X/Uz9F7QhJCSEjOndWblmA1WqVjP0+AnVrr9kyZiOkaPH8lajJuTw9WbO3O9o+PbTMHnm9O+ULFKAjVt3UbJ0GUOPa29rMnR///TJiGGsXLGcvQcOJ9gxYmMyJVybYnPr1i38MnqxYfM2KlR8I8GOcy8swrB9tW3ekHTpvZkw9UvLvI5tmuPo5MTUWXNj3eZBSAh5/NKzcPkaKlaqalgtHmkcDNvX81QsV5riJUoyafLTL6lms5mc2Xzp3KUbffsNSJBjJmQEGTxoALt3/8rGLdsT7BjPk9CvL2v0VUhICN5p3QgODsbV1fW56yWJM5Y+Pj6Wyc3NDZPJFGNebKFy69atlCpVijRp0uDu7k758uX5448/Yqzz7bffkjVrVtzc3GjRogUPHjywLPv3pfCsWbMycuRI2rZti6urK++99x7ZsmUDoGjRophMJipXrmxZ/8qVK5w4cYLatWuTNWtWABo1aoTJZLI8BpgxYwY5cuTAwcGBPHny8O2338ao0WQyMWPGDOrUqYOTkxPZs2fnp59+esX/yfjb8/sNqvhnJmdGNwAKZU1L2fw+rD905f/1Qe0Sfpy9dp8Vw+rxx7x2bP+sEfVL/93GojnS4WBvy+ajf1rmnbl6n8s3H1A6r0+itUVeLiIigm/mzMLNzY1C/oWtXU6cRUVF8dOiBTwMC6NU6bIcOXyQyMhIKletblknd568+Pr6sW/vHitW+mrOnztL9iyZyJ8nB+3btubK5cvWLslwIcHBAHh4eFq5krgrUaosO7dt4fy5MwCcOH6MfXt+pWr12K/GRERE8N28Obi6upG/oH9ilvraIiIiOHzoIFWr/f2asrGxoWrV6uzbs9uKlb26X1atpFjx4rRq0YwsmbwpU7IYX38129plvbak3ldJIljG15MnT2jYsCGVKlXi2LFj7N69m/feey/GN4Tz58+zbNkyVq1axapVq9i2bRuffvrpC/c7fvx4ChcuzOHDhxk8eDD7/n+/wsaNG7l+/To///yzZd0VK1ZQuXJlXF1d2b9/PwDffPMN169ftzxeunQpPXr0oHfv3vz222+8//77tG/fni1btsQ47uDBg2ncuDFHjx6lVatWtGjRglOnTj23zvDwcEJCQmJMr2r8ksMs3nmOo9NaELKkE3smNmHqiuMs2HYWAC83J1ycHOjTuCgbDl2h/rBVrNhzkQUDalGhQAYAfDxSEx4ZRfC/zhTcvP8Ib/ekf5/lf8GaX1bh7elCWlcnpk6ZxIrV60mXLp21y3qpE78dJ2M6V9K7OdGr+4d8v3AJefPl5+aNGzg4OODu7h5j/fRe3gQF3Yh9Z0lUyVKlmTXnG5avXMMXU6Zz6dJFqld9I8YX4eTObDbTt3cgZcuVp0DBgi/fIIno2rMvbzVuyhsl/fFLl4aab5SiU+duvN2sZYz1Nqz9hZyZPMnm7crs6VNYsGw1adMm/dfXP92+fZuoqCi8vLxjzPfy9o5xVTE5uXjxArO/nEmOnDlZvmotnd7/gD49e/Dd/HnWLu21JPW+srN2Aa8iJCSE4OBg3nzzTXLkyAFAvnwxb3Y3m83MnTsXFxcXANq0acOmTZsYNWrUc/dbtWpVevfubXlsa2sLQNq0afHxiXnmbfny5bz11lsApE+fHgB3d/cY640fP56AgAA+/PBDAHr16sWePXsYP348VapUsazXtGlTOnbsCMDIkSPZsGEDU6ZMYfr06bHWOWbMGIYPH/7cdsRHkwo5aFEpFwETNnLy8j38s6Xls3fLc/1uGN9vOYONzdOwvmrvJaasOAbAsYt3KJ3Xh06187PzxHVD6pCE9UblKvy67zB37txm7tezaftOc7bs3IOXl5e1S3uhXLnzsGPvIUKCg1m+dAkfdGrP6vVbXr5hMlKrdh3Lvwv5+1OyVGny5szKkp8WEdD+XStWZpzAbl04ceI3Nm3dae1S4mXF0p/4efECps2ZT568+Tlx/ChDB/bB2ycDzd5pY1mvfMXKbNixj7t37vD9vK95P+Adftm0k3Tpk/brK6Uzm80UK16CEZ+MBqBI0aKcPPEbc2Z/Seu27axcXcqV5M9YXr582XKPpbOzM6NHj8bT05OAgABq1apF/fr1+eKLL7h+PWbAyZo1qyVUAmTIkOGlN7WWKFEiTjWFhISwbds2GjRo8ML1Tp06Rfny5WPMK1++/DNnI8uWLfvM4xedsRw4cCDBwcGW6cqVK3GqOzajA8o+PWu54zwn/rjLj1vPMmXFMfo2KQrA7ZDHRD6J4tSVezG2O33lHr7pn/7/3rj3kFT2trj96x4gL3cngu4/euXaxDhp0qQhR86clCpdhulffoWdnR3z535l7bJeysHBgRw5clK0WHGGjRxNwUKFmTFtMl4+PkRERHD//v0Y69+6GYS3d/K+/cLd3Z2cuXJz4dw5a5diiMDuXVm9ehXrNmwhc+bM1i4nXkYOGUjXwD40bNyMfAUK0qRFKzp92J0pE8fFWC91mjRky56T4iVLM2Hql9jZ2fHjt3OtU/QrSpcuHba2tty8GXNkhZtBQc+cWEkufDJkIO+/TjrlyZuPK1eS960mSb2vknywzJgxI0eOHLFMH3zw9Mcc33zzDbt376ZcuXIsXLiQ3Llzs2fP3/dW2dvbx9iPyWTCbDa/8Fhp0qSJU01r1qwhf/78+Pr6xrM1xkiVKhWurq4xplfl5GCH+V8/uIgyR2Pz/9sKIp+YOXjuFrkzucdYJ1cmdy7ffHqp7vD520RERlHFP9M/lrvh5+XC3t+tf1penmU2mwkPD7d2GfFmNpuJCA+nSNHi2Nvbs23LJsuys2dOc+XKZUoZ/MOdxBYaGsrFC+fxyZDB2qW8lujoaAK7d2XF8qWsXb+ZrP+/Zz05efzwITY2MT8mbW1tiX7JZ0lyfH05ODhQtFhxtmz++zVlNpvZsmUTpcqUfcGWSVfZsuU5e+ZMjHnnzp7Bzy+LlSoyRlLvqyR/KdzOzo6cOXPGuqxo0aIULVqUgQMHUrZsWX744QfKlDHuQ8XB4ekZuKioqBjz/3kZ/C/29vbPrJcvXz527dpFu3Z/n3LftWsX+fPnj7Henj17aNu2bYzHRYsWNaQNL7N6/x/0b1qMK7dCOXnlHkWyp6X7W/7M3/i7ZZ2JS4/wbZ8a7DxxnW3Hr1KzmC91S2ah1kcrAAh5GMHcjb8ztkM57oaG8+BhBBPeq8Ce32+81i/CE0NoaCjn/3Fm6NLFixw9cgQPT0/8/PysWFnchYaGcuH8323449JFjh09goeHJ55p0/LZp6Oo+2YDfHwycOfObWbNnMa1a1dp1LipFat+uWGDB1GjVm0y+/oR+uABixf+yM7tW/l55Rrc3NxoE9CBj/r3wcPTExcXV/r16kGp0mUN/0V4QhvYvw9169XHzy8L169f45MRw7C1taVp85Yv3TYpC+zWhYULfmDxz8txdnGx3Pvl5uaGk1PyuPe6Ru16TP58LJky+5Inb35+O3aUL6d9QYvWT9/TH4aF8cXnn1Kzzpt4e/tw9+4dvpk9kxvXr1G/YWMrVx9/3QN70alDO4oXL0GJkqWYOnkSD8PCaNuuvbVLeyVdewRS9Y3yjPt0NI2bNOPA/n18PWc2U6d/+fKNk7ik3FdJPljG5uLFi8yaNYsGDRqQMWNGTp8+zdmzZ2OEMyN4eXnh5OTE2rVryZw5M46OjqRJk4Y1a9bQp0+fGOtmzZqVTZs2Ub58eVKlSoWHhwd9+/alWbNmFC1alOrVq7Ny5Up+/vlnNm7cGGPbxYsXU6JECSpUqMD333/Pvn37+OqrxLlM2Wv2Toa+U5IvPqhIejcnrt8N46t1Jxm98KBlnRV7LtFtxnb6NinG553Kc+bqfVp+up5fT/19NrLfV79ijo7mx/41SWVvy8bDV+gxM+mPxXfo4AFqVf/7ftf+fXsB0LpNO2Z/PddKVcXPoYMHqFvz72FNBvR7ep9wqzbt+GLqDE6fPs333zXhzu3beKZNS/HiJVm/eTv58xewVslxcuvWTT54N4AbN67j6uZGgYL+/LxyDVWr1QBgzLgJ2NjY0KZlUyLCw6lavSYTvkh+45Fe/fMq7dq8w907d0iXPj3lylVg647dlnu3k6tZX84AoGa1yjHnz/mGNu0CEr+gV/DJuImMGzWMgb17cOf2Tbx9MtCmfUd69vsIABtbW86dOc3iH7/j7p3beHimpXDR4ixds5k8+fK/ZO9JT9Nmzbl96xYjhg8h6MYN/AsXYfmqtXh7e7984ySoRImSLFj8M0M/HsSYUSPJmjUb4z6fSIt3Wlm7tNeWlPsqSYxj+U9z584lMDDwmXun/ikoKIgPPviAvXv3cufOHTJkyEC7du0YOnQoNjY2sY5jOWnSJCZNmsSlS5eAp8MNFSlShEmTJgFPg2FgYOAzf41nzpw5jBgxgqtXr1KxYkUGDx5MQEDAM/c1rly5kl69enHp0iUyZcpkOc6MGTMYP348V65cIVu2bHz88ce0afP3Td8mk4lp06axbNkytm/fToYMGRg7dizNmjWL8//Z64xjmdQl5jiWiSmhx3u0lpTaroQcx9JaEnscy8Ri5DiWSUlijGNpDUksghgmJb6+4jqOZZILlkld9+7defLkyXN/sR1fRgysrmCZ/KTUAJZS26VgmXwoWCYvKTWCpMTXV1yDZbK8FG5NBQsWfOZX3CIiIiKiYBlv7733nrVLEBEREUmSFCytLKVeBhAREZH/niQ/jqWIiIiIJA8KliIiIiJiCAVLERERETGEgqWIiIiIGELBUkREREQMoWApIiIiIoZQsBQRERERQyhYioiIiIghFCxFRERExBAKliIiIiJiCAVLERERETGEgqWIiIiIGELBUkREREQMoWApIiIiIoZQsBQRERERQyhYioiIiIghFCxFRERExBB21i5AjHP5u3dxdXW1dhmG8ijZ1dolJIh7+6dau4QEER0dbe0S5D/OI42DtUuQeDCZTNYuQQymM5YiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULCUl5o1cwYli/rj5emKl6crlSqUZd3aNdYu66WcU6fisz6NOb16BHd3T2DL3F4Uz+8XY5082bxZPOl9bmz/jNu/fs7O7/ri6+NhWZ4tczoWft6Jy5vHELTjM74b2wEvT5fEbsormTl9GnlyZsXd2ZGK5Uqzf98+a5cULzt3bKfp2w3IlS0zLo62rFyxLMbym0FBvN+xPbmyZcbLw5lG9etw7txZ6xRroPHjPiW1gw19ewdauxRDJPfn4b99NnYM5cuUJL2HC34ZvWjauCFnTp+2dlmGSWn9lVw/v+IiqfZVigyWJpPphdOwYcOsXWKykilzZkaO/pRf9x5k154DVK5SlaZvv8XJEyesXdoLzRjyDlXL5KXDx/Mo0Ww0G3f/zi8zu5ExvRvwNDRu+roXZy7eoFanLyjZbAxjZq/lcXgkAKkdHVg1vQvR0dHUeW8KVdtPxMHeliVfvI/JZLJm015q8aKF9O/bi48+HsrufYfw9y9Mg3q1uHnzprVLi7OHD8MoVKgwn0+a8syy6OhoWjR7m0sXL7Jg8VJ27j2Ir18WGtSpSVhYmBWqNcaBA/v5as4sChXyt3YphkgJz8N/27F9Gx907sK2nXtYtWYDTyIjebNu8n7e/SUl9ldy/fx6maTcV6bo6OhoaxdhtBs3blj+vXDhQoYMGcLpf3yjdHZ2xtnZGXj6ARUVFYWdnV2i1/kyERERODg4vHS9kJAQ3NzcCLoTjKurayJUBhm9PBn96WcEdHg3QY/jUbLrK23nmMqeWzvH07TnLNbu/PsNZNf3/Vi/6yTDp69i/qftiYyM4t3B82PdR7UyeVk+9UMyVOrHg7DHALg6O3J92zje/HAaW/a++lmKe/unvvK2cVGxXGmKlyjJpMlPj2M2m8mZzZfOXbrRt9+ABDvukyhzguzXxdGWHxYtoX6DhgCcPXuGYoXyse/QMfLlLwA8bWOOLBkZOvwTAjp0NPT4tjYJ/0UiNDSUcqWKM2nKNMaOGYV/4cJ89vmkBDteYnw5stbzMDHdunULv4xebNi8jQoV37B2Oa/lv9BfkHifXwnJGn0VEhKCd1o3goNfnDVS5BlLHx8fy+Tm5obJZLI8/v3333FxcWHNmjUUL16cVKlSsXPnTsLDw+nevTteXl44OjpSoUIF9u/fb9nn3LlzcXd3j3GcZcuWxXhzPnr0KFWqVMHFxQVXV1eKFy/OgQMHLMt37txJxYoVcXJywtfXl+7du8f4lps1a1ZGjhxJ27ZtcXV15b333ku4/6RXFBUVxaKFCwgLC6N0mbLWLue57GxtsLOz5XFEZIz5j8MjKVc0ByaTidoVCnD28k1WTOvCH5vGsH1+H+pX/vtMUSoHO6KjowmPePKP7Z9gNkdTrkiORGtLfEVERHD40EGqVqtumWdjY0PVqtXZt2e3FSszTkR4OACpUjla5tnY2JDKIRW7f91lrbJeS8/uXaldt26MfkvO/gvPQ4CQ4GAAPDw8rVzJ6/kv9Fdy+fx6maTeVykyWMbFgAED+PTTTzl16hT+/v7069ePJUuWMG/ePA4dOkTOnDmpVasWd+/ejfM+W7VqRebMmdm/fz8HDx5kwIAB2NvbA3D+/Hlq165N48aNOXbsGAsXLmTnzp107RrzjNz48eMpXLgwhw8fZvDgwbEeJzw8nJCQkBhTQvvt+HHSuTvjliYV3bt8wMKflpIvf/4EP+6rCn0Yzp6jFxjYqQ4Z0rthY2OiRd2SlPbPhk86V7w8nXFJ40if9jXY8OtJ6neeyootR1nweUcqFM8JwL7jlwh7FMGoHm/h5GhPakcHPu3VCDs7W3zSJc6Z4Vdx+/ZtoqKi8PLyjjHfy9s7xtn85Cx3nrz4+voxbMgg7t27R0REBBPGj+Pq1T8JunHd2uXF2+KFCzhy+BAjPhlj7VIM8194HprNZvr2DqRsufIUKFjQ2uW8lpTcX8nt8+tlknpf/WeD5YgRI6hRowY5cuQgVapUzJgxg88++4w6deqQP39+Zs+ejZOTE1999VWc93n58mWqV69O3rx5yZUrF02bNqVw4cIAjBkzhlatWhEYGEiuXLkoV64ckydPZv78+Tx+/Niyj6pVq9K7d29y5MhBjhyxnxUbM2YMbm5ulsnX1/f1/jPiIHeePOw9cITtu/bS6f3OdOrQjlMnTyb4cV9Hh4/nYzLBhfWjCN47iS4tK7Fo7QHM5mhsbJ4+9VdtPc6U77dw7MxVxn+zgdU7TtCpSQUAbt8LpVW/r6j7RkFu7/qcoB2f4ebsxKGTlzGnvDtIkhV7e3u+X/gT586exS9DOrw8nNmxbQs1a9W29G1y8eeVK/TtHcjX877D0dHx5RtIkhHYrQsnTvzG/O8XWLsUeYHk+PmVnCW9GwsTSYkSJSz/Pn/+PJGRkZQvX94yz97enlKlSnHq1Kk477NXr1507NiRb7/9lurVq9O0aVNLODx69CjHjh3j+++/t6wfHR2N2Wzm4sWL5MuX75m6nmfgwIH06tXL8jgkJCTBw6WDgwM5cj49k1eseHEOHtjPtClfMHXGlwl63Ndx8c/b1Oz4BakdHXB1duTG7RC+/bQ9F6/e5va9UCIjozh1IebZrdMXblCuaHbL4017fqdAg+GkdU/DkydmgkMfcXHDaC6tO5jYzYmzdOnSYWtry82bQTHm3wwKwsfHx0pVGa9oseL8uu8QwcHBREREkD59eqpULEvRYsWtXVq8HDp0kJs3b1Ku9N91R0VFsXPHdmZOn8b90MfY2tpascJXk9Kfh4Hdu7J69So2bt5O5syZrV3Oa0vJ/ZUcP79eJKn3VfL6am+gNGnSxGt9Gxsb/v07p8jImPfvDRs2jBMnTlCvXj02b95M/vz5Wbp0KfD0xvz333+fI0eOWKajR49y9uzZGGcm41JXqlSpcHV1jTElNrPZTPj/73NL6h4+juDG7RDcXZyoXi4fq7YeJ/JJFAdP/kHuLDEvJeTK4sXl6/ee2ced+2EEhz6iUsnceHk6s2rb8cQqP94cHBwoWqw4WzZvsswzm81s2bKJUsn4vqLncXNzI3369Jw7d5ZDBw9Q780G1i4pXqpUrcb+Q8fYs/+wZSpWvAQtWrZiz/7DyTJUQsp9HkZHRxPYvSsrli9l7frNZM2WzdolGSKl9ldsktPnV2ySel/9Z89Y/lOOHDlwcHBg165dZMmSBXgaGvfv309gYCAA6dOn58GDB4SFhVnC35EjR57ZV+7cucmdOzc9e/akZcuWfPPNNzRq1IhixYpx8uRJcv7/W1NyMvijgdSqXQdfXz8ePHjAwgU/sH3bVlauXmft0l6oetl8mExw5tJNcvimZ3TPhpy5GMT8FU9vbp44byPfju3AzkPn2HbgDDXL5afuGwWp1ekLyz7aNCjD6Ys3uHUvlNL+2RjftwlTvt/C2T+sP6TDi3QP7EWnDu0oXrwEJUqWYurkSTwMC6Ntu/bWLi3OQkNDuXD+nOXxH5cucezoETw8PPH182PpksWkS5eezL5+nDhxnP69e/Jmg7eoVqOmFauOPxcXl2fuz0uTJg2eaT2T/X17KeF5+G+B3bqwcMEPLP55Oc4uLpZ72tzc3HBycrJyda8nJfZXcv38epmk3FcKljx9E+/cuTN9+/bF09MTPz8/xo0bx8OHD3n33afDEZQuXZrUqVMzaNAgunfvzt69e5k7d65lH48ePaJv3740adKEbNmy8eeff7J//34aN24MQP/+/SlTpgxdu3alY8eOpEmThpMnT7JhwwamTk3YoWde162bN3m3fVtuXL+Om5sbBQv5s3L1OqpVr2Ht0l7IzdmREd0akMnbnbvBD1m+6QhDp63kyZOnQ+Ks2HKMbqMW0LdDTT7v14Qzf9ykZd85/HrkgmUfubN6MaJbAzzdUvPHtbuM+2odk7/bbK0mxVnTZs25fesWI4YPIejGDfwLF2H5qrV4e3u/fOMk4vDBA9StVc3yeGC/3gC807otX875hhs3bjCwXx9u3gzCxycDLVu1of+gj61VrsQiJTwP/23WlzMAqFmtcsz5c76hTbuAxC/IQCmxv5Lr59fLJOW+SpHjWP7T3LlzCQwM5P79+wBs3bqVKlWqcO/evRjDBz1+/Jh+/frx448/8uDBA0qUKMHEiRMpWbKkZZ1ly5bRt29frl69SrVq1WjQoAHvvfce0dHRRERE0K5dO3bt2kVQUBDp0qXj7bff5rPPPrPckL9//34++ugjdu/eTXR0NDly5KB58+YMGjQIeDrcUGBgoOUsaVxZYxzLxPKq41gmdQk9jqW1JNQ4ltaWGONYJrakPsi/iCQtcR3HMsUHy/8CBcvkR8EyeVGwFJH/uv/0AOkiIiIikvgULEVERETEEAqWIiIiImIIBUsRERERMYSCpYiIiIgYQsFSRERERAyhYCkiIiIihlCwFBERERFDKFiKiIiIiCEULEVERETEEAqWIiIiImIIBUsRERERMYSCpYiIiIgYQsFSRERERAyhYCkiIiIihlCwFBERERFDKFiKiIiIiCEULEVERETEEAqWIiIiImIIBUsRERERMYSdtQsQ40SZo4kyR1u7DEPd2z/V2iUkiBzdl1q7hARxdlJDa5eQIK7ee2ztEgyX2dPJ2iUkiLuhEdYuIUF4OjtYuwSRONEZSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWP5f1qxZmTRpkuWxyWRi2bJlVqvHmnbu2E7TRg3ImTUTzqlsWLl8mWVZZGQkgwf1p1Qxf7w8nMmZNROdOrTj+rVr1iv4NezcsZ3GDeuTzS8jTvYmVvyjrUnRnpE1uTq90TPTqOaFAVgcWOGZZZ+2LBJjH4WzuLOwe3lOjq/HifH1+L5rOfJncrVCa15s547tNGnUgBxZM5HmX89DgOXLfqZ+3Vr4ZkhHmlQ2HD16xCp1vsy+3Tt5r3VjyvtnJ5d3ajasXhFj+eTPPqFW+SL4Z01H8dwZadekHkcO7ouxzvttmvBGsdwU8POgXKFs9OnyLkE3ksdrbub0aeTJmRV3Z0cqlivN/n37Xr5REhEVFcW4UcMoUzg3OTK4Ua5oXiZ+Npro6OhY1+/fswuZPFIxe8bkRK7UOMm5v2KT3N7j4yOp9lWKCZYBAQGYTCZMJhMODg7kzJmTESNG8OTJE2uXluw8DAujoL8/E76Y+uyyhw85cvgw/Qd9zM49B/lh4RLOnjlNs8ZvWaHS1xcWFkYh/8JMmjzN2qXESd2xWykyYLVlavHFTgBWHbpqWee7nRdjrPPJ0t8sy1KnsuX7LuW5eu8R9cdto9Hn2wl7/ITvu5bHzsaU6O15kad948/EWJ6Hfy0vV748I0d9msiVxc+jh2HkLVCIoZ9OjHV51uy5GDJ6Aqu27mfBio1k8vWjffMG3Ll9y7JOmfKV+GLWd6zfdZSpX//I5UsX6PZuq8RqwitbvGgh/fv24qOPh7J73yH8/QvToF4tbt68ae3S4mTapPHM/3oWn4ybxNa9Rxk0bDQzJn/O17Oefb9Ys2o5hw7swydDRitUaozk3l+xSW7v8XGVlPvKztoFGKl27dp88803hIeHs3r1arp06YK9vT0DBw60dmmvJCIiAgcHh0Q/bs3adahZu06sy9zc3Fi5Zn2MeZ9PmkKl8qW5cvkyvn5+iVGiYWrVrkOt57Q1KbobGhHjcdeaPly8Gcrus7ct8x5HRHErJDzW7XN6u+Dh7MD4Vae4du8RABNW/86mj6uROW1qLt0KS7ji4+llffNOqzYA/HHpUiJV9GoqVatFpWq1nru8QePmMR4PHDGWxT/M4/TJ3yj3RhUA2n/QzbI8k68f73frTeeA5kRGRmJvb58whRtg8qQJtH+3E20D2gMwZfpM1qz5hXlzv6ZvvwFWru7lDuzbTa269aleqy4Avn5ZWb5kIUcOHoix3vVrV/m4f09++GkVbZs3tEKlxkju/RWb5PYeH1dJua9SzBlLgFSpUuHj40OWLFno3Lkz1atXZ8WKFVSuXJnAwMAY6zZs2JCAgIA47/v48eNUrVoVJycn0qZNy3vvvUdoaCgA69evx9HRkfv378fYpkePHlStWtXyeOfOnVSsWBEnJyd8fX3p3r07YWF/f5BnzZqVkSNH0rZtW1xdXXnvvffi/X9gDSHBwZhMJtzc3a1dyn+Kva2Jt0v5snD3HzHmNyrpy/Fxddn0cTUGvJUfR3tby7LzQaHcDQ2nRbks2NuacLS3oWW5LJy5HsKVOw8TuwnyLxERESz89mtcXN3IW6BQrOvcv3eXFUsWUqxkmSQdKiMiIjh86CBVq1W3zLOxsaFq1ers27PbipXFXYlSZdm5bQvnz50B4MTxY+zb8ytVqv/9RcFsNtP9gw507taTPPnyW6vU15YS+uu/Iqn3VYoKlv/m5ORERETEy1d8ibCwMGrVqoWHhwf79+9n8eLFbNy4ka5duwJQrVo13N3dWbJkiWWbqKgoFi5cSKtWTy9XnT9/ntq1a9O4cWOOHTvGwoUL2blzp2Uffxk/fjyFCxfm8OHDDB48ONZ6wsPDCQkJiTFZy+PHjxn80QCaNm+Jq2vSu08vJatdOCOuTvYs2nPZMm/Z/j/pNvcATSftZOq60zQp5ceU9iUsy8PCn9Bk4g7eLunL+S/e4szEBlTO703rab8SZY79vjFJeJvXr6ZwtvQU9PNg7pdTmLtoJZ5p08VYZ9zIj/HPmo6SeTNz7eoVZsxbZKVq4+b27dtERUXh5eUdY76Xtzc3btywUlXx07VnX956uymVSvmTJX0aalUqRccPuvF2s5aWdaZNGo+dnS3vvt/1BXtK+lJCf/1XJPW+SpHBMjo6mo0bN7Ju3boYZwxf1Q8//MDjx4+ZP38+BQsWpGrVqkydOpVvv/2WoKAgbG1tadGiBT/88INlm02bNnH//n0aN24MwJgxY2jVqhWBgYHkypWLcuXKMXnyZObPn8/jx48t21WtWpXevXuTI0cOcuTIEWs9Y8aMwc3NzTL5+vq+dhtfRWRkJG3faU50dDSTpky3Sg3/ZS3KZWHLySCCgv9+/ny/6xLbTt3k92shLN3/Jz3mHaBukYxkSZcGAEd7G8a3LsaBC3ep/9lWGo7fxulrIcz/sByO9iny7SBZKFO+Eis272Hhqi1UrFKDHp3acOdWzHulOn4YyPJNu/lm0UpsbW3p263jc39EIsZYufQnfl68gGmz57N2614mTf+KmVMnsujHbwE4duQQX305lYnT5mAyJa17lEWsJUV9kqxatQpnZ2ccHR2pU6cOzZs3Z9iwYa+931OnTlG4cGHSpEljmVe+fHnMZjOnT58GoFWrVmzdupVr//919Pfff0+9evVw///l4aNHjzJ37lycnZ0tU61atTCbzVy8eNGy3xIl/j679DwDBw4kODjYMl25cuW12xhfkZGRtHmnOZcv/8GK1et1tjKRZfJ0omJeL37Y9ccL1zt06R4AWdM/fe42LOmLb9rU9Pz2IEf/uM+hS/fo8s1+/NKmpqZ/hgSvW2KXOk0asmTLQdESpRgzaSa2dnYs/mFejHU806YjW45cVKhUjYlfzmPbxnUcOZA0fgUam3Tp0mFra8vNm0Ex5t8MCsLHx8dKVcXPyCED6RrYh7caNyNfgYI0adGKTh92Z+rEcQDs3b2T27duUqpQTvzSpcYvXWr+vPIHIz7uT2n/3FauPn5SQn/9VyT1vkpRwbJKlSocOXKEs2fP8ujRI+bNm0eaNGmwsbF55pt9ZGSkoccuWbIkOXLkYMGCBTx69IilS5daLoMDhIaG8v7773PkyBHLdPToUc6ePRvjzOQ/w+vzpEqVCldX1xhTYvorVJ4/d5aVazaQNm3aRD2+QPOyWbj9IJxNv734skeBzG4A3Ax5elbTycEWczT88+Xw12MbnXFJMsxmMxERsf8ACyD6/7ctvGgda3NwcKBoseJs2bzJMs9sNrNlyyZKlSlrxcri7tGjh5hsYn5M2trYYjabAWjcvBUbdx5k/fb9lsknQ0Y6d+vF90tWWqPkV5YS+uu/Iqn3VYr6VXiaNGnImTPnM/PTp0/P9evXLY+joqL47bffqFKlSpz2my9fPubOnUtYWJgl+O3atQsbGxvy5MljWa9Vq1Z8//33ZM6cGRsbG+rVq2dZVqxYMU6ePBlrfUlNaGgoF86fszz+49JFjh09goeHJz4ZMtC6RVOOHDnET0tXYo6KIuj/93R4eHpa5VfsryM0NJTz5/5u66WLFzl65Agenp74JdFfuJtM0LxMFhbvuRzjvsgs6dLQqGRmNv0WxL2wCPJlcmVYk0LsPnubU1ef3oe7/dRNPm5UkNEtCvP11gvYmKBrzdw8MZv59cyt5x3SKkJDQzn/j+fhpUsXOXr0CJ4envj6+XH37l2uXLlsGUP17JmnVw+8vX2SxLf2v4SFhfLHxfOWx39e/oOTvx3F3d0Tdw9PZkwaS9Vab+Ll7cO9u7f57usvCbpxjTr13wbgyMF9HD9ykOKly+Hm5sHlSxeYNHYEflmzU6REaWs1K066B/aiU4d2FC9eghIlSzF18iQehoXRtl17a5cWJzVq12PyhLFkyuxLnnz5+e3YUWZN/4IWrdoB4OmZFk/PmF+s7ezsSe/tTc5ceWLbZZKW3PsrNsnxPT4uknJfpahg+TxVq1alV69e/PLLL+TIkYMJEyY88wvuF2nVqhVDhw6lXbt2DBs2jFu3btGtWzfatGmDt7d3jPWGDRvGqFGjaNKkCalSpbIs69+/P2XKlKFr16507NiRNGnScPLkSTZs2MDUqbGP02cthw4eoG7Nv+9NHdCvNwCt2rRj0MdD+WXV0wGey5YsGmO71es380alyolWpxEOHTxArep/f8Ho37cXAK3btGP213OtVNWLVczrRea0qZ/5NXhklJkKeb3oWCUnTqlsuX7vEauPXOOLNact65wPCiVgxm561c3Hij5vYI6GE1fu03rqr9x8zhBF1nLo4AHqPOd5OGvON/yyagUfdOpgWd6u9dMfVAz6eAgfDR6WqLW+yG9HDtH67dqWx6OH9gegUfPWjBw3mfPnzrB0UUvu3r2Dh4cnhYoU58flG8iV9+kvjJ2cUrP+lxVM/mwUDx+G4eXlQ8WqNfiiZ/8Y7zFJUdNmzbl96xYjhg8h6MYN/AsXYfmqtTHeN5OyT8ZOZNzoYQzq04M7t2/i7ZOB1gEd6dnvI2uXliCSe3/FJjm+x8dFUu4rU3QKufs7ICCA+/fvx/rXciIjI+nRowcLFy7Ezs6Onj17smfPHtzd3Zk7dy7wdKifwMBAy7BEJpOJpUuX0rBhQ+DpcEM9evRg9+7dpE6dmsaNGzNhwgScnZ1jHKt06dLs27ePzZs3P3NGdP/+/Xz00Ufs3r2b6OhocuTIQfPmzRk0aFCsNcRVSEgIbm5uXLt1P8Xd62ibxAbtNkqO7kutXUKCODupobVLSBDX7j9++UrJTGZPJ2uXkCD+PdZrSuHpnLyuBknKExISgndaN4KDg1+YNVJMsPwvU7BMfhQskxcFy+RDwVIkYcQ1WKaoH++IiIiIiPUoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYgg7axcgxjGbozGbo61dhqFsbUzWLiFBnPuiobVLSBCeNUdZu4QEEbRmkLVLkDhydtTHmog16YyliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQs5Rmff/YplcqXJmN6N7L7+dCyaSPOnjkdY526Navi6mQbYwrs1tlKFb+az8aOoXyZkqT3cMEvoxdNGzfkzOnTL98wicubKxupHWyemQK7d7F2aS/k7OTAZ11qcPrHbtxd258tU9pRPE8Gy/K3KuZh5bh3+HNZLx5t+Rj/HN7P7COVvS0Te9Tmz2W9uLW6Hz8Ob4yXR5rEbMZLff7Zp1QuX5pM6d3I4efDO/96ff3xxyXcnGxjnZYuWWzFyl/NzOnTyJMzK+7OjlQsV5r9+/ZZu6Q4+6/1FSTv/opNSn2fh6TbVwqW/xcQEIDJZMJkMmFvb4+3tzc1atTg66+/xmw2W7u8RLVzxzbe+6Azm7b9yvJV64h8EknDN2sTFhYWY72ADh05e/GqZRoxaqyVKn41O7Zv44POXdi2cw+r1mzgSWQkb9at+Uw7k5sdv+7jwuVrlmnVmvUAvN24qZUre7EZfetRtUR2OoxZTokOs9h44CK/jG9FxnQuAKR2dODX367w8azNz93HuC41qVc2F62G/0zNwPlkSOvCghFNEqsJcbJrxzY6fdCZjdt+Zdn/X1+N/vH6ypzZlzMXr8aYBg0ehrOzMzVq1bFy9fGzeNFC+vftxUcfD2X3vkP4+xemQb1a3Lx509qlxcl/qa8g+fdXbFLq+3xS7itTdHR0tLWLSAoCAgIICgrim2++ISoqiqCgINauXcuYMWOoWLEiK1aswM7O7pntIiMjsbe3t0LFfwsJCcHNzY0/g+7h6upq+P5v37pFdj8f1mzYQvkKbwBPz1gW8i/M2PETDT/eP9nbJd53n1u3buGX0YsNm7dRoeIbCXqsxHzZ9e0dyJrVv3D85BlMJlOCHsuz5qhX2s7RwY5bq/vR9ONFrN1zzjJ/15fvsn7veYZ/vdUyz8/bjdMLulG642yOnQ+yzHdNk4orS3sR8MlSlm7/HYDcvmk5Or8zlT78hn2nrr5ao4CgNYNeeduXuX3rFjn8fFj9j9fXv1UoU5zCRYoybeYcw47rkAivrYrlSlO8REkmTZ4KgNlsJmc2Xzp36UbffgMS5JgRTxLuRIC1+gpSbn8ltsR8n09I1uirkJAQvNO6ERwc/MKsoTOW/5AqVSp8fHzIlCkTxYoVY9CgQSxfvpw1a9Ywd+5cAEwmEzNmzKBBgwakSZOGUaOefpAuX76cYsWK4ejoSPbs2Rk+fDhPnjwBnoaIYcOG4efnR6pUqciYMSPdu3e3HHf69OnkypULR0dHvL29adIkaZ1hCQ4JBsDDwzPG/EULfyBrZi9KF/dn2OBBPHz40BrlGSYkOPZ2JmcREREs+OF72rZrn+Ch8nXY2dpgZ2vD44gnMeY/Dn9CuUK+cdpH0dwZcLC3ZfPBi5Z5Z67c4fKNYEoXyGRovUZ63uvrL4cPHeT40SO0bdchMct6bRERERw+dJCq1apb5tnY2FC1anX27dltxcpeXUrtK0iZ/RWblPA+n9T76tlTcBJD1apVKVy4MD///DMdO3YEYNiwYXz66adMmjQJOzs7duzYQdu2bZk8eTIVK1bk/PnzvPfeewAMHTqUJUuWMHHiRBYsWECBAgW4ceMGR48eBeDAgQN0796db7/9lnLlynH37l127NjxwprCw8MJDw+3PA4JCUmg1j/9FjSgb0/KlC1P/gIFLfObNm+Br18WMmTIyG/HjzH044GcPXOa7xcuSbBaEpLZbKZv70DKlitPgYIFX75BMrFy+TLu379P67YB1i7lhUIfRbDntysMbFOR03/cJuheGM2qFqB0/kycv3ovTvvw8UxDeMQTgsPCY8y/eS8Ub0/nhCj7tZnNZgbG8vr6p2/nfU2evPkoXbZcIlf3em7fvk1UVBReXjHvhfXy9ub06d+tVNWrS8l9BSmvv2KTUt7nk3pfKVjGQd68eTl27Jjl8TvvvEP79u0tjzt06MCAAQNo164dANmzZ2fkyJH069ePoUOHcvnyZXx8fKhevTr29vb4+flRqlQpAC5fvkyaNGl48803cXFxIUuWLBQtWvSF9YwZM4bhw4cnQEuf1TuwK6dOnGDdpu0x5rd/9z3LvwsULIRPhgzUr1ODCxfOkz17jkSpzUiB3bpw4sRvbNq609qlGGre3K+pWasOGTNmtHYpL9VhzAq+7PcmF34K5EmUmSNnrrNo8wmK5s7w8o2Tqb9eX2v/9fr6y6NHj/hp4Y/0HfBxIlcm/6a+Sv5S6vt8UqNL4XEQHR0d4zJiiRIlYiw/evQoI0aMwNnZ2TJ16tSJ69ev8/DhQ5o2bcqjR4/Inj07nTp1YunSpZbL5DVq1CBLlixkz56dNm3a8P3337/0kvLAgQMJDg62TFeuXDG+0UDvwG6sXf0Lq9ZtIlPmzC9ct0TJ0gBcOH/uheslRYHdu7J69SrWbdhC5pe0Mzm5/McfbN60kYAO71q7lDi5eO0eNQO/JW2dseRqNpmKH36DvZ0NF6/H7YzljbthpHKwwy1NqhjzvTycCbobmhAlv5Y+gd1Yt/oXVr7g9bV86U88fPiQlq3aJHJ1ry9dunTY2tpy82ZQjPk3g4Lw8fGxUlWvJqX3FaSs/opNSnqfT+p9pWAZB6dOnSJbtmyWx2nSxBy+JDQ0lOHDh3PkyBHLdPz4cc6ePYujoyO+vr6cPn2a6dOn4+TkxIcffsgbb7xBZGQkLi4uHDp0iB9//JEMGTIwZMgQChcuzP37959bT6pUqXB1dY0xGSk6Opregd1YtWIZK9duJGvWbC/d5vjRIwD4+CSfs0vR0dEEdu/KiuVLWbt+M1mzvbydycn8ed+Q3suLOnXrWbuUeHn4OJIbd0Nxd3akeskcrNp1Jk7bHT5znYjIKKoU/7sfc/l64ufjxt4Tr/7DHaNFR0fTJ46vr2/nfkOdevVJlz59IlZoDAcHB4oWK86WzZss88xmM1u2bKJUmbJWrCzu/it9BSmjv2KTEt/nk3pf6VL4S2zevJnjx4/Ts2fP565TrFgxTp8+Tc6cOZ+7jpOTE/Xr16d+/fp06dKFvHnzcvz4cYoVK4adnR3Vq1enevXqDB06FHd3dzZv3szbb7+dEE16qV6BXflp4Y/8uHgpLs4uBN24AYCrmxtOTk5cuHCexQt/pGatOnimTcuJ48cY0K835Su8QcFC/lap+VUEduvCwgU/sPjn5Ti7uHDj/+10+387kzOz2cy38+fSunXbWEczSIqql8yOCThz5S45Mnkw+oNqnLl8m/lrnt6P7OHiiK+XGxnSPb1fMrdfWgCC7oYSdC+MkLBw5q4+wtjONbgb8ogHD8OZ0K0We3678lq/CDda7/+/vn5YvBTnWF5ffzl//hy7dm7np2WrrFXqa+se2ItOHdpRvHgJSpQsxdTJk3gYFkbbdu1fvnES8F/qK0j+/RWblPo+n5T7Knl84iSS8PBwbty48cxwQ2+++SZt27Z97nZDhgzhzTffxM/PjyZNmmBjY8PRo0f57bff+OSTT5g7dy5RUVGULl2a1KlT89133+Hk5ESWLFlYtWoVFy5c4I033sDDw4PVq1djNpvJkydPIrY8pq9mzQSeDin0TzNmfUWrNgE42DuwdfMmpk/9godhYWTK7MtbDd+m74CPrFHuK5v15QwAalarHHP+nG9o0y4g8Qsy0OZNG7ly+TJtA5LPr1Pd0qRiRMeqZErvwt0Hj1i+/XeGfrWVJ1FPh4+pVy43swc0sKz/7ZCnX7w+mbudUfOe3vfWb9p6zNHR/Di8Cansbdm4/wI9Jq1J/Ma8wF+vr3r/en1N///r6y/fzfuGTJkyU7V6zcQsz1BNmzXn9q1bjBg+hKAbN/AvXITlq9bi7f3s4PZJ0X+pryD591dsUur7fFLuK41j+X8BAQHMmzcPADs7Ozw8PChcuDDvvPMO7dq1w8bm6V0DJpOJpUuX0rBhwxjbr1u3jhEjRnD48GHs7e3JmzcvHTt2pFOnTixbtoxPP/2UU6dOERUVRaFChfjkk0+oVq0aO3fu5OOPP+bYsWM8fvyYXLly8dFHH9GsWbM4157Q41haU2KOY5mYUurL7lXHsUzqEnIcS2tJjHERrSEhx7G0ppTaX5J8xHUcSwXLFEDBMvlJqS87BcvkI6UGFQVLkYShAdJFREREJFEpWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQdtYuQIxjb2eDvZ2+KyQHjyKirF1Cgri+eqC1S0gQ3q2+sXYJhru38F1rl5AgUupry0Hv7ZJM6JkqIiIiIoZQsBQRERERQyhYioiIiIghFCxFRERExBAKliIiIiJiCAVLERERETGEgqWIiIiIGELBUkREREQMoWApIiIiIoZQsBQRERERQyhYioiIiIghFCxFRERExBAKliIiIiJiCAVLERERETGEgqWIiIiIGELBUkREREQMoWApIiIiIoZQsBQRERERQyhYioiIiIghFCxFRERExBAKliIiIiJiCAVLERERETGEgqXEyc4d22ncsD7Z/DLiZG9ixfJl1i7ptX02dgzly5QkvYcLfhm9aNq4IWdOn7Z2Wa9l0ufjSOtsz6B+vSzzgoJu8EHHduTLnhlfLzeqlC/JimU/W7HKuPlq1kzKlyqKn7cHft4e1Kxcng3r1liWv1mrKh6p7WJMPbt9aMWKn2VjY2JIi2Kcmt6Muz+048S0pgxoUuS5609+rxyPlrxL13oFYl3uYGfDnvENebTkXfyzeiZQ1caaOX0aeXJmxd3ZkYrlSrN/3z5rlxQvJQrlwsfN4ZlpQO/uADx+/JgBvbuTL6sP2TN68G7rZty6GWTlql9dcu+v2KTENkHSbZddXFZasWJFnHfYoEGDVy4mKbtx4wajRo3il19+4erVq3h5eVGkSBECAwOpVq2aIcfImjUrgYGBBAYGGrI/I4WFhVHIvzBtAzrQounb1i7HEDu2b+ODzl0oXqIkT548YejgQbxZtyaHj50kTZo01i4v3g4d3M+8r2dToGChGPM/7NSe4OD7fLfoZ9KmTcdPixbwbtuWbNqxB//CRa1U7ctlzJSJoSNGkSNnLqKjo/nxu/m0avY223YfIF/+p8GrXfuODBw8zLKNU+rUVqo2dr0b+tOpVj46TdnOySv3KJ4jHV92rUjIwwimrz4ZY90GpbJQKrcX1+6EPXd/o9uW4vq9hxTOljahSzfE4kUL6d+3F1OmzaRkqdJMnTyJBvVqcfTEaby8vKxdXpys3fIr5qgoy+PfT56gWcM61G/YGIAhA/uwaf0aZs/7ERdXNwb17UGH1s1YuX6btUp+ZSmhv/4tJbYJkna7TNHR0dEvW8nGJm4nNk0mE1H/eAGmFJcuXaJ8+fK4u7szYsQIChUqRGRkJOvWrWPWrFn8/vvvhhznVYNlSEgIbm5uBN0JxtXV1ZBaXsTJ3sTCn5bS4K2GCX6sxHTr1i38MnqxYfM2KlR8I0GP9TD8iaH7Cw0NpWqFUoybOIUJY0dT0L8wo8dNAMDP253PJk2lecvWlvVz+nkzdMRo2gS8a2gdNjYmQ/f3b9kypWfEqLG0CejAm7WqUsi/CGM+m5CgxwTI0HruK223ZGANbgY/ovP0nZZ5P/atyqPwKDpM/jt4ZPRMzfZPG1B/5FqWDqrJ1FUnmPrLiRj7qlk0M2MDStPys00c/qIxpXsv5dilu69UF8C9hcb2fWwqlitN8RIlmTR5KgBms5mc2Xzp3KUbffsNSJBjBj+MTJD9/mXwgN5sWLua3YdP8iAkhAI5MjJ9znxL0Dx75ncqlvTnl407KF6ytGHHdUttb9i+nsca/ZXQUmKbwDrtCgkJwTutG8HBL84acUqMZrM5TlNKDJUAH374ISaTiX379tG4cWNy585NgQIF6NWrF3v27AHg8uXLvPXWWzg7O+Pq6kqzZs0ICvr7csj58+d566238Pb2xtnZmZIlS7Jx40bL8sqVK/PHH3/Qs2dPTCYTJlPCfkDLs0KCgwHw8Egelxj/qV+vbtSoVYfKVZ49e16ydFmWLVnMvbt3MZvN/Lx4IeGPH1O+YiUrVPpqoqKiWLJ4IQ/DwihZuoxl/uKFP5DD15uyJQozfMggHj58aMUqn7Xn9E2qFMpIzgxP34QLZfGkbF4f1h/+07KOyQRfda/ExOXHOXXlfqz78XJzZHrnCrw7eZvhX0oSSkREBIcPHaRqteqWeTY2NlStWp19e3ZbsbJXFxERwZKFP9CydTtMJhPHjhwiMjKSNyr//brLlTsvmXz9OLBvjxUrjb+U2l8prU2Q9NsVp0vhz/P48WMcHR2NqiVJunv3LmvXrmXUqFGxXh51d3fHbDZbQuW2bdt48uQJXbp0oXnz5mzduhV4ekapbt26jBo1ilSpUjF//nzq16/P6dOn8fPz4+eff6Zw4cK89957dOrU6YU1hYeHEx4ebnkcEhJiaJv/i8xmM317B1K2XHkKFCxo7XLi5efFCzl25DAbt8f+Qfb1/B95t9075PTzxs7ODqfUqZn/409kz5EzkSuNvxO/HadWlQo8fvyYNM7OfLvgJ/Lmyw9Ak2Yt8fXzwydDRk78dpzhHw/k3JkzfLvgJytX/bfxS4/imtqeo5ObEGWOxtbGxNAfDrBgx3nLOr0b+vMkKppp/zpD+U+zur7B7HW/c+j8bfzSOydG6a/t9u3bREVF4eXlHWO+l7c3p08bc5Unsa1ZtZzg4Ps0b9UWgJs3b+Dg4ICbu3uM9dKn9+Jm0A0rVPjqUmJ/pcQ2QdJvV7yDZVRUFKNHj2bmzJkEBQVx5swZsmfPzuDBg8maNSvvvpvwl1cS07lz54iOjiZv3rzPXWfTpk0cP36cixcv4uvrC8D8+fMpUKAA+/fvp2TJkhQuXJjChQtbthk5ciRLly5lxYoVdO3aFU9PT2xtbXFxccHHx+eFNY0ZM4bhw4cb00ABILBbF06c+I1NW3e+fOUk5OqfVxjUrxdLVq557pe80SOHEhx8n59XriNturSsXrmCDm1b8su6LeT/1/2YSU2u3HnYvucgIcHBLF+2hA/f68CqdZvJmy8/Ae/+/QWsQMFC+Pj48Fbdmly8cJ5s2XNYseq/NSmXnRYVcxAwaSsnr9zDP1taPmtfmuv3HvL91nMUzZ6WLvUKUK7v8ufu48O6+XFxsuezpUcTsXKJzY/fzqVqjVr4ZMho7VJEkqx4/yp81KhRzJ07l3HjxuHg4GCZX7BgQebMmWNocUlBHG5B5dSpU/j6+lpCJUD+/Plxd3fn1KlTwNMzln369CFfvny4u7vj7OzMqVOnuHz5crxrGjhwIMHBwZbpypUr8d6H/C2we1dWr17Fug1byJw5s7XLiZcjhw9x69ZNqpQvhZebI15ujuzauZ1ZM6bi5ebIxQvnmfPldKZMn02lKlUpWKgw/QYNpkjR4nw1a4a1y38pBwcHsufISZFixRk6YjQFC/kzc9qUWNf96362C+fPJWaJLzS6bUnGLz3G4l0XOHH5Hj9uO8eUlSfo+/bTL5nl8/ng5ebEmS+b82BRex4sak8WLxc+bVeK32c0A6ByoYyUzu1F8IIAHixqz4lpTQHYNe4tZndN2HuBX0e6dOmwtbXl5r9+IX0zKOilX56ToiuX/2D71k20atvBMs/Ly4eIiAiC79+Pse6tWzfx8k5ebUxp/QUps02Q9NsV72A5f/58Zs2aRatWrbC1tbXML1y4sGE/YklKcuXKhclkeu229enTh6VLlzJ69Gh27NjBkSNHKFSoEBEREfHeV6pUqXB1dY0xSfxFR0cT2L0rK5YvZe36zWTNls3aJcXbG5WrsnPvYbb9esAyFSlWnCbNW7Lt1wM8+v89h6Z//QDP1tYWs9lsjZJfi9lsJiIiPNZlx48dAcDbJ0MiVvRiTqnsMP/ry2mU2YzN/++h/mHbOUr2Wkrp3sss07U7YUxccZz6I9cB0Pur3ZT6x/KGo9YD0GbCFob9cCBxGxQPDg4OFC1WnC2bN1nmmc1mtmzZRKkyZa1Y2atZ8P080qX3onqtupZ5/kWKYW9vz45tmy3zzp09zdUrlylRqkxsu0myUlp/QcpsEyT9dsX7UvjVq1fJmfPZe7PMZjORkQn7azxr8PT0pFatWkybNo3u3bs/c5/l/fv3yZcvH1euXOHKlSuWs5YnT57k/v375M//9H6wXbt2ERAQQKNGjYCnZzAvXboUY18ODg5J9gdQoaGhnD/395mgSxcvcvTIETw8PfHz87NiZa8usFsXFi74gcU/L8fZxYUbN57eE+Xm5oaTk5OVq4sbFxcX8hWIeU9omtRp8PRMS74CBYmMjCR7jpz07v4hw0ePxdMzLatXrWDr5o38+NPzL78mBcOHDKJ6zdr4+vrx4MEDflr0Izu3b2PJitVcvHCenxb+SI1adfBMm5bfjh/no/69KVehIgUL+Vu7dIvVBy7Tv3ERrtwK4+SVexTJlpbu9Qsyf/NZAO6GhnM3NGZQjowyE3TvEWevPf0x2ZXbYcDfQxCFPn76PnvhRghX7yatHyv9W/fAXnTq0I7ixUtQomQppk6exMOwMNq2a2/t0uLFbDaz4Pv5NGvZGju7vz82Xd3caNmmPUM/6oe7hycuLq581C+QEqXKGPqL8MSSUvrrn1JimyBptyvewTJ//vzs2LGDLFmyxJj/008/UbRo0h0T73VMmzaN8uXLU6pUKUaMGIG/vz9Pnjxhw4YNzJgxg5MnT1KoUCFatWrFpEmTePLkCR9++CGVKlWiRIkSwNMznz///DP169fHZDIxePDgZ84YZc2ale3bt9OiRQtSpUpFunTprNHcWB06eIBa1atYHvfv+3QA7tZt2jH767lWqur1zPry6aXgmtUqx5w/5xvatAtI/IISgL29PQuWrGDEkI9o1bQRYWGhZMueg2mzvqZGrTrWLu+Fbt+8ReeO7Qm6cR1XNzcKFCzEkhWrqVKtBn/+eYWtWzYxY9pkHoaFkSmzL/UbNqJP/4+sXXYMvebsYWjLYnzxXjnSuzpy/d5DvtpwmtGLD1u7tETRtFlzbt+6xYjhQwi6cQP/wkVYvmot3t7eL984Cdm+ZRNXr1ymZZuAZ5aNGDMeGxsbOrZpTnhEOFWq1uDTCbHfrpHUpZT++qeU2CZI2u2K0ziW/7R8+XLatWvHwIEDGTFiBMOHD+f06dPMnz+fVatWUaNGjYSq1aquX7/OqFGjWLVqFdevXyd9+vQUL16cnj17UrlyZS5fvky3bt3YtGkTNjY21K5dmylTplg6+dKlS3To0IE9e/aQLl06+vfvz+LFiylSpAiTJk0CYM+ePbz//vucPn2a8PDwON3fCYk/jqW8vuQyZEx8JfQ4ltbyquNYJmWJMY6lNST0OJbWkhjjWIq8SFzHsYx3sATYsWMHI0aM4OjRo4SGhlKsWDGGDBlCzZo1X6toeTUKlsmPgmXyomCZfChYiiSMuAbLVxrHsmLFimzYsOGVixMRERGRlOeVB0g/cOCAZSid/PnzU7x4ccOKEhEREZHkJ97B8s8//6Rly5bs2rUL9///tYH79+9Trlw5FixYkOzGARQRERERY8R7HMuOHTsSGRnJqVOnuHv3Lnfv3uXUqVOYzWY6duyYEDWKiIiISDIQ7zOW27Zt49dffyVPnjyWeXny5GHKlClUrFjR0OJEREREJPmI9xlLX1/fWAdCj4qKImNG/f1UERERkf+qeAfLzz77jG7dunHgwN9/SuzAgQP06NGD8ePHG1qciIiIiCQfcboU7uHhgcn09/h0YWFhlC5d2vKnrZ48eYKdnR0dOnSgYcOGCVKoiIiIiCRtcQqWf/1lGBERERGR54lTsGzXrl1C1yEiIiIiydwrD5AO8PjxYyIiImLM058UFBEREflvivePd8LCwujatSteXl6kSZMGDw+PGJOIiIiI/DfFO1j269ePzZs3M2PGDFKlSsWcOXMYPnw4GTNmZP78+QlRo4iIiIgkA/G+FL5y5Urmz59P5cqVad++PRUrViRnzpxkyZKF77//nlatWiVEnSIiIiKSxMX7jOXdu3fJnj078PR+yrt37wJQoUIFtm/fbmx1IiIiIpJsxDtYZs+enYsXLwKQN29eFi1aBDw9k+nu7m5ocSIiIiKSfMQ7WLZv356jR48CMGDAAKZNm4ajoyM9e/akb9++hhcoIiIiIslDvO+x7Nmzp+Xf1atX5/fff+fgwYPkzJkTf39/Q4sTERERkeTjtcaxBMiSJQtZsmQxohYRERERScbiFCwnT54c5x127979lYsR+a9Ineq1v9NJIrq38F1rl2A4j5JdrV1Cgri3f6q1S0gQT6LM1i4hQdjZxvuOvGQhOjra2iUYLq5titOn28SJE+O0M5PJpGApIiIi8h8Vp2D516/ARURERESeJ2WegxYRERGRRKdgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQrxQsd+zYQevWrSlbtixXr14F4Ntvv2Xnzp2GFiciIiIiyUe8g+WSJUuoVasWTk5OHD58mPDwcACCg4MZPXq04QWKiIiISPIQ72D5ySefMHPmTGbPno29vb1lfvny5Tl06JChxYmIiIhI8hHvYHn69GneeOONZ+a7ublx//59I2oSERERkWQo3sHSx8eHc+fOPTN/586dZM+e3ZCiRERERCT5iXew7NSpEz169GDv3r2YTCauXbvG999/T58+fejcuXNC1CgiIiIiyUCc/lb4Pw0YMACz2Uy1atV4+PAhb7zxBqlSpaJPnz5069YtIWoUERERkWQg3sHSZDLx0Ucf0bdvX86dO0doaCj58+fH2dk5IeoTERERkWQi3sHyLw4ODuTPn9/IWkREREQkGYt3sKxSpQomk+m5yzdv3vxaBYmIiIhI8hTvYFmkSJEYjyMjIzly5Ai//fYb7dq1M6ouEREREUlm4h0sJ06cGOv8YcOGERoa+toFiYiIiEjy9Ep/Kzw2rVu35uuvvzZqdyIiIiKSzBgWLHfv3o2jo6NRuxMRERGRZCbewfLtt9+OMTVq1IgyZcrQvn173n///YSoUZKAnTu207hhfbL5ZcTJ3sSK5cusXZJhZk6fRp6cWXF3dqRiudLs37fP2iUZIqW167OxYyhfpiTpPVzwy+hF08YNOXP6tLXLMkxy6y/n1Kn4rE9jTq8ewd3dE9gytxfF8/tZlj86PDXWqWfbagD4ZfBkxtB3OLVqGHd3T+DEiqF8/EFd7O1srdWkeElu/fVvO3dsp+nbDciVLTMujrasXLEsxvLQ0FB6B3YjTw4/0runoUSRgnw1e6Z1in0Ns2bOoGRRf7w8XfHydKVShbKsW7vG2mUZavy4T0ntYEPf3oHWLgV4hWDp5uYWY/L09KRy5cqsXr2aoUOHJkSNyVpAQAANGzaM8/qXLl3CZDJx5MiRBKvpVYSFhVHIvzCTJk+zdimGWrxoIf379uKjj4eye98h/P0L06BeLW7evGnt0l5LSmzXju3b+KBzF7bt3MOqNRt4EhnJm3VrEhYWZu3SXlty7K8ZQ96hapm8dPh4HiWajWbj7t/5ZWY3MqZ3AyBr9YExpveGfofZbGbppiMA5MnmjY3Jhq6fLKBYk1H0+/xnOjapwIhuDazYqrhJjv31bw8fhlGoUGE+nzQl1uUD+/Vm4/p1zPl6PgeOnODDrt3pHdidX1atSORKX0+mzJkZOfpTft17kF17DlC5SlWavv0WJ0+csHZphjhwYD9fzZlFoUL+1i7FwhQdHR0d15WjoqLYtWsXhQoVwsPDIyHrMtytW7cYMmQIv/zyC0FBQXh4eFC4cGGGDBlC+fLlE+y4AQEB3L9/n2XLlsVp/UuXLpEtWzYOHz78zC/wnyckJAQ3NzeC7gTj6ur66sXGkZO9iYU/LaXBWw0T/FgJrWK50hQvUZJJk6cCYDabyZnNl85dutG33wArV/fqUmq7/unWrVv4ZfRiw+ZtVKj4hrXLeS3W6C+Pkl1feVvHVPbc2jmepj1nsXbn3x/Qu77vx/pdJxk+fdUz2yya0Ann1I7U/SD2IAPQs201OjWtSP76w165tnv7p77ytnFljf56EmVOkP0CuDja8sOiJdRv0NAyr1Qxfxo3aUb/QR9b5lUsW5IaNWszZPhIw45tZ2vYHXlxltHLk9GffkZAh3cT7BjxiFavLDQ0lHKlijNpyjTGjhmFf+HCfPb5pAQ7XkhICD7p3AkOfnHWiFeP2traUrNmTe7fv/+69SW6xo0bc/jwYebNm8eZM2dYsWIFlStX5s6dO9YuTawkIiKCw4cOUrVadcs8Gxsbqlatzr49u61Y2etJqe36t5DgYAA8PDytXMnrSY79ZWdrg52dLY8jImPMfxweSbmiOZ5Z38vThdoVCjJv2Yvb4+rsxN2Qh4bWarTk2F+vonSZsqz+ZSXXrl4lOjqa7Vu3cO7sGapWr2Ht0l5ZVFQUixYuICwsjNJlylq7nNfWs3tXatetG+O5mBTE+6tCwYIFuXDhQkLUkmDu37/Pjh07GDt2LFWqVCFLliyUKlWKgQMH0qDB08suEyZMoFChQqRJkwZfX18+/PDDGMMnzZ07F3d3d9atW0e+fPlwdnamdu3aXL9+3bJOVFQUvXr1wt3dnbRp09KvX79nvrWsXbuWChUqWNZ58803OX/+fOL8R0gMt2/fJioqCi8v7xjzvby9uXHjhpWqen0ptV3/ZDab6ds7kLLlylOgYEFrl/NakmN/hT4MZ8/RCwzsVIcM6d2wsTHRom5JSvtnwyfds2cyWtcvzYOHj1m2+chz95ndNx2dW1Tiq592JmDlry859terGD9xMnny5iNPDj88XRxp1KAun0+akiyvDvx2/Djp3J1xS5OK7l0+YOFPS8mXzP9y4OKFCzhy+BAjPhlj7VKeEe9g+cknn9CnTx9WrVrF9evXCQkJiTElRc7Ozjg7O7Ns2TLCw8NjXcfGxobJkydz4sQJ5s2bx+bNm+nXr1+MdR4+fMj48eP59ttv2b59O5cvX6ZPnz6W5Z9//jlz587l66+/ZufOndy9e5elS5fG2EdYWBi9evXiwIEDbNq0CRsbGxo1aoTZHPfLHOHh4cni/10koQR268KJE78x//sF1i7lP6vDx/MxmeDC+lEE751El5aVWLT2AGbzs5cA275VhoVrDhAe8STWfWVM78aKqV34eeNhvln6a0KXLnEwc/pU9u/by8Ily9ixez+jx46nd2A3tmzaaO3S4i13njzsPXCE7bv20un9znTq0I5TJ09au6xX9ueVK/TtHcjX875LkqPxxHuA9Lp16wLQoEGDGH/aMTo6GpPJRFRUlHHVGcTOzo65c+fSqVMnZs6cSbFixahUqRItWrTA3//pDa+BgYGW9bNmzconn3zCBx98wPTp0y3zIyMjmTlzJjlyPL3U07VrV0aMGGFZPmnSJAYOHMjbb78NwMyZM1m3bl2MWho3bhzj8ddff0369Ok5efIkBeN45mXMmDEMHz487v8BEqt06dJha2vLzZtBMebfDArCx8fHSlW9vpTarr8Edu/K6tWr2Lh5O5kzZ7Z2Oa8tufbXxT9vU7PjF6R2dMDV2ZEbt0P49tP2XLx6O8Z65YvmIE82H9oM+CbW/WRI78ba2T3Yc+wCXUb+mBilv5bk2l/x8ejRI4YP+YgfFi2hdp16ABQs5M+xo0eYPOlzqiSxS68v4+DgQI6cOQEoVrw4Bw/sZ9qUL5g640srV/ZqDh06yM2bNylXurhlXlRUFDt3bGfm9GncD32Mra31RleI9xnLLVu2WKbNmzdbpr8eJ1WNGzfm2rVrrFixgtq1a7N161aKFSvG3LlzAdi4cSPVqlUjU6ZMuLi40KZNG+7cucPDh3/f75M6dWpLqATIkCGD5VeAwcHBXL9+ndKlS1uW29nZUaJEiRh1nD17lpYtW5I9e3ZcXV3JmjUrAJcvX45zWwYOHEhwcLBlunLlSnz/O4SnbzZFixVny+ZNlnlms5ktWzZRKhnff5NS2xUdHU1g966sWL6Utes3kzVbNmuXZIjk3l8PH0dw43YI7i5OVC+Xj1Vbj8dY3q5hWQ6evMzxM1ef2TZjejfWze7B4VOXeW/od4nyg4fXldz7Ky4iIyOJjIzExiZmRLC1tY3X1bWkymw2P/fqZXJQpWo19h86xp79hy1TseIlaNGyFXv2H7ZqqIRXOGOZLVs2fH19Y5ythKdv+kk94Dg6OlKjRg1q1KjB4MGD6dixI0OHDqVy5cq8+eabdO7cmVGjRuHp6cnOnTt59913iYiIIHXq1ADY29vH2J/JZIr3G2H9+vXJkiULs2fPJmPGjJjNZgoWLEhERESc95EqVSpSpUoVr+O+rtDQUM6fO2d5fOniRY4eOYKHpyd+fn4v2DJp6x7Yi04d2lG8eAlKlCzF1MmTeBgWRtt27a1d2mtJie0K7NaFhQt+YPHPy3F2cbHcz+bm5oaTk5OVq3s9ybG/qpfNh8kEZy7dJIdvekb3bMiZi0HMX/H3D1hc0jjydo2iDJiw9JntM6Z3Y92cHly+fpeBE5aS3sPZsizozoNEacOrSo799W+hoaFcOP/3e/ofly5x7OgRPDw88fXzo0LFSnw8sD9Ojk74+mVh545t/Pj9t4wZN96KVcff4I8GUqt2HXx9/Xjw4AELF/zA9m1bWbl63cs3TqJcXFyeubc8TZo0eKb1TBL3nL9SsLx+/TpeXl4x5t+9e5ds2bIlyUvhz5M/f36WLVvGwYMHMZvNfP7555ZvaIsWLYrXvtzc3MiQIQN79+7ljTee3tz85MkTDh48SLFixQC4c+cOp0+fZvbs2VSsWBGAnTuT9o3qfzl08AC1qlexPO7ftxcArdu0Y/bXc61U1etr2qw5t2/dYsTwIQTduIF/4SIsX7UWb2/vl2+chKXEds36cgYANatVjjl/zje0aReQ+AUZKDn2l5uzIyO6NSCTtzt3gx+yfNMRhk5byZMnf5/RalqrOCZMLFp74Jntq5bJS04/L3L6eXF+/agYy5yKvvpQSIkhOfbXvx0+eIC6tapZHg/s1xuAd1q35cs53zD32x8YOngQ77Zvw727d/H1y8KQ4Z/wbqcPrFXyK7l18ybvtm/LjevXcXNzo2Ahf1auXke1ZPzr9qQuXuNYwtMfuQQFBZE+ffoY8//44w/y58+fJAcrvnPnDk2bNqVDhw74+/vj4uLCgQMH6NatG/Xq1aN79+4UKVKESZMmUb9+fXbt2sXAgQO5evUq9+7dw93dnblz5xIYGBhjqKVly5bRqFEjy1nLsWPHMm7cOL766ivy5s3LhAkTWLBgAVWrVmXZsmWYzWa8vLyoU6cOQ4cO5fLlywwYMID9+/ezdOlSGjZsmCzGsRSR5O91xrFMyhJjHEtrSMhxLK3JGuNYJobkcFtHfMV1HMs4n7Hs1evpGSqTycTgwYMtl4fh6U2je/fujXMQSmzOzs6ULl2aiRMncv78eSIjI/H19aVTp04MGjQIJycnJkyYwNixYxk4cCBvvPEGY8aMoW3btvE6Tu/evbl+/Trt2rXDxsaGDh060KhRI4L/P96ejY0NCxYsoHv37hQsWJA8efIwefJkKleunACtFhEREUlccT5jWaXK08ug27Zto2zZsjg4OFiWOTg4kDVrVvr06UOuXLkSplJ5Lp2xFJH40hnL5EVnLJMXnbGMgy1btgDQvn17vvjiCwUYEREREYkh3j/e+eab2MciExEREZH/tpR5DlpEREREEp2CpYiIiIgYQsFSRERERAyhYCkiIiIihlCwFBERERFDKFiKiIiIiCEULEVERETEEAqWIiIiImIIBUsRERERMYSCpYiIiIgYQsFSRERERAyhYCkiIiIihlCwFBERERFDKFiKiIiIiCEULEVERETEEAqWIiIiImIIBUsRERERMYSdtQsQ41y6FYbzY1trl2Go7F5prF1Cggh5FGntEhKEg23K/K76MCLK2iUY7t7+qdYuIUFUm7jd2iUkiE0937B2CQnCbI62dgkJwsbGZO0SDGcyxa1NKfNTQEREREQSnYKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWAoH9uzkw3ZNqVwsJwUyObNp7cpn1jl/9ne6BDSjdN6MlMjpRbO6b3Dt6hXL8oAmtSmQyTnGNLx/98RsxivZuWM7jRvWJ5tfRpzsTaxYvszaJb2S69eu8mHHduTN4kMWL1cqlSnKkUMHLcu7f/Au3q4OMaYWjd60YsUv99XsmZQvVRQ/Hw/8fDyoWaU8G9atsSwPunGD999tR55smciU3pVK5UqyYtnPVqz45aKiohg3ahhlCucmRwY3yhXNy8TPRhMdHR1jvbOnTxHQ8m3y+qUnZyYP6lYtx9Url61U9euZOX0aeXJmxd3ZkYrlSrN/3z5rl/RC6ZwdGFIvD6u7lmVzYHnmBxQnr7ezZXmHcln4oUMJNvYoz5puZZnUrBD5M7jE2MdP75ViV983YkytS/kmdlNeSXLrr3/buWM7TRo1IEfWTKRJZcPKf72nR0dHM3L4ELJnyUhat9TUq12Dc2fPWqfY15RU+8rO2gWkBCaTiaVLl9KwYcNYl2/dupUqVapw79493N3dE7W2uHj08CF58hfk7RZt6NHxnWeWX750gTYNa/J2y7Z07fMRaZxdOHfmFKlSpYqxXpNWAXTtM9jy2MnJKcFrf11hYWEU8i9M24AOtGj6trXLeSX3792jfs3KlK9YiR+WrCRtunRcPH/umeda1eq1+GLGbMtjB4dUJGUZM2Vi6IhR5MiZi+joaH78fj6tmr/Ntl8PkC9/ATp3CiA4+D4/LF5K2rTp+GnRj7Rv04ItO/biX6SotcuP1bRJ45n/9SwmTZ9Dnnz5OXr4EL26dsLV1ZV33+8KwKWL52lYpyotWwfQZ+AQnF1cOHPqJKkcHa1cffwtXrSQ/n17MWXaTEqWKs3UyZNoUK8WR0+cxsvLy9rlPcMllR0z3ynCocv36f3Tb9x/FImvhxMPwp9Y1rly7yETNp3j2v3HpLKzoXmJTExsWojms/dz/1GkZb3ZOy+x4th1y+OHEVGJ2pZXkdz6KzZP39P9aRvQnpbNGj+zfMLn45gxbQqz5swlS7ZsjBw2hLferM3BoydwTEavsaTcV6bof39VlmfcunWLIUOG8MsvvxAUFISHhweFCxdmyJAhlC9f/qXBMiIigrt37+Lt7Y3JZHrucQICArh//z7Lli2LV30hISG4ubmx9/drOLu4xmvbfyuQyZnJX/1Itdr1LfP6dG6HnZ09n06Z89ztAprUJk9+fwaOGPdax/+37F5pDN3fizjZm1j401IavNUwwY8V8o8PoNc1cugg9u/ZzYp1W567TvcP3iU4+D7zflxi2HFj42CbsBdBsmVOz4hRY2nTrgOZvdwYP2kaLd5pbVme3deLYSPH0DbgXUOPa1QoaNu8Iem9vPl8ypeWeZ3aNsfR0Ykps+YC0LlDa+zs7Zny5TeGHPN5PJ0dEnT/ABXLlaZ4iZJMmjwVALPZTM5svnTu0o2+/QYkyDGrTdz+ytt+8EZW/DO58eGPR+O8TWoHWzb0KE/3hcc4ePk+8PSM5aKDV1l08Oor1/Jvm3q+Ydi+nsca/WU2J1wESZPKhgWLfqb+/9/To6OjyZE1E9179CKwVx8AgoODyebrw5dzvqFpsxaGHdvG5vmf9UawRl+FhITgndaN4OBgXF2fnzV0KTwOGjduzOHDh5k3bx5nzpxhxYoVVK5cmTt37sRpewcHB3x8fJ4bKqOiojCbzUaWbBiz2cy2TevIkj0nnd55i4r+WWnxZuVYL5f/snQh5Qv68VbVkkwcM5RHjx5aoeL/nvWrV1G4aHE6tm1B/uyZqFahJN/O/eqZ9X7duZ382TNRrlgB+vXsyt04Pn+TgqioKJYsXsjDsDBKlioDQKnSZVm6ZBH37t7FbDazZPFCwh8/pkLFSlau9vlKlCrLzm1bOH/uDAAnjh9j355fqVK9FvD09bZpwxqy58zFO43r4Z8rM29Wr8DaX5Zbs+xXEhERweFDB6larbplno2NDVWrVmffnt1WrOz5KuRIy+83HjCyQT5WfViGb9oWo76/z3PXt7Mx8VbhDDx4/IRzt0JjLGtd2pfVXcvyTdtivFMyM7YJmzNeW3Lsr/i6dPEiQTduUOUfbXRzc6NkqdLsTUZtTOp9pUvhL3H//n127NjB1q1bqVTp6QdWlixZKFWqVIz1bt++TaNGjVi3bh2ZMmXi888/p0GDBsCzl8Lnzp1LYGAg8+fPZ8CAAZw5c4bWrVszb948AEsA3bJlC5UrV36mpvDwcMLDwy2PQ0JCEqLpANy5fYuHYaF8NW0C3foNodegkezcuoEeHd/hm8WrKVm2IgB1GzYjY2Y/vLx9OHPqBBNGDebS+TN8MefHBKtNnvrj0kXmffUl73ftQY/e/Tl86CAf9+uJg709zVu1BaBK9ZrUbdAQvyxZuXTxAmOGD6Zl4/qs3rQDW1tbK7fg+U78dpxaVSvw+PFj0jg78+2PP5E3X34Avvl2AR3atiS7rxd2dnY4pU7Ntz/+RPYcOa1c9fN17dmX0AchVCrlj62tLVFRUfT/eARvN2sJwO1bNwkLDWXapM/o99EwBg0bzdaN6+nYpjmLV66nbPmEP2tllNu3bxMVFYWXl3eM+V7e3pw+/buVqnqxjO5ONCzixMIDfzJ/z2Xy+bjQs2oOnkRFs+ZEkGW9ctk9GV4/H472NtwJjSBw8TGCH/19uXzxoaucCQol5PETCmV05f03spLW2YEpWy5Yo1lxkhz7K76Cgm4APNtGL29uBgXFtkmSlNT7SsHyJZydnXF2dmbZsmWUKVPmmfsK/zJ8+HDGjRvHZ599xpQpU2jVqhV//PEHnp6esa7/8OFDxo4dy5w5c0ibNi0ZMmTg0aNHhISE8M03Ty+BPW/bMWPGMHz4cGMa+BLR/z+TWqVWPdq99/QesHwF/TlyYC8Lv/3KEiybte5g2SZ3voKk8/Lm3eZvcvnSBfyyZk+UWv+rzGYzhYsW56OhnwBQqHBRfj95gnlfz7YEy0ZNmlvWz1+gEPkLFKJ04bzs2rGNNypXtUrdcZErdx627z5ISEgwy5cu4cP3O7Bq7Wby5svPqJFDCQ6+z7JV6/BMm47Vq5bTvm1LVq/fSoGChaxdeqxWLv2JnxcvYNrs+eTOm58Tx48ydFAfvDNkoFnLNpYrF7Xq1Oe9D3sAULBQYQ7s2823X89OVsEyObIxwe83HvDljksAnL0ZRvZ0aWhYJEOMYHnoyn0C5h3E3cme+v4ZGFk/P52+P8z9h09vcVl44O9L4OdvhREZZaZfzVzM3H6RyCjdfSYpmy6Fv4SdnR1z585l3rx5uLu7U758eQYNGsSxY8dirBcQEEDLli3JmTMno0ePJjQ0lH0v+IVWZGQk06dPp1y5cuTJkwdXV1ecnJxIlSoVPj4++Pj44OAQ+z1QAwcOJDg42DJduXIl1vWM4O6ZFjs7O3LkyhtjfvZcebh+9c/nbudfrCTw9Ic/krC8fTKQO2++GPNy58nL1T+f/7zImi07adOm49KF8wld3mtxcHAge46cFClanKEjRlOwoD8zp0/h4oXzzJ45jSkz5lCpSjUK+Rem/6AhFC1anDmzZli77OcaOWQgXQP78FbjZuQrUJAmLVrR6cPuTJ349N5kz7TpsLOzI9e/+jNX7hf3Z1KULl06bG1tuXkz5pmgm0FB+Pg8//KyNd0JjeDSnZi38Fy6+xBvl5gnFB5Hmrl6/zEnrj/g03VniIqOpn6h57fp5PUH2NnakME16f44JDn2V3x5ez9txzNtvBmEl7d3bJskSUm9rxQs46Bx48Zcu3aNFStWULt2bbZu3UqxYsWYO3euZR1/f3/Lv9OkSYOrqys3b9587j4dHBxibBMfqVKlwtXVNcaUUBwcHChYuDiXzsccjuGPC2fJmPn5w2f8fuJp8E7vZf0neUpXsnRZzp89E2Pe+XNnyezr99xtrl39k7t37+CVBN6E4sNsNhMRHs7Dh08//G1sYr6F2draWs6yJ0WPHj3E9O+abWwtZyodHBwoXLTEM/154fyL+zMpcnBwoGix4mzZvMkyz2w2s2XLJkqVKWvFyp7v2NUQ/DxTx5jn5+HEjZDHL9zOxgT2L/jhWi4vZ6LM0dx7aNyP9oyWHPsrvrJmy4a3jw9b/9HGkJAQ9u/bS+lk1Mak3le6FB5Hjo6O1KhRgxo1ajB48GA6duzI0KFDCQgIAMDe3j7G+iaT6YU/yHFycnrhL8QTU1hYKJcv/n1m8c/Lf3Dqt2O4eXiQMZMv7Tv3oHfndhQvU55S5d5g59YNbN2whm9+ejqm4OVLF/hl6SLeqFYLdw9PTp/6jXHDBlCiTHny5C9orWbFSWhoKOfPnbM8vnTxIkePHMHD0xM/v+TxQf5+lx68WeMNJo3/lLcaNeHQwf18O3cO47+YDkBYaCjjP/2Eeg0a4eXtzaWLFxg5ZCDZsuegSrWaVq7++YYPGUT1mrXx9fXjwYMH/LToR3bu2MaS5avJnScv2XPkpGf3zowcPQ5Pz7T8snI5WzZvZMFPSfeHLjVq12PyhLFkyuxLnnz5+e3YUWZN/4IWrdpZ1uncvRedO7SiTLkKlKtYia0b17Nh7S/8tHKDFSt/Nd0De9GpQzuKFy9BiZKlmDp5Eg/Dwmjbrr21S4vVwoN/8uU7RWhb2pdNp2+RP4MLDfwzMG790y/WjvY2tCvjx85zd7gdFoG7kz1vF81IOudUbDl9C4ACGV0okMGVQ5fv8zAiioIZXeleJTvrT96MMWxRUpTc+is2oaGhnD//j/f0Sxc5evQInh6e+Pr50aVbD8Z9OoqcOXNZhhvKkCEj9Rs0tF7RryAp95WC5SvKnz9/vIcFehkHBweiohJ/rLMTRw/Rvmldy+Nxw58OVfBW01aMnvQl1es0YOinXzB7yueMGdKXrNlzMWn29xQvVQ4Ae3sH9uzcwrdzpvPoURg+GTJTve5bfNCjX6K3Jb4OHTxArepVLI/79+0FQOs27Zj99VwrVRU/RYuX4JvvFzNq+MdMGDsKvyxZGfnp5zRp/nRMUhtbW07+dpyFP3xLSPB9fDJkpFLV6vT/eNhz7xlOCm7fukXnTu0JunEdV1c3ChQsxJLlq6lSrQYAi35eyfAhg2jZpCFhYaFky56T6bO+oWbtui/Zs/V8MnYi40YPY1CfHty5fRNvnwy0DuhIz34fWdap8+ZbfDphKlMmjmPIgF5kz5mb2fMXUKpseStW/mqaNmvO7Vu3GDF8CEE3buBfuAjLV63FO4ledvz9RigDl53kgzeyEVAuC9eDH/PFlvOsP/X06pPZHE0Wz9TUecsbNyd7Qh5Hcur6Az788QgX/38JPfJJNNXzpqdDuSw42Jq4FvyYhQevsuDA828dSiqSW3/F5tDBA9Sp+fd94wP69QagVZt2zJrzDb169+NhWBhdu7xP8P37lC1XgWUr1ySrMSwhafeVxrF8iTt37tC0aVM6dOiAv78/Li4uHDhwgG7dulGvXj2++uqrWMexdHd3Z9KkSQQEBDz3V+H379+PcazRo0fz5Zdfsn79etKmTYubm9szZ0JjY+Q4lklNYo5jmZiMHMcyKUnocSytJTkMbh1fiTGOpTW8zjiWSVlijGNpDQk5jqU1JfQ4ltYQ13EsdcbyJZydnSldujQTJ07k/PnzREZG4uvrS6dOnRg0aJChx+rUqRNbt26lRIkShIaGPne4IREREZGkSGcsUwCdsUx+dMYyedEZy+RDZyyTF52xTD70l3dEREREJFEpWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQpujo6GhrFyGvJyQkBDc3N4LuBOPq6mrtckQkGXgSZbZ2CQnCzjZlni/xKN/X2iUkiHu7PrN2CQki4knKe32FhITg6+1BcPCLs0bKfAWKiIiISKJTsBQRERERQyhYioiIiIghFCxFRERExBAKliIiIiJiCAVLERERETGEgqWIiIiIGELBUkREREQMoWApIiIiIoZQsBQRERERQyhYioiIiIghFCxFRERExBAKliIiIiJiCAVLERERETGEgqWIiIiIGELBUkREREQMoWApIiIiIoZQsBQRERERQyhYioiIiIghFCxFRERExBAKliIiIiJiCAVLibOZ06eRJ2dW3J0dqViuNPv37bN2SYZQu5IXtSvpGT/uUyqVL02GdG5k8/WhRdNGnDlz2rL87t279OnZnaKF8pHePQ35cmalb68eBAcHW7Hq15Pc+ss5dSo+69mA08sGcXfbaLbM7kLxfJljXXdy/7d5tPczuraoEGN+Tt90LPosgCvrhhG0eSSbZn3IG8VzJEb5ryW59dW/zZk1g3Ili5DZy53MXu5Ur1SeDevWWJY/fvyY3oFdyZopPRnTudK6RRNuBgVZrV4FS4NcunQJk8nEkSNHrF1Kgli8aCH9+/bio4+HsnvfIfz9C9OgXi1u3rxp7dJei9qVvKhdSdOuHdvo9H5nNm//lRW/rCMyMpKG9WoTFhYGwI3r17h+/RqjPh3H3oPHmDn7azasX0eXDzpaufJXkxz7a8agJlQtlYsOw36kRKvP2bj3DL9MfY+M6V1jrNegUkFKFczCtZvPhv6fJ3TAztaGOl2+pFy7Lzh29jo/f94Bb0+XxGpGvCXHvvq3TJkyM2zkaLb9up+tu/bxRuUqtGzaiFMnTwAwsF8v1v6yinnfL+SX9Vu4cf06rVs0sVq9pujo6GirHd0gt27dYsiQIfzyyy8EBQXh4eFB4cKFGTJkCOXLl0+UGi5dukS2bNk4fPgwRYoUSZRj/iUkJAQ3NzeC7gTj6ur68g1eQcVypSleoiSTJk8FwGw2kzObL527dKNvvwEJcszEoHYlL2qXcZ5EmRNkv/D0PTm7rw9rNmyhQsU3Yl1n6ZLFdGzflqC7D7CzszPs2Ha2CX++xBr95VG+7ytv65jKjlubP6Fpv7ms3fW7Zf6ueT1Y/+vvDP9yHQAZ07uy/etu1O8+h6UTOjB14Q6mLtgJQFq31Py5fjjV35/OriMXgadnQW9t+YS6XWexZf/ZV6rt3q7PXrldcWGt94yIJwn3+gLIkjEdI0eP5a1GTcjh682cud/R8O2nYfLM6d8pWaQAG7fuomTpMoYdMyQkBF9vD4KDX5w1UsQZy8aNG3P48GHmzZvHmTNnWLFiBZUrV+bOnTvWLu21REZGWrsEACIiIjh86CBVq1W3zLOxsaFq1ers27PbipW9HrUreVG7ko+QkKdnuzw9PZ+7TnBwMC6uroaGysSQHPvLztYWOztbHoc/iTH/cXgk5QpnA8BkMvHVsJZM/G4bpy4+exn1TvBDTl+6yTt1ipPa0R5bWxs6NipD0N0HHP79z0RpR3wlx756maioKH5atICHYWGUKl2WI4cPEhkZSeWqf7cxd568+Pr6sW/vHqvUmOyD5f3799mxYwdjx46lSpUqZMmShVKlSjFw4EAaNGgAPH3BzJkzh0aNGpE6dWpy5crFihUrYuznt99+o06dOjg7O+Pt7U2bNm24ffu2ZfnatWupUKEC7u7upE2bljfffJPz588/t66oqCg6dOhA3rx5uXz5MgDLly+nWLFiODo6kj17doYPH86TJ3+/0E0mEzNmzKBBgwakSZOGUaNGxbrv8PBwQkJCYkwJ6fbt20RFReHl5R1jvpe3Nzdu3EjQYycktSt5UbuSB7PZTP8+PSlTtjz5CxSMdZ3bt28zbswo2nfolMjVvb7k2F+hD8PZc+wSAztUJ0M6V2xsTLSoXYzSBbPgk+7pZezebSvzJMrMtIU7n7ufet1mUThPRm5t+YT720fTvWVF3uoxh/sPHiVWU+IlOfbV85z47TgZ07mS3s2JXt0/5PuFS8ibLz83b9zAwcEBd3f3GOun9/ImKMg6bUz2wdLZ2RlnZ2eWLVtGeHj4c9cbPnw4zZo149ixY9StW5dWrVpx9+5d4Gk4rVq1KkWLFuXAgQOsXbuWoKAgmjVrZtk+LCyMXr16ceDAATZt2oSNjQ2NGjXCbH72dHd4eDhNmzblyJEj7NixAz8/P3bs2EHbtm3p0aMHJ0+e5Msvv2Tu3LnPhMdhw4bRqFEjjh8/TocOHWJty5gxY3Bzc7NMvr6+r/JfJyJiuF49unLqxAnmfvtDrMtDQkJo2qg+efPlY9DgoYlc3X9Xh2ELMJngwi+DCd4xhi7NyrNo/RHM5miK5s1El+YVeW/EwhfuY2LfRty6F0r192dQscMUVmw7wZLP2+OTNuneY5lS5Mqdhx17D7Fp+246dPqADzq15/dTJ61dVqyS1zWIWNjZ2TF37lw6derEzJkzKVasGJUqVaJFixb4+/tb1gsICKBly5YAjB49msmTJ7Nv3z5q167N1KlTKVq0KKNHj7as//XXX+Pr68uZM2fInTs3jRs3jnHcr7/+mvTp03Py5EkKFvz7W3loaCj16tUjPDycLVu24ObmBjwNtgMGDKBdu3YAZM+enZEjR9KvXz+GDv37zfWdd96hffv2L2zzwIED6dWrl+VxSEhIgobLdOnSYWtry82bMS+P3AwKwsfHJ8GOm9DUruRF7Ur6egd2Y+3qX1i7cSuZMj/7i+MHDx7QqEFdnJ1d+GHRz9jb21uhyteTXPvr4tU71Ow8k9SO9rimceTGnQd8+0krLl67S/ki2fDySMOZ5YMs69vZ2fJp9/p0bV6RvI3GULlETuqWz0eGGkN4EPb0JE7gZ0upVjoXreuVYPz8LdZq2nMl176KjYODAzly5ASgaLHiHDp4gBnTJvN2k2ZERERw//79GGctb90MwtvbOm1M9mcs4ek9lteuXWPFihXUrl2brVu3UqxYMebOnWtZ558hM02aNLi6ulp+FXb06FG2bNliOfvp7OxM3rx5ASyXu8+ePUvLli3Jnj07rq6uZM2aFcBymfsvLVu2JCwsjPXr11tC5V/HGDFiRIxjdOrUievXr/Pw4UPLeiVKlHhpe1OlSoWrq2uMKSE5ODhQtFhxtmzeZJlnNpvZsmUTpcqUTdBjJyS1K3lRu5Ku6Ohoegd2Y+WKZaxat5Gs2bI9s05ISAhvvVkbB3sHFi5ZhqOjoxUqfX3Jvb8ePo7kxp0HuLs4Ub1MHlZtP8EPqw9RstUESreZaJmu3Qxm4ndbqd9jDgCpHZ9+CTCbY/7e12yOxmQyJXo74iK599WLmM1mIsLDKVK0OPb29mzb8ncbz545zZUrlyll4A934iPZn7H8i6OjIzVq1KBGjRoMHjyYjh07MnToUAICAgCe+WZsMpksl7FDQ0OpX78+Y8eOfWa/GTJkAKB+/fpkyZKF2bNnkzFjRsxmMwULFiQiIiLG+nXr1uW7775j9+7dVK1a1TI/NDSU4cOH8/bbb8da+1/SpEnzav8BCax7YC86dWhH8eIlKFGyFFMnT+JhWBht27347GpSp3YlL2pX0tSrR1cWL/yRBYuX4uLsQtD/719zdXPDycnJEiofPXzInK/n8yAkhAf/vzc8Xfr02NraWrP8eEuO/VW9dG5MJhNn/rhJDt90jO72Jmf+uMn8lft5EmXmbsjDGOtHPoki6O4Dzl6+BcDe439w78Ej5gxtweivNvDocSQdGpYma0ZP1v56yhpNipPk2Ff/NmzwIGrUqk1mXz9CHzxg8cIf2bl9Kz+vXIObmxttAjrwUf8+eHh64uLiSr9ePShVuqyhvwiPjxQTLP8tf/78LFu2LE7rFitWjCVLlpA1a9ZYf6F4584dTp8+zezZs6lYsSIAO3fGfoNz586dKViwIA0aNOCXX36hUqVKlmOcPn2anDlzvlqDrKxps+bcvnWLEcOHEHTjBv6Fi7B81Vq8vb1fvnESpnYlL2pX0jRn1kwA6tSsGmP+jFlf0bptAEcPH+LAvr0AFC6QO8Y6v/1+niz/vwKUXCTH/nJzdmTEh3XJ5OXG3ZCHLN9ynKEz1sZ52Kk7wQ95q8cchnWuzZpp72NvZ8upC0E07TuX42evJ3D1ry459tW/3bp1kw/eDeDGjeu4urlRoKA/P69cQ9VqNQAYM24CNjY2tGnZlIjwcKpWr8mEL6ZZrd5kP47lnTt3aNq0KR06dMDf3x8XFxcOHDhAt27dqFevHl999RUmk4mlS5fSsGFDy3bu7u5MmjSJgIAArl27RpEiRahUqRL9+vXD09OTc+fOsWDBAubMmYPJZMLLy4s6deowdOhQLl++zIABA9i/f79lv/8ex3LSpEkMHjyYNWvWUKFCBdatW8ebb77Jxx9/TJMmTbCxseHo0aP89ttvfPLJJwCx1hkXiTGOpYikLAk5jqU1JcY4ltbwOuNYJmUJPY6ltST0OJbWENdxLJP9GUtnZ2dKly7NxIkTOX/+PJGRkfj6+tKpUycGDRr08h0AGTNmZNeuXfTv35+aNWsSHh5OlixZqF27NjY2NphMJhYsWED37t0pWLAgefLkYfLkyVSuXPm5+wwMDMRsNlO3bl3Wrl1LrVq1WLVqFSNGjGDs2LHY29uTN29eOnZMnn95QkREROTfkv0ZS9EZSxGJP52xTF50xjJ5+S+fsUyZr0ARERERSXQKliIiIiJiCAVLERERETGEgqWIiIiIGELBUkREREQMoWApIiIiIoZQsBQRERERQyhYioiIiIghFCxFRERExBAKliIiIiJiCAVLERERETGEgqWIiIiIGELBUkREREQMoWApIiIiIoZQsBQRERERQyhYioiIiIghFCxFRERExBAKliIiIiJiCAVLERERETGEnbULEJGUw2yOtnYJCcLGxmTtEgxnZ5syzyuk1OfgvV2fWbuEBOFRsqu1S0gQ9/ZPtXYJhnOwi9t7Rsp8ZxERERGRRKdgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxERERExhIKliIiIiBhCwVJEREREDKFgKSIiIiKGULAUEREREUMoWIqIiIiIIRQsRURERMQQCpYiIiIiYggFSxER+V97dx4X0/7/Afx12ktKoRJFC0JEypqtoqw3su9ZspN9p+zL1yVb3Ox7dq7LtWYLyVK2iGTLkrUUbTPv3x/95txGuFyjmcn7+Xj0YM45M/P+zJk5530+57MwxphCcGLJGGOMMcYUghNLxhhjjDGmEJxYMsYYY4wxheDEkjHGGGOMKQQnlowxxhhjTCE4sWSMMcYYYwrBiSX7V3+sCIFrtSowMzWCmakRGrjVxuG/Dyk7LIU4e+Y0fH1awsbaEvraAvbv26vskH5YQd1fEokE0wIno2I5WxQ1NoCjgz3mzJoOIlJ2aD9k/tzZqFvLFcVNCsPa0gztfH0Qd+eOssP6YQW1XADw/v17jB4ZAIeyZVDU2ADuDeri8qUoZYf1Q9TxuGFooIv5o3xx5+A0vDn/O8LXjUD1itZy25S3MceORf3w/PR8vDq3AGc3jYaVhYm43qZUMYQt6ItHJ2bjxZn52DS3F8xMC+d3Uf6TFcuXobx9GRQx1EO9OjURdfGiskMCwIkl+wYlS5XC9FlzcC7yMiIuXELDRu5o1+Y33Lp5U9mh/bC0tDRUruKERYuXKTsUhSmo++v3/83Fqj9W4PdFS3Al5hamz5qDhQvmI2TZEmWH9kPOnD6F/gMG4dTZCzhw6Ciys7LQolkTpKWlKTu0H1JQywUAg/r3RfjxY1i1ZgMuXr4GD8/GaNG0MZ4mJio7tP9MHY8bIVM6w72WA3pNWg+X9rNw7Pxt/LViCCyLGwPISRqPrxmBuITn8OobDNf2szE79G+kZ2QBAAz0dHBg+SAQEZr6L4G730LoaGtiV3A/CIKgzKL9qx3bwzB29AhMnDQV5y9eQZUqTmjV3AtJSUnKDg0CqfvlvpL07NkT69evFx+bmprC1dUV8+bNQ5UqVfI1lpSUFBgbG+PF62QYGRnly3tampli1pz56Nmrd768X37Q1xYQtnMPWv3mo+xQFC6/9pdU+vMOJ74+LWFmboaQlavFZZ07tIWevj7WrNv4094XADQ08u8k8/LlS1hbmuHoiVNwq1c/3973Z8uvcv3M7yAAfPz4EeZFjbB95154N2suLq9bywVNvLwxNWjGT3nf/PwOyuTHccPEdfB/ep6erjZenv0f2g3/A3+f/Sf5jdg8BkcibiFo+QFsmOOHrCwJek/e8NnX8KjlgH1LB6JEgzF4n5YOADAy1MOzU/PQYuAyhEf+9xr2t1FL//Nzv0W9OjVR3cUVixbnvI9UKoW9jRUGDBqC0WPG/ZT3TElJgXlRYyQnfz3X4BrLH+Dt7Y1nz57h2bNnOH78OLS0tNCiRQtlh/VTSSQSbA/bhrS0NNSsVVvZ4bB/UZD2V63atXEy/ATuxsUBAK5di8G5c2fRxMtbyZEpVkpyMgDAxMRUyZEoVkEpV3Z2NiQSCXT19OSW6+vr4/y5CCVFpVjqcNzQ0tSAlpYm0jOz5JanZ2ShTjU7CIIAb7dKuPsoCfuXDcLD47NxesMotGz4T8WPro4WiAgZmdm5np8NqZRQp6pdvpXle2VmZuLqlctw9/AUl2loaMDd3RMXL5xXYmT/H4uyA1Bnurq6sLCwgIWFBapWrYpx48bh8ePHePnyJQBg7NixKFeuHAwMDGBra4vJkycjK0v+RzBjxgyYmZmhcOHC6NOnD8aNG4eqVat+9X0zMjKQkpIi9/ez3bh+HcWKGMK4kC6GDuqPsJ17UKFixZ/+vuy/KYj7a+TocWjbrgOqVakA40I6qFPDGYOGDEPHTl2UHZrCSKVSjB4ZgNp16qKSo6Oyw1GYglSuwoULo2at2pg7ewaePX0KiUSCrVs2IfLCeTx/9kzZ4f0QdTpupH7IwIWY+xjftylKFDeGhoaAjs1cUbOKDSyKGcHM1BCFC+lhlF9jHD13Cy0HLMX+8BhsW9AHbtXtAQAXrz9A2sdMzBz2G/T1tGGgp4M5I1pDS0sTFsXy5+7ff/Hq1StIJBKYmZnLLTczN8fz58+VFNU/OLFUkNTUVGzatAn29vYoWrQogJwD0Lp163Dr1i0EBwcjNDQUCxcuFJ+zefNmzJw5E3PnzsXly5dhbW2NkJCQf32v2bNnw9jYWPyzsrL6aeWSKVe+PCIvReN0RCT69huAvr16IPbWrZ/+vuy/KYj7a9fO7QjbtgVrN2xGRORl/LF6HRYvXIBNG9f/+5PVRMCQQbh58wY2bN6m7FAUqqCVa9WaDSAi2NuUgklhPYQsW4J2HTpBQ0O9T6nqdtzoNWkDBAG4f2QmkiMXYVCnBtj+9yVIpSTuiwMnr2PJ5nBci0vE/9YexcEzN9G3rRsA4NXbVHQZsxrN6jviVcQCvDgzH8aG+rhy6xGk3ErwP+M2lv9Rz549sWnTJuj9/+2QtLQ0lChRAgcOHICzs/Nnn/O///0P27Ztw6VLlwAAtWrVgouLC5Yu/acthpubG1JTUxEdHf3F987IyEBGRob4OCUlBVZWVvnaxrKZlydsbe2wNGRlvrxffijIbSzza3/9zPZt5eysMXLUWPQbMEhcNnf2DGzbshlXr8f+tPcF8qd9W8DQwTjw5z4cO3EaZWxsfvr75Zf8LtfPbmOZW1paGlJSUlCiRAl079IRqamp2L3vwE95L2W0scyP48Z/bWOZm4GeDowM9fD8VQo2zvFDIQNddBgRitfnfsfMPw5i7qrD4rYzhv6GOtVs4e63UO41ihYphOxsKZJTPyLh6Cws3ngcCzcc/88x/cw2lpmZmTA1MsCWsJ1y56s+fj2QnPwOO3bv+ynvy20s80GjRo0QHR2N6OhoXLx4EV5eXmjatCkePnwIAAgLC0PdunVhYWEBQ0NDTJo0CY8ePRKff+fOHdSoUUPuNT99/Dm6urowMjKS+8tvUqlULrllqq0g7K+PHz7kqRHS0NSEVCpVUkSKQUQIGDoY+/ftwd9HThSYpLKgliu3QoUKoUSJEnj79i2OHT2MFi1bKTskhVKX48aH9Ew8f5WCIoX14VmnAg6cvI6sbAku33qIcqXlbxeXLW2GR8/e5nmN1+/SkJz6EQ1cy8HM1BAHTl3Pr/C/m46ODqo5V0f4iX8SX6lUivDw46ihAm1itZQdgDorVKgQ7O3txcerVq2CsbExQkND0bx5c3Tp0gVBQUHw8vKCsbExtm3bhgULFigx4v9m8sTx8PJuCisra7x//x5h27bg9KmT+PPg4X9/sopLTU1F/L174uMHCQmIiY6GiakprK2tv/JM1VVQ91fT5i0xb+4sWFlZo0LFSoiJuYqlwQvRrYefskP7IQFDBiFs2xbs2L0PhoULi22kjI2Noa+vr+To/ruCWi4AOHrkMIgI5cqVR3z8PUwcPwblyjuo9XdRHY8bnrUrQBCAuAdJsLMqjlnDfRCX8AIb9ud0YFm4/hg2zu2Fs1fu4dSlODSpUxHN6jvCq2+w+BrdWtXCnYTnePk2FTWr2OB/o9tiyeZw3H2o/GF7vmZowAj07dUD1au7wMW1BpYuXoQPaWnorgLfQU4sFUgQBGhoaODjx484d+4cSpcujYkTJ4rrZTWZMuXLl0dUVBS6d+8uLouKUr1Bdl8mJaG3X3c8f/YMxsbGcKxcBX8ePAwPz8bKDu2HXbl8CV6ejcTHY0ePAAB07dYDoWvWKSmqH1NQ99eChYsxLXAyAoYNwsukJJQoYYleffwxfuIUZYf2Q/5YmdOuuolHQ/nlq9aiW4+e+R+QghTUcgFASkoypk6agMTEJzAxNYWPTxtMnTYT2trayg7tP1PH44axoR6mDWmFkuZF8Cb5A/Ydj8bUZX8iOzvnLsb+8GsYMnMbRvdqggVj2iLuYRI6jV6Fc9H3xdcoV8YM04a0gqmxAR4+fYN5qw9j8aYTyirSN2vXvgNevXyJaUFT8OL5c1Rxqop9B/6Gubn5vz/5J+M2lv9Rz5498eLFC6xduxYA8PbtWyxduhQhISE4ceIEUlJS4Ovri40bN8LV1RV//fUXgoKCIJFI8O7dOwA5nXf69u2LkJAQ1KlTB2FhYZg/fz5sbW1x9erVb45FGeNYMvY5+dm+LT8po30b+2/4O6heFNHGUhX97HEsleFb21hyjeUP+Pvvv1GiRAkAOT3AHRwcsGPHDjRs2BAAMHz4cAwePBgZGRlo3rw5Jk+ejMDAQPH5Xbp0wf379zFq1Cikp6ejffv26NmzJy6qyLRMjDHGGGPfg2ssVUzjxo1hYWGBjRu/fSYRrrFkqoJri5iy8XdQvXCNpfrgGks18OHDB6xYsQJeXl7Q1NTE1q1bcezYMRw9elTZoTHGGGOMfTdOLJVIEAQcPHgQM2fORHp6OsqXL49du3bB09Pz35/MGGOMMaZiOLFUIn19fRw7dkzZYTDGGGOMKQQPkM4YY4wxxhSCE0vGGGOMMaYQnFgyxhhjjDGF4MSSMcYYY4wpBCeWjDHGGGNMITixZIwxxhhjCsGJJWOMMcYYUwhOLBljjDHGmEJwYskYY4wxxhSCE0vGGGOMMaYQnFgyxhhjjDGF4MSSMcYYY4wpBCeWjDHGGGNMITixZIwxxhhjCsGJJWOMMcYYUwhOLBljjDHGmEJoKTsAxljBoaEhKDsE9o2kUlJ2CD9FQf0OpmdKlB3CT/E2aqmyQ/gpTOqMVHYICkeSjG/ajmssGWOMMcaYQnBiyRhjjDHGFIITS8YYY4wxphCcWDLGGGOMMYXgxJIxxhhjjCkEJ5aMMcYYY0whOLFkjDHGGGMKwYklY4wxxhhTCE4sGWOMMcaYQnBiyRhjjDHGFIITS8YYY4wxphCcWDLGGGOMMYXgxJIxxhhjjCkEJ5aMMcYYY0whOLFkjDHGGGMKwYklY4wxxhhTCE4sGWOMMcaYQnBiyRhjjDHGFIITS8YYY4wxphCcWDLGGGOMMYXgxJIxxhhjjCkEJ5bsm61Yvgzl7cugiKEe6tWpiaiLF5UdkkJwudTH2TOn4evTEjbWltDXFrB/315lh6Qw6r6/zp45jbatW8GuTEkU0tXAn5/sGyLC9KApsC1tiaLGBmju3Rj37t5VTrAKoM77a3XoCtStUQ3WFiawtjBBk0Z1cfTwIXH9i+fP0a93D5S3KYmSxY3QoI4r9u/drcSIf4y67StDA13MH/4b7uybiDen5yB81RBUr2Alrv9jSkd8vLhA7m9fcF+51xjj54HwVUPw+vRsPDs+I1/jLxCJZWBgIKpWrfrF9evWrUORIkV+6D169uwJHx+fH3oNdbZjexjGjh6BiZOm4vzFK6hSxQmtmnshKSlJ2aH9EC6XeklLS0PlKk5YtHiZskNRqIKwv3L2TRUsDF762fW/L5iHkGVLsHhJCE6evYBChQrhtxbeSE9Pz+dIf5y67y/LkiUxddpMhJ+9iBNnIlGvQSN06dAGsbduAgAG9O2Je3fvYMuOPYi4GI2Wv/nAr1tHXIu+quTIv5867quQie3hXrMcegVuhUvn+TgWeQd/LesHy+JG4jaHz8WiTNNA8a/HpE1yr6GjpYXdx2MQuutcfoevGonl+fPnoampiebNmys7FKVr2LAhAgIClB1GHosX/Q6/3n3RvacfKlSsiCXLV0DfwADr161Rdmg/hMulXry8myJw2gz85tNa2aEoVEHYX17eTTE1aAZa/ZZ33xARli0JxphxE9Gi1W+oXLkKQtesx7NnT/Hn/r35H+wPUvf91bRZSzTxbgY7+7KwL1sOkwNnoJChIS5FRQIALkaeR9/+g1HdpQbK2Nhi1NiJMC5SBNHRV5Qc+fdTt32lp6sFn0aVMXHJAURcvY/7T15jZugRxD9+hb6+dcTtMrMkePH6vfj37v1HudeZEXoYS7aexo17z/O7CKqRWK5evRpDhgzB6dOn8fTpU2WHwz6RmZmJq1cuw93DU1ymoaEBd3dPXLxwXomR/RguF1MFv8L+epCQgBfPn6NRrjIaGxvDtUZNRKpZGQva/pJIJNi1Iwwf0tLgWqMWAKBGzdrYs2s73r55A6lUil07wpCRng63eg2UHO33Ucd9paWpCS0tTaRnZsstT8/IRh0nG/FxPWc7PPw7EDE7xiJ4rC9MjQ3yO9QvUnpimZqairCwMAwYMADNmzfHunXr5NafPHkSgiDg+PHjcHFxgYGBAerUqYM7d+588TXj4+Nha2uLwYMHg4g+u82+ffvg7OwMPT092NraIigoCNnZ2Z/dNregoCAUL14cRkZG6N+/PzIzM8V1GRkZGDp0KMzMzKCnpwc3NzdERUXJPf/UqVOoUaMGdHV1UaJECYwbN0583549e+LUqVMIDg6GIAgQBAEPHjzIE0NGRgZSUlLk/n6mV69eQSKRwMzMXG65mbk5nj/P/6shReFyMVXwK+yvFy9yypGnjGbmSHrxQhkh/WcFZX/dvHEdpcyMYW5igBHDBmLj1p1wqFARALB24zZkZ2XB1soM5iYGGD50ADZu3QlbO3slR/191HFfpX7IwIVrDzC+lydKFDOChoaAjt7OqFm5NCyK5dwKP3r+NvoEbkWzQSswaelfqFfNFvsW9YWGhqDk6HMoPbHcvn07HBwcUL58eXTt2hVr1qz5bDI4ceJELFiwAJcuXYKWlhZ69er12de7du0a3Nzc0LlzZyxduhSCkPeDPnPmDLp3745hw4bh1q1bWLlyJdatW4eZM2d+Ndbjx48jNjYWJ0+exNatW7F7924EBQWJ68eMGYNdu3Zh/fr1uHLlCuzt7eHl5YU3b94AABITE9GsWTO4uroiJiYGISEhWL16NWbMyGlYGxwcjNq1a6Nv37549uwZnj17BisrqzxxzJ49G8bGxuLf57ZhjDHGvqRsufI4ff4yjp06h159+mFgv164HXsLADBz+lQkJ7/D3gOHceJMJAYNCYBf9064eeO6kqP+NfSaugWCIOD+walIPjsXgzrUw/YjVyGV5uRGO45G468zN3Ez/jn+PHUDbUashksla9SvrhqJv9ITy9WrV6Nr164AAG9vbyQnJ+PUqVN5tps5cyYaNGiAihUrYty4cTh37lyeRt/nzp1Dw4YNMWrUKDFZ+5ygoCCMGzcOPXr0gK2tLRo3bozp06dj5cqVX41VR0cHa9asQaVKldC8eXNMmzYNixcvhlQqRVpaGkJCQjB//nw0bdoUFStWRGhoKPT19bF69WoAwPLly2FlZYWlS5fCwcEBPj4+CAoKwoIFCyCVSmFsbAwdHR0YGBjAwsICFhYW0NTUzBPH+PHjkZycLP49fvz4Xz/nH1GsWDFoamoiKUm+ZiHpxQtYWFj81Pf+mbhcTBX8CvvL3DynHHnKmPQCZubmn3uKyioo+0tHRwe2dvaoWq06pk6bBUfHKlixfAkS7scjdMUyLAlZhQaNPFC5ihPGTpiCatWqY9UfIcoO+7uo675KSHyNJv2Xo2j98Sjbcjrq+QVDW0sTCYmvP7v9g6dv8PJtKuxKFc3nSD9PqYnlnTt3cPHiRXTq1AkAoKWlhQ4dOoiJWG5VqlQR/1+iRAkAkOvV9ejRIzRu3BhTpkzByJEjv/q+MTExmDZtGgwNDcU/WS3hhw8fvvg8JycnGBj8046hdu3aSE1NxePHjxEfH4+srCzUrVtXXK+trY0aNWogNjYWABAbG4vatWvL1aLWrVsXqampePLkyVdjzk1XVxdGRkZyfz+Tjo4OqjlXR/iJ4+IyqVSK8PDjqFGr9k9975+Jy8VUwa+wv8rY2MDcwgInc5UxJSUFURcjUVPNylhQ95dUKkVmRoZ4DtTQkE8PNDU1QVKpMkL7z9R9X31Iz8Tz1+9RpLA+PGuVx4HTNz+7XUkzYxQ1NsDzV+/zOcLP01Lmm69evRrZ2dmwtLQUlxERdHV1sXTpUhgbG4vLtbW1xf/LEjNpri958eLFYWlpia1bt6JXr15fTbZSU1MRFBSENm3a5Fmnp6f3Q2UqqIYGjEDfXj1QvboLXFxrYOniRfiQlobuPfyUHdoP4XKpl9TUVMTfuyc+fpCQgJjoaJiYmsLa2lqJkf2YgrC/UlNTER+fa988SEBMTDRMTUxhZW2NQUOGYd6cmbC3L4vSNjaYHjgFJUpYomUrH+UF/R+p+/4KmjIBnk28YWVljffv32Pn9q04e+YUdu07iHLlHWBrZ4/hQwdg+qx5MDUtir/+3IfwE8ewbec+ZYf+3dRxX3nWKg8BQNyjl7ArVQyzhrZA3IMkbPjzIgrp62BinybYG34Nz1+/h22pYpg5uDnin7zG0Qu3xdewMi8CEyMDWFkUgaaGgCplc/Ks+CevkPYx8wvvrBhKSyyzs7OxYcMGLFiwAE2aNJFb5+Pjg61bt6J///7f/Hr6+vo4cOAAmjVrBi8vLxw5cgSFCxf+7LbOzs64c+cO7O2/rz1CTEwMPn78CH19fQDAhQsXYGhoCCsrKxQrVgw6OjqIiIhA6dKlAQBZWVmIiooShw+qUKECdu3aBSISk+OIiAgULlwYpUqVApBzhSWRSL4rrvzQrn0HvHr5EtOCpuDF8+eo4lQV+w78DXM1u431KS6Xerly+RK8PBuJj8eOHgEA6NqtB0LXrFNSVD+uIOyvK5cvoWkTd/HxuDE5d466dOuBP1atxYiRY/AhLQ2DB/VD8rt3qF3HDXv/PKSWF/Pqvr9evXyJAX398OL5MxgZGaOSY2Xs2ncQjTwaAwC27/4TQVMmoFNbH6SlpcLG1h7L/1iLJt7NlBz591PHfWVsqIdpA5uhpFkRvEn5gH0nrmFqyCFkS6TQkkrhWNYSXZq7oEhhfTx7mYJjkXcwbeXfyMz6J3eY3M8b3Vq4io8jN+f8Hpv0X44zV+J/avwCfanb9E+2d+9edOjQAUlJSXI1kwAwduxYnDhxAlFRUTh58iQaNWqEt2/fioOcR0dHo1q1akhISECZMmUQGBiIvXv3Ijo6GqmpqWjatCmICH///TcMDQ2xbt06BAQE4N27dwCAw4cPo0WLFpg0aRLatm0LDQ0NxMTE4MaNG19sm9mzZ0/s2rULLVu2xKRJk/DgwQP06tULfn5+mD17NgAgICAAO3bswOrVq2FtbY158+Zh//79iI+Ph4mJCRITE1GuXDn4+flh8ODBuHPnDvr06YNBgwYhMDAQAODv74/o6Ghs374dhoaGMDU1zXNL4lMpKSkwNjbGi9fJP/22OGOsYJB1BChoVKVnrKKlZ6pehYMi6Onk7UdQEJjU+XqTPHVEkgxkXFmG5OSv5xpKa2O5evVqeHp65kkqAcDX1xeXLl3CtWvXvvt1DQ0NcejQIRARmjdvjrS0tDzbeHl54cCBAzhy5AhcXV1Rq1YtLFy4UKxp/BIPDw+ULVsW9evXR4cOHdCqVSsxIQSAOXPmwNfXF926dYOzszPu3buHw4cPw8TEBABQsmRJHDx4EBcvXoSTkxP69++P3r17Y9KkSeJrjBo1CpqamqhYsSKKFy+OR48effdnwBhjjDGmDEqrsWSKwzWWjLHvxTWW6oVrLNUL11gyxhhjjDH2gzixZIwxxhhjCsGJJWOMMcYYUwhOLBljjDHGmEJwYskYY4wxxhSCE0vGGGOMMaYQnFgyxhhjjDGF4MSSMcYYY4wpBCeWjDHGGGNMITixZIwxxhhjCsGJJWOMMcYYUwhOLBljjDHGmEJwYskYY4wxxhSCE0vGGGOMMaYQnFgyxhhjjDGF4MSSMcYYY4wpBCeWjDHGGGNMITixZIwxxhhjCqGl7ADYjyMiAMD7lBQlR8IYUxdSKSk7hJ9CQ0NQdgg/RXqmRNkh/BSZOprKDuGnIEmGskNQOJJk5vxLXz92cGJZALx//x4AYG9jpeRIGGOMMVaQvX//HsbGxl9cL9C/pZ5M5UmlUjx9+hSFCxeGIPzcq/WUlBRYWVnh8ePHMDIy+qnvlZ+4XOqjIJYJ4HKpGy6XeuFy/Tgiwvv372FpaQkNjS+3pOQaywJAQ0MDpUqVytf3NDIyKlA/Thkul/ooiGUCuFzqhsulXrhcP+ZrNZUy3HmHMcYYY4wpBCeWjDHGGGNMITixZN9FV1cXU6dOha6urrJDUSgul/ooiGUCuFzqhsulXrhc+Yc77zDGGGOMMYXgGkvGGGOMMaYQnFgyxhhjjDGF4MSSMcYYY4wpBCeWjDHGGGNMITixZIwxxhhjCsGJJWPImaoKAB49eqTkSNivjIgglUqVHYbCXLlyRdkhMFbg5B7MRxWPF5xYMgZAEATs3bsX7dq1w82bN5Udzk/BI4uproyMDAA538PHjx8rORrFOH/+PFxcXLBs2TJlh/LTSCQSZYegcLLjxKlTp3D06FElR8M+RxAEPH/+HLGxsdDQ0MDOnTuxe/duZYcl4sSSfRNVvCpSBNlB9PHjxwgODkafPn1QqVIlJUelGLKy3bp1CxKJBIIgKDki9jnx8fGYOHEi3r59ix07dsDGxgbx8fHKDuuH1a5dGzNmzMCIESMQEhKi7HAUQnYcfP/+PQBAU1MT0dHReP78uTLDUgjZ8UIQBISHh6NZs2ZIS0tDdna2kiP7cZ+ev9T9Ijs5ORmdO3fGwoULERwcjPbt2yMtLU3ZYYm0lB0AU31SqRQaGjnXIH/++ScSExNRpkwZlC1bFnZ2dkqO7scIgoAzZ85g3759MDY2xm+//abskBRGEATs378fI0aMwIYNG1CnTh1lh/TDiAiCIODChQtIS0uDh4eHskP6YdevX8fKlStx8+ZNnDx5EmvXroWdnZ1YVnU2YcIEaGpqYvDgwQCAAQMGKDmiH6OhoYGnT5/C398fgwYNQmZmJlq3bo3IyEhYWFgoO7wfIvuuPX36FJcuXcKECRPg4+Oj9kkYAPH8FR0djapVq6r978rY2Bi9e/dGYGAgVq1ahVmzZqFbt26qc8wgxr7RmDFjyNDQkKpUqUJFihSh+vXr0/r165Ud1g/7/fffSRAEMjY2psuXLys7nB8mlUqJiOjp06fUunVrWr58uZIjUgxZuXbt2kWWlpbUv39/evLkiZKjUozx48eTIAjk7u4uVyZZmdXdnDlzSENDo0B8F69evUq+vr5UqVIl0tXVpS1bthARkUQiUXJkP0YqlVJCQgIJgkCmpqY0f/58ZYf0w3LvkzNnzpCZmZm4v9SV7Jjw4MEDKlOmDFlZWdGgQYPoxo0bebZRFr4Vzr5JVFQUjh07hsOHDyMmJgZHjx5FuXLlEBwcjLCwMGWH90OGDx+O0NBQaGhoYM2aNXjw4IGyQ/ohgiDg9OnTGDVqFN69e4dGjRoBUP/bP4Ig4OjRo+jatSumT5+OhQsXomTJksoO64fI2ujp6elh+PDhuHv3LmbOnInbt28DyCmzuu83ABg7dixmzpyJwYMHq+1tcfr/jlVVq1ZFixYtcOvWLVhbW6Nw4cIAcmrF1LXJEP1/TVeZMmWwcOFCvH37FlevXsWrV6+UHdp/lvtO26ZNm7BlyxakpaVh7Nix2Lx5s5Kj++9kNZJmZmY4ceIEpk+fjnPnziE4OFjsH6D0WkulprVMLcyZM4d69epFXbp0kbsCvHHjBvn6+lLHjh0pKytL6VdJ30IWY1xcHF28eJGOHTsmrlu8eDFZWlrShAkT6OHDh8oKUSFOnDhBxYoVIw0NDdq1a5e4XB320ZdkZGTQgAEDaOTIkURE9O7dO4qKiqKAgACaMmUK3b59W8kR/ritW7dSqVKlqH///nLliYmJUWJU3072/bp58yadOXOGDh06JLd+1qxZal9zuW3bNmrZsiWtWrWKunTpQm5ubhQWFiauV6eaS9n++jTmBQsWkCAINGfOHEpOTlZGaAozduxYsrCwoJCQEJozZw7Vq1ePypYtS2vXrlV2aN9Ftq8ePnxIt27dovj4eHFdaGgoVatWjfr16yfWXE6fPp327NmjjFCJE0v2ryZPnkyCIJCNjQ09evRIbt2WLVtIS0uL7t+/r6Tovl3uW6kODg7k4OBAFStWJGdnZ3r8+DEREQUHB1PJkiVp8uTJlJCQoMRof1xERASVKVOGWrRoQZcuXRKXq3Ny2alTJ6pWrRolJCRQt27dyN3dnerUqUPFixenNm3aKDu8byL7/KOiomjTpk20dOlSevjwoXhy37p1K1lZWdGAAQPo9OnTNG3aNBIEgd68eaPS+04W2+7du8nKyooqVapEhQsXptatW1NsbKy43axZs0hXV5cWLFigrFC/m6xs9+7dI0NDQ1qyZAkR5ezD9u3bk5ubG+3YsUPc/vDhw/T8+XOlxPqtZGU6ceIEDRs2jHr16kWTJk0S18+fP58EQaC5c+eqbXJ57949cnBwkEuwoqOjqW/fvmRra0tbt25VXnDfIfe5q0KFClSiRAmyt7enVq1aUUZGBhHlJJc1atSghg0bUocOHUgQBKU17eLEksn50tV2cHAwCYJA06ZNo1evXonLIyMjycHBge7cuZNfIf6QU6dOkaGhIYWGhlJ6ejqdOnWKBEGgFStWiNssXryY9PT0aPr06ZSVlaXEaL+N7KBz7do12rt3L23evJmSkpKIKKe8NjY21LlzZ7py5Yoyw/xusnJdunRJrFk+d+4cVatWjXR1daldu3a0e/duIspJZqpWrUpv3rxRWrzfIvcJwtTUlNzd3cnc3Jw8PT1p7dq1lJ2dTURE27dvpwoVKpCjoyNZWVnRxYsXlRn2V+VOdo8cOUJFihSh0NBQIsq5uBEEgZo3b07Xr18Xt5s0aRIVLVqU3r59m9/h/menT5+mdevW0fjx4+WWX7p0iTp06EBubm60cOFCCgwMJEEQ1KL97+7du8nQ0JAGDRpEo0ePJnt7e6patSplZmYSUU7NpY6ODgUGBlJKSoqSo/1+jx8/JhMTE9qwYYPc8qtXr1KZMmWoRIkStHHjRiVF933Cw8NJX1+fQkJC6Pjx47Rz506ytbWlWrVqiceNsLAwGjZsGLVp00bu95bfOLFkotxJ5f379+nGjRtySaSs5mTkyJF08uRJunHjBnl7e5Orq6va3P5ZsGABDRw4kIhyyli6dGkaMGBAnu2WL19OcXFx+R3ef7Zz504qXbo0OTs7U+3atcnQ0JCOHz9OREQnT54kGxsb6tatm0onKLnlTsCsrKxo1KhRlJiYSFlZWZSWlpanHEOHDqWmTZtSWlqaMsL9LidPniRzc3NatWoVERFdv36dtLS0qEaNGrRixQrxt3T9+nW6cOGCWJuuanbv3k23bt0iopz9lZKSQkOHDqXAwEAiyvl92draUpcuXcjS0pIaNWpEMTEx4r7NfWxRNQEBATRv3jzxcXJyMnl7e5MgCNS6dWsiIrmLzqtXr5K/vz85ODhQpUqV5O4QqKrExERydHSkxYsXExFRQkICWVhYUJ8+feS2CwoKIhMTE5XeX0T/HDNy//vq1Stq3LgxjRw5Mk/87dq1o/r165OrqysdPXo03+P9XkFBQXnuysTHx1OZMmWoXbt2cstlFwbKwoklIyL5Wofx48dT5cqVSU9Pj+rWrSsmYkREM2bMIEEQSBAE6tGjB7Vp00b8EqtDctm1a1fy8/Oj169fk5WVFfn7+4tlX7dunVr2hIyMjCQTExOxlujmzZskCALNmjVL3CcnT54kIyMj6tu3L6Wnpysz3G/2999/k76+Pq1cuZI+fvz42W0uXbpEI0eOpCJFiqhFO8SsrCyaM2cOBQQEEFHOiUGWfHl7e5OtrS2tWrVKrIFQVdeuXSMnJydq3bq1eAGWkZFBe/bsobi4OHrz5g1Vr16devfuTUREBw4cIEEQyM3NjW7evKnM0P9VdnY2rVq1Kk8N/9mzZ8nX15eMjIzEMuc+gb97945evHgh3i1Qdbdu3aKyZctSZmYmPXnyhEqVKkX9+vUT1x84cED8/+vXr5UR4jfLfe75NKn6/fffqUiRIhQcHCzum5SUFGrbti0tX76c6tatSxMmTMjXeP+LHj16kIuLi/hYdmGzdu1aqlSpkkpdgHJiyeTMnTuXTE1N6cCBAxQeHk7Tp08nR0dHuSulpUuXkiAItHjxYnr37h0RkUqeCHPXjHz48IGIcmpZvLy8qHjx4tS3b18iyjkoSSQSGjRoEA0cOFDcVl1s3ryZOnfuTEQ5tUSy9nky79+/J6KcW3l3795VSozfKz09nbp160ZjxowhopwaoytXrtD48eMpKCiIXr9+TdeuXaMhQ4ZQtWrV1CKplImNjaVbt25Ramoq1a1bl3r16kVEOcOHFClShCpVqiTWZqqyNWvWUMOGDalt27ZizaXsomXHjh1Uo0YNse313r17qWnTplShQgW1art88OBBmjp1qvg4KiqKGjVqRFZWVnTv3j0iIrVoLpPbjRs3SCKR0LNnz6hBgwa0a9cusra2pn79+olliYuLo65du9KZM2eISLXbZedOKpcvX07t27enjh070uzZs8XlU6ZMITMzM2rZsiX5+/tT7dq1ydnZmYhyKhs8PDxUuoxERH/99RfZ2dnRtm3b5Jbv3buXbGxsKDExUUmR5cWJ5S8u948pOTmZmjdvTr///ru4LC0tjbZt20YVK1ak//3vf+LymTNnkiAItGjRIpVsJyUr1/79+6lJkyZ09OhRkkgkdOfOHXJzcyM7Ozs6fPgwEeXUNEycOJEsLCzkOhmoqk8PgEFBQeTu7k4PHz4ka2tr8vf3Fw+2u3fvpoCAALVLlomIOnfuTPXq1aN79+6Rn58fubu7k4uLCxUvXlxMpG/cuKHSnSQ+d7KSnbxPnz5Njo6OYg1eVFQUeXh4ULdu3VR6VILcidQff/xBzZo1o3bt2sn1Up03bx7Z2dmJ+2b8+PE0e/ZstUrCpFIpLV++nARBoOnTp4vLo6KiyMvLi8qUKSMmzqp4YU2UN+m9fv06lSpVih49ekRv376lhg0bkoaGBnXp0kVuu1GjRlGtWrVU+rf1KVnv7wkTJtCoUaPIxsaG/Pz8xPWbNm2i4cOHU5MmTWjAgAHiRVCbNm0oICBAZe64yY4ZiYmJFB8fL7Ybf/HiBbVu3ZqaN28udjrKzMykcePGUY0aNVSqfTknlr+wT39IUqmUnJ2d5W59E+V8eX19falTp05yy+fOnUuCINDy5ctV8mpP1jB92rRpYu0CEdHly5epWrVq5OjoSA4ODuTp6UmWlpZq1bnl7Nmz4hX5uXPnqGHDhmRqaioeSGX7NiAggDp37qzyDe8/9/3Zt28fubq6kqamJrVr14527txJRDlNFlxdXVW+PaWsTGfPnqW5c+fSuHHj6NixY+IJ7ejRo2RjY0P79u0jiURCU6dOpd69e4s1zKrq097Ejo6OpKmpSe3btxdvEcfFxZGRkRFVqVKF6tevT8bGxhQdHa3MsP+TDx8+0MqVK0lDQ0NsO0pEdPHiRWrWrBkZGRmpbA3s/PnzqW3btnK/k/Pnz5ODg4N4u/jmzZtUrFgxat68OW3YsIGOHDlCgwcPJmNjY7W6C7BlyxYqV64cXbhwgYhyaswNDAzEUQlkcp/zkpKSaOLEiWRqairWuCtb7pEVypYtSzY2NmRsbExDhgyh+/fvU0JCArVt25ZKly5N5cuXp0aNGpGJiYnKnbs4sfxFRUVF0cuXL4koZ0addevWERHRkCFDyMvLK88PberUqeTp6Unp6elyP86FCxeqzI8yt4SEBLKzs6OlS5cSUc4BJTMzkyIjI+njx4/0+vVr2r9/P40ZM4a2bt2qFsMlyWRkZFBAQAC5u7sTUU57IVkHiVWrVlFWVhY9e/aMxo8fT8WKFVP5Nm25E7DAwEAaN26c2Ivz/fv3dO7cObntBwwYQC1btvxiu0tVsnPnTjI0NKQGDRpQzZo1SRAEGjVqFD1+/Jhev34tjqlXsWJFlTxBfMmRI0dIEARauHAh/fnnnzR27FiqXLkytW3bVqz1v379OvXt25dGjx6t8t9Bon9qHZ88eSJ350IqldKyZcvyJJfnzp0jX19flW1e8vfff5Ourq7cxcqhQ4fIycmJiP5Jsi5fvkzu7u5UunRpqlChgtjJSpVlZGTIJcwhISE0ZcoUIsq5S2ViYkKLFi2i0NBQ0tTUFNv6yrx+/Zr8/PzI1taWrl69mp+h/6uTJ0+Svr4+LVy4kC5fvkxLliyh2rVrU+vWrSkhIYFevXpFp0+fplGjRtGSJUtUspMpJ5a/oKSkJBIEgYYMGUL9+vWjwoULi0MTREdHk7m5OXXr1k0cA+v9+/fUsGFDsU0ikep21JElKbdv36bq1avT5cuX6dWrVzR//nxq0KABGRsbU/369SkiIkLJkf6YS5cuka6urnhL5O3bt9S8eXOqXLkyFSlShNzc3MjGxkZtEpVdu3aRsbExde7cmXr16kUmJiZ5ashv3LhBI0aMoCJFitC1a9eUFOm3u3v3LllbW1NoaKj4vdy6dSsVK1ZMHOT94cOHtHLlSgoODlbJE8SnpFIpSSQS6tOnD3Xs2FFu3R9//EEVKlSg9u3bi8lWdna2St7NkFm+fDmdOHFCvGW8Y8cOsrKyEsfhPHHihFi7J0suc98WV/WLm/DwcDI0NCQ/Pz+SSCS0d+9eqlq1KhHJ3yVIT0+n58+fU1JSksrXmO/cuZPatGlD1apVo2nTponL79+/T69evSJnZ2eaM2cOEeX8BkuWLEmCINDYsWPlXufhw4d5xmVWJtn+GDlypFwtK9E/d29kbc5VHSeWv5hTp05RQkICXb58mXR1dUlfX59OnDhBRP9csV+4cIFsbGzI2dmZHB0dqWbNmuTo6CgeYFX5RCG75fvw4UMyNTUlLy8vMjc3Jx8fH5o9ezYdPnyYKlSooFYzf+T+vCUSifh4xIgR5OHhIR4c09LS6NKlS7RixQoKDw9XqV6CXyPrGS2rXb579y6ZmpqSv7+/uE1kZCT179+fnJycVPaWalJSEkVFRYkXZNevXydbW1uKjo6W24ebN28mDQ0NOn36tLJC/WGDBg0iT0/PPD1wAwICSE9Pj7y8vFR6bFvZ/ihfvjxZW1vTuXPn6Nq1a2RjY0Pz58+n8PBw8vLyImtra9qxY4c4CPWKFSvEQcPVxfHjx8nQ0JCGDh1K27dvp9q1a9ORI0fo5MmTdPPmTbp8+TLt37+fnj17puxQ/9WKFSvIyMiIhg8fTgEBAaSpqUnLli0T10dGRpK1tbV4kXb37l3q3LkzHT16VK4drCqfw0aMGEGenp6UnZ0tV4Ezb948KlasmMon/kScWP5SUlJSqHfv3jRmzBg6f/486enpkYaGBg0fPpyePn1KRP/84O7evUtbt26lsWPH0tKlS8UrelVufB8dHU26urp0/vx5IsqZBm/cuHG0YMECuUbonp6eFBwcrKww/5OjR4/Snj175DpK7du3j+zt7cWem+rqypUrVKVKFSLKuSCQTWkoExUVRUQ5tbSy76mquXnzJtWtW5e8vb2pTZs2lJ2dTVFRUaStrS22+8o9zJOjo6NcZzh1M3/+/M/WiG/YsIEqV65MnTp1UtkLm0/vtjRo0IAcHBxo/fr1NHr0aLl1vr6+eZLLVatWqWTzn9w+TZyOHTtGhQoVIgMDA7KzsyMbGxsqUaIElS9fnkqVKkWWlpYq3xwoNDSUtLW15WbR6dSpEy1evFg8vsfHx5OdnR0NGTKEbt26RV5eXtS6dWvx81DVTla5LVy4kAwNDcWpGWWxHzlyhCpWrEgvXrxQZnjfhBPLX8zmzZupdOnSYvvKo0ePkoaGBg0aNOhfr1hV/Uf54MEDatGiBRkZGVFkZCQRyZ/Ms7Ozafz48WRubi7XmUfVffjwgYYMGUKCIJCPj494m4eIqFu3bnJjm6kD2YEyPDycjh07Rrdu3aI6derQ0aNH8wx7EhMTQ127dlXpecBv3LhBRYoUEeeYz524tGvXjipWrCjXYzojI4OqV69Of/zxhzLC/S6yfRUbG0sxMTFyTRBcXV2pUqVKFBUVJbZ3GzNmDI0fP15lxz2U7ZuEhARasmSJeByoUaMGCYJAXl5eeWphfX19yc7OjjZt2qT0gaf/jWx/paSkUGpqqty6U6dOUfHixalZs2b06NEjev36NSUnJ9OrV6/EYeNUVXh4OAmCQEFBQXLLnZycqEqVKlS4cGGqW7cuLV68mBYsWEClSpWi0qVLU82aNVX2TpvsGBcfH0+xsbFyxzjZqAMxMTHibysgIICcnZ1Vfl8RcWL5y8j9o+ratSu1bdtWnP/1zz//JA0NDRo6dKg4DVnbtm0pLCxMKbF+q9xlkv3/4cOH1L59e9LX1xdnv5BIJLRmzRry8fGhkiVLqk27w0+dO3eOJkyYQObm5lSjRg1avHgx7d69mzw9PenPP/9Udnj/Kvf+Cg8PJwMDA9q9ezfFx8eTi4sL6enpUY8ePeSeM2LECGrUqJF4IaRqXr9+TW5ubjR06FC55bIE5uzZs+Tt7U3ly5en48eP06lTp2jixIlUrFgxuWRTle3YsYPMzMzIysqK7OzsxNEIPn78SDVq1CAbGxtydXWlJk2akI6Ojsp21JHtk2vXrlG5cuWodevWcrVfjRs3JhMTEzp+/Hiei+jGjRtT5cqVVXp0Bdnv66+//qKGDRuSs7Mz1a9fn27cuCHWtp44cYIMDAyof//+ajUEWVxcHNWrV49atWol3sFo06YN2dvbU1hYGB06dIgqVapELi4uFBMTQ4mJiXT+/Hlxn6vKnbb169eLE1kQEW3bto2srKzIzMyM7O3tqX379pSZmUlJSUnk7e1NhQsXJldXV3J3dydjY2OV62j0JZxYFnCf62QTHh5OrVu3Fm8ZE+XMsqCrq0tNmjQhZ2dnKleunMpfnRPlXIXLbuHIDqwPHjyg9u3bk4GBgfhDvH79Og0fPlyl233JyMoRExNDe/bsoR07dsjN5pGUlER9+/YlDw8P0tfXF6fZVLUr8i958uQJzZ8/n2bMmCEuO3jwIGlpaZG/vz8dPnyYLl26RAEBASrfUefmzZtkZ2dHp06d+mKHtosXL1KXLl1IV1eX7O3tqVKlSip/cSP7Lr1+/ZocHBxo7dq1dOLECZo9ezZpa2vTpEmTxG2XL19OEydOpNGjR6v8LeLY2FgyMTGhcePGfXZA6bp161KZMmXozJkzefanqt7az23fvn1UuHBhmjhxIh0/fpzq1KlDTk5OdPDgQTG5PH78OAmCQIMGDVKbYwZRTnLp7e1NzZs3p7p165Kzs7PcUE+XL18mQRBo3759cs9TlY6mSUlJ1KJFC6pZsyZt27aNnj59SjY2NhQSEkInTpygbdu2UalSpcjd3V3cL6GhoTRjxgyaMWOGWnTuk+HEsgDL3Wbm999/F4dtycrKopYtW5Kvr6/c9idPnqThw4fT6NGj1aJNZXJyMnl6elKxYsXEA4zsBxkXF0dVq1al4sWLi1e4qlyWT8lqicqWLUvW1tZUtGhR+vPPP8VeqFKplBITE2nevHnk5OQk9upXdffv3ydBEMjY2DhPB4iwsDBydnamokWLkqOjI7m6uqpsRx2ZzZs3k5aWlvi9y30Sk9V6paWlUWxsLL18+ZIePnyosrWvnzp27BiNGzeOBg8eLCYl79+/p6VLl5KmpmaeafBUPUn5+PEjtWvXjgYNGiS3PDMzk+7fvy9evHl7e5O1tTVFRESoTFLyLe7fv08uLi60cOFCIiJ6+fIl2djYkJmZGZmZmdHBgwfFpkGnTp1Si8kgPhUXF0eenp5kbGxM27dvJ6J/OjRevnyZKlasSGfPnlVylF8WHR1NXbt2pUaNGtHw4cOpS5cuchU4sbGxZGlpSV27dlVilD+OE8sCKjo6mgRBoL1799KwYcPI1NRUbry1Z8+ekYODgzh+5ecaN6tDInb+/Hlq2rQp2djY5Gl83qNHD9LQ0KASJUrQx48f1eYkceXKFTIxMaG1a9fS8+fP6fnz59SnTx8yNDSkQ4cOEZH8SVyVBwpPS0ujly9fUnh4uNjMYsuWLSQIArVv3z7PvMrPnz+n2NhYun//vkrO6PSpiIgI0tPTEwdv/5zFixdT48aN1WaOdqKcdqATJ04kTU1Nql69utw6WXKpp6cnDptEpPqJZVZWFtWrV4+WLFkiLvv7778pICCAjIyMqFSpUtS2bVsiykkujY2NxY5X6uDOnTs0d+5cSk1NpadPn5K9vb04taurqys5OTnR3r17xYsEdXXv3j3y8vKipk2byo2s0KJFC2rYsKHKH+ejo6OpS5cuZGNjQ7Vq1RKXy863q1evpooVK9LDhw/F35Sq/7Y+xYllARYUFET6+vpkaGgodzsxOzubsrKyKCgoiAYPHkwfPnxQ+R8j0T8/rszMTLmG6devXycPDw+ysbGhBw8eiMsDAgJo+/btKt2L7siRI3k6Te3Zs4ecnZ3p7du3cgcUPz8/KlGihJhwqfpB586dO9S9e3dycHAgPT09Kly4MHXq1IkSExNp9+7d4lR56tAY/UuePHlCZmZm1KpVK7nvXu59MnLkSBo3bpzK7qfccsf44MEDCgoKEmfXyi01NZXmz59PRYsWpZcvX6pF2ZKTk8nBwYH69u1Lt2/fplmzZlH58uXJ19eXgoODafXq1VS6dGlxnEoPDw+VHfz8S2TxDhw4kHx9fcWhabp160aCIFC5cuXydOpRR7Lb4s2aNaMzZ85QmzZt5Jpvqfr57Pr169SxY0cyMDCgFStWyK3bv38/lSpVSqWndf03nFgWMLl/UDNmzCBBEEhLS4t27dqVZ9uIiAgyNzenAwcOEJHqJihE8g3TW7duTU5OTtSnTx86ePAgERHdunWLPD09ycTEhCZPnkzdunWjEiVKqOwQGrJ5y2VtnXLX3IWGhpKBgYF4BSur6bp79y6VKlWKjh07ppSYv0dMTAyVKFGC+vfvT+vWraPY2FgaO3Ys2djYUPny5enRo0dizeWsWbPEjmTqaNeuXaSrq0vdunWT67iSlpZG48ePp9KlS6t8217Z7+vTuxSPHj2iCRMmkKGhYZ4TYFpamkrNT/wtjh8/TlpaWlS6dGkqXLgwrVixQkzGMjMzqUmTJnkG5ldFsv0VHx9Pd+7cyVOz2qxZM7kBwYcPH05Xr14V7xoUBHFxcdS8eXPS1tam8uXLi0mlOtxpI8o5Z3Xq1Ilq1qxJISEhRJRzwTZ69GhycHBQmyYzn8OJZQEVFBRE/v7+dOPGDQoKCiJtbW3atGkTEcknnytWrKCqVauq1AwEX/Lnn3+Sjo4ODRs2jKZNm0YuLi5Uu3ZtWrx4MRERPX36lIYNG0YuLi7UuHFjle5BJ2tysHPnTtLW1qahQ4eKY7G9fPmSKlWqRH379pW7fSqbpvLkyZNKiflbxcTEkIGBAY0fPz7PQT4sLIyqVKlCNWrUoPT0dFqxYgVpa2vT5MmT1Ta5lEgktGLFCtLS0iIHBwfy8/OjAQMGUKtWrcjMzExtOuocP36cevbsSZ07d5ZLSh4/fkwTJ06kwoULy/VoVVePHj2iS5cu5TlxSyQSateuHU2aNIkkEonK1nrlnk+6QoUK5OjoSObm5tS5c2exg4ePjw9VqFCB1qxZQwMGDCBjY2O1rgH7ktjYWBoyZIha9An4nGvXrlGnTp1IV1eXqlWrRp06dSIHBwdxRBN1xYllAZG7beSRI0eobNmy4gwgRETjx48nbW1tcQpAopyr2PXr15Ovry8dOXIkX+P9HlKplJKTk6lRo0ZyU3glJSXRoEGDqFatWnK1eMnJySo91dqaNWto06ZNYox79uwRp9h88eIFSSQSWrRoEdWuXZv8/PwoOTmZnjx5QlOmTKEyZcqodK3Do0ePqFixYtSuXTtxmVQqlTvg//HHH1SoUCFxHMeZM2eSiYkJvXr1Kt/jVaTIyEhq27YtVa1alerVq0djx45V+Z6cuZMUIyMj6tu3L40dO5bKlClDrVq1Eo8rjx8/pilTppAgCLR27VolRvxzZGRk0KRJk8jS0lLl9xlRzrBBhoaGFBoaSqmpqXTo0CESBIG2bNlCRDm1yfXq1aOKFSuSk5OTSl9kK4oqJpXf0lzp1q1b1KVLFzI3N6fAwEC1rqmU4cRSzX06Ft6WLVto2LBhNHz4cCKS/7FNmDCBBEGgoUOHUp06dcjR0ZGIcnogy3pOqwrZnMREOQOEZ2dnk6urq9j+Sbbu1atXVLlyZQoICFBarN9DVo6qVavSrl27xBpJWXI5cOBASk1NpY8fP9KSJUuocuXKpK2tTY6OjlSyZEm5iwVVlJCQQK6urtSqVas8MwLlPrjWr1+ffHx8xMfqdkv1S1R9EgHZ7yZ3bVx0dDSVK1dObEeZkJBAJUqUIEEQyM3NTTyGPHjwgGbMmKHSg9X/Fxs3bqShQ4eSubm5ytcuywQGBoqzU927d4/s7e3lpkCVefbsmdreCVBnsmNdcnIyZWZmiuOffinBvHr1Kvn7+6vFkFbfghNLNdazZ08KDAwkon+GXKhbty4JgkAeHh6fHQJl0aJF5OXlRd26dVPZWr3cwy9s3bqVunfvTgkJCVS/fn3y8/MjIpK7VRUQEEAeHh4qf1KX7Y8PHz6Qt7c3Va9enXbs2PHF5FIqldKHDx9o586ddPLkSbU56Mga1nt5eckll7kPqg0bNqTOnTt/dp06+9yg/aoi96wzK1eupIsXLxJRzhiisgvRR48eka2tLfXt21ecY9rHx0ft2q99q9u3b1PDhg2pdevWKj8Gp4xUKqXmzZvThAkTKD09nUqWLEn+/v7i923x4sVizSXLf7L9cODAAWrZsiW5uLhQy5Ytaf/+/V99njqNGvFvOLFUY/v27RMP+LL2eVlZWdSxY0eytLSktWvXislj7uQy9+wRqjYI+vXr1ykwMJAkEgm9fPmSbG1txXm9Dx8+TIIg5JljuX379uTn56eybaJyk52YP3z4QB4eHuTi4kI7duzIc1t80KBBKt2b/d/kTi5zjysnkUjo8ePH1LRp0zxDXbGf53Ozzsg67RHl1FpKpVLy8fGhLl26kFQqpdTUVHJxcSFBEKhJkybKCv2ne/HihdqNTLBhwwZyc3OjYsWK0YABA+QqEXr37k2DBg0qUImKutm/fz/p6enR3LlzaceOHeTn50eCIKjsrFSKxomlGvr0RBwaGkrt27cXb+NkZWVR8+bNqWrVqhQWFiaOW/ZpjZ6qndBlY28uW7aMTpw4QdOnT6f+/fvLDY+xbNkyEgSBOnXqRCNGjKB+/fqRoaGhWgwQLvu8Zbd909LSyMPD47M1lzo6OuTn55dnnEd18qWay7Fjx5KTk5Pa1MAWFP8268y7d+/IyclJnOYwPT2d+vTpQ3/99ZfKjq5Q0MmOGU+ePKHbt2+Lj69cuUL169enihUrihNfpKam0sSJE8nS0lLlRyEoiGQXb2lpadSyZUuaN28eERElJiZS6dKlP9tUoaDixLIACAkJoSpVqpC/v79cctm0aVOqVq0abd++XeWvXm/evEn6+vo0depUIiKaPHmyOO6abCw2mRMnTlCrVq3I3d2d2rRpo9JT/n0qMjKS2rdvLw4PIksuP625DAsLI1NTU7EmWl3lTi6vXLlCc+fOJUNDQ5WfUaeg+dqsM0+ePKG4uDhKS0uj6tWrk4+PDyUkJNCoUaOoXLlyecZZZflr586dZGVlRVZWVlSpUiUKDw8nopyh1+rUqUO2trbk5uZG7u7uVKJECbVpJ1oQLFiwQK59v1QqpXfv3pGtrS2dPn2akpKSxKYKMuvXry/wiT8nlmokd4eWT61evZqcnZ2pd+/ecsllixYtyNLSko4fP56foX6X69evU7FixahChQrisqSkJJo3bx5paGiIY3wR/VPrKkuUVbWd6Jds2rSJqlatSl27dhU7TOWuudy1a5dYpk8TanUVFxdHLVq0IDMzM9LW1lb7oTTU0b/NOlO6dGlq0qQJ7d69m+zs7KhkyZJkZWXFSYqSyI7zN2/eJFtbW5o/fz6Fh4eTl5cXlSpVSpzp6fr167R+/XoaOHAgrVy5ku7du6fMsH8pHz9+pNmzZ5OhoSFNnjxZXJ6dnU3dunWjGTNmkLW1NfXr1088byUlJVH37t1p48aNKnfHUJE4sVRTBw4coL1799KJEyfEZaGhoWJyKRteIjMzk0aOHKmyHVuio6PJwMCAGjZsSJaWljRkyBBx3du3b8Wayw0bNhBRTnIt+5M9VlVfim3r1q3k5uZGHTt2FDtQpKWlkZeXF9nZ2dG+ffu++nx1dPv2bWrVqhXduHFD2aH8kr5l1pkKFSpQQEAAvXjxgs6ePcs1lfnoc731z58/T+vXr6fRo0fLbevr6ysml+o+PaO6e/PmDS1evJiKFClCEydOFJePGzeOBEGgpk2b0ocPH+SWly9fXm6WroKIE0s1MGTIELk5eQMCAsjMzIwsLCzI0dGRhg4dKq4LDQ2l6tWrk7+/P0VGRsq9jqoll1FRUaStrU2BgYGUnZ1NK1eupGLFiskll+/evaNJkyaRIAjiAO+q7HM1yrGxsXlqEjZv3kz16tWjDh06iBcBqamp5OPjU2Dbs6laR7FfzddmncnIyKDGjRtT9+7dlRzlr+fT3vqy47as45S3t3ee346vry/Z2dnJjYfL8k/uyo3379/TwoULqUiRIjR+/Hhxm86dO5OZmRkNHjyYpk6dSj179iRjY+NfYkxRLTCV9vbtW2hpaeHQoUMoUqQIevTogYsXL+Lo0aPQ1tbG4cOHsXz5cqSlpWHVqlXo06cPNDQ0EBgYCBsbG9SoUQNEBEEQoKmpqeziyPnw4QMGDBiAqVOnAgA6dOgAAJg4cSIAYPHixTA2NsaoUaOgqamJbt26QUtLS9xO1UilUmhoaCAxMRFnz56FRCKBrq4uQkJCYG9vjzFjxsDW1hYA0LlzZ2RnZyMgIAAaGhoYNmwYatasiT179ii5FD+Ptra2skP4pbm7u+P+/ftISkpC6dKlUaxYMXGdlpYWjI2NYW1tDSICAAiCoKxQfxmyY8b169fRtm1bVKpUCZaWlgCAqKgoNGvWDBcuXMCZM2fQoEED8Ri+c+dONGnSBPPmzUOrVq2gp6enzGL8EmTnUeCf30ZUVBQsLCzQs2dPCIKAoKAgSKVSzJkzB5s3b8akSZNw+/ZtREZGolq1aoiIiEClSpWUWYz8oeTEln2DxMRECgwMJEdHR2rbti317NlTrH189+4dhYSEkJ2dHfXp00d8zv79+1WuhvJrcg8o+7mayzdv3tDMmTNVdqw5Wa1DTEwM2draUsWKFUlbW5tq1KhBTk5O5OXlRcOGDctTG+nm5kZmZmbUp08f+vjxY4G6/c3Ug7rNOlPQ/Ftv/bp161KZMmXozJkzee6I8MgK+efp06dE9E9fh/j4eDI3Nxc7Ir5584YWLVpEJiYmNGbMGPF5GRkZlJmZqVbn4x/FiaUKy30QSUxMpKlTp5KNjQ3VqVNHbrt3797RihUrqHz58tSmTRu5der4Zc6dXH7a404V5U4qDQwMaMyYMZSYmEj79u2jpk2bUv369WngwIFUtWpVGjZsmNi+5uPHj9S3b1+aOXMmnyCYUqjjrDMFydd669+/f18cbszb25usra0pIiJCLcbrLWh27NhBNjY24mgeRESvX78mBwcHuSl2cyeXkyZNUkaoKoETSxWV++AhGyj7+fPnNHXqVCpSpEieL21ycjItWLCA2rdvXyAOPMnJyRQaGkqCINDYsWOVHc6/+twc2UQ5Q0GZmJjQkydPaNmyZeTi4kIdOnSg9evX09ixY6lixYpqP0c2U0/qOOtMQfNvvfVLlSpFbdu2JaKc5NLY2FguuWH54/Dhw9SyZUtydXUV28DGx8dT2bJl8xy/ZR16BEGgGTNmKCNcpeM2lipI1u4GAKZPn44rV65g5syZqFixIgYMGAAACAsLg6amJgIDAwEARkZG6NevH4YPHw5BEOReQx0ZGRmhXbt20NbWRu3atZUdzr+SSCSwsbFBRkYGzp49Czc3NwCAnZ0dAOD9+/cYOHAgChUqhJ07d2LChAkoVqwYNm7ciKJFiyozdPaLKl++PMLCwqCrqwtjY2Nlh/NL+vDhA16+fIlr167hzp072L17N9avXw9HR0dMnz4dhoaGmDZtGmbMmIFDhw7B09OTjxdK0KRJE+jq6iI4OBj9+/dHSEgILCwskJKSAolEIretiYkJunfvDm1tbTRq1EhJESuXQPT/LbWZyhk7diw2btyIOXPmwMPDAyVLlgQAPHv2DCtXrsS2bdvQuXNnTJkyRe55lKuRsbpTp7LcvXsXQ4cOhVQqxaJFi2BlZQVbW1v4+flh7ty54nbJyclITU2Fnp4enyQY+8WdOHECXl5eKFmyJN68eYP58+fDw8MD9vb2yMrKQosWLVC0aFFs2bJF2aH+knKfg06ePIng4GA8efIE/fv3x+bNm+Hl5QUbGxtIpVJkZWUhIyMDlSpVUosKkZ+FE0sVdfToUfTs2RO7d+9GzZo1QUR4+/YtHj58iLJly0IQBCxYsACLFi3C//73P/Tq1UvZITPkJJfDhg3Dhw8fcO3aNfTo0QMLFy4EAGRnZ0NLi28SMMbkPX78+LO99aVSKTp27Ijy5csjKCgIANT6TlRBcOzYMYSEhOD06dN4/fo1WrVqhbi4OAiCAB0dHUgkEmzfvh0ODg7KDlVp+Cynot6+fQtLS0vUqFEDV65cwb59+7BlyxakpKTA3d0dS5YsQe/evVGqVCn06NFD2eGy/1e2bFnxdomRkRFat24trlO14Z4YY6rBysoKVlZWcssyMzMxffp0REREYObMmZxQ5jNZTeWVK1fw4sULSKVSNG/eHJ6enhAEAXp6erh27RqCgoLg5OQkPi8tLQ2FChVSYuTKxzWWKuDjx4/Q19eXWxYdHQ1nZ2d4e3sjKioKLVq0QKNGjaCrq4uBAwfiwIEDclXtEomEExcVcu/ePQwZMgREhMmTJ6Nu3brKDokxpiY2bdqEqKgohIWF4dChQ6hWrZqyQ/ol7dq1Cz179oSFhQWePn0KX19fbNiwAQBw/PhxLF68GM+fP8ecOXPE9pTq1HzrZ+HEUsk2btyI+Ph4jB8/Hrq6uiAiSKVSaGpqIiIiAjt37kStWrXg7u6O4sWLIy0tDQ0aNMC8efPg7u6u7PDZV9y9excjRozAq1evsHDhQtSqVUvZITHGVNydO3fQv39/mJiYYObMmahQoYKyQ/qlyBLDDx8+oGnTpujTpw/c3NwQGxuL7t27o169euJEFqdOncK0adMgkUjw999/80D1/48TSyX6448/0L9/fxw8eBDe3t5yM15cunQJZmZmsLa2BgBkZWUhPT0d7du3R3JyMs6cOcM1lGrg9u3bmDx5MhYsWCDuS8YY+5qkpCTura9ER48excaNG6GpqYm5c+fCzMwMABAREQEfHx+4ublh9+7dEAQBZ86cgY2NDUqVKqXkqFUHJ5ZKsnHjRvTu3Rt79+5Fs2bN5JLK3bt3w9/fH7t27UKDBg2QlZWFZcuWYefOncjMzERERAS0tbXVfkihX0VmZiZ0dHSUHQZjjLFvEBYWBj8/PxgZGeHWrVswNTUVazIjIiLQrl07VKhQAceOHfvlb3t/DmclSrBu3Tr06NEDDRs2RLNmzQDk9P4TBAF79+5F27ZtMWPGDDRo0ABATrLp5OQET09PnDt3Dtra2sjOzuakUk1wUskYY6pFKpV+8XHr1q2xefNmpKWlYdKkSQD+mR+8bt262LJlCx49eoTExMT8C1iNcI1lPgsNDUX//v3Rq1cvHDx4EG3btkVwcDCAnLYdO3fuxNu3b+Hv7//F1+COOowxxtiPuX37NjZu3Ah/f39YW1vL1T5mZWVhz5496NmzJ/r06YPFixfLPfdznW5ZDk4s89GiRYswYsQI/PXXX2jatClWrlyJSZMmoXPnzmJyyRhjjLGfKysrC3Xr1sWlS5dgb2+P3377DTVq1EC7du3EbdLT07Fv3z707NkT/fv3F8ckZl/H41jmo2rVqmHLli1o2rQpAKBjx44QBAETJ04EADG55BpJxhhj7OfR1tZGu3bt0KlTJzg6OiIiIgL9+vXD/v37Ubt2bfTv3x96enro0KEDAKBTp07Q0dGRm0WNfR7XWCpB7nGuUlJSsG3bNkycOFGu5pKTS8YYY+znOXnyJH777TccP34cLi4uePbsGf744w/MmzcPlStXRu/evdGoUSPY29tjz549qFChwi89o8634sRSBciSy0mTJqFLly5c3c4YY4zlg9GjR+PZs2dYtWoV9PT00LFjR8TExKBmzZpISEjA+fPnMX/+fAwdOpR7gH8jvhWuAoyMjMTb4v369UOZMmUwbNgwZYfFGGOMFWg1a9bE77//Dh0dHfTp0wcnT57E8ePHUalSJdy5cweHDx+Gh4cHJ5XfgWssVci7d+9w6tQptGjRgm+DM8YYY/mgQYMGOHv2LCwsLHDw4EG5ub/Z9+PEUkVlZ2dDS4srlBljjLGfQdbf4eDBgxg+fDjmzp0LHx8fnu/7B/EI2yqKk0rGGGPs55Elj9WrV4dUKsXly5fllrP/hhNLxhhjjP2yzM3NMXXqVCxcuBAXL15UdjhqjxNLxhhjjP3SGjVqBFdXV1haWio7FLXHbSwZY4wx9stLT0+Hnp6essNQe5xYMsYYY4wxheBb4YwxxhhjTCE4sWSMMcYYYwrBiSVjjDHGGFMITiwZY4wxxphCcGLJGGOMMcYUghNLxhhjjDGmEJxYMsaYiipTpgwWLVokPhYEAXv37s33OAIDA1G1atUvrj958iQEQcC7d++++TUbNmyIgICAH4pr3bp1KFKkyA+9BmNMsTixZIwxNfHs2TM0bdr0m7b9t2SQMcZ+Bi1lB8AYYwVZZmYmdHR0FPJaFhYWCnkdxhj7WbjGkjHGvlHDhg0xePBgDB48GMbGxihWrBgmT56M3BOYlSlTBtOnT0f37t1hZGQEf39/AMDZs2dRr1496Ovrw8rKCkOHDkVaWpr4vKSkJLRs2RL6+vqwsbHB5s2b87z/p7fCnzx5gk6dOsHU1BSFChWCi4sLIiMjsW7dOgQFBSEmJgaCIEAQBKxbtw4A8O7dO/Tp0wfFixeHkZER3N3dERMTI/c+c+bMgbm5OQoXLozevXsjPT39uz6n169fo1OnTihZsiQMDAxQuXJlbN26Nc922dnZX/0sMzIyMGrUKJQsWRKFChVCzZo1cfLkye+KhTGWvzixZIyx77B+/XpoaWnh4sWLCA4Oxu+//45Vq1bJbfO///0PTk5OuHr1KiZPnoz4+Hh4e3vD19cX165dQ1hYGM6ePYvBgweLz+nZsyceP36M8PBw7Ny5E8uXL0dSUtIX40hNTUWDBg2QmJiI/fv3IyYmBmPGjIFUKkWHDh0wcuRIVKpUCc+ePcOzZ8/QoUMHAEC7du2QlJSEQ4cO4fLly3B2doaHhwfevHkDANi+fTsCAwMxa9YsXLp0CSVKlMDy5cu/6zNKT09H9erV8ddff+HGjRvw9/dHt27dcPHixe/6LAcPHozz589j27ZtuHbtGtq1awdvb2/cvXv3u+JhjOUjYowx9k0aNGhAFSpUIKlUKi4bO3YsVahQQXxcunRp8vHxkXte7969yd/fX27ZmTNnSENDgz5+/Eh37twhAHTx4kVxfWxsLAGghQsXissA0J49e4iIaOXKlVS4cGF6/fr1Z2OdOnUqOTk55XlPIyMjSk9Pl1tuZ2dHK1euJCKi2rVr08CBA+XW16xZM89r5RYeHk4A6O3bt1/cpnnz5jRy5Ejx8b99lg8fPiRNTU1KTEyUex0PDw8aP348ERGtXbuWjI2Nv/iejLH8x20sGWPsO9SqVQuCIIiPa9eujQULFkAikUBTUxMA4OLiIvecmJgYXLt2Te72NhFBKpUiISEBcXFx0NLSQvXq1cX1Dg4OX+3xHB0djWrVqsHU1PSbY4+JiUFqaiqKFi0qt/zjx4+Ij48HAMTGxqJ///5y62vXro3w8PBvfh+JRIJZs2Zh+/btSExMRGZmJjIyMmBgYCC33dc+y+vXr0MikaBcuXJyz8nIyMgTP2NMdXBiyRhjClaoUCG5x6mpqejXrx+GDh2aZ1tra2vExcV993vo6+t/93NSU1NRokSJz7ZTVOSwPfPnz0dwcDAWLVqEypUro1ChQggICEBmZuZ3xaqpqYnLly+LCbuMoaGhwmJljCkWJ5aMMfYdIiMj5R5fuHABZcuWzZP85Obs7Ixbt27B3t7+s+sdHByQnZ2Ny5cvw9XVFQBw586dr44LWaVKFaxatQpv3rz5bK2ljo4OJBJJnjieP38OLS0tlClT5rOvW6FCBURGRqJ79+5yZfweERER+O2339C1a1cAgFQqRVxcHCpWrCi33dc+y2rVqkEikSApKQn16tX7rvdnjCkPd95hjLHv8OjRI4wYMQJ37tzB1q1bsWTJEgwbNuyrzxk7dizOnTuHwYMHIzo6Gnfv3sW+ffvEzjvly5eHt7c3+vXrh8jISFy+fBl9+vT5aq1kp06dYGFhAR8fH0REROD+/fvYtWsXzp8/DyCnd3pCQgKio6Px6tUrZGRkwNPTE7Vr14aPjw+OHDmCBw8e4Ny5c5g4cSIuXboEABg2bBjWrFmDtWvXIi4uDlOnTsXNmze/6zMqW7Ysjh49inPnziE2Nhb9+vXDixcvvuuzLFeuHLp06YLu3btj9+7dSEhIwMWLFzF79mz89ddf3xUPYyz/cGLJGGPfoXv37vj48SNq1KiBQYMGYdiwYeKQQl9SpUoVnDp1CnFxcahXrx6qVauGKVOmwNLSUtxm7dq1sLS0RIMGDdCmTRv4+/vDzMzsi6+po6ODI0eOwMzMDM2aNUPlypUxZ84csebU19cX3t7eaNSoEYoXL46tW7dCEAQcPHgQ9evXh5+fH8qVK4eOHTvi4cOHMDc3BwB06NABkydPxpgxY1C9enU8fPgQAwYM+K7PaNKkSXB2doaXlxcaNmwoJsDf+1muXbsW3bt3x8iRI1G+fHn4+PggKioK1tbW3xUPYyz/CES5Bg1jjDH2RQ0bNkTVqlXlpllkjDH2D66xZIwxxhhjCsGJJWOMMcYYUwi+Fc4YY4wxxhSCaywZY4wxxphCcGLJGGOMMcYUghNLxhhjjDGmEJxYMsYYY4wxheDEkjHGGGOMKQQnlowxxhhjTCE4sWSMMcYYYwrBiSVjjDHGGFOI/wN3Bt8StBS4OQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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 visualizing 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": 74,
   "id": "d058e8fa-560f-4350-a154-49593ff403c9",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "d058e8fa-560f-4350-a154-49593ff403c9",
    "outputId": "894cd015-d265-4bae-f1d6-6d7c306faf14"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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": 75,
   "id": "634a8f7a-3013-4b45-b365-49b286d3c478",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "634a8f7a-3013-4b45-b365-49b286d3c478",
    "outputId": "39fb106a-0579-4068-9538-002c0cc35f11"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-75-01e1a5266d0e>:8: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  loaded_model_2.load_state_dict(torch.load(f=MODEL_SAVE_PATH))\n"
     ]
    }
   ],
   "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": 76,
   "id": "3e3bcd06-d99b-47bc-8828-9e3903285599",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3e3bcd06-d99b-47bc-8828-9e3903285599",
    "outputId": "db09daa7-2302-44f9-c72e-84b37196a15b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'model_name': 'FashionMNISTModelV2',\n",
       " 'model_loss': 0.3261563777923584,\n",
       " 'model_acc': 88.15894568690096}"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "68544254-c99a-47ec-a32f-9816c21a993e",
    "outputId": "74b8d4ca-d35a-4f70-e8b9-ed54f034358e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'model_name': 'FashionMNISTModelV2',\n",
       " 'model_loss': 0.3285697102546692,\n",
       " 'model_acc': 88.37859424920129}"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "48dcf0ba-7e00-4406-8aaa-41918856361a",
    "outputId": "47324300-0d00-46de-d130-1283ad044ef8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(True)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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 prediction 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 visualizing 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 through 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": {
  "accelerator": "GPU",
  "colab": {
   "gpuType": "T4",
   "include_colab_link": true,
   "machine_shape": "hm",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "3fbe1355223f7b2ffc113ba3ade6a2b520cadace5d5ec3e828c83ce02eb221bf"
   }
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "043d95264d9e4d4b8ccd25bf3162f398": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "09b483589d7b4623a31ea645acf31f01": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "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_e35d666f940e46569363e16ad5ac49cf",
       "IPY_MODEL_2860ba1876df4b88beecfddab08ec30c",
       "IPY_MODEL_ffe4ea9e54ed4fb79e085cf8f4eb70a0"
      ],
      "layout": "IPY_MODEL_fb55efa8f0b64c59ab6b8036ac667a71"
     }
    },
    "0cd547aae2cd49cd81074d28f2ccd200": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "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_bb842c06bef54b01bd668b42f780b001",
      "placeholder": "​",
      "style": "IPY_MODEL_40c0f5e89e404063815446086ba629e5",
      "value": "100%"
     }
    },
    "160e8fefd7534ec8a1a3fe6eae7fac42": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "1f66d52b47174fe0a187af5314cd4591": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "26a074d9079f403dae5f8daa57018aa7": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "2860ba1876df4b88beecfddab08ec30c": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "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_e7cefdac24f84d6984b4edd909b4847f",
      "max": 313,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_d60bf5a1f8114da2bc09a7189747709c",
      "value": 313
     }
    },
    "2862c68d07324e15b0f023481160c9eb": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "34bec9be3a8b410fa87f85d305447628": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "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_63f492cc30dc4b25bc9051a79762d4cf",
      "placeholder": "​",
      "style": "IPY_MODEL_a48a1d52984341c88fefb7c4672d18a5",
      "value": " 3/3 [00:37&lt;00:00, 12.45s/it]"
     }
    },
    "398ac7652fc74e498d743868a5ab963d": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "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": ""
     }
    },
    "3b05c7d67cd54c6db4ae5a3be8b2534b": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "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_0cd547aae2cd49cd81074d28f2ccd200",
       "IPY_MODEL_82c4cc5d9aba44aaa25586f6bfb171d2",
       "IPY_MODEL_bd5131b2ea5f4644be17191d2ccbc89e"
      ],
      "layout": "IPY_MODEL_26a074d9079f403dae5f8daa57018aa7"
     }
    },
    "40c0f5e89e404063815446086ba629e5": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "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": ""
     }
    },
    "4bc9170f713b44cdbf9f9380bede178f": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "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_5b37be19536044bb8659171600c2017e",
      "max": 3,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_5a40017005cb4322ba943ff528623d1e",
      "value": 3
     }
    },
    "56ad754db89d42cc89d4a098155bec0e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "5a40017005cb4322ba943ff528623d1e": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "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": ""
     }
    },
    "5b37be19536044bb8659171600c2017e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "61462d2ff08243cb8b631ca307c37d49": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "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_2862c68d07324e15b0f023481160c9eb",
      "placeholder": "​",
      "style": "IPY_MODEL_cb2a4fcf1c57403c9f1bc11334e87644",
      "value": "100%"
     }
    },
    "63f492cc30dc4b25bc9051a79762d4cf": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "6c8477b91d5e43cb9ce98d3c1fa63c00": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "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_a77efb97769b407fbe49dcac0fa89136",
       "IPY_MODEL_b2acd0ad92014e52a9a34582c21ef1d6",
       "IPY_MODEL_ba784861bfcc4708944e93a149d6b3b4"
      ],
      "layout": "IPY_MODEL_56ad754db89d42cc89d4a098155bec0e"
     }
    },
    "7ce5bd4acb1b493d88d05324e1b46116": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "8034607c9a094d2ea6a5d0d9cb4fcab4": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "82c4cc5d9aba44aaa25586f6bfb171d2": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "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_87370ff792344f20910c7c42624e618a",
      "max": 3,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_ac303ef44ec842b69f51706ff3b153af",
      "value": 3
     }
    },
    "87370ff792344f20910c7c42624e618a": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "882b6fa90348468499b6b7cc634148dc": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "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": ""
     }
    },
    "a48a1d52984341c88fefb7c4672d18a5": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "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": ""
     }
    },
    "a624df7d7f6b4b4abf3fe1ffa6c61888": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "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": ""
     }
    },
    "a77efb97769b407fbe49dcac0fa89136": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "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_ebf4633360e945f09320825aa13dc84e",
      "placeholder": "​",
      "style": "IPY_MODEL_e9886b40b5164e2c81f1e7b54dae66a4",
      "value": "100%"
     }
    },
    "a96e76a1acd24255a12ed04a83c0aab7": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "ac303ef44ec842b69f51706ff3b153af": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "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": ""
     }
    },
    "b2041791a3204b8883d080ac22ece232": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "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_61462d2ff08243cb8b631ca307c37d49",
       "IPY_MODEL_4bc9170f713b44cdbf9f9380bede178f",
       "IPY_MODEL_34bec9be3a8b410fa87f85d305447628"
      ],
      "layout": "IPY_MODEL_043d95264d9e4d4b8ccd25bf3162f398"
     }
    },
    "b2acd0ad92014e52a9a34582c21ef1d6": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "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_1f66d52b47174fe0a187af5314cd4591",
      "max": 3,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_398ac7652fc74e498d743868a5ab963d",
      "value": 3
     }
    },
    "ba784861bfcc4708944e93a149d6b3b4": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "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_7ce5bd4acb1b493d88d05324e1b46116",
      "placeholder": "​",
      "style": "IPY_MODEL_882b6fa90348468499b6b7cc634148dc",
      "value": " 3/3 [00:28&lt;00:00,  9.57s/it]"
     }
    },
    "bb842c06bef54b01bd668b42f780b001": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "bd5131b2ea5f4644be17191d2ccbc89e": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "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_a96e76a1acd24255a12ed04a83c0aab7",
      "placeholder": "​",
      "style": "IPY_MODEL_fc089d60cd25438eb801da1881d51c84",
      "value": " 3/3 [00:31&lt;00:00, 10.48s/it]"
     }
    },
    "bee3dc7c2f454eec9ade50dc94ce9630": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "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": ""
     }
    },
    "cb2a4fcf1c57403c9f1bc11334e87644": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "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": ""
     }
    },
    "d60bf5a1f8114da2bc09a7189747709c": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "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": ""
     }
    },
    "e35d666f940e46569363e16ad5ac49cf": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "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_8034607c9a094d2ea6a5d0d9cb4fcab4",
      "placeholder": "​",
      "style": "IPY_MODEL_a624df7d7f6b4b4abf3fe1ffa6c61888",
      "value": "Making predictions: 100%"
     }
    },
    "e7cefdac24f84d6984b4edd909b4847f": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "e9886b40b5164e2c81f1e7b54dae66a4": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "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": ""
     }
    },
    "ebf4633360e945f09320825aa13dc84e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "fb55efa8f0b64c59ab6b8036ac667a71": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "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
     }
    },
    "fc089d60cd25438eb801da1881d51c84": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "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": ""
     }
    },
    "ffe4ea9e54ed4fb79e085cf8f4eb70a0": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "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_160e8fefd7534ec8a1a3fe6eae7fac42",
      "placeholder": "​",
      "style": "IPY_MODEL_bee3dc7c2f454eec9ade50dc94ce9630",
      "value": " 313/313 [00:01&lt;00:00, 230.54it/s]"
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}