Image Classifier Project Take 6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Developing an AI application\n",
    "\n",
    "Going forward, AI algorithms will be incorporated into more and more everyday applications. For example, you might want to include an image classifier in a smart phone app. To do this, you'd use a deep learning model trained on hundreds of thousands of images as part of the overall application architecture. A large part of software development in the future will be using these types of models as common parts of applications. \n",
    "\n",
    "In this project, you'll train an image classifier to recognize different species of flowers. You can imagine using something like this in a phone app that tells you the name of the flower your camera is looking at. In practice you'd train this classifier, then export it for use in your application. We'll be using [this dataset](http://www.robots.ox.ac.uk/~vgg/data/flowers/102/index.html) of 102 flower categories, you can see a few examples below. \n",
    "\n",
    "<img src='assets/Flowers.png' width=500px>\n",
    "\n",
    "The project is broken down into multiple steps:\n",
    "\n",
    "* Load and preprocess the image dataset\n",
    "* Train the image classifier on your dataset\n",
    "* Use the trained classifier to predict image content\n",
    "\n",
    "We'll lead you through each part which you'll implement in Python.\n",
    "\n",
    "When you've completed this project, you'll have an application that can be trained on any set of labeled images. Here your network will be learning about flowers and end up as a command line application. But, what you do with your new skills depends on your imagination and effort in building a dataset. For example, imagine an app where you take a picture of a car, it tells you what the make and model is, then looks up information about it. Go build your own dataset and make something new.\n",
    "\n",
    "First up is importing the packages you'll need. It's good practice to keep all the imports at the beginning of your code. As you work through this notebook and find you need to import a package, make sure to add the import up here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports here\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "import numpy as np\n",
    "# PyTorch stuff...\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch import optim\n",
    "\n",
    "# For deep copy of object/variable\n",
    "import copy\n",
    "# For label mapping\n",
    "import json\n",
    "# To display elapsed time between each epoch\n",
    "import time\n",
    "# For ordered dictionary\n",
    "from collections import OrderedDict\n",
    "\n",
    "# for the sanity check at the end of this...\n",
    "import matplotlib.pyplot as plt\n",
    "# for plotting\n",
    "import seaborn as sb\n",
    "\n",
    "# for image processing\n",
    "from PIL import Image\n",
    "import glob, os\n",
    "\n",
    "\n",
    "\n",
    "from torchvision import datasets, transforms, models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the data\n",
    "\n",
    "Here you'll use `torchvision` to load the data ([documentation](http://pytorch.org/docs/0.3.0/torchvision/index.html)). The data should be included alongside this notebook, otherwise you can [download it here](https://s3.amazonaws.com/content.udacity-data.com/nd089/flower_data.tar.gz). The dataset is split into three parts, training, validation, and testing. For the training, you'll want to apply transformations such as random scaling, cropping, and flipping. This will help the network generalize leading to better performance. You'll also need to make sure the input data is resized to 224x224 pixels as required by the pre-trained networks.\n",
    "\n",
    "The validation and testing sets are used to measure the model's performance on data it hasn't seen yet. For this you don't want any scaling or rotation transformations, but you'll need to resize then crop the images to the appropriate size.\n",
    "\n",
    "The pre-trained networks you'll use were trained on the ImageNet dataset where each color channel was normalized separately. For all three sets you'll need to normalize the means and standard deviations of the images to what the network expects. For the means, it's `[0.485, 0.456, 0.406]` and for the standard deviations `[0.229, 0.224, 0.225]`, calculated from the ImageNet images.  These values will shift each color channel to be centered at 0 and range from -1 to 1.\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = 'flowers'\n",
    "train_dir = data_dir + '/train'\n",
    "valid_dir = data_dir + '/valid'\n",
    "test_dir = data_dir + '/test'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset ImageFolder\n",
      "    Number of datapoints: 819\n",
      "    Root Location: flowers/test\n",
      "    Transforms (if any): Compose(\n",
      "                             Resize(size=256, interpolation=PIL.Image.BILINEAR)\n",
      "                             CenterCrop(size=(224, 224))\n",
      "                             ToTensor()\n",
      "                             Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
      "                         )\n",
      "    Target Transforms (if any): None\n",
      "<torch.utils.data.dataloader.DataLoader object at 0x7fa345643c50>\n"
     ]
    }
   ],
   "source": [
    "# DONE: Define your transforms for the training, validation, and testing sets\n",
    "## Train\n",
    "train_transforms = transforms.Compose([transforms.RandomRotation(30),\n",
    "                                       transforms.RandomResizedCrop(224),\n",
    "                                       transforms.RandomHorizontalFlip(),\n",
    "                                       transforms.ToTensor(),\n",
    "                                       transforms.Normalize([0.485, 0.456, 0.406], \n",
    "                                                            [0.229, 0.224, 0.225])])\n",
    "## Test\n",
    "test_transforms = transforms.Compose([transforms.Resize(256),\n",
    "                                      transforms.CenterCrop(224),\n",
    "                                      transforms.ToTensor(),\n",
    "                                      transforms.Normalize([0.485, 0.456, 0.406], \n",
    "                                                           [0.229, 0.224, 0.225])])\n",
    "\n",
    "# Valid - I'm assuming valid and test use the same deal... so, just copying it.\n",
    "valid_transforms = transforms.Compose([transforms.Resize(256),\n",
    "                                       transforms.CenterCrop(224),\n",
    "                                       transforms.ToTensor(),\n",
    "                                       transforms.Normalize([0.485, 0.456, 0.406], \n",
    "                                                            [0.229, 0.224, 0.225])])\n",
    "\n",
    "# DONE: Load the datasets with ImageFolder\n",
    "train_data = datasets.ImageFolder(train_dir, transform=train_transforms)\n",
    "test_data = datasets.ImageFolder(test_dir, transform=test_transforms)\n",
    "valid_data = datasets.ImageFolder(valid_dir, transform=valid_transforms)\n",
    "\n",
    "# TODO: Using the image datasets and the trainforms, define the dataloaders\n",
    "train_loader = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(test_data, batch_size=64)\n",
    "valid_loader = torch.utils.data.DataLoader(valid_data, batch_size=64)\n",
    "print(test_data)\n",
    "print(test_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Label mapping\n",
    "\n",
    "You'll also need to load in a mapping from category label to category name. You can find this in the file `cat_to_name.json`. It's a JSON object which you can read in with the [`json` module](https://docs.python.org/2/library/json.html). This will give you a dictionary mapping the integer encoded categories to the actual names of the flowers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'21': 'fire lily', '3': 'canterbury bells', '45': 'bolero deep blue', '1': 'pink primrose', '34': 'mexican aster', '27': 'prince of wales feathers', '7': 'moon orchid', '16': 'globe-flower', '25': 'grape hyacinth', '26': 'corn poppy', '79': 'toad lily', '39': 'siam tulip', '24': 'red ginger', '67': 'spring crocus', '35': 'alpine sea holly', '32': 'garden phlox', '10': 'globe thistle', '6': 'tiger lily', '93': 'ball moss', '33': 'love in the mist', '9': 'monkshood', '102': 'blackberry lily', '14': 'spear thistle', '19': 'balloon flower', '100': 'blanket flower', '13': 'king protea', '49': 'oxeye daisy', '15': 'yellow iris', '61': 'cautleya spicata', '31': 'carnation', '64': 'silverbush', '68': 'bearded iris', '63': 'black-eyed susan', '69': 'windflower', '62': 'japanese anemone', '20': 'giant white arum lily', '38': 'great masterwort', '4': 'sweet pea', '86': 'tree mallow', '101': 'trumpet creeper', '42': 'daffodil', '22': 'pincushion flower', '2': 'hard-leaved pocket orchid', '54': 'sunflower', '66': 'osteospermum', '70': 'tree poppy', '85': 'desert-rose', '99': 'bromelia', '87': 'magnolia', '5': 'english marigold', '92': 'bee balm', '28': 'stemless gentian', '97': 'mallow', '57': 'gaura', '40': 'lenten rose', '47': 'marigold', '59': 'orange dahlia', '48': 'buttercup', '55': 'pelargonium', '36': 'ruby-lipped cattleya', '91': 'hippeastrum', '29': 'artichoke', '71': 'gazania', '90': 'canna lily', '18': 'peruvian lily', '98': 'mexican petunia', '8': 'bird of paradise', '30': 'sweet william', '17': 'purple coneflower', '52': 'wild pansy', '84': 'columbine', '12': \"colt's foot\", '11': 'snapdragon', '96': 'camellia', '23': 'fritillary', '50': 'common dandelion', '44': 'poinsettia', '53': 'primula', '72': 'azalea', '65': 'californian poppy', '80': 'anthurium', '76': 'morning glory', '37': 'cape flower', '56': 'bishop of llandaff', '60': 'pink-yellow dahlia', '82': 'clematis', '58': 'geranium', '75': 'thorn apple', '41': 'barbeton daisy', '95': 'bougainvillea', '43': 'sword lily', '83': 'hibiscus', '78': 'lotus lotus', '88': 'cyclamen', '94': 'foxglove', '81': 'frangipani', '74': 'rose', '89': 'watercress', '73': 'water lily', '46': 'wallflower', '77': 'passion flower', '51': 'petunia'}\n"
     ]
    }
   ],
   "source": [
    "with open('cat_to_name.json', 'r') as f:\n",
    "    cat_to_name = json.load(f)\n",
    "print(cat_to_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building and training the classifier\n",
    "\n",
    "Now that the data is ready, it's time to build and train the classifier. As usual, you should use one of the pretrained models from `torchvision.models` to get the image features. Build and train a new feed-forward classifier using those features.\n",
    "\n",
    "We're going to leave this part up to you. If you want to talk through it with someone, chat with your fellow students! You can also ask questions on the forums or join the instructors in office hours.\n",
    "\n",
    "Refer to [the rubric](https://review.udacity.com/#!/rubrics/1663/view) for guidance on successfully completing this section. Things you'll need to do:\n",
    "\n",
    "* Load a [pre-trained network](http://pytorch.org/docs/master/torchvision/models.html) (If you need a starting point, the VGG networks work great and are straightforward to use)\n",
    "* Define a new, untrained feed-forward network as a classifier, using ReLU activations and dropout\n",
    "* Train the classifier layers using backpropagation using the pre-trained network to get the features\n",
    "* Track the loss and accuracy on the validation set to determine the best hyperparameters\n",
    "\n",
    "We've left a cell open for you below, but use as many as you need. Our advice is to break the problem up into smaller parts you can run separately. Check that each part is doing what you expect, then move on to the next. You'll likely find that as you work through each part, you'll need to go back and modify your previous code. This is totally normal!\n",
    "\n",
    "When training make sure you're updating only the weights of the feed-forward network. You should be able to get the validation accuracy above 70% if you build everything right. Make sure to try different hyperparameters (learning rate, units in the classifier, epochs, etc) to find the best model. Save those hyperparameters to use as default values in the next part of the project."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading: \"https://download.pytorch.org/models/vgg11-bbd30ac9.pth\" to /root/.torch/models/vgg11-bbd30ac9.pth\n",
      "100%|██████████| 531456000/531456000 [00:06<00:00, 86776048.18it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "VGG(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (1): ReLU(inplace)\n",
       "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (3): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (4): ReLU(inplace)\n",
       "    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (6): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (7): ReLU(inplace)\n",
       "    (8): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (9): ReLU(inplace)\n",
       "    (10): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (11): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (12): ReLU(inplace)\n",
       "    (13): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (14): ReLU(inplace)\n",
       "    (15): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (16): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (17): ReLU(inplace)\n",
       "    (18): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (19): ReLU(inplace)\n",
       "    (20): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (classifier): Sequential(\n",
       "    (fc1): Linear(in_features=25088, out_features=4096, bias=True)\n",
       "    (relu1): ReLU()\n",
       "    (dropout1): Dropout(p=0.335)\n",
       "    (output): Linear(in_features=4096, out_features=102, bias=True)\n",
       "    (softmax): LogSoftmax()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TODO: Build network\n",
    "# 1. Load a pre-trained network (If you need a starting point, \n",
    "#    the VGG networks work great and are straightforward to use)\n",
    "#model = models.vgg11(pretrained=True)\n",
    "\n",
    "input_size=25088\n",
    "hidden_sizes=[4096]\n",
    "output_size=102\n",
    "dropout_rate=0.335\n",
    "\n",
    "model = models.vgg11(pretrained=True)\n",
    "for param in model.parameters():\n",
    "    param.requires_grad = False\n",
    "classifier = nn.Sequential(OrderedDict([\n",
    "    ('fc1', nn.Linear(input_size, hidden_sizes[0])),\n",
    "    ('relu1', nn.ReLU()),\n",
    "    ('dropout1', nn.Dropout(p=dropout_rate)),\n",
    "    #('fc2', nn.Linear(hidden_sizes[0], hidden_sizes[1])),\n",
    "    #('relu2', nn.ReLU()),\n",
    "    #('dropout2', nn.Dropout(p=dropout_rate)),\n",
    "    ('output', nn.Linear(hidden_sizes[0], output_size)),\n",
    "    ('softmax', nn.LogSoftmax(dim=1))\n",
    "]))\n",
    "model.classifier=classifier\n",
    "\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train the network\n",
    "criterion = nn.NLLLoss()\n",
    "optimizer = optim.Adam(model.classifier.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "device is:  cuda\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "VGG(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (1): ReLU(inplace)\n",
       "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (3): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (4): ReLU(inplace)\n",
       "    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (6): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (7): ReLU(inplace)\n",
       "    (8): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (9): ReLU(inplace)\n",
       "    (10): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (11): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (12): ReLU(inplace)\n",
       "    (13): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (14): ReLU(inplace)\n",
       "    (15): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (16): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (17): ReLU(inplace)\n",
       "    (18): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (19): ReLU(inplace)\n",
       "    (20): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (classifier): Sequential(\n",
       "    (fc1): Linear(in_features=25088, out_features=4096, bias=True)\n",
       "    (relu1): ReLU()\n",
       "    (dropout1): Dropout(p=0.335)\n",
       "    (output): Linear(in_features=4096, out_features=102, bias=True)\n",
       "    (softmax): LogSoftmax()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') \n",
    "print('device is: ', device)\n",
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Do validation on the test set\n",
    "# Implement a function for the validation pass\n",
    "def validation(model, valid_loader, criterion):\n",
    "    test_loss = 0\n",
    "    accuracy = 0\n",
    "    for images, labels in valid_loader:\n",
    "        images = images.to(device)\n",
    "        labels = labels.to(device)\n",
    "        output = model.forward(images)\n",
    "        test_loss += criterion(output, labels).item()\n",
    "        ps = torch.exp(output)\n",
    "        equality = (labels.data == ps.max(dim=1)[1])\n",
    "        accuracy += equality.type(torch.FloatTensor).mean()\n",
    "    return test_loss, accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/3...  Loss: 4.0116 Test Loss: 1.433.. Test Accuracy: 0.613\n",
      "Epoch: 1/3...  Loss: 1.7549 Test Loss: 0.833.. Test Accuracy: 0.780\n",
      "Epoch: 2/3...  Loss: 1.2975 Test Loss: 0.627.. Test Accuracy: 0.824\n",
      "Epoch: 2/3...  Loss: 1.0814 Test Loss: 0.630.. Test Accuracy: 0.817\n",
      "Epoch: 2/3...  Loss: 1.1192 Test Loss: 0.510.. Test Accuracy: 0.853\n",
      "Epoch: 3/3...  Loss: 0.9998 Test Loss: 0.498.. Test Accuracy: 0.855\n",
      "Epoch: 3/3...  Loss: 0.9801 Test Loss: 0.494.. Test Accuracy: 0.855\n"
     ]
    }
   ],
   "source": [
    "# put the training network through a loop\n",
    "epochs=3\n",
    "print_every=40 ## should be 40, but setting to 10 to get something quicker for now\n",
    "running_loss = 0\n",
    "steps=0\n",
    "for e in range(epochs):\n",
    "    #print('In epoch {}'.format(e+1))\n",
    "    #running_loss = 0\n",
    "    model.train()\n",
    "    for ii, (inputs, labels) in enumerate(train_loader):\n",
    "        steps += 1\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "        #print('In step {}'.format(steps))\n",
    "        #images.resize_(images.size()[0], input_size)\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        #print('optimizer.zero_grad() ....done')\n",
    "        output = model.forward(inputs)\n",
    "        #print('output = model.forward(inputs) ....done')\n",
    "        loss = criterion(output, labels)\n",
    "        #print('loss = criterion(output, labels) ....done')\n",
    "        loss.backward()\n",
    "        #print('loss.backward() ....done')\n",
    "        optimizer.step()\n",
    "        #print('optimizer.step() ....done')\n",
    "        \n",
    "        running_loss += loss.item()\n",
    "        #print('running_loss += loss.item() ...done')\n",
    "        if steps % print_every == 0:\n",
    "            model.eval()\n",
    "            \n",
    "            with torch.no_grad():\n",
    "                test_loss, accuracy = validation(model, valid_loader, criterion)\n",
    "                \n",
    "            print('Epoch: {}/{}... '.format(e+1, epochs), \n",
    "                  'Loss: {:.4f}'.format(running_loss/print_every),\n",
    "                  'Test Loss: {:.3f}..'.format(test_loss/len(test_loader)),\n",
    "                  'Test Accuracy: {:.3f}'.format(accuracy/len(test_loader)))\n",
    "            running_loss = 0\n",
    "            \n",
    "            model.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing your network\n",
    "\n",
    "It's good practice to test your trained network on test data, images the network has never seen either in training or validation. This will give you a good estimate for the model's performance on completely new images. Run the test images through the network and measure the accuracy, the same way you did validation. You should be able to reach around 70% accuracy on the test set if the model has been trained well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing the network\n",
      "Accuracy of the network on the test images: 82 %\n"
     ]
    }
   ],
   "source": [
    "print('Testing the network')\n",
    "model.to(device)\n",
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for data in test_loader:\n",
    "        images, labels = data\n",
    "        images, labels = images.to(device), labels.to(device)\n",
    "        outputs = model(images)\n",
    "        ##\n",
    "        # Returns the maximum value of each row of the input tensor \n",
    "        # in the given dimension dim. The second return value is the \n",
    "        # index location of each maximum value found (argmax).\n",
    "        ##\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "print('Accuracy of the network on the test images: %d %%' % (100 * correct / total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save the checkpoint\n",
    "\n",
    "Now that your network is trained, save the model so you can load it later for making predictions. You probably want to save other things such as the mapping of classes to indices which you get from one of the image datasets: `image_datasets['train'].class_to_idx`. You can attach this to the model as an attribute which makes inference easier later on.\n",
    "\n",
    "```model.class_to_idx = image_datasets['train'].class_to_idx```\n",
    "\n",
    "Remember that you'll want to completely rebuild the model later so you can use it for inference. Make sure to include any information you need in the checkpoint. If you want to load the model and keep training, you'll want to save the number of epochs as well as the optimizer state, `optimizer.state_dict`. You'll likely want to use this trained model in the next part of the project, so best to save it now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Save the checkpoint \n",
    "checkpoint_file = 'checkpoint.pth';\n",
    "cp = {\n",
    "    'input_size': input_size, \n",
    "    'output_size': output_size, \n",
    "    'hidden_sizes': hidden_sizes,\n",
    "    'dropout_rate': dropout_rate,\n",
    "    'state_dict': model.state_dict()\n",
    "}\n",
    "torch.save(cp, checkpoint_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the checkpoint\n",
    "\n",
    "At this point it's good to write a function that can load a checkpoint and rebuild the model. That way you can come back to this project and keep working on it without having to retrain the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "VGG(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (1): ReLU(inplace)\n",
       "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (3): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (4): ReLU(inplace)\n",
       "    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (6): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (7): ReLU(inplace)\n",
       "    (8): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (9): ReLU(inplace)\n",
       "    (10): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (11): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (12): ReLU(inplace)\n",
       "    (13): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (14): ReLU(inplace)\n",
       "    (15): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (16): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (17): ReLU(inplace)\n",
       "    (18): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (19): ReLU(inplace)\n",
       "    (20): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (classifier): Sequential(\n",
       "    (fc1): Linear(in_features=25088, out_features=4096, bias=True)\n",
       "    (relu1): ReLU()\n",
       "    (dropout1): Dropout(p=0.335)\n",
       "    (output): Linear(in_features=4096, out_features=102, bias=True)\n",
       "    (softmax): LogSoftmax()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TODO: Write a function that loads a checkpoint and rebuilds the model\n",
    "def load_checkpoint(filepath):\n",
    "    checkpoint = torch.load(filepath)\n",
    "    tmp_model = models.vgg11(pretrained=True)\n",
    "    for param in tmp_model.parameters():\n",
    "        param.requires_grad = False\n",
    "    classifier = nn.Sequential(OrderedDict([\n",
    "        ('fc1', nn.Linear(checkpoint['input_size'], checkpoint['hidden_sizes'][0])),\n",
    "        ('relu1', nn.ReLU()),\n",
    "        ('dropout1', nn.Dropout(checkpoint['dropout_rate'])),\n",
    "        ('output', nn.Linear(checkpoint['hidden_sizes'][0], checkpoint['output_size'])),\n",
    "        ('softmax', nn.LogSoftmax(dim=1))\n",
    "    ]))\n",
    "    tmp_model.classifier=classifier\n",
    "    return tmp_model\n",
    "\n",
    "model = load_checkpoint(checkpoint_file)\n",
    "# see if the model matches up\n",
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inference for classification\n",
    "\n",
    "Now you'll write a function to use a trained network for inference. That is, you'll pass an image into the network and predict the class of the flower in the image. Write a function called `predict` that takes an image and a model, then returns the top $K$ most likely classes along with the probabilities. It should look like \n",
    "\n",
    "```python\n",
    "probs, classes = predict(image_path, model)\n",
    "print(probs)\n",
    "print(classes)\n",
    "> [ 0.01558163  0.01541934  0.01452626  0.01443549  0.01407339]\n",
    "> ['70', '3', '45', '62', '55']\n",
    "```\n",
    "\n",
    "First you'll need to handle processing the input image such that it can be used in your network. \n",
    "\n",
    "## Image Preprocessing\n",
    "\n",
    "You'll want to use `PIL` to load the image ([documentation](https://pillow.readthedocs.io/en/latest/reference/Image.html)). It's best to write a function that preprocesses the image so it can be used as input for the model. This function should process the images in the same manner used for training. \n",
    "\n",
    "First, resize the images where the shortest side is 256 pixels, keeping the aspect ratio. This can be done with the [`thumbnail`](http://pillow.readthedocs.io/en/3.1.x/reference/Image.html#PIL.Image.Image.thumbnail) or [`resize`](http://pillow.readthedocs.io/en/3.1.x/reference/Image.html#PIL.Image.Image.thumbnail) methods. Then you'll need to crop out the center 224x224 portion of the image.\n",
    "\n",
    "Color channels of images are typically encoded as integers 0-255, but the model expected floats 0-1. You'll need to convert the values. It's easiest with a Numpy array, which you can get from a PIL image like so `np_image = np.array(pil_image)`.\n",
    "\n",
    "As before, the network expects the images to be normalized in a specific way. For the means, it's `[0.485, 0.456, 0.406]` and for the standard deviations `[0.229, 0.224, 0.225]`. You'll want to subtract the means from each color channel, then divide by the standard deviation. \n",
    "\n",
    "And finally, PyTorch expects the color channel to be the first dimension but it's the third dimension in the PIL image and Numpy array. You can reorder dimensions using [`ndarray.transpose`](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.ndarray.transpose.html). The color channel needs to be first and retain the order of the other two dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(213, 256)\n",
      "<PIL.Image.Image image mode=RGB size=224x224 at 0x7FA3253EAA58>\n",
      "[[[-2.11790393 -2.11790393 -2.11790393 ..., -2.11790393 -2.11790393\n",
      "   -2.11790393]\n",
      "  [-2.11790393 -2.11790393 -2.11790393 ..., -2.11790393 -2.11790393\n",
      "   -2.11790393]\n",
      "  [-2.11790393 -2.11790393 -2.11790393 ..., -2.11790393 -2.11790393\n",
      "   -2.11790393]\n",
      "  ..., \n",
      "  [-2.11790393 -2.11790393 -2.11790393 ..., -2.11790393 -2.11790393\n",
      "   -2.11790393]\n",
      "  [-2.11790393 -2.11790393 -2.11790393 ..., -2.11790393 -2.11790393\n",
      "   -2.11790393]\n",
      "  [-2.11790393 -2.11790393 -2.11790393 ..., -2.11790393 -2.11790393\n",
      "   -2.11790393]]\n",
      "\n",
      " [[-2.03571429 -2.03571429 -2.03571429 ..., -2.03571429 -2.03571429\n",
      "   -2.03571429]\n",
      "  [-2.03571429 -2.03571429 -2.03571429 ..., -2.03571429 -2.03571429\n",
      "   -2.03571429]\n",
      "  [-2.03571429 -2.03571429 -2.03571429 ..., -2.03571429 -2.03571429\n",
      "   -2.03571429]\n",
      "  ..., \n",
      "  [-2.03571429 -2.03571429 -2.03571429 ..., -2.03571429 -2.03571429\n",
      "   -2.03571429]\n",
      "  [-2.03571429 -2.03571429 -2.03571429 ..., -2.03571429 -2.03571429\n",
      "   -2.03571429]\n",
      "  [-2.03571429 -2.03571429 -2.03571429 ..., -2.03571429 -2.03571429\n",
      "   -2.03571429]]\n",
      "\n",
      " [[-1.80444444 -1.80444444 -1.80444444 ..., -1.80444444 -1.80444444\n",
      "   -1.80444444]\n",
      "  [-1.80444444 -1.80444444 -1.80444444 ..., -1.80444444 -1.80444444\n",
      "   -1.80444444]\n",
      "  [-1.80444444 -1.80444444 -1.80444444 ..., -1.80444444 -1.80444444\n",
      "   -1.80444444]\n",
      "  ..., \n",
      "  [-1.80444444 -1.80444444 -1.80444444 ..., -1.80444444 -1.80444444\n",
      "   -1.80444444]\n",
      "  [-1.80444444 -1.80444444 -1.80444444 ..., -1.80444444 -1.80444444\n",
      "   -1.80444444]\n",
      "  [-1.80444444 -1.80444444 -1.80444444 ..., -1.80444444 -1.80444444\n",
      "   -1.80444444]]]\n",
      "(179, 256)\n",
      "<PIL.Image.Image image mode=RGB size=224x224 at 0x7FA3253EAD30>\n",
      "[[[-2.11790393 -2.11790393 -2.11790393 ..., -2.11790393 -2.11790393\n",
      "   -2.11790393]\n",
      "  [-2.11790393 -2.11790393 -2.11790393 ..., -2.11790393 -2.11790393\n",
      "   -2.11790393]\n",
      "  [-2.11790393 -2.11790393 -2.11790393 ..., -2.11790393 -2.11790393\n",
      "   -2.11790393]\n",
      "  ..., \n",
      "  [-2.11790393 -2.11790393 -2.11790393 ..., -2.11790393 -2.11790393\n",
      "   -2.11790393]\n",
      "  [-2.11790393 -2.11790393 -2.11790393 ..., -2.11790393 -2.11790393\n",
      "   -2.11790393]\n",
      "  [-2.11790393 -2.11790393 -2.11790393 ..., -2.11790393 -2.11790393\n",
      "   -2.11790393]]\n",
      "\n",
      " [[-2.03571429 -2.03571429 -2.03571429 ..., -2.03571429 -2.03571429\n",
      "   -2.03571429]\n",
      "  [-2.03571429 -2.03571429 -2.03571429 ..., -2.03571429 -2.03571429\n",
      "   -2.03571429]\n",
      "  [-2.03571429 -2.03571429 -2.03571429 ..., -2.03571429 -2.03571429\n",
      "   -2.03571429]\n",
      "  ..., \n",
      "  [-2.03571429 -2.03571429 -2.03571429 ..., -2.03571429 -2.03571429\n",
      "   -2.03571429]\n",
      "  [-2.03571429 -2.03571429 -2.03571429 ..., -2.03571429 -2.03571429\n",
      "   -2.03571429]\n",
      "  [-2.03571429 -2.03571429 -2.03571429 ..., -2.03571429 -2.03571429\n",
      "   -2.03571429]]\n",
      "\n",
      " [[-1.80444444 -1.80444444 -1.80444444 ..., -1.80444444 -1.80444444\n",
      "   -1.80444444]\n",
      "  [-1.80444444 -1.80444444 -1.80444444 ..., -1.80444444 -1.80444444\n",
      "   -1.80444444]\n",
      "  [-1.80444444 -1.80444444 -1.80444444 ..., -1.80444444 -1.80444444\n",
      "   -1.80444444]\n",
      "  ..., \n",
      "  [-1.80444444 -1.80444444 -1.80444444 ..., -1.80444444 -1.80444444\n",
      "   -1.80444444]\n",
      "  [-1.80444444 -1.80444444 -1.80444444 ..., -1.80444444 -1.80444444\n",
      "   -1.80444444]\n",
      "  [-1.80444444 -1.80444444 -1.80444444 ..., -1.80444444 -1.80444444\n",
      "   -1.80444444]]]\n"
     ]
    }
   ],
   "source": [
    "def process_image(image):\n",
    "    ''' Scales, crops, and normalizes a PIL image for a PyTorch model,\n",
    "        returns an Numpy array\n",
    "    '''\n",
    "    img = Image.open(image)\n",
    "    # resize image - use thumbnail\n",
    "    size = 256, 256\n",
    "    img.thumbnail(size)\n",
    "    print(img.size)\n",
    "    width, height = img.size\n",
    "    # crop image - parameter is a box\n",
    "    left = (width - 224)/2\n",
    "    right = (width + 224)/2\n",
    "    top = (height - 224)/2\n",
    "    bottom = (height + 224)/2\n",
    "    img = img.crop(box=(left, top, right, bottom))\n",
    "    print(img)\n",
    "    # color image channels\n",
    "    np_image = np.array(img)/255\n",
    "    # apply mean: [0.485, 0.456, 0.406]\n",
    "    mean = np.array([0.485, 0.456, 0.406])\n",
    "    # apply std: [0.229, 0.224, 0.225]\n",
    "    std = np.array([0.229, 0.224, 0.225])\n",
    "    # subtract the means from each color channel, then divide by the standard deviation\n",
    "    np_image = (np_image - mean)/std\n",
    "    # move the 3rd array element to be first\n",
    "    np_image = np_image.transpose(2,0,1)\n",
    "    # return a numpy array of the image\n",
    "    return np_image\n",
    "\n",
    "# test it...\n",
    "processed_image = process_image(test_dir+\"/1/image_06743.jpg\")\n",
    "# see what it looks like\n",
    "print(processed_image)\n",
    "\n",
    "processed_image = process_image(train_dir+\"/1/image_06744.jpg\")\n",
    "# see what it looks like\n",
    "print(processed_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To check your work, the function below converts a PyTorch tensor and displays it in the notebook. If your `process_image` function works, running the output through this function should return the original image (except for the cropped out portions)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AxesSubplot(0.125,0.125;0.775x0.755)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa325402e48>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 251,
       "width": 259
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def imshow(image, ax=None, title=None):\n",
    "    if ax is None:\n",
    "        fig, ax = plt.subplots()\n",
    "    \n",
    "    # PyTorch tensors assume the color channel is the first dimension\n",
    "    # but matplotlib assumes is the third dimension\n",
    "    image = image.transpose((1, 2, 0))\n",
    "    \n",
    "    # Undo preprocessing\n",
    "    mean = np.array([0.485, 0.456, 0.406])\n",
    "    std = np.array([0.229, 0.224, 0.225])\n",
    "    image = std * image + mean\n",
    "    \n",
    "    # Image needs to be clipped between 0 and 1 or it looks like noise when displayed\n",
    "    image = np.clip(image, 0, 1)\n",
    "    \n",
    "    ax.imshow(image)\n",
    "    \n",
    "    return ax\n",
    "\n",
    "# show the \"processed_image\"... let's see if the imshow function approves of the selected image\n",
    "print(imshow(processed_image))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Prediction\n",
    "\n",
    "Once you can get images in the correct format, it's time to write a function for making predictions with your model. A common practice is to predict the top 5 or so (usually called top-$K$) most probable classes. You'll want to calculate the class probabilities then find the $K$ largest values.\n",
    "\n",
    "To get the top $K$ largest values in a tensor use [`x.topk(k)`](http://pytorch.org/docs/master/torch.html#torch.topk). This method returns both the highest `k` probabilities and the indices of those probabilities corresponding to the classes. You need to convert from these indices to the actual class labels using `class_to_idx` which hopefully you added to the model or from an `ImageFolder` you used to load the data ([see here](#Save-the-checkpoint)). Make sure to invert the dictionary so you get a mapping from index to class as well.\n",
    "\n",
    "Again, this method should take a path to an image and a model checkpoint, then return the probabilities and classes.\n",
    "\n",
    "```python\n",
    "probs, classes = predict(image_path, model)\n",
    "print(probs)\n",
    "print(classes)\n",
    "> [ 0.01558163  0.01541934  0.01452626  0.01443549  0.01407339]\n",
    "> ['70', '3', '45', '62', '55']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(179, 256)\n",
      "<PIL.Image.Image image mode=RGB size=224x224 at 0x7FA3444B76A0>\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'numpy.ndarray' object has no attribute 'to'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-85d050ae302b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     23\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     24\u001b[0m \u001b[0;31m# call predict function here...\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 25\u001b[0;31m \u001b[0mprobs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclasses\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_dir\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;34m\"/1/image_06744.jpg\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mload_checkpoint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcheckpoint_file\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     26\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     27\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprobs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-18-85d050ae302b>\u001b[0m in \u001b[0;36mpredict\u001b[0;34m(image_path, model, topk)\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprocess_image\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimage_path\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m     \u001b[0mimg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0;31m# underscore forces change on object?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'to'"
     ]
    }
   ],
   "source": [
    "def predict(image_path, model, topk=5):\n",
    "    ''' Predict the class (or classes) of an image using a trained deep learning model.\n",
    "    '''\n",
    "    model.eval()\n",
    "    img = process_image(image_path)\n",
    "    img.to(device)\n",
    "    print(img)\n",
    "    # underscore forces change on object?\n",
    "    img.unsqueeze_(0)\n",
    "    # examples of topk usage:\n",
    "    # https://www.programcreek.com/python/example/101209/torch.topk\n",
    "    # convert image to tensor\n",
    "    img_as_tensor = torch.from_numpy(np.array(img)).float()\n",
    "    # use x.topk(k) to get the K largest values \n",
    "    # convert to labels using:\n",
    "    # model.class_to_idx = image_datasets['train'].class_to_idx\n",
    "    probability_object = model.forward(img.float(), dim=1)\n",
    "    probabilities, classes = torch.exp(probability_object).topk(topk)\n",
    "    # TODO: Implement the code to predict the class from an image file\n",
    "    probabilities = probabilities.detach().numpy()[0]\n",
    "    classes = classes.numpy()[0]\n",
    "    return probabilities, classes\n",
    "    \n",
    "# call predict function here...\n",
    "probs, classes = predict(train_dir+\"/1/image_06744.jpg\", load_checkpoint(checkpoint_file)) \n",
    "\n",
    "print(probs)\n",
    "print(classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sanity Checking\n",
    "\n",
    "Now that you can use a trained model for predictions, check to make sure it makes sense. Even if the testing accuracy is high, it's always good to check that there aren't obvious bugs. Use `matplotlib` to plot the probabilities for the top 5 classes as a bar graph, along with the input image. It should look like this:\n",
    "\n",
    "<img src='assets/inference_example.png' width=300px>\n",
    "\n",
    "You can convert from the class integer encoding to actual flower names with the `cat_to_name.json` file (should have been loaded earlier in the notebook). To show a PyTorch tensor as an image, use the `imshow` function defined above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Display an image along with the top 5 classes\n",
    "\n",
    "## change the color to be a common color\n",
    "#base_color = sb.color_palette()[0]"
   ]
  }
 ],
 "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
}