Part 5 - Inference and Validation (Solution).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": 2,
   "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": 3,
   "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": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1],\n",
      "        [3],\n",
      "        [3],\n",
      "        [3],\n",
      "        [3],\n",
      "        [3],\n",
      "        [1],\n",
      "        [3],\n",
      "        [1],\n",
      "        [1]])\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": 5,
   "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 implement 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": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 7.8125%\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 the  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. 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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/30..  Training Loss: 0.511..  Test Loss: 0.458..  Test Accuracy: 0.828\n",
      "Epoch: 2/30..  Training Loss: 0.394..  Test Loss: 0.409..  Test Accuracy: 0.852\n",
      "Epoch: 3/30..  Training Loss: 0.357..  Test Loss: 0.406..  Test Accuracy: 0.861\n",
      "Epoch: 4/30..  Training Loss: 0.334..  Test Loss: 0.399..  Test Accuracy: 0.858\n",
      "Epoch: 5/30..  Training Loss: 0.315..  Test Loss: 0.394..  Test Accuracy: 0.861\n",
      "Epoch: 6/30..  Training Loss: 0.302..  Test Loss: 0.370..  Test Accuracy: 0.871\n",
      "Epoch: 7/30..  Training Loss: 0.294..  Test Loss: 0.375..  Test Accuracy: 0.869\n",
      "Epoch: 8/30..  Training Loss: 0.284..  Test Loss: 0.359..  Test Accuracy: 0.875\n",
      "Epoch: 9/30..  Training Loss: 0.275..  Test Loss: 0.377..  Test Accuracy: 0.871\n",
      "Epoch: 10/30..  Training Loss: 0.264..  Test Loss: 0.367..  Test Accuracy: 0.876\n",
      "Epoch: 11/30..  Training Loss: 0.264..  Test Loss: 0.369..  Test Accuracy: 0.876\n",
      "Epoch: 12/30..  Training Loss: 0.256..  Test Loss: 0.364..  Test Accuracy: 0.880\n",
      "Epoch: 13/30..  Training Loss: 0.246..  Test Loss: 0.367..  Test Accuracy: 0.879\n",
      "Epoch: 14/30..  Training Loss: 0.241..  Test Loss: 0.379..  Test Accuracy: 0.877\n",
      "Epoch: 15/30..  Training Loss: 0.238..  Test Loss: 0.385..  Test Accuracy: 0.880\n",
      "Epoch: 16/30..  Training Loss: 0.233..  Test Loss: 0.377..  Test Accuracy: 0.877\n",
      "Epoch: 17/30..  Training Loss: 0.231..  Test Loss: 0.444..  Test Accuracy: 0.876\n",
      "Epoch: 18/30..  Training Loss: 0.224..  Test Loss: 0.382..  Test Accuracy: 0.877\n",
      "Epoch: 19/30..  Training Loss: 0.219..  Test Loss: 0.378..  Test Accuracy: 0.885\n",
      "Epoch: 20/30..  Training Loss: 0.214..  Test Loss: 0.389..  Test Accuracy: 0.876\n",
      "Epoch: 21/30..  Training Loss: 0.215..  Test Loss: 0.384..  Test Accuracy: 0.882\n",
      "Epoch: 22/30..  Training Loss: 0.209..  Test Loss: 0.385..  Test Accuracy: 0.877\n",
      "Epoch: 23/30..  Training Loss: 0.207..  Test Loss: 0.385..  Test Accuracy: 0.887\n",
      "Epoch: 24/30..  Training Loss: 0.202..  Test Loss: 0.405..  Test Accuracy: 0.882\n",
      "Epoch: 25/30..  Training Loss: 0.199..  Test Loss: 0.433..  Test Accuracy: 0.878\n",
      "Epoch: 26/30..  Training Loss: 0.203..  Test Loss: 0.394..  Test Accuracy: 0.885\n",
      "Epoch: 27/30..  Training Loss: 0.190..  Test Loss: 0.420..  Test Accuracy: 0.879\n",
      "Epoch: 28/30..  Training Loss: 0.191..  Test Loss: 0.417..  Test Accuracy: 0.878\n",
      "Epoch: 29/30..  Training Loss: 0.196..  Test Loss: 0.427..  Test Accuracy: 0.880\n",
      "Epoch: 30/30..  Training Loss: 0.182..  Test Loss: 0.424..  Test Accuracy: 0.882\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": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x20dabffe4c8>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 248,
       "width": 380
      },
      "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": [
    "## 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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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",
    "            model.eval()\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",
    "        model.train()\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(train_losses[-1]),\n",
    "              \"Test Loss: {:.3f}.. \".format(test_losses[-1]),\n",
    "              \"Test Accuracy: {:.3f}\".format(accuracy/len(testloader)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1226ff908>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 250,
       "width": 380
      },
      "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": 17,
   "metadata": {},
   "outputs": [
    {
     "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",
    "\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
}