exercises/1_5_CNN_Layers/4_1. Classify FashionMNIST, exercise.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CNN for Classification\n",
    "---\n",
    "In this notebook, we define **and train** an CNN to classify images from the [Fashion-MNIST database](https://github.com/zalandoresearch/fashion-mnist)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load the [data](http://pytorch.org/docs/master/torchvision/datasets.html)\n",
    "\n",
    "In this cell, we load in both **training and test** datasets from the FashionMNIST class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data, number of images:  60000\n",
      "Test data, number of images:  10000\n"
     ]
    }
   ],
   "source": [
    "# our basic libraries\n",
    "import torch\n",
    "import torchvision\n",
    "\n",
    "# data loading and transforming\n",
    "from torchvision.datasets import FashionMNIST\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import transforms\n",
    "\n",
    "from collections import OrderedDict\n",
    "\n",
    "# The output of torchvision datasets are PILImage images of range [0, 1]. \n",
    "# We transform them to Tensors for input into a CNN\n",
    "\n",
    "## Define a transform to read the data in as a tensor\n",
    "data_transform = transforms.ToTensor()\n",
    "\n",
    "# choose the training and test datasets\n",
    "train_data = FashionMNIST(root='./data', train=True,\n",
    "                                   download=True, transform=data_transform)\n",
    "\n",
    "test_data = FashionMNIST(root='./data', train=False,\n",
    "                                  download=True, transform=data_transform)\n",
    "\n",
    "\n",
    "# Print out some stats about the training and test data\n",
    "print('Train data, number of images: ', len(train_data))\n",
    "print('Test data, number of images: ', len(test_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prepare data loaders, set the batch_size\n",
    "## you can try changing the batch_size to be larger or smaller\n",
    "## when you get to training your network, see how batch_size affects the loss\n",
    "batch_size = 10\n",
    "\n",
    "train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=True)\n",
    "\n",
    "# specify the image classes\n",
    "classes = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', \n",
    "           'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize some training data\n",
    "\n",
    "This cell iterates over the training dataset, loading a random batch of image/label data, using `dataiter.next()`. It then plots the batch of images and labels in a `2 x batch_size/2` grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABPoAAAD7CAYAAADzafoaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzs3XmYXVWV///PNmSeKgmZKvNEAgSCSYyoBARDo9AgiAOIiK3whbZbGWzagW61nVAfG1BUoFsUFUFaEX5tCzRiOzAYIJAQIIQhJCFzZa7MTPv3x73ZrL1S96SqUlNu3q/n4XnWybr33FPRu7LPqbPWCTFGAQAAAAAAANi/vam9DwAAAAAAAADAvuNCHwAAAAAAAFAFuNAHAAAAAAAAVAEu9AEAAAAAAABVgAt9AAAAAAAAQBXgQh8AAAAAAABQBfbLC30hhBhCGN/U3F72+bEQwgP7fnQADkQhhNHl+nNQeftPIYTz2/u4AFSvEMIDIYSPVciNDSFsbeNDAnAAoQYB6Ag4D9tTu17oK/8PsDGE0LU9j6M1hRDeGUJY3t7HAaDxQghLQgg7QghbQwhrQgg3hRB6tfdxAdj/levK7v9eN7VmawjhnJb6nBjjizHGwrpV6SQ9hDAzhPCXEMJB5YXz6JY6LgDtixoEoCPjPKxltNuFvnLBnikpSjqtvY4DACo4tbxAnSppuqR/aefj2asQQqf2PgYAxWKMvXb/J+kllWtN+b9ftMUxhBDeFEIoWgOeIumutjgWAG2LGgRgP8B52D5qzzv6PipptqSbJJ1nE+Wrtj8IIfwuhLAlhPBwCGFcQzsJIRwTQlgWQnhnA7muIYTvhBBeKl8Nvj6E0L3gmEII4fshhM0hhIUhhHeZRG0I4b9DCBtCCC+EEC5wn3NNCGFl+b9ryn/WU9LdkmrNb8pqm/KXBKB9xRhXqPQ9nlz+DdOs3bkQwpdDCDfvbR/lBe2/hBCWhhDqQgg/CyH0LefuDiH8o3v9EyGE95XjSSGE35drz7MhhA+a190UQrguhHBXCGGbpONb6McG0EGEEHqEEG4JIawPIWwKITwSQjjYvGRMCOGh8nrpnhBC//L7xocQotnPAyGEr4YQ/ippm6RbJb1N0vXl9ck1Zp8nq3SS/Zfy9tPl15xZ3tdF5bXQ+hDCnSGEoeU/3333zadCCItDCOtCCN/cywk9gA6MGgSgvXAe1nztfaHvF+X/TgohDHb5syT9m6R+kl6Q9HW/gxDCu1X6R+LMGOOfGviMb0o6RNJRksZLGibpiwXH9FZJiyQdLOlLkn6z+x8rSb+UtFxSraT3S/pGCOGEcu4KSUeXP2eKpBmS/iXGuE3SeyStNL8pW1nw+QA6mBDCCJUWnHP3YTcfK/93vKSxknpJ+n45d6uks83nHSZplKTflX9Z8HtJt0gapFJd/GH5Nbt9WKX62FsSc0aB6vN3knpIGi5pgKRPStpp8h9W6RemgyX1lHRZwb7OlfRxSX0knSPpr5IuKq9PLpFSzauJMc6XdGz5fYeXX3N7COFvJH1FpbXQMEkrVVrLWe9V6bfw08qv+2gzfm4AHQM1CEC74Dys+drlQl8I4RiV/gL/K8b4mEoX1z7sXnZHjPGRGOOrKhXvo1z+A5JukPSeGOMjDXxGkPT/JF0aY9wQY9wi6Rsq/Q9USZ2ka2KMr8QYb5P0rKRTyv8He4ekz8YYd8YY50n6kd74R+McSV+JMdbFGNeqdIHy3Mb9bQDooO4MIWxSqWj/WaX60VznSLqqPK9mq6TPSzorlAbG3iHpqBDCKPPa38QYd0n6W0lLYow/iTG+GmOcK+l2lerfbv9fjPHBGOPrMUa78AZQHV5R6ReQ42OMr8UY55TryG43xhifjzFul/Qr7blesn4cY3ymvM55tcJrTlbpt+eVnCPpRzHGeeWa8zlJx4UQhpvXfDPGuDHGuFTS92QW0QD2O9QgAG2N87B91F539J0n6d4Y47ry9i1y7buSVpt4u0pXXq1LVLpQ+FSFzxio0m+fHivfZr5J0j3lP69kRYwxmu2lKt3BVytp98VCmxtWjmvL2/59APZfp8cYa2KMo2KMn4wx7tiHfTVUIw6SNLhcV36nN34Jcbbe+M30KElv3V3DynXsHElDzL6W7cNxAehAQgidQj4ov1alESf3SfqvEMKKchvaQeZte1svWY2pF7tb5irJ6lmMsV7SRr2xJvKfw5oI2E9QgwB0EJyH7aOD9v6SlhVKM/I+KKlTCGH3PwxdJdWEEKbEGJ9o5K4+IOnGEMLyGON3G8ivk7RDpVu9VzRyn8NCCMFc7Bsp6b9VuiW8fwiht7nYN1LS7v2uVOn/CE+b3O4WXXvhEMD+bZtKv0DYbUilFzq7a8RuIyW9KmlNeftWSV8KIfxFUjdJfyz/+TJJf44xnliwb2oMUCVijK+p4ZPkL0v6cghhjEq/tHxG0k+b8xFF2yGELpKO0RtdFg3Vl6yehRB6qzRmxa61RqjUFSHlayIAHRg1CEAHxnlYE7THHX2nS3pN0mEq3dp9lKRDJd2vps1PWCnpXZIuDiH8vU/GGF+X9J+Srg4hDJKkEMKwEMJJBfscJOnTIYTOIYQPlI/rrhjjMkkPSboyhNAthHCkpE9I2j388VZJ/xJCGFgeTvtFk1sjacDugY8A9mvzVLrVu3MIYbpKc18a41ZJl4YQxoTS4+G/Iek207Zyl0r/AH2l/Oevl//8fyQdEkI4t/yZnUMIbwkhHNpyPxKAjiyEcEIIYXJ5mHy9Sm10r+/lbY21RqV5NbsdJ+mx8ozh3Sf9691rbpX0iRDCkSGErpKulHR/jHG5ec0/hxBqQggjJX1a0m0tdLwA2hg1CEAHwXlYE7THhb7zJP0kxvhSjHH17v9UGoh4jrsVvFCM8SWVLvZ9LoRwfgMv+axKD/KYHUKoV+m284kFu3xY0gSV7gb8uqT3xxjXl3NnSxqt0gXGOyR9KcZ4Xzn3NUlzJM2X9KSkx8t/phjjQpX+z/Vi+ZZPbh0H9l//KmmcSi0i/6bS2IHG+LGkn6v09LjFKg2x/tTuZHkOxG8kzbL7LN9B/Dcq3U6+UqX2mG+pdBc0gANDrUr1oV6lzoH71PjaszfXSDq7vD65StIp2rNl7kuSbim/5n0xxntUWgzfIWmVSr8ZP8e957cqLcjnll93UwsdL4C2Rw0C0BFwHtYEIR9JBwAAgANRCOE5SX8bY3yume8/SKW7fcbEGJe05LEBqH7UIABoGe31MA4AAAB0ECGEbio9PbNZJ9gAsC+oQQDQcrijDwAAAPuMu2kAtCdqEACUcKEPAAAAAAAAqAK07gIAAAAAAABVgAt9AAAAAAAAQBU4qCkvDiHQ59txrIsxDmzvgwDaCvWnQ6H+4ICzv9SgqVOnZtuvvPJKxdd26tQp2966dWuKX3jhhZY9sJZFDcIBp6VqUAghxX6EU69evVLco0ePLFdXV9fgPhraT2soOu5BgwaleNu2bVnOb7eEGGPY+6uA6tGR10BvetMb9671798/y9XX16e4c+fOWa5r167Z9oYNG1rh6FpFo9ZATbrQhw5laXsfAIADFvUHaAX2RNYuXCXp9ddfT3HRSfVDDz2Uba9duzbFr732Wpbr27dvxfeecsopjTjiPY/VH1srXQCgBgHNdNBBb5z++V8ETJs2LcVHHnlklrv22mtT3KVLlyy3a9euljzEBtnP9J931llnpfjhhx/Ocnbb/uyS9Oqrr7bkIQJoB926dUvx6aefnuXuu+++FA8ZMiTLjR8/Ptu++eabW+HoWkWj1kC07gIAAAAAAABVgAt9AAAAAAAAQBWgdRfAAauoNe6www7Lcp/+9KdT7OfWjBo1KsUTJkzIclu2bKn4vu7du2fbTz/9dIp9i52dmzNjxgxVUvQzAehYitrIfA0oMmfOnIo52+7m59H4zzj55JNTbNtdJOn8889P8ZIlS7JcUZ2xM3GK5gUCaBtF39cFCxak+Pjjj6/4uvZoeS2qiQcffHCKly6t3NXGmgjouIYNG5bigQPzEXSTJ09OsV+DPPDAAynu169flvvhD3+Y4htvvDHLjR49uuKxvPvd78627Tnb3Llzs5w/no6CO/oAAAAAAACAKsCFPgAAAAAAAKAKhKY8Da0jP1b5APRYjHF6ex8E0FaaW3/sUyy9ovr3xBNPZNv+6XOV+CfBFT0p8+WXX862bRufbdWVpCeffDLFJ510UpZbtWpVituodZf6gwNOW6+Bjj322Gz7oosuSvHZZ5+d5bZu3Zri+vr6LGdrwN7qg93u379/lrM16e67785yX/nKV1I8e/ZstQFqEA44LVWD7LqoaB30n//5n9n2BRdcsM/7bIqieuXXdtdff32KL7zwwhb5/CIxxsqLS6AKtcYayI8HsKOQVq5cmeXWr1+fYj/6aNOmTSl+6qmnstzYsWMr7nPnzp3Z9lFHHZVi+yRfKV9njRkzJsvZWrVixYosVzRaZR80ag3EHX0AAAAAAABAFeBCHwAAAAAAAFAFuNAHAAAAAAAAVIGD9v6SjqNo1pblZ0N06tSp4muL5lcVzYbwuSL2ta+88krF1/mZO3b7tNNOa/TnAQc6+51r7qyY73znO9m2nevw5je/OcvZ7+fgwYOzXI8ePSp+hp//0LVr1xTfdtttWc7OwHrHO96R5X7961+nuJVm8gFoBXbuniT90z/9U4p9LbHq6uqybTvvs0uXLlnO1gRfH/z6yM4JtTNv/PbMmTOz3O9///sUr1mzJstdfvnlKb7jjjsEoH3ZdVHnzp2znD1P8WuUt7/97Sl+6KGHspytJa+99lqWs+dve1uj2NcWnfcdd9xx2batXZ79GYvOwwC0Pru26dOnT5aza4mBAwdmuVdffTXFdl6fJNXU1KR42rRpWa53794pHjlyZJbbsWNHtr1x48YU+/l9tnY988wzWc7WysMPPzzLLVy4MMV2zl9b4I4+AAAAAAAAoApwoQ8AAAAAAACoAvtV625zW/D8LeQt8b6m7LO5n79u3bpmvQ840NlaUVQ37K3ekjRr1qwUT5gwIcsNGzYsxf7R6V/4whdS7FtdbHvJ0KFDs5y/Zdy2wjz88MNZbvr0N56ifsQRR2S54cOHp/i+++7Lcv4x8wDa16BBg1L8ta99LcvZ1pQNGzZkOTuSwLfb2XZd3xpXNHbE10f7+UUtfb6t1+7HtslI0o9//OMUz5kzJ8stW7ZMANpPUSvrc889l23btYdv3bW1w2tsO66U15Ki8yc/QuX555+v+FradYGO47DDDktxfX19lhs3blzFnB1v1LNnzyy3efPmFNtRJpK0ZcuWFHfv3j3Lbdu2reJx+jEoRew6y48vsedoto23LXBHHwAAAAAAAFAFuNAHAAAAAAAAVAEu9AEAAAAAAABVYL+a0ddYfv6DnfcwderULPf+978/27YzHn72s59luV69ejUYS/lMmh49emS5Xbt2pfi0007LcvZ4lixZkuWuuuoqAWi6Tp06pdjPjbGPVr/sssuy3NKlS1PsZ9vZGS9+BpV9lLqdEyFJ//d//5figw7KS+727duzbVs7Tj755CxnZ9X4WTR25teFF16Y5b7+9a+nePXq1VnO1srmzkAF0DQf/ehHU2xnzkj5TBo/S8Z+R/0cPpvzayC77d/n2Rl+fq6Vrau+XtjP2Lp1a5YbMmRIin3NvfTSSwuPB0D7sfOyJOnMM89MsZ/T+atf/SrFRXNC98VZZ52V4o9//ONZzs81BtAx2bWEZ9dEfk5xnz59UuzPtYo0pf7YOev+fX5NZtnzO78GYkYfAAAAAAAAgH3ChT4AAAAAAACgClRl665tPZHyljd7+6SUt9VK0owZM1Js202k/HHNPldTU1PxeMaMGZPi5cuXZzl7C+ewYcOynL9lFUDj+HZd69RTT03xCy+8kOUWL16cYt+ea23cuDHb3rFjR4p9e66vFZYfAfDMM8+k+IEHHshy9pZ1Px7AttH5n/24445L8W233VbxfQDaxpQpUyrmOnfunGLfgmu/2771xb+2Jfi1VFG9sDn7M0j5cU+bNq2Fjg5Aaxs8eHC23a9fvxR/5zvfyXK33HJLin0b7R133JHi+fPnZ7mjjjoq2z7jjDNS/Na3vjXLLVu2LMW+rc6OMAHQcdh2WEnq27dvirdt25bl7Hph4MCBWc6OO/KjRWw98J9nr9/4ll9/zmb3Y8+7/Gf6NZdtOfa1yf8cbYk7+gAAAAAAAIAqwIU+AAAAAAAAoApwoQ8AAAAAAACoAlU5o6+I77e2/d5SPmfG942vWbOm4vvszCw/98/2dPsZEvbx9DNnzsxytqccQMtYsGBBiv3MKbu9fv36LGe/x342hP3O25mgnp955ec2PPjggymePn16lrvssstSfP3112e5urq6FNufT5L69+9f8XgAtL0jjzwyxX6mpp3zUjQjr73na/oZNF26dElx0WxBP4sYQNuz39GiWuLnCNu1jj/X2bJlS4r9bOJLLrkkxbW1tVlu1apV2fbOnTtT/Oyzz1b8/J49e2Y5vw2gY/Azz+3axq+BunfvnmI/D93WBn+NxK5J/PUbu0+7VvHvk/JrPfbz/Hv9Mx/sz1Q0P9DOOZX2/BlbGnf0AQAAAAAAAFWAC30AAAAAAABAFajK1l3f7mJb6Xxbnb3VXMpvL/W3hXbu3LnBWMpvCy3ib3Wvr69Psb99dN26dY3aJ4DKzjrrrGz729/+dopvvPHGLHf33XeneMWKFVnu4IMPTvGIESOynB0J0KlTp4rHsmPHjmzb39591FFHpdjfFm7r0fz587OcHQnwiU98IsvNmjUrxcccc0yW8+3JAFqfbd1dvXp1ljvooDeWZbaNV9qzXlit0crrW3Dttl9L2TWRX8vY2uXrGoCOy39fi1p+bW7r1q1ZzrbA2fMeac/WPXsO58/nbE3052GjR4/e4/gBtD/fVm+vb/hzJtva6utIt27dUuzXJ3bt5GuTbY+1+2jo2IpGANias3bt2ixnrx/52mTPteyoN39srYE7+gAAAAAAAIAqwIU+AAAAAAAAoApwoQ8AAAAAAACoAlU5o6+I7wX3M3DsHAn/CGbb/93cz9y+fXuWGzBgQIqL5u8AaJ5DDz00266trU3xZz7zmSz32c9+NsV+/oOf69DaVq5cmW3buTY/+clPspyd+VVTU5Pl7HEfffTRWe53v/vdPh8ngObz8+yKZnz617Y2P+fGbvtjsTlfK+26x6+rALS9xs703LRpU7ZtZxX7GmDPp/zc8qL1k5+H7tdelp1z7uf3MXMY6JjstQ4pn/Fra4oknXTSSSn2M4x/+9vfpnjs2LFZbvHixSn212tsPfJz//y84b59+6Z43LhxWe7+++9P8c9//vMs97//+78pvueee7KcrX92ll9b4I4+AAAAAAAAoApwoQ8AAAAAAACoAlXZulvUAjtixIhs2z/m2L7Xt9DY7aJby/3t7PYxy/a2c//abdu2VdwngObx33n7KHPfMmJvqfa3d9vv/Kuvvprl7K3fRa14vm74bVsr/CPebUvupEmTspx9VL2NJemZZ55J8aJFiwSgbfkWE6toveAVrTtsDfItbS3Ft7hYts751/l6aQ0bNizFK1as2IejA9BYtpYUtfH6Fjj7Wv++orEDlq8PResiv8+iGlRUOwG0H38+Yx1++OHZ9osvvpjip556KssNHTo0xWvXrs1ydrzRoEGDspw97/Ots369tGHDhgY/T8rbem+55ZYsN2vWrBTPnTs3y9nrO7169VJb4o4+AAAAAAAAoApwoQ8AAAAAAACoAlzoAwAAAAAAAKrAfjWjr7EzJYr0798/27Zzr6S8N3v79u1Zzs6q8D3dRTO6bM7Pu7CfUdTDDqB5pkyZkm0XzX+xcxT8rM+uXbum2M+Csd9rX5tsrfA5XyvsZ/p5nva4V61aleXs4+ntLApJuvTSS1N84oknZrmFCxcKQOsaN25ctu2/o5atSTt37sxyRTP6WkPR7KyiOYB+nWP5n33y5MkpZkYf0LGMHj0627Zzsfz33K6LiuYPN2VGn/8Mu2bysz9Hjhy5x/E3xH9ec88nAew7P8PYzre77bbbstynPvWpFC9evDjL1dbWptjPKrd1xNcNX2PsuZ5fk9jP+OUvf5nlhg8fnuIjjjgiy9mfqeg5Eq2BO/oAAAAAAACAKsCFPgAAAAAAAKAKdOjWXd8eZ2/Z9rd+29f62yJtK8zMmTOz3L333ptt29vU/W2h9nZv/xn2ccm+pcXeJmpvCfXGjBlTcZ9bt26t+D4AlQ0bNizbfvnll1Psv6tdunRJsf+O25rj32dbP3wbiK9Vlm8hKWqHs8dW1GpiH/8uSd/4xjdS7G9nB9D6hgwZkm0Xjfqw7bqLFi3KcrYF2Lf12nVOS7WiFbXf2ToqSY8//niK/bgEuwbyx+bbdgC0vqJRSPbcw8ZSPjakaISRH4tStLbxNdDWGb+fovMwO5rJn2vZUSi07gJtq1+/ftl2fX19iv36yK8fLLuW8GuggQMHNvg6z7fq7tixI9vu3r17ijdt2pTlevTokWI76kmSrrvuuhR/61vfynJLlixJ8fr167OcrY2+FrYE7ugDAAAAAAAAqgAX+gAAAAAAAIAqwIU+AAAAAAAAoAp06Bl9fv6Cn6tgFfU1n3766Sm2M24k6a677sq2r7jiihTbmVhSPivCz38YNGhQin3fuO2/tr3ffj9+Dt/RRx+d4vvuu08Amm7AgAHZtp0x47/jRbOk7PfY54pmvBTVraYomnFjZ9r07t07y1177bUptnMiALSNM888M9u2s6T82sV+f5syh6+l6ozl59zY9Yr//G7duqW4T58+Wc7OxPG50047LcV2xg2A9jF8+PAUr127NsvZeuXn51l+xrpdv+ytVtn9+nVP0Tyrurq6FA8dOjTL2bVPa9RKADn7776dbSflNcbPFb/hhhsq7nPLli0prqmpyXIbN25MsZ3XJ+UzAT1fq+y6x88PtDVn+/btWc7WGD9ncPbs2SlevXp1lrN/N63xPAbu6AMAAAAAAACqABf6AAAAAAAAgCrQoVt3PXsbqL9l2z7WfcSIEVnu+uuvT/Hll1+e5YYNG5Zt29smix6rbFtv/Gv9++zj6X3bysyZM1PsH9Xsb2cF0HT+Ueq2dvgWDtuO1hbtuE3Zj61xnv2ZfKuLHRfgW5UBtD7bPu9NnTo1237ppZdSfPvtt2e5Y445JsWt0eKxN7t27UqxXwPdeeedKfZrMJt79NFHs9zjjz/ekocIoBGK1jfHH398iv2aoeh9du3h111W0bpLylt3fVvdyy+/XPF99ljf+c53Zrmbbrqp4vsAtDxbD/y4s8GDB6fYjzS7++67K+7Tjjbp2bNnltu8eXOK/eg3W0f897+oVtl2YL+fIhMnTqz4Gf7vwl7roXUXAAAAAAAAQIO40AcAAAAAAABUAS70AQAAAAAAAFWgxWb0+ces+xl6lp8hVYmfSWV7rv2Mh0mTJqX43//937Pcd7/73RQvXbo0y/lHJ9sZNIcddliWW7lyZYrt45elfG7E4YcfnuVsP7bvRR8wYECD+5f2nOcHoHHsXEzPfnd9nbK1yc9x2LFjR8V9+vpXid+n37bH42dM+MfTW7b+eHbmQ9E+ALSOP/zhD4XbjXX11Vc36nVFsz+bMp/K1zW7JvM19uKLL24wBtDxFNWBt7/97RVfZ9dPRTN//Swru7bx666idVDR+aJf99j92HmmEjP6gLY2cODAFPtrH6NHj06xPy/Zvn17g/uQ8mcZ+OcaFD3HwdYtv67xM/rsOZO9RuP3W3Tc69aty3LDhw9P8cKFC7OcnTvYGrijDwAAAAAAAKgCXOgDAAAAAAAAqgAX+gAAAAAAAIAq0OQZfXb2i51z4OfpFWnKay07E+bUU0/Nct26dUvx8uXLs9zs2bNTPH369Cy3adOmiq89/vjjs1zfvn1TPHjw4CxXU1NT8fPtzzthwoQst2DBghT7mVx+RiCAximab1k0K8bOcbCzNSVp6NChLXR0zWNrla9bduaEr692bsTOnTtb6egAVOJn5jV2RpSfD2P52tXYOaFN4WtJ0ezlQYMGpbiuri7L+Rk4lp3BVTRrFEDbmDlzZor9eYmtM02ZdVfp3HFv27522m1fV+z67R3veEfFY2FGH9D67DmUn+nbr1+/FK9fv77iPiZOnJht27WFP5+x5332vEfK5+kVrWP8sfr92PVKbW1tlnvhhRdSvHnz5ixnZxIWzYZvDdzRBwAAAAAAAFQBLvQBAAAAAAAAVaDJrbuVbnk+5JBDsu2VK1emeNeuXVnOtqP4Fjt7S+O4ceOy3NixY1O8atWqLGdb2err67OcvUXUPjZZ2vPWy40bN6Z47ty5Wc4+5tm+zvOPg7a3gfpje+mll1Ls23T69+9f8TMAVGYfZe7ZGubbc+3j2v0+Pvaxj6X4sccey3K2rvgaY8cK+FYT325nRwD4evAf//EfKfaPqrctb/428IsvvjjFhx9+eJabNWtWiteuXSsALa+oVayo/czXIF9brKLWuObyx2bXcv5YhgwZkmLfumvZnw9AxzNq1KgU+1FERSMCfJttYxW9z69n7Gs7d+6c5Wx9mjRpUrOOBUDL6N27d4qLxnLYttq9se26fpySvQ7k64atWz7nW2m7dOnS4OdJ+ZpoxIgRWa6oddfWKr+usqPg7Di3lsIdfQAAAAAAAEAV4EIfAAAAAAAAUAW40AcAAAAAAABUgSbN6OvRo4cmT56ctu0j2H2P88iRI1O8Zs2aLGfn8vleaTvbz8+MWrhwYYqXLl2a5WzPsz0uf2zPP/98lvOPfD700ENT7Od32flZPmdnQ9g+cSmfEehnC9redD/L0B6b7RmXivvdgQPdmDFjGvU6X7eKZlv99Kc/3adj2ld2Lp+fTWPrgZ93M2/evBQ/+uijFd8HoO35GmQddthh2bZdB7TUHL4i/jPstl+7HXnkkSmeP39+4X4AdBx+du+6detS/Morr2Q5O+vKf69tzs/ye+211yq+r6g++PWM3a/P2fmf/vxx/PjxKbaztAC0Dnue4tc59nu8YsWKivuw10+k/DqJ36e9nrJly5YsZ2uMnxPsZ+bZWuWfI2F39ZSeAAAgAElEQVRn7/nzMOu5557Ltu3MdTu7UCp+5kNL4I4+AAAAAAAAoApwoQ8AAAAAAACoAk1q3R08eLAuvvjitG1vP7zhhhuy1/7+979P8cSJE7OcbT/p27dvlrP7POSQQ7LckCFDUty/f/+K7/O3bJ9yyikptu2/krR9+/Zs297SaVvlpPwW9uHDh2c5ezupb1UePXp0ip999tksZ28Zra+vz3L25+3Zs2eWo+UOqMzXB8u3nFm+Rb5Szn//amtrU+wfx25rim818exrt23bVvHzfZu/vdXcO/HEE1P8zDPPZLmivwsAra+odfftb397xdf6WrK32rKb/877trmi47Hv9a+bMWNGim+++eZG7xNA+3rb296WbXfr1i3FtlVNyuuMrx22Pvg6U7RGKWrd9fux20Wtu/ZnkKSjjz46xbTuAq3PXt/w7an22o+/LlJpH56vDfa1fnSAbbPdW+uuza9fv77ifmyrsLd69eps214z8n8Xvla1NM7yAAAAAAAAgCrAhT4AAAAAAACgCnChDwAAAAAAAKgCTZrRt337dj3xxBNpe9q0aSn+zGc+k73Wzsm7//77s9yOHTtS7Puf7Xy7wYMHZzk7687nbK+0nwVh59udccYZWW758uXZtu3N9o9V7tWrV4q7du2a5ezP4XOLFi1KsZ8faOcA+jk248aNS/H3v//9LHfOOecIQMP8TEvLzmPwtcLO+vSPR7dz+fz8TjtPz8+b8fMgLP/aose1P/TQQyk+9thjs1zR49m//e1vp3jSpEmNfh+A9uXnFNta0tz5mr7mFM3H8uxMLF/X7AysvX0mgI7DzjGX8nMR/z0vWqO0hqJZpL4G2vnI/nzq5JNPTrGfIQqg5dlrKCtWrMhydi6dz1k1NTXZdl1dXYr9d7xotqg9f/PPhvDz0G2Nsc9KkPacj27Zc8vbbrsty02fPj3F9lpSQ8fa0rijDwAAAAAAAKgCXOgDAAAAAAAAqkCTWnd37dql559/Pm3PmjUrxf527jFjxjQYS3nr7tatW7Pc9u3bU1xfX5/l7Gf42zntrZb+1krbZueP0z/W2Lb82dZZSXrllVca/Bmk/BZVfzu5bSueOHFixZz/ebt06ZLiww47TAAap3///hVz9hZu/3h0e0v1eeedV3Ef9ru5N771pChX1OL2iU98IsWrVq3KckW3k59++ukp9reM29vJ58yZU3EfAFqOXSP49hNrxowZ2XbR97wt2mM7deqUYtsmJ+05zqASvz4q+vkBtL4pU6Zk23aN1JQRAfa1fm1TtJ+mrJHsfnzNs+sye74m7fkzAmg7/tzDrhf8eLcidtyS36cdM+DXFQMHDkzxli1bspyvMXb8mm+rteeMtlXXf8bixYuzXNGaz173ag3c0QcAAAAAAABUAS70AQAAAAAAAFWAC30AAAAAAABAFWjSjL5NmzbpjjvuSNt2DtaHPvSh7LV2Zp3vY7bbvXv3znK2d9n3MRfN2rOv9bMg7OfZGTOSNHjw4Gzb7tfvx+ZsD7dU3LdtZ0X4GTu2/9vn7PyJP/7xjwLQOHZ2g53pIOXzZwYNGpTlfvKTn6R49uzZWc7WOzsLQsq/835uTNFsBv9aPzvCWr16dYo///nPZ7mvfvWrKfazaZ544okU33vvvVnOz9kC0PrsOsTXBLt28t9lW8v8XJmiOVfN5ddA/nisAQMGVDwWW+eY0Qd0LH6O+sqVK1Psz5mK1jNF50/NncPnc/Z4ij7Dr22Ycw60LVsPNm7cmOXs8xBsvZGkvn37Vtynzfm5wPYaiq9bth7s7bzHnt/56zn22o+/ZlNbW5vixx57LMsVrXP8syJaGnf0AQAAAAAAAFWAC30AAAAAAABAFWhS66534403pvimm27KcoceemiK/+Ef/iHLTZw4McW+dda2rQwZMiTLrV27NsX2McaStGPHjhT72zJtG5+/1XP58uXZtr0V0x/bggULUmxv0fTb/jZUy/9M69evT7Ft/5WkrVu3pvhzn/tcxX0CyNnvuW3VlfLvWX19fZY79thjK+5zw4YNLXR0lY0cOTLFP/jBD7LcqaeemuJzzjkny9kWlk2bNmW5K6+8MsXnnntulvPbAFqfbSvx7bCnn356in0LS11dXYp9u4cfUdBYRS11TRlDYOvq8OHDs9yyZcsa9XkA2oY/37Dsmsm3x9qa4OtDU9pzK+1zb4r2Y4/Vr/usLl26ZNtFrwXQPLbGFI0t89+/KVOmpNjXBjtuye/TXgcaNmxYo4/Tt+fa+lB0/uivNdl1j2/dtWOZ/LqutUcocUcfAAAAAAAAUAW40AcAAAAAAABUAS70AQAAAAAAAFVgn2b02Ucn+zkzTz31VIr//u//vtH7HDVqVIr9I9/t45kPOeSQLGdn+z399NNZbvz48Q0esyT98Y9/zLZtr3RNTU2WW7RoUcXP79evX4pffPFFVeLnYtgZfUX95k2ZYQEc6CZNmpRiP5fTzuz0c63GjRuXYj+vb926dSn2M17sXDw7W9O/1j/y3c6pkPI6MmfOnCx3xhlnpNjXphdeeCHFfn6orSPHHHNMlrO1ccmSJQLQ+vx6yZowYUKj9vHqq69m23Y+VUutF/w8rKIZfbbOjR07NsvZGX1+5heAtjdjxowU+zlUtn7476utCb4+FNUdWy/8TKwivs4U1bmiY7PnV1OnTs1ys2fPbvTxAGicrl27pnjAgAFZzs6s27ZtW5b7y1/+0mC8P7P1xz+rwV4vaw2suAAAAAAAAIAqwIU+AAAAAAAAoArsU+tuUftJcy1durTB2HviiScavc/m3pa9evXqijnfHgyg43jyySdT3L9//yxnW962b9+e5ebOnZviyy67LMvZ8QBr1qzJcradxLeMWL4NxbMtNH4/hx9+eIp//vOfZ7kRI0akeNasWVnOjiMYOHBglrPtyADahq0XfnzA6NGjU2zb7v1rffub349V1NLma5Jthytqm/Otw/Z9Q4cObdSxAGgfH/rQh1LsR5HYczs/bsR+733Nse/z9cm26vnxJnaNIuU1wq/RLF8f7Wgm39Zr2wjtzy7Rugu0BlsPevfuneW6deuWYl8PqpFdS/m61ZRRBs3BHX0AAAAAAABAFeBCHwAAAAAAAFAFuNAHAAAAAAAAVIHWbQwGgHbwwx/+MMV2FoQkbdq0KcULFizIclOmTEnxmDFjspydyzdo0KAsZ2fKLFu2LMvZuVbDhg3Lcn6OTKV9Svkj6CdPnpzl7Mw+Pwtj8eLFKR4+fHiWmzdvXsXPB9Ay/HfZz7ezRo4cmeK+fftW3I+dGdpW7LwsO09UyuuOnxP6y1/+MsW2HgJoH0VzoWpqalLs1zp27pafn2fn+e3atSvL2XrhZwL6NZr9fBt7vXr1yrbtz1RXV1fxfXZeH4DWYf+t79evX5YbMmRIiv33f/PmzQ3uQ9r7nPPGHEtTNPfzPFtHe/bsmeUmTJiQ4gceeKBFPs9ixQUAAAAAAABUAS70AQAAAAAAAFWA1l0AVce2xtXW1ma5oUOHpvjpp5/Ocp/61KdSPH369CxnW35tG62UPy59586dWc5vt7b3vOc92ba9Zd0/1h1A6ytq0fduvPHGFN9yyy1Zzraj2ZZ8SVq/fn3Fz7M16LXXXstyvv3Ntt+NGjUqyw0cODDFfkTA1KlTU3znnXeqEtv6B6B9XHDBBSm+8MILs9yHP/zhFPsaYFvQ+vfvn+Vsm60fLWBb93zbsF1bSfm6bNWqVVnOtgT7OmfHq7zwwgtZ7le/+lWKW6odD0Bl99xzT4oHDBiQ5V566aUU2++t11Lf1fb+zv/mN79J8e23357l1q1b16qfzR19AAAAAAAAQBXgQh8AAAAAAABQBbjQBwAAAAAAAFSB0JTZMSGEtZKWtt7hoAlGxRgH7v1lQHWg/nQo1B8ccKhBHQo1CAccalCHQf3BAYf606E0qgY16UIfAAAAAAAAgI6J1l0AAAAAAACgCnChDwAAAAAAAKgC+/2FvhDCAyGEj1XIjQ0hbG3jQwJQ5UIIMYQwvqm5vezzYyGEB/b96ABUM+oPgGoTQlgSQpjV3scBYP+3tzVNCOHuEMJ5bXlM7aFdLvSFELaa/14PIeww2+e01OfEGF+MMfbay7E0eKEwhDAzhPCXEMJB5YXz6JY6LgAdQwjhTyGEjSGEru19LK0lhPDOEMLy9j4OADnqD4COKIRwTAjhoRDC5hDChhDCgyGEt7T3cQGA1dxaFWN8T4zxpwX7rYpffrbLhb4YY6/d/0l6SdKp5s9+0RbHEEJ4Uwih6Oc/RdJdbXEsANpe+eL9TElR0mntejAADijUHwAdUQihj6T/kXStpP6Shkn6N0m72vO4GiuEcFB7HwOA1tdataqaash+0bobQugRQrglhLA+hLAphPBICOFg85Ix5au5W0II94QQ+pffNz6EEM1+HgghfDWE8FdJ2yTdKultkq4v3014jdnnySpd6PtLefvp8mvOLO/rohDCC+VjujOEMLT857vvAPxUCGFxCGFdCOGbe7moCKDtfVTSbEk3Scpu3w4h3BRC+EEI4XfluvJwCGFcQzsp/zZpWQjhnQ3kuoYQvhNCeCmEsCaEcH0IoXvBMYUQwvfLv5laGEJ4l0nUhhD+u/wbqxdCCBe4z7kmhLCy/N815T/rKeluSbXmrunapvwlAWgV1B8AHdEhkhRjvDXG+FqMcUeM8d4Y4/zdd7mU68rG8nnOe3a/MYTQN4RwYwhhVQhhRQjhayGETuXcuBDC/5XPm9aFEH4RQqhp6ABCCIeW9312ebs2hHB7CGFt+c8/bV775RDCr0MIN4cQ6iV9rDX/cgB0GBVr1e4XFNSqP4UQzi/HHwulOwGvDiGsl3SbpOslva28btnUxj9Xi9lfLj79naQekoZLGiDpk5J2mvyHVVooD5bUU9JlBfs6V9LHJfWRdI6kv0q6qHw34SWSFEIYIamm/H+UY8vvO7z8mttDCH8j6SuS3q/S1eOVkvydiO+VNFXStPLrPtqMnxtA6/moSt/bX0g6KYQw2OXPUuk3Q/0kvSDp634HIYR3q/QLgzNjjH9q4DO+qdI/REdJGq9SvfhiwTG9VdIiSQdL+pKk34TyLy4k/VLSckm1KtWUb4QQTijnrpB0dPlzpkiaIelfYozbJL1H0kpz1/TKgs8H0DaoPwA6ouckvRZC+GkI4T0hhH4u/1ZJz6pUJ74t6cYQQijnbpL0qkr15s2S/kbS+eVckHSlSjXkUEkjJH3Zf3gIYaqk/5X0qRjjraF0o8RvJT2hUg17l6RLQggnmbe9V9KvJdVoz/MxANVpX2qV91ZJL6p0Lekjki6S9NfyuqXBX0jsD/aXC32vqPQ/0vjyFds5MUb7kI0bY4zPxxi3S/qVSovNSn4cY3wmxvhKjPHVCq85WaXfQldyjqQfxRjnxRh3SvqcpONCCMPNa74ZY9wYY1wq6XuSzt7LzwigjYQQjpE0StJ/xRgfU+nk9sPuZXfEGB8p14lfaM+68gFJN0h6T4zxkQY+I0j6f5IujTFuiDFukfQNlU7gK6mTdE25Pt2m0j9Qp5R/+fAOSZ+NMe6MMc6T9CO98QuEcyR9JcZYF2Ncq9IFgnMb97cBoC1RfwB0VDHGeknHqDRW4D8lrS3fzbv7lxFLY4z/GWN8TdJPJQ2VNLicP1nSJTHGbTHGOklXq1xzYowvxBh/H2PcVa4TV0k6zn38TEn/LemjMcb/Kf/ZWyQNjDF+Jcb4cozxxfJx2Vr21xjjnTHG12OMO1r2bwRAR9TcWlVhdytjjNfGGF+tphrS4S70hRA6hfxhHbUq/YboPkn/Vb4V/Jsh759ebeLtkooewLGsEYexu223klpJS3dvlP+PtlGl3zQ19DlLy+8B0DGcJ+neGOO68vYtcu1z2ntduUSlE/WnKnzGQJXuRH4slEYObJJ0T/nPK1kRY4xme3ftqJW0+2Td5nbXnKwmiZoDdGTUHwAdVvmGiI/FGIdLmqzS93n3eKPV5nXby2EvlX550VnSKlNzbpA0SJJCCINDCL8sn8fVS7pZpZs4rIskPeTuUB6lUvv/JrPfLyg/YW/MuR2AKtPMWtWQqqwhHe5CX/mOvV7mv5Xl3+B8OcZ4qEpXbs9Q6TfIzfqIou0QQpfyZ9xX4fVSqVV3lHlPb5Xaa1aY14ww8cjyewC0s/KMqg+qdBfu6hDCakmXSpoSQpjShF19QNLpIYSLK+TXSdqhUtt/Tfm/vnt5Evgwd1v57tqxUlL/cq2xud01J6tJymtOQzUMQDug/gDYn8QYF6p0w8Xkvbx0mUpD8A82NadPjPHwcv4bKtWDI2KMfVRqj/NtdBdJGhlCuNrtd7HZZ02MsXeM8WR7mM376QBUiybUqgbfvpft/VKHu9DXkBDCCSGEyeU5DfUqtfK+3kK7XyNprNk+TtJj5dkyKt/uud695lZJnwghHBlC6KrSzIn7Y4zLzWv+OYRQE0IYKenTKg12BND+Tpf0mqTDVGqHO0qleTH3q2mzNFeqNCvm4hDC3/tkjPF1lW4lvzqEsPs32sPcXBlvkKRPhxA6hxA+UD6uu2KMyyQ9JOnKEEK3EMKRkj6h0m/EpVJN+pcQwsBQelDRF01ujaQBIYS+TfjZALQO6g+ADiuEMCmE8Jnd44jKrftnq/TwoIpijKsk3Svp30MIfUIIbwqlB3Dsbs/tLWmrpM0hhGGSLm9gN1skvVvSsSGEb5b/7BFJW0IInw0hdC93fk0OIbxln39YAPut5taqRlojaXj5BrD91n5xoU+l2zB/o9JFvqdVutvulhba9zWSzi7fDn6VpFO0Z9vulyTdUn7N+2KM96j0MI47JK1S6bfX/g7D30qaJ2lu+XU3tdDxAtg350n6SYzxpRjj6t3/Sfq+pHNCEx6rHmN8SaWT7c+F8tObnM+qNEh/drlV5T5JEwt2+bCkCSrdjfN1Se+PMa4v586WNFqlE/w7JH0pxrj7zuOvSZojab6kJyU9Xv6z3b/hulXSi+UaRksd0H6oPwA6si0qDaZ/OISwTaWT5qckfaYR7/2opC6SFqg00ujXKs3FkkqzO6dK2izpdyqd1+0hxrhJ0omS3hNC+Gr5hou/VemXIotVqk8/ksQvD4AD277Uqr35P5WuOa0OIazb24s7qpCPY0EI4TlJfxtjfK6Z7z9IpTsOx8QYl7TksQEAAAAAAACV7C939LWJEEI3lZ7g26yLfAAAAAAAAEB74Y6+FsYdfQAAAAAAAGgPXOgDAAAAAAAAqgCtuwAAAAAAAEAVaPTT3SQphNCut/+FEFLcr1+/LHfQQW/8KHV1dS3yGcOHD89y27dvT/H69evVztbFGAe290EAbaW96w8y1B8ccKhBHQo1CAccalDHEWMMe38VUD06cv3p1KlTivv06ZPldu7c2eDrpPy6jyRt2bKlFY6uVTRqDdSkC33trUuXLik+6aSTstyQIUNSfPXVVzf7M+wFw8svvzzLzZ07N8U/+clPmv0ZLWRpex8AgAMW9QdAe6IGAQBwgLAX5fzoOXtxb9asWVnuuefeeMZq3759s1znzp2z7T/84Q/N+vx20Kg1EK27AAAAAAAAQBXgQh8AAAAAAABQBdq9dfdNb8qvNX7gAx9I8WmnnZblbF+1nZcnSeecc06Kv/3tb2e5zZs3p/imm27Kcueee262PWjQoBTbWz0lqVu3bik+8cQTs9yiRYtSfN9992W5P//5zwIAAAAAAEDjFbXLnnDCCSm+6qqrspy99mPHwElSbW1ttv3MM8+keOXKlY3+/I6KO/oAAAAAAACAKsCFPgAAAAAAAKAKhKbchthSj1U+9thjU3zFFVdkOdsu+/LLL2e5+vr6FK9fvz7LDRs2LMXTpk3Lcr169UrxmjVrslzv3r2z7VWrVqX4d7/7XZYbNWpUiv1TW/x+KuUuu+yyLLdhw4aK79uLx2KM05v7ZmB/05Ef634Aov7ggEMN6lCoQTjgUIM6jhhj2PurgOrR3vVn+vQ3/sn3I9Ruv/32BmNJmjx5corXrVuX5ebNm5dt22s//om83//+91O8Y8eOxh52a2nUGog7+gAAAAAAAIAqwIU+AAAAAAAAoApwoQ8AAAAAAACoAu0yo+/GG29M8fLly7Pctm3bUty9e/eK+3j99dez7VdffTXFq1evznLdunVLcZ8+fbLcpk2bsu2DDjooxTU1NVmuU6dOFY9n165dKX7Tm/Lrp4MHD674vksuuaRibi+YT4MDSnvPhrDfa1837XYIodG54447LtueM2dOirdu3dr8g2191B8ccNq7BiFDDcIBhxrUcTCjDwea1qg/Xbt2zbZnzpyZ4vHjx2c5e13Iz8iz51cjRozIcpdeemmKN2/enOX++te/Ztv2upR/roN9doS9XuX38/jjj6sNMKMPAAAAAAAAOFBwoQ8AAAAAAACoAgft/SX77l3vele2bVvgtm/fnuXso4xtO66Ut+D6nL31c+LEiVnulVdeqfi+4cOHVzxue4um59tz7bF5GzZsSPG4ceOy3CGHHJLi5557ruI+ALStohZc37prX1s0DuGTn/xktu1r1fHHH5/iRx99NMv9z//8T6OOtSnjGABUn6La5Z177rnZtq0zGzdubJHPaK7Ro0en2I9dmT9/fot/HgAAaF22BfcjH/lIlrMj1Orq6rLca6+9lmJ/PeeUU05JsR2DJEn/9E//lOKxY8dmuWXLlmXbAwYMSPELL7yQ5ey1JnucknTWWWel2I5zk6Snn346xW2xdrK4ow8AAAAAAACoAlzoAwAAAAAAAKoAF/oAAAAAAACAKtAmM/pmzJiRba9duzbFffv2zXJbtmxJsZ975+f5WXa2n3/kse3j9rP1Xn/99Yqvtfv07/U91fZ9/rhtT7nv2542bVqKmdEHdFz2O+/riJ25YL/vUj4H9MILL8xyS5cuzbanTJmS4ssuuyzL2bkStob6zy+a9+BnQ1jM9gOqg58dY+cUT548Ocv94Ac/yLa/8IUvpPikk07Kci+99FKKO3XqlOVs/fA1sLH+7u/+Lts+8cQTU7xw4cIsx4w+AAD2P0cccUSKd+7cmeXstR6/lrHXbOy8PEn69a9/nWJ/Hcaeh/m5e+vWrcu27cy+3r17Zzl7DuWvNdnnMbzlLW/JcnZGX1ufa3FHHwAAAAAAAFAFuNAHAAAAAAAAVIE2ad0dNWpUtl1fX5/iYcOGZbnm3t5oW+l824hvs7P845ntbaJ+P/aWzZdffrniPnv06JFt2xZg25osSYcddljF/QDoOGwd8S3/Rb74xS+m2NY3SfqP//iPbNvWvJkzZ2Y5e1u419jjoT0XqH5F3/P+/ftn25s3b862BwwYkOKLLrooy9m2Xr92aizfbnPXXXel+IQTTshytv1lzpw5zfo8AADQcdh1yNatWyu+zp/b2OsrfpzboEGDUuzXJ/Y6zI4dO7Jcr169Gv35dr9+LWNf25HOtbijDwAAAAAAAKgCXOgDAAAAAAAAqgAX+gAAAAAAAIAq0Goz+vr165di38e8fv36FPs5VMuXL0+xneUn5X3Ur7zySpazPdddunTJcnbunp+tV9RjXTTbr+hn8p9/yCGHpHjp0qVZrqampuJnAGg/fsaCndFZ5Iwzzsi2jzvuuBTffPPNWe7cc8/NthcvXpziefPmZbnjjz8+xQ888ECW84+nr8TXtKLaCGD/VDQfZty4cdm2X8vYGrFmzZoWOR77Gb5W2bqzatWqLLdo0aIW+XwAANAxdO/ePcX+vGTMmDEpfvbZZ7OcXdv07Nkzy9nrQp06dcpydg7g3p7jYK8D2XMkqfj61bZt21LsZwTa88e2nt/HHX0AAAAAAABAFeBCHwAAAAAAAFAFWq1119566R9PbG+h3LVrV8X33X///VnOtu76NjP7yGX/eXbbt9XaRy5L+eOai9rcvMMOO6zisQ0cODDFzz33XJYbP358igcPHpzlWqptBsC+s/XA1xjrG9/4RrZt2/WPPvroLHfyySdn2wsWLKiYsy1vvjZce+21KX7wwQezXLdu3VL8wQ9+sOJx/+xnP6uYA9D+Gtv+4VtTrBNOOKHiPqW8/eS8887Lcueff36KhwwZkuVsq8xLL72U5Q4//PAUb9myJctt2LAhxX379q24TwBtz38H7dqnKS1ow4YNS/Fpp52W5d72trdl21dddVXFz3/++edT7Mc7Adg/FI0NOvjgg1Psx3fU1dWleMCAAVnO1oqiUUt+9JuvMUXnevY8bPLkyVnu97//fYr9taXevXunuK3rFnf0AQAAAAAAAFWAC30AAAAAAABAFeBCHwAAAAAAAFAFWm1Gn503Z2e+SHn/te139jn/eGLbR20fzSzlsyLsTCopnwPoe7P9HD677ef52WN7+umns9ysWbNS7Gf5rVq1qmLOzqsZPnx4lmNGH9Bx+HpkvfWtb03xkiVLsty0adNSvHbt2iw3f/78bPuRRx5JsZ9lNWHChBT36dMny11//fUpvummm7LcH/7whxTbORFSXtOK+HkXbf14eADF37vGzu+ztUracz6OrXN2vrDn11I7duxIsV/LbN68OcV2DrKU1zK7D6l41iCA1mFrSVO+g+9973tTPGPGjCz30EMPpXj9+vVZ7pZbbsm2R4wYkeJBgwZluZEjR6bYzyO2ayY/I8vOcbfzAv2x/vnPf85ydm4ygObx11Msuz6Q8mcePProo1nOzszzaxf7Gf7ajq1p/jqMf1aEvdbk64jdr68jGzduVCX2GRPM6AMAAAAAAADQZFzoAwAAAAAAAKpAq7XuHnvssSkeOnRolrOtG/4WyokTJ6Z469atWc625PrbyW0biX8csr0N0z9G2W937dq14mfYlhbfcmx/Dt+2smzZshT71rmampoUn3766VnuscceE4D24WtDUQvLd77znRSvXr06y9nWj3Xr1mW5q6++Ots+9dRTU+xb7GyN8+1vtl34A9Z4S/kAABaFSURBVB/4QJabNGlSim37jJTfsm5vl/fHTesusP+y6xM7AkCSli9fnm3bsSh+fIjdjx+RYtdHfg3Ws2fPFNsWOimva36fvgYDaH2Nbf33teTKK69M8ZNPPpnlbr311hQfccQRWc6fF/Xv3z/FixcvznLHHXdcij/+8Y9nudmzZ6fY1xnb1uvHotj24IsvvjjL/eu//muK6+rqBKDpilpgfQuuH01k2TWBPy+x6xM/aslu+3M5v17xtcOy7cGjR4/OcrYF2Y89sTVt5cqVFfffGrijDwAAAAAAAKgCXOgDAAAAAAAAqgAX+gAAAAAAAIAq0Goz+r773e+m+Pjjj89ygwcPTrHvzbbzYQ4++OAsZ3u8/aOTi+b32e29zd2yx2Mfhyzlj4S3/dZS/ph3O0NCyucOzp07N8vZ7T/96U8C0DH4uQ1Wv379sm37WPUhQ4ZkOTvvZsyYMVnuk5/8ZLZta5yfnWXnh/pZVnZuhJ9pY9/nZ+Ns2LBBjcFMPmD/dcEFF6TY1ippzzWQrSV2tp6U10Q/H8fOtfFrJ1s/7P6lfK6NnZUl5fNFH3jgAQFoffbc6+yzz85y9vvqZ03ZGcNHHnlklrPngY8++miWs99zSXrmmWdSPG7cuCz3yCOPpPjxxx/Pcna2lz9HtLXFn7/ZmujnBZ511lkp/t73vicATef/3bfnOv46kL1O48+17DmLf8aD3fbnb3bbXwfyr7X7sXPMpXymsF8DWX5GoJ/Z15a4ow8AAAAAAACoAlzoAwAAAAAAAKpAq7Xurl69OsX2sereNddck23PmDEjxVdccUWWs7eJb926NcvZVpGiWzb9rZa+Jc1u+5xtTfG5J554IsWXXHKJALSdoluom9t2WvS+6667Ltu24wiefPLJLGdv9fZjDHxbys6dO1Nsxxh4y5Yty7Y3bdqU4i1btmQ5e+u5v9Xdjhm44YYbKn4egPZn61zR2sU7//zzU2zrkd/n3vZjX1vU7uJbY+w+fauwPR6/rvvMZz6TYlp3gZKiOlCJb8O3ba6+rWzq1Kkp9muUH//4xykeMGBAlqupqUnxggULstznP//5FN95551Zzp4vSnm7sF/r2NEovs3Wtuf6tY4dveQ/z66R/PiAkSNHCsC+8eOG7BrBr0nsa21NkYqv59h9+vWJbaX151a+hto1ih195PfjRx/Z61D2XE7as/62Je7oAwAAAAAAAKoAF/oAAAAAAACAKsCFPgAAAAAAAKAKtNqMvubMkJDyR6dv37694j6LHsfse7P9Y9aL2LkOvv+6tra2wWNp6DOboymzcoADUaVZfE35rth9NOV7PHr06BQffPDBWc7OcTjmmGOynJ3feccdd1Tcp9+Pn1c1atSoFPvZOHZ+6PDhw7PcmjVrUuwf+W4/w87skaS1a9cKQMdh65yfHWPnTH3oQx/Kcnbm1qJFi7KcrR1eUX30M7A6d+5c8X32uP3azc7Z2rZtW5Y7/fTTKx4bcKCy3yc7F+roo4/OXmfnQvnzILvtZ2raeXbPP/98ljvllFNSvHDhwix3xhlnpPhnP/tZlrOvfeyxx7KcnxF48803V/yM/v37qxI7x92fv23evDnFfg6fnQO2Y8eOwmMD0HR+vWLXC35ur2XXNVI+z8+frxVdB7JrEv95vv7Z1/rZena/fragrSOrVq3KcrZOtzXu6AMAAAAAAACqABf6AAAAAAAAgCrQaq27LdF26m/ZHjt2bIq7dOmS5ey2v52yiL191G/7W93tLZv+NkzfjtIctOoCxex3xN5u7b87RS249rVF37nJkydn27feemuK77777ixnW2bq6uqynG3znTBhQpbzrbS2ZWbEiBFZzrbc+Rpn/y784+htK++cOXOy3F133ZXiGTNmVPw8ahPQ/my7rG9psd/zX/ziF1lu8eLFFffpv9u2baVoDVTUuuvrr22V8e+zNbBoHfXpT3862/7e975X8bVAtQohZOc7Z599dor9SBHbvlpfX5/l7GiknTt3Zjm7/wULFmS5Cy+8MMUXX3xxlrvuuutSfMQRR2S5F198McU33HBDlhs2bFi2bdt+R44cqUo2btyYbdufyde1vn37pti343Xv3j3FfiyKb/MFsO/8uY9lRwqtW7cuy9nvatFoEZ+z6469jXcrOt+xtfGpp57KcoMHD06xX3P52tyWuKMPAAAAAAAAqAJc6AMAAAAAAACqABf6AAAAAAAAgCrQajP6WoKfo2B7uotmwBQ9Otn3hfvHKtsZMd26dctyq1evTvFb3vKWLLdp06Y9fwAArabokeyNNWXKlGx7yJAhKT700EOznK0Hp512Wpb71re+leIxY8ZkudGjR6fYz9YbN25ctr1mzZoUL1myJMvZGRO+3gwcODDFy5cvz3J2lpef3/eRj3wkxStWrMhydiYhgPZn1y+1tbVZzs6LsbO5pHzmjZ1xIxXPM/VzbuwsGz/Xxm7v2LGj4n583bbbfvayPTY7i0xiRh8OTD179tTUqVPT9vz581Ps/+23r/Oz7uxcvG3btmU5u9axc+8k6Uc/+lGKb7/99iy3efPmFHft2jXL9evXL8Xz5s3Lco8//ni2bddF/jzMbvfu3VuV+Jydvedrnv35/dw/W7v69OmTYltTARTr0aNHtm3ngvqcrTn2uouUzwL212+K2Pf5GXx+LWPXWf61dtbeo48+muXsXHV/rcnPJm5L3NEHAAAAAAAAVAEu9AEAAAAAAABVgAt9AAAAAAAAQBXYr2b0rV+/PsW9evXKckXz+2wft585UzTny/dU217ttWvXZrnBgwdX3A+AlnfMMcek2M9Vsd/r6dOnZzlbV0488cQsd8IJJ6T4L3/5S5a75557Urxu3bosd8YZZ6TYz4axc3P8cfrPeOKJJ1LsZ+OccsopKZ4wYUKWq6+vT/HQoUOznK1jvm6tXLkyxYccckiWs3WzJeYhAgcqP0vGr0MsP9vFsjXv3nvvzXK2Jtm1kiT17ds3xf677OfT2GPzx2nXQHbmjbTn/FHL/kx+XWW3/drN1jU/XxQ4EL3++uvZ2sB+R+w8Xkl68MEHU3z//fdnObtO8fP07KwpO5NKymcQ+3O08ePHp7iuri7L2Tlcdl6etGctsdt+fpetc1u2bMlytu75Omfnlvp1kJ0t6OeL2rozduzYFD/77LMC0Dh+1qatVf37989yS5cuTbH9bkr5rFG/lrDrLF9T7ExAPwvYr4Fs7fDrMTvjeMGCBVnO18pK/JxkX3NaGnf0AQAAAAAAAFWAC30AAAAAAABAFejQrbv2lnQpbxuxrShS3hLnb9m0/C2bRY889m0r9nZLf4u8vxUTQMvq27ev3vnOd6bt733veyn2LbC2XbZfv35ZzrZ33H777Vlu3rx5KfZttraFZPLkyVnO3jLu2/Tsrd/+Vu+tW7dm24ceemiKp02bluXsY+Zty62U32rub3UfPnx4in1b78KFC1Psb58fPXp0ihctWiQA+brArh+KWleb2/p+3XXXZdsXXXRRiou+k741rmh8ia9Xll1zSfnP4dtsbfuLz9m/G98maI/Ht9DY9kLfCggciHr16qW3v/3tafvwww9P8bXXXpu91o8Ysew6wX/vVqxYkWLfumbPoXztsPvx51Y259/nX2vPr/w6rKjOVqrNUl6TisYH+HM5uw4q+vsE0Hi2rviW1yeffDLFfu3kxwVU2qdfu9jvv69pRWsZ/1p7rHPnzs1ydiSA/5nsz+HPSWndBQAAAAAAALBXXOgDAAAAAAAAqgAX+gAAAAAAAIAq0KFn9PlZLkWPR3755ZdT7B/jbPl+bz+vxvZ1+1l/dnaDfby9tOeMCwAta8iQIfrnf/7ntG2/q36enZ2h99hjj2U5+92dMmVKlnvxxRdTPHbs2Cz3jne8I8VPPfVUlrMzJVatWpXl7PyXSZMmZblRo0Zl27YeFc3O2rJlS7ZtZ+/52mhnRdjZO1Je03wttO9jRh9QYutO0byoxjrzzDOzbTtny8/UtN9Dvz6xc2b8fBp7nH595F9bNEvLrsH8nCt7PHaeqZSv5fxayX6G//u023/6058EHOjq6uqy+cRXXHFFir/61a9mr7Uzgf1c39mzZ6fYr2fsd9nOyZTytYdfM9ga5L/L9rV+JpU/L7Prktra2ixnj8fXIDvzuFevXlnObvufydbEiRMnZjm7RvvHf/zHiscMoLKimZl+Zt38+fNT7NcrRbM27VrCzz+3s8qL1jVS/t0umhtsZ/JJ0rJly1I8bNiwLGdnDBddo2oNXJ0CAAAAAAAAqgAX+gAAAAAAAIAq0KFbd207rpTfprlt27YsZ9vx/G2R9jZ0fzu5f3RyURuJbXHxt376djkALev111/f43u/W01NTbZtv7snnnhilquvr0/x+vXrK77P52yri7+de/Xq1Sm2t4hL0vTp01PsbzX3bb67du1K8XPPPZflbNvviBEjspy9Ldy3zdlb2H3Lr61ptv1YyltYHn74YQHI2ZaTSy+9NMu9+93vTvGgQYOynG/Zt5YvX57i559/PsvZljavsW3/nm2FkfIa6NdAgwcPTrFvK7Z828zmzZsr7tO2yWzatCnL2Z9j3rx5FT8POFB9/etfr5iz40bOOuusLHfqqaem2J+/2O+aH9thz7XWrVuX5ez5VN++fbOc/d77Y2nKKCa79vLrGfsZReOVbD2S8nWXXedJ0o9+9KMU064LNI9fZ9hzIX9eZEco+bWTXRMUteD60SaWv+5TxB+3HUPi68HTTz+dYj9ywI4O8OerrY07+gAAAAAAAIAqwIU+AAAAAAAAoApwoQ8AAAAAAACoAh16Rp+fozBw4MAU+8ez2/5n37dd1NNdNAfQzm3w/NwIZvQBrWv16tW68sor0/Z5552XYj8rYdy4cSn2M+vsd/XII4/Mcm9+85tT/Otf/zrL9ezZs8FYkt72trel2M69k6Q1a9ZUzNl5gd6QIUOybTuPxtcx+8h3P8fQfoavW/Z4fG7ChAkVjw04EHXp0iWbTXfXXXeluH///tlr7RwYP+dlyZIlFT/DrkHsukbas35Uep//PPvd9rOr/GttbfNztmyd+eMf/5jlLr/88hRfcMEFWe5973tfiu08Uymvz35Wj932s3oA5LM5fX148MEHG4w9P8/quOOOS7E975LyOVh+jWLn4Pl1yMqVK1N84403Zjk/m/PRRx9NMXPxgP2fX2dY/t99Ox/d1x/72qIZfX7tZK8Z+Xpna6jfr79GZH8Ofx5o65id5SdJGzZsSLFfV7U27ugDAAAAAAAAqgAX+gAAAAAAAIAq0KFbdz17O6V/rLq9FbKoHdffPuq3i9p17e2evlW36H0A9t2WLVuydrFJkyaleMaMGdlr586dm+K6urost3HjxhQfeuihWc7WCj86oHv37g2+TpJWrFiRYl9/bAuLvw197Nix2ba9vdsf97p161Js24Gl/7+9u2etotsCADwKSvyIJn52vooY4TWooAiCIPgDLPwDgo2FNv4FS7W3sLJTtBJLm5DKRpREBD8gIqgkmIiJHyCYW1zuvmuv13M83nvPe4/j81Rrs2fOzBTZ7NnZa033reZzc3Mlzum44+PjJX758mXVNzU11QD/Njw83Jw4caK04xj0/Pnz6tiYRtct5TaOK01Tp7/FVJSmqecgPypDEsV03Zh+2zR/TXGJ6ScXL16s+q5cudLxGtHZs2er9oYNG0qc51w5jSaK86qcJgN0H1t69fXr16p97969//o3Af4lp/LHkh2xzEnT1POVnFYb5wFLS0tVXzw2lyiJc5A858qlA+L7XZyP5fbo6GjV9+DBgxLnUiPxvbPbXK0f7OgDAAAAgBaw0AcAAAAALWChDwAAAABaYKBr9OXPqnf7rHJs53zvmFOda+nla8R6MbmWTDw2187JeeRAf129erXEk5OTVd+pU6dK/Oeff1Z9mzdvLnGu4xA/wZ5rM8RaVkNDQ1Xfhw8fSpzHpqNHj5Y415S4e/du1Y61co4fP97x+jt37qz64r3mz7p3q1Ea7yc+e9M0zbFjx0p8//79qi/X84PfwcLCQnPz5s3SPn/+fIk3bdpUHZv/RqNYYzjPSeLcIs9lcm3QaMuWLSXO41P0+vXrqn3mzJmqffv27Y7n9irXwIk1afJcKd5rrjcW52Px+QCAX0NeM4nvKbnWXZTnR3FOkOv+datXGucPuS5xni/Fe83vbHEdKNYZbJr6/e3Vq1dVX5wT5XetfrOjDwAAAABawEIfAAAAALTAQKfu5k++x+2UOT0ubqdcvXp11dctda1biku+fjx3eHi4598B+mt6erpjO48Hp0+fLvHIyEjVt3v37hKPj49XfS9evChxHhv27NlT4pwad+nSpRLfunXr+w/wHbt27arahw8fLnFOOY5jXC5H8O7duxLncSqm1M3Pz1d9d+7cKbFUXfjnHCD+7R06dKjjsQcPHizxyZMnq74DBw6UeNu2bVVfTAGOZQaapk5NyWkrMzMzJZ6YmKj6bty4UeJHjx51vOcsz7PiHCin4Ma+WMqgaeoxMafwzM3NlTintMTfnJqa6vW2AYABkcuQxLlFXpfpdFzT1POO/JsxrTeXMIrHxjlH0/w15Tf/bif5GtH79++rdkwX7va8/WBHHwAAAAC0gIU+AAAAAGgBC30AAAAA0AIDXaMvi59ZznWouuU8x5zuXK+r2+eYY753vsbCwkLVlz+z3Mu9/Oj6QG9Wrqz/ZxH/rmIduqZpmmvXrnX8nfg3PzY2VvU9ffq043l79+4t8ezsbNWX21G3WqMXLlyo+uIz5ueN9R/yWJRrBgL99/Dhw+/Gv5I8z4q6zV3OnTvXj9sBAH5xsQ5eXNvJ8ppJrI+e5yDxfSqfF9+Rcv28XBs4nhvrn//oXqNcvy/OpbrV9usHO/oAAAAAoAUs9AEAAABACwx06u6XL1+qdtyymbdTxrTanKr38ePHjtdYXFzs2JevEdN+fyZ1GOiv/9XfXxxjHj9+3PN509PT/9H1uqXGZfEZ8/PGreh5WzoAAMDfbWRkpGrv2LGjxMPDwx3P27hxY8e+mP6b5bTeuJ6USyblNaN4bj42rgPl9OAorzvt27evxM+ePet4Xj/Y0QcAAAAALWChDwAAAABawEIfAAAAALTAQNfo27p1a9Veu3ZtiWOe9Pfa0bp160qc862Xlpaqdsz57lY/K39iOeafr1q1quqLdb9yTnfOIwcAAAD4leWa52/evClxt1p3T548qdpHjhwp8djYWNUXa+3ltZ5ozZo1VXv79u1Ve2hoqMS5tmBcM5qYmOh4jevXr1ftuA716dOnjuf1gx19AAAAANACFvoAAAAAoAUGOnV3cnKyasctlPnTxXGbZrctmzkdd+XKlR3buS+em7dzxmvGVF0AAACA39n8/HxPx83Ozlbty5cvl3j//v1V3/r160s8Ojpa9X379q3EeW0np9J+/vy5xG/fvq36ZmZmerjr+npN0zSLi4s9ndcPdvQBAAAAQAtY6AMAAACAFrDQBwAAAAAtsGJ5ebn3g1esmGua5mX/boef8Mfy8vLW//dNwN/F+DNQjD/8doxBA8UYxG/HGDQwjD/8dow/A6WnMeinFvoAAAAAgMEkdRcAAAAAWsBCHwAAAAC0gIU+AAAAAGgBC30AAAAA0AIW+gAAAACgBSz0AQAAAEALWOgDAAAAgBaw0AcAAAAALWChDwAAAABa4B9kM+0iiTc8VAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11d9092b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "    \n",
    "# obtain one batch of training images\n",
    "dataiter = iter(train_loader)\n",
    "images, labels = dataiter.next()\n",
    "images = images.numpy()\n",
    "\n",
    "# plot the images in the batch, along with the corresponding labels\n",
    "fig = plt.figure(figsize=(25, 4))\n",
    "for idx in np.arange(batch_size):\n",
    "    ax = fig.add_subplot(2, batch_size/2, idx+1, xticks=[], yticks=[])\n",
    "    ax.imshow(np.squeeze(images[idx]), cmap='gray')\n",
    "    ax.set_title(classes[labels[idx]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the network architecture\n",
    "\n",
    "The various layers that make up any neural network are documented, [here](http://pytorch.org/docs/master/nn.html). For a convolutional neural network, we'll use a simple series of layers:\n",
    "* Convolutional layers\n",
    "* Maxpooling layers\n",
    "* Fully-connected (linear) layers\n",
    "\n",
    "You are also encouraged to look at adding [dropout layers](http://pytorch.org/docs/stable/nn.html#dropout) to avoid overfitting this data.\n",
    "\n",
    "---\n",
    "\n",
    "To define a neural network in PyTorch, you define the layers of a model in the function `__init__` and define the feedforward behavior of a network that employs those initialized layers in the function `forward`, which takes in an input image tensor, `x`. The structure of this Net class is shown below and left for you to fill in.\n",
    "\n",
    "Note: During training, PyTorch will be able to perform backpropagation by keeping track of the network's feedforward behavior and using autograd to calculate the update to the weights in the network.\n",
    "\n",
    "#### Define the Layers in ` __init__`\n",
    "As a reminder, a conv/pool layer may be defined like this (in `__init__`):\n",
    "```\n",
    "# 1 input image channel (for grayscale images), 32 output channels/feature maps, 3x3 square convolution kernel\n",
    "self.conv1 = nn.Conv2d(1, 32, 3)\n",
    "\n",
    "# maxpool that uses a square window of kernel_size=2, stride=2\n",
    "self.pool = nn.MaxPool2d(2, 2)      \n",
    "```\n",
    "\n",
    "#### Refer to Layers in `forward`\n",
    "Then referred to in the `forward` function like this, in which the conv1 layer has a ReLu activation applied to it before maxpooling is applied:\n",
    "```\n",
    "x = self.pool(F.relu(self.conv1(x)))\n",
    "```\n",
    "\n",
    "You must place any layers with trainable weights, such as convolutional layers, in the `__init__` function and refer to them in the `forward` function; any layers or functions that always behave in the same way, such as a pre-defined activation function, may appear *only* in the `forward` function. In practice, you'll often see conv/pool layers defined in `__init__` and activations defined in `forward`.\n",
    "\n",
    "#### Convolutional layer\n",
    "The first convolution layer has been defined for you, it takes in a 1 channel (grayscale) image and outputs 10 feature maps as output, after convolving the image with 3x3 filters.\n",
    "\n",
    "#### Flattening\n",
    "\n",
    "Recall that to move from the output of a convolutional/pooling layer to a linear layer, you must first flatten your extracted features into a vector. If you've used the deep learning library, Keras, you may have seen this done by `Flatten()`, and in PyTorch you can flatten an input `x` with `x = x.view(x.size(0), -1)`.\n",
    "\n",
    "### Define the rest of the layers\n",
    "\n",
    "It will be up to you to define the other layers in this network; we have some recommendations, but you may change the architecture and parameters as you see fit.\n",
    "\n",
    "Recommendations/tips:\n",
    "* Use at least two convolutional layers\n",
    "* Your output must be a linear layer with 10 outputs (for the 10 classes of clothing)\n",
    "* Use a dropout layer to avoid overfitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class Net(nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.layer1 = nn.Sequential(\n",
    "            OrderedDict([\n",
    "            ('conv1', nn.Conv2d(1, 5, kernel_size=3)),\n",
    "            ('relu1',nn.ReLU()),\n",
    "            ('bachnorm1', nn.BatchNorm2d(10))]))\n",
    "        \n",
    "        self.layer2 = nn.Sequential(OrderedDict([\n",
    "            ('maxp1', nn.MaxPool2d(2,2))]))\n",
    "        \n",
    "        self.layer3 = nn.Sequential(OrderedDict([\n",
    "            ('conv2', nn.Conv2d(10, 10, kernel_size=3)),\n",
    "            ('relu2', nn.ReLU())]))\n",
    "        \n",
    "        self.layer4 = nn.Sequential(OrderedDict([\n",
    "            ('fc1', nn.Linear(11*11*10,100 )),\n",
    "            ('relu3', nn.ReLU()),\n",
    "            ('dropout4',  nn.Dropout(0.4))]))\n",
    "        \n",
    "        self.layer5 = nn.Sequential(OrderedDict([\n",
    "            ('fc2', nn.Linear(100, 50)),\n",
    "            ('relu4', nn.ReLU()),\n",
    "            ('dropout4',  nn.Dropout(0.4))]))\n",
    "        \n",
    "        self.layer6 = nn.Sequential(OrderedDict([\n",
    "            ('fc3', nn.Linear(50, 10)),\n",
    "            ('relu5', nn.ReLU())]))\n",
    "        \n",
    "        \n",
    "    ## define the feedforward behavior\n",
    "    def forward(self, x):\n",
    "        out = self.layer1(x)\n",
    "        out = self.layer2(out)\n",
    "        out = self.layer3(out)\n",
    "        out = out.view(out.size(0), -1)\n",
    "        out = self.layer4(out)\n",
    "        out = self.layer5(out)\n",
    "        out = self.layer6(out)\n",
    "        # final output\n",
    "        return F.log_softmax(out, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (layer1): Sequential(\n",
      "    (conv1): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1))\n",
      "    (relu1): ReLU()\n",
      "    (bachnorm1): BatchNorm2d(10, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  )\n",
      "  (layer2): Sequential(\n",
      "    (maxp1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  )\n",
      "  (layer3): Sequential(\n",
      "    (conv2): Conv2d(10, 20, kernel_size=(3, 3), stride=(1, 1))\n",
      "    (relu2): ReLU()\n",
      "  )\n",
      "  (layer4): Sequential(\n",
      "    (fc1): Linear(in_features=2420, out_features=200, bias=True)\n",
      "    (relu3): ReLU()\n",
      "    (dropout4): Dropout(p=0.4)\n",
      "  )\n",
      "  (layer5): Sequential(\n",
      "    (fc2): Linear(in_features=200, out_features=100, bias=True)\n",
      "    (relu4): ReLU()\n",
      "    (dropout5): Dropout(p=0.4)\n",
      "  )\n",
      "  (layer6): Sequential(\n",
      "    (fc3): Linear(in_features=100, out_features=10, bias=True)\n",
      "    (relu5): ReLU()\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class Net(nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.layer1 = nn.Sequential(\n",
    "            OrderedDict([\n",
    "            ('conv1', nn.Conv2d(1, 10, kernel_size=3)),\n",
    "            ('relu1',nn.ReLU()),\n",
    "            ('bachnorm1', nn.BatchNorm2d(10))]))\n",
    "        \n",
    "        self.layer2 = nn.Sequential(OrderedDict([\n",
    "            ('maxp1', nn.MaxPool2d(2,2))]))\n",
    "        \n",
    "        self.layer3 = nn.Sequential(OrderedDict([\n",
    "            ('conv2', nn.Conv2d(10, 20, kernel_size=3)),\n",
    "            ('relu2', nn.ReLU())]))\n",
    "        \n",
    "        self.layer4 = nn.Sequential(OrderedDict([\n",
    "            ('fc1', nn.Linear(11*11*20,200 )),\n",
    "            ('relu3', nn.ReLU()),\n",
    "            ('dropout4',  nn.Dropout(0.4))]))\n",
    "        \n",
    "        self.layer5 = nn.Sequential(OrderedDict([\n",
    "            ('fc2', nn.Linear(200, 100)),\n",
    "            ('relu4', nn.ReLU()),\n",
    "            ('dropout5',  nn.Dropout(0.4))]))\n",
    "        \n",
    "        self.layer6 = nn.Sequential(OrderedDict([\n",
    "            ('fc3', nn.Linear(100, 10)),\n",
    "            ('relu5', nn.ReLU())]))\n",
    "        \n",
    "        \n",
    "    ## define the feedforward behavior\n",
    "    def forward(self, x):\n",
    "        out = self.layer1(x)\n",
    "        out = self.layer2(out)\n",
    "        out = self.layer3(out)\n",
    "        out = out.view(out.size(0), -1)\n",
    "        out = self.layer4(out)\n",
    "        out = self.layer5(out)\n",
    "        out = self.layer6(out)\n",
    "        # final output\n",
    "        return F.log_softmax(out, dim=1)\n",
    "\n",
    "# instantiate and print your Net\n",
    "net = Net()\n",
    "print(net)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specify the loss function and optimizer\n",
    "\n",
    "Learn more about [loss functions](http://pytorch.org/docs/master/nn.html#loss-functions) and [optimizers](http://pytorch.org/docs/master/optim.html) in the online documentation.\n",
    "\n",
    "Note that for a classification problem like this, one typically uses cross entropy loss, which can be defined in code like: `criterion = nn.CrossEntropyLoss()`. PyTorch also includes some standard stochastic optimizers like stochastic gradient descent and Adam. You're encouraged to try different optimizers and see how your model responds to these choices as it trains.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "\n",
    "## specify loss function (try categorical cross-entropy)\n",
    "criterion = nn.NLLLoss()\n",
    "\n",
    "## specify optimizer \n",
    "optimizer = optim.Adam(net.parameters()) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A note on accuracy\n",
    "\n",
    "It's interesting to look at the accuracy of your network **before and after** training. This way you can really see that your network has learned something. In the next cell, let's see what the accuracy of an untrained network is (we expect it to be around 10% which is the same accuracy as just guessing for all 10 classes)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy before training:  11.08\n"
     ]
    }
   ],
   "source": [
    "# Calculate accuracy before training\n",
    "correct = 0\n",
    "total = 0\n",
    "\n",
    "# Iterate through test dataset\n",
    "for images, labels in test_loader:\n",
    "\n",
    "    # forward pass to get outputs\n",
    "    # the outputs are a series of class scores\n",
    "    outputs = net(images)\n",
    "    \n",
    "    # get the predicted class from the maximum value in the output-list of class scores\n",
    "    _, predicted = torch.max(outputs.data, 1)\n",
    "\n",
    "    # count up total number of correct labels\n",
    "    # for which the predicted and true labels are equal\n",
    "    total += labels.size(0)\n",
    "    correct += (predicted == labels).sum()\n",
    "\n",
    "# calculate the accuracy\n",
    "accuracy = 100 * correct.item() / total\n",
    "\n",
    "# print it out!\n",
    "print('Accuracy before training: ', accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the Network\n",
    "\n",
    "Below, we've defined a `train` function that takes in a number of epochs to train for. The number of epochs is how many times a network will cycle through the training dataset. \n",
    "\n",
    "Here are the steps that this training function performs as it iterates over the training dataset:\n",
    "\n",
    "1. Zero's the gradients to prepare for a forward pass\n",
    "2. Passes the input through the network (forward pass)\n",
    "3. Computes the loss (how far is the predicted classes are from the correct labels)\n",
    "4. Propagates gradients back into the network’s parameters (backward pass)\n",
    "5. Updates the weights (parameter update)\n",
    "6. Prints out the calculated loss\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(n_epochs):\n",
    "    \n",
    "    for epoch in range(n_epochs):  # loop over the dataset multiple times\n",
    "\n",
    "        running_loss = 0.0\n",
    "        for batch_i, data in enumerate(train_loader):\n",
    "            # get the input images and their corresponding labels\n",
    "            inputs, labels = data       \n",
    "\n",
    "            # zero the parameter (weight) gradients\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            # forward pass to get outputs\n",
    "            outputs = net(inputs)\n",
    "\n",
    "            # calculate the loss\n",
    "            loss = criterion(outputs, labels)\n",
    "\n",
    "            # backward pass to calculate the parameter gradients\n",
    "            loss.backward()\n",
    "\n",
    "            # update the parameters\n",
    "            optimizer.step()\n",
    "\n",
    "            # print loss statistics\n",
    "            # to convert loss into a scalar and add it to running_loss, we use .item()\n",
    "            running_loss += loss.item()\n",
    "            if batch_i % 1000 == 999:    # print every 1000 mini-batches\n",
    "                print('Epoch: {}, Batch: {}, Avg. Loss: {}'.format(epoch + 1, batch_i+1, running_loss/1000))\n",
    "                running_loss = 0.0\n",
    "\n",
    "    print('Finished Training')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1, Batch: 1000, Avg. Loss: 0.9699986395016312\n",
      "Epoch: 1, Batch: 2000, Avg. Loss: 0.5187839368926361\n",
      "Epoch: 1, Batch: 3000, Avg. Loss: 0.4400461117052473\n",
      "Epoch: 1, Batch: 4000, Avg. Loss: 0.411709688089788\n",
      "Epoch: 1, Batch: 5000, Avg. Loss: 0.3856442253987771\n",
      "Epoch: 1, Batch: 6000, Avg. Loss: 0.3770311394848395\n",
      "Epoch: 2, Batch: 1000, Avg. Loss: 0.34286243400443345\n",
      "Epoch: 2, Batch: 2000, Avg. Loss: 0.3446795161117334\n",
      "Epoch: 2, Batch: 3000, Avg. Loss: 0.3415969092875021\n",
      "Epoch: 2, Batch: 4000, Avg. Loss: 0.33885291626595426\n",
      "Epoch: 2, Batch: 5000, Avg. Loss: 0.33418563305970744\n",
      "Epoch: 2, Batch: 6000, Avg. Loss: 0.33411115120220347\n",
      "Epoch: 3, Batch: 1000, Avg. Loss: 0.3069368022899143\n",
      "Epoch: 3, Batch: 2000, Avg. Loss: 0.3038891102146008\n",
      "Epoch: 3, Batch: 3000, Avg. Loss: 0.2953024883713224\n",
      "Epoch: 3, Batch: 4000, Avg. Loss: 0.30327373158145926\n",
      "Epoch: 3, Batch: 5000, Avg. Loss: 0.2926836688127369\n",
      "Epoch: 3, Batch: 6000, Avg. Loss: 0.2940279271320905\n",
      "Epoch: 4, Batch: 1000, Avg. Loss: 0.24922800236014883\n",
      "Epoch: 4, Batch: 2000, Avg. Loss: 0.2719155228970012\n",
      "Epoch: 4, Batch: 3000, Avg. Loss: 0.28646562914940293\n",
      "Epoch: 4, Batch: 4000, Avg. Loss: 0.2823120166708832\n",
      "Epoch: 4, Batch: 5000, Avg. Loss: 0.26472015253435527\n",
      "Epoch: 4, Batch: 6000, Avg. Loss: 0.27632884062369706\n",
      "Epoch: 5, Batch: 1000, Avg. Loss: 0.2322955418534111\n",
      "Epoch: 5, Batch: 2000, Avg. Loss: 0.2537460395822418\n",
      "Epoch: 5, Batch: 3000, Avg. Loss: 0.25700896583357824\n",
      "Epoch: 5, Batch: 4000, Avg. Loss: 0.2501169126061741\n",
      "Epoch: 5, Batch: 5000, Avg. Loss: 0.2603454343963531\n",
      "Epoch: 5, Batch: 6000, Avg. Loss: 0.25177633419010087\n",
      "Epoch: 6, Batch: 1000, Avg. Loss: 0.21981123720030882\n",
      "Epoch: 6, Batch: 2000, Avg. Loss: 0.2210736058506882\n",
      "Epoch: 6, Batch: 3000, Avg. Loss: 0.24249445832308264\n",
      "Epoch: 6, Batch: 4000, Avg. Loss: 0.2291299604982778\n",
      "Epoch: 6, Batch: 5000, Avg. Loss: 0.2460019525910029\n",
      "Epoch: 6, Batch: 6000, Avg. Loss: 0.23334708851033428\n",
      "Epoch: 7, Batch: 1000, Avg. Loss: 0.20764905944644124\n",
      "Epoch: 7, Batch: 2000, Avg. Loss: 0.22071842044605364\n",
      "Epoch: 7, Batch: 3000, Avg. Loss: 0.2146049677088813\n",
      "Epoch: 7, Batch: 4000, Avg. Loss: 0.2256286596042264\n",
      "Epoch: 7, Batch: 5000, Avg. Loss: 0.2170183050939704\n",
      "Epoch: 7, Batch: 6000, Avg. Loss: 0.23336152301402763\n",
      "Epoch: 8, Batch: 1000, Avg. Loss: 0.19607314516163024\n",
      "Epoch: 8, Batch: 2000, Avg. Loss: 0.20221807147853907\n",
      "Epoch: 8, Batch: 3000, Avg. Loss: 0.1967942530506698\n",
      "Epoch: 8, Batch: 4000, Avg. Loss: 0.22049952449002375\n",
      "Epoch: 8, Batch: 5000, Avg. Loss: 0.22171969691202684\n",
      "Epoch: 8, Batch: 6000, Avg. Loss: 0.20608995255909396\n",
      "Epoch: 9, Batch: 1000, Avg. Loss: 0.19219528582835937\n",
      "Epoch: 9, Batch: 2000, Avg. Loss: 0.1925053586633003\n",
      "Epoch: 9, Batch: 3000, Avg. Loss: 0.19720500698259047\n",
      "Epoch: 9, Batch: 4000, Avg. Loss: 0.19629245457303476\n",
      "Epoch: 9, Batch: 5000, Avg. Loss: 0.19623626791744936\n",
      "Epoch: 9, Batch: 6000, Avg. Loss: 0.1974818973736519\n",
      "Epoch: 10, Batch: 1000, Avg. Loss: 0.181109919509076\n",
      "Epoch: 10, Batch: 2000, Avg. Loss: 0.18711125381798682\n",
      "Epoch: 10, Batch: 3000, Avg. Loss: 0.19210810532996767\n",
      "Epoch: 10, Batch: 4000, Avg. Loss: 0.19285151658665745\n",
      "Epoch: 10, Batch: 5000, Avg. Loss: 0.18337349748409723\n",
      "Epoch: 10, Batch: 6000, Avg. Loss: 0.19889042450072883\n",
      "Epoch: 11, Batch: 1000, Avg. Loss: 0.1627638785520916\n",
      "Epoch: 11, Batch: 2000, Avg. Loss: 0.17133745448785612\n",
      "Epoch: 11, Batch: 3000, Avg. Loss: 0.18279215658167813\n",
      "Epoch: 11, Batch: 4000, Avg. Loss: 0.18459168471598172\n",
      "Epoch: 11, Batch: 5000, Avg. Loss: 0.18648267935995522\n",
      "Epoch: 11, Batch: 6000, Avg. Loss: 0.18583833218957624\n",
      "Epoch: 12, Batch: 1000, Avg. Loss: 0.1599357671841626\n",
      "Epoch: 12, Batch: 2000, Avg. Loss: 0.17714675695145343\n",
      "Epoch: 12, Batch: 3000, Avg. Loss: 0.18295281035467906\n",
      "Epoch: 12, Batch: 4000, Avg. Loss: 0.1728972812901893\n",
      "Epoch: 12, Batch: 5000, Avg. Loss: 0.17865068687076563\n",
      "Epoch: 12, Batch: 6000, Avg. Loss: 0.16454883145744498\n",
      "Epoch: 13, Batch: 1000, Avg. Loss: 0.15155506238686667\n",
      "Epoch: 13, Batch: 2000, Avg. Loss: 0.1674118490814667\n",
      "Epoch: 13, Batch: 3000, Avg. Loss: 0.1682930581155142\n",
      "Epoch: 13, Batch: 4000, Avg. Loss: 0.16239041777976732\n",
      "Epoch: 13, Batch: 5000, Avg. Loss: 0.16546311994004845\n",
      "Epoch: 13, Batch: 6000, Avg. Loss: 0.16664542072952326\n",
      "Epoch: 14, Batch: 1000, Avg. Loss: 0.15443331276111621\n",
      "Epoch: 14, Batch: 2000, Avg. Loss: 0.15449942335092634\n",
      "Epoch: 14, Batch: 3000, Avg. Loss: 0.172117608324078\n",
      "Epoch: 14, Batch: 4000, Avg. Loss: 0.15587035365897692\n",
      "Epoch: 14, Batch: 5000, Avg. Loss: 0.15398748881293978\n",
      "Epoch: 14, Batch: 6000, Avg. Loss: 0.1639501902860133\n",
      "Epoch: 15, Batch: 1000, Avg. Loss: 0.15346078630180693\n",
      "Epoch: 15, Batch: 2000, Avg. Loss: 0.1593993215997434\n",
      "Epoch: 15, Batch: 3000, Avg. Loss: 0.16690757644514814\n",
      "Epoch: 15, Batch: 4000, Avg. Loss: 0.14978507387909532\n",
      "Epoch: 15, Batch: 5000, Avg. Loss: 0.16004380256875123\n",
      "Epoch: 15, Batch: 6000, Avg. Loss: 0.14700218699714607\n",
      "Epoch: 16, Batch: 1000, Avg. Loss: 0.13785630764969936\n",
      "Epoch: 16, Batch: 2000, Avg. Loss: 0.1407776606097899\n",
      "Epoch: 16, Batch: 3000, Avg. Loss: 0.14841013599157918\n",
      "Epoch: 16, Batch: 4000, Avg. Loss: 0.15262251887538153\n",
      "Epoch: 16, Batch: 5000, Avg. Loss: 0.15043099325195544\n",
      "Epoch: 16, Batch: 6000, Avg. Loss: 0.1628807671934735\n",
      "Epoch: 17, Batch: 1000, Avg. Loss: 0.13724821812888058\n",
      "Epoch: 17, Batch: 2000, Avg. Loss: 0.13554388971990233\n",
      "Epoch: 17, Batch: 3000, Avg. Loss: 0.14020647091771843\n",
      "Epoch: 17, Batch: 4000, Avg. Loss: 0.14893016272989043\n",
      "Epoch: 17, Batch: 5000, Avg. Loss: 0.14167733536927254\n",
      "Epoch: 17, Batch: 6000, Avg. Loss: 0.15511050673452667\n",
      "Epoch: 18, Batch: 1000, Avg. Loss: 0.12768850818708005\n",
      "Epoch: 18, Batch: 2000, Avg. Loss: 0.14047787652837815\n",
      "Epoch: 18, Batch: 3000, Avg. Loss: 0.1485289590734444\n",
      "Epoch: 18, Batch: 4000, Avg. Loss: 0.14501062227450143\n",
      "Epoch: 18, Batch: 5000, Avg. Loss: 0.13704983294144388\n",
      "Epoch: 18, Batch: 6000, Avg. Loss: 0.1378782645685547\n",
      "Epoch: 19, Batch: 1000, Avg. Loss: 0.13057611673050817\n",
      "Epoch: 19, Batch: 2000, Avg. Loss: 0.1320240361841758\n",
      "Epoch: 19, Batch: 3000, Avg. Loss: 0.14451400965348027\n",
      "Epoch: 19, Batch: 4000, Avg. Loss: 0.15000172514331386\n",
      "Epoch: 19, Batch: 5000, Avg. Loss: 0.14092081201798765\n",
      "Epoch: 19, Batch: 6000, Avg. Loss: 0.15095493397678514\n",
      "Epoch: 20, Batch: 1000, Avg. Loss: 0.12229240300691435\n",
      "Epoch: 20, Batch: 2000, Avg. Loss: 0.13543196265810434\n",
      "Epoch: 20, Batch: 3000, Avg. Loss: 0.1338104474837055\n",
      "Epoch: 20, Batch: 4000, Avg. Loss: 0.14023020681399578\n",
      "Epoch: 20, Batch: 5000, Avg. Loss: 0.12753956259263616\n",
      "Epoch: 20, Batch: 6000, Avg. Loss: 0.1496482570514715\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "# define the number of epochs to train for\n",
    "n_epochs = 20 # start small to see if your model works, initially\n",
    "\n",
    "# call train\n",
    "train(n_epochs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test the Trained Network\n",
    "\n",
    "Once you are satisfied with how the loss of your model has decreased, there is one last step: test!\n",
    "\n",
    "You must test your trained model on a previously unseen dataset to see if it generalizes well and can accurately classify this new dataset. For FashionMNIST, which contains many pre-processed training images, a good model should reach **greater than 85% accuracy** on this test dataset. If you are not reaching this value, try training for a larger number of epochs, tweaking your hyperparameters, or adding/subtracting layers from your CNN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.322420\n",
      "\n",
      "Test Accuracy of T-shirt/top: 85% (855/1000)\n",
      "Test Accuracy of Trouser: 97% (978/1000)\n",
      "Test Accuracy of Pullover: 90% (900/1000)\n",
      "Test Accuracy of Dress: 92% (924/1000)\n",
      "Test Accuracy of  Coat: 84% (842/1000)\n",
      "Test Accuracy of Sandal: 97% (977/1000)\n",
      "Test Accuracy of Shirt: 72% (729/1000)\n",
      "Test Accuracy of Sneaker: 95% (958/1000)\n",
      "Test Accuracy of   Bag: 98% (981/1000)\n",
      "Test Accuracy of Ankle boot: 96% (967/1000)\n",
      "\n",
      "Test Accuracy (Overall): 91% (9111/10000)\n"
     ]
    }
   ],
   "source": [
    "# initialize tensor and lists to monitor test loss and accuracy\n",
    "test_loss = torch.zeros(1)\n",
    "class_correct = list(0. for i in range(10))\n",
    "class_total = list(0. for i in range(10))\n",
    "\n",
    "# set the module to evaluation mode\n",
    "net.eval()\n",
    "\n",
    "for batch_i, data in enumerate(test_loader):\n",
    "    \n",
    "    # get the input images and their corresponding labels\n",
    "    inputs, labels = data\n",
    "    \n",
    "    # forward pass to get outputs\n",
    "    outputs = net(inputs)\n",
    "\n",
    "    # calculate the loss\n",
    "    loss = criterion(outputs, labels)\n",
    "            \n",
    "    # update average test loss \n",
    "    test_loss = test_loss + ((torch.ones(1) / (batch_i + 1)) * (loss.data - test_loss))\n",
    "    \n",
    "    # get the predicted class from the maximum value in the output-list of class scores\n",
    "    _, predicted = torch.max(outputs.data, 1)\n",
    "    \n",
    "    # compare predictions to true label\n",
    "    correct = np.squeeze(predicted.eq(labels.data.view_as(predicted)))\n",
    "    \n",
    "    # calculate test accuracy for *each* object class\n",
    "    # we get the scalar value of correct items for a class, by calling `correct[i].item()`\n",
    "    for i in range(batch_size):\n",
    "        label = labels.data[i]\n",
    "        class_correct[label] += correct[i].item()\n",
    "        class_total[label] += 1\n",
    "\n",
    "print('Test Loss: {:.6f}\\n'.format(test_loss.numpy()[0]))\n",
    "\n",
    "for i in range(10):\n",
    "    if class_total[i] > 0:\n",
    "        print('Test Accuracy of %5s: %2d%% (%2d/%2d)' % (\n",
    "            classes[i], 100 * class_correct[i] / class_total[i],\n",
    "            np.sum(class_correct[i]), np.sum(class_total[i])))\n",
    "    else:\n",
    "        print('Test Accuracy of %5s: N/A (no training examples)' % (classes[i]))\n",
    "\n",
    "        \n",
    "print('\\nTest Accuracy (Overall): %2d%% (%2d/%2d)' % (\n",
    "    100. * np.sum(class_correct) / np.sum(class_total),\n",
    "    np.sum(class_correct), np.sum(class_total)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize sample test results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11e12d240>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# obtain one batch of test images\n",
    "dataiter = iter(test_loader)\n",
    "images, labels = dataiter.next()\n",
    "# get predictions\n",
    "preds = np.squeeze(net(images).data.max(1, keepdim=True)[1].numpy())\n",
    "images = images.numpy()\n",
    "\n",
    "# plot the images in the batch, along with predicted and true labels\n",
    "fig = plt.figure(figsize=(25, 4))\n",
    "for idx in np.arange(batch_size):\n",
    "    ax = fig.add_subplot(2, batch_size/2, idx+1, xticks=[], yticks=[])\n",
    "    ax.imshow(np.squeeze(images[idx]), cmap='gray')\n",
    "    ax.set_title(\"{} ({})\".format(classes[preds[idx]], classes[labels[idx]]),\n",
    "                 color=(\"green\" if preds[idx]==labels[idx] else \"red\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question: What are some weaknesses of your model? (And how might you improve these in future iterations.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer**: Double-click and write answer, here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Save Your Best Model\n",
    "\n",
    "Once you've decided on a network architecture and are satisfied with the test accuracy of your model after training, it's time to save this so that you can refer back to this model, and use it at a later data for comparison of for another classification task!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "## change the model_name to something uniqe for any new model\n",
    "## you wish to save, this will save it in the saved_models directory\n",
    "model_dir = 'saved_models/'\n",
    "model_name = 'model_91.pt'\n",
    "\n",
    "# after training, save your model parameters in the dir 'saved_models'\n",
    "# when you're ready, un-comment the line below\n",
    "torch.save(net.state_dict(), model_dir+model_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load a Trained, Saved Model\n",
    "\n",
    "To instantiate a trained model, you'll first instantiate a new `Net()` and then initialize it with a saved dictionary of parameters (from the save step above)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (layer1): Sequential(\n",
      "    (conv1): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1))\n",
      "    (relu1): ReLU()\n",
      "    (bachnorm1): BatchNorm2d(10, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  )\n",
      "  (layer2): Sequential(\n",
      "    (maxp1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  )\n",
      "  (layer3): Sequential(\n",
      "    (conv2): Conv2d(10, 20, kernel_size=(3, 3), stride=(1, 1))\n",
      "    (relu2): ReLU()\n",
      "  )\n",
      "  (layer4): Sequential(\n",
      "    (fc1): Linear(in_features=2420, out_features=200, bias=True)\n",
      "    (relu3): ReLU()\n",
      "    (dropout4): Dropout(p=0.4)\n",
      "  )\n",
      "  (layer5): Sequential(\n",
      "    (fc2): Linear(in_features=200, out_features=100, bias=True)\n",
      "    (relu4): ReLU()\n",
      "    (dropout5): Dropout(p=0.4)\n",
      "  )\n",
      "  (layer6): Sequential(\n",
      "    (fc3): Linear(in_features=100, out_features=10, bias=True)\n",
      "    (relu5): ReLU()\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# instantiate your Net\n",
    "# this refers to your Net class defined above\n",
    "net = Net()\n",
    "\n",
    "# load the net parameters by name\n",
    "# uncomment and write the name of a saved model\n",
    "#net.load_state_dict(torch.load('saved_models/model_1.pt'))\n",
    "\n",
    "print(net)\n",
    "\n",
    "# Once you've loaded a specific model in, you can then \n",
    "# us it or further analyze it! \n",
    "# This will be especialy useful for feature visualization "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.6"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}