Image Classifier Project (1).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": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports here\n",
    "\n",
    "import os\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import seaborn as sb\n",
    "\n",
    "import torchvision\n",
    "from torchvision import datasets,models,transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import helper\n",
    "import pandas as pd\n",
    "\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "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": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = os.getcwd() + '/flowers'\n",
    "train_dir = data_dir + '/train'\n",
    "valid_dir = data_dir + '/valid'\n",
    "test_dir = data_dir + '/test'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Define your transforms for the training, validation, and testing sets\n",
    "\n",
    "#Training Transform with rotation, resizing, cropping and vertical flip\n",
    "train_transforms = transforms.Compose([transforms.RandomRotation(10),\n",
    "                                       transforms.RandomResizedCrop(224),\n",
    "                                       transforms.RandomHorizontalFlip(),\n",
    "                                       transforms.RandomVerticalFlip(),\n",
    "                                       transforms.ToTensor(),\n",
    "                                       transforms.Normalize([0.485, 0.456, 0.406],\n",
    "                                                            [0.229, 0.224, 0.225])])\n",
    "\n",
    "#Validation and testing transforms--Resizing and then Cropping\n",
    "valid_transforms = transforms.Compose([transforms.Resize(255),\n",
    "                                       transforms.CenterCrop(224),\n",
    "                                       transforms.ToTensor(),\n",
    "                                       transforms.Normalize([0.485, 0.456, 0.406],\n",
    "                                                            [0.229, 0.224, 0.225])])\n",
    "\n",
    "test_transforms = transforms.Compose([transforms.Resize(255),\n",
    "                                       transforms.CenterCrop(224),\n",
    "                                       transforms.ToTensor(),\n",
    "                                       transforms.Normalize([0.485, 0.456, 0.406],\n",
    "                                                            [0.229, 0.224, 0.225])])\n",
    "\n",
    "\n",
    "# TODO: Load the datasets with ImageFolder\n",
    "train_data = datasets.ImageFolder(train_dir, transform=train_transforms)\n",
    "valid_data = datasets.ImageFolder(valid_dir, transform=valid_transforms)\n",
    "test_data = datasets.ImageFolder(test_dir, transform=test_transforms)\n",
    "\n",
    "# TODO: Using the image datasets and the transforms, define the dataloaders\n",
    "trainloader = torch.utils.data.DataLoader(train_data, batch_size=32, shuffle=True)\n",
    "validloader = torch.utils.data.DataLoader(valid_data, batch_size=32)\n",
    "testloader = torch.utils.data.DataLoader(test_data, batch_size=32)\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": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "with open('cat_to_name.json', 'r') as f:\n",
    "    cat_to_name = json.load(f)\n"
   ]
  },
  {
   "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": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "VGG(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (1): ReLU(inplace)\n",
       "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (3): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (4): ReLU(inplace)\n",
       "    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (6): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (7): ReLU(inplace)\n",
       "    (8): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (9): ReLU(inplace)\n",
       "    (10): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (11): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (12): ReLU(inplace)\n",
       "    (13): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (14): ReLU(inplace)\n",
       "    (15): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (16): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (17): ReLU(inplace)\n",
       "    (18): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (19): ReLU(inplace)\n",
       "    (20): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (classifier): Sequential(\n",
       "    (0): Linear(in_features=25088, out_features=4096, bias=True)\n",
       "    (1): ReLU(inplace)\n",
       "    (2): Dropout(p=0.5)\n",
       "    (3): Linear(in_features=4096, out_features=4096, bias=True)\n",
       "    (4): ReLU(inplace)\n",
       "    (5): Dropout(p=0.5)\n",
       "    (6): Linear(in_features=4096, out_features=1000, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TODO: Build and train your network\n",
    "    \n",
    "#Loading the pre-trained model from PyTorch\n",
    "model=models.vgg11(pretrained=True)\n",
    "    \n",
    "#Freeze training for all \"features\" layers\n",
    "    \n",
    "for param in model.features.parameters():\n",
    "    \n",
    "    param.requires_grad = False\n",
    "        \n",
    "#check if CUDA is available\n",
    "device=torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "VGG(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (1): ReLU(inplace)\n",
       "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (3): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (4): ReLU(inplace)\n",
       "    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (6): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (7): ReLU(inplace)\n",
       "    (8): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (9): ReLU(inplace)\n",
       "    (10): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (11): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (12): ReLU(inplace)\n",
       "    (13): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (14): ReLU(inplace)\n",
       "    (15): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (16): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (17): ReLU(inplace)\n",
       "    (18): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (19): ReLU(inplace)\n",
       "    (20): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (classifier): Sequential(\n",
       "    (0): Linear(in_features=25088, out_features=512, bias=True)\n",
       "    (1): ReLU()\n",
       "    (2): Dropout(p=0.2)\n",
       "    (3): Linear(in_features=512, out_features=256, bias=True)\n",
       "    (4): ReLU()\n",
       "    (5): Dropout(p=0.2)\n",
       "    (6): Linear(in_features=256, out_features=102, bias=True)\n",
       "    (7): LogSoftmax()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Defining the new classifier\n",
    "\n",
    "classifier = nn.Sequential(nn.Linear(25088,512),\n",
    "                           nn.ReLU(),\n",
    "                           nn.Dropout(p=0.2),\n",
    "                           nn.Linear(512,256),\n",
    "                           nn.ReLU(),\n",
    "                           nn.Dropout(p=0.2),\n",
    "                           nn.Linear(256,len(cat_to_name)),\n",
    "                           nn.LogSoftmax(dim=1))\n",
    "                           \n",
    "                           \n",
    "                           \n",
    "                           \n",
    "                    \n",
    "                           \n",
    "#Replacing the classifier in the pre-trained classifier with our classifier\n",
    "                           \n",
    "model.classifier=classifier\n",
    "\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Loss Function and Optimizer\n",
    "\n",
    "#Specifying negative Log likelihood loss function\n",
    "criterion = nn.NLLLoss()\n",
    "\n",
    "#Specifying optimizer and learning rate=0.005\n",
    "optimizer = optim.SGD(model.classifier.parameters(), lr=0.10)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Move our model to whichever device is available\n",
    "\n",
    "model.to(device);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2.. Train loss: 2.355.. Validation loss: 0.979.. Validation Accuracy: 0.733\n",
      "Epoch 4.. Train loss: 1.269.. Validation loss: 0.640.. Validation Accuracy: 0.826\n",
      "Epoch 7.. Train loss: 1.099.. Validation loss: 0.634.. Validation Accuracy: 0.837\n",
      "Epoch 9.. Train loss: 0.988.. Validation loss: 0.570.. Validation Accuracy: 0.856\n"
     ]
    }
   ],
   "source": [
    "#Training the Model\n",
    "\n",
    "epochs=10\n",
    "steps=0\n",
    "running_loss=0\n",
    "print_every=500\n",
    "\n",
    "#looping through the number of epochs\n",
    "for epoch in range(epochs):\n",
    "    \n",
    "    #looping through the data\n",
    "    for images,labels in trainloader:\n",
    "        \n",
    "        #steps increment through each batch\n",
    "        steps+=1\n",
    "        \n",
    "        #Moving images and labels to the default device\n",
    "        images,labels = images.to(device), labels.to(device)\n",
    "        \n",
    "        #making the gradients zero to avoid gradient accumulation\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        #calculating the log probabilities\n",
    "        logps=model(images)\n",
    "        \n",
    "        #calculating the loss\n",
    "        loss=criterion(logps, labels)\n",
    "        \n",
    "        #backward pass\n",
    "        loss.backward()\n",
    "        \n",
    "        #taking a step with the optimizer to update the parameters\n",
    "        optimizer.step()\n",
    "        \n",
    "        running_loss += loss.item()\n",
    "        \n",
    "        #checking the model performance on validation set\n",
    "        if steps % print_every == 0:\n",
    "            \n",
    "            #setting the validation loss and accuracy to zero\n",
    "            valid_loss=0\n",
    "            valid_accuracy=0\n",
    "            \n",
    "            #turn the model in evaluation mode\n",
    "            model.eval()\n",
    "            \n",
    "            with torch.no_grad():\n",
    "                \n",
    "                for images,labels in validloader:\n",
    "                    \n",
    "                    #transferring images and labels to GPU\n",
    "                    images,labels = images.to(device), labels.to(device)\n",
    "                    \n",
    "                    #calculating log probabilities for data in validation set\n",
    "                    logps=model(images)\n",
    "                    \n",
    "                    #calculating loss\n",
    "                    batch_loss=criterion(logps, labels)\n",
    "                    \n",
    "                    valid_loss += batch_loss.item()\n",
    "                    \n",
    "                    #calculate validation probabilities\n",
    "                    ps = torch.exp(logps)\n",
    "                    \n",
    "                    #get the most likely class\n",
    "                    top_ps, top_class = ps.topk(1, dim=1)\n",
    "                    \n",
    "                    #calculating equality after comparing top_class and labels\n",
    "                    equality = top_class == labels.view(*top_class.shape)\n",
    "                    \n",
    "                    #accuracy calculation\n",
    "                    valid_accuracy += torch.mean(equality.type(torch.cuda.FloatTensor)).item()\n",
    "                \n",
    "            #Printing the results depending on print_every\n",
    "            print(f\"Epoch {epoch}.. \"\n",
    "                  f\"Train loss: {running_loss/print_every:.3f}.. \"\n",
    "                  f\"Validation loss: {valid_loss/len(validloader):.3f}.. \"\n",
    "                  f\"Validation Accuracy: {valid_accuracy/len(validloader):.3f}\")\n",
    "            \n",
    "            running_loss=0\n",
    "            #setting model back in training mode\n",
    "            model.train()\n",
    "                \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        \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": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing loss: 0.608.. Testing Accuracy: 0.842\n"
     ]
    }
   ],
   "source": [
    "#setting the testing loss and accuracy to zero\n",
    "test_loss=0\n",
    "test_accuracy=0\n",
    "\n",
    "#turn the model in evaluation mode\n",
    "model.eval()\n",
    "\n",
    "with torch.no_grad():\n",
    "    \n",
    "    for images,labels in testloader:\n",
    "                \n",
    "        #Moving images and labels to the default device\n",
    "        images,labels = images.to(device), labels.to(device)\n",
    "        \n",
    "        #moving the model to device\n",
    "        model=model.to(device)\n",
    "\n",
    "\n",
    "        #calculating log probabilities for data in testing set\n",
    "        logps=model(images)\n",
    "\n",
    "        #calculating loss\n",
    "        batch_loss = criterion(logps, labels)\n",
    "\n",
    "        test_loss += batch_loss.item()\n",
    "\n",
    "        #calculate testing probabilities\n",
    "        ps = torch.exp(logps)\n",
    "\n",
    "        #get the most likely class\n",
    "        top_ps, top_class = ps.topk(1, dim=1)\n",
    "\n",
    "        #calculating equality after comparing top_class and labels\n",
    "        equality = top_class == labels.view(*top_class.shape)\n",
    "\n",
    "        #accuracy calculation\n",
    "        test_accuracy += torch.mean(equality.type(torch.FloatTensor)).item()\n",
    "\n",
    "#Printing the results\n",
    "\n",
    "print(f\"Testing loss: {test_loss/len(testloader):.3f}.. \"\n",
    "      f\"Testing Accuracy: {test_accuracy/len(testloader):.3f}\")\n",
    "\n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "print(device)"
   ]
  },
  {
   "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": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Save the checkpoint\n",
    "\n",
    "#assigning class_to_idx as an attribute to the model\n",
    "model.class_to_idx = train_data.class_to_idx\n",
    "\n",
    "#defining the checkpoint into a dictionary\n",
    "checkpoint={\n",
    "    'class_to_idx':train_data.class_to_idx,\n",
    "    'state_dict':model.state_dict(),\n",
    "    'optimizer_dict':optimizer.state_dict(),\n",
    "    'classifier':model.classifier,\n",
    "    'optimizer':optimizer\n",
    "}\n",
    "\n",
    "#saving checkpoint\n",
    "torch.save(checkpoint, 'checkpoint.pth')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "features.0.weight \t torch.Size([64, 3, 3, 3])\n",
      "features.0.bias \t torch.Size([64])\n",
      "features.3.weight \t torch.Size([128, 64, 3, 3])\n",
      "features.3.bias \t torch.Size([128])\n",
      "features.6.weight \t torch.Size([256, 128, 3, 3])\n",
      "features.6.bias \t torch.Size([256])\n",
      "features.8.weight \t torch.Size([256, 256, 3, 3])\n",
      "features.8.bias \t torch.Size([256])\n",
      "features.11.weight \t torch.Size([512, 256, 3, 3])\n",
      "features.11.bias \t torch.Size([512])\n",
      "features.13.weight \t torch.Size([512, 512, 3, 3])\n",
      "features.13.bias \t torch.Size([512])\n",
      "features.16.weight \t torch.Size([512, 512, 3, 3])\n",
      "features.16.bias \t torch.Size([512])\n",
      "features.18.weight \t torch.Size([512, 512, 3, 3])\n",
      "features.18.bias \t torch.Size([512])\n",
      "classifier.0.weight \t torch.Size([512, 25088])\n",
      "classifier.0.bias \t torch.Size([512])\n",
      "classifier.3.weight \t torch.Size([256, 512])\n",
      "classifier.3.bias \t torch.Size([256])\n",
      "classifier.6.weight \t torch.Size([102, 256])\n",
      "classifier.6.bias \t torch.Size([102])\n"
     ]
    }
   ],
   "source": [
    "#checking the model's layers' weights and biases\n",
    "for param_tensor in model.state_dict():\n",
    "    print(param_tensor, \"\\t\", model.state_dict()[param_tensor].size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state \t {}\n",
      "param_groups \t [{'lr': 0.1, 'momentum': 0, 'dampening': 0, 'weight_decay': 0, 'nesterov': False, 'params': [140443554109840, 140443554109768, 140443486030008, 140443554107968, 140443554108688, 140443554110056]}]\n"
     ]
    }
   ],
   "source": [
    "#checking the optimizer's parameters\n",
    "for param_tensor in optimizer.state_dict():\n",
    "    print(param_tensor, \"\\t\", optimizer.state_dict()[param_tensor])"
   ]
  },
  {
   "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": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Write a function that loads a checkpoint and rebuilds the model\n",
    "\n",
    "def load_checkpoint(path):\n",
    "    \n",
    "    checkpoint=torch.load(path)\n",
    "    \n",
    "    model=models.vgg11(pretrained=True)\n",
    "    \n",
    "    for param in model.parameters():\n",
    "        param.requires_grad=False\n",
    "        \n",
    "    model.classifier=checkpoint['classifier']\n",
    "    model.class_to_idx=checkpoint['class_to_idx']\n",
    "    model.load_state_dict(checkpoint['state_dict'])\n",
    "    \n",
    "    optimizer=checkpoint['optimizer']\n",
    "    optimizer.load_state_dict(checkpoint['optimizer_dict'])\n",
    "    \n",
    "    return model\n",
    "\n",
    "\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "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): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (3): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (4): ReLU(inplace)\n",
      "    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (6): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (7): ReLU(inplace)\n",
      "    (8): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (9): ReLU(inplace)\n",
      "    (10): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (11): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (12): ReLU(inplace)\n",
      "    (13): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (14): ReLU(inplace)\n",
      "    (15): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (16): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (17): ReLU(inplace)\n",
      "    (18): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (19): ReLU(inplace)\n",
      "    (20): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  )\n",
      "  (classifier): Sequential(\n",
      "    (0): Linear(in_features=25088, out_features=512, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Dropout(p=0.2)\n",
      "    (3): Linear(in_features=512, out_features=256, bias=True)\n",
      "    (4): ReLU()\n",
      "    (5): Dropout(p=0.2)\n",
      "    (6): Linear(in_features=256, out_features=102, bias=True)\n",
      "    (7): LogSoftmax()\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SGD (\n",
      "Parameter Group 0\n",
      "    dampening: 0\n",
      "    lr: 0.1\n",
      "    momentum: 0\n",
      "    nesterov: False\n",
      "    weight_decay: 0\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(optimizer)"
   ]
  },
  {
   "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": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "\n",
    "def process_image(image):\n",
    "    ''' Scales, crops, and normalizes a PIL image for a PyTorch model,\n",
    "        returns an Numpy array\n",
    "    '''\n",
    "    \n",
    "    # TODO: Process a PIL image for use in a PyTorch model\n",
    "    \n",
    "    #defining means and standard dev.\n",
    "    means=np.array([0.485,0.456,0.406])\n",
    "    sd=np.array([0.229,0.224,0.225])\n",
    "    \n",
    "    \n",
    "    #defining transforms for resize and center crop\n",
    "    transform=transforms.Compose([\n",
    "        transforms.Resize(256),\n",
    "        transforms.CenterCrop(224),\n",
    "        transforms.ToTensor()])\n",
    "    \n",
    "    \n",
    "    #opening the image\n",
    "    image_pil=Image.open(image)\n",
    "    \n",
    "    #resizing and center cropping the PIL image\n",
    "    image_pil=transform(image_pil)\n",
    "    \n",
    "    #converting the PIL image to a Numpy array\n",
    "    np_image=np.array(image_pil)\n",
    "    \n",
    "    #Normalizing the image\n",
    "    normalized_im=(np.transpose(np_image,(1,2,0))-means)/sd\n",
    "    \n",
    "    #transposing to color channel being the first dimension\n",
    "    normalized_im=np.transpose(normalized_im, (2,0,1))\n",
    "    \n",
    "    return normalized_im\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": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torchvision.models.vgg.VGG"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fbb8c0c7198>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "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",
    "\n",
    "imshow(process_image('flowers/train/1/image_06740.jpg'))\n",
    "type(model)\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": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'torchvision.models.vgg.VGG'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(tensor([[ 0.9686,  0.0287,  0.0015,  0.0004,  0.0001]], device='cuda:0'),\n",
       " tensor([[  0,  87,  76,  93,  95]], device='cuda:0'))"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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",
    "    #processing the image\n",
    "    image=process_image(image_path)\n",
    "    \n",
    "    #converting the numpy image to a tensor\n",
    "    tensor=torch.from_numpy(image)\n",
    "    tensor=tensor.float().unsqueeze_(0).to(device)\n",
    "    \n",
    "    print(type(model))\n",
    "    \n",
    "    model.eval()\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        \n",
    "        model=model.to(device)\n",
    "        \n",
    "        ps=torch.exp(model(tensor))\n",
    "        top_prob,top_cls=ps.topk(topk, dim=1)\n",
    "        \n",
    "    return top_prob, top_cls\n",
    "\n",
    "predict('./flowers/train/1/image_06740.jpg', model)\n",
    "\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/workspace/aipnd-project/flowers/test/1/'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()+'/flowers/test/1/'"
   ]
  },
  {
   "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": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'torchvision.models.vgg.VGG'>\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fbb8c317b38>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Display an image along with the top 5 classes\n",
    "\n",
    "#Setting currentdir to be the workspace\n",
    "currentdir='/home/workspace/aipnd-project/'\n",
    "#Setting the image path to be test image folder path\n",
    "img_path='/home/workspace/aipnd-project/flowers/test/18/'\n",
    "#Setting the image to be any image in test image folder\n",
    "test_img='./flowers/test/18/image_04277.jpg'\n",
    "\n",
    "#Converting from class integer encoding to actual flower names with cat_to_name.json\n",
    "with open('cat_to_name.json', 'r') as f:\n",
    "    mapper = json.load(f)\n",
    "\n",
    "#isolating the test name and passing it to cat_to_name to identify the actual flower name\n",
    "flower_name = mapper[img_path.split('/')[-2]]\n",
    "\n",
    "#creating a 2X1 subplots\n",
    "\n",
    "figure, (ax1,ax2)= plt.subplots(2,1)\n",
    "\n",
    "#convert the NumPy array image to a tensor\n",
    "image=process_image(test_img)\n",
    "#tensor=torch.from_numpy(image)\n",
    "#tensor=tensor.float().unsqueeze_(0).to(device)\n",
    "\n",
    "#showing the actual flower on the axes without its actual name\n",
    "imshow(image, ax1)\n",
    "ax1.axis(\"off\")\n",
    "\n",
    "#prediction work below\n",
    "\n",
    "model=load_checkpoint(currentdir+ 'checkpoint.pth')\n",
    "\n",
    "top_probs, top_labels=predict(test_img, model)\n",
    "\n",
    "#Creating a dataframe combining class with name of the flower\n",
    "data_frame= pd.DataFrame({'class': pd.Series(model.class_to_idx), 'flower_name':pd.Series(cat_to_name)})\n",
    "\n",
    "#Setting the index as class\n",
    "data_frame= data_frame.set_index('class')\n",
    "\n",
    "#dataframe limiting to top values and subsequently adding the predictions of those values\n",
    "data_frame= data_frame.iloc[top_labels[0]]\n",
    "data_frame['predict']= top_probs[0]\n",
    "\n",
    "#creating a new subplot\n",
    "plt.subplot(2,1,2)\n",
    "\n",
    "#setting the color palette seagreen with seaborn\n",
    "with sb.dark_palette(\"seagreen\", reverse=True):\n",
    "    sb.barplot(x=data_frame['predict'], y=data_frame['flower_name'])\n",
    "    \n",
    "plt.show()"
   ]
  },
  {
   "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
}