{
 "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": 2,
   "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, 0.5), (0.5, 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": 4,
   "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": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([64, 10])\n"
     ]
    }
   ],
   "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)"
   ]
  },
  {
   "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": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 9],\n",
      "        [ 9],\n",
      "        [ 9],\n",
      "        [ 9],\n",
      "        [ 9],\n",
      "        [ 9],\n",
      "        [ 9],\n",
      "        [ 9],\n",
      "        [ 7],\n",
      "        [ 9]])\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": 16,
   "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": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 18.75%\n"
     ]
    }
   ],
   "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": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1 out of 30\n",
      "Training Loss: 0.511\n",
      "Test Loss: 0.462\n",
      "Test Accuracy: 0.833\n",
      "Epoch: 2 out of 30\n",
      "Training Loss: 0.389\n",
      "Test Loss: 0.415\n",
      "Test Accuracy: 0.854\n",
      "Epoch: 3 out of 30\n",
      "Training Loss: 0.353\n",
      "Test Loss: 0.387\n",
      "Test Accuracy: 0.861\n",
      "Epoch: 4 out of 30\n",
      "Training Loss: 0.331\n",
      "Test Loss: 0.375\n",
      "Test Accuracy: 0.867\n",
      "Epoch: 5 out of 30\n",
      "Training Loss: 0.313\n",
      "Test Loss: 0.374\n",
      "Test Accuracy: 0.868\n",
      "Epoch: 6 out of 30\n",
      "Training Loss: 0.301\n",
      "Test Loss: 0.374\n",
      "Test Accuracy: 0.866\n",
      "Epoch: 7 out of 30\n",
      "Training Loss: 0.293\n",
      "Test Loss: 0.381\n",
      "Test Accuracy: 0.866\n",
      "Epoch: 8 out of 30\n",
      "Training Loss: 0.282\n",
      "Test Loss: 0.381\n",
      "Test Accuracy: 0.869\n",
      "Epoch: 9 out of 30\n",
      "Training Loss: 0.274\n",
      "Test Loss: 0.370\n",
      "Test Accuracy: 0.873\n",
      "Epoch: 10 out of 30\n",
      "Training Loss: 0.268\n",
      "Test Loss: 0.402\n",
      "Test Accuracy: 0.864\n",
      "Epoch: 11 out of 30\n",
      "Training Loss: 0.261\n",
      "Test Loss: 0.368\n",
      "Test Accuracy: 0.878\n",
      "Epoch: 12 out of 30\n",
      "Training Loss: 0.254\n",
      "Test Loss: 0.367\n",
      "Test Accuracy: 0.877\n",
      "Epoch: 13 out of 30\n",
      "Training Loss: 0.246\n",
      "Test Loss: 0.387\n",
      "Test Accuracy: 0.873\n",
      "Epoch: 14 out of 30\n",
      "Training Loss: 0.242\n",
      "Test Loss: 0.387\n",
      "Test Accuracy: 0.880\n",
      "Epoch: 15 out of 30\n",
      "Training Loss: 0.236\n",
      "Test Loss: 0.374\n",
      "Test Accuracy: 0.879\n",
      "Epoch: 16 out of 30\n",
      "Training Loss: 0.227\n",
      "Test Loss: 0.366\n",
      "Test Accuracy: 0.883\n",
      "Epoch: 17 out of 30\n",
      "Training Loss: 0.228\n",
      "Test Loss: 0.382\n",
      "Test Accuracy: 0.879\n",
      "Epoch: 18 out of 30\n",
      "Training Loss: 0.229\n",
      "Test Loss: 0.370\n",
      "Test Accuracy: 0.885\n",
      "Epoch: 19 out of 30\n",
      "Training Loss: 0.219\n",
      "Test Loss: 0.376\n",
      "Test Accuracy: 0.882\n",
      "Epoch: 20 out of 30\n",
      "Training Loss: 0.212\n",
      "Test Loss: 0.372\n",
      "Test Accuracy: 0.882\n",
      "Epoch: 21 out of 30\n",
      "Training Loss: 0.212\n",
      "Test Loss: 0.384\n",
      "Test Accuracy: 0.878\n",
      "Epoch: 22 out of 30\n",
      "Training Loss: 0.206\n",
      "Test Loss: 0.405\n",
      "Test Accuracy: 0.882\n",
      "Epoch: 23 out of 30\n",
      "Training Loss: 0.210\n",
      "Test Loss: 0.376\n",
      "Test Accuracy: 0.888\n",
      "Epoch: 24 out of 30\n",
      "Training Loss: 0.199\n",
      "Test Loss: 0.406\n",
      "Test Accuracy: 0.884\n",
      "Epoch: 25 out of 30\n",
      "Training Loss: 0.212\n",
      "Test Loss: 0.382\n",
      "Test Accuracy: 0.885\n",
      "Epoch: 26 out of 30\n",
      "Training Loss: 0.195\n",
      "Test Loss: 0.377\n",
      "Test Accuracy: 0.885\n",
      "Epoch: 27 out of 30\n",
      "Training Loss: 0.201\n",
      "Test Loss: 0.411\n",
      "Test Accuracy: 0.881\n",
      "Epoch: 28 out of 30\n",
      "Training Loss: 0.185\n",
      "Test Loss: 0.405\n",
      "Test Accuracy: 0.883\n",
      "Epoch: 29 out of 30\n",
      "Training Loss: 0.185\n",
      "Test Loss: 0.409\n",
      "Test Accuracy: 0.887\n",
      "Epoch: 30 out of 30\n",
      "Training Loss: 0.186\n",
      "Test Loss: 0.377\n",
      "Test Accuracy: 0.888\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",
    "trainLosses, testLosses = [], []\n",
    "for e in range(epochs):\n",
    "    runningLoss = 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",
    "        runningLoss += loss.item()\n",
    "        \n",
    "    else:\n",
    "        ## TODO: Implement the validation pass and print out the validation accuracy\n",
    "        testLoss = 0\n",
    "        accuracy = 0\n",
    "        \n",
    "        # Turn off gradients for validation step\n",
    "        with torch.no_grad():\n",
    "            for images, labels in testloader:\n",
    "                # Get the output\n",
    "                log_ps = model(images)\n",
    "                # Get the loss\n",
    "                testLoss += criterion(log_ps, labels)\n",
    "                \n",
    "                # Get the probabilities\n",
    "                ps = torch.exp(log_ps)\n",
    "                # Get the most likely class for each prediction\n",
    "                top_p, top_class = ps.topk(1, dim=1)\n",
    "                # Check if the predictions match the actual label\n",
    "                equals = top_class == labels.view(*top_class.shape)\n",
    "                # Update accuracy\n",
    "                accuracy += torch.mean(equals.type(torch.FloatTensor))\n",
    "        \n",
    "        # Update train loss\n",
    "        trainLosses.append(runningLoss/len(trainloader))\n",
    "        # Update test loss\n",
    "        testLosses.append(testLoss/len(testloader))\n",
    "        \n",
    "        # Print output\n",
    "        print(f'Epoch: {e+1} out of {epochs}')\n",
    "        print(f'Training Loss: {runningLoss/len(trainloader):.3f}')\n",
    "        print(f'Test Loss: {testLoss/len(testloader):.3f}')\n",
    "        print(f'Test Accuracy: {accuracy/len(testloader):.3f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f0884bc8978>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f088ce9e4a8>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 250,
       "width": 380
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(trainLosses, label='Training loss')\n",
    "plt.plot(testLosses, label='Validation loss')\n",
    "plt.legend(frameon=False)"
   ]
  },
  {
   "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": 32,
   "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",
    "        # Dropout module with 0.2 prob\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",
    "        # Apply dropout to inputs\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 does not need dropout\n",
    "        x = F.log_softmax(self.fc4(x), dim=1)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1 out of 30\n",
      "Training Loss: 0.615\n",
      "Test Loss: 0.459\n",
      "Test Accuracy: 0.836\n",
      "Epoch: 2 out of 30\n",
      "Training Loss: 0.484\n",
      "Test Loss: 0.455\n",
      "Test Accuracy: 0.844\n",
      "Epoch: 3 out of 30\n",
      "Training Loss: 0.455\n",
      "Test Loss: 0.419\n",
      "Test Accuracy: 0.846\n",
      "Epoch: 4 out of 30\n",
      "Training Loss: 0.436\n",
      "Test Loss: 0.409\n",
      "Test Accuracy: 0.856\n",
      "Epoch: 5 out of 30\n",
      "Training Loss: 0.416\n",
      "Test Loss: 0.400\n",
      "Test Accuracy: 0.857\n",
      "Epoch: 6 out of 30\n",
      "Training Loss: 0.414\n",
      "Test Loss: 0.414\n",
      "Test Accuracy: 0.853\n",
      "Epoch: 7 out of 30\n",
      "Training Loss: 0.406\n",
      "Test Loss: 0.424\n",
      "Test Accuracy: 0.853\n",
      "Epoch: 8 out of 30\n",
      "Training Loss: 0.408\n",
      "Test Loss: 0.398\n",
      "Test Accuracy: 0.866\n",
      "Epoch: 9 out of 30\n",
      "Training Loss: 0.395\n",
      "Test Loss: 0.395\n",
      "Test Accuracy: 0.868\n",
      "Epoch: 10 out of 30\n",
      "Training Loss: 0.387\n",
      "Test Loss: 0.396\n",
      "Test Accuracy: 0.854\n",
      "Epoch: 11 out of 30\n",
      "Training Loss: 0.384\n",
      "Test Loss: 0.409\n",
      "Test Accuracy: 0.862\n",
      "Epoch: 12 out of 30\n",
      "Training Loss: 0.380\n",
      "Test Loss: 0.394\n",
      "Test Accuracy: 0.864\n",
      "Epoch: 13 out of 30\n",
      "Training Loss: 0.382\n",
      "Test Loss: 0.377\n",
      "Test Accuracy: 0.870\n",
      "Epoch: 14 out of 30\n",
      "Training Loss: 0.372\n",
      "Test Loss: 0.387\n",
      "Test Accuracy: 0.869\n",
      "Epoch: 15 out of 30\n",
      "Training Loss: 0.382\n",
      "Test Loss: 0.387\n",
      "Test Accuracy: 0.867\n",
      "Epoch: 16 out of 30\n",
      "Training Loss: 0.374\n",
      "Test Loss: 0.402\n",
      "Test Accuracy: 0.861\n",
      "Epoch: 17 out of 30\n",
      "Training Loss: 0.368\n",
      "Test Loss: 0.389\n",
      "Test Accuracy: 0.870\n",
      "Epoch: 18 out of 30\n",
      "Training Loss: 0.368\n",
      "Test Loss: 0.367\n",
      "Test Accuracy: 0.869\n",
      "Epoch: 19 out of 30\n",
      "Training Loss: 0.363\n",
      "Test Loss: 0.382\n",
      "Test Accuracy: 0.871\n",
      "Epoch: 20 out of 30\n",
      "Training Loss: 0.361\n",
      "Test Loss: 0.414\n",
      "Test Accuracy: 0.863\n",
      "Epoch: 21 out of 30\n",
      "Training Loss: 0.368\n",
      "Test Loss: 0.386\n",
      "Test Accuracy: 0.866\n",
      "Epoch: 22 out of 30\n",
      "Training Loss: 0.358\n",
      "Test Loss: 0.380\n",
      "Test Accuracy: 0.876\n",
      "Epoch: 23 out of 30\n",
      "Training Loss: 0.351\n",
      "Test Loss: 0.383\n",
      "Test Accuracy: 0.866\n",
      "Epoch: 24 out of 30\n",
      "Training Loss: 0.353\n",
      "Test Loss: 0.389\n",
      "Test Accuracy: 0.868\n",
      "Epoch: 25 out of 30\n",
      "Training Loss: 0.351\n",
      "Test Loss: 0.379\n",
      "Test Accuracy: 0.864\n",
      "Epoch: 26 out of 30\n",
      "Training Loss: 0.354\n",
      "Test Loss: 0.385\n",
      "Test Accuracy: 0.873\n",
      "Epoch: 27 out of 30\n",
      "Training Loss: 0.350\n",
      "Test Loss: 0.385\n",
      "Test Accuracy: 0.871\n",
      "Epoch: 28 out of 30\n",
      "Training Loss: 0.350\n",
      "Test Loss: 0.370\n",
      "Test Accuracy: 0.876\n",
      "Epoch: 29 out of 30\n",
      "Training Loss: 0.346\n",
      "Test Loss: 0.387\n",
      "Test Accuracy: 0.869\n",
      "Epoch: 30 out of 30\n",
      "Training Loss: 0.338\n",
      "Test Loss: 0.391\n",
      "Test Accuracy: 0.872\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",
    "trainLosses, testLosses = [], []\n",
    "for e in range(epochs):\n",
    "    runningLoss = 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",
    "        runningLoss += loss.item()\n",
    "        \n",
    "    else:\n",
    "        ## TODO: Implement the validation pass and print out the validation accuracy\n",
    "        testLoss = 0\n",
    "        accuracy = 0\n",
    "        \n",
    "        # Turn off gradients for validation step\n",
    "        with torch.no_grad():\n",
    "            \n",
    "            # Set model to evaluation mode\n",
    "            model.eval()\n",
    "            \n",
    "            for images, labels in testloader:\n",
    "                # Get the output\n",
    "                log_ps = model(images)\n",
    "                # Get the loss\n",
    "                testLoss += criterion(log_ps, labels)\n",
    "                \n",
    "                # Get the probabilities\n",
    "                ps = torch.exp(log_ps)\n",
    "                # Get the most likely class for each prediction\n",
    "                top_p, top_class = ps.topk(1, dim=1)\n",
    "                # Check if the predictions match the actual label\n",
    "                equals = top_class == labels.view(*top_class.shape)\n",
    "                # Update accuracy\n",
    "                accuracy += torch.mean(equals.type(torch.FloatTensor))\n",
    "        \n",
    "        # Update train loss\n",
    "        trainLosses.append(runningLoss/len(trainloader))\n",
    "        # Update test loss\n",
    "        testLosses.append(testLoss/len(testloader))\n",
    "        \n",
    "        # Set model back to train mode\n",
    "        model.train()\n",
    "        \n",
    "        # Print output\n",
    "        print(f'Epoch: {e+1} out of {epochs}')\n",
    "        print(f'Training Loss: {runningLoss/len(trainloader):.3f}')\n",
    "        print(f'Test Loss: {testLoss/len(testloader):.3f}')\n",
    "        print(f'Test Accuracy: {accuracy/len(testloader):.3f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f0884912780>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0884af76d8>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 250,
       "width": 380
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(trainLosses, label='Training loss')\n",
    "plt.plot(testLosses, 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": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,\n",
      "          0.0000,  1.0000,  0.0000]])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f08845dc940>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 204,
       "width": 423
      },
      "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",
    "\n",
    "# Plot the image and probabilities\n",
    "helper.view_classify(img.view(1, 28, 28), ps, version='Fashion')\n",
    "\n",
    "print(ps)"
   ]
  },
  {
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}