Image Classifier Project.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",
    "import torchvision\n",
    "from torchvision import datasets, transforms, models\n",
    "import json\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch import optim\n",
    "from collections import OrderedDict\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "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": {},
   "outputs": [],
   "source": [
    "# TODO: Define your transforms for the training, validation, and testing sets\n",
    "data_transforms_train = transforms.Compose([transforms.RandomRotation(30),\n",
    "                                    transforms.RandomResizedCrop(224),\n",
    "                                    transforms.RandomHorizontalFlip(),\n",
    "                                    transforms.ToTensor(),\n",
    "                                    transforms.Normalize([0.485,0.456,0.406],[0.229, 0.224, 0.225])])\n",
    "\n",
    "data_transforms_validation = transforms.Compose([transforms.Resize(255),\n",
    "                                                transforms.CenterCrop(244),\n",
    "                                                transforms.ToTensor(),\n",
    "                                                transforms.Normalize([0.485,0.456,0.406],[0.229, 0.224, 0.225])])\n",
    "\n",
    "data_transforms_test = transforms.Compose([transforms.Resize(255),\n",
    "                                                transforms.CenterCrop(244),\n",
    "                                                transforms.ToTensor(),\n",
    "                                                transforms.Normalize([0.485,0.456,0.406],[0.229, 0.224, 0.225])])\n",
    "\n",
    "# TODO: Load the datasets with ImageFolder\n",
    "image_train = datasets.ImageFolder(train_dir, transform=data_transforms_train)\n",
    "image_validation = datasets.ImageFolder(valid_dir, transform=data_transforms_validation)\n",
    "image_test = datasets.ImageFolder(test_dir, transform=data_transforms_test)\n",
    "\n",
    "\n",
    "# TODO: Using the image datasets and the trainforms, define the dataloaders\n",
    "train_dataloaders = torch.utils.data.DataLoader(image_train, batch_size=32, shuffle=True)\n",
    "validation_dataloaders = torch.utils.data.DataLoader(image_validation, batch_size=32)\n",
    "test_dataloaders  = torch.utils.data.DataLoader(image_test, batch_size=32)\n",
    "\n",
    "\n",
    "image_datasets = [image_train, image_validation, image_test]\n",
    "dataloaders = [train_dataloaders, validation_dataloaders, test_dataloaders]"
   ]
  },
  {
   "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": [],
   "source": [
    "import json\n",
    "\n",
    "with open('cat_to_name.json', 'r') as f:\n",
    "    cat_to_name = json.load(f)"
   ]
  },
  {
   "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. 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.\n",
    "\n",
    "One last important tip if you're using the workspace to run your code: To avoid having your workspace disconnect during the long-running tasks in this notebook, please read in the earlier page in this lesson called Intro to\n",
    "GPU Workspaces about Keeping Your Session Active. You'll want to include code from the workspace_utils.py module.\n",
    "\n",
    "**Note for Workspace users:** If your network is over 1 GB when saved as a checkpoint, there might be issues with saving backups in your workspace. Typically this happens with wide dense layers after the convolutional layers. If your saved checkpoint is larger than 1 GB (you can open a terminal and check with `ls -lh`), you should reduce the size of your hidden layers and train again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading: \"https://download.pytorch.org/models/vgg19-dcbb9e9d.pth\" to /root/.torch/models/vgg19-dcbb9e9d.pth\n",
      "100%|██████████| 574673361/574673361 [00:05<00:00, 111721228.28it/s]\n"
     ]
    }
   ],
   "source": [
    "# TODO: Build network\n",
    "model = models.vgg19(pretrained = True)\n",
    "\n",
    "for param in model.parameters():\n",
    "    param.requires_grad = False\n",
    "    \n",
    "\n",
    "classifier = nn.Sequential(OrderedDict([\n",
    "                          ('fc1', nn.Linear(25088, 1024)),\n",
    "                          ('drop', nn.Dropout(p=0.3)),\n",
    "                          ('relu', nn.ReLU()),\n",
    "                          ('fc2', nn.Linear(1024, 102)),\n",
    "                          ('output', nn.LogSoftmax(dim=1))\n",
    "                          ]))\n",
    "    \n",
    "model.classifier = classifier\n",
    "\n",
    "criterion = nn.NLLLoss()\n",
    "optimizer = optim.SGD(model.classifier.parameters(), lr=0.01)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10.. Train loss: 3.294.. Validation loss: 1.899.. Validation accuracy: 0.532\n",
      "Epoch 2/10.. Train loss: 1.816.. Validation loss: 1.133.. Validation accuracy: 0.745\n",
      "Epoch 3/10.. Train loss: 1.310.. Validation loss: 0.806.. Validation accuracy: 0.809\n",
      "Epoch 4/10.. Train loss: 1.094.. Validation loss: 0.669.. Validation accuracy: 0.834\n",
      "Epoch 5/10.. Train loss: 0.937.. Validation loss: 0.610.. Validation accuracy: 0.851\n",
      "Epoch 6/10.. Train loss: 0.857.. Validation loss: 0.534.. Validation accuracy: 0.864\n",
      "Epoch 7/10.. Train loss: 0.772.. Validation loss: 0.495.. Validation accuracy: 0.867\n",
      "Epoch 8/10.. Train loss: 0.717.. Validation loss: 0.437.. Validation accuracy: 0.885\n",
      "Epoch 9/10.. Train loss: 0.692.. Validation loss: 0.446.. Validation accuracy: 0.885\n",
      "Epoch 10/10.. Train loss: 0.630.. Validation loss: 0.414.. Validation accuracy: 0.884\n"
     ]
    }
   ],
   "source": [
    "device ='cuda'\n",
    "\n",
    "model.to(device);\n",
    "\n",
    "epochs = 10\n",
    "running_loss = 0\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    for inputs, labels in dataloaders[0]:\n",
    "        # Move input and label tensors to the default device\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        logps = model.forward(inputs)\n",
    "        loss = criterion(logps, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        running_loss += loss.item()\n",
    "        \n",
    "        \n",
    "    validation_loss = 0\n",
    "    accuracy = 0\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        for inputs, labels in dataloaders[1]:\n",
    "            inputs, labels = inputs.to(device), labels.to(device)\n",
    "            logps = model.forward(inputs)\n",
    "            batch_loss = criterion(logps, labels)\n",
    "               \n",
    "            validation_loss += batch_loss.item()\n",
    "                    \n",
    "            # Calculate accuracy\n",
    "            ps = torch.exp(logps)\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)).item()\n",
    "                    \n",
    "    print(f\"Epoch {epoch+1}/{epochs}.. \"\n",
    "        f\"Train loss: {running_loss/len(dataloaders[0]):.3f}.. \"\n",
    "        f\"Validation loss: {validation_loss/len(dataloaders[1]):.3f}.. \"\n",
    "        f\"Validation accuracy: {accuracy/len(dataloaders[1]):.3f}\")\n",
    "    running_loss = 0\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": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.884\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): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (3): ReLU(inplace)\n",
       "    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (6): ReLU(inplace)\n",
       "    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (8): ReLU(inplace)\n",
       "    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (11): ReLU(inplace)\n",
       "    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (13): ReLU(inplace)\n",
       "    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (15): ReLU(inplace)\n",
       "    (16): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (17): ReLU(inplace)\n",
       "    (18): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (19): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (20): ReLU(inplace)\n",
       "    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (22): ReLU(inplace)\n",
       "    (23): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (24): ReLU(inplace)\n",
       "    (25): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (26): ReLU(inplace)\n",
       "    (27): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (29): ReLU(inplace)\n",
       "    (30): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (31): ReLU(inplace)\n",
       "    (32): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (33): ReLU(inplace)\n",
       "    (34): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (35): ReLU(inplace)\n",
       "    (36): 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=1024, bias=True)\n",
       "    (drop): Dropout(p=0.3)\n",
       "    (relu): ReLU()\n",
       "    (fc2): Linear(in_features=1024, out_features=102, bias=True)\n",
       "    (output): LogSoftmax()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TODO: Do validation on the test set\n",
    "model.eval()\n",
    "test_accuracy = 0\n",
    "with torch.no_grad():\n",
    "    for inputs, labels in dataloaders[2]:\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "        logps = model.forward(inputs)\n",
    "                           \n",
    "        # Calculate accuracy\n",
    "        ps = torch.exp(logps)\n",
    "        top_p, top_class = ps.topk(1, dim=1)\n",
    "        equals = top_class == labels.view(*top_class.shape)\n",
    "        test_accuracy += torch.mean(equals.type(torch.FloatTensor)).item()\n",
    "                    \n",
    "print(f\"Test accuracy: {accuracy/len(dataloaders[2]):.3f}\")\n",
    "model.train()"
   ]
  },
  {
   "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": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Save the checkpoint \n",
    "model.class_to_idx = image_datasets[0].class_to_idx\n",
    "\n",
    "checkpoint = {'input_size': 25088,\n",
    "              'output_size': 102,\n",
    "              'arch': 'vgg19',\n",
    "              'learning_rate': 0.01,\n",
    "              'classifier' : classifier,\n",
    "              'epochs': epochs,\n",
    "              'optimizer': optimizer.state_dict(),\n",
    "              'state_dict': model.state_dict(),\n",
    "              'class_to_idx': model.class_to_idx}\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "torch.save(checkpoint, 'flower_classifier_model.pth')"
   ]
  },
  {
   "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": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (3): ReLU(inplace)\n",
      "    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (6): ReLU(inplace)\n",
      "    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (8): ReLU(inplace)\n",
      "    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (11): ReLU(inplace)\n",
      "    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (13): ReLU(inplace)\n",
      "    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (15): ReLU(inplace)\n",
      "    (16): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (17): ReLU(inplace)\n",
      "    (18): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (19): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (20): ReLU(inplace)\n",
      "    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (22): ReLU(inplace)\n",
      "    (23): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (24): ReLU(inplace)\n",
      "    (25): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (26): ReLU(inplace)\n",
      "    (27): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (29): ReLU(inplace)\n",
      "    (30): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (31): ReLU(inplace)\n",
      "    (32): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (33): ReLU(inplace)\n",
      "    (34): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (35): ReLU(inplace)\n",
      "    (36): 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=1024, bias=True)\n",
      "    (drop): Dropout(p=0.3)\n",
      "    (relu): ReLU()\n",
      "    (fc2): Linear(in_features=1024, out_features=102, bias=True)\n",
      "    (output): LogSoftmax()\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# TODO: Write a function that loads a checkpoint and rebuilds the model\n",
    "def load_checkpoint(filepath):\n",
    "    checkpoint = torch.load(filepath)\n",
    "    model = getattr(torchvision.models, checkpoint['arch'])(pretrained=True)\n",
    "    model.classifier = checkpoint['classifier']\n",
    "    model.epochs = checkpoint['epochs']\n",
    "    model.load_state_dict(checkpoint['state_dict'])\n",
    "    model.class_to_idx = checkpoint['class_to_idx']\n",
    "    optimizer.load_state_dict(checkpoint['optimizer'])\n",
    "    return model, optimizer\n",
    "\n",
    "\n",
    "model, optimizer = load_checkpoint('flower_classifier_model.pth')\n",
    "print(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": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_image(image):\n",
    "    ''' Scales, crops, and normalizes a PIL image for a PyTorch model,\n",
    "        returns an Numpy array\n",
    "    '''\n",
    "    # TODO: Process a PIL image for use in a PyTorch model\n",
    "    img = Image.open(image)\n",
    "    # Resize the images where the shortest side is 256 pixels, keeping the aspect ratio\n",
    "    img_width, img_height = img.size\n",
    "    aspect_ratio = img_width / img_height\n",
    "    if aspect_ratio > 1:\n",
    "        img = img.resize((round(aspect_ratio * 256), 256))\n",
    "    else:\n",
    "        img = img.resize((256, round(256 / aspect_ratio)))\n",
    "    \n",
    "    \n",
    "    old_width, old_height = img.size\n",
    "    new_width = 224\n",
    "    new_height = 224\n",
    "    left = (old_width - new_width)/2\n",
    "    top = (old_height - new_height)/2\n",
    "    right = (old_width + new_width)/2\n",
    "    bottom = (old_height + new_height)/2\n",
    "    img_crop = img.crop((round(left), round(top), round(right), round(bottom)))\n",
    "    \n",
    "    np_image = np.array(img_crop)\n",
    "    \n",
    "    np_image_0 = np.array(np_image) / 255\n",
    "\n",
    "    np_image_norm = (np_image_0 - np.array([0.485, 0.456, 0.406])) / np.array([0.229, 0.224, 0.225])\n",
    "    np_image_out =  np_image_norm.transpose((2, 0, 1))\n",
    "            \n",
    "    return np_image_out\n",
    "\n"
   ]
  },
  {
   "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": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "def imshow(image, ax=None, title=None):\n",
    "    \"\"\"Imshow for Tensor.\"\"\"\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f2ab44dbbe0>"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2ab44db470>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "pil_image = './flowers/valid/1/image_06739.jpg'\n",
    "np_image = process_image(pil_image)\n",
    "imshow(np_image)\n",
    "\n"
   ]
  },
  {
   "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": 115,
   "metadata": {},
   "outputs": [],
   "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",
    "    \n",
    "    # TODO: Implement the code to predict the class from an image file\n",
    "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "    \n",
    "    \n",
    "    np_image = process_image(image_path)\n",
    "\n",
    "    model.to(device)\n",
    "    model.eval()\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        images = torch.from_numpy(np_image)\n",
    "        images = images.unsqueeze(0)\n",
    "        images = images.type(torch.FloatTensor)\n",
    "        images = images.to(device) # Move input tensors to the GPU/CPU\n",
    "\n",
    "        output = model.forward(images)\n",
    "        ps = torch.exp(output) # get the class probabilities from log-softmax\n",
    "\n",
    "        #top_p, top_class = ps.topk(5, dim=1)\n",
    "        top_p = torch.topk(ps, topk)[0].tolist()[0]\n",
    "        top_class = torch.topk(ps, topk)[1].tolist()[0]\n",
    "        inv_map = {v: k for k, v in model.class_to_idx.items()}\n",
    "        classes = [inv_map[int(index)] for index in top_class]\n",
    "        \n",
    "    return top_p, classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "probs:  [0.7480573654174805, 0.08748809248209, 0.085265152156353, 0.0390377901494503, 0.019353235140442848]\n",
      "classes:  ['1', '52', '51', '86', '89']\n"
     ]
    }
   ],
   "source": [
    "pil_image = './flowers/valid/1/image_06739.jpg'\n",
    "probs, classes = predict(pil_image, model, topk=5)\n",
    "print(\"probs: \", probs) \n",
    "print(\"classes: \", 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": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2aa8f8aac8>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Display an image along with the top 5 classes\n",
    "probs, classes = predict(pil_image , model)\n",
    "label_index = classes[np.argmax(probs)]\n",
    "y_pos = np.arange(5)\n",
    "labels = [cat_to_name[class1] for class1 in classes]\n",
    "\n",
    "f, plots = plt.subplots(2,1)\n",
    "image = Image.open(pil_image)\n",
    "plots[0].imshow(image)\n",
    "plots[0].axis('off')\n",
    "plots[0].set_title(cat_to_name[label_index])\n",
    "\n",
    "plots[1].barh(y_pos, probs, align='center', color='blue')\n",
    "plots[1].set_yticks(y_pos)\n",
    "plots[1].set_yticklabels(labels)\n",
    "plots[1].invert_yaxis()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}