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 torch\n",
    "import torchvision\n",
    "from torch import nn, optim\n",
    "from torchvision import transforms\n",
    "from torchvision.datasets import ImageFolder\n",
    "from torch.utils import data\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "import os, random\n",
    "import json\n",
    "import signal\n",
    "\n",
    "from contextlib import contextmanager\n",
    "\n",
    "import requests\n",
    "\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "%config IPCompleter.greedy=True"
   ]
  },
  {
   "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",
    "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], [0.229, 0.224, 0.225])\n",
    "                                     ])\n",
    "\n",
    "valid_and_test_transform = transforms.Compose([transforms.Resize(255),\n",
    "                                     transforms.CenterCrop(224),\n",
    "                                     transforms.ToTensor(),\n",
    "                                     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "                                     ])\n",
    "\n",
    "\n",
    "# TODO: Load the datasets with ImageFolder\n",
    "# image_datasets = \n",
    "train_data = ImageFolder(root=train_dir, transform=train_transforms)\n",
    "valid_data = ImageFolder(root=valid_dir, transform=valid_and_test_transform)\n",
    "test_data = ImageFolder(root=test_dir, transform=valid_and_test_transform)\n",
    "\n",
    "\n",
    "# TODO: Using the image datasets and the trainforms, define the dataloaders\n",
    "# dataloaders = \n",
    "train_data_loader = data.DataLoader(train_data, batch_size=64, shuffle=True)\n",
    "valid_data_loader = data.DataLoader(valid_data, batch_size=64)\n",
    "test_data_loader = data.DataLoader(test_data, batch_size=64)\n"
   ]
  },
  {
   "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": [
    "\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",
    "<font color='red'>**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.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading: \"https://download.pytorch.org/models/vgg16-397923af.pth\" to /root/.torch/models/vgg16-397923af.pth\n",
      "100%|██████████| 553433881/553433881 [00:04<00:00, 114332801.41it/s]\n"
     ]
    }
   ],
   "source": [
    "# TODO: Build and train your network\n",
    "model = torchvision.models.vgg16(pretrained=True)\n",
    "\n",
    "# freeze model parameters\n",
    "for param in model.parameters():\n",
    "    param.requires_grad = False\n",
    "\n",
    "    \n",
    "in_features_of_pretrained_model = model.classifier[0].in_features\n",
    "    \n",
    "# alter the classifier so that it has 102 out features (i.e. len(cat_to_name.json))\n",
    "number_of_flower_classes = len(train_data.classes)\n",
    "classifier = nn.Sequential(nn.Linear(in_features=in_features_of_pretrained_model, out_features=2048, bias=True),\n",
    "                           nn.ReLU(inplace=True),\n",
    "                           nn.Dropout(p=0.2),\n",
    "                           nn.Linear(in_features=2048, out_features=number_of_flower_classes, bias=True),\n",
    "                           nn.LogSoftmax(dim=1)\n",
    "                          )\n",
    "\n",
    "model.classifier = classifier# TODO: Build and train your network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "DELAY = INTERVAL = 4 * 60  # interval time in seconds\n",
    "MIN_DELAY = MIN_INTERVAL = 2 * 60\n",
    "KEEPALIVE_URL = \"https://nebula.udacity.com/api/v1/remote/keep-alive\"\n",
    "TOKEN_URL = \"http://metadata.google.internal/computeMetadata/v1/instance/attributes/keep_alive_token\"\n",
    "TOKEN_HEADERS = {\"Metadata-Flavor\":\"Google\"}\n",
    "\n",
    "\n",
    "def _request_handler(headers):\n",
    "    def _handler(signum, frame):\n",
    "        requests.request(\"POST\", KEEPALIVE_URL, headers=headers)\n",
    "    return _handler\n",
    "\n",
    "\n",
    "@contextmanager\n",
    "def active_session(delay=DELAY, interval=INTERVAL):\n",
    "    \"\"\"\n",
    "    Example:\n",
    "\n",
    "    from workspace_utils import active session\n",
    "\n",
    "    with active_session():\n",
    "        # do long-running work here\n",
    "    \"\"\"\n",
    "    token = requests.request(\"GET\", TOKEN_URL, headers=TOKEN_HEADERS).text\n",
    "    headers = {'Authorization': \"STAR \" + token}\n",
    "    delay = max(delay, MIN_DELAY)\n",
    "    interval = max(interval, MIN_INTERVAL)\n",
    "    original_handler = signal.getsignal(signal.SIGALRM)\n",
    "    try:\n",
    "        signal.signal(signal.SIGALRM, _request_handler(headers))\n",
    "        signal.setitimer(signal.ITIMER_REAL, delay, interval)\n",
    "        yield\n",
    "    finally:\n",
    "        signal.signal(signal.SIGALRM, original_handler)\n",
    "        signal.setitimer(signal.ITIMER_REAL, 0)\n",
    "\n",
    "\n",
    "def keep_awake(iterable, delay=DELAY, interval=INTERVAL):\n",
    "    \"\"\"\n",
    "    Example:\n",
    "\n",
    "    from workspace_utils import keep_awake\n",
    "\n",
    "    for i in keep_awake(range(5)):\n",
    "        # do iteration with lots of work here\n",
    "    \"\"\"\n",
    "    with active_session(delay, interval): yield from iterable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/5 Batch % Complete: 0.97%\n",
      "Epoch: 1/5 Batch % Complete: 19.42%\n",
      "Epoch: 1/5 Batch % Complete: 38.83%\n",
      "Epoch: 1/5 Batch % Complete: 58.25%\n",
      "Epoch: 1/5 Batch % Complete: 77.67%\n",
      "Epoch: 1/5 Batch % Complete: 97.09%\n",
      "Epoch: 1/5 Batch % Complete: 100.00%\n",
      "Train Loss: 2.355\n",
      "Valid Loss: 1.290\n",
      "Accuracy: 65.519%\n",
      "Epoch: 2/5 Batch % Complete: 0.97%\n",
      "Epoch: 2/5 Batch % Complete: 19.42%\n",
      "Epoch: 2/5 Batch % Complete: 38.83%\n",
      "Epoch: 2/5 Batch % Complete: 58.25%\n",
      "Epoch: 2/5 Batch % Complete: 77.67%\n",
      "Epoch: 2/5 Batch % Complete: 97.09%\n",
      "Epoch: 2/5 Batch % Complete: 100.00%\n",
      "Train Loss: 1.865\n",
      "Valid Loss: 1.034\n",
      "Accuracy: 72.817%\n",
      "Epoch: 3/5 Batch % Complete: 0.97%\n",
      "Epoch: 3/5 Batch % Complete: 19.42%\n",
      "Epoch: 3/5 Batch % Complete: 38.83%\n",
      "Epoch: 3/5 Batch % Complete: 58.25%\n",
      "Epoch: 3/5 Batch % Complete: 77.67%\n",
      "Epoch: 3/5 Batch % Complete: 97.09%\n",
      "Epoch: 3/5 Batch % Complete: 100.00%\n",
      "Train Loss: 1.857\n",
      "Valid Loss: 1.036\n",
      "Accuracy: 72.966%\n",
      "Epoch: 4/5 Batch % Complete: 0.97%\n",
      "Epoch: 4/5 Batch % Complete: 19.42%\n",
      "Epoch: 4/5 Batch % Complete: 38.83%\n",
      "Epoch: 4/5 Batch % Complete: 58.25%\n",
      "Epoch: 4/5 Batch % Complete: 77.67%\n",
      "Epoch: 4/5 Batch % Complete: 97.09%\n",
      "Epoch: 4/5 Batch % Complete: 100.00%\n",
      "Train Loss: 1.732\n",
      "Valid Loss: 0.909\n",
      "Accuracy: 76.486%\n",
      "Epoch: 5/5 Batch % Complete: 0.97%\n",
      "Epoch: 5/5 Batch % Complete: 19.42%\n",
      "Epoch: 5/5 Batch % Complete: 38.83%\n",
      "Epoch: 5/5 Batch % Complete: 58.25%\n",
      "Epoch: 5/5 Batch % Complete: 77.67%\n",
      "Epoch: 5/5 Batch % Complete: 97.09%\n",
      "Epoch: 5/5 Batch % Complete: 100.00%\n",
      "Train Loss: 1.665\n",
      "Valid Loss: 0.962\n",
      "Accuracy: 77.327%\n"
     ]
    }
   ],
   "source": [
    "# train\n",
    "\n",
    "# specify criterion\n",
    "criterion = nn.NLLLoss()\n",
    "\n",
    "# specify optimizer, using only classifer params. don't want to change the rest of VGG19\n",
    "optimizer = optim.Adam(model.classifier.parameters(), lr=0.003)\n",
    "\n",
    "# move device to cpu, before moving it to cuda/gpu\n",
    "device = 'cuda'\n",
    "model.to(device)\n",
    "\n",
    "# init variables for tracking loss/steps etc.\n",
    "epochs = 5\n",
    "print_every = 20\n",
    "\n",
    "with active_session():\n",
    "  \n",
    "    # for each epoch\n",
    "    for e in range(epochs):\n",
    "        step = 0\n",
    "        running_train_loss = 0\n",
    "        running_valid_loss = 0\n",
    "         # for each batch of images\n",
    "        for images, labels in train_data_loader:\n",
    "            step += 1\n",
    "\n",
    "            # turn model to train mode\n",
    "            model.train()\n",
    "\n",
    "            # move images and model to device\n",
    "            images, labels = images.to(device), labels.to(device)\n",
    "\n",
    "            # zeroise grad\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            # forward\n",
    "            \n",
    "            outputs = model(images)\n",
    "            \n",
    "            # loss\n",
    "            train_loss = criterion(outputs, labels)\n",
    "\n",
    "            # backward\n",
    "            train_loss.backward()\n",
    "\n",
    "            # step\n",
    "            optimizer.step()\n",
    "\n",
    "            running_train_loss += train_loss.item()\n",
    "\n",
    "            if step % print_every == 0 or step == 1 or step == len(train_data_loader):\n",
    "                print(\"Epoch: {}/{} Batch % Complete: {:.2f}%\".format(e+1, epochs, (step)*100/len(train_data_loader)))\n",
    "            \n",
    "        # validate\n",
    "        # turn model to eval mode\n",
    "        # turn on no_grad\n",
    "        model.eval()\n",
    "        with torch.no_grad():\n",
    "            # for each batch of images\n",
    "            running_accuracy = 0\n",
    "            running_valid_loss = 0\n",
    "            for images, labels in valid_data_loader:\n",
    "\n",
    "                # move images and model to device\n",
    "                images, labels = images.to(device), labels.to(device)\n",
    "\n",
    "                # forward\n",
    "                outputs = model(images)\n",
    "\n",
    "                # loss\n",
    "                valid_loss = criterion(outputs, labels)\n",
    "                running_valid_loss += valid_loss.item()\n",
    "\n",
    "                # accuracy\n",
    "                ps = torch.exp(outputs)\n",
    "                top_p, top_class = ps.topk(1, dim=1)\n",
    "                equals = top_class == labels.view(*top_class.shape)\n",
    "                running_accuracy += torch.mean(equals.type(torch.FloatTensor)).item()\n",
    "\n",
    "        # print stats\n",
    "        average_train_loss = running_train_loss/len(train_data_loader)\n",
    "        average_valid_loss = running_valid_loss/len(valid_data_loader)\n",
    "        accuracy = running_accuracy/len(valid_data_loader)\n",
    "        print(\"Train Loss: {:.3f}\".format(average_train_loss))\n",
    "        print(\"Valid Loss: {:.3f}\".format(average_valid_loss))\n",
    "        print(\"Accuracy: {:.3f}%\".format(accuracy*100))\n"
   ]
  },
  {
   "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": [
      "Test Loss: 1.074\n",
      "Test Accuracy: 79.709\n"
     ]
    }
   ],
   "source": [
    "# TODO: Do validation on the test set\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    # for each batch of images\n",
    "    running_accuracy = 0\n",
    "    running_loss = 0\n",
    "    for images, labels in test_data_loader:\n",
    "\n",
    "        # move images and model to device\n",
    "        images, labels = images.to(device), labels.to(device)\n",
    "\n",
    "        # forward\n",
    "        outputs = model(images)\n",
    "\n",
    "        # loss\n",
    "        loss = criterion(outputs, labels)\n",
    "        running_loss += loss.item()\n",
    "\n",
    "        # accuracy\n",
    "        ps = torch.exp(outputs)\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",
    "average_loss = running_loss/len(valid_data_loader)\n",
    "total_accuracy = accuracy/len(valid_data_loader)\n",
    "print(\"Test Loss: {:.3f}\".format(average_loss))\n",
    "print(\"Test Accuracy: {:.3f}\".format(total_accuracy*100))\n"
   ]
  },
  {
   "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",
    "model.class_to_idx = train_data.class_to_idx\n",
    "checkpoint = {'classifier': model.classifier,\n",
    "              'state_dict': model.state_dict(),\n",
    "              'epochs': epochs,\n",
    "              'optim_stat_dict': optimizer.state_dict(),\n",
    "              'class_to_idx': train_data.class_to_idx\n",
    "             }\n",
    "\n",
    "torch.save(checkpoint, 'checkpoint.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": 12,
   "metadata": {},
   "outputs": [],
   "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 = torchvision.models.vgg16(pretrained=True)\n",
    "    # freeze model parameters\n",
    "    for param in model.parameters():\n",
    "        param.requires_grad = False\n",
    "\n",
    "    model.classifier = checkpoint['classifier']\n",
    "    model.load_state_dict(checkpoint['state_dict'])\n",
    "    model.class_to_idx = checkpoint['class_to_idx']\n",
    "    \n",
    "    return 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": [],
   "source": [
    "def process_image(image_path):\n",
    "    ''' Scales, crops, and normalizes a PIL image for a PyTorch model,\n",
    "        returns an Numpy array\n",
    "    '''\n",
    "    pil_image=Image.open(image_path)\n",
    "    \n",
    "    # TODO: Process a PIL image for use in a PyTorch model\n",
    "    pil_image.resize((256,256))\n",
    "    \n",
    "    # centre crop\n",
    "    width, height = pil_image.size   # Get dimensions\n",
    "    new_width, new_height = 224, 224\n",
    "    \n",
    "    left = round((width - new_width)/2)\n",
    "    top = round((height - new_height)/2)\n",
    "    x_right = round(width - new_width) - left\n",
    "    x_bottom = round(height - new_height) - top\n",
    "    right = width - x_right\n",
    "    bottom = height - x_bottom\n",
    "\n",
    "    # Crop the center of the image\n",
    "    pil_image = pil_image.crop((left, top, right, bottom))\n",
    "    \n",
    "    # convert colour channel from 0-255, to 0-1\n",
    "    np_image = np.array(pil_image)/255\n",
    "    \n",
    "    # normalize for model\n",
    "    mean = np.array([0.485, 0.456, 0.406])\n",
    "    std = np.array([0.229, 0.224, 0.225])\n",
    "    np_image = (np_image - mean)/std\n",
    "    \n",
    "    # tranpose color channge to 1st dim\n",
    "    np_image = np_image.transpose((2 , 0, 1))\n",
    "    # convert to Float Tensor\n",
    "    tensor = torch.from_numpy(np_image)\n",
    "    tensor = tensor.type(torch.FloatTensor)\n",
    "   \n",
    "    # return tensor\n",
    "    return tensor\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": 14,
   "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.numpy().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"
   ]
  },
  {
   "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": 15,
   "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",
    "    image = process_image(image_path)\n",
    "    image = image.unsqueeze(0)\n",
    "\n",
    "    # move to device\n",
    "    image = image.to(device)\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        ps = torch.exp(model(image))\n",
    "        \n",
    "    idx_to_flower = {v:cat_to_name[k] for k, v in model.class_to_idx.items()}    \n",
    "    \n",
    "    top_ps, top_classes = ps.topk(topk, dim=1)\n",
    "    predicted_flowers = [idx_to_flower[i] for i in top_classes.tolist()[0]]\n",
    "\n",
    "    return top_ps.tolist()[0], predicted_flowers\n",
    "    \n",
    "    # TODO: Implement the code to predict the class from an image file"
   ]
  },
  {
   "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": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Display an image along with the top 5 classes\n",
    "\n",
    "model = load_checkpoint(\"checkpoint.pth\")\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model = model.to(device)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'>**Reminder for Workspace users:** If your network becomes very large when saved as a checkpoint, there might be issues with saving backups in your workspace. You should reduce the size of your hidden layers and train again. \n",
    "    \n",
    "We strongly encourage you to delete these large interim files and directories before navigating to another page or closing the browser tab.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classify_random_image():\n",
    "    # pick random image from test folder\n",
    "    random_label_idx = random.choice(os.listdir(test_dir))\n",
    "    random_image_file = random.choice(os.listdir(\"{}/{}\".format(test_dir, random_label_idx))) \n",
    "    image_path = os.path.join(test_dir, random_label_idx, random_image_file)\n",
    "    actual_flower_name = cat_to_name[random_label_idx]\n",
    "\n",
    "    # process image\n",
    "    image = process_image(image_path)\n",
    "    top_ps, top_classes = predict(image_path, model)\n",
    "    \n",
    "\n",
    "    top1_flower_name = top_classes[0]\n",
    "\n",
    "\n",
    "    # graph\n",
    "    if top1_flower_name == actual_flower_name:\n",
    "        classified_correctly = \"Yes, Top Prediction\" \n",
    "    elif actual_flower_name in top_classes:\n",
    "        classified_correctly = \"Yes in Top 5 Prediction\" \n",
    "    else: \n",
    "        classified_correctly = \"No\" \n",
    "\n",
    "    plt.barh(top_classes, top_ps)\n",
    "    plt.title(\"Actual Class = {} \\n Correctly Classified = {}\".format(actual_flower_name, classified_correctly))\n",
    "    plt.show()\n",
    "    imshow(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f091f7870f0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f091d67ab00>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "classify_random_image()"
   ]
  },
  {
   "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
}