JNotebooks/fully_connected_NN_mnist_pytorch.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step-by-step MNIST Digits Classification - Simple Fully Connected Neural Network for MNIST Classification - PyTorch\n",
    "\n",
    "In this example, we will see how to implement a simple fully connected neural network using PyTorch for classifying the digits in the MNIST dataset.\n",
    "\n",
    "1. Set your data loader, explore your data \n",
    "\n",
    "2. Define your model\n",
    "\n",
    "3. Train your model with the appropriate loss function, optmizer, learning rate, batch_size, checkpoints, etc.\n",
    "\n",
    "    3.1 If you are satisfied with the train and validation performance go to the next step\n",
    "\n",
    "    3.2 If you are not satisfied with the train and validation performance go back to step 5\n",
    "\n",
    "4. Test your model on the test and extract relevant metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "import torch # pytorch main library \n",
    "import torchvision # computer vision utilities\n",
    "import torchvision.transforms as transforms # transforms used in the pre-processing of the data\n",
    "\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import torch.optim as optim\n",
    "\n",
    "# Check if GPU is available\n",
    "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
    "\n",
    "# Assuming that we are on a CUDA machine, this should print a CUDA device:\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to get thge statistics of a dataset\n",
    "def get_dataset_stats(data_loader):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    nb_samples = 0.\n",
    "    for data in data_loader:\n",
    "        data = data[0] # Get the images to compute the stgatistics\n",
    "        batch_samples = data.size(0)\n",
    "        data = data.view(batch_samples, data.size(1), -1)\n",
    "        mean += data.mean(2).sum(0)\n",
    "        std += data.std(2).sum(0)\n",
    "        nb_samples += batch_samples\n",
    "\n",
    "    mean /= nb_samples\n",
    "    std /= nb_samples\n",
    "    return mean,std\n",
    "\n",
    "# functions to show an image\n",
    "def imshow(img,stats):\n",
    "    img = img *stats[1] + stats[0]     # unnormalize\n",
    "    npimg = img.numpy() # convert the tensor back to numpy\n",
    "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train stats: (tensor([0.1307]), tensor([0.3016]))\n"
     ]
    }
   ],
   "source": [
    "batch_size = 256\n",
    "\n",
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor()]) # Convert the data to a PyTorch tensor\n",
    "\n",
    "# Load develpoment dataset\n",
    "devset = torchvision.datasets.MNIST(root='./data', train=True,\n",
    "                                        download=True, transform = transform)\n",
    "\n",
    "train_set_size = int(len(devset) * 0.8)\n",
    "val_set_size = len(devset) - train_set_size\n",
    "\n",
    "# Split the development set into train and validation\n",
    "trainset, valset = torch.utils.data.random_split(devset, [train_set_size, val_set_size], generator=torch.Generator().manual_seed(42))\n",
    "\n",
    "\n",
    "# Get the data loader for the train set\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "\n",
    "# Comopute the statistics of the train set\n",
    "stats = get_dataset_stats(trainloader)\n",
    "print(\"Train stats:\", stats)\n",
    "# Pre-processing transforms\n",
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "     transforms.Normalize((stats[0]), (stats[1]))])\n",
    "\n",
    "\n",
    "# Load the development set again using the proper pre-processing transforms\n",
    "devset = torchvision.datasets.MNIST(root='./data', train=True,\n",
    "                                        download=True, transform = transform)\n",
    "\n",
    "# Split the development set into train and validation\n",
    "trainset, valset = torch.utils.data.random_split(devset, [train_set_size, val_set_size], generator=torch.Generator().manual_seed(42))\n",
    "\n",
    "# Get the data loader for the train set\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "\n",
    "# Get the data loader for the test set\n",
    "valloader = torch.utils.data.DataLoader(valset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "\n",
    "# Get the test set\n",
    "testset = torchvision.datasets.MNIST(root='./data', train=False,\n",
    "                                       download=True, transform=transform)\n",
    "\n",
    "# Get the data loader for the test set\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\n",
    "                                         shuffle=False, num_workers=2)\n",
    "\n",
    "classes = ('zero', 'one', 'two', 'three',\n",
    "           'four', 'five', 'six', 'seven', 'eight', 'nine')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "four  two   eight eight three three two   five \n"
     ]
    }
   ],
   "source": [
    "# get some random training images\n",
    "dataiter = iter(trainloader)\n",
    "images, labels = next(dataiter)\n",
    "\n",
    "# show images\n",
    "imshow(torchvision.utils.make_grid(images[:8]), stats)\n",
    "# print labels\n",
    "print(' '.join(f'{classes[labels[j]]:5s}' for j in range(8)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Net(\n",
       "  (fc1): Linear(in_features=784, out_features=120, bias=True)\n",
       "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
       "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(28*28, 120)\n",
    "        self.fc2 = nn.Linear(120, 84)\n",
    "        self.fc3 = nn.Linear(84, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = torch.flatten(x, 1) # flatten all dimensions except batch\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "net = Net()\n",
    "net.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss() # Loss function\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) # Optimizer used for training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1,  train loss: 2.063, val loss: 1.580\n",
      "Saving model\n",
      "2,  train loss: 0.971, val loss: 0.657\n",
      "Saving model\n",
      "3,  train loss: 0.532, val loss: 0.480\n",
      "Saving model\n",
      "4,  train loss: 0.423, val loss: 0.417\n",
      "Saving model\n",
      "5,  train loss: 0.374, val loss: 0.380\n",
      "Saving model\n",
      "6,  train loss: 0.344, val loss: 0.356\n",
      "Saving model\n",
      "7,  train loss: 0.323, val loss: 0.337\n",
      "Saving model\n",
      "8,  train loss: 0.306, val loss: 0.324\n",
      "Saving model\n",
      "9,  train loss: 0.292, val loss: 0.311\n",
      "Saving model\n",
      "10,  train loss: 0.280, val loss: 0.300\n",
      "Saving model\n",
      "11,  train loss: 0.269, val loss: 0.290\n",
      "Saving model\n",
      "12,  train loss: 0.259, val loss: 0.281\n",
      "Saving model\n",
      "13,  train loss: 0.250, val loss: 0.273\n",
      "Saving model\n",
      "14,  train loss: 0.242, val loss: 0.265\n",
      "Saving model\n",
      "15,  train loss: 0.235, val loss: 0.258\n",
      "Saving model\n",
      "16,  train loss: 0.227, val loss: 0.250\n",
      "Saving model\n",
      "17,  train loss: 0.221, val loss: 0.244\n",
      "Saving model\n",
      "18,  train loss: 0.215, val loss: 0.240\n",
      "Saving model\n",
      "19,  train loss: 0.209, val loss: 0.234\n",
      "Saving model\n",
      "20,  train loss: 0.203, val loss: 0.228\n",
      "Saving model\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "nepochs = 20\n",
    "PATH = './cifar_net.pth' # Path to save the best model\n",
    "\n",
    "best_loss = 1e+20\n",
    "for epoch in range(nepochs):  # loop over the dataset multiple times\n",
    "    # Training Loop\n",
    "    train_loss = 0.0\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        # get the inputs; data is a list of [inputs, labels]\n",
    "        inputs, labels = data[0].to(device), data[1].to(device)\n",
    "        \n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward + backward + optimize\n",
    "        outputs = net(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        train_loss += loss.item()\n",
    "    print(f'{epoch + 1},  train loss: {train_loss / i:.3f},', end = ' ')\n",
    "    \n",
    "    val_loss = 0\n",
    "    # since we're not training, we don't need to calculate the gradients for our outputs\n",
    "    with torch.no_grad():\n",
    "        for i, data in enumerate(valloader, 0):\n",
    "            # get the inputs; data is a list of [inputs, labels]\n",
    "            inputs, labels = data[0].to(device), data[1].to(device)\n",
    "            \n",
    "            outputs = net(inputs)\n",
    "            loss = criterion(outputs, labels)\n",
    "            \n",
    "            val_loss += loss.item()\n",
    "        print(f'val loss: {val_loss / i:.3f}')\n",
    "        \n",
    "        # Save best model\n",
    "        if val_loss < best_loss:\n",
    "            print(\"Saving model\")\n",
    "            torch.save(net.state_dict(), PATH)\n",
    "        \n",
    "print('Finished Training')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the best model to be used in the test set\n",
    "net = Net()\n",
    "net.load_state_dict(torch.load(PATH))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAB5CAYAAAAtfwoEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAwVElEQVR4nO29e2yd533n+XnO/X7n4Z0iKYqSbCuSbcUeO3GTpnGbmRaTRYEG7ewsUmyB/LOLnVkMsE2nfwxm/gqwi8EOsHNBMO00s1s0Ldo0TdOZbnqx46Z2PY5ly5Iiy6JJirdDnvv9fs4zf5DP40OJlEiJEsnD5wMckHx5Lu/znvf9vc/zu3x/QkqJwWAwGPoHy2HvgMFgMBgOFmPYDQaDoc8wht1gMBj6DGPYDQaDoc8wht1gMBj6DGPYDQaDoc94JMMuhPiSEOKWEGJOCPH1g9opg8FgMDw84mHz2IUQVuAj4FVgBXgH+BUp5U8ObvcMBoPBsF9sj/DaF4A5KeU8gBDi28CXgV0Nu9VqlTbbo3ykwWAwnDyazWZaSjmw1+c/ipUdBZZ7/l4BXrz7SUKIrwFfA7BarYyOjj7CRxoMBsPJY2Fh4c5+nv8oPnaxw7Z7/DpSym9KKS9LKS9brdZH+DiDwWAw7IVHMewrwHjP32PA2qPtjsFgMBgelUdxxbwDnBFCTAGrwC8D/2i/byKlxAiR7Q8hBEJsXzCZ47h/djqOYI7lflHH0JyTj85u5+R+eWjDLqVsCyH+V+D/B6zAb0spb+zzPajX6zQaDXMC7BEhBG63G6fTuW17u92mVqvR6XQOac+OHw6HA7fbjcXyycK12+1Sq9VoNpuHuGfHC6vVitvtxm63621SShqNBvV63Vzbe0QIgdPpxOVyPbJxf6QUFSnlfwH+yyO8nnq9TrFYNF/+HrFarVgsFhwOx7Yvv9VqUSqVaLVah7h3xwuv14vT6bzHsFerVSqVyiHu2fHCbrfrRy/NZpNisUi32z2kPTteCCEIBoM4nc7DNewHhVmy7Z37XSTmOB4M5jjuj92Ol9pujuXeOahjZSQFDAaDoc8wht1gMBj6DGPYDQaDoc8wht1gMBj6jCMRPDX0D3uJ5ptgmsHweDGG3bBvbDYbAwMDhMNhXVAhhNB54VarlUAgQCAQ2JZKWK/XSaVSVKtVGo0GlUqFdrtNoVAgn88bg28wHBDGsBv2jcPhYGZmhnPnzmGxWLDb7VgsFvx+P/F4HJfLxeTkJKdPn96W25xOp7ly5QobGxvkcjnW1taoVqvcvn2bUqlEu90+xFEZDP2DMeyGPWO1WrHZbLjdbkKhELFYTG9Ts/TBwUHcbjejo6NMTEzQK9PsdrtJJBJIKbHZbNRqNRwOBx6PB4vFghDCzNofAuX+slqtOBwOLBYLnU6HdruNlJJut3vii4SEEFitVqxWK0IILBYLFotlW659u93Wk4vjfh4aw27YExaLhZmZGc6fP08wGOS5557j7Nmz+gIRQuByufD5fNhsNiKRyD2G2u12c/r0aeLxOPl8npGRESqVCo1Gg6WlJWq1GvV63VTP7gOLxYLX68XhcDA+Ps5nP/tZotEoy8vL3L59m2q1yurqKhsbG8feWD0MFosFq9WK0+lkZmaG0dFRvF4vY2NjBAIBarUaxWKRZrPJRx99xM2bN2k2m9Tr9WMtK2EMu2FPWCwWpqen+bmf+zmi0ShPP/00U1NT24KlvQJGytj34na7mZ6eRkpJuVwmk8lQqVRYXV3lypUrWK1WOp2OMez7wGq14vV68fl8PPPMM/zqr/4qZ86c4e233+YHP/gB6XSaVqtFMpk8sYbdZrPh8/l4+umnef755xkYGOCFF15geHiYXC5HIpGgVCrx53/+52xsbFAul+l0OsawG/oXh8OB1+vF5XIRi8WIRCKEQiE8Hg8OhwNAz8yllHQ6HaSUNJtNvaxVs3rlj1cuA7fbTbfbxev14vf7tU6LYe+ooLXL5cLlcuHxePB4PDidTq0rdJJRht1ut+P3+4lGo4TDYXw+Hx6Ph3a7TaVS0TEir9dLt9s99lpBxrAb7svY2Bgvv/wysViMZ599losXL+LxeAgGg8D29MZGo0GxWKTVapFOp0mlUkgp8Xq9uN1uPB4Po6Oj+Hw+HA4HoVAIt9vN5OQkn/rUp8hms3zwwQcUCoXDGu6xw2azEQ6HicfjRCIRbDabVlYslUqUSqVjPfN8VBwOB36/n3A4zJkzZ7h8+TJutxu/34+UEpfLxeDgIMFgkKmpKc6ePUsul6PZbB7r89AYdsN9iUajPPfcc4yNjTEzM8OpU6fuUfFTtNttyuUy9XqdRCLB/Pw8UkoikQh+v18HXP1+PzabDZvNhsPhIB6Pc+rUKbxeLwsLCyaIug+sVis+n49wOIzf78dqtepAYK1Wo1arndhsIyEEdrtdx35GRkY4ffr0tlWM3W7XAfx4PM7IyAhOp5OlpaVD3PNHxxh2wz0oWWCbzUYwGCQajRKNRvF6vXqG3mw26XQ61Go1kskklUqFSqVCJpOh0WiQSCRYXV1FSkk6ncbr9RKPx3XWjHLHqM9Thv4gmgycJCwWizZcSqNffS/ZbJZsNkutVjtRN8reDJhoNMrU1BSDg4MEAoFdm4L0vrYfMIbdcA92u52BgQG8Xi9TU1M89dRTjI+Pa4Pc6XQoFouUSiVWVlb4sz/7Mz7++GPq9brWhFeGXkqJ0+nEZrMxMzOjLy6fz0c0GtWzKo/Hg9vt3pYeaXgwKgNpZGSESCQCbN50k8kkN2/eJJlMnrhmFzabDZfLhdPp5OLFi7z66qtEIhFOnz59YB2Kjjp9dxXt1urMsHdURxyfz0cgECAcDuv0ReUmaTabVKtVstkst27d4oMPPqDZbFKpVHRmi/Lt2mw2HTjN5XJUq1UcDgdSSp1T3JtjbNg7asaumob0umFyuRz5fP6wd/GJo841p9NJLBZjenqaUChEIBDY0+t7Z/XH1XYce8PudDoJh8M4nU4CgYAOILVaLV2goR5qedpoNHQBR7fbpdlsnugA0930ygOoTk3KmCvjffXqVebm5lhbW2NtbU3LA7RarW0FMTabjeHhYaLRKDMzM8TjcYLBoC5KklJSKpVIJBKk02mq1eqxvZieFL0t1GKxGJOTk5w9exa3200mkyGfz5NOp09Um0Sn00k8Hsfr9RIIBPTv58+fJx6Pb3NV7YQQAq/Xy8DAAHa7nampqW03yVarRb1e1xOXo86xN+xer1ffkaenp7lw4QIul4tqtUq1WqXb7WoDnkqluHHjBrlcTn9JSqvEGPZPsFqteDwe/H6/dr8AVKtVcrkcmUyGv/7rv+a1116jWq2yvr6u3S7KKKufTqeTM2fOcP78ecbHxzl16hTxeFzP0FutFplMhtu3b5PNZo91JsKTQgihMz3Gxsb41Kc+xUsvvUQmk+HWrVsUCgVWV1dPVNDU5/Px1FNPMTIywuDgIGfPnsXv9zM5Ocnk5KROs90N1ZZuYmJCr07j8fi2GJKKH/WFYRdC/DbwC0BSSvnM1rYI8PvAJLAIfEVKmXt8u7k7NptNn+SxWIyhoSHcbrf28SrDrr6McDgMQK1W0zP73vLrg6TXyHU6Hbrd7rFpFdZbZl2r1ahWq5TLZYrFIoVCgXQ6zcbGhm5YvNvJrmZC4XCYYDComx73+jrb7Tb1ev2+72P4BCEENptNz9pVHUCxWKRWq1EoFE5cwNRmsxEIBIhGowwMDBCPx/H7/bqH6INiNyrW4/V6AQiFQrRaLarVKs1mE5vNRr1e1zbjqF/He5mx/w7w/wD/uWfb14G/klJ+Qwjx9a2/f/3gd+/BhMNhnnvuOaamphgeHmZqagqn06ndBkorQ1U7Tk9Pa3VBlQqWyWTI5XIH+kWpXGLli15cXCSbzerm3Ud5NtVoNFhbW6NQKOgbUiAQoFKpUCqVKJfL3Lx5k3K5vO2muRPKFXPu3Dmi0Sg+n2/HqlTD3hFC4PF4CIfDuhbAZrPRaDRYXFxkZWWF9fX1I32OHTQ+n49nn32WS5cu4fP5GBgY0DnseynSEkLoAGur1dJyF7VaTSuS3rp1i1arRS6Xo1KpUC6Xj6xxf6Bhl1K+IYSYvGvzl4HPb/3+LeB1DsmwK92SCxcu4Pf7iUQiesl190HvNfKtVotGo0G73SadTpPJZA70S+p2u5RKJb2E+5u/+Rvm5+cpFotUq9UjfdGpdEUhBBsbG8zNzeFwOPSNSuWr78UfbrPZGBoa4uzZs/h8Prxe74mvhnxUhBC43W69CnK5XNjtdhqNBnfu3GFubo6NjY0Ttfrx+/1cvHiRz3/+89tWg3vNglGGXRXeKTvRbDbJ5XLUajWCwSCLi4vY7XZSqZR2Px5FHtbHPiilTABIKRNCiPhuTxRCfA34GnBfH9fD0ul0qFQqFItFpJRabVDNNNXnqpJ2lXmhAoQ2mw2v16ufr75Qla2x20nR+4X2Bmh7VQrVcrnb7RIMBgkEArRarcdyHA4adeyUbroS51LBUbUc3Q2Hw4HT6SQYDGpJAofDocfe7XbpdDo0Gg39ULnxhvujDLvK9FApqM1mU7vN1Gq1n1ECaG63m1gsti0zaD9jV+d672tUJpc61haLhXA4zMjICFarlUajQTKZPPAxHRSPPXgqpfwm8E0Ap9N54GdaKpXi9ddf56OPPiIUCjEwMIDVatUuAyUn63a7cblc2zJootGo9tEHAgE6nY6+KFRu9W6+ubvlPhuNBt1uV+t2CCF0Zk4mkyGbzeLxeLhz5w6JROLYaFG0Wi2KxSJCiG03vvsZYIvFwvj4ODMzM8RiMU6fPk0sFsPhcOiq1VqtRiaToVwus7y8zPLyMqVSyWjF7AGbzcbU1BSf/exnCYVCuFwuHdROJBKsra1pIat+xu1289JLL3HhwgXGx8cZGRnZt4uv3W7TbDZ1LK7dbmOxWPB4PLhcLu2773Q6XLx4kVAoRKFQ4Lvf/a5WJD2KPKxh3xBCDG/N1oeBQ7t1lUolbty4wcrKCuFwmKGhIaxWK+l0mmw2i81mY3BwEL/fj9/vZ2RkBK/Xy9DQkJ5JKvGfTqeD1WqlWq3icrkIhUK7ls8DWvCq1WrpC8nj8Wg/ssLj8XDq1CkdiLzfex41VBXjfhBCEI1GmZ2d1QFtNbNUM/ZGo0Eul6NYLJLJZLTSo8lOejBWq5XBwUHOnTunU1Kr1SqlUolcLkc2m33giqofcDgczM7O8rnPfY5wOKwTI5Rx38v4Vbpzb+2FkvkFtp2zXq+XyclJqtUq169fP9Ir74c17N8Dvgp8Y+vnnxzYHu2TdrtNqVTSS/tut4vFYqFQKFAsFrFarXS7XYrFIh6PRxvtbDZLPp/H5XJpN4maXVcqFTweD5FIZNfc194GBkpwqd1uMzY2xvT0NE6nc5tbRvn0+/mCU6scp9PJ0NCQTh3rDWCpm2GxWGRlZYVcLkcul9NB2H49NgeBkl5wOp06HVWpOKpzsfc66Ndjqdx8gUBAqzS6XC59jj3IFdNqtbQ4mkrhVTN3ZdhjsZjOqFE/FapyWsljlMvlIzdz30u64++xGSiNCSFWgH/BpkH/AyHErwFLwC89zp28H9VqleXlZe1bV/ojalml0pjUnVd1mFEpYg6Hg4GBAaLRKM1mk0QiQaFQ0LN7t9u94+cqF0y329VuhU6nwxe/+EW+8pWvEAqFcDqdOBwOOp0OpVKJTCZDqVTq2yVyIBDg1KlTBAIBXnzxRV599VWdiqriHioTaWFhgddee42NjQ0+/PBDXQTSr8boIFCaMGplOjY2hsVioVQqUa/Xtxmnfj2OQghCoRCDg4NEo1FGRkaIx+N4PB7sdvs2F+lulMtlbty4QSqVIpPJcOfOHWq1Gs1mk0ajgd1uZ2Jigng8zsDAAM8//zxDQ0Pb9mF0dJQXX3yRbDbLT37ykyMnGraXrJhf2eVfP3PA+/JQqODpflGVlSprY2BggEajwerqKrlcjmAwSC6Xw+Px7Ph6ZdiVXz6dTtNutzl37pwuYugNyvR2ZenXNmV2u51gMEg4HGZwcJCxsTG8Xu82qQC15C0Wi6yurpJIJPSMqV+N0UGhXAROpxO3261F2VS9Ru+jn1Gz9UAgoIOnaoV8d1LDTjSbTTKZDOvr62xsbDA/P6/dgI1GQ8tdqLhZo9HY9l69M3Ylv3HU5AeOfeXpw9LrW8vn87pIqVKpaBGrVCp1X1eMch1YLBYCgQB2u13P1G02mzbmmUyG1dVVFhcXSaVSfdshSGmsRyIRvF7vtswC2PSrr6+vazfM+vo6yWTySOcDHyVU9kev0qbKUOp3N59abdvtdqanp3nhhRcIh8Na7rk346oXlcmlKszL5TIbGxtcvXqV5eVl8vk8iURCpz63Wi29wlc3zEKhQKPR0K4wi8XC0NAQFy9eJJvNUq1WdWxO5bzD4WpUnVjDrmbbQggajQbpdHpbhagy7g+KskspiUajnDlzhlAopDUqnE6nLpFfXV3l1q1bXLt2TVdY9iNut5vBwUHi8TihUEg3uVbUajUWFhZYW1vj5s2bzM/P65VOv88yHxUlIzAxMUE0GtUqmWpmqVJS+/U42u12AoEAHo+HS5cu8Yu/+IsEg0Gde66keu9Gxb9qtRofffQRq6urrK2t8Zd/+ZfcuXNHp4gq96hKmc7n87on6iuvvMLo6Ki+eVitVqanpxkcHCSfz2O32wmHw6RSKX784x/rmb4x7IeE8sXtdDF0Op09+cKV4VfiQ0pbRQihBbN6HyoPvF9QMQyVIub1evUMSh2b3iBzsVgkn8/ri63RaBzyCI4PSo5WyTLAJyvPfnfz9Wr2K8lnJSbXW5sC2yU8lJS0CpKm02nS6bQO2ivXYK8RVrNvIYQuxKvX69vcLSoVUhU2xWIxWq2WjuEBh/pdnGjD/ij0FjiNjIzw8ssvMz4+zuzsLE6nk06nw+LiIteuXSORSLCxsUGtVus7H2g4HObSpUsMDg4yOTnJ5cuXCYVCjI+PY7PZaLfbJBIJstksq6ur/N3f/R2Li4usra317crlceFyuXTTE+XXrdfr3L59Wz/6uQ5AFRja7Xbcbveu+v3KiNdqNW7cuMH7779PpVJhbW2NTCZDsVjUTb53CrSqhIhOp8PGxgbXrl2j0WgwNjbGM888o5VJlbbMU089RSQSYW5ujtu3b1MqlfQq6rCudWPYHxKLxaIDWSMjI7z00kucPXtWu2FqtRp37tzh7bffJpvNsrGx0ZeGLBQK8fLLL/PMM88wNDTE7OwsXq9X+ylrtRpra2vMz8/r43H79m09yzTsHZfLRSQSIRqN6qB+vV5nbm6Od955h42Njb417KoSXHX3UgWHO1Gr1UgkEhSLRd566y3+9E//lHK5rNs2qpTQ3VwlSuK7Xq+TTCa5fv06+XyeRqPBzMyMjm8ogbtz584xOztLKBTi9ddf13IcaiJ3GBjD/pD0uh78fv+2SjW1FGw0GlSr1b7sO6kuNLvdjs/n09IBTqdTu2ZUNZ9K9VRNNlSgql8DfQeJUnJUUsqBQED3NlUa4Up1s1qt9m0q7d3crQGjstSU2F86nSafz5PL5SiXyzoGsZ8COPWe5XJZB16V/EVvK0e1alCTmaPQpckY9ofE7XYzOzvL2NgYTz/9tM5UUMGsarWq5W2LxWJfVVQKIbT2i9LPmJiYwOfz6ZubMjr5fJ7r16/zox/9iFwuRyqV0r5gY9gfjGqmoc63S5cuEQ6HcbvdrK+v62yrubk5nYt9ElFiXfV6nevXr/ODH/yAZDLJ/Pw8hUJBZ8bsl1qtxtLSEoVCgUAgwPLyMs1mU6f1HrYB3w1j2B8Su93OyMgIs7OzTExM6CrA3kBWtVqlWCxqedt+obfDktJa79WCUbN1FTxeXl7mxo0b1Gq1Iy9ZfNRQKbSqYG5qaopgMEihUKBQKJDNZkkmk6yvr+tsrpOIKgIslUosLS1x5coV1tbWdOD0YScRzWaTVCpFqVRiYmKCTCaDw+HQqb3GsPcJqpo0FArp6r9YLKazFHK5nC6VV52F+q2BhCrqUvr3KodfLUmllFSrVTKZjF6xqAyYfjoOTwK73Y7f7ycUCulso94qXqW62W9B+fuxkzGt1Wp8/PHHJBIJ5ufndQDzcU8iejNxHA4Hg4ODTExMkEwmD3USYwz7PrBarTp4NT4+zosvvsiLL76I2+3G7/fT7Xb58MMP+f73v086nebatWusra1pSdV+QanqvfLKK7rnpsoUsFgsOpvg+vXrpFIp7ty5oyUXTuqM8mFxu92Mj48zODjIyMiI7t3ZaDR0SXy1WtXH9aS4t+72Y6dSKb773e/y9ttvax+7KkA8iGOiPk89VOFd7z6Ew2FeeOEFhoeH+eCDD0gkEoeWIGAM+z5QTYRVyy11sSmD1u12yefzzM3NkUqlSCaTfdmcWSlmzs7O6mCe0umATeNSqVR0zrDSMum34/AkUHnbKmdbrYyUUqgKzJ+UY9trXHup1+ssLCxw/fr1x/KZd3/+TtuV7pSUkpWVlQe243ucGMO+D1TDW9UwVwnwK19yo9FgY2NDz6T6re+kkj5WPSVVPrUy6qrKr16vMz8/z7Vr13QhSD8dhyeJqrgMh8N4PB6EEFoGY2lpifX19SOnLPg48Pl8TE5OEgqFiEaj9xj2x3V+KWMdDAYZHh4mGo3q4PXdn1+pVJibm2NxcVFXtR4WxrDvA6vVysDAAGfOnNmmMd5oNFhZWaFYLLKwsMDS0hK5XK6v3A4Wi4VIJMLU1BQDAwNMTk4yMjKyTVGzUqno4/D+++/z+uuvUyqVKBaLh7z3xxeHw0E0GmVoaIhgMKhdXevr6/zkJz/RBTf9Tjgc5sKFCwwODjI+Po7Vat2T4Nej4na7mZiYYHh4mOnpaUZHR4nFYtviSSq2USgUePfdd3n//fd1gdRhYQz7PlCuGKUBrb5cJR5WLBb1zL3fyrvV2AOBgHYLKO2MXuXGer2umz7k83nTPOMRUPonTqfznhoJVSpfqVRORJaRCiKrHq+PMxul193TW6eh4htqIgNscz/25rxXq1UjKXDUUReYw+HQwcJIJILL5aLT6ZDNZnnvvfdYW1vj448/1tVt/eB+UCXcdrudU6dO8elPf5poNKolS+9Wb1RtAFXufr9p4zwJ1E3UZrMRCoUYHh5mbGwMt9ut0/eWl5e5ffu2rqjsd7xeLxMTE4yPjxONRh9LQ3R1nqt+DS6Xi4mJCZ599lmmp6cZGxu7p9pVSXKrug0laHfY174x7HtAaVSoZfHk5CR+vx+Xy0W32yWbzXL16lXm5ua0BGi/GDMlneByuRgfH+fy5ctab/1uNT1l2FWKo5KSNeyPXrmKYDDI0NAQo6OjWse+UCiwsrLC3NzcPVrh/YrX62V8fJzp6WlCodBjMexKZE1N4ILBINPT01y6dInz589r3fdeenst9Br2wzbuxrDvAYfDsW05ptwQKpe4Wq1SLpf7MvtDLYFVObvP59NaMIAuilEFIqrnZj9mAz0pLBYLbrdbH2sl06AaQajc9d5mLv2OWjWrVeLjeH/V59jpdOoOTfF4XE/i7Hb7NoVHde7n83mKxSLZbHabcT9MjGF/AEIIhoeHtYLbU089xcjICFJKLdK/sLDAnTt3WF5e7rtipGg0ynPPPUckEuHChQtMTEzorjWwmWa2srJCqVTi6tWr/PCHP2RjY4NEInEifL+PA6fTydTUFGNjY5w7d07LVRQKBa2UWSwWzY3zALFYLExMTHDx4kWCwSBPP/00p06dwu/36zqN3ptKvV7XldRvvfUWN2/eZH19nYWFBfL5/KEb9730PB0H/jMwBHSBb0op/40QIgL8PjAJLAJfkVLmHt+uHh6hUIjZ2VlisRijo6NEIhHq9Tqrq6skk0mSySSpVIp0On3Yu3rg+P1+3VRgYmKCWCy2bTmqSq7T6TTz8/PcuHGDjY0NXRxi2D92u53BwUGdhaHkKtrtNrlcri9TaQ8bi8XCwMAA58+fJxqN8uKLL3Lu3Lkdg7TK/VKpVMjn89y8eZO//du/pVgs6tqVw2YvM/Y28M+klFeEEH7gXSHEXwC/CvyVlPIbQoivA18Hfv3x7eqTxWaz6YKQeDzO2NgY0WgUn8+nm0akUimWlpZIJpN9m/mhuiKNjo7qdLvek73RaJBIJHRO9VFZih5nVDZG7/IfPsm8MMf34AgEAroZ9qlTp4jFYtods5tKo5SSVqtFrVajUqnolN5yuXxkJjN7aWadABJbv5eEEDeBUeDLwOe3nvYt4HX6yLB7vV4dJL18+TJf+MIXCIVCeDwerSR35coV3nvvPTY2NiiVSoe9y4+FWCzGpz/9aaanp/H7/fdU0+XzeX70ox/x7rvvks1myeVyNJtNM5t8BKxWKz6fT4t/9abV9gbpDI/O5OQkP//zP68nb+Pj49rXvhtKCymVSrGxscHS0hLz8/O02+0j0xFsXz52IcQk8CzwNjC4ZfSRUiaEEPFdXvM14GvAjj0Jjyq9FX/xeFzPWFVqk+qTurKyomVB+xGXy8XAwADDw8P3zNbhkwbVi4uLWujLzCYfjd1m7Erf3szY98f9ct6DwSCnT59mdHSUcDhMNBrFbrfv2sRe0Wq1qFarVCoVnThxlCYzezbsQggf8EfAP5VSFvdaICCl/CbwTQCn03l0Rr4DKvJusViIRqM888wzDA8PMzk5qcvmi8UiuVyOtbU1NjY2SKfTVKvVEzWDklLqi0X1onQ4HFqqdy/L0d4uNr0XRO/7qkcvKjPCbrfrUu8H7Wuz2WRtbY1sNrtrj9ujhM1mIxKJaPdfb2VvIpEglUpRLpePlCF5UuymFaNSFEdGRvQ2i8XC8PAwo6Oj2Gw23Qijl7NnzzIzM0M4HNb9etX5tZuN63a73LlzhzfeeINMJsP6+vqR+y72ZNiFEHY2jfrvSim/s7V5QwgxvDVbHwaSj2snnxSqMMRutzM2NsZP/dRPcebMGa2JIqXUQcKVlRUWFxdZWlrSRuqk0HvCq5xrpZuz1ybgatmqcn6VsVXKearisvdCVEJLSojt+eefZ2ZmZtcLUBnxYrHID3/4Q+0DPeozXofDwejoKGfPntWduVQWlhKYUzepk8RuYlywubIcGxtjdnZWb7PZbHzmM5/hp3/6p7XRvlvjRZ1LqoJaTSR2Wp0qOp0O169f59vf/rauNj9q7CUrRgC/BdyUUv7rnn99D/gq8I2tn3/yWPbwCdJrpPx+P5FIhEgkgtfrBT5pclssFrXGeL8GTfeKyrlWCo9KpOpBNBqNbTcCZWjViqk3eN2Ly+XS0gaxWIzBwcFdP0OtBlQdgtPp1PnfRxFlrFShjMfjwel0amOjpAROmqIjfJIzvttNWalghsNhvU0lPoyOjuLz+fD5fPcY9t4bRK88wE4oOYdWq0WpVCKdTh/Zqt+9zNg/A/xPwDUhxPtb2/45mwb9D4QQvwYsAb/0WPbwCSGEIBAI8PLLLzMzM6PziNVSX5Vyf/jhh7z55ptkMhkymcwh7/XhE4vF+NKXvsSFCxdot9t71shR7izVbUoFnZRf2ev1MjY2hs/n06/p7f/pdDoZHx8nFovdd8auZrrpdBqr1apnvYVC4WAOwAGhlEP9fj/Dw8O6sYbNZnssBTnHjUKhwIcffki5XObMmTMEg8FtN/1gMMgrr7zC7OysNswWi0V3nFINSh50M7zbNdhLNptldXVV1xMc5VXfXrJifgTs5lD/mYPdncNB3bX9fr9uIBEKhRgbG8Pr9WpBK3Vyvfnmm1QqFbLZ7GHv+qETjUb52Z/92X3NgqWUrK6ucuPGDd1ouFKp6K7vLpeLaDTKhQsXGBgY2PE9ervWP4h8Pk8mk8FqtbKyskIikThyht1isWhpWGXYe5uXHGUj8iRQ1142m8Xr9TI7O3uPYf/MZz6jDbMyziomc7+bP6ArSu83W8/lclpRM5FIHNmVH5jKU2B7ANDr9RIMBvVsSQhBo9HQuuKqG3ytVjvSX+xB0bv8V/7tXlRcYj9IKXU6n8r+cLlcWCwW7X4IhUI7Lp13QgVtla/+bjeFUtw8yiX4vcqhSrLBYrHonOlOp0Oj0dCPkxSsh82YTKlUwul0aldUp9PZ1tGoNx6zXzeViscojZfec6lSqdBqtUgkEiSTSbLZLJVK5Ui7wk68YRdC4PF48Hq9xGIxhoaGGBkZ0UpvUkqWl5d57bXXyGQy3Lhxg3Q6TavVOhH+9XK5zOLiIlJKBgcHGR4e3pbL/rDyqcFgkNnZWZ2+pwyVylxQN1mFMsg7XUzlcpnV1VWtdJjL5bYZvkqlwo0bN3SLvsNqV3Y/LBYL8Xic8+fPa+11NanI5/PUajUdsD+JWTHFYpG5uTmSySSnT5/WdSMq2eEgUGnM6iZSrVZJJpO88847WsphZWWFWq3G2trakb65GsPeM1NSTYMjkYj+f7fb1f1LU6kUy8vLlEqlIzvzO2hqtRrJZBKHw4Hb7WZoaOiR31PdTD0ez56ef/fy+m6DVq/X2djYIJvNaj9ob6FIo9Hgzp07usHwUaw5UK6Y0dFRBgYGtnVLUlWN6XSaZDJJJpM5Meefolarsb6+TrFY1DdnJW18UIZdrYpUAWKhUGBhYYE33niDW7duaQ38drt95OWoT6xhV+4Xu93OyMiIDpYGAgFg01gotbbV1VUymYzuinKSZkqlUomPP/5Ypwo6HI775vjCJ0HOXm1rVaLd+xz4pIqvUqnope/dLq5Go6E/v9Vq0Wq1tn0HpVKJhYUFna2USqW2Ge9Wq6U7DR3FmgPlRvB6vYTD4W2BwWazqeM76hicpPNPodxtFouFZDLJ7du3dQFhIBDA4XAQCAT25BbsrcPo3VYsFnWrweXlZVKplK5/UBlw6vw8ykYdTrBhV7N0n8/H5z73OV599VWCwSBTU1PAZtfzN998k2QyyZUrV7h27VpfyvI+iKWlJf74j/8Yt9vNxYsXWVxc1Cl4uxl3i8VCIBAgFArhdruZnp7eVjjSS7fbZW1tjbm5OZrNJqVS6Z6bZzKZZH5+nmq1qvXIey+sTqejDbbKzOl9vdL26fVVHxVUcM/lcjE0NMTZs2d1g3DYdDMpnf+VlZW+68y1V1qtFoVCgUqlwrvvvkuj0cDn8+lzKxKJcPHiReLxHQvgt7HTedvpdFhcXOTtt98ml8tx9epV3TRHGfbeepWjbgNOrGFXKXMej4eRkRHOnTuHx+PRF1S9XtcXk7prH8VChMeN8lsr/ZKBgQFcLtd9dbGFEESjUVqtFl6vl5GREbrd7q4XVLlcJpVKUavVyOfz23KD786gUR2a+sm4qRm72+3WQWM1Y1d635lMhnK53Ffj3g+9wcxUKsXc3Bw+n08nOKgg/4Ny0XvpnbmrQja1Or99+zYffvjhYx3T4+TEGnY1O1daMKqARUXWm80m2WxWC3ydhAyY+yGlJJPJcOvWLe2K2W3GLoTQMQun08n8/Pyu+ebdbpeVlRWWl5dpNptUq9V7ugIpqdp6vd6XHYNUFoZabdRqNVKpFIVCgTt37vDRRx+xvLzM+vr6kXMjHQaVSoVUKqUDqOl0mlgshpSS4eFhfD6flmLw+XwEAgGklHrGX6/XSafTutm0EIJ2u83Vq1dZWlrSLrvjzIk07EIIYrEYly5dIhaLMTU1pVPvlPGp1Wqsrq6yuLhIOp0+8YZdGeBkMnlfo65Qs1AlaHW3KmQvKsNIGbi7DbfyrR+FlmMHjRpzp9PRRr3VapFMJmm329y4cYN33nmHhYUF/b+TjPKFVyoVLBYLi4uL2Gw2gsEgc3NzxGIxxsfHuXjxIqFQiPHxcbxeL51Oh/X1dT0jf++990gmN1VQhBB0u13W19dJJBLU6/UjV+ewX06cYVcFH263m2AwqAtBVEWjQgVrVPpTPxmTh6XZbJ6IFM8nicr2UedbpVLBarXq3HuVnaGyMU6qK6aXnfSIOp0OGxsbtFotnE6ndtcFAgEddM7n87p1YzKZJJFIAJ8UJ2WzWcrlsg7QH2dOlGF3Op2Ew2FcLhdnzpzRM/bBwUHtL94pYm4wPC6UUW80Gly5coVarYbFYtEZGKlUikwmc+TT6w6bZrPJ+vo6hUKBXC5HMpnUMYtIJKIF/AqFAtVqlZWVlXtiOap/sdKlOc6cKMPucrmIx+MEAgFmZma4ePEi0WgUl8uljbkx6oYnTbfbpV6v895773Ht2jXgk+DfTpW0hntRfQGUm/DatWvbqlIB7cbbzeV3v1qJ48aJMuwWi0Wr5imVQIfDoV0wd5cS96NP13B06a3ANewfs6L5hBNl2F0uF8PDw8TjceLxOC6XC4fDsU0WtVwu02g0KBQKWnnQXGwGg+E4caIMu8PhIBwOMzAwoKvV7g6Y1ut1KpUK1Wp1W6WZmbUbDIbjwoky7LuhouCVSkULDc3NzWkJgbtL2A0Gg+Eoc+INu6o4y+fzrK+v853vfIcrV65QLBZZXl6mUqkcC20Ig8FgUJw4w96rFNibalapVMjlcnz88cdcv35ddyE/6YVJBoPh+HGiDHu5XGZ+fl7rvqTTaZxOpy4AUXrLqimDcb8YDIbjyIky7Pl8nitXrmC1Wnnrrbd0/rpytahuKUqPxBh2g8FwHHmgYRdCuIA3AOfW8/9QSvkvhBAR4PeBSWAR+IqUMrffHdiL7shB0e129yXucxSLle7X4/NJHst+4H4iZuY47p3dJJzVcTTHcm/cTwp7v+xlxt4AviClLAsh7MCPhBD/FfhF4K+klN8QQnwd+Drw6/v5cNW9KBgMmtnxHrFYLPc0rYDNlnJ+v9/EBPZBbw2DQvVdvZ9omWE7Vqt1x+Olrm2TeLA3hBDbquAfhQeevXLT4ipRBfvWQwJfBj6/tf1bwOs8hGFXFaCGvbHbl26z2fD7/eYGuQ92mk0qw76XJtqGTXabrTscDhwOhzkn98FBrXD2NC0RQliBd4EZ4N9KKd8WQgxKKRMAUsqEEGLH1iVCiK8BXwO2FQP1/N8s1Q4Ao3VzcJhz8mAw5+ThsbvDtgcpZUdKeQkYA14QQjyz1w+QUn5TSnlZSnl5J8NuMBgMhoNlT4ZdIaXMs+ly+RKwIYQYBtj6mTzonTMYDAbD/nmgYRdCDAghQlu/u4EvAh8C3wO+uvW0rwJ/8pj20WAwGAz7QDwosCGE+BSbwVErmzeCP5BS/ishRBT4A2ACWAJ+SUqZfcB7pYAKkD6AfT+KxDBjO46YsR1PTtLYTkkpB/b64gca9oNGCPFjKeXlJ/qhTwgztuOJGdvxxIxtd/blYzcYDAbD0ccYdoPBYOgzDsOwf/MQPvNJYcZ2PDFjO56Yse3CE/exGwwGg+HxYlwxBoPB0GcYw24wGAx9xhM17EKILwkhbgkh5rYUIY8tQohxIcRrQoibQogbQoh/srU9IoT4CyHE7a2f4cPe14dBCGEVQrwnhPj+1t/9Mq6QEOIPhRAfbn13L/XR2P73rXPxuhDi94QQruM6NiHEbwshkkKI6z3bdh2LEOI3tuzKLSHEzx3OXu+NXcb2f26dkx8IIf5YFYVu/W/fY3tihn1LSOzfAn8feAr4FSHEU0/q8x8DbeCfSSnPA38P+F+2xvN1NuWMzwB/tfX3ceSfADd7/u6Xcf0b4M+llOeAi2yO8diPTQgxCvxvwGUp5TNsFhT+Msd3bL/DpnRJLzuOZeu6+2Xg6a3X/Lste3NU+R3uHdtfAM9IKT8FfAT8Bjz82J7kjP0FYE5KOS+lbALfZlP691gipUxIKa9s/V5i00CMsjmmb2097VvA/3AoO/gICCHGgJ8H/mPP5n4YVwD4KeC3AKSUzS39o2M/ti1sgFsIYQM8wBrHdGxSyjeAuyvZdxvLl4FvSykbUsoFYI5Ne3Mk2WlsUsofSCnbW3/+HZuCi/CQY3uShn0UWO75e2Vr27FHCDEJPAu8DWyTMwZ2lDM+4vzfwP8B9HZI6IdxTQMp4D9tuZn+oxDCSx+MTUq5CvxfbMp7JICClPIH9MHYethtLP1mW/5n4L9u/f5QY3uShn0nUeZjn2sphPABfwT8Uyll8bD351ERQvwCkJRSvnvY+/IYsAHPAf9eSvksm7pFx8U1cV+2/M1fBqaAEcArhPjHh7tXT4y+sS1CiN9k0837u2rTDk974NiepGFfAcZ7/h5jc6l4bBGbrQL/CPhdKeV3tjYfdznjzwD/UAixyKa77AtCiP+P4z8u2DwHV6SUb2/9/YdsGvp+GNsXgQUpZUpK2QK+A7xMf4xNsdtY+sK2CCG+CvwC8D/KTwqMHmpsT9KwvwOcEUJMCSEcbAYEvvcEP/9AEZttYX4LuCml/Nc9/zrWcsZSyt+QUo5JKSfZ/I7+Wkr5jznm4wKQUq4Dy0KIs1ubfgb4CX0wNjZdMH9PCOHZOjd/hs24Tz+MTbHbWL4H/LIQwimEmALOAP/tEPbvoRFCfInN1qL/UEpZ7fnXw41NSvnEHsA/YDPi+zHwm0/ysx/DWD7L5pLoA+D9rcc/AKJsRuxvb/2MHPa+PsIYPw98f+v3vhgXcAn48db39l0g3Edj+5ds9kq4Dvy/gPO4jg34PTZjBS02Z62/dr+xAL+5ZVduAX//sPf/IcY2x6YvXdmS//AoYzOSAgaDwdBnmMpTg8Fg6DOMYTcYDIY+wxh2g8Fg6DOMYTcYDIY+wxh2g8Fg6DOMYTcYDIY+wxh2g8Fg6DP+O3Ejdnr1tCoHAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GroundTruth:  seven two   one   zero \n"
     ]
    }
   ],
   "source": [
    "dataiter = iter(testloader)\n",
    "images, labels = next(dataiter)\n",
    "\n",
    "\n",
    "# print images\n",
    "imshow(torchvision.utils.make_grid(images[:4]), stats)\n",
    "print('GroundTruth: ', ' '.join(f'{classes[labels[j]]:5s}' for j in range(4)))\n",
    "outputs = net(images)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted:  seven two   one   zero \n"
     ]
    }
   ],
   "source": [
    "_, predicted = torch.max(outputs, 1)\n",
    "\n",
    "print('Predicted: ', ' '.join(f'{classes[predicted[j]]:5s}'\n",
    "                              for j in range(4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on the 10000 test images: 94.0 %\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "# since we're not training, we don't need to calculate the gradients for our outputs\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        # calculate outputs by running images through the network\n",
    "        outputs = net(images)\n",
    "        # the class with the highest energy is what we choose as prediction\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "print(f'Accuracy of the network on the 10000 test images: {100 * correct / total} %')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for class: zero  is 98.3 %\n",
      "Accuracy for class: one   is 97.6 %\n",
      "Accuracy for class: two   is 93.0 %\n",
      "Accuracy for class: three is 93.5 %\n",
      "Accuracy for class: four  is 93.7 %\n",
      "Accuracy for class: five  is 89.8 %\n",
      "Accuracy for class: six   is 95.7 %\n",
      "Accuracy for class: seven is 93.4 %\n",
      "Accuracy for class: eight is 91.0 %\n",
      "Accuracy for class: nine  is 93.3 %\n"
     ]
    }
   ],
   "source": [
    "# prepare to count predictions for each class\n",
    "correct_pred = {classname: 0 for classname in classes}\n",
    "total_pred = {classname: 0 for classname in classes}\n",
    "\n",
    "# again no gradients needed\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        outputs = net(images)\n",
    "        _, predictions = torch.max(outputs, 1)\n",
    "        # collect the correct predictions for each class\n",
    "        for label, prediction in zip(labels, predictions):\n",
    "            if label == prediction:\n",
    "                correct_pred[classes[label]] += 1\n",
    "            total_pred[classes[label]] += 1\n",
    "\n",
    "\n",
    "# print accuracy for each class\n",
    "for classname, correct_count in correct_pred.items():\n",
    "    accuracy = 100 * float(correct_count) / total_pred[classname]\n",
    "    print(f'Accuracy for class: {classname:5s} is {accuracy:.1f} %')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch1.11",
   "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.10.4 | packaged by conda-forge | (main, Mar 30 2022, 08:38:02) [MSC v.1916 64 bit (AMD64)]"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "249d11310564531dbb0422c65726fbafe5d71a3f15733fe196d56460bed7c227"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}