Chapter05.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Learning with PyTorch Step-by-Step: A Beginner's Guide"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.container { width:80% !important; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.core.display import display, HTML\n",
    "display(HTML(\"<style>.container { width:80% !important; }</style>\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    import google.colab\n",
    "    import requests\n",
    "    url = 'https://raw.githubusercontent.com/dvgodoy/PyTorchStepByStep/master/config.py'\n",
    "    r = requests.get(url, allow_redirects=True)\n",
    "    open('config.py', 'wb').write(r.content)    \n",
    "except ModuleNotFoundError:\n",
    "    pass\n",
    "\n",
    "from config import *\n",
    "config_chapter5()\n",
    "# This is needed to render the plots in this chapter\n",
    "from plots.chapter5 import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from torchvision.transforms.v2 import Compose, Normalize\n",
    "\n",
    "from data_generation.image_classification import generate_dataset\n",
    "from helpers import index_splitter, make_balanced_sampler\n",
    "from stepbystep.v1 import StepByStep"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convolutions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filter / Kernel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/conv1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1, 6, 6)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "single = np.array(\n",
    "    [[[[5, 0, 8, 7, 8, 1],\n",
    "       [1, 9, 5, 0, 7, 7],\n",
    "       [6, 0, 2, 4, 6, 6],\n",
    "       [9, 7, 6, 6, 8, 4],\n",
    "       [8, 3, 8, 5, 1, 3],\n",
    "       [7, 2, 7, 0, 1, 0]]]]\n",
    ")\n",
    "single.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1, 3, 3)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "identity = np.array(\n",
    "    [[[[0, 0, 0],\n",
    "       [0, 1, 0],\n",
    "       [0, 0, 0]]]]\n",
    ")\n",
    "identity.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convolving"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/conv2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "region = single[:, :, 0:3, 0:3]\n",
    "filtered_region = region * identity\n",
    "total = filtered_region.sum()\n",
    "total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/conv3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Moving Around"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/stride1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_region = single[:, :, 0:3, (0+1):(3+1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/conv5.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_filtered_region = new_region * identity\n",
    "new_total = new_filtered_region.sum()\n",
    "new_total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/conv6.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/conv7.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "last_horizontal_region = single[:, :, 0:3, (0+4):(3+4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (1,1,3,2) (1,1,3,3) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[10], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mlast_horizontal_region\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43midentity\u001b[49m\n",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (1,1,3,2) (1,1,3,3) "
     ]
    }
   ],
   "source": [
    "last_horizontal_region * identity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/conv8.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\Large\n",
    "(h_i, w_i) * (h_f, w_f) = (h_i - (h_f - 1), w_i - (w_f - 1))\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\Large\n",
    "(h_i, w_i) * f = (h_i - f + 1, w_i - f + 1)\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convolving in PyTorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = torch.as_tensor(single).float()\n",
    "kernel_identity = torch.as_tensor(identity).float()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[9., 5., 0., 7.],\n",
       "          [0., 2., 4., 6.],\n",
       "          [7., 6., 6., 8.],\n",
       "          [3., 8., 5., 1.]]]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "convolved = F.conv2d(image, kernel_identity, stride=1)\n",
    "convolved"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[-1.1368, -1.7877,  1.1727, -0.1205],\n",
       "          [-2.4004, -1.3590, -2.3216, -1.8754],\n",
       "          [-5.3097, -4.0190, -2.2523, -1.6204],\n",
       "          [-0.7945, -1.4882, -2.2404,  1.2865]]]],\n",
       "       grad_fn=<ConvolutionBackward0>)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conv = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=3, stride=1)\n",
    "conv(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([[[[-0.1466, -0.1951,  0.1140],\n",
       "          [ 0.2668, -0.2026, -0.0553],\n",
       "          [-0.2089,  0.2455, -0.0725]]],\n",
       "\n",
       "\n",
       "        [[[-0.1988, -0.1322,  0.2085],\n",
       "          [-0.1208,  0.0960,  0.1318],\n",
       "          [-0.2942, -0.1641,  0.0348]]]], requires_grad=True)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conv_multiple = nn.Conv2d(in_channels=1, out_channels=2, kernel_size=3, stride=1)\n",
    "conv_multiple.weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "with torch.no_grad():\n",
    "    conv.weight[0] = kernel_identity\n",
    "    conv.bias[0] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[9., 5., 0., 7.],\n",
       "          [0., 2., 4., 6.],\n",
       "          [7., 6., 6., 8.],\n",
       "          [3., 8., 5., 1.]]]], grad_fn=<ConvolutionBackward0>)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conv(image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Striding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/strider2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/strider3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\Large\n",
    "(h_i, w_i) * f = \\left(\\frac{h_i - f + 1}{s}, \\frac{w_i - f + 1}{s}\\right)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[9., 0.],\n",
       "          [7., 6.]]]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "convolved_stride2 = F.conv2d(image, kernel_identity, stride=2)\n",
    "convolved_stride2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Padding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/padding1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "          [0., 5., 0., 8., 7., 8., 1., 0.],\n",
       "          [0., 1., 9., 5., 0., 7., 7., 0.],\n",
       "          [0., 6., 0., 2., 4., 6., 6., 0.],\n",
       "          [0., 9., 7., 6., 6., 8., 4., 0.],\n",
       "          [0., 8., 3., 8., 5., 1., 3., 0.],\n",
       "          [0., 7., 2., 7., 0., 1., 0., 0.],\n",
       "          [0., 0., 0., 0., 0., 0., 0., 0.]]]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "constant_padder = nn.ConstantPad2d(padding=1, value=0)\n",
    "constant_padder(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "padded = F.pad(image, pad=(1, 1, 1, 1), mode='constant', value=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/paddings.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[5., 5., 0., 8., 7., 8., 1., 1.],\n",
       "          [5., 5., 0., 8., 7., 8., 1., 1.],\n",
       "          [1., 1., 9., 5., 0., 7., 7., 7.],\n",
       "          [6., 6., 0., 2., 4., 6., 6., 6.],\n",
       "          [9., 9., 7., 6., 6., 8., 4., 4.],\n",
       "          [8., 8., 3., 8., 5., 1., 3., 3.],\n",
       "          [7., 7., 2., 7., 0., 1., 0., 0.],\n",
       "          [7., 7., 2., 7., 0., 1., 0., 0.]]]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "replication_padder = nn.ReplicationPad2d(padding=1)\n",
    "replication_padder(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[9., 1., 9., 5., 0., 7., 7., 7.],\n",
       "          [0., 5., 0., 8., 7., 8., 1., 8.],\n",
       "          [9., 1., 9., 5., 0., 7., 7., 7.],\n",
       "          [0., 6., 0., 2., 4., 6., 6., 6.],\n",
       "          [7., 9., 7., 6., 6., 8., 4., 8.],\n",
       "          [3., 8., 3., 8., 5., 1., 3., 1.],\n",
       "          [2., 7., 2., 7., 0., 1., 0., 1.],\n",
       "          [3., 8., 3., 8., 5., 1., 3., 1.]]]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reflection_padder = nn.ReflectionPad2d(padding=1)\n",
    "reflection_padder(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[0., 7., 2., 7., 0., 1., 0., 7.],\n",
       "          [1., 5., 0., 8., 7., 8., 1., 5.],\n",
       "          [7., 1., 9., 5., 0., 7., 7., 1.],\n",
       "          [6., 6., 0., 2., 4., 6., 6., 6.],\n",
       "          [4., 9., 7., 6., 6., 8., 4., 9.],\n",
       "          [3., 8., 3., 8., 5., 1., 3., 8.],\n",
       "          [0., 7., 2., 7., 0., 1., 0., 7.],\n",
       "          [1., 5., 0., 8., 7., 8., 1., 5.]]]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F.pad(image, pad=(1, 1, 1, 1), mode='circular')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\Large\n",
    "(h_i, w_i) * f = \\left(\\frac{(h_i + 2p) - f + 1}{s}, \\frac{(w_i + 2p) - f + 1}{s}\\right)\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A REAL Filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 1, 3, 3])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "edge = np.array(\n",
    "    [[[[0, 1, 0],\n",
    "       [1, -4, 1],\n",
    "       [0, 1, 0]]]]\n",
    ")\n",
    "kernel_edge = torch.as_tensor(edge).float()\n",
    "kernel_edge.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/padding2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/padding3.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "padded = F.pad(image, (1, 1, 1, 1), mode='constant', value=0)\n",
    "conv_padded = F.conv2d(padded, kernel_edge, stride=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pooling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/pooling1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[22., 23., 11.],\n",
       "          [24.,  7.,  1.],\n",
       "          [13., 13., 13.]]]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pooled = F.max_pool2d(conv_padded, kernel_size=2)\n",
    "pooled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[24.]]]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maxpool4 = nn.MaxPool2d(kernel_size=4)\n",
    "pooled4 = maxpool4(conv_padded)\n",
    "pooled4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[24., 24., 23., 23.],\n",
       "          [24., 24., 23., 23.],\n",
       "          [24., 24., 13., 13.],\n",
       "          [13., 13., 13., 13.]]]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F.max_pool2d(conv_padded, kernel_size=3, stride=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Flattening"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[22., 23., 11., 24.,  7.,  1., 13., 13., 13.]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flattened = nn.Flatten()(pooled)\n",
    "flattened"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[22., 23., 11., 24.,  7.,  1., 13., 13., 13.]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pooled.view(1, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Typical Architecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LeNet5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/architecture_lenet.png)\n",
    "\n",
    "*Source: Generated using Alexander Lenail's [NN-SVG](http://alexlenail.me/NN-SVG/) and adapted by the author. For more details, see LeCun, Y., et al (1998).  [Gradient-based learning applied to document recognition](http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf). Proceedings of the IEEE,86(11), 2278–2324*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "lenet = nn.Sequential()\n",
    "\n",
    "# Featurizer\n",
    "# Block 1: 1@28x28 -> 6@28x28 -> 6@14x14\n",
    "lenet.add_module('C1', nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, padding=2))\n",
    "lenet.add_module('func1', nn.ReLU())\n",
    "lenet.add_module('S2', nn.MaxPool2d(kernel_size=2))\n",
    "# Block 2: 6@14x14 -> 16@10x10 -> 16@5x5\n",
    "lenet.add_module('C3', nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5))\n",
    "lenet.add_module('func2', nn.ReLU())\n",
    "lenet.add_module('S4', nn.MaxPool2d(kernel_size=2))\n",
    "# Block 3: 16@5x5 -> 120@1x1\n",
    "lenet.add_module('C5', nn.Conv2d(in_channels=16, out_channels=120, kernel_size=5))\n",
    "lenet.add_module('func2', nn.ReLU())\n",
    "# Flattening\n",
    "lenet.add_module('flatten', nn.Flatten())\n",
    "\n",
    "# Classification\n",
    "# Hidden Layer\n",
    "lenet.add_module('F6', nn.Linear(in_features=120, out_features=84))\n",
    "lenet.add_module('func3', nn.ReLU())\n",
    "# Output Layer\n",
    "lenet.add_module('OUTPUT', nn.Linear(in_features=84, out_features=10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Multiclass Classification Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "images, labels = generate_dataset(img_size=10, n_images=1000, binary=False, seed=17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x450 with 30 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_images(images, labels, n_plot=30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransformedTensorDataset(Dataset):\n",
    "    def __init__(self, x, y, transform=None):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.transform = transform\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        x = self.x[index]\n",
    "        \n",
    "        if self.transform:\n",
    "            x = self.transform(x)\n",
    "        \n",
    "        return x, self.y[index]\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Builds tensors from numpy arrays BEFORE split\n",
    "# Modifies the scale of pixel values from [0, 255] to [0, 1]\n",
    "x_tensor = torch.as_tensor(images / 255).float()\n",
    "y_tensor = torch.as_tensor(labels).long()\n",
    "\n",
    "# Uses index_splitter to generate indices for training and\n",
    "# validation sets\n",
    "train_idx, val_idx = index_splitter(len(x_tensor), [80, 20])\n",
    "# Uses indices to perform the split\n",
    "x_train_tensor = x_tensor[train_idx]\n",
    "y_train_tensor = y_tensor[train_idx]\n",
    "x_val_tensor = x_tensor[val_idx]\n",
    "y_val_tensor = y_tensor[val_idx]\n",
    "\n",
    "# We're not doing any data augmentation now\n",
    "train_composer = Compose([Normalize(mean=(.5,), std=(.5,))])\n",
    "val_composer = Compose([Normalize(mean=(.5,), std=(.5,))])\n",
    "\n",
    "# Uses custom dataset to apply composed transforms to each set\n",
    "train_dataset = TransformedTensorDataset(x_train_tensor, y_train_tensor, transform=train_composer)\n",
    "val_dataset = TransformedTensorDataset(x_val_tensor, y_val_tensor, transform=val_composer)\n",
    "\n",
    "# Builds a weighted random sampler to handle imbalanced classes\n",
    "sampler = make_balanced_sampler(y_train_tensor)\n",
    "\n",
    "# Uses sampler in the training set to get a balanced data loader\n",
    "train_loader = DataLoader(dataset=train_dataset, batch_size=16, sampler=sampler)\n",
    "val_loader = DataLoader(dataset=val_dataset, batch_size=16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Softmax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\Large\n",
    "\\begin{array}\n",
    "& z & = \\text{logit}(p) & = \\text{log odds ratio }(p) & = \\text{log}\\left(\\frac{p}{1-p}\\right)\n",
    "\\\\\n",
    "e^z & = e^{\\text{logit}(p)} & = \\text{odds ratio }(p) & = \\left(\\frac{p}{1-p}\\right)\n",
    "\\end{array}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\Large\n",
    "\\text{softmax}(z_i) = \\frac{e^{z_i}}{\\sum_{c=0}^{C-1}{e^{z_c}}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\Large\n",
    "\\text{softmax}(z) = \\left[\\frac{e^{z_0}}{e^{z_0}+e^{z_1}+e^{z_2}},\\frac{e^{z_1}}{e^{z_0}+e^{z_1}+e^{z_2}},\\frac{e^{z_2}}{e^{z_0}+e^{z_1}+e^{z_2}}\\right]\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "logits = torch.tensor([ 1.3863,  0.0000, -0.6931])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([4.0000, 1.0000, 0.5000])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "odds_ratios = torch.exp(logits)\n",
    "odds_ratios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.7273, 0.1818, 0.0909])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "softmaxed = odds_ratios / odds_ratios.sum()\n",
    "softmaxed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([0.7273, 0.1818, 0.0909]), tensor([0.7273, 0.1818, 0.0909]))"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nn.Softmax(dim=-1)(logits), F.softmax(logits, dim=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Negative Log Likelihood Loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\Large\n",
    "\\texttt{BCE}(y)={-\\frac{1}{(N_{\\text{pos}}+N_{\\text{neg}})}\\Bigg[{\\sum_{i=1}^{N_{\\text{pos}}}{\\text{log}(\\text{P}(y_i=1))} + \\sum_{i=1}^{N_{\\text{neg}}}{\\text{log}(1 - \\text{P}(y_i=1))}}\\Bigg]}\n",
    "\\\\\n",
    "\\Large\n",
    "\\texttt{NLLLoss}(y)={-\\frac{1}{(N_0+N_1+N_2)}\\Bigg[{\\sum_{i=1}^{N_0}{\\text{log}(\\text{P}(y_i=0))} + \\sum_{i=1}^{N_1}{\\text{log}(\\text{P}(y_i=1))} + \\sum_{i=1}^{N_2}{\\text{log}(\\text{P}(y_i=2))}}\\Bigg]}\n",
    "\\\\\n",
    "\\Large \\texttt{NLLLoss}(y)={-\\frac{1}{(N_0+\\cdots+N_{C-1})}\\sum_{c=0}^{C-1}{\\sum_{i=1}^{N_c}{\\text{log}(\\text{P}(y_i=c))} }}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-0.3185, -1.7048, -2.3979])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_probs = F.log_softmax(logits, dim=-1)\n",
    "log_probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(2.3979)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label = torch.tensor([2])\n",
    "F.nll_loss(log_probs.view(-1, 3), label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-1.5229, -0.3146, -2.9600],\n",
       "        [-1.7934, -1.0044, -0.7607],\n",
       "        [-1.2513, -1.0136, -1.0471],\n",
       "        [-2.6799, -0.2219, -2.0367],\n",
       "        [-1.0728, -1.9098, -0.6737]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.manual_seed(11)\n",
    "dummy_logits = torch.randn((5, 3))\n",
    "dummy_labels = torch.tensor([0, 0, 1, 2, 1])\n",
    "dummy_log_probs = F.log_softmax(dummy_logits, dim=-1)\n",
    "dummy_log_probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(1.6553)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "relevant_log_probs = torch.tensor([-1.5229, -1.7934, -1.0136, -2.0367, -1.9098])\n",
    "-relevant_log_probs.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(1.6553)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss_fn = nn.NLLLoss()\n",
    "loss_fn(dummy_log_probs, dummy_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(1.7188)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss_fn = nn.NLLLoss(weight=torch.tensor([1., 1., 2.]))\n",
    "loss_fn(dummy_log_probs, dummy_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(1.5599)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss_fn = nn.NLLLoss(ignore_index=2)\n",
    "loss_fn(dummy_log_probs, dummy_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cross Entropy Loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(1.6553)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.manual_seed(11)\n",
    "dummy_logits = torch.randn((5, 3))\n",
    "dummy_labels = torch.tensor([0, 0, 1, 2, 1])\n",
    "\n",
    "loss_fn = nn.CrossEntropyLoss()\n",
    "loss_fn(dummy_logits, dummy_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(13)\n",
    "model_cnn1 = nn.Sequential()\n",
    "\n",
    "# Featurizer\n",
    "# Block 1: 1@10x10 -> n_channels@8x8 -> n_channels@4x4\n",
    "n_channels = 1\n",
    "model_cnn1.add_module('conv1', nn.Conv2d(in_channels=1, out_channels=n_channels, kernel_size=3))\n",
    "model_cnn1.add_module('relu1', nn.ReLU())\n",
    "model_cnn1.add_module('maxp1', nn.MaxPool2d(kernel_size=2))\n",
    "# Flattening: n_channels * 4 * 4\n",
    "model_cnn1.add_module('flatten', nn.Flatten())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Classification\n",
    "# Hidden Layer\n",
    "model_cnn1.add_module('fc1', nn.Linear(in_features=n_channels*4*4, out_features=10))\n",
    "model_cnn1.add_module('relu2', nn.ReLU())\n",
    "# Output Layer\n",
    "model_cnn1.add_module('fc2', nn.Linear(in_features=10, out_features=3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/classification_softmax.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = 0.1\n",
    "multi_loss_fn = nn.CrossEntropyLoss(reduction='mean')\n",
    "optimizer_cnn1 = optim.SGD(model_cnn1.parameters(), lr=lr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "sbs_cnn1 = StepByStep(model_cnn1, multi_loss_fn, optimizer_cnn1)\n",
    "sbs_cnn1.set_loaders(train_loader, val_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "sbs_cnn1.train(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = sbs_cnn1.plot_losses()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizing Filters and More!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "@staticmethod\n",
    "def _visualize_tensors(axs, x, y=None, yhat=None, \n",
    "                       layer_name='', title=None):\n",
    "    # The number of images is the number of subplots in a row\n",
    "    n_images = len(axs)\n",
    "    # Gets max and min values for scaling the grayscale\n",
    "    minv, maxv = np.min(x[:n_images]), np.max(x[:n_images])\n",
    "    # For each image\n",
    "    for j, image in enumerate(x[:n_images]):\n",
    "        ax = axs[j]\n",
    "        # Sets title, labels, and removes ticks\n",
    "        if title is not None:\n",
    "            ax.set_title(f'{title} #{j}', fontsize=12)\n",
    "        shp = np.atleast_2d(image).shape\n",
    "        ax.set_ylabel(\n",
    "            f'{layer_name}\\n{shp[0]}x{shp[1]}',\n",
    "            rotation=0, labelpad=40\n",
    "        )\n",
    "        xlabel1 = '' if y is None else f'\\nLabel: {y[j]}'\n",
    "        xlabel2 = '' if yhat is None else f'\\nPredicted: {yhat[j]}'\n",
    "        xlabel = f'{xlabel1}{xlabel2}'\n",
    "        if len(xlabel):\n",
    "            ax.set_xlabel(xlabel, fontsize=12)\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "\n",
    "        # Plots weight as an image\n",
    "        ax.imshow(\n",
    "            np.atleast_2d(image.squeeze()),\n",
    "            cmap='gray', \n",
    "            vmin=minv, \n",
    "            vmax=maxv\n",
    "        )\n",
    "    return\n",
    "\n",
    "setattr(StepByStep, '_visualize_tensors', _visualize_tensors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Static Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cat(object):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    @staticmethod\n",
    "    def meow():\n",
    "        print('Meow')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meow\n"
     ]
    }
   ],
   "source": [
    "Cat.meow()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing Filters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1, 3, 3)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights_filter = model_cnn1.conv1.weight.data.cpu().numpy()\n",
    "weights_filter.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualize_filters(self, layer_name, **kwargs):\n",
    "    try:\n",
    "        # Gets the layer object from the model\n",
    "        layer = self.model\n",
    "        for name in layer_name.split('.'):\n",
    "            layer = getattr(layer, name)\n",
    "        # We are only looking at filters for 2D convolutions\n",
    "        if isinstance(layer, nn.Conv2d):\n",
    "            # Takes the weight information\n",
    "            weights = layer.weight.data.cpu().numpy()\n",
    "            # weights -> (channels_out (filter), channels_in, H, W)\n",
    "            n_filters, n_channels, _, _ = weights.shape\n",
    "\n",
    "            # Builds a figure\n",
    "            size = (2 * n_channels + 2, 2 * n_filters)\n",
    "            fig, axes = plt.subplots(n_filters, n_channels, \n",
    "                                     figsize=size)\n",
    "            axes = np.atleast_2d(axes)\n",
    "            axes = axes.reshape(n_filters, n_channels)\n",
    "            # For each channel_out (filter)\n",
    "            for i in range(n_filters):    \n",
    "                StepByStep._visualize_tensors(\n",
    "                    axes[i, :],\n",
    "                    weights[i],\n",
    "                    layer_name=f'Filter #{i}', \n",
    "                    title='Channel'\n",
    "                )\n",
    "                    \n",
    "            for ax in axes.flat:\n",
    "                ax.label_outer()\n",
    "\n",
    "            fig.tight_layout()\n",
    "            return fig\n",
    "    except AttributeError:\n",
    "        return\n",
    "    \n",
    "setattr(StepByStep, 'visualize_filters', visualize_filters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = sbs_cnn1.visualize_filters('conv1', cmap='gray')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hooks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "dummy_model = nn.Linear(1, 1)\n",
    "\n",
    "dummy_list = []\n",
    "\n",
    "def dummy_hook(layer, inputs, outputs):\n",
    "    dummy_list.append((layer, inputs, outputs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch.utils.hooks.RemovableHandle at 0x7fb94d5dd1c0>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dummy_handle = dummy_model.register_forward_hook(dummy_hook)\n",
    "dummy_handle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-0.8366], grad_fn=<ViewBackward0>)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dummy_x = torch.tensor([0.3])\n",
    "dummy_model.forward(dummy_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dummy_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-0.8366], grad_fn=<ViewBackward0>)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dummy_model(dummy_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(Linear(in_features=1, out_features=1, bias=True),\n",
       "  (tensor([0.3000]),),\n",
       "  tensor([-0.8366], grad_fn=<ViewBackward0>))]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dummy_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "dummy_handle.remove()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('',\n",
       "  Sequential(\n",
       "    (conv1): Conv2d(1, 1, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (relu1): ReLU()\n",
       "    (maxp1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (flatten): Flatten(start_dim=1, end_dim=-1)\n",
       "    (fc1): Linear(in_features=16, out_features=10, bias=True)\n",
       "    (relu2): ReLU()\n",
       "    (fc2): Linear(in_features=10, out_features=3, bias=True)\n",
       "  )),\n",
       " ('conv1', Conv2d(1, 1, kernel_size=(3, 3), stride=(1, 1))),\n",
       " ('relu1', ReLU()),\n",
       " ('maxp1',\n",
       "  MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)),\n",
       " ('flatten', Flatten(start_dim=1, end_dim=-1)),\n",
       " ('fc1', Linear(in_features=16, out_features=10, bias=True)),\n",
       " ('relu2', ReLU()),\n",
       " ('fc2', Linear(in_features=10, out_features=3, bias=True))]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "modules = list(sbs_cnn1.model.named_modules())\n",
    "modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{Conv2d(1, 1, kernel_size=(3, 3), stride=(1, 1)): 'conv1',\n",
       " ReLU(): 'relu1',\n",
       " MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False): 'maxp1',\n",
       " Flatten(start_dim=1, end_dim=-1): 'flatten',\n",
       " Linear(in_features=16, out_features=10, bias=True): 'fc1',\n",
       " ReLU(): 'relu2',\n",
       " Linear(in_features=10, out_features=3, bias=True): 'fc2'}"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_names = {layer: name for name, layer in modules[1:]}\n",
    "layer_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "visualization = {}\n",
    "\n",
    "def hook_fn(layer, inputs, outputs):\n",
    "    name = layer_names[layer]\n",
    "    visualization[name] = outputs.detach().cpu().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "layers_to_hook = ['conv1', 'relu1', 'maxp1', 'flatten', 'fc1', 'relu2', 'fc2']\n",
    "\n",
    "handles = {}\n",
    "\n",
    "for name, layer in modules:\n",
    "    if name in layers_to_hook:\n",
    "        handles[name] = layer.register_forward_hook(hook_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "images_batch, labels_batch = next(iter(val_loader))\n",
    "logits = sbs_cnn1.predict(images_batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['conv1', 'relu1', 'maxp1', 'flatten', 'fc1', 'relu2', 'fc2'])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visualization.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "for handle in handles.values():\n",
    "    handle.remove()\n",
    "handles = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "setattr(StepByStep, 'visualization', {})\n",
    "setattr(StepByStep, 'handles', {})\n",
    "\n",
    "def attach_hooks(self, layers_to_hook, hook_fn=None):\n",
    "    # Clear any previous values\n",
    "    self.visualization = {}\n",
    "    # Creates the dictionary to map layer objects to their names\n",
    "    modules = list(self.model.named_modules())\n",
    "    layer_names = {layer: name for name, layer in modules[1:]}\n",
    "\n",
    "    if hook_fn is None:\n",
    "        # Hook function to be attached to the forward pass\n",
    "        def hook_fn(layer, inputs, outputs):\n",
    "            # Gets the layer name\n",
    "            name = layer_names[layer]\n",
    "            # Detaches outputs\n",
    "            values = outputs.detach().cpu().numpy()\n",
    "            # Since the hook function may be called multiple times\n",
    "            # for example, if we make predictions for multiple mini-batches\n",
    "            # it concatenates the results\n",
    "            if self.visualization[name] is None:\n",
    "                self.visualization[name] = values\n",
    "            else:\n",
    "                self.visualization[name] = np.concatenate([self.visualization[name], values])\n",
    "\n",
    "    for name, layer in modules:\n",
    "        # If the layer is in our list\n",
    "        if name in layers_to_hook:\n",
    "            # Initializes the corresponding key in the dictionary\n",
    "            self.visualization[name] = None\n",
    "            # Register the forward hook and keep the handle in another dict\n",
    "            self.handles[name] = layer.register_forward_hook(hook_fn)\n",
    "\n",
    "def remove_hooks(self):\n",
    "    # Loops through all hooks and removes them\n",
    "    for handle in self.handles.values():\n",
    "        handle.remove()\n",
    "    # Clear the dict, as all hooks have been removed\n",
    "    self.handles = {}\n",
    "    \n",
    "setattr(StepByStep, 'attach_hooks', attach_hooks)\n",
    "setattr(StepByStep, 'remove_hooks', remove_hooks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "sbs_cnn1.attach_hooks(layers_to_hook=['conv1', 'relu1', 'maxp1', 'flatten', 'fc1', 'relu2', 'fc2'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "images_batch, labels_batch = next(iter(val_loader))\n",
    "logits = sbs_cnn1.predict(images_batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "sbs_cnn1.remove_hooks()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 2, 2, 0, 0, 0, 2, 2, 2, 1, 0, 1, 2, 1, 2, 0])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted = np.argmax(logits, 1)\n",
    "predicted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing Feature Maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x150 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_images(images_batch.squeeze(), labels_batch.squeeze(), n_plot=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualize_outputs(self, layers, n_images=10, y=None, yhat=None):\n",
    "    layers = filter(lambda l: l in self.visualization.keys(), layers)\n",
    "    layers = list(layers)\n",
    "    shapes = [self.visualization[layer].shape for layer in layers]\n",
    "    n_rows = [shape[1] if len(shape) == 4 else 1 \n",
    "              for shape in shapes]\n",
    "    total_rows = np.sum(n_rows)\n",
    "\n",
    "    fig, axes = plt.subplots(total_rows, n_images, \n",
    "                             figsize=(1.5*n_images, 1.5*total_rows))\n",
    "    axes = np.atleast_2d(axes).reshape(total_rows, n_images)\n",
    "    \n",
    "    # Loops through the layers, one layer per row of subplots\n",
    "    row = 0\n",
    "    for i, layer in enumerate(layers):\n",
    "        start_row = row\n",
    "        # Takes the produced feature maps for that layer\n",
    "        output = self.visualization[layer]\n",
    "            \n",
    "        is_vector = len(output.shape) == 2\n",
    "        \n",
    "        for j in range(n_rows[i]):\n",
    "            StepByStep._visualize_tensors(\n",
    "                axes[row, :],\n",
    "                output if is_vector else output[:, j].squeeze(),\n",
    "                y, \n",
    "                yhat, \n",
    "                layer_name=layers[i] \\\n",
    "                           if is_vector \\\n",
    "                           else f'{layers[i]}\\nfil#{row-start_row}',\n",
    "                title='Image' if (row == 0) else None\n",
    "            )\n",
    "            row += 1\n",
    "            \n",
    "    for ax in axes.flat:\n",
    "        ax.label_outer()\n",
    "\n",
    "    plt.tight_layout()\n",
    "    return fig\n",
    "\n",
    "setattr(StepByStep, 'visualize_outputs', visualize_outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABcgAAAIKCAYAAAAXsKxKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABtNklEQVR4nO3deVxV1f7/8fdhUlAxcwpxzjiGSoqkN4fsOpWlDWZpOTRpmUNmWZrmkJazaKKZQ2mZNpiQY5qi9U0tFTGHTBwRcECcB2Y4vz/8cZIL6AEP09mv5+NxH5ez1l57rX38eKQ3m7VNFovFIgAAAAAAAAAADMapsBcAAAAAAAAAAEBhICAHAAAAAAAAABgSATkAAAAAAAAAwJAIyAEAAAAAAAAAhkRADgAAAAAAAAAwJAJyAAAAAAAAAIAhEZADAAAAAAAAAAyJgBwAAAAAAAAAYEgE5A4uODhYZrNZ+/btK+ylFBiLxaImTZrou+++kyQdOHBAZrNZMTExWY5NT0/X/Pnz1bp1azVo0ECdOnXS6tWrC3rJRQK1cutamTNnjvr27atmzZrJbDYrKCiooJdbZFArOdfK0aNHNXnyZD311FNq1KiRWrRooddff91Q79XNqJWcayU2NlZDhgzRo48+qkaNGikgIEBdunRRSEiILBZLYSy9UFErt/436GYrV66U2WxWo0aNCmKZRQ61knOtxMTEyGw2Z/u/NWvWFMbSCxW1cvvPlaioKL377rt66KGH5Ofnp/bt22v69OkFueQigVrJuVaCgoJy/Fwxm83atWtXYSy/UFEvt/5sOXv2rEaOHKnWrVvLz89Pbdu21YQJE3Tx4sWCXnaho1ZuXSsnTpzQW2+9pQcffFAPPPCAXnjhBf35558FvWQrl0KbGcgnkZGRunz5sho2bChJ2r17typUqKCqVatmOXb69OmaN2+enn/+eTVo0EChoaF69913ZTKZ9MQTTxTwylHQclMrM2bMUMWKFXX//fdry5YtBbxSFDZba+XHH3/Ujz/+qPbt2+vFF1/U1atX9f3336tr165asGCBmjVrVgirR0GytVYuXryo2NhYPfbYY/Ly8lJqaqq2bt2qYcOG6fjx43rnnXcKYfUoSLn5NyjD9evXNWXKFHl4eBTQKlEU5LZWOnbsqIcffjhTW8ZYOLbc1Mo///yjnj17qnLlynrllVdUrlw5nTp1SmfOnCngVaMw2For7dq1U/Xq1bOMnz59uuLj49WgQYOCWC4Kma31cv36dXXr1k3x8fF68cUX5eXlpYMHD2rJkiXavn27goOD5eTEfbqOzNZaOX36tLp27SpnZ2e99tprcnd3V3BwsF577TUtWrRIDz74YIGvnYAcDmfv3r3y8PDQfffdJ0n666+/5Ofnl+W42NhYLVy4UN27d9eoUaMkSc8995x69OihyZMn67HHHpOzs3OBrh0Fy9ZakaTQ0FBVrVpVFy5c0EMPPVSQy0QRYGutPPHEExowYIBKlSplbXv22Wf1+OOPKygoiIDcAGytlbp162rx4sWZ2nr06KG+fftq8eLFGjRoEP8GObjc/BuUYc6cOSpVqpSaNm2q0NDQglgmioDc1oqvr6+eeuqpgloeihBbayU9PV3vv/++ateura+//lolS5Ys6KWikOXm+5W6detmajt9+rTOnDmj5557Tm5ubgWyXhQuW+tl06ZNOnnypObOnatHHnnE2l62bFnNnj1bBw8elK+vb0EtG4XA1lqZN2+erl69qlWrVql27dqSpOeff14dOnTQhAkTFBwcXKDrlthixZCGDRumRo0a6dSpU3rjjTfUqFEjtWzZUkuWLJEkRUREqFevXmrYsKH++9//atWqVZnGX7p0SZMmTVKnTp3UqFEj+fv7q3fv3jp48GCWuU6ePKm+ffuqYcOGeuihhzR+/Hj9/vvvMpvN2r59e6Zj9+zZo9dee02NGzfWAw88oB49etj8K1vXr1/XhQsXdOHCBe3atUtms1mXL1/WhQsX9Ndff6lOnTq6cOGCLl++bB2zceNGpaSk6MUXX7S2mUwmvfDCCzpz5ox2795t83vqqKiVf93qjj5QKxnq16+fKRyXpHLlyikgIEDHjh2zaV5HR63cmre3txISEpSSkmLT3I6MWsksMjJSixYt0gcffCAXF+5xuRm1klV8fLySk5NtmstIqJUbtmzZokOHDql///4qWbKkEhISlJaWltu306FRKzlbvXq1LBaLOnXqZNO8RkC93HDt2jVJUvny5TOdq2LFipKkEiVK2DS3I6NWbggLC9P9999vDcclyd3dXa1bt9bff/+tyMhIW99Su+G7a4NKS0tTnz59FBAQoCFDhmjVqlUaO3as3N3dNX36dHXq1Ent27fXd999p6FDh6phw4aqVq2aJCk6OlobN27UY489pqpVq+rcuXP6/vvv1aNHD61Zs0aVK1eWdOMb85deeklxcXHq1auXKlSooNWrV2f5iyhJf/zxh/r06aP69etrwIABMplMCg4O1ksvvaSlS5fe9o6qcePGKSQkJFPbzXf5zps3T/PmzZO3t7c2bdok6cavFXp4eOjee+/NNC5jrn/++UcBAQG5fGcdD7UCW1ErOYuLi9Ndd91ly9toCNTKvxITExUfH6/4+Hjt3LlTwcHBatiwIXfz/X/Uyr/Gjx+vpk2bqlWrVvr555/z9H46MmrlX7NmzdLkyZNlMplUr149DR48WC1atMjT++qIqJUbc0qSm5ubOnfurL///luurq5q166dRo8ezfcs/x+1kr1Vq1bJy8urULZAKMqoF+nBBx+Uk5OTPvnkEw0bNkz33HOPIiIi9Pnnn6tt27ZZshejolak5ORklS1bNsu5Mv4b6O+//1bNmjVtf1PtwQKr6Ohoyw8//GAZNWqUpXPnzpZ69epZfHx8LD169CjspeXZ8uXLLT4+Ppa9e/da24YOHWrx8fGxfP7559a2y5cvW/z8/Cxms9myZs0aa/vRo0ctPj4+lpkzZ1rbkpKSLGlpaZnmiY6OttSvX98ya9Ysa9uXX35p8fHxsWzYsMHalpiYaHnssccsPj4+lj///NNisVgs6enplvbt21teffVVS3p6uvXYhIQES+vWrS2vvPLKba/z8OHDlq1bt1rWrVtn8fHxsXz55ZeWrVu3WqZOnWqpX7++ZcuWLZatW7dawsLCrGNef/11S5s2bbKcKz4+3uLj42OZOnXqbed1JNRKzrVys/Pnz2e5TqOhVmyrlQw7d+60mM1my4wZM247p6OhVm5fK3PnzrX4+PhY//fSSy9ZTp06dds5HQ21cuta2bx5s8XX19dy+PBh63vTsGHD287niKiVnGvl5MmTlldffdWydOlSS2hoqGXRokWWRx55xFK3bl3L5s2bbzuno6FWcq6Vvn37Wnx8fCxNmjSxvPvuu5Z169ZZZsyYYfH19bV07do101qMgFqx/XvbQ4cOWXx8fCyTJ0++7XyOinq5db388MMPloCAgEzf3w4dOtSSkpJy2zkdDbWSc6288cYbloCAAMvVq1cznatr164WHx8fyxdffHHbee2NLVZu8tVXX+nDDz/Ud999p/379zv8rzc/99xz1q89PT1Vq1Ytubu7q0OHDtb22rVry9PTU9HR0dY2Nzc364MV0tLSdPHiRXl4eKhWrVo6cOCA9bjff/9dlStXVps2baxtJUqU0PPPP59pHf/8848iIyPVqVMnXbx40fqrGfHx8XrooYe0c+dOpaen3/Ja6tSpo2bNmsnFxUWurq7q2rWrmjVrpuvXr6thw4Zq3ry5mjVrpsaNG1vHJCYmZrtnWsav/SQmJt5yTiMxeq3AdtRKZufPn9e7776rqlWrqnfv3rd594yFWrnhiSee0MKFCzVt2jR17NhREv/+/C+j10pycrImTJigbt26qU6dOrl894zF6LVSpUoVffHFF3rhhRfUunVrvfTSSwoJCdHdd9+tiRMn5vLddGxGr5X4+HhJUoMGDTR16lQ9+uijGjRokAYNGqTdu3db7zAHtfK/MrZ7YHuV7FEvUuXKleXn56fhw4dr9uzZeuWVV7Rq1SpNmzYtF++k4zN6rbzwwgu6cuWKBg8erAMHDuj48eP65JNPtH//fkmF899DbLFyk3LlyqlVq1aqV6+e6tevr7CwMH355ZeFvax8UaJECd19992Z2sqUKaN77rlHJpMpS/uVK1esr9PT0/X1119r6dKliomJybRf3c2/jnfy5ElVr149y/n+9ynYGXsLDR06NMf1Xr16Ndtfv5CkhIQEJSQkSLrxIVC3bl0lJiYqMTFRf/75p1q1aqULFy5IUqZrLlmyZLZ7MyYlJVn7Qa3AdtRKZvHx8XrjjTd0/fp1LV26NMve5EZGrfzL29tb3t7ekqSOHTtq5MiReuWVV7Ru3Tr+HRK1IkmLFi3SxYsXNXDgwBznBbWSk7vuukudO3fWvHnzdObMGd1zzz23PN4IqJV//zsn4wezGTp27Khp06YpPDycB4uLWvlfFotFq1evlo+PT5YHd4J6kaRdu3apb9+++v7779WgQQNJUtu2bVW6dGnNmjVLzz77LD/sF7UiSa1atdLIkSM1bdo0PfPMM5KkGjVq6O2339aUKVPk4eGR43ryCwH5Tfr165fp9dGjRwtpJfnP2dk5V+0Wi8X69eeff65PP/1Uzz77rAYNGqSyZcvKyclJ48ePz3ScrTLGvP/++7r//vuzPeZWfzkWLFigWbNmZWq7eb+jo0ePWn/QERERYW2vWLGitm/fLovFkulDIy4uTpJUqVKlXF6JY6JWYCtq5V/JyckaOHCgIiIi9MUXX8jHxyfX1+DIqJWcPfroo/rhhx+0c+dOtWzZ8rbHOzqj18rVq1c1Z84cvfjii7p27Zr14Vfx8fGyWCyKiYmRu7t7lodhGZHRa+VWMkLxS5cuEZCLWpH+/e+c//3syHh9cxhjZNRKZrt27dLJkyf17rvv5mrtRkG9SN9//73Kly9vDccztG7dWkFBQdq9ezcBuaiVDD169FDnzp0VEREhV1dX3X///frxxx8lSbVq1cr1tdypPAXkFotFoaGhWr58ufbt26dLly7J09NTVatWVatWrfTcc89lChcvXryohQsXatOmTYqJiZHJZFLVqlXVrl07vfLKKypTpkyWOXr27KkdO3ZowoQJat26tWbPnq3Q0FCdPXvWeqf3oEGDrE/DlaRTp06pdevWMplM2rx5c47fAP7+++/q3bu37rrrLv3+++/ZbrOBnK1fv15NmzbV+PHjM7VfuXJF5cqVs7729vbWkSNHsgTQUVFRmcZlPGygdOnSebpT4emnn1bjxo2VkJCgfv36Wf9i79y5U/Pnz9fnn39u/RWUm91///1atmyZjh49mulDes+ePdZ+3BlHqRXkP0eqlfT0dA0dOlR//PGHZsyYoSZNmuR6fuTMkWolOxm/Tnj16tVcrwWZOUKtXL58WfHx8VqwYIEWLFiQ5Zxt2rRRmzZt9Nlnn+V6PfiXI9TKrcTExEjit+PswVFqpV69epKk2NjYTO1nz56VRK3Yg6PUys1WrVolk8mU5TcPcOccpV7Onz+f7XYcqampmf4feecotZLBw8NDjRo1sr7etm2bSpYsKX9//1yv5U7lOglKTExU//791b9/f23atEkpKSkym80qVaqUDhw4oJkzZ2rLli3W448cOaKnnnpKc+fO1bFjx1S9enVVrVpVR44c0ezZs/XUU0/pxIkTOc535swZPf3009ZfT/f29ta5c+e0bNkyvfDCC9Y7aaQb++49+OCDSk9P18qVK3M8508//SRJ6tChA+F4Hjg7O2f5ydTPP/+c5RusFi1aKDY2VqGhoda2pKQk/fDDD5mOq1+/vqpXr64vv/xS169fzzJfxq9j5KRatWpq1qyZSpUqJZPJpC5duqhZs2ZKSUmRr6+vWrRooWbNmmX5y96mTRu5urpq6dKl1jaLxaLvvvtOlStXzvSXFHnjKLWC/OdItTJu3DitXbtWo0ePVvv27W977cgdR6mVnM77448/ymQyWcML5J0j1Er58uU1e/bsLP9r2rSpSpQoodmzZ+uNN96w+T1B9hyhVnI6b2xsrJYvXy6z2cxvR9qBo9RKmzZt5ObmpuDg4Exh1rJlyySJ74XtwFFqJUNKSorWrVunxo0bq0qVKrecC7nnKPVSs2ZNnTt3Ttu3b8/Uvnr1akmSr6/vLefF7TlKrWQnPDxcGzZsUJcuXbK9kTq/5foO8jFjxig0NFSenp4aN26c2rdvb/1pQGJiotatW6eqVatKuvEr5gMGDFBsbKweeOABzZgxw/phGhUVpYEDB+rgwYN66623FBwcnO2vE3z22Wdq2rSpfvjhB+s3dQcOHFCfPn0UHR2tL7/8Um+99Zb1+Kefflo7duzQihUr9Prrr2c53/Xr160FkrHPDXLnkUce0ezZs/XBBx+oUaNGOnTokFatWmX9yVOGrl276ptvvtG7776rXr16qWLFilq1apX1IZgZP8VycnLSxx9/rD59+qhjx47q3LmzKleurNjYWG3fvl2lS5fW559/ftt1hYeHq3bt2ta9kXbv3n3LkPuee+5Rr1699MUXXyg1NVUNGjTQxo0bFRYWpqlTp+b46y2wnaPUinTjB2unTp2y3t25c+dO6x17Tz31lHUPYeSNo9TKokWLtHTpUjVq1EglS5bUihUrMvW3a9euUPZTcySOUitz5sxReHi4WrZsqSpVqujSpUv65ZdftG/fPvXs2VM1atTI61uE/88RasXd3V1t27bN0r5x40bt27cv2z7kniPUiiRNmTJFUVFReuihh1SpUiWdPHlS3333neLj4zVixIi8vj24iaPUSsWKFdW3b1/NnDlTvXv3Vps2bRQREaEffvhBHTt2lJ+fX17fIvx/jlIrGbZs2aJLly7xcM584ij10r17dwUHB6tv377q2bOnqlSpop07d2r16tVq3ry5Hnjggby+Rfj/HKVWTp48qbffflutW7dWhQoVdOTIEX333Xcym80aPHhwXt+eO5KrgPzgwYMKCQmRJM2cOTPTvjLSjYd9PP3009bXa9eu1fHjx+Xq6qqZM2dm2vKkevXqmjFjhp544gkdPHhQGzdu1KOPPpplztKlS2v69Ony9PS0tvn6+qp3796aOHGiNm/enCkgf/TRRzVu3DgdOXJE+/bty7L30fr165WQkKBatWrxlzOP+vbtq4SEBK1atUpr166Vr6+v5s6dm+WpxKVKldJXX32ljz/+WF9//bU8PDz09NNPq1GjRho4cKD1L6YkNW3aVN9//70+++wzffPNN4qPj1fFihXl5+enrl272rSu8PBw61/AlJQU7d+/Xz179rzlmCFDhqhs2bL6/vvvFRwcrJo1a2rKlCn8w28njlQry5cv144dO6yvt2/fbv3JeOPGjQnI75Cj1MrBgwcl3fiGYPfu3Vn6Q0NDCcjvkKPUyiOPPKLo6GgtX75cFy9elJubm8xmsyZMmMAP8O3EUWoF+c9RaqV58+aKjo7WkiVLdOXKFZUpU0YPPvig3nzzTX4rxU4cpVakG8/fKlu2rBYvXqwJEyaoQoUK6tu3r/r375/LdwXZcaRakW5sr+Lq6qrHHnssF+8CbOUo9VK7dm0tX75cM2bM0MqVK3Xu3DlVqlRJr776aqbcDnnnKLVSunRpVaxYUUuWLNGlS5dUuXJl9ezZU3379lXp0qXz8M7YgSUXZs6cafHx8bF07drVpuPffvtti4+Pj2XIkCE5HtO/f3+Lj4+PZdiwYZnae/ToYfHx8bGMGzcu23Hh4eEWHx8fS6NGjbL0vfPOOzmO7dWrl8XHx8cyZ86c265/7ty5Fh8fH0uPHj1ueyxst3DhQouPj4/lzJkzhb0UFHHUCmxFrcBW1ApsRa3AVtQKbEWtwFbUCnKDeoGtqJWc5WoP8kOHDkmSzXszHz9+XJJ033335XiMj49PpmP/V05PLq1QoYIkZbtHTsZd7GvWrFFKSoq1/fTp09qxY4dMJpOefPLJ218A7ljGdhQZkpKS9P3336tmzZqqXLlyIa0KRRG1AltRK7AVtQJbUSuwFbUCW1ErsBW1gtygXmAraiV3crXFSsYDMW3dLD0jvK5YsWKOx2T0ZRd0Szf2XszOzU9h/V/NmjVTpUqVdPbsWf3f//2f2rRpI+nGrwWlp6frP//5Dw+WKCADBgxQlSpVVLduXV27dk0rV67UsWPHNHXq1MJeGooYagW2olZgK2oFtqJWYCtqBbaiVmAragW5Qb3AVtRK7uQqIM/YB+bq1as2HV+qVClJUlxcXI7HZPRlHGsPzs7O6tSpk7744gutWLHCGpBnPCzt5n3Skb9atGihH3/8UatWrVJaWprq1Kmj6dOn6/HHHy/spaGIoVZgK2oFtqJWYCtqBbaiVmAragW2olaQG9QLbEWt5I7JYrFYbD141qxZCgoKUqNGjfTdd9/d9vh33nlHa9as0ZNPPqkpU6Zke8yAAQO0YcMGPfvssxo/fry1vWfPntqxY4cmTJigzp07ZxkXExNjDb4jIiKy9B86dEidOnWSm5ubtmzZoujoaD377LPy8PDQli1bbArk582bp2nTpqlJkyZavHjxbY8HAAAAAAAAABQfudqDvH379jKZTNq9e7e2b99+2+NbtWolSfr555915syZLP0nTpzQpk2bJEmPPPJIbpZyWz4+PvL19VVycrJ+/vln/fTTT5Kkdu3a2fVudQAAAAAAAABA8ZSrgNzHx0fPPPOMJOmtt97Shg0bdPMN6ElJSVqxYoXCwsIkSR06dFCtWrWUkpKiQYMG6dSpU9Zjo6Oj9fbbbystLU1169a13g1uT0899ZQkafny5Vq7dq0kWdcPAAAAAAAAADC2XO1BLkmjR4/WpUuXtGnTJg0YMEB33XWXqlWrpitXrujUqVNKSUnRhAkTFBAQIDc3NwUFBenVV1/VX3/9pbZt26pOnTqyWCw6cuSI0tPT5e3trZkzZ8rZ2dnuF9epUydNmTJFe/fulSR5eXmpadOmOR6/a9cu9evXz/o6KSlJkhQeHp5pXMeOHTVy5Ei7r1eSAgIClJycfMsHm6L4iYuLk5ubm/WHR/ZArTgmagW2olZgK2oFtqJWYCtqBbaiVmAragW2olZgq9zUSq4D8pIlS+qzzz7TunXrFBwcrL///lsHDx5U2bJlVa9ePT3yyCNq2bKl9fj77rtPK1eu1MKFCxUaGqoTJ07IZDKpTp06atu2rV555RV5enrmdhk2KV++vFq2bKnNmzdLuhGYOznlfNN8amqqLl26dNv269ev23upVklJSUpJSdG5c+fybQ4UvOTkZCUnJ9v1nNSKY6JWYCtq5V8VKlTI07ibf7MttxITE/M8Nr++78kJtXLn8lpjUvGqM0erlcL4cytOnw13Ir9qJTk5mffewTja5wryT37VSlJSko4dO5an8Xw2FE2O9rlStmzZPI9NS0vL07jz58/nec6UlJQ8j3V1dc3z2BIlSuR6TG5qJdcBuSSZTCZ16NBBHTp0sOn4cuXK6Z133tE777xj8xy3eyhm1apVs3045//6/PPPbZ6zadOmNp0zP1WqVEnnzp275Z3u+cVkMhXK2LzKxfNl7To2L2zZsz+3CrNWCkNxq08pb3X2559/2n0dRqsVo+Bz5V/z5s3L07iHHnooz3Peyd/VPn365HlsXlArdy6vNSYVrzpztFopjD+34vTZcCfyq1ZOnTqlu+66K0/jjfLeFzeO9rmC/JNftXLs2DFFRkbmaTyfDUWTo32uDB48OM9j4+Li8jRu4MCBeZ7zTm7+qF27dp7HNmnSJNdjclMrudqDHAAAAAAAAAAAR0FADgAAAAAAAAAwJAJyAAAAAAAAAIAhEZADAAAAAAAAAAyJgBwAAAAAAAAAYEgE5AAAAAAAAAAAQyIgBwAAAAAAAAAYEgE5AAAAAAAAAMCQ8iUgj42N1dChQ9WyZUv5+vrKbDZr2LBhCgoKsn79v1q3bi2z2azt27fnx5IAAAAAAAAAAMjE7gF5cnKyevXqpZ9++knx8fHy9fWVv7+/atasadd51q5dK7PZrOnTp1vboqKiZDabNWDAgNuO3717twYOHKhmzZqpQYMGat26tcaMGaPY2Fi7rhMAAAAAAAAAUDS52PuEW7duVWRkpCpVqqQ1a9bI09PT2vfNN9+oVq1aqlix4h3PEx4eLklq3LixtW3nzp1Z2rKzbNkyjRo1Sunp6SpXrpzuu+8+nThxQt9++63Wrl2rr7/+WnXr1r3jNQIAAAAAAAAAii6730F+5MgRSZK/v3+mcFySevTooXXr1undd9+943nCw8Pl5OQkf39/a1tYWJikWwfkERERGj16tNLT09WnTx/9/vvvCg4O1pYtW9SpUyddvnxZ/fv3V3Jy8h2vEQAAAAAAAABQdNn9DvKkpCRJkru7u71PbRUfH6+IiAjVrVtXpUuXtraHhYXJ3d1dvr6+OY6dPXu20tLS5O/vryFDhljb3d3dNX78eO3evVsxMTFavny5XnjhhXy7hqLIYrEU+Jwmk6lQxt6JwnifUHjve3GsUQAAAAAAUDAGDx6c57FxcXF5Hjtw4MA8jTt+/Hie56xdu3aexzZp0iTPY/Ob3e4gz3gAZ1BQkCQpJCREZrPZ+r+YmJhbPqQzN/bs2aPU1NRMd4qfPXtWUVFR8vPzk4tL9rl/fHy8fv31V0lSt27dsvS7ubnpmWeekXRjj3MAAAAAAAAAgOOy2x3kXl5e8vf31+nTp3X69GmVL19eNWrUsPaXKFEiz+cOCgrSrFmzsrQvXrxYixcvztS2fft2mc1m6+uvv/5aTZs2lSQdOHDAeof7gw8+mO1cGT/N2LNnj9LT0+XkZPddaAAAAAAAAAAARYDdAvIuXbqoS5cu1jD74Ycf1sSJE+1ybm9v70y34e/Zs0dJSUmZ2g4dOqRLly7Jz89PJUuWtLbfvA96ZGSkJMnV1VVeXl7ZzlW9enVJN7aKOXnypKpVq2aXawAAAAAAAAAAFC1234M8P3Tu3FmdO3eWJF27dk1NmzaVj49PprvH27Vrp6SkJC1ZskRubm7Znufy5cuSpLJly+a4N3DZsmWtX1+5csVelwAAAAAAAAAAKGKK3f4hf/75p1JTU9WiRQtrW0xMjKKiohQQEJBjOC5JiYmJkm7cQZ6Tm7eCSUhIsMOKAQAAAAAAAABFUbELyLdu3SpJevjhh61t27ZtkyQ1b978lmMztl5JSUnJ8ZiMPcolyd3dPc/rBAAAAAAAAAAUbUV+i5Vx48bpwIED1teHDh2SJAUGBsrF5cbyY2JiJEnLly/XL7/8IkmqWLGiZs6cmelcGfuRX758WRaLJdttVjK2Ybn5eAAAAAAAAACA4ynyAfmhQ4cUHh6epX3v3r1Z2g4fPmz92tvbO0t/rVq1JN24g/zUqVPZHhMVFSXpxlYr2fUDAAAAAAAAABxDkd9iZfHixYqIiFBERISCgoIkSf3797e2rVu3TpLUvn17a1tERIQ2bdqU5Vy+vr7WPcZ37tyZ7Xw7duyQJPn5+cnJqci/PQAAAAAAAACAPCpWCXBYWJgkKSAgIEtb48aNbzvew8NDrVq1kiR9//33WfqTk5MVEhIiSerQocMdrxcAAAAAAAAAUHQVu4DcxcVFDRs2tLbt2rVLUubQ/Fb69+8vZ2dnhYeHa+rUqdYHdiYkJGjEiBGKiYmRt7e3nnvuObuvHwAAAAAAAABQdBT5PcgzXLt2TQcPHpSvr688PDys7WFhYSpVqpTuv/9+m85Tt25djRo1Sh999JHmz5+vH3/8UVWqVNGJEyd07do1eXp6atasWXJzc8uvSwEAAAAAAAAAFAHF5g7yv/76S2lpaZm2UomNjVV0dLQaNmwoZ2dnm8/VrVs3LVmyRG3btpXJZNKhQ4fk6empbt26adWqVfL19c2PSwAAAAAAAAAAFCF2v4N84MCBGjhwYK77snuo5s1atGihiIiITG2VK1fO0mYrf39/+fv752ksAAAAAAAAAKD4KzZbrKBos1gsBT6nyWQqlLEofgqjPiXqDAAAAACA4qBs2bIaPHhwnsbGxcXled6cbiS2xfHjx/M0rnbt2nmes0mTJnkeW5QVmy1WAAAAAAAAAACwJwJyAAAAAAAAAIAhEZADAAAAAAAAAAyJgBwAAAAAAAAAYEgE5AAAAAAAAAAAQyIgBwAAAAAAAAAYEgE5AAAAAAAAAMCQXApysqSkJH377bdat26djhw5ooSEBJUuXVo+Pj7q2LGjunTpImdnZ7vNFxsbq0WLFmnLli2Kjo5WamqqypUrpwceeEDdunVTixYt7DYXAAAAAAAAAKB4KbCA/OLFi3rppZcUEREhSbrnnntUvXp1xcbGaseOHdqxY4dWr16t+fPnq2TJknc83969e/Xaa6/pypUrcnZ2VtWqVeXh4aHo6Ght2LBBGzZs0Guvvab333//jucCAAAAAAAAABQ/BbbFyrRp0xQREaGyZctq8eLF+u233xQcHKytW7dq1qxZcnNz044dO7RgwYI7nstisei9997TlStXVL9+fa1bt06//PKLfvrpJ/3xxx/q16+fJOmLL77Qjh077ng+AAAAAAAAAEDxU2ABeWhoqCSpX79+atKkSaa+du3aqWfPnpKkTZs23fFcR48eVWRkpCRp3Lhxql69urXPzc1NgwYNUoMGDSRJmzdvvuP5AAAAAAAAAADFT4EF5ImJiZKkGjVqZNtfs2ZNSVJqaqq1bdCgQTKbzXr22WeVkpKSZczhw4f1wAMPyGw2a+3atdb2hIQE69c5zZfRnt15AQAAAAAAAACOr8ACcl9fX0lSWFhYtv07d+6UJDVs2NDa9vHHH8vb21v79+/XtGnTMh2fmJiowYMHKzExUc8//7wef/xxa1/t2rXl7u6e43zJycnau3dvlvkAAAAAAAAAAMZRYAH54MGD5ebmpoULF2rOnDk6efKkkpKSdOLECU2aNEkrV66Ul5eXdX9wSSpTpowCAwPl4uKiRYsW6bfffrP2ffLJJzp8+LDq1Kmj4cOHZ5qrVKlS6t+/vyRp+PDhWrlypc6fP6+EhATt27dP/fv3V1RUlB566KFMwToAAAAAAAAAwDhcCmqigIAALVmyREFBQfr00081Y8aMfxfh4qKXXnpJr7/+uipUqJBpXMOGDTVo0CBNmzZNw4YN04oVK7Rr1y798MMPKlGihAIDA613i9+sT58+qly5sr788ku99957mfrKlSunDz74QN27d5eTU4H9jADZsFgshTKvyWQqlLEofgqrRgEAAAAAQMFIS0tTXFxcnsYOHDgwz/MeP348z2Nr166dp3H/+2xIFOAd5JIUExOjc+fOyWKxqHz58qpXr57Kly+v1NRU/fzzzzk+oLNPnz5q3ry5Lly4oLfeeksjR46UJA0bNkxmsznbMWlpaYqOjtbFixfl5OQkb29v1a1bVx4eHrp48aJCQkKs26wAAAAAAAAAAIynwO4gX7RokSZMmKBy5cpp3rx5atWqlbVv8+bNGjZsmEaOHKmkpCT17Nkz01iTyaTJkyfrqaee0u7duyVJ7dq104svvpjjfAMHDlRoaKjq1aunL774QnXq1JF046GcX331laZMmaKXX35ZS5cuVYMGDfLhigEAAAAAAAAARVmB3EF+4cIF65YqH3zwQaZwXJL++9//6oMPPpAkzZw5U8nJyVnOUaFChUx3iz///PM5zvfrr78qNDRULi4u+vTTT63huCS5urqqd+/e6ty5s5KTk/Xpp5/eyaUBAAAAAAAAAIqpAgnI9+3bp4SEBElSy5Ytsz0mo/3KlSuKjIzM0v/VV19p69at1j3DP/roI129ejXbc+3cuVOSVLNmTVWrVu2W8+3bt8/2CwEAAAAAAAAAOIwCCcivX7+eq+OTkpIyvT5w4ICmTJkiSZo+fbr8/PwUExOjUaNGZTv+2rVrNs+V3d3qAAAAAAAAAADHVyABea1ataxf//7779ke83//93+SJGdnZ9WoUcPaHh8fr8GDByslJUU9evTQY489psDAQJUuXVpr167VsmXLcpwvMjJS0dHR2c6XsY6b1wYAAAAAAAAAMI4CCcjr1q2runXrSpImTJig3377LVP/5s2bNXHiRElS27Zt5enpae0bO3asIiMjZTabNXToUElStWrVNGbMGEnSJ598oqNHj2Y6X4cOHVSyZEmlpqZq0KBBmfpTUlK0YMECBQcHS5I6d+5s34sFAAAAAAAAABQLLgUxiclk0rRp0/Tyyy8rLi5Or7/+usqXL6977rlHZ86c0fnz5yVJ9957b6ZtU1auXKmQkBC5u7tr+vTpcnNzs/Z16tRJW7duVUhIiN555x0tW7bM2l+5cmWNHz9eQ4cO1d9//62OHTvKy8tLnp6eioqKsm750qFDB73wwgsF8RYAAAAAAAAAAIqYArmDXJLq1KmjVatWacCAAapXr56SkpJ08OBBpaSkyN/fX8OGDVNwcLAqVKggSYqKirLeJT58+HDde++9Wc45cuRI1axZUwcPHtTkyZMz9T3xxBNasWKFunbtqho1auj8+fM6cuSIPDw89Mgjj2jGjBmaMWOGnJ2d8/3aAQAAAAAAAABFT4HcQZ6hXLlyGjhwoAYOHHjbY6tXr67w8PBbHlOqVCmtX78+x/57771XY8eOzfU6AQAAAAAAAACOr8DuIAcAAAAAAAAAoCghIAcAAAAAAAAAGBIBOQAAAAAAAADAkAp0D3LAniwWS6HMazKZCmVeFD+FVaMAAAAAAMB258+ft+mZidk5fvx4nuetXbt2nsc2adIkz2ORGXeQAwAAAAAAAAAMiYAcAAAAAAAAAGBIBOQAAAAAAAAAAEMiIAcAAAAAAAAAGBIBOQAAAAAAAADAkAjIAQAAAAAAAACGREAOAAAAAAAAADAkAnIAAAAAAAAAgCERkAMAAAAAAAAADImAHAAAAAAAAABgSATkAAAAAAAAAABDIiAHAAAAAAAAABgSATkAAAAAAAAAwJAIyAEAAAAAAAAAhuRS2AsACoPFYinsJQAAAAAAAKAISElJ0alTp/I0tnbt2nmet0mTJnkeC/vhDnIAAAAAAAAAgCERkAMAAAAAAAAADImAHAAAAAAAAABgSATkAAAAAAAAAABDIiAHAAAAAAAAABgSATkAAAAAAAAAwJAIyAEAAAAAAAAAhkRADgAAAAAAAAAwJAJyAAAAAAAAAIAhEZADAAAAAAAAAAyJgBwAAAAAAAAAYEgE5AAAAAAAAAAAQyIgBwAAAAAAAAAYEgE5AAAAAAAAAMCQXAp7AUBxY7FYCnsJAAAAAGBoJpMpT+P47zkA2XF1dVXt2rXzNLZJkyZ2Xg0KGneQAwAAAAAAAAAMiYAcAAAAAAAAAGBIBOQAAAAAAAAAAEMiIAcAAAAAAAAAGBIBOQAAAAAAAADAkAjIAQAAAAAAAACGREAOAAAAAAAAADAkAnIAAAAAAAAAgCERkAMAAAAAAAAADImAHAAAAAAAAABgSATkAAAAAAAAAABDIiAHAAAAAAAAABgSATkAAAAAAAAAwJAIyAEAAAAAAAAAhuRS2AsAAAAAAADIDZPJVOBzWiyWAp8TQMEoUaKEmjRpUtjLQCHhDnIAAAAAAAAAgCERkAMAAAAAAAAADImAHAAAAAAAAABgSATkAAAAAAAAAABDIiAHAAAAAAAAABgSATkAAAAAAAAAwJAIyAEAAAAAAAAAhkRADgAAAAAAAAAwJAJyAAAAAAAAAIAhEZADAAAAAAAAAAyJgBwAAAAAAAAAYEgE5AAAAAAAAAAAQyIgBwAAAAAAAAAYkslisVgKexH4V4MGDZSSkqISJUoU9lJgR0lJSZKkgwcP2u2c1IpjolZgK2rlXxUqVMjTuFOnTuV5zsTExDyP9fT0zPPYvKBW7lxea0wqXnXmaLVSGH9uxemz4U7kV60kJyfLySlv93AZ5b0vbhztcwX5J79qJSkpSSkpKXkaz2dD0cTnCmyVm1pxye/FIHdKlCghk8l0R9/Qo+iJi4uTm5ubXc9JrTgmagW2olbuXJUqVQp7CQWCWilcxanOqJV/Fac/t8KQn7VSsWJFu54XhYvPFdgqP2ulWrVqdj0vChefK7BVbmqFO8gBAAAAAAAAAIbEHuQAAAAAAAAAAEMiIAcAAAAAAAAAGBIBOQAAAAAAAADAkIp0QB4TEyOz2Syz2VzYSwEAAAAAAAAAOBiXwl5AYbhy5Yq2bNmi/fv3a//+/Tpw4ICuXr0qSYqIiCjk1QEAAAAAAAAACoIhA/IdO3Zo8ODBhb0MAAAAAAAAAEAhMmRAXqJECQUEBKhevXqqX7++TCaThgwZUtjLAgAAAAAAAAAUIEMG5C1btlTLli2tr//666/CWwwAAAAAAAAAoFDY5SGdrVu3ltls1vbt23Xs2DENHTpUDz/8sOrVq6dhw4ZZj/v77781dOhQtW7dWg0aNFBAQIC6d++u4OBgpaen52rOnj17ymw2Kzg4ONt+HvAJAAAAAAAAALgVu95B/tdff2nOnDlKS0tTnTp1VLZsWZlMJknSggULNHXqVFksFpUqVUq1a9fWpUuXFBYWprCwMIWGhmrmzJlydna255IAAAAAAAAAAMiWXQPyTz/9VB06dNDo0aPl6ekpSUpMTNTatWs1ZcoUeXp6asSIEXryySfl5HTj5vW9e/dqyJAh2rhxoz7//HP179/fnksCAAAAAAAAACBbdtliJUOtWrU0adIkazguSS4uLpo6daokafz48Xr66aet4bgk+fn5KTAwUCaTSYsWLVJycrI9lwQAAAAAAAAAQLbsGpA//fTTcnHJfFP6nj17dPLkSVWsWFHt2rXLdlz9+vVVpUoVXblyRX///bc9lwQAAAAAAAAAQLbsusXKfffdl6Xt4MGDkm5stfLCCy/kOPbSpUuSpNOnT6tRo0b2XBYAAAAAAAAAAFnYNSB3d3fP0nblyhVJ0tWrVxUeHn7bcyQmJtpzSQAAAAAAAAAAZMuuAXl2PDw8JEkPPvigvvnmG7uf32KxZNuekJBg97kAAAAAAAAAAI7DrnuQZ8fHx0eSdPjwYaWnp9vtvBnB+/nz57Ptj4yMtNtcAAAAAAAAAADHk+8BeePGjVWpUiVdunRJP/74o93OW6NGDUnS7t27s+3/9ttv7TYXAAAAAAAAAMDx5HtA7ubmpvfff1+SNG7cOC1atCjLPuPXr1/X+vXrNWLECJvP27p1a0nS5s2btWbNGmt7UlKSAgMDtWPHDjusHgAAAAAAAADgqPJ9D3JJ6tSpky5cuKDJkydrwoQJCgwMVK1atVSiRAldvHhRMTExSk9Pl7e3t83n/M9//qP27dvrl19+0TvvvKNJkyapYsWKOn78uFJTUzVq1CiNHDkyx/FNmza1fp2WlpZte5UqVRQSEpLLq70zAQEBSk5OVsWKFQt0XuSvuLg4ubm5KSwszG7npFYcE7UCW1ErsBW1AltRK7AVtQJbUSuwFbUCW1ErsFVuaqVAAnJJeumll9SiRQstWbJEf/75p6KiopScnKy77rpLAQEBevjhh9WuXbtcnXPatGlasGCBVqxYoZMnTyo5OVnNmzdX//79Vbp06VuOvXTp0m3bS5Uqlav12ENSUpKSkpJ07NixAp8b+cfV1dXuD46lVhwTtQJbUSv/ql27dp7GFbfrzCtq5c7ltcak4lVnjlYrRvlzKwyOVivIP9QKbEWtwFaOViteXl55HpuSkpKncefOncvznMVJbmrFLgH5pk2bbDru3nvv1ahRo2w+b9WqVRUREZFjv5ubm/r166d+/fpl23+rsbfqK0yVKlXSsWPHeMiog6lZs6bdz0mtOCZqBbaiVv51/PjxPI0zmUx2XknRRK3cubzWmFS86szRasUof26FwdFqBfmHWoGtqBXYytFqZe7cuXkee/To0TyNyylHdTS5qZV834McAAAAAAAAAICiiIAcAAAAAAAAAGBIBOQAAAAAAAAAAEMiIAcAAAAAAAAAGBIBOQAAAAAAAADAkAjIAQAAAAAAAACGREAOAAAAAAAAADCkfAnIY2NjNXToULVs2VK+vr4ym80aNmyYgoKCrF//r9atW8tsNmv79u35sSQAAAAAAAAAADKxe0CenJysXr166aefflJ8fLx8fX3l7++vmjVr2nWetWvXymw2a/r06da2qKgomc1mDRgw4Lbjd+/erYEDB6pZs2Zq0KCBWrdurTFjxig2Ntau6wQAAAAAAAAAFE0u9j7h1q1bFRkZqUqVKmnNmjXy9PS09n3zzTeqVauWKlaseMfzhIeHS5IaN25sbdu5c2eWtuwsW7ZMo0aNUnp6usqVK6f77rtPJ06c0Lfffqu1a9fq66+/Vt26de94jQAAAAAAAACAosvud5AfOXJEkuTv758pHJekHj16aN26dXr33XfveJ7w8HA5OTnJ39/f2hYWFibp1gF5RESERo8erfT0dPXp00e///67goODtWXLFnXq1EmXL19W//79lZycfMdrBAAAAAAAAAAUXXYPyJOSkiRJ7u7u9j61VXx8vCIiIlS3bl2VLl3a2h4WFiZ3d3f5+vrmOHb27NlKS0uTv7+/hgwZIldXV+t6x48fr6pVqyomJkbLly/Pt/UDAAAAAAAAAAqf3bZYCQoK0qxZs6yvQ0JCFBISYn0dGhqqkJAQzZo1S88884wmTpyY57n27Nmj1NTUTHeKnz17VlFRUWratKlcXLK/rPj4eP3666+SpG7dumXpd3Nz0zPPPKOgoCCtXbtWL7zwQp7XCAAAAAAAAMCxrV+/Ps9jjx49muex/fr1y/NYZGa3gNzLy0v+/v46ffq0Tp8+rfLly6tGjRrW/hIlSuT53P8bvmdYvHixFi9enKlt+/btMpvN1tdff/21mjZtKkk6cOCA9Q73Bx98MNu5mjRpIulGCJ+eni4nJ7vfZA8AAAAAAAAAKALsFpB36dJFXbp0sYbZDz/88B3dJX4zb29va3At3Qivk5KSMrUdOnRIly5dkp+fn0qWLGltv3kf9MjISEmSq6urvLy8sp2revXqkm5sFXPy5ElVq1bNLtcAAAAAAAAAACha7BaQ56fOnTurc+fOkqRr166padOm8vHxyXT3eLt27ZSUlKQlS5bIzc0t2/NcvnxZklS2bFmZTKZsjylbtqz16ytXrtjrEgAAAAAAAAAARUyx2z/kzz//VGpqqlq0aGFti4mJUVRUlAICAnIMxyUpMTFRkqwP5szOzVvBJCQk2GHFAAAAAAAAAICiqNgF5Fu3bpUkPfzww9a2bdu2SZKaN29+y7EZW6+kpKTkeEzGHuWS5O7unud1AgAAAAAAAACKtiK/xcq4ceN04MAB6+tDhw5JkgIDA+XicmP5MTExkqTly5frl19+kSRVrFhRM2fOzHSujP3IL1++LIvFku02KxnbsNx8PAAAAAAAAADA8RT5gPzQoUMKDw/P0r53794sbYcPH7Z+7e3tnaW/Vq1akm7cQX7q1Klsj4mKipJ0Y6uV7PoBAAAAAAAAAI6hyG+xsnjxYkVERCgiIkJBQUGSpP79+1vb1q1bJ0lq3769tS0iIkKbNm3Kci5fX1/rHuM7d+7Mdr4dO3ZIkvz8/OTkVOTfHgAAAAAAAABAHhWrBDgsLEySFBAQkKWtcePGtx3v4eGhVq1aSZK+//77LP3JyckKCQmRJHXo0OGO1wsAAAAAAAAAKLqKXUDu4uKihg0bWtt27dolKXNofiv9+/eXs7OzwsPDNXXqVOsDOxMSEjRixAjFxMTI29tbzz33nN3XDwAAAAAAAAAoOor8HuQZrl27poMHD8rX11ceHh7W9rCwMJUqVUr333+/TeepW7euRo0apY8++kjz58/Xjz/+qCpVqujEiRO6du2aPD09NWvWLLm5ueXXpQAAAAAAAAAAioBicwf5X3/9pbS0tExbqcTGxio6OloNGzaUs7Ozzefq1q2blixZorZt28pkMunQoUPy9PRUt27dtGrVKvn6+ubHJQAAAAAAAAAAihC730E+cOBADRw4MNd92T1U82YtWrRQREREprbKlStnabOVv7+//P398zQWAAAAAAAAAFD8FZs7yAEAAAAAAAAAsKdiswc5AAAAAAAAANibl5eX5s6dm6exR48ezfO8/fr1y/NY2A93kAMAAAAAAAAADImAHAAAAAAAAABgSATkAAAAAAAAAABDIiAHAAAAAAAAABgSATkAAAAAAAAAwJAIyAEAAAAAAAAAhkRADgAAAAAAAAAwJJeCnCwpKUnffvut1q1bpyNHjighIUGlS5eWj4+POnbsqC5dusjZ2dlu88XGxmrRokXasmWLoqOjlZqaqnLlyumBBx5Qt27d1KJFC7vNBQAAAAAAAAAoXgosIL948aJeeuklRURESJLuueceVa9eXbGxsdqxY4d27Nih1atXa/78+SpZsuQdz7d371699tprunLlipydnVW1alV5eHgoOjpaGzZs0IYNG/Taa6/p/fffv+O5AAAAAAAAAADFT4FtsTJt2jRFRESobNmyWrx4sX777TcFBwdr69atmjVrltzc3LRjxw4tWLDgjueyWCx67733dOXKFdWvX1/r1q3TL7/8op9++kl//PGH+vXrJ0n64osvtGPHjjueDwAAAAAAAABQ/BRYQB4aGipJ6tevn5o0aZKpr127durZs6ckadOmTXc819GjRxUZGSlJGjdunKpXr27tc3Nz06BBg9SgQQNJ0ubNm+94PgAAAAAAAABA8VNgAXliYqIkqUaNGtn216xZU5KUmppqbRs0aJDMZrOeffZZpaSkZBlz+PBhPfDAAzKbzVq7dq21PSEhwfp1TvNltGd3XgAAAAAAAACA4yuwgNzX11eSFBYWlm3/zp07JUkNGza0tn388cfy9vbW/v37NW3atEzHJyYmavDgwUpMTNTzzz+vxx9/3NpXu3Ztubu75zhfcnKy9u7dm2U+AAAAAAAAAIBxFFhAPnjwYLm5uWnhwoWaM2eOTp48qaSkJJ04cUKTJk3SypUr5eXlZd0fXJLKlCmjwMBAubi4aNGiRfrtt9+sfZ988okOHz6sOnXqaPjw4ZnmKlWqlPr37y9JGj58uFauXKnz588rISFB+/btU//+/RUVFaWHHnooU7AOAAAAAAAAADAOl4KaKCAgQEuWLFFQUJA+/fRTzZgx499FuLjopZde0uuvv64KFSpkGtewYUMNGjRI06ZN07Bhw7RixQrt2rVLP/zwg0qUKKHAwEDr3eI369OnjypXrqwvv/xS7733Xqa+cuXK6YMPPlD37t3l5FRgPyMAAAAAAAAAUMSkpKTo6NGjeRp7882+KJ4KNB2OiYnRuXPnZLFYVL58edWrV0/ly5dXamqqfv755xwf0NmnTx81b95cFy5c0FtvvaWRI0dKkoYNGyaz2ZztmLS0NEVHR+vixYtycnKSt7e36tatKw8PD128eFEhISHWbVYAAAAAAAAAAMZTYHeQL1q0SBMmTFC5cuU0b948tWrVytq3efNmDRs2TCNHjlRSUpJ69uyZaazJZNLkyZP11FNPaffu3ZKkdu3a6cUXX8xxvoEDByo0NFT16tXTF198oTp16ki68ROhr776SlOmTNHLL7+spUuXqkGDBvlwxQAAAAAAAACAoqxA7iC/cOGCdUuVDz74IFM4Lkn//e9/9cEHH0iSZs6cqeTk5CznqFChQqa7xZ9//vkc5/v1118VGhoqFxcXffrpp9ZwXJJcXV3Vu3dvde7cWcnJyfr000/v5NIAAAAAAAAAAMVUgQTk+/btU0JCgiSpZcuW2R6T0X7lyhVFRkZm6f/qq6+0detW657hH330ka5evZrtuXbu3ClJqlmzpqpVq3bL+fbt22f7hQAAAAAAAAAAHEaBBOTXr1/P1fFJSUmZXh84cEBTpkyRJE2fPl1+fn6KiYnRqFGjsh1/7do1m+fK7m51AAAAAAAAAIDjK5CAvFatWtavf//992yP+b//+z9JkrOzs2rUqGFtj4+P1+DBg5WSkqIePXroscceU2BgoEqXLq21a9dq2bJlOc4XGRmp6OjobOfLWMfNawMAAAAAAAAAGEeBBOR169ZV3bp1JUkTJkzQb7/9lql/8+bNmjhxoiSpbdu28vT0tPaNHTtWkZGRMpvNGjp0qCSpWrVqGjNmjCTpk08+0dGjRzOdr0OHDipZsqRSU1M1aNCgTP0pKSlasGCBgoODJUmdO3e278UCAAAAAAAAAIoFl4KYxGQyadq0aXr55ZcVFxen119/XeXLl9c999yjM2fO6Pz585Kke++9N9O2KStXrlRISIjc3d01ffp0ubm5Wfs6deqkrVu3KiQkRO+8846WLVtm7a9cubLGjx+voUOH6u+//1bHjh3l5eUlT09PRUVFWbd86dChg1544YWCeAsAAAAAAAAAAEVMgdxBLkl16tTRqlWrNGDAANWrV09JSUk6ePCgUlJS5O/vr2HDhik4OFgVKlSQJEVFRVnvEh8+fLjuvffeLOccOXKkatasqYMHD2ry5MmZ+p544gmtWLFCXbt2VY0aNXT+/HkdOXJEHh4eeuSRRzRjxgzNmDFDzs7O+X7tAAAAAAAAAICip0DuIM9Qrlw5DRw4UAMHDrztsdWrV1d4ePgtjylVqpTWr1+fY/+9996rsWPH5nqdAAAAAAAAAADHV2B3kAMAAAAAAAAAUJQQkAMAAAAAAAAADImAHAAAAAAAAABgSAW6BzkAAAAAAAAAFCXnzp1Tv379CnsZKCTcQQ4AAAAAAAAAMCQCcgAAAAAAAACAIRGQAwAAAAAAAAAMiYAcAAAAAAAAAGBIBOQAAAAAAAAAAEMiIAcAAAAAAAAAGBIBOQAAAAAAAADAkAjIAQAAAAAAAACGREAOAAAAAAAAADAkAnIAAAAAAAAAgCERkAMAAAAAAAAADImAHAAAAAAAAABgSATkAAAAAAAAAABDIiAHAAAAAAAAABgSATkAAAAAAAAAwJAIyAEAAAAAAAAAhkRADgAAAAAAAAAwJAJyAAAAAAAAAIAhEZADAAAAAAAAAAyJgBwAAAAAAAAAYEgE5AAAAAAAAAAAQyIgBwAAAAAAAAAYEgE5AAAAAAAAAMCQCMgBAAAAAAAAAIZEQA4AAAAAAAAAMCQCcgAAAAAAAACAIRGQAwAAAAAAAAAMiYAcAAAAAAAAAGBIBOQAAAAAAAAAAEMiIAcAAAAAAAAAGBIBOQAAAAAAAADAkAjIAQAAAAAAAACGREAOAAAAAAAAADAkAnIAAAAAAAAAgCERkAMAAAAAAAAADImAHAAAAAAAAABgSATkAAAAAAAAAABDIiAHAAAAAAAAABgSATkAAAAAAAAAwJAIyAEAAAAAAAAAhkRADgAAAAAAAAAwJAJyAAAAAAAAAIAhEZADAAAAAAAAAAyJgBwAAAAAAAAAYEgE5AAAAAAAAAAAQyIgBwAAAAAAAAAYEgE5AAAAAAAAAMCQCMgBAAAAAAAAAIZEQA4AAAAAAAAAMCQCcgAAAAAAAACAIRGQAwAAAAAAAAAMiYAcAAAAAAAAAGBIBOQAAAAAAAAAAEMiIAcAAAAAAAAAGBIBOQAAAAAAAADAkAjIAQAAAAAAAACGREAOAAAAAAAAADAkAnIAAAAAAAAAgCG5FPYCkNnZs2fl6uqqmjVrFvZSYEeurq6yWCx2PSe14pioFdiKWvlXmzZt8jSuuF1nXlErdy6vNSYVrzpztFoxyp9bYXC0WkH+oVZgK2oFtqJWYKvc1AoBeRFTokQJmUwmVatWrbCXAjuKi4uTm5ubXc9JrTgmagW2olbuXO3atQt7CQWCWilcxanOqJV/Fac/t8JArcBW1ApsRa3AVtQKbJWbWjFZ7P1jFwAAAAAAAAAAigH2IAcAAAAAAAAAGBIBOQAAAAAAAADAkAjIAQAAAAAAAACGREAOAAAAAAAAADAkl8JeQFF35MgR7dixQ/v379f+/ft19OhRpaam6plnntHEiRMLe3kAAAAAAAAAgDwiIL+NwMBAhYaGFvYyAAAAAAAAAAB2RkB+G5UqVVLbtm1Vv3591a9fXz/99JNWr15d2MsCAAAAAAAAANwhAvLbGDNmTKbXGzZsKJyFAAAAAAAAAADs6pYP6WzdurXMZrO2b9+uY8eO6Z133lHz5s31wAMP6Mknn1RISIj12GvXrikwMFDt27dXgwYN1KpVK02aNEkJCQlZzhsWFqZJkyapS5cuatGiherXr69mzZrp9ddf16ZNm7Jdy+TJk2U2m9W6dWtduXIlS39cXJyaNWsms9ms+fPnZ+ozm80ym82KiYlRWFiYXn/9dTVt2lR+fn566qmn9M033ygtLc2mNwwAAAAAAAAA4BhuGZBn+Pvvv/Xss89q8+bNqly5skqXLq2IiAgNGzZMCxcu1MWLF9W1a1ctWLBAJUuWVOXKlRUbG6svv/xSgwYNynK+/v3768svv1R0dLTuuusu+fj4yGKx6LffftObb76padOmZRkzePBg+fn56eTJk/rwww8z9aWnp+v999/X+fPn1aJFC/Xu3Tvb69i4caN69eqlnTt3qmrVqrr77rt18OBBjRs3Tm+99RYhOQAAAAAAAAAYiE0BeWBgoJ588klt27ZNwcHB2rp1q/r37y9JmjlzpoYMGaIyZcpo06ZNWrlypTZu3Kh58+bJxcVFv/32m7Zt25bpfEOGDNHGjRu1fft2rV69WsHBwfrjjz+0cOFClS9fXvPmzdNff/2VaYyrq6sCAwNVunRprV+/XkuXLrX2zZs3T9u2bVOFChU0adIkmUymbK9j6tSpeuaZZ7Rt2zYtX75cv/76q2bPnq2SJUtq48aNWrhwYW7eOwAAAAAAAABAMWZTQF6rVi2NHj1a7u7u1rZ+/fqpUqVKio+P186dOzV9+nTdc8891v6HH35Ybdq0kST9+uuvmc733HPPqVq1alnmadasmQYPHixJmbZvyVCtWjWNHTtWkjRx4kQdOnRIu3fvVlBQkEwmkyZNmqQKFSrkeB1Vq1bVuHHjMl1H27Zt9eabb0qSFixYoOTk5Nu9HQAAAAAAAAAAB2DTQzq7dOkiJ6fMWbqLi4vMZrPOnj2rli1bysvLK8u4+vXra/369YqKisrSd+TIEa1bt04RERG6dOmSUlNTJd3Yy1yS/vnnn2zX8sQTT2jbtm368ccf9fbbbysxMVGpqanq3bu3WrRoccvr6NmzZ5brkKTu3bsrKChIFy9e1N69exUQEHDL8wAAAAAAAAAAij+bAvIaNWpk216+fHlJUvXq1W/Zf/369UztU6dO1YIFC2SxWHKc89KlSzn2ffjhh9q9e7eOHj0qSfLz89Pbb7+d4/EZfHx8sm0vU6aMKleurJMnT+ro0aME5AAAAAAAAABgADZtsXLzliQ3y9jr28PD45b9N1uzZo3mz58vk8mkAQMGaMWKFdq1a5f++ecfRUREaNGiRZJkvaM8p/X4+/tbX3fu3Fmurq63vY6MwD47GVuz/G+YDwAAAAAAAABwTDYF5PYUHBwsSXr55Zc1cOBA1a1bV6VLl7ZufXKrO8czbNy4UcuWLbOOCQwM1KlTp2477vz58zn2nTt3TpJUqlSp254HAAAAAAAAAFD8FXhAHhMTI0l68MEHs+3fs2fPLcefOXNGI0aMkCR98MEHateuna5cuaJ3331XaWlptxx7+PDhbNuvXr2q2NhYSdK99957y3MAAAAAAAAAABxDgQfkGdu1xMXFZem7cOGCQkJCchyblpamIUOG6NKlS/rvf/+rXr166eOPP5aXl5fCw8MVFBR0y7m/+eabbPc9X7p0qVJTU1WuXDn5+fnl8ooAAAAAAAAAAMVRgQfkGXeOz507V8ePH7e2R0dH64033lBCQkKOYz/77DPt3LlTlSpV0oQJEyRJd911l6ZOnSpnZ2fNnTtX27dvz3F8VFSURo8ercTERGtbaGio5syZI0l69dVX5ebmdkfXBwAAAAAAAAAoHlwKesLevXvr559/1smTJ9WxY0fVrFlTTk5OOnLkiEqXLq2hQ4dq7NixWcbt3LlTc+bMkZOTk6ZMmaJy5cpZ+wICAvTmm29q1qxZeu+997RixYpM/RmGDBmiyZMna/Xq1apVq5YuXLhg3bu8devWevXVV7OMWbNmTab1ZAT4a9as0ebNmzNdV58+ffL+xtx0LcnJyapYseIdnwtFR1xcnNzc3BQWFma3c1Irjolaga2oFdiKWoGtqBXYilqBragV2Ipaga2oFdgqN7VS4AF55cqV9f3332v69OnaunWrTpw4oQoVKujpp59W//79dfLkySxjLl26pCFDhigtLU19+/bVf/7znyzH9OvXT3/++afCwsI0fPhw613hN2vbtq3q16+vuXPnau/evYqPj5ePj4+ee+45de/eXc7OzlnGJCUlZfvg0OTkZCUnJ1tf33xX+p1ISkpSUlKSjh07ZpfzoWhwdXW95W9H5AW14pioFdjK0Wqldu3aBT6nUf5OOFqtFIbCqE+p4GvU0WqFz5X842i1gvxDrcBW1ApslV+1kpqaavfzFlWnT58u7CUUiNzUismS3abcDsZsNku6sZ1K1apVC3k1t9amTRsdO3ZMkZGRhb0U2FHNmjUlKdO2QneKWnFM1Aps5Wi1UhjfjphMpgKfszA4Wq0UhsL6drmga9TRaoXPlfzjaLWC/EOtwFbUCmyVX7WSkJCgMWPG2O2cRdmjjz5a2EsoELmplQLfgxwAAAAAAAAAgKKAgBwAAAAAAAAAYEgE5AAAAAAAAAAAQyIgBwAAAAAAAAAYkkthL6AgREREFPYSAAAAAAAAAABFDHeQAwAAAAAAAAAMiYAcAAAAAAAAAGBI+RKQx8bGaujQoWrZsqV8fX1lNps1bNgwBQUFWb/+X61bt5bZbNb27dvzY0kAAAAAAAAAAGRi94A8OTlZvXr10k8//aT4+Hj5+vrK399fNWvWtOs8a9euldls1vTp061tUVFRMpvNGjBgwG3H7969WwMHDlSzZs3UoEEDtW7dWmPGjFFsbKxd1wkAAAAAAAAAKJrs/pDOrVu3KjIyUpUqVdKaNWvk6elp7fvmm29Uq1YtVaxY8Y7nCQ8PlyQ1btzY2rZz584sbdlZtmyZRo0apfT0dJUrV0733XefTpw4oW+//VZr167V119/rbp1697xGgEAAAAAAAAARZfd7yA/cuSIJMnf3z9TOC5JPXr00Lp16/Tuu+/e8Tzh4eFycnKSv7+/tS0sLEzSrQPyiIgIjR49Wunp6erTp49+//13BQcHa8uWLerUqZMuX76s/v37Kzk5+Y7XCAAAAAAAAAAouuwekCclJUmS3N3d7X1qq/j4eEVERKhu3boqXbq0tT0sLEzu7u7y9fXNcezs2bOVlpYmf39/DRkyRK6urtb1jh8/XlWrVlVMTIyWL1+eb+sHAAAAAAAAABQ+uwXkGQ/gDAoKkiSFhITIbDZb/xcTE3PLh3Tmxp49e5SamprpTvGzZ88qKipKfn5+cnHJfueY+Ph4/frrr5Kkbt26Zel3c3PTM888I+nGHucAAAAAAAAAAMdltz3Ivby85O/vr9OnT+v06dMqX768atSoYe0vUaJEns8dFBSkWbNmZWlfvHixFi9enKlt+/btMpvN1tdff/21mjZtKkk6cOCA9Q73Bx98MNu5mjRpIulGCJ+eni4nJ7vfZA8AAAAAAAAAKALsFpB36dJFXbp0sYbZDz/8sCZOnGiXc3t7e1uDa+lGeJ2UlJSp7dChQ7p06ZL8/PxUsmRJa/vN+6BHRkZKklxdXeXl5ZXtXNWrV5d0Y6uYkydPqlq1ana5BgAAAAAAAABA0WK3gDw/de7cWZ07d5YkXbt2TU2bNpWPj0+mu8fbtWunpKQkLVmyRG5ubtme5/Lly5KksmXLymQyZXtM2bJlrV9fuXLFXpcAAAAAAAAAAChiit3+IX/++adSU1PVokULa1tMTIyioqIUEBCQYzguSYmJiZJkfTBndm7eCiYhIcEOKwYAAAAAAAAAFEXFLiDfunWrJOnhhx+2tm3btk2S1Lx581uOzdh6JSUlJcdjMvYolyR3d/c8rxMAAAAAAAAAULQV+S1Wxo0bpwMHDlhfHzp0SJIUGBgoF5cby4+JiZEkLV++XL/88oskqWLFipo5c2amc2XsR3758mVZLJZst1nJ2Ibl5uMBAAAAAAAAAI6nyAfkhw4dUnh4eJb2vXv3Zmk7fPiw9Wtvb+8s/bVq1ZJ04w7yU6dOZXtMVFSUpBtbrWTXDwAAAAAAAABwDEV+i5XFixcrIiJCERERCgoKkiT179/f2rZu3TpJUvv27a1tERER2rRpU5Zz+fr6WvcY37lzZ7bz7dixQ5Lk5+cnJ6ci//YAAAAAAAAAAPKoWCXAYWFhkqSAgIAsbY0bN77teA8PD7Vq1UqS9P3332fpT05OVkhIiCSpQ4cOd7xeAAAAAAAAAEDRVewCchcXFzVs2NDatmvXLkmZQ/Nb6d+/v5ydnRUeHq6pU6daH9iZkJCgESNGKCYmRt7e3nruuefsvn4AAAAAAAAAQNFR5Pcgz3Dt2jUdPHhQvr6+8vDwsLaHhYWpVKlSuv/++206T926dTVq1Ch99NFHmj9/vn788UdVqVJFJ06c0LVr1+Tp6alZs2bJzc0tvy4FAAAAAAAAAFAEFJs7yP/66y+lpaVl2kolNjZW0dHRatiwoZydnW0+V7du3bRkyRK1bdtWJpNJhw4dkqenp7p166ZVq1bJ19c3Py4BAAAAAAAAAFCE2P0O8oEDB2rgwIG57svuoZo3a9GihSIiIjK1Va5cOUubrfz9/eXv75+nsQAAAAAAAACA4q/Y3EEOAAAAAAAAAIA9FZs9yAEAAAAAAADAUTz66KOFvQSIO8gBAAAAAAAAAAZFQA4AAAAAAAAAMCQCcgAAAAAAAACAIRGQAwAAAAAAAAAMiYAcAAAAAAAAAGBIBOQAAAAAAAAAAEMiIAcAAAAAAAAAGFKhBeSnT5+Wv7+/zGazzGazYmJi8nW+ffv2ydfX1zofAAAAAAAAAMDYCi0g//DDD3X9+vUCmSslJUXDhw9XWlpagcwHAAAAAAAAACj6CiUgX758ubZs2aJ27doVyHxz5szRoUOHCmw+AAAAAAAAAEDRV+AB+dmzZzVx4kR5e3tr0KBB+T7fwYMHNW/ePDVs2FDdu3fP9/kAAAAAAAAAAMVDgQfkY8aM0ZUrVzR27Fi5u7vneNzkyZNlNpvVunVrXblyJUt/XFycmjVrJrPZrPnz52d7jtTUVA0fPlySNG7cODk58UxSAAAAAAAAAMANBZoYr169WqGhoXryySfVokWLWx47ePBg+fn56eTJk/rwww8z9aWnp+v999/X+fPn1aJFC/Xu3Tvbc3zxxRf6+++/1bt3b/n4+NjtOgAAAAAAAAAAxV+BBeQXLlzQxx9/rHLlyumDDz647fGurq4KDAxU6dKltX79ei1dutTaN2/ePG3btk0VKlTQpEmTZDKZsow/evSoZs2apdq1a6tfv352vRYAAAAAAAAAQPFXYAH52LFjdfHiRQ0fPlx33323TWOqVaumsWPHSpImTpyoQ4cOaffu3QoKCpLJZNKkSZNUoUKFLOPS09M1YsQIpaSkaNy4cXJzc7PrtQAAAAAAAAAAij+Xgphk48aN+vnnn9WyZUs9+eSTuRr7xBNPaNu2bfrxxx/19ttvKzExUampqerdu3eO27R8/fXX2r17t7p27aqAgAB7XAIAAAAAAAAAwMHke0B++fJljRkzRh4eHvroo4/ydI4PP/xQu3fv1tGjRyVJfn5+evvtt7M9NioqSjNmzFClSpX03nvv5XXZAAAAAAAAAAAHl+9brEyePFlxcXEaNGiQvL2983QOd3d3+fv7W1937txZrq6u2R47atQoJSQkaPTo0SpTpkye5gMAAAAAAAAAOL58v4N8//79kqS5c+dq/vz5mfrS0tKsX3fp0kXOzs7q0KGDPvzww0zHbdy4UcuWLZOTk5PS09MVGBioVq1aqUqVKjnON3r0aI0ePTpTX0pKivXr5s2bS5JeffVVvfbaa3dwhQAAAAAAAACA4qhA9iCXpAsXLtyy/+LFi5Kka9euZWo/c+aMRowYIUn64IMPtGPHDm3YsEHvvvuuvvnmGzk7O2d7vnPnzt1yvoz++Ph4m9YPAAAAAAAAAHAs+R6Qr1ixIse+mJgYtWnTRpIUGhqqqlWrZupPS0vTkCFDdOnSJf33v/9Vr1699OSTT2r//v0KDw9XUFBQlr3Iw8LCcpxv+/bt6tWrlyQpIiIij1cEAAAAAAAAAHAE+b4H+Z347LPPtHPnTlWqVEkTJkyQJN11112aOnWqnJ2dNXfuXG3fvr2QVwkAAAAAAAAAKI6KbEC+c+dOzZkzR05OTpoyZYrKlStn7QsICNCbb76p9PR0vffee9btWQAAAAAAAAAAsFWRDMgvXbqkIUOGKC0tTa+//rr+85//ZDmmX79+CggIUGxsrIYPH14IqwQAAAAAAAAAFGcF9pDO7FStWjXbvcDvuusu/fbbb7cc6+zsrCVLluRqvqZNm7L3OAAAAAAAAABAUhG9gxwAAAAAAAAAgPxGQA4AAAAAAAAAMCQCcgAAAAAAAACAIRXqHuQAAAAAAAAAUJhOnz6tRx99tLCXgULCHeQAAAAAAAAAAEMiIAcAAAAAAAAAGBIBOQAAAAAAAADAkAjIAQAAAAAAAACGREAOAAAAAAAAADAkAnIAAAAAAAAAgCERkAMAAAAAAAAADImAHAAAAAAAAABgSATkAAAAAAAAAABDIiAHAAAAAAAAABgSATkAAAAAAAAAwJAIyAEAAAAAAAAAhkRADgAAAAAAAAAwJAJyAAAAAAAAAIAhEZADAAAAAAAAAAyJgBwAAAAAAAAAYEgE5AAAAAAAAAAAQyIgBwAAAAAAAAAYEgE5AAAAAAAAAMCQCMgBAAAAAAAAAIZEQA4AAAAAAAAAMCQCcgAAAAAAAACAIRGQAwAAAAAAAAAMiYAcAAAAAAAAAGBIBOQAAAAAAAAAAEMiIAcAAAAAAAAAGBIBOQAAAAAAAADAkAjIAQAAAAAAAACGREAOAAAAAAAAADAkAnIAAAAAAAAAgCERkAMAAAAAAAAADImAHAAAAAAAAABgSATkAAAAAAAAAABDIiAHAAAAAAAAABgSATkAAAAAAAAAwJAIyAEAAAAAAAAAhkRADgAAAAAAAAAwJAJyAAAAAAAAAIAhEZADAAAAAAAAAAyJgBwAAAAAAAAAYEgE5AAAAAAAAAAAQyIgBwAAAAAAAAAYEgE5AAAAAAAAAMCQCMgBAAAAAAAAAIZEQA4AAAAAAAAAMCQCcgAAAAAAAACAIRGQAwAAAAAAAAAMiYAcAAAAAAAAAGBIBOQAAAAAAAAAAEMiIAcAAAAAAAAAGBIBOQAAAAAAAADAkAjIAQAAAAAAAACGREAOAAAAAAAAADAkAnIAAAAAAAAAgCERkAMAAAAAAAAADImAHAAAAAAAAABgSATkAAAAAAAAAABDIiAHAAAAAAAAABiSS2EvAJmdPXtWrq6uqlmzZmEvBXbk6uoqi8Vi13NSK46JWoGtHK1W2rRpU+BzGuXvhKPVSmEojPqUCr5GHa1W+FzJP45WK8g/1ApsRa3AVtQKbJWbWiEgL2JKlCghk8mkatWqFfZSYEdxcXFyc3Oz6zmpFcdErcBW1Mqdq127dmEvoUBQK8VXQdcotXLn+FzJO6PVilFQK7AVtQJbUSuwVW5qxWSx949dAAAAAAAAAAAoBtiDHAAAAAAAAABgSATkAAAAAAAAAABDIiAHAAAAAAAAABgSATkAAAAAAAAAwJAIyAEAAAAAAAAAhkRADgAAAAAAAAAwJAJyAAAAAAAAAIAhEZADAAAAAAAAAAyJgBwAAAAAAAAAYEgE5AAAAAAAAAAAQyIgBwAAAAAAAAAYEgE5AAAAAAAAAMCQCMgBAAAAAAAAAIZEQA4AAAAAAAAAMCQCcgAAAAAAAACAIRGQAwAAAAAAAAAMiYAcAAAAAAAAAGBIBOQAAAAAAAAAAEMiIAcAAAAAAAAAGBIBOQAAAAAAAADAkAjIAQAAAAAAAACGREAOAAAAAAAAADAkAnIAAAAAAAAAgCERkAMAAAAAAAAADImAHAAAAAAAAABgSATkAAAAAAAAAABDIiAHAAAAAAAAABgSATkAAAAAAAAAwJAIyAEAAAAAAAAAhuRi64GxsbEKDAzUtm3bdP78eaWlpemZZ56Rt7e3Zs2apWeeeUYTJ07Mz7UCAAAAAAAAAGA3NgXkycnJ6tWrlyIjI1W6dGn5+vrK1dVVNWvWVEpKit0XFRwcrJMnT6pt27a6//77sz1m48aN+ueff9SkSRM1bdrU7msAAAAAAAAAADg2mwLyrVu3KjIyUpUqVdKaNWvk6elp7QsKCrL7okJCQrRjxw55e3vfMiAPCQnRgAEDCMgBAAAAAAAAALlm0x7kR44ckST5+/tnCscBAAAAAAAAACiubArIk5KSJEnu7u75uhgAAAAAAAAAAAqKyWKxWHLqDAoK0qxZs3IcHBoaqpCQkBwf0nngwAFt2LBBf/zxh06dOqULFy6oVKlSMpvN6ty5s5566imZTCbr8du3b1evXr1ynK9JkyaaMGGC2rRpk+Mx3t7e2rRpU6a2EydOaOHChfrjjz905swZOTk5qXbt2urUqZNefPFFubm5ZTo+JibGOkdERITCwsI0b9487dmzRwkJCapRo4a6du2q7t27Z1o/AAAAAAAAAKD4uOUe5F5eXvL399fp06d1+vRplS9fXjVq1LD2lyhR4pYn//DDD/X333+rTJkyqlixoipWrKizZ89q+/bt2r59u37//XdNmzbNenyZMmXk7++vQ4cO6dq1a6pZs6buvvtua7+Pj49KlCghf39/nThxQufPn5eXl5e8vLysx1SsWDHTGlauXKkRI0YoOTlZJUuWVPXq1ZWQkKADBw5o//79WrdunRYsWKDSpUtnew3BwcEaMWKEPD09VbVqVZ06dUqHDh3SuHHjdPLkSQ0dOvSW7wEAAAAAAAAAoGi65R3kGTLuJM/uLvFb9a1atUpms1k+Pj6Z2vfu3av33ntPkZGRCgwM1BNPPJGpv2fPntqxY4cmTJigzp07Z7umYcOGWR/SOXDgwGyP2bVrl3r16iWTyaT33ntPL7zwgvVu8ePHj+u9997Tvn379Oyzz2r8+PHWcTffQe7m5qZ3331XPXv2lLOzsyRp7ty5CgwMlMlk0i+//KLq1avf7i0EAAAAAAAAABQxNu1BnledOnXKEo5Lkp+fn0aPHi1JCgkJybf5p06dqtTUVA0ZMkQvvfRSpq1UatWqpaCgIHl4eOinn35SbGxstud48skn9fLLL1vDcUl644035OPjI4vFol9//TXf1g8AAAAAAAAAyD+33GLFHk6ePKk1a9bowIEDunjxopKTkyXJ+v///PNPvswbGxur8PBwubi4qEuXLtke4+Xlpfr162vHjh3auXOnOnbsmOWY7t27Zzu2UaNGOnTokKKiouy6bgAAAAAAAABAwcjXgPzrr7/W5MmTlZKSkuMxly5dype5Dx48KElycnJSnz59cjwuMjJSknT69Ols+2vWrJlte/ny5SVJ169fz/siAQAAAAAAAACFJt8C8t27d+uTTz6RdOMu7Kefflo1a9ZUqVKl5OzsrOjoaLVt21apqan5Mv/ly5cl3bhTPTw8/LbHJyYmZtvu4eGRbbuT043daWzYwh0AAAAAAAAAUATlW0Cesbf4o48+qlGjRmXpv3jxYn5NLenfYLtKlSravHlzvs4FAAAAAAAAACh+8u0hnSdPnpQkPfjgg9n279mz547ObzKZbtlvNpslSWfOnMm3bVwAAAAAAAAAAMVXvgXkJUuWlCTFxcVl6UtKStI333yT41h3d3dJUkJCwm3Pn9Mx1apVU7169ZSenq6FCxfavG4AAAAAAAAAgDHkW0Cecef40qVLtXfvXmv7+fPn9dZbb+X4UExJql69uiRp+/btSk9Pz/aYGjVqSJJ27dql5OTkbI8ZNmyYXFxcNHfuXE2fPl1XrlzJ1J+UlKTffvtNb731lu0XBgAAAAAAAABwCPm2B/nzzz+vH374QUePHtXzzz+vGjVqyMPDQ4cPH5bJZNKoUaP04YcfZjv2ySef1JIlS7R+/Xo98sgj8vb2louLi+rWrasRI0ZIurG3+YwZM/TXX3+pVatWqlGjhlxdXVWhQgVNnz5dktSkSRNNmTJFI0aM0Oeff64FCxaoVq1aKlWqlC5fvqyYmBilpKTk11sAAAAAAAAAACjC8i0g9/Dw0JIlS/Tpp58qNDRUJ0+e1F133aW2bduqb9++Kl26dI5j/fz8NHv2bC1cuFAHDx7UX3/9leVOci8vL33xxRf6/PPPtW/fPu3Zs0fp6eny9vbOdNzjjz8uf39/LV68WFu2bFF0dLQSExNVpkwZ1a9fX82bN1fbtm3z5T0AAAAAAAAAABRdJovFYinsRQAAAAAAAAAAUNDybQ9yAAAAAAAAAACKMgJyAAAAAAAAAIAhEZADAAAAAAAAAAyJgBwAAAAAAAAAYEgE5AAAAAAAAAAAQyIgBwAAAAAAAAAYEgE5AAAAAAAAAMCQCMgBAAAAAAAAAIbkYq8TxcXFadu2bdq/f7/279+vf/75RwkJCfL29tamTZvsNY3VkSNHtGPHDut8R48eVWpqqp555hlNnDjRpnMkJyfr22+/1bp163Ts2DHFx8fr7rvvVp06ddS6dWt1797d7usGAAAAAAAAABQNdgvI16xZowkTJtjrdLcVGBio0NDQPI+Pjo5W7969FRkZKScnJ9WqVUtVq1a1Bv1RUVEE5AAAAAAAAADgwOwWkJcuXVoPPfSQ6tevr/r16+v06dM238mdF5UqVVLbtm2t8/30009avXq1TWMvX76snj176vTp0+revbsGDBigu+++29p/4cIF7d27N7+WDgAAAAAAAAAoAuwWkHfp0kVdunSxvl6zZo29Tp2tMWPGZHq9YcMGm8dOmjRJp0+fVo8ePTRy5Mgs/XfffbceeeSRO1whAAAAAAAAAKAoK9SHdA4aNEhms1nPPvusUlJSsvQfPnxYDzzwgMxms9auXWuXOc+dO6eVK1fK1dVV/fv3t8s5AQAAAAAAAADFj93uIM+Ljz/+WPv27dP+/fs1bdo0DRs2zNqXmJiowYMHKzExUc8//7wef/xxu8z522+/KSUlRQ0aNNDdd9+tjRs3av369Tp79qzKli0rf39/PfvssypTpoxd5gMAAAAAAAAAFE2FGpCXKVNGgYGB6t69uxYtWqSHHnpIrVq1kiR98sknOnz4sOrUqaPhw4fbbc6MvcXvuecevfXWW1q/fn2m/vXr12vu3Ln67LPP1KhRI7vNCwAAAAAAAAAoWgp1ixVJatiwoQYNGiSLxaJhw4bp7Nmz+vnnn/XDDz+oRIkSCgwMlLu7u93mi4uLkyT9+uuvWr9+vV566SX9+uuv2rdvn5YsWSIfHx9duHBBb775pvVYAAAAAAAAAIDjKfSAXJL69Omj5s2b68KFC3rrrbesD84cNmyYzGazXeeKj4+XJKWkpOjxxx/X8OHD5eXlJTc3NwUEBGj+/PkqUaKELl68qK+++squcwMAAAAAAAAAio4iEZCbTCZNnjxZFSpU0O7du3X16lW1a9dOL774ot3nKlmypPXrV155JUv/PffcoyeeeELSjf3KAQAAAAAAAACOqUgE5JJUoUKFTHeLP//88/kyT9myZa1f33vvvdkek9EeExOTL2sAAAAAAAAAABS+IhOQf/XVV9q6daucnG4s6aOPPtLVq1ftPk/t2rUl3bhr3dXVNdtj3NzcJElpaWl2nx8AAAAAAAAAUDQUiYD8wIEDmjJliiRp+vTp8vPzU0xMjEaNGmX3ufz9/SVJFoslxzvEo6KiJN3YbgUAAAAAAAAA4JgKPSCPj4/X4MGDlZKSoh49euixxx5TYGCgSpcurbVr12rZsmV2na9x48by8vKSJC1fvjzb9axdu1aS1KxZM7vODQAAAAAAAAAoOgo9IB87dqwiIyNlNps1dOhQSVK1atU0ZswYSdInn3yio0eP2m0+Jycnvf3225KkxYsX65dffrH2Xb9+XSNGjND58+dVsmTJbB/iCQAAAAAAAABwDCaLxWKxx4lOnz6tp59+2vo6JSVF169fl5OTkzw9Pa3t/v7+mjNnjiRp5cqVeu+99+Tu7q7ly5dneWjmsGHDFBISorp162rZsmXWvcElac2aNRo7dqz1dUJCgpKSkuTm5iYPDw9re+/evdWnT58s6x0/fry++uorSZK3t7fuvvtuHT16VPHx8XJzc9O0adPUvn37O3tTAAAAAAAAAABFlou9TpSWlqZLly5laU9PT8/Ufu3aNUk39vnOuEt8+PDhWcJxSRo5cqR2796tgwcPavLkyfrwww+tfUlJSdnOl5ycrOTkZOvrxMTEbNc7fPhw/ec//9GSJUu0f/9+nT17VuXLl9ejjz6qPn36ZLseAAAAAAAAAIDjsNsd5AAAAAAAAAAAFCd2u4Mc9hEQEKDk5GRVrFixsJcCO4qLi5Obm5vCwsLsdk5qxTFRK7AVtQJbUSuwFbUCW1ErsBW1AltRK7AVtQJb5aZWCMiLmKSkJCUlJenYsWOFvRTYkaurqxISEux6TmrFMVErsFVh1Ert2rVvOT6/aqwozpuff5/sPW9R/FxxlPf2TucsavPyuVK48xan2i+KnysomqgV2Ipaga3yq1ZSU1PzfN7Tp0/neW4vL698OS9yVysE5EVMpUqVdOzYMUVGRhb2UmBHNWvWtPs5qRXHRK3AVoVRK8ePH7/leJPJZPc1FdV582vO/Ji3KH6uOMp7e6dzFrV5+Vwp3HmLU+0Xxc8VFE3UCmxFrcBW+VUrCQkJ1mcl5tajjz6a57nnzp2bL+dF7mrFKf+WAQAAAAAAAABA0UVADgAAAAAAAAAwJAJyAAAAAAAAAIAhEZADAAAAAAAAAAzJZLFYLIW9CPyrQYMGSkpKUkpKSmEvBXbk6uoqi8Wiw4cP2+2c1IpjolZgq8Koldq1a99y/LFjx+y2lqI+b37NmR/zFsXPFUd5b+90zqI2L58rhTtvcar9ovi5gqKJWoGtqBXYKr9qJTU1VeXKlcvT+NOnT+d5bi8vr3w5L3JXKy4FsB7kQokSJWQymVStWrXCXgrsKC4uTm5ubnY9J7XimKgV2Koo1srtAqf8UhjzFqdrLYq1civF6b11tHmLYq0UpffHEefM67xFsVZQNFErsBW1AlvlZ624u7vnaXx+/RteWN8bOIrc1Ap3kAMAAAAAAAAADIk9yAEAAAAAAAAAhkRADgAAAAAAAAAwJAJyAAAAAAAAAIAhEZADAAAAAAAAAAyJgBwAAAAAAAAAYEgE5AAAAAAAAAAAQyIgBwAAAAAAAAAYEgE5AAAAAAAAAMCQ/h9DQgvFF+qYTAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1500x600 with 40 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "featurizer_layers = ['conv1', 'relu1', 'maxp1', 'flatten']\n",
    "\n",
    "with plt.style.context('seaborn-white'):\n",
    "    fig = sbs_cnn1.visualize_outputs(featurizer_layers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing Classifier Layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x450 with 30 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "classifier_layers = ['fc1', 'relu2', 'fc2']\n",
    "\n",
    "with plt.style.context('seaborn-white'):\n",
    "    fig = sbs_cnn1.visualize_outputs(classifier_layers, y=labels_batch, yhat=predicted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "def correct(self, x, y, threshold=.5):\n",
    "    self.model.eval()\n",
    "    yhat = self.model(x.to(self.device))\n",
    "    y = y.to(self.device)\n",
    "    self.model.train()\n",
    "    \n",
    "    # We get the size of the batch and the number of classes \n",
    "    # (only 1, if it is binary)\n",
    "    n_samples, n_dims = yhat.shape\n",
    "    if n_dims > 1:        \n",
    "        # In a multiclass classification, the biggest logit\n",
    "        # always wins, so we don't bother getting probabilities\n",
    "        \n",
    "        # This is PyTorch's version of argmax, \n",
    "        # but it returns a tuple: (max value, index of max value)\n",
    "        _, predicted = torch.max(yhat, 1)\n",
    "    else:\n",
    "        n_dims += 1\n",
    "        # In binary classification, we NEED to check if the\n",
    "        # last layer is a sigmoid (and then it produces probs)\n",
    "        if isinstance(self.model, nn.Sequential) and \\\n",
    "           isinstance(self.model[-1], nn.Sigmoid):\n",
    "            predicted = (yhat > threshold).long()\n",
    "        # or something else (logits), which we need to convert\n",
    "        # using a sigmoid\n",
    "        else:\n",
    "            predicted = (F.sigmoid(yhat) > threshold).long()\n",
    "    \n",
    "    # How many samples got classified correctly for each class\n",
    "    result = []\n",
    "    for c in range(n_dims):\n",
    "        n_class = (y == c).sum().item()\n",
    "        n_correct = (predicted[y == c] == c).sum().item()\n",
    "        result.append((n_correct, n_class))\n",
    "    return torch.tensor(result)\n",
    "\n",
    "setattr(StepByStep, 'correct', correct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[5, 7],\n",
       "        [3, 3],\n",
       "        [6, 6]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sbs_cnn1.correct(images_batch, labels_batch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loader Apply"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "@staticmethod\n",
    "def loader_apply(loader, func, reduce='sum'):\n",
    "    results = [func(x, y) for i, (x, y) in enumerate(loader)]\n",
    "    results = torch.stack(results, axis=0)\n",
    "\n",
    "    if reduce == 'sum':\n",
    "        results = results.sum(axis=0)\n",
    "    elif reduce == 'mean':\n",
    "        results = results.float().mean(axis=0)\n",
    "    \n",
    "    return results\n",
    "\n",
    "setattr(StepByStep, 'loader_apply', loader_apply)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[59, 67],\n",
       "        [55, 62],\n",
       "        [71, 71]])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "StepByStep.loader_apply(sbs_cnn1.val_loader, sbs_cnn1.correct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Putting It All Together"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Builds tensors from numpy arrays BEFORE split\n",
    "# Modifies the scale of pixel values from [0, 255] to [0, 1]\n",
    "x_tensor = torch.as_tensor(images / 255).float()\n",
    "y_tensor = torch.as_tensor(labels).long()\n",
    "\n",
    "# Uses index_splitter to generate indices for training and\n",
    "# validation sets\n",
    "train_idx, val_idx = index_splitter(len(x_tensor), [80, 20])\n",
    "# Uses indices to perform the split\n",
    "x_train_tensor = x_tensor[train_idx]\n",
    "y_train_tensor = y_tensor[train_idx]\n",
    "x_val_tensor = x_tensor[val_idx]\n",
    "y_val_tensor = y_tensor[val_idx]\n",
    "\n",
    "# We're not doing any data augmentation now\n",
    "train_composer = Compose([Normalize(mean=(.5,), std=(.5,))])\n",
    "val_composer = Compose([Normalize(mean=(.5,), std=(.5,))])\n",
    "\n",
    "# Uses custom dataset to apply composed transforms to each set\n",
    "train_dataset = TransformedTensorDataset(x_train_tensor, y_train_tensor, transform=train_composer)\n",
    "val_dataset = TransformedTensorDataset(x_val_tensor, y_val_tensor, transform=val_composer)\n",
    "\n",
    "# Builds a weighted random sampler to handle imbalanced classes\n",
    "sampler = make_balanced_sampler(y_train_tensor)\n",
    "\n",
    "# Uses sampler in the training set to get a balanced data loader\n",
    "train_loader = DataLoader(dataset=train_dataset, batch_size=16, sampler=sampler)\n",
    "val_loader = DataLoader(dataset=val_dataset, batch_size=16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(13)\n",
    "model_cnn1 = nn.Sequential()\n",
    "\n",
    "# Featurizer\n",
    "# Block 1: 1@10x10 -> n_channels@8x8 -> n_channels@4x4\n",
    "n_channels = 1\n",
    "model_cnn1.add_module('conv1', nn.Conv2d(in_channels=1, out_channels=n_channels, kernel_size=3))\n",
    "model_cnn1.add_module('relu1', nn.ReLU())\n",
    "model_cnn1.add_module('maxp1', nn.MaxPool2d(kernel_size=2))\n",
    "# Flattening: n_channels * 4 * 4\n",
    "model_cnn1.add_module('flatten', nn.Flatten())\n",
    "\n",
    "# Classification\n",
    "# Hidden Layer\n",
    "model_cnn1.add_module('fc1', nn.Linear(in_features=n_channels*4*4, out_features=10))\n",
    "model_cnn1.add_module('relu2', nn.ReLU())\n",
    "# Output Layer\n",
    "model_cnn1.add_module('fc2', nn.Linear(in_features=10, out_features=3))\n",
    "\n",
    "lr = 0.1\n",
    "multi_loss_fn = nn.CrossEntropyLoss(reduction='mean')\n",
    "optimizer_cnn1 = optim.SGD(model_cnn1.parameters(), lr=lr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "sbs_cnn1 = StepByStep(model_cnn1, multi_loss_fn, optimizer_cnn1)\n",
    "sbs_cnn1.set_loaders(train_loader, val_loader)\n",
    "sbs_cnn1.train(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing Filters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig_filters = sbs_cnn1.visualize_filters('conv1', cmap='gray')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Capturing Outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "featurizer_layers = ['conv1', 'relu1', 'maxp1', 'flatten']\n",
    "classifier_layers = ['fc1', 'relu2', 'fc2']\n",
    "\n",
    "sbs_cnn1.attach_hooks(layers_to_hook=featurizer_layers + classifier_layers)\n",
    "\n",
    "images_batch, labels_batch = next(iter(val_loader))\n",
    "logits = sbs_cnn1.predict(images_batch)\n",
    "predicted = np.argmax(logits, 1)\n",
    "\n",
    "sbs_cnn1.remove_hooks()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing Feature Maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x600 with 40 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x450 with 30 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with plt.style.context('seaborn-white'):\n",
    "    fig_maps1 = sbs_cnn1.visualize_outputs(featurizer_layers)\n",
    "    fig_maps2 = sbs_cnn1.visualize_outputs(classifier_layers, y=labels_batch, yhat=predicted)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[59, 67],\n",
       "        [55, 62],\n",
       "        [71, 71]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "StepByStep.loader_apply(sbs_cnn1.val_loader, sbs_cnn1.correct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}