Part 5 - Inference and Validation (Exercises).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inference and Validation\n",
    "\n",
    "Now that you have a trained network, you can use it for making predictions. This is typically called **inference**, a term borrowed from statistics. However, neural networks have a tendency to perform *too well* on the training data and aren't able to generalize to data that hasn't been seen before. This is called **overfitting** and it impairs inference performance. To test for overfitting while training, we measure the performance on data not in the training set called the **validation** set. We avoid overfitting through regularization such as dropout while monitoring the validation performance during training. In this notebook, I'll show you how to do this in PyTorch. \n",
    "\n",
    "As usual, let's start by loading the dataset through torchvision. You'll learn more about torchvision and loading data in a later part. This time we'll be taking advantage of the test set which you can get by setting `train=False` here:\n",
    "\n",
    "```python\n",
    "testset = datasets.FashionMNIST('~/.pytorch/F_MNIST_data/', download=True, train=False, transform=transform)\n",
    "```\n",
    "\n",
    "The test set contains images just like the training set. Typically you'll see 10-20% of the original dataset held out for testing and validation with the rest being used for training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torchvision import datasets, transforms\n",
    "\n",
    "# Define a transform to normalize the data\n",
    "transform = transforms.Compose([transforms.ToTensor(),\n",
    "                                transforms.Normalize((0.5,), (0.5,))])\n",
    "# Download and load the training data\n",
    "trainset = datasets.FashionMNIST('~/.pytorch/F_MNIST_data/', download=True, train=True, transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)\n",
    "\n",
    "# Download and load the test data\n",
    "testset = datasets.FashionMNIST('~/.pytorch/F_MNIST_data/', download=True, train=False, transform=transform)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here I'll create a model like normal, using the same one from my solution for part 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch import nn, optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class Classifier(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 256)\n",
    "        self.fc2 = nn.Linear(256, 128)\n",
    "        self.fc3 = nn.Linear(128, 64)\n",
    "        self.fc4 = nn.Linear(64, 10)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # make sure input tensor is flattened\n",
    "        x = x.view(x.shape[0], -1)\n",
    "        \n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        x = F.log_softmax(self.fc4(x), dim=1)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The goal of validation is to measure the model's performance on data that isn't part of the training set. Performance here is up to the developer to define though. Typically this is just accuracy, the percentage of classes the network predicted correctly. Other options are [precision and recall](https://en.wikipedia.org/wiki/Precision_and_recall#Definition_(classification_context)) and top-5 error rate. We'll focus on accuracy here. First I'll do a forward pass with one batch from the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([64, 10])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Classifier(\n",
       "  (fc1): Linear(in_features=784, out_features=256, bias=True)\n",
       "  (fc2): Linear(in_features=256, out_features=128, bias=True)\n",
       "  (fc3): Linear(in_features=128, out_features=64, bias=True)\n",
       "  (fc4): Linear(in_features=64, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Classifier()\n",
    "\n",
    "images, labels = next(iter(testloader))\n",
    "# Get the class probabilities\n",
    "ps = torch.exp(model(images))\n",
    "# Make sure the shape is appropriate, we should get 10 class probabilities for 64 examples\n",
    "print(ps.shape)\n",
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the probabilities, we can get the most likely class using the `ps.topk` method. This returns the $k$ highest values. Since we just want the most likely class, we can use `ps.topk(1)`. This returns a tuple of the top-$k$ values and the top-$k$ indices. If the highest value is the fifth element, we'll get back 4 as the index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[7],\n",
      "        [7],\n",
      "        [7],\n",
      "        [7],\n",
      "        [7],\n",
      "        [7],\n",
      "        [7],\n",
      "        [7],\n",
      "        [7],\n",
      "        [7]])\n"
     ]
    }
   ],
   "source": [
    "top_p, top_class = ps.topk(1, dim=1)\n",
    "# Look at the most likely classes for the first 10 examples\n",
    "print(top_class[:10,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can check if the predicted classes match the labels. This is simple to do by equating `top_class` and `labels`, but we have to be careful of the shapes. Here `top_class` is a 2D tensor with shape `(64, 1)` while `labels` is 1D with shape `(64)`. To get the equality to work out the way we want, `top_class` and `labels` must have the same shape.\n",
    "\n",
    "If we do\n",
    "\n",
    "```python\n",
    "equals = top_class == labels\n",
    "```\n",
    "\n",
    "`equals` will have shape `(64, 64)`, try it yourself. What it's doing is comparing the one element in each row of `top_class` with each element in `labels` which returns 64 True/False boolean values for each row."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "equals = top_class == labels.view(*top_class.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need to calculate the percentage of correct predictions. `equals` has binary values, either 0 or 1. This means that if we just sum up all the values and divide by the number of values, we get the percentage of correct predictions. This is the same operation as taking the mean, so we can get the accuracy with a call to `torch.mean`. If only it was that simple. If you try `torch.mean(equals)`, you'll get an error\n",
    "\n",
    "```\n",
    "RuntimeError: mean is not implemented for type torch.ByteTensor\n",
    "```\n",
    "\n",
    "This happens because `equals` has type `torch.ByteTensor` but `torch.mean` isn't implemented for tensors with that type. So we'll need to convert `equals` to a float tensor. Note that when we take `torch.mean` it returns a scalar tensor, to get the actual value as a float we'll need to do `accuracy.item()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 6.25%\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.0625"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy = torch.mean(equals.type(torch.FloatTensor))\n",
    "print(f'Accuracy: {accuracy.item()*100}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The network is untrained so it's making random guesses and we should see an accuracy around 10%. Now let's train our network and include our validation pass so we can measure how well the network is performing on the test set. Since we're not updating our parameters in the validation pass, we can speed up our code by turning off gradients using `torch.no_grad()`:\n",
    "\n",
    "```python\n",
    "# turn off gradients\n",
    "with torch.no_grad():\n",
    "    # validation pass here\n",
    "    for images, labels in testloader:\n",
    "        ...\n",
    "```\n",
    "\n",
    ">**Exercise:** Implement the validation loop below and print out the total accuracy after the loop. You can largely copy and paste the code from above, but I suggest typing it in because writing it out yourself is essential for building the skill. In general you'll always learn more by typing it rather than copy-pasting. You should be able to get an accuracy above 80%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/1..  Training Loss: 0.517..  Test Loss: 0.458..  Test Accuracy: 0.833\n"
     ]
    }
   ],
   "source": [
    "model = Classifier()\n",
    "criterion = nn.NLLLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.003)\n",
    "\n",
    "epochs = 30\n",
    "steps = 0\n",
    "\n",
    "train_losses, test_losses = [], []\n",
    "for e in range(epochs):\n",
    "    running_loss = 0\n",
    "    for images, labels in trainloader:\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        log_ps = model(images)\n",
    "        loss = criterion(log_ps, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        running_loss += loss.item()\n",
    "        \n",
    "    else:\n",
    "        test_loss = 0\n",
    "        accuracy = 0\n",
    "        \n",
    "        # Turn off gradients for validation, saves memory and computations\n",
    "        with torch.no_grad():\n",
    "            for images, labels in testloader:\n",
    "                log_ps = model(images)\n",
    "                test_loss += criterion(log_ps, labels)\n",
    "                \n",
    "                ps = torch.exp(log_ps)\n",
    "                top_p, top_class = ps.topk(1, dim=1)\n",
    "                equals = top_class == labels.view(*top_class.shape)\n",
    "                accuracy += torch.mean(equals.type(torch.FloatTensor))\n",
    "                \n",
    "        train_losses.append(running_loss/len(trainloader))\n",
    "        test_losses.append(test_loss/len(testloader))\n",
    "\n",
    "        print(\"Epoch: {}/{}.. \".format(e+1, epochs),\n",
    "              \"Training Loss: {:.3f}.. \".format(running_loss/len(trainloader)),\n",
    "              \"Test Loss: {:.3f}.. \".format(test_loss/len(testloader)),\n",
    "              \"Test Accuracy: {:.3f}\".format(accuracy/len(testloader)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overfitting\n",
    "\n",
    "If we look at the training and validation losses as we train the network, we can see a phenomenon known as overfitting.\n",
    "\n",
    "<img src='assets/overfitting.png' width=450px>\n",
    "\n",
    "The network learns the training set better and better, resulting in lower training losses. However, it starts having problems generalizing to data outside the training set leading to the validation loss increasing. The ultimate goal of any deep learning model is to make predictions on new data, so we should strive to get the lowest validation loss possible. One option is to use the version of the model with the lowest validation loss, here the one around 8-10 training epochs. This strategy is called *early-stopping*. In practice, you'd save the model frequently as you're training then later choose the model with the lowest validation loss.\n",
    "\n",
    "The most common method to reduce overfitting (outside of early-stopping) is *dropout*, where we randomly drop input units. This forces the network to share information between weights, increasing it's ability to generalize to new data. Adding dropout in PyTorch is straightforward using the [`nn.Dropout`](https://pytorch.org/docs/stable/nn.html#torch.nn.Dropout) module.\n",
    "\n",
    "```python\n",
    "class Classifier(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 256)\n",
    "        self.fc2 = nn.Linear(256, 128)\n",
    "        self.fc3 = nn.Linear(128, 64)\n",
    "        self.fc4 = nn.Linear(64, 10)\n",
    "        \n",
    "        # Dropout module with 0.2 drop probability\n",
    "        self.dropout = nn.Dropout(p=0.2)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # make sure input tensor is flattened\n",
    "        x = x.view(x.shape[0], -1)\n",
    "        \n",
    "        # Now with dropout\n",
    "        x = self.dropout(F.relu(self.fc1(x)))\n",
    "        x = self.dropout(F.relu(self.fc2(x)))\n",
    "        x = self.dropout(F.relu(self.fc3(x)))\n",
    "        \n",
    "        # output so no dropout here\n",
    "        x = F.log_softmax(self.fc4(x), dim=1)\n",
    "        \n",
    "        return x\n",
    "```\n",
    "\n",
    "During training we want to use dropout to prevent overfitting, but during inference we want to use the entire network. So, we need to turn off dropout during validation, testing, and whenever we're using the network to make predictions. To do this, you use `model.eval()`. This sets the model to evaluation mode where the dropout probability is 0. You can turn dropout back on by setting the model to train mode with `model.train()`. In general, the pattern for the validation loop will look like this, where you turn off gradients, set the model to evaluation mode, calculate the validation loss and metric, then set the model back to train mode.\n",
    "\n",
    "```python\n",
    "# turn off gradients\n",
    "with torch.no_grad():\n",
    "    \n",
    "    # set model to evaluation mode\n",
    "    model.eval()\n",
    "    \n",
    "    # validation pass here\n",
    "    for images, labels in testloader:\n",
    "        ...\n",
    "\n",
    "# set model back to train mode\n",
    "model.train()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Exercise:** Add dropout to your model and train it on Fashion-MNIST again. See if you can get a lower validation loss or higher accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "## TODO: Define your model with dropout added\n",
    "class Classifier(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784, 256)\n",
    "        self.fc2 = nn.Linear(256, 128)\n",
    "        self.fc3 = nn.Linear(128, 64)\n",
    "        self.fc4 = nn.Linear(64, 10)\n",
    "\n",
    "        # Dropout module with 0.2 drop probability\n",
    "        self.dropout = nn.Dropout(p=0.2)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # make sure input tensor is flattened\n",
    "        x = x.view(x.shape[0], -1)\n",
    "\n",
    "        # Now with dropout\n",
    "        x = self.dropout(F.relu(self.fc1(x)))\n",
    "        x = self.dropout(F.relu(self.fc2(x)))\n",
    "        x = self.dropout(F.relu(self.fc3(x)))\n",
    "\n",
    "        # output so no dropout here\n",
    "        x = F.log_softmax(self.fc4(x), dim=1)\n",
    "\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/1..  Training Loss: 0.608..  Test Loss: 0.512..  Test Accuracy: 0.819\n"
     ]
    }
   ],
   "source": [
    "## TODO: Train your model with dropout, and monitor the training progress with the validation loss and accuracy\n",
    "model = Classifier()\n",
    "criterion = nn.NLLLoss()\n",
    "optimizer = optim.Adam(model.parameters(),lr=0.003)\n",
    "\n",
    "epochs = 30\n",
    "steps = 0\n",
    "\n",
    "train_losses, test_losses = [],[]\n",
    "\n",
    "for e in range(epochs):\n",
    "    running_loss = 0\n",
    "    for images, labels in trainloader:\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        log_ps = model(images)\n",
    "        loss = criterion(log_ps,labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        running_loss += loss.item() \n",
    "    \n",
    "    else:\n",
    "        \n",
    "        test_loss = 0\n",
    "        accuracy = 0\n",
    "        \n",
    "        with torch.no_grad():\n",
    "            for images,labels in testloader:\n",
    "                log_ps = model(images)\n",
    "                test_loss += criterion(log_ps,labels)\n",
    "                \n",
    "                ps = torch.exp(log_ps)\n",
    "                top_p,top_class = ps.topk(1,dim=1)\n",
    "                equals = top_class == labels.view(*top_class.shape)\n",
    "                accuracy += torch.mean(equals.type(torch.FloatTensor))\n",
    "                \n",
    "        train_losses.append(running_loss/len(trainloader))\n",
    "        test_losses.append(test_loss/len(testloader))\n",
    "\n",
    "        print(\"Epoch: {}/{}.. \".format(e+1, epochs),\n",
    "              \"Training Loss: {:.3f}.. \".format(running_loss/len(trainloader)),\n",
    "              \"Test Loss: {:.3f}.. \".format(test_loss/len(testloader)),\n",
    "              \"Test Accuracy: {:.3f}\".format(accuracy/len(testloader)))\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1815d178588>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvUAAAH1CAYAAAB2qgEQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdebiWVb3H//cXkHkQJRREURBE046CSioxqZiGYA45ReJxqNQw07QSVNLEn0oqTqEkaHZ+hubZeHCIDqIyOYH60wIkDFNxQg1RERnW74/n2fvs6YE9PAg3vl/Xta/bvda611oP++rqs9de97ojpYQkSZKk7GqwuScgSZIkqX4M9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZVzRQn1EdIqIuyJiWUSsjoilEXFjRLStRR9PRETawFfTSu13ioifRMSj+fFWR8QHEfHXiDi2WJ9NkiRJ2pI1KkYnEdEVmAO0B6YAC4EDgfOBb0fEISmlD2rR5egC5Wsrff8T4BLgn8AM4B2gM3AscFhE3JBS+lktxpUkSZIyJ1JK9e8k4i/AIGBESunmcuW/BS4AxqeUflSDfp4A+qWUoobjHgt8kFJ6slL5nsDTQGtg/5TSvJp+FkmSJClr6h3qI6ILsARYCnRNKa0vV9cKeBsIoH1K6dON9PUEtQj1G+nrDuAs4KKU0th69PNPcr8cLK3vnCRJkqQN2BX4OKW0W21vLMb2m4H567TygR4gpbQyImaTW8X/JjC9Jh1GxInAbsAXwALg8ZTS6lrOa03+WnnLTm21btas2XZ77rnndvXsR5IkSSpowYIFrFq1qk73FiPU75G/vlqgfjG5UN+dGoZ64L5K378XEeemlB6oyc0R0Ro4DkjAtBqOWcjSPffcc7t589zBI0mSpE2nV69ezJ8/f2ld7i1GqG+Tv64oUF9avm0N+poCXA+8AHxA7qHX04ALgT9FxOCU0qMb6iAiApgA7ADcllJaUINxiYhCqb1HTe6XJEmSNpeinH6zEaX74ze6eT+ldEOlokXAryJiGXAzcDWwwVAPjAVOAGYCnnwjSZKkrV4xQn3pSnybAvWtK7WriwnADcC+EdEqpbSyukYRcR2503aeAr5Tm334KaVeBfqcB/Ss/ZQlSZKkL0cxXj61KH/tXqC+W/5aaM/9RqWUPgdKg3yL6tpExA3AReTOqz8ypfRJXceTJEmSsqQYoX5G/jooIir0lz/S8hBgFblz4+skIvYA2pIL9ssr1UVE3Ar8FPgruRX6z+o6liRJkpQ19Q71KaUl5E6Y2RU4t1L1aHIr6/eUP6M+InpERIUHUCOiS0TsVLn/iGgHTMx/e19KaW25ugDuAM4ht9d+SEqpbucASZIkSRlVrAdlzwHmAOMi4lByZ8v3BgaQ23ZzaaX2pSfSlH/JVF9gQkQ8Se5lVh8CuwBHkduv/zxwcaV+LgPOJPeXgBeBX+RyfgUvppRK6vzJJEmSpC1cUUJ9SmlJROwP/Br4Nrkg/jYwDhidUvqwBt3MA+4FegH7knvAdiXwMjAZGJ9S+qLSPaVv22oG/LJAv3cDhnpJkiRttYp2pGVK6Q3g9Bq2rbKcnlJ6GRheyzGH1/YeSZIkaWtTjAdlJUmSJG1GhnpJkiQp4wz1kiRJUsYZ6iVJkqSMM9RLkiRJGWeolyRJkjLOUC9JkiRlnKFekiRpC/DJJ58QEQwePLjefe2///60bNmyCLMqnltuuYWI4IEHHtjcU9kqGeolSdJXWkTU6mvSpEmbe8pSFUV7o6wkSVIWXX755VXKbrzxRlasWMH555/PtttuW6Fu33333STzaNGiBQsWLCjKCvuf//xnVq9eXYRZKSsM9ZIk6SvtiiuuqFI2adIkVqxYwU9/+lN23XXXL2UeEUGPHj2K0lfnzp2L0o+yw+03kiRJdVC6b33VqlWMHDmS3XffncaNG3PeeecB8MEHH3DNNdfQr18/OnbsSOPGjdlhhx047rjjmD9/fpX+Cu2pv+iii4gInn/+ef74xz/Sq1cvmjVrRrt27Rg2bBjvvfdewbmVN3XqVCKC66+/nmeffZYjjjiCNm3a0LJlSw477DDmzZtX7ef817/+xfe//33atWtH8+bN6dWrF3/6058q9Fdfc+fOZejQobRr144mTZrQpUsXfvrTn/L+++9Xabts2TLOP/98unfvTvPmzWnbti177rknZ5xxBm+88UZZu/Xr13PnnXfSu3dv2rVrR7Nmzdhll1046qijKCkpqfectzSu1EuSJNXR+vXrGTx4MIsWLeKII45g++23L1slf+GFF7j88svp378/Q4cOpU2bNvzzn//koYceYurUqfz1r3+lb9++NR7r2muvZerUqQwdOpQBAwYwe/Zs7r33Xl555RWef/55GjZsWKN+Zs2axciRI+nfvz9nnXUWr732GiUlJfTv359XXnmlwir/m2++yUEHHcSyZcs49NBDOeCAA3jrrbc47bTTOPLII2v3j1XA5MmTOfXUU2nYsCEnnHACnTp14umnn+amm25iypQpzJ49m44dOwLw8ccf07t3b5YtW8agQYM45phjWLNmDa+//joPPPAAw4YNY+eddwbgpz/9KTfffDPdunXj5JNPpmXLlixbtoxnnnmGkpISjjnmmKLMf0thqJckSaqjVatWsXLlSl555ZUqe+979uzJO++8Q9u2bSuUL1myhN69e3PhhRfy3HPP1Xis6dOn8+KLL9K9e3cAUkocc8wxPPTQQ/zlL3/hqKOOqlE/U6ZM4f777+f4448vKxs7diwXXXQRt956K9dee21Z+YUXXsiyZcv49a9/zahRo8rKzznnHPr06VPjuRfy4YcfcuaZZxIRzJo1i/3337+sbtSoUVx11VWcd955PPjggwA8/PDDvPnmm4wcOZIrr7yyQl+ff/45a9euBf5vlb5r1668/PLLNGnSpELb5cuX13vuWxpDvSRJKmjXXzy8uadQY0uv+c5mGXfMmDFVAj3AdtttV237rl27MmTIECZOnMgHH3zA9ttvX6Nxfv7zn5cFesjtwT/zzDN56KGHePbZZ2sc6o844ogKgR7g7LPP5qKLLuLZZ58tK1u5ciUPPvgg7du35+c//3mF9t/85jc54YQTuO+++2o0ZiH3338/K1eu5KyzzqoQ6AEuvfRSJkyYwJQpU1i+fDnt2rUrq2vWrFmVvpo2bVrh+4igcePG1f4Fo3xfWwv31EuSJNXDgQceWLBuxowZHHvssXTq1InGjRuXHYs5ceJEILc/vKYqh16gbKvJRx99VK9+WrVqRZs2bSr088orr7B27Vp69epVJTADRVmpL322YODAgVXqmjZtysEHH8z69et56aWXADj88MP52te+xqhRoxg8eDC33norL774IuvXr69wb4MGDTjppJNYsGABe++9N6NGjWLatGmsXLmy3nPeUrlSL0mSVEfNmzenVatW1dbde++9/OAHP6Bly5Ycfvjh7LbbbrRo0YKIYNq0acydO7dWx05W99eARo1yUW7dunX16qe0r/L9rFixAoAddtih2vaFymujdIwOHTpUW19a/u9//xvIrbA/88wzXHHFFUydOpWHH364bC4jRozgkksuKVuZHz9+PD169ODuu+/mqquuAmCbbbZhyJAhjB07dqs7IchQL0mSCtpcW1qyIiIK1o0cOZJWrVrxwgsv0KVLlwp1ixcvZu7cuZt6evXSunVrAN59991q6wuV10abNm0AeOedd6qtf/vttyu0A9htt924++67Wb9+Pa+88grTp0/nlltu4dJLL6Vhw4ZccsklQC7AX3zxxVx88cW88847zJw5k3vvvZc///nPLFy4kJdeeqnGDxdngdtvJEmSimzt2rW8/vrr7LvvvlUC/Zo1a7b4QA+wzz770KhRI+bNm8fnn39epX7WrFn1HmO//fYD4IknnqhSt3r1aubOnUtEVPvCrwYNGvCNb3yDCy64gKlTpwIUPKpyxx135IQTTmDKlCkceOCB/O1vf+Mf//hHvee/JTHUS5IkFVmjRo3Yaaed+Nvf/lbhpJX169fzy1/+kn/+85+bcXY106pVK4455hjee+89rrvuugp1zzzzDPfff3+9x/je975Hy5YtmThxYtm++VJjxozh7bffLju/HuDFF1/kzTffrNJP6V8NmjdvDuTO/H/yySertFu9enXZlp/qHrbNMrffSJIkbQIXXHABF110Ed/4xjc49thjadCgAU8++SRLly7lyCOP5NFHH93cU9yosWPHMmvWLC677DKeeuopDjjgAN58800mT57M0UcfTUlJCQ0a1H2NeLvttuOOO+5g2LBhHHTQQZxwwgnstNNOPP3008yYMYOdd96ZW265paz91KlTufzyy+nTpw977LEH7dq14/XXX2fKlCk0bNiQiy66CMjtwe/fvz9du3blwAMPZJddduGzzz7jscceY/HixZxyyinssssu9f732ZIY6iVJkjaBn/3sZ7Rs2ZJbbrmFu+66ixYtWtC/f38mT57MnXfemYlQv8suu/D000/zy1/+kr/85S/MmjWLvfbai7vvvptVq1ZRUlJStve+rk4++WR22WUXrrnmGqZOncrKlSvp2LEjP/nJTxg5ciTt27cvaztkyBDef/99Zs6cyYMPPsgnn3xChw4dOProo7nwwgvLTvbZfvvtufrqq5kxYwYzZ87k/fffp3Xr1nTr1o1LLrmE0047rV5z3hJFSmlzz2GLFhHzevbs2bPQq5MlSZK+is4//3zGjRvHrFmzOOSQQzb3dLYKvXr1Yv78+fNTSr1qe6976iVJklRQdWfpP/fcc9xxxx107NiR3r17b4ZZqTK330iSJKmgPffck549e/L1r3+dpk2bsmjRorKtQ7feemvZWfnavPwpSJIkqaBzzjmHRx55hD/+8Y988skntG3blsGDB3PxxRdz8MEHb+7pKc9QL0mSpILGjBnDmDFjNvc0tBHuqZckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZL0JfnHP/5BRHDmmWdWKP/+979PRPDmm2/WuK9OnTqx++67F3uKFRSa7+b0v//7v0QEV1111eaeyhbFUC9Jkr7STjnlFCKC22+/faNtDz/8cCKCkpKSL2Fmm97atWuJCA477LDNPRXVk6FekiR9pZ199tkA3HnnnRtst3TpUqZPn06HDh0YPHhwUedw3XXXsWDBAnbcccei9ltfnTt3ZsGCBa6KZ4ChXpIkfaX179+f7t2788ILLzB//vyC7SZMmEBKidNPP51GjRoVdQ4dOnSgR48eRe+3vrbZZht69Oixxf2yoaoM9ZIk6SvvrLPOAgqv1q9bt45JkyZV2V/+1ltvMXr0aA4++GB23HFHGjduzE477cSpp57KwoULazx+oT31KSXGjRvHXnvtRZMmTdhpp50YMWIEH3/8cbX9/Pvf/+baa69lwIAB7LTTTjRu3Jj27dtzzDHH8Oyzz1ZoO2HCBLbZZhsApk+fTkSUfZWuzG9oT/2yZcv48Y9/TOfOnWnSpAnt27fnuOOO44UXXqjSdsKECUQE9957L9OnT6dfv360bNmSNm3acPTRR7No0aIa/1ttyKJFixg2bBgdO3akcePGdOzYkdNOO40lS5ZUafvxxx8zevRo9t57b1q1akWrVq3YfffdOfnkk6t8hpKSEgYOHMiOO+5Y9nPo378/v/vd74oy72LYsn4dlCRJ2gxOO+00Lr30Uv7rv/6LsWPH0rx58wr1jzzyCG+99RaHH344u+22W1n5jBkzykL0fvvtR4sWLVi8eDGTJ0/mf/7nf5gzZw577713ned13nnncdttt9GxY0d++MMf0qhRI0pKSnj22WdZs2YNTZs2rdD+lVdeYeTIkfTr14+jjz6abbfdltdff52HHnqIRx55hEceeaRs/3zPnj0ZNWoUV155Jbvtths/+MEPyvrp27fvBue1ZMkS+vTpwzvvvMNhhx3GKaecwr/+9S/uv/9+Hn74Yf77v/+bI488ssp9JSUlTJkyhaOOOoof//jHvPLKK0ydOpXnnnuOv//972y33XZ1/rd6+umnGTRoEJ988glDhw6lR48eLFy4kD/84Q889NBDTJ8+nZ49ewK5X5YGDRrEM888w8EHH8xZZ51Fw4YNefPNN5kxYwb9+vVjv/32A+C2227j3HPPpUOHDgwZMoR27drx3nvv8dJLL3H33Xfzox/9qM5zLqqUkl8b+ALm9ezZM0mSpK3b9773vQSkiRMnVqkbMmRIAtL9999fofydd95JK1eurNJ+/vz5qXnz5mnw4MEVyhcvXpyAdMYZZ1QoP/XUUxOQ3njjjbKyJ598MgGpW7du6cMPPywr/+yzz9IBBxyQgNS1a9cK/Xz00Udp+fLlVeazdOnStMMOO6S99967QvmaNWsSkA499NAq92xovgMHDkxAuuaaayqUP/XUU6lBgwapXbt26dNPPy0rv/POOxOQGjVqlGbMmFHhnosuuigBaezYsdXOobK//vWvCUhXXnllWdm6detSt27dEpDuu+++Cu3vvffeBKSvf/3raf369Sml3M8HSMcff3yV/teuXVvh3/sb3/hGatq0aXr//fertK2urD569uyZgHmpDpnVlXpJklTYFW029wxq7ooV9br97LPPZvLkyUyYMIHhw4eXlb/99ts88sgj7LDDDgwdOrTCPTvssEO1fe23337069eP6dOns27dOho2bFjr+UycOBGAUaNG0bZt27LyZs2acfXVV3P44YdXuWfbbbettq/OnTtz7LHHcvvtt7Ns2TI6duxY6/mUWrp0KY8//ji77bYbF154YYW6b33rW3zve9/jvvvuo6SkhFNOOaVC/amnnkr//v0rlJ199tlcf/31VbYH1cbMmTNZvHgx3/rWtzjxxBOrjHnLLbfw9NNPM3fuXA4++OCyumbNmlXpq2HDhhX+vSH3bEHpVqXy2rVrV+c5F5t76iVJkoCBAwfStWtXZs+ezYIFC8rKJ06cyNq1axk+fHi1we6hhx7iO9/5DjvuuCPbbLNN2b70Rx99lFWrVvHhhx/WaT6lD+3269evSl3fvn1p0KD6GDdz5kxOOOEEdt55Z5o0aVI2n9IjO9966606zadU6X7zvn37Vvtg78CBAyu0K2///fevUrbzzjsD8NFHH9V5TqX/VqVjb2xO++yzD/vssw9/+MMf+Na3vsV1113H3LlzWbNmTZV7Tz31VFauXMlee+3Fz372M6ZMmcLy5cvrPNdNxZV6SZIkKHsg9Je//CUTJkxg7NixpJT4/e9/X/Bh0d/+9rdceOGFbLfddhx22GF07tyZZs2aERE8+OCDvPzyy6xevbpO81mxIveXh+r+GtC4ceMqq8kA999/PyeddBLNmjXj8MMPp0uXLrRo0YIGDRrw+OOPM3PmzDrPp/K8OnToUG19afm///3vKnXV/SWh9BeDdevWfWlzatSoEU888QSjR4/mz3/+MxdffDEArVu3Zvjw4Vx99dW0aNECgIsvvpj27dtz++23c+ONN3LDDTcQEQwYMIDrrruubJ/+5maolyRJhdVzS0vWnH766Vx22WXcc889jBkzhpkzZ/Laa68xcODAKm9vXbNmDVdccQUdO3Zk/vz5VcL3zJkz6zWXNm1yW5/effdddtlllwp1X3zxBR999FGVkDxq1CiaNm3KvHnz2GOPPSrUvfHGG/WeU/l5vfPOO9XWv/322xXafRnqMqftttuOm266iZtuuonFixfzxBNPMH78eMaNG8fHH39ctv0JYPjw4QwfPpyPPvqIOXPm8OCDDzJx4kSOOOIIFi5cyPbbb78JP13NuP1GkiQpb4cddmDIkCEsX76ckpKSsiMuS19QVd67777LypUr6dOnT5VA//HHH1e7/aQ2SleAn3zyySp1Tz31FOvXr69SvmTJEvbee+8qgX7dunXMnj27SvvSLTy1WSUvPRVm5syZ1d43Y8aMCvP/MpTO6Yknnqi2vrS80Jy6devGWWedxZNPPkmzZs0KvjG4bdu2fOc73+H3v/89w4YNY/ny5cyaNave8y8GQ70kSVI5pWfWjx07lpKSEtq1a8d3v/vdKu06dOhA06ZNee655/j000/Lyr/44gt+8pOf1GuPOOT+agBw5ZVXVtjKsmrVKn71q19Ve0/nzp1ZtGhRhRXrlBKXXXZZtWfBN2jQgLZt2/Kvf/2rxvPaddddGTBgAEuWLOHmm2+uUDd79mz+9Kc/sf3221d5qHhT6tu3L7vvvjtPPPFElUB+3333MWfOHPbcc08OOuggIPfLT/nnJkp99NFHrFmzpsKRpo899hhr166t0C6lxHvvvQdQ5fjTzcXtN5IkSeUMGjSI3Xbbrew0lvPOO4/GjRtXadewYUPOO+88rr/+evbZZx+GDBnC6tWrefzxx1mxYgX9+vWrdpW9pvr27cuPf/xjbr/9dr7+9a9z/PHHl51T/7WvfY327dtXueeCCy7gvPPOY9999+W4446jUaNGzJw5k1dffZXBgwczderUKvcceuihPPDAAwwdOpT99tuPRo0a0b9/f/r06VNwbuPHj6dPnz5ccMEFPProo/Tq1avsnPpGjRoxadKksj3pX4YGDRpw9913M2jQII477jiOOeYY9thjDxYuXMiUKVNo3bo199xzDxEB5B6YPeGEE9h///3Ze++96dChA++99x5Tpkxh7dq1XHLJJWV9H3/88bRq1Yo+ffqw6667sm7dOmbOnMnzzz/PgQceyIABA760z7khrtRLkiSVExGcccYZZd+XrtxXZ8yYMVx77bU0adKE8ePHU1JSQu/evXnuuefo1KlTvedyyy23cOONN9K6dWt+97vfcd9993HUUUcxbdq0ak/iOffcc/n973/PDjvswMSJE/njH//IrrvuyjPPPMN//Md/VDvGzTffzEknncTcuXO58sorGTVqVMFtLKW6devGvHnz+OEPf8iCBQu4/vrreeyxx/jOd77D7NmzGTx4cL0/e20dfPDBPPfcc5x00knMmTOn7ESbU045heeff77CyTu9e/fmF7/4Bdtssw2PPvooY8eO5S9/+QsHHnggjz32GCNGjChre+2119K7d2/mzZvHrbfeyqRJk1i3bh3XXnst06dPr/YEoM0hUu4FSyogIub17Nmz57x58zb3VCRJkrQV69WrF/Pnz5+fUupV23uLtlIfEZ0i4q6IWBYRqyNiaUTcGBFVz1sq3McTEZE28NW0mnvOiIjxEfFMRHyWb3dVsT6XJEmStKUryt8LIqIrMAdoD0wBFgIHAucD346IQ1JKH9Siy9EFytdWUzYWaAN8BCwDutZiHEmSJCnzirUJ6DZygX5ESqnsMeiI+C1wAfAb4Ec17SyldEUtxj4JWJBSej0ihgMTN9JekiRJ2qrUe/tNRHQBBgFLgVsrVV8OfAoMi4hN8gh0SumxlNLrm6JvSZIkKQuKsVI/MH+dllKq8BaElNLKiJhNLvR/E5hekw4j4kRgN+ALYAHweEqpfu80liRJkrZSxQj1pa8se7VA/WJyob47NQz1wH2Vvn8vIs5NKT1Qh/nVSEQUOt6mx6YaU5IkSSqGYpx+0yZ/XVGgvrR82xr0NQU4GugENCMXqMfk7/1TRBxZj3lKkiRJW6Uv47T8yF83eiB+SumGSkWLgF9FxDLgZuBq4NHiTq9s7GrPA82v4PfcFGNKkiRJxVCMlfrSlfg2BepbV2pXFxPIHWe5b0S0qkc/kiRJ0lanGKF+Uf7avUB9t/y10J77jUopfQ6szH+7SU7RkSRJkrKqGKF+Rv46KCIq9JdfVT8EWAU8XdcBImIPoC25YL+8rv1IkiRJW6N6h/qU0hJgGrArcG6l6tHkVtbvSSl9WloYET0iosKpMhHRJSJ2qtx/RLTj/14odV9Kqbq3ykqSJElfWcV6UPYcYA4wLiIOJXe2fG9gALltN5dWar8gf41yZX2BCRHxJLAE+BDYBTiK3H7954GLKw8cEWcCffLf7p6/Hh0RnfL/vTCldE3dP5okSZK0ZStKqE8pLYmI/YFfA98mF8TfBsYBo1NKH9agm3nAvUAvYF9yD9iuBF4GJgPjU0pfVHNfH+C0SmXfyH8BPAkY6iVJkrTVKtqRlimlN4DTa9g2qil7GRheh3GH1+U+SZIkaWtRjAdlJUmSJG1GhnpJkiQp4wz1kiRJUsYZ6iVJkqSMM9RLkiRJGWeolyRJkjLOUC9JkiRlnKFekiRJyjhDvSRJkpRxhnpJkiQp4wz1kiRJUsYZ6iVJkqSMM9RLkiRJGWeolyRJkjLOUC9JkiRlnKFekiRJyjhDvSRJkpRxhnpJkiQp4wz1kiRJUsYZ6iVJkqSMM9RLkiRJGWeolyRJkjLOUC9JkiRlnKFekiRJyjhDvSRJkpRxhnpJkiQp4wz1kiRJUsYZ6iVJkqSMM9RLkiRJGWeolyRJkjLOUC9JkiRlnKFekiRJyjhDvSRJkpRxhnpJkiQp4wz1kiRJUsYZ6iVJkqSMM9RLkiRJGWeolyRJkjLOUC9JkiRlnKFekiRJyjhDvSRJkpRxhnpJkiQp4wz1kiRJUsYZ6iVJkqSMM9RLkiRJGWeolyRJkjLOUC9JkiRlnKFekiRJyjhDvSRJkpRxhnpJkiQp4wz1kiRJUsYVLdRHRKeIuCsilkXE6ohYGhE3RkTbWvTxRESkDXw1LXDfXhExOSLei4jPI2JRRIyOiGbF+nySJEnSlqpRMTqJiK7AHKA9MAVYCBwInA98OyIOSSl9UIsuRxcoX1vN2L2Bx4FtgAeAN4CBwGXAoRFxaEppdS3GliRJkjKlKKEeuI1coB+RUrq5tDAifgtcAPwG+FFNO0spXVGTdhHREJgINAeGppQeypc3ACYDx+XHv6amY0uSJElZU+/tNxHRBRgELAVurVR9OfApMCwiWtR3rGr0A/YEnioN9AAppfXAxflvfxQRsQnGliRJkrYIxdhTPzB/nZYP02VSSk0hW3UAAB77SURBVCuB2eRW0r9Z0w4j4sSI+EVE/CwijoyIJhsZ+7HKFSml14BXgc5Al5qOLUmSJGVNMbbf7JG/vlqgfjG5lfzuwPQa9nlfpe/fi4hzU0oP1GHs7vmvJRsaMCLmFajqsaH7JEmSpM2tGCv1bfLXFQXqS8u3rUFfU4CjgU5AM3KBekz+3j9FxJGbcGxJkiQpk4r1oOyGlO5nTxtrmFK6oVLRIuBXEbEMuBm4Gnh0E43dq9oOciv4PWsxpiRJkvSlKsZKfelqeJsC9a0rtauLCeSOs9w3Ilp9yWNLkiRJW7RihPpF+Wv3AvXd8tdC+943KqX0ObAy/235U3Q2+diSJEnSlq4YoX5G/joofz58mfyq+iHAKuDpug4QEXsAbckF++Xlqh7PX79dzT1dyIX914HX6jq2JEmStKWrd6hPKS0BpgG7AudWqh5NbmX9npTSp6WFEdEjIiqcKhMRXSJip8r9R0Q7ci+YArgvpVT+rbJPAguAvhExpNw9DYD/J//t71JKG91TL0mSJGVVsR6UPQeYA4yLiEPJBe3ewAByW18urdR+Qf5a/qVQfYEJEfEkueMnPwR2AY4it2f+ef7vhVIApJTWRcTp5FbsH4iIB4B/AYcC+5M7I7/yw7eSJEnSVqUooT6ltCQi9gd+TW4rzFHA28A4YHRK6cMadDMPuBfoBexL7iHXlcDLwGRgfErpi2rGfiYiDiD3V4FBQCtyW25+DVyTUlpdz48nSZIkbdGKdqRlSukN4PQato1qyl4Ghtdx7L8DJ9TlXkmSJCnrivGgrCRJkqTNyFAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkScq4ooX6iOgUEXdFxLKIWB0RSyPixohoW48++0bEuohIEXFVgTYtI+LKiFgQEZ9HxL8jYnpEHFX3TyNJkiRlR1FCfUR0BeYBpwPPAjcArwHnA3MjYvs69NkKuBv4bANttgXmAiOBdcB44AFgH+DhiBhR23ElSZKkrCnWSv1tQHtgRErpmJTSL1JKA8mF+z2A39Shz5uANsCYDbS5AtgbeBDYN6V0fkrpTODrwFLg+ojoVoexJUmSpMyod6iPiC7AIHIh+tZK1ZcDnwLDIqJFLfocSm7VfwSwbANNj81fL0sprS0tTCm9D4wFtgF+VNNxJUmSpCwqxkr9wPx1WkppffmKlNJKYDbQHPhmTTqLiPbAnUBJSunejTTfMX99rZq60rJDazKuJEmSlFXFCPV75K+vFqhfnL92r2F/d5CbV01W2Jfnr7tVU9clf+1Rw3ElSZKkTGpUhD7a5K8rCtSXlm+7sY4i4j+BocCJKaV3azD2VOAs4IqIODmltC7fz/bAz/JtmkREs5TSqo2MPa9Alb8USJIkaYtWjFC/MZG/pg02itgVuBG4P6U0uYZ9X0ZuP/8JwJ4RMZ3cVp+hwEpyJ+c0J3cyjiRJkrRVKkaoL12Jb1OgvnWldoXcBawCzqnpwCmldyLiAHJHWh6dv/cjciv4V5LbV78ipfRFDfrqVV15fgW/Z03nJEmSJH3ZirGnflH+WmjPfOmRkoX23JfqSe5YzPfzL5tKEZGAifn6S/NlJeVvSim9nz/KsktKqXFKaYeU0hnk9tkH8FytP5EkSZKUIcVYqZ+Rvw6KiAblT8DJv0DqEHIr8E9vpJ97yG2Vqawb0Bd4kdwLrl6o4bzOyl//WMP2kiRJUibVO9SnlJZExDRye9vPBW4uVz0aaAGMTyl9WloYET3y9y4s10+1b3+NiOHkQv3DKaWRleoaAM1TSp9UKj8TOJncLwKGekmSJG3VivWg7DnAHGBcRBwKLAB6AwPIbbu5tFL7BflrUD/NgXcj4q/AP/Jl3wIOBJYA300prannGJIkSdIWrRh76kkpLQH2ByaRC/MXAl2BccBBKaUPijFONVYD9wF7Aj/OfzUj9ybbfVNKSzfRuJIkSdIWo2hHWqaU3gBOr2HbGq/Qp5Qmkftlobq6NcAZNe1LkiRJ2hoVZaVekiRJ0uZjqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZVzRQn1EdIqIuyJiWUSsjoilEXFjRLStR599I2JdRKSIuKpAmyYRcW5EPBsRyyPik4hYEBHjIqJz3T+RJEmSlA1FCfUR0RWYB5wOPAvcALwGnA/MjYjt69BnK+Bu4LMNtGkETAduAVoB/y/wO+A94CfASxGxV23HliRJkrKkWCv1twHtgREppWNSSr9IKQ0kF+73AH5Thz5vAtoAYzbQ5rvAIeSC/ddTSj9JKV2UUuoH/Dp//0V1GFuSJEnKjHqH+ojoAgwClgK3Vqq+HPgUGBYRLWrR51Byq/4jgGUbaNolf304pbS+Ut2U/PVrNR1XkiRJyqJirNQPzF+nVQ7WKaWVwGygOfDNmnQWEe2BO4GSlNK9G2n+t/z1yIio/FkG56//W5NxJUmSpKxqVIQ+9shfXy1Qv5jcSn53cttkNuYOcr9s/KgGbR8GHgSOBV6OiP8FvgB6AX2Am8ntt5ckSZK2WsUI9W3y1xUF6kvLt91YRxHxn8BQ4MSU0rsba59SShFxPHAZMAoo/1DsdOC/UkrrNtZPfux5Bap61OR+SZIkaXP5Ms6pj/w1bbBRxK7AjcD9KaXJNeo4oinwJ3IPw54LdCD3S8ZRQGfgqfz+fEmSJGmrVYyV+tKV+DYF6ltXalfIXcAq4JxajP0L4ATg/JTS+HLlj+ZX8F8kd4rOlOpuLi+l1Ku68vwKfs9azEmSJEn6UhVjpX5R/tq9QH23/LXQnvtSPckdi/l+/mVTKSISMDFff2m+rKTcPaUPw86o3FlK6SXgQ6BzXc7JlyRJkrKiGCv1pYF6UEQ0KH8CTv4FUoeQW4F/eiP93EPulJzKugF9ya26zwNeKFfXJH+tcmxlRDTh//5K8MVGxpYkSZIyq96hPqW0JCKmkTvh5lxyJ86UGg20AManlD4tLYyIHvl7F5brZ0R1/UfEcHKh/uGU0shK1TOBvYFfRcTslNLqcnVXkPt8z+WP1pQkSZK2SsVYqYfcPvg5wLiIOBRYAPQGBpDbdnNppfYL8tegfn4DHA0cCiyMiMfI/VXgEODA/H+fX88xJEmSpC1aUU6/SSktAfYHJpEL8xcCXYFxwEEppQ+KMU41475Fbi/+WOBzcm+hPQ/YMT+XnimluZtibEmSJGlLUayVelJKb5AL1TVpW+MV+pTSJHIBvVD9++SOtLyopn1KkiRJW5Mv45x6SZIkSZuQoV6SJEnKOEO9JEmSlHGGekmSJCnjDPWSJElSxhnqJUmSpIwz1EuSJEkZZ6iXJEmSMs5QL0mSJGWcoV6SJEnKOEO9JEmSlHGGekmSJCnjDPWSJElSxhnqJUmSpIwz1EuSJEkZZ6iXJEmSMs5QL0mSJGWcoV6SJEnKOEO9JEmSlHGGekmSJCnjDPWSJElSxhnqJUmSpIwz1EuSJEkZZ6iXJEmSMs5QL0mSJGWcoV6SJEnKOEO9JEmSlHGGekmSJCnjDPWSJElSxhnqJUmSpIwz1EuSJEkZZ6iXJEmSMs5QL0mSJGWcoV6SJEnKOEO9JEmSlHGGekmSJCnjDPWSJElSxhnqJUmSpIwz1EuSJEkZZ6iXJEmSMs5QL0mSJGWcoV6SJEnKOEO9JEmSlHGGekmSJCnjDPWSJElSxhnqJUmSpIwz1EuSJEkZZ6iXJEmSMs5QL0mSJGWcoV6SJEnKOEO9JEmSlHGGekmSJCnjihbqI6JTRNwVEcsiYnVELI2IGyOibT367BsR6yIiRcRV1dRPytdt6Gt6/T6ZJEmStGVrVIxOIqIrMAdoD0wBFgIHAucD346IQ1JKH9Syz1bA3cBnQMsCzUqApQXqhgFdgEdrM64kSZKUNUUJ9cBt5AL9iJTSzaWFEfFb4ALgN8CPatnnTUAbYEz+/ipSSiXkgn0FEbEtcDHwBTCpluNKkiRJmVLv7TcR0QUYRG7F/NZK1ZcDnwLDIqJFLfocCpwOjACW1WFaw4BmwIMppeV1uF+SJEnKjGLsqR+Yv05LKa0vX5FSWgnMBpoD36xJZxHRHrgTKEkp3VvHOZ2Vv95Rx/slSZKkzCjG9ps98tdXC9QvJreS3x2oyUOrd5D7ZaO223UAiIiDgH2AV1NKM2px37wCVT3qMg9JkiTpy1KMUN8mf11RoL60fNuNdRQR/wkMBU5MKb1bx/mcnb/eWcf7JUmSpEwp1oOyGxL5a9pgo4hdgRuB+1NKk+s0UEQb4HvU4QHZlFKvAn3OA3rWZT6SJEnSl6EYe+pLV+LbFKhvXaldIXcBq4Bz6jGX75Pbv+8DspIkSfrKKEaoX5S/di9Q3y1/LbTnvlRPcsdivl/+5VHAxHz9pfmyKkdYllP6gOz4jU1akiRJ2loUY/tN6cOogyKiQfkTcPIvkDqE3Ar80xvp5x5yq+yVdQP6Ai8C84AXqrs5InoD/0HuAdknavMBJEmSpCyrd6hPKS2JiGnkTrg5F7i5XPVooAUwPqX0aWlhRPTI37uwXD8jqus/IoaTC/UPp5RGbmAqpQ/IeoylJEmSvlKK9aDsOcAcYFxEHAosAHoDA8htu7m0UvsF+WtQBBHRGjiR3AOydxejT0mSJCkrirGnnpTSEmB/cifO9AYuBLoC44CDUkofFGOcDTiV3F8EfEBWkiRJXzlFO9IypfQGcHoN29Z4hT6lNImNHE+ZUroduL2mfUqSJElbk6Ks1EuSJEnafAz1kiRJUsYZ6iVJkqSMM9RLkiRJGWeolyRJkjLOUC9JkiRlnKFekiRJyjhDvSRJkpRxhnpJkiQp4wz1kiRJUsYZ6iVJkqSMM9RLkiRJGWeolyRJkjLOUC9JkiRlnKFekiRJyjhDvSRJkpRxhnpJkiQp4wz1kiRJUsYZ6iVJkqSMM9RLkiRJGWeolyRJkjLOUC9JkiRlnKFekiRJyjhDvSRJkpRxhnpJkiQp4wz1kiRJUsYZ6iVJkqSMM9RLkiRJGWeolyRJkjLOUC9JkiRlnKFekiRJyjhDvSRJkpRxhnpJkiQp4wz1kiRJUsYZ6iVJkqSMM9RLkiRJGWeolyRJkjLOUC9JkiRlnKFekiRJyjhDvSRJkpRxhnpJkiQp4wz1kiRJUsYZ6iVJkqSMM9RLkiRJGWeolyRJkjLOUC9JkiRlnKFekiRJyjhDvSRJkpRxhnpJkiQp4wz1kiRJUsYZ6iVJkqSMK1qoj4hOEXFXRCyLiNURsTQiboyItvXos29ErIuIFBFXbaBdRMRpEfFERHwYEasi4p8RMTkiutd1fEmSJCkLGhWjk4joCswB2gNTgIXAgcD5wLcj4pCU0ge17LMVcDfwGdByA+2aAvcDg4FFwH8BK4GOwLeA7sCrtfxIkiRJUmYUJdQDt5EL9CNSSjeXFkbEb4ELgN8AP6plnzcBbYAx+fsLGUsu0I8BRqaU1pevjIhtajmuJEmSlCn13n4TEV2AQcBS4NZK1ZcDnwLDIqJFLfocCpwOjACWbaBdV3K/LDwHXFo50AOklNbUdFxJkiQpi4qxp35g/jqtcqhOKa0EZgPNgW/WpLOIaA/cCZSklO7dSPOTyX2Gu4HWEfH9iPhlRJwdEbvX5kNIkiRJWVWM7Td75K+F9q0vJreS3x2YXoP+7iAX1GuyXeeA/LUNsATYvlxdiojbyW0JWrexjiJiXoGqHjWYhyRJkrTZFGOlvk3+uqJAfWn5thvrKCL+ExgKnJNSercGY7fPX38NPA/sA7QCDiUX8s8BRtWgH0mSJCmzivWg7IZE/po22ChiV+BG4P6U0uQa9t0wf30b+G5KaVX++8cj4nhgPvCziLg6pfTFhjpKKfUqMK95QM8azkeSJEn60hVjpb50Jb5NgfrWldoVchewitzqek19lL8+Vi7QA5BSegn4J7mV+z1r0ackSZKUKcUI9Yvy10IveeqWv27srPie5LbTvJ9/2VSKiARMzNdfmi8rqWbsfxfoszT0N9vI2JIkSVJmFWP7zYz8dVBENCh/Ak7+BVKHkFuBf3oj/dxD7pScyroBfYEXgXnAC+XqpgM/AfaufFNENOH/fqFYutFPIUmSJGVUvUN9SmlJREwjd8LNucDN5apHAy2A8SmlT0sLI6JH/t6F5foZUV3/ETGcXKh/OKU0slL1o8BrwBERcXhK6a/l6kaR2xL0ZErpnTp+PEmSJGmLV6wHZc8B5gDjIuJQYAHQGxhAbtvNpZXaL8hfg3pIKX0REacB04BHI+K/gdfJHXXZF3gfOLs+Y0iSJElbumLsqSeltATYH5hELsxfCHQFxgEHpZQ+KMY4BcaelR/7z0A/cm+h7ULuvPueKaWN7eWXJEmSMq1oR1qmlN4ATq9h2xqv0KeUJpH7ZWFDbf4OnFjTPiVJkqStSVFW6iVJkiRtPoZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcYZ6SZIkKeMM9ZIkSVLGGeolSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4Q70kSZKUcZFS2txz2KJFxAfNmjXbbs8999zcU5EkSdJWbMGCBaxaterDlNL2tb3XUL8REfFPoDWwdDNP5augR/66cLPOQpuaP+evBn/OXw3+nLd+/oy/XLsCH6eUdqvtjYZ6bTEiYh5ASqnX5p6LNh1/zl8N/py/Gvw5b/38GWeHe+olSZKkjDPUS5IkSRlnqJckSZIyzlAvSZIkZZyhXpIkSco4T7+RJEmSMs6VekmSJCnjDPWSJElSxhnqJUmSpIwz1EuSJEkZZ6iXJEmSMs5QL0mSJGWcoV6SJEnKOEO9NrmIODgiHomIDyPis4j4/yLipxHRsA597RURkyPivYj4PCIWRcToiGhWw/t/HxEp/7V77T+NCtlcP+eI6BYRl0TE4xHxRkR8ERHvRsSUiBhQnE/31RERnSLirohYFhGrI2JpRNwYEW1r2c92+fuW5vtZlu+306YeWxu3OX7OEbF9RJwZEf8dEf+IiFURsSIiZkXEGRFhJimyzfm/50r3Dyv3/71n1u3TaGN8+ZQ2qYgYCvwZ+Bz4E/AhcDSwB/BASumEWvTVG3gc2AZ4AHgDGAjsD8wGDk0prd7A/UcDDwGfAC2Bbimlf9ThY6mSzflzjoj7gBOBvwOz8mPvAQwBGgLnp5TG1fMjfiVERFdgDtAemAIsBA4EBgCLgENSSh/UoJ/t8/10J/ezfA7oAQwF3vv/27u/WDnKMo7j3+dQBaS1pISgiVipFop4AYaIVEKbNl4ZK0IwXPCvBBIStGJMxJCg9cKkibamgaCm1bZQGxUTvbFpUcK2gZAQSEggGg4UgQsx2kCQIAXhPF487ynTyezO7J5Z3zN7fp/kzcLM7PPuzHN2++zM7PsCl7r7C+PoW+rlyrOZ3Qr8FHgFeBh4GTgLuBJYSnyGXO0qTFqR8/1cev7ZwNPE5/Fi4BZ33zn6nklf7q6mNpYGfJh4w78NXFxYfgrxAeHANQ1jnUQUbQ5sKCyfIgo/B7474PlnAv8Afg300vafyn2MJqHlzjNwI3BRRaw1wDvpdX0093HqQgMOpmP8jdLybWn5zxrG+Xnafltp+aa0/MC4+labv3kmvpx/GZgqLf8IUeA7cFXu4zMpLef7ubCNAX8GjgA/StvfnPvYTGrL/gLUJrcBN6U38J6KdevSukMNY/XdHliR1r1IuvpUsc3vU1F/hor6yc1zxXMeVKHQOI+zx/dvFUXXEuIK15vAaTVxTgP+k7ZfUlo3leI7sKLtvtXmd55r4t2Ztr879zGahDZf8gx8E5gBLgc2o6J+rE33r8k4rUuPByrWHSY+KFab2clzieVx2W8aWE58kJ3AzG4ErgBudV2+H4d5kec+/pse3224/UI2e+wfdPeZ4gp3f4O49elDwOdr4lwKnAo8mp5XjDNDfNGCuAWg7b6lXs48D6L3aruy59nMzge2ANvd/fDQeyBDU1Ev43Reepwur3D3d4lv+ItoVqD1jZU8lx7PLS40s+XAdmCvu/+hQT8yvOx5rpJyv574UqF/UOq1dexHidNa3qVWzjxXMrNFwPXpf6tODsjwsuY55fR+4raqO2v6kJYsyv0CZKItTY+v91k/u/z0ccRKIynsIS4bbmrQh4wma56rpKsCvwJOBr7j7q816HuhayuPo8Rp829IBsuZ5362AJ8B9rv7wQbbS73cef4ecBFwmbu/VdOHtERn6mWgNHyVD9H2DhM+PbYx0kFVrG8RP5a8RUXdYB3P84kbxBCa9wNfIEbi+XEL/Up7eRwlTpt/QzLY/zXPZrYJ+DYxMst1c+xTmhtbns3sc8TZ+a3u/tgc48sQdKZe6hwhhils6u+F/579Br+0akNi1JTidoMMFcvMVgI/BHa5+/4G8Re6Tua5LBX0e4Grgd8C13r6tZbUaiuPo8Rp829IBsuZ5xOY2W3E7ZF/IYaqfbWmT2kuS54Lt91MA3fVv0xpk4p6Gcjd18/h6c8SY4ufCzxZXJHe+OcQP4rqO75tKRb0v/9vZXqcve/vAuLWi41mtrHPc54zM4CvLvT77Tuc53Jf+4iCfh9wvbu/16BPCSMf+xbitNW31MuZ5+PM7HbgJ8AzREH/z5r+ZDi58ry4sO2x9G9s2Q4z20H8gPb2mv5lCJp8SsbGzG4CfgHc5+43lNatAx4CDrv7mgax+m5vZiuIM80vAee4u5vZhcDX+4T7EjEu8gPAv4F73P2poXZOjsuZ58K6DxJn5r8C3AdsLI/4IIOliWqeJ4YM/WTx+JnZEmLCoCngTHd/c0CcxcS8BTPE/ABvFNZNETn8ROrjhTb7lno581xYfwdxH/1TwBfd/WgrOyfH5cqzxazfd/cJ91niPvtHiC8Lf3L334y6j1Ih95iaapPbiMty/2KISYmIIbZWAR8vLR80KdED1Ew+VYrVQ+PUT0yeiSsyf0zrdlIak1ltqFwONVlNyuGqijizk9VsLS3X5FPzoGXO811p3RPAstzHYpJbzjz3eT2b0Tj1Y206Uy9jZWZXEDOBHiNmc30V2EAMk/U74Gte+CM0s7XE9OGH3H1tKdYlxBTVH0jPfZkYsvBiYszd9e7+doPX1CN+QLvS3Z+f0w4KkDfPZraLmFX2KHAv1T/86rl7b847OuEqppX/K3AJMQb1NLDaC3M9mJkDuLuV4pSnlX8cOJ/3p5Vf7e5H5tK3jC5Xns3sBmA38B5xNrfqfu4X3X13C7u54OV8P/d5PZuB7xODV+yc4+5JldzfKtQmvxGjkOwHXgPeAp4mRqY5qWLbtURR1usT69PEGdujxJnhaeAHwKlDvJ4eOlM/MXku5HNQ25z7+HSlAWcDu4jL8+8Qtzttp+Ks6uzx7RNnWXreSynOK8AvgY+10bda9/LM+2dqB7Ve7mMzSS3n+3lA/nWmfkxNZ+pFRERERDpO49SLiIiIiHScinoRERERkY5TUS8iIiIi0nEq6kVEREREOk5FvYiIiIhIx6moFxERERHpOBX1IiIiIiIdp6JeRERERKTjVNSLiIiIiHScinoRERERkY5TUS8iIiIi0nEq6kVEREREOk5FvYiIiIhIx6moFxERERHpOBX1IiIiIiIdp6JeRERERKTjVNSLiIiIiHTc/wB5ngknSgJAUQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 250,
       "width": 378
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_losses, label='Training loss')\n",
    "plt.plot(test_losses, label='Validation loss')\n",
    "plt.legend(frameon=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inference\n",
    "\n",
    "Now that the model is trained, we can use it for inference. We've done this before, but now we need to remember to set the model in inference mode with `model.eval()`. You'll also want to turn off autograd with the `torch.no_grad()` context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.1035, 0.1009, 0.0919, 0.1029, 0.0901, 0.1088, 0.1071, 0.1001, 0.0964,\n",
      "         0.0984]])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x648 with 2 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 216,
       "width": 424
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Import helper module (should be in the repo)\n",
    "import helper\n",
    "\n",
    "# Test out your network!\n",
    "\n",
    "model.eval()\n",
    "\n",
    "dataiter = iter(testloader)\n",
    "images, labels = dataiter.next()\n",
    "img = images[0]\n",
    "# Convert 2D image to 1D vector\n",
    "img = img.view(1, 784)\n",
    "\n",
    "# Calculate the class probabilities (softmax) for img\n",
    "with torch.no_grad():\n",
    "    output = model.forward(img)\n",
    "\n",
    "ps = torch.exp(output)\n",
    "print(ps)\n",
    "# Plot the image and probabilities\n",
    "helper.view_classify(img.view(1, 28, 28), ps, version='Fashion')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next Up!\n",
    "\n",
    "In the next part, I'll show you how to save your trained models. In general, you won't want to train a model everytime you need it. Instead, you'll train once, save it, then load the model when you want to train more or use if for inference."
   ]
  }
 ],
 "metadata": {
  "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}