{ "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", "\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": [ "%matplotlib inline\n", "%config InlineBackend.figure_format = 'retina'\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "import torch\n", "import numpy as np\n", "from torch import nn\n", "from torch import optim\n", "import torch.nn.functional as F\n", "from torchvision import datasets, transforms, models\n", "from workspace_utils import active_session\n", "import time\n", "from collections import OrderedDict # use dict, but we have to keep the order\n", "from PIL import Image\n", "import json" ] }, { "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": 7, "metadata": {}, "outputs": [], "source": [ "# Define transforms for the training, validation, and testing sets, using data augumentations on training set,\n", "# Inception_v3 has input size 299x299\n", "train_transforms = transforms.Compose([transforms.RandomRotation(30),\n", " transforms.RandomResizedCrop(299),\n", " transforms.RandomHorizontalFlip(),\n", " transforms.ToTensor(),\n", " transforms.Normalize([0.485, 0.456, 0.406], \n", " [0.229, 0.224, 0.225])])\n", "\n", "validation_transforms = transforms.Compose([transforms.Resize(299),\n", " transforms.CenterCrop(299),\n", " transforms.ToTensor(),\n", " transforms.Normalize([0.485, 0.456, 0.406], \n", " [0.229, 0.224, 0.225])])\n", "\n", "\n", "test_transforms = transforms.Compose([transforms.Resize(299),\n", " transforms.CenterCrop(299),\n", " transforms.ToTensor(),\n", " transforms.Normalize([0.485, 0.456, 0.406], \n", " [0.229, 0.224, 0.225])])\n", "\n", "# Load the datasets with ImageFolder\n", "train_data = datasets.ImageFolder(train_dir, transform=train_transforms)\n", "validation_data = datasets.ImageFolder(valid_dir, transform=validation_transforms)\n", "test_data = datasets.ImageFolder(test_dir, transform=test_transforms)\n", "\n", "# Using the image datasets and the trainforms, define the dataloaders\n", "trainloader = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True)\n", "validloader = torch.utils.data.DataLoader(validation_data, batch_size= 32)\n", "testloader = torch.utils.data.DataLoader(test_data, batch_size= 32)" ] }, { "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": 15, "metadata": {}, "outputs": [], "source": [ "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. 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/inception_v3_google-1a9a5a14.pth\" to /root/.torch/models/inception_v3_google-1a9a5a14.pth\n", "100%|██████████| 108857766/108857766 [00:02<00:00, 41898537.19it/s]\n" ] } ], "source": [ "# Build Inception network\n", "inception = models.inception_v3(pretrained=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The last layer of the inception network, (fc): Linear(in_features=2048, out_features=1000, bias=True), therefore the inputs of the feedforward network is 2048" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# Freeze parameters so we don't backprop through them\n", "for param in inception.parameters():\n", " param.requires_grad = False\n", "\n", "\n", "classifier = nn.Sequential(OrderedDict([\n", " ('fc1', nn.Linear(2048, 500)),\n", " ('relu1', nn.ReLU()),\n", " ('dropout1', nn.Dropout(0.1)),\n", " ('fc2', nn.Linear(500, 102)),\n", " ('output', nn.LogSoftmax(dim=1))\n", " ]))\n", "# Attach the feedforward neural network\n", "inception.fc = classifier" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Define criterion and loss" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "criterion = nn.NLLLoss()\n", "# Only train the classifier parameters, feature parameters are frozen\n", "adam = optim.Adam(inception.fc.parameters(), lr=0.001)\n", "# Important: Send model to use gpu cuda\n", "inception = inception.to('cuda')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Build function to calculate the loss and accuracy of the validation set on a single batch" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def evaluate_performance_batch(model,batch, criterion, device = 'cuda'):\n", " with torch.no_grad():\n", " images, labels = tuple(map(lambda x: x.to(device), batch))\n", " predictions = model.forward(images)\n", " _, predict = torch.max(predictions, 1)\n", " \n", " correct = (predict == labels).sum().item()\n", " total = len(labels)\n", " \n", " return correct, total" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Build function to calculate the loss and accuracy of the validation set" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def evaluate_performance(model, dataloader,criterion, device = 'cuda'):\n", " performance = [evaluate_performance_batch(model, i, criterion) for i in iter(dataloader)] \n", " correct, total = list(map(sum, zip(*performance)))\n", " return correct/total" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Build function to tranin the neural network" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def train_model(model, trainloader, validloader, epochs, print_every, criterion, optimizer, device = 'cuda'):\n", " \n", " for e in range(epochs):\n", " model.train()\n", " running_loss = 0 # the loss for every batch\n", " \n", " for i, train_batch in enumerate(trainloader): # minibatch training\n", " \n", " # send the inputs labels to the tensors that uses the specified devices\n", " inputs, labels = tuple(map(lambda x: x.to(device), train_batch))\n", " optimizer.zero_grad() # clear out previous gradients, avoids accumulations\n", " \n", " # Forward and backward passes\n", " predictions = model.forward(inputs)\n", " \n", " loss = criterion(predictions[0], labels)\n", " loss.backward()\n", " optimizer.step()\n", " \n", " # calculate the total loss for 1 epoch of training\n", " running_loss += loss.item()\n", " \n", " # print the loss every .. batches\n", " if i % print_every == 0:\n", " model.eval() # set to evaluation mode\n", " train_accuracy = evaluate_performance(model, trainloader, criterion)\n", " validate_accuracy = evaluate_performance(model, validloader, criterion)\n", " print(\"Epoch: {}/{}... :\".format(e+1, epochs),\n", " \"Loss: {:.4f},\".format(running_loss/print_every),\n", " \"Training Accuracy:{: .4f} %,\".format(train_accuracy * 100),\n", " \"Validation Accuracy:{: .4f} %\".format(validate_accuracy * 100)\n", " )\n", " running_loss = 0\n", " model.train()\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 1/15... : Loss: 0.0925, Training Accuracy: 3.1288 %, Validation Accuracy: 3.4230 %\n", "Epoch: 1/15... : Loss: 4.2734, Training Accuracy: 24.8474 %, Validation Accuracy: 26.1614 %\n", "Epoch: 1/15... : Loss: 3.3331, Training Accuracy: 43.9713 %, Validation Accuracy: 45.4768 %\n", "Epoch: 2/15... : Loss: 0.0521, Training Accuracy: 45.5281 %, Validation Accuracy: 47.3105 %\n", "Epoch: 2/15... : Loss: 2.5228, Training Accuracy: 56.0134 %, Validation Accuracy: 59.0465 %\n", "Epoch: 2/15... : Loss: 2.0230, Training Accuracy: 61.3248 %, Validation Accuracy: 63.5697 %\n", "Epoch: 3/15... : Loss: 0.0327, Training Accuracy: 62.9731 %, Validation Accuracy: 62.7139 %\n", "Epoch: 3/15... : Loss: 1.7305, Training Accuracy: 65.9799 %, Validation Accuracy: 68.2152 %\n", "Epoch: 3/15... : Loss: 1.6081, Training Accuracy: 70.3602 %, Validation Accuracy: 72.2494 %\n", "Epoch: 4/15... : Loss: 0.0246, Training Accuracy: 70.5433 %, Validation Accuracy: 72.2494 %\n", "Epoch: 4/15... : Loss: 1.4438, Training Accuracy: 71.2912 %, Validation Accuracy: 73.3496 %\n", "Epoch: 4/15... : Loss: 1.4034, Training Accuracy: 74.7711 %, Validation Accuracy: 76.6504 %\n", "Epoch: 5/15... : Loss: 0.0321, Training Accuracy: 75.8852 %, Validation Accuracy: 77.8729 %\n", "Epoch: 5/15... : Loss: 1.2899, Training Accuracy: 76.8620 %, Validation Accuracy: 80.0733 %\n", "Epoch: 5/15... : Loss: 1.2660, Training Accuracy: 77.1215 %, Validation Accuracy: 79.3399 %\n", "Epoch: 6/15... : Loss: 0.0245, Training Accuracy: 76.1294 %, Validation Accuracy: 77.3839 %\n", "Epoch: 6/15... : Loss: 1.2428, Training Accuracy: 78.9988 %, Validation Accuracy: 80.5623 %\n", "Epoch: 6/15... : Loss: 1.1950, Training Accuracy: 79.7924 %, Validation Accuracy: 82.5183 %\n", "Epoch: 7/15... : Loss: 0.0266, Training Accuracy: 80.0519 %, Validation Accuracy: 82.2738 %\n", "Epoch: 7/15... : Loss: 1.1748, Training Accuracy: 80.4335 %, Validation Accuracy: 82.2738 %\n", "Epoch: 7/15... : Loss: 1.1639, Training Accuracy: 80.1129 %, Validation Accuracy: 84.1076 %\n", "Epoch: 8/15... : Loss: 0.0216, Training Accuracy: 80.1129 %, Validation Accuracy: 82.5183 %\n", "Epoch: 8/15... : Loss: 1.1408, Training Accuracy: 81.3645 %, Validation Accuracy: 82.8851 %\n", "Epoch: 8/15... : Loss: 1.0852, Training Accuracy: 81.2882 %, Validation Accuracy: 81.4181 %\n", "Epoch: 9/15... : Loss: 0.0217, Training Accuracy: 81.5934 %, Validation Accuracy: 83.6186 %\n", "Epoch: 9/15... : Loss: 1.0224, Training Accuracy: 81.5476 %, Validation Accuracy: 84.1076 %\n", "Epoch: 9/15... : Loss: 1.0719, Training Accuracy: 81.7766 %, Validation Accuracy: 83.9853 %\n", "Epoch: 10/15... : Loss: 0.0149, Training Accuracy: 82.0360 %, Validation Accuracy: 84.9633 %\n", "Epoch: 10/15... : Loss: 0.9796, Training Accuracy: 81.9597 %, Validation Accuracy: 83.1296 %\n", "Epoch: 10/15... : Loss: 1.0293, Training Accuracy: 83.3486 %, Validation Accuracy: 84.8411 %\n", "Epoch: 11/15... : Loss: 0.0188, Training Accuracy: 84.0965 %, Validation Accuracy: 85.6968 %\n", "Epoch: 11/15... : Loss: 1.0163, Training Accuracy: 83.0128 %, Validation Accuracy: 84.4743 %\n", "Epoch: 11/15... : Loss: 1.0363, Training Accuracy: 82.7686 %, Validation Accuracy: 85.2078 %\n", "Epoch: 12/15... : Loss: 0.0260, Training Accuracy: 83.7607 %, Validation Accuracy: 85.0856 %\n", "Epoch: 12/15... : Loss: 0.9740, Training Accuracy: 83.6386 %, Validation Accuracy: 85.9413 %\n", "Epoch: 12/15... : Loss: 1.0162, Training Accuracy: 83.7302 %, Validation Accuracy: 83.8631 %\n", "Epoch: 13/15... : Loss: 0.0206, Training Accuracy: 84.1728 %, Validation Accuracy: 83.9853 %\n", "Epoch: 13/15... : Loss: 0.9534, Training Accuracy: 84.6459 %, Validation Accuracy: 85.8191 %\n", "Epoch: 13/15... : Loss: 0.9911, Training Accuracy: 84.0812 %, Validation Accuracy: 86.9193 %\n", "Epoch: 14/15... : Loss: 0.0206, Training Accuracy: 84.0507 %, Validation Accuracy: 86.4303 %\n", "Epoch: 14/15... : Loss: 0.9785, Training Accuracy: 85.2106 %, Validation Accuracy: 85.2078 %\n", "Epoch: 14/15... : Loss: 0.9902, Training Accuracy: 84.4170 %, Validation Accuracy: 85.4523 %\n", "Epoch: 15/15... : Loss: 0.0192, Training Accuracy: 83.9286 %, Validation Accuracy: 84.8411 %\n", "Epoch: 15/15... : Loss: 0.9125, Training Accuracy: 85.3022 %, Validation Accuracy: 86.4303 %\n", "Epoch: 15/15... : Loss: 0.9841, Training Accuracy: 85.1496 %, Validation Accuracy: 85.2078 %\n", "Training time lapsed: 10200.958985805511 s\n" ] } ], "source": [ "start = time.time()\n", "with active_session():\n", " train_model(inception, trainloader, validloader, 15, 50, criterion, adam, device = 'cuda')\n", "end = time.time()\n", "print('Training time lapsed:', end - start, 's')" ] }, { "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": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Test Accuracy:83.7607 %,\n" ] } ], "source": [ "# TODO: Do validation on the test set\n", "inception.eval()\n", "test_accuracy = evaluate_performance(inception, testloader, criterion)\n", "print (\"Test Accuracy:{:.4f} %,\".format(test_accuracy * 100) )" ] }, { "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": 13, "metadata": {}, "outputs": [], "source": [ "# Save the checkpoint \n", "with active_session():\n", " check_point_file = 'inception_checkpoint.pth'\n", " inception.class_to_idx = train_data.class_to_idx\n", "\n", " checkpoint_dict = {\n", " 'architecture': 'inception_v3',\n", " 'class_to_idx': inception.class_to_idx,\n", " 'input_units': 2048,\n", " 'hidden_units': 500,\n", " 'dropout_prob': 0.1,\n", " 'state_dict': inception.state_dict()\n", " }\n", " torch.save(checkpoint_dict, check_point_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": 2, "metadata": {}, "outputs": [], "source": [ "# Write a function that loads a checkpoint and rebuilds the model\n", "def load_model_checkpoint(path, device = 'cuda'):\n", " checkpoint = torch.load(path, map_location={'cuda:0': 'cpu'})\n", " model = models.inception_v3(pretrained=True) # static, will change in application\n", " classifier = nn.Sequential(OrderedDict([\n", " ('fc1', nn.Linear(checkpoint['input_units'], checkpoint['hidden_units'])),\n", " ('relu1', nn.ReLU()),\n", " ('dropout1', nn.Dropout(checkpoint['dropout_prob'])),\n", " ('fc3', nn.Linear(checkpoint['hidden_units'], 102)),\n", " ('output', nn.LogSoftmax(dim=1))\n", " ]))\n", " # Attach the feedforward neural network\n", " model.fc = classifier\n", " model.load_state_dict(checkpoint['state_dict'])\n", " model.class_to_idx = checkpoint['class_to_idx']\n", " model.to(device)\n", " return model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Load model" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "model = load_model_checkpoint('inception_v3_checkpoint.pth')" ] }, { "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": 4, "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", " # Process a PIL image for use in a PyTorch model\n", " im = Image.open(image)\n", " \n", " # resize image to 320 on the shortest side\n", " size = (320, 320)\n", " im.thumbnail(size)\n", " \n", " # crop out 299 portion in the center\n", " width, height = im.size\n", " left = (width - 299)/2\n", " top = (height - 299)/2\n", " right = (width + 299)/2\n", " bottom = (height + 299)/2\n", " im = im.crop((left, top, right, bottom))\n", " \n", " # normalize image\n", " np_image = np.array(im)\n", " im_mean = np.array([0.485, 0.456, 0.406])\n", " im_sd = np.array([0.229, 0.224, 0.225])\n", " np_image = (np_image/255 - im_mean)/im_sd\n", " \n", " # transpose the image\n", " np_image = np_image.T\n", " return np_image" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "image_path = 'flowers/valid/1/image_06739.jpg'\n", "processed_image = process_image(image_path)" ] }, { "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": 6, "metadata": {}, "outputs": [], "source": [ "def imshow2(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", " #plt.suptitle(title)\n", " ax.imshow(image)\n", "\n", " return ax" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": { "image/png": { "height": 251, "width": 260 } }, "output_type": "display_data" } ], "source": [ "imshow2(processed_image, title= cat_to_name['1'])" ] }, { "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": 13, "metadata": {}, "outputs": [], "source": [ "def predict(image_path, model, device = 'cuda', topk=5):\n", " ''' Predict the class (or classes) of an image using a trained deep learning model.\n", " '''\n", " # Implement the code to predict the class from an image file\n", " model.eval()\n", " image = process_image(image_path)\n", " # use forward propagation to obtain the class probabilities\n", " image = torch.tensor(image, dtype= torch.float).unsqueeze(0).to(device)\n", " predict_prob_tensor = torch.exp(model.forward(image)) # convert log probabilities to real probabilities\n", " predict_prob = predict_prob_tensor.cpu().detach().numpy()[0] # change into numpy array\n", " \n", " # Find the correspoinding top k classes\n", " top_k_idx = predict_prob.argsort()[-topk:][::-1]\n", " probs = predict_prob[top_k_idx]\n", " classes = np.array(list(range(1, 102)))[top_k_idx]\n", " \n", " return probs, classes" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 0.95828944 0.01654186 0.00614283 0.00491109 0.00466084]\n", "[ 0.95828944 0.01654186 0.00614283 0.00491109 0.00466084]\n", "[ 1 88 65 60 51]\n" ] } ], "source": [ "probs, classes = predict(image_path, model, topk=5)\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", "\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": 39, "metadata": {}, "outputs": [], "source": [ "# Display an image along with the top 5 classes\n", "def visualize_pred(image, model, cat_to_name):\n", "\n", " im = process_image(image_path) \n", " # Get predicted class names from predict function\n", " probs, classes = predict(image, model, topk=5)\n", " flower_names = [cat_to_name[str(x)] for x in classes]\n", " \n", " # Build subplots above\n", " fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10,10))\n", " # set axis settings top\n", " imshow2(im, ax =ax1)\n", " ax1.set_title(cat_to_name[image.split('/')[2]])\n", " # set axis settings bottom\n", " ax2.barh(np.arange(1,6), probs)\n", " ax2.set_yticks(np.arange(1,6))\n", " ax2.set_yticklabels(flower_names) \n", " ax2.set_aspect(0.187)\n", " ax2.set_xlim(0,1)" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": { "image/png": { "height": 589, "width": 370 } }, "output_type": "display_data" } ], "source": [ "visualize_pred(image_path, inception, cat_to_name)" ] } ], "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 }