finetuning_torchvision_models_tutorial.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "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.6"
    },
    "colab": {
      "name": "finetuning_torchvision_models_tutorial.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "a517164c526a4d728cb1cd1dc43a38be": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "state": {
            "_view_name": "HBoxView",
            "_dom_classes": [],
            "_model_name": "HBoxModel",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "box_style": "",
            "layout": "IPY_MODEL_7970a1268e3348558818f4c5419ae5f2",
            "_model_module": "@jupyter-widgets/controls",
            "children": [
              "IPY_MODEL_df71252281264d8aabb7d2cc3a211049",
              "IPY_MODEL_05ba9c708e054ebaae476c7944b1e288"
            ]
          }
        },
        "7970a1268e3348558818f4c5419ae5f2": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "df71252281264d8aabb7d2cc3a211049": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "IntProgressModel",
          "state": {
            "_view_name": "ProgressView",
            "style": "IPY_MODEL_1d75bee240dd43b38b8055183215b28f",
            "_dom_classes": [],
            "description": "100%",
            "_model_name": "IntProgressModel",
            "bar_style": "success",
            "max": 5017600,
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": 5017600,
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "orientation": "horizontal",
            "min": 0,
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_aed7892bce9b403f88f6e13218bb52cb"
          }
        },
        "05ba9c708e054ebaae476c7944b1e288": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "state": {
            "_view_name": "HTMLView",
            "style": "IPY_MODEL_0f0f6dbd723c4a81a9adf7819b455464",
            "_dom_classes": [],
            "description": "",
            "_model_name": "HTMLModel",
            "placeholder": "​",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": " 4.79M/4.79M [00:00&lt;00:00, 5.11MB/s]",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_1388484c8cbc45b38d6bb3c5b25b2749"
          }
        },
        "1d75bee240dd43b38b8055183215b28f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "ProgressStyleModel",
            "description_width": "initial",
            "_view_module": "@jupyter-widgets/base",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.2.0",
            "bar_color": null,
            "_model_module": "@jupyter-widgets/controls"
          }
        },
        "aed7892bce9b403f88f6e13218bb52cb": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "0f0f6dbd723c4a81a9adf7819b455464": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "DescriptionStyleModel",
            "description_width": "",
            "_view_module": "@jupyter-widgets/base",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.2.0",
            "_model_module": "@jupyter-widgets/controls"
          }
        },
        "1388484c8cbc45b38d6bb3c5b25b2749": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        }
      }
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mashyko/Image-Classifier/blob/master/finetuning_torchvision_models_tutorial.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nYUgwKQAE9v6",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "Finetuning Torchvision Models\n",
        "=============================\n",
        "\n",
        "Adopted from the demo code written by Nathan Inkawhich <https://github.com/inkawhich>\n",
        "\n",
        "Modified by mashyk\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oBk1JJjME9v7",
        "colab_type": "text"
      },
      "source": [
        " We will use pretrained models, trained using 1000-class Imagenet datasets（more than 14million images）\n",
        " \n",
        "  two types of transfer learning:　\n",
        "\n",
        "**finetuning**, we start with a\n",
        "pretrained model and update *all* of the model’s parameters for our new\n",
        "task, in essence retraining the whole model. \n",
        "\n",
        "**feature extraction**,\n",
        "we start with a pretrained model and only update the final layer weights\n",
        "from which we derive predictions. \n",
        "\n",
        "In general both transfer learning methods follow the same few steps:\n",
        "\n",
        "-  Initialize the pretrained model\n",
        "-  Reshape the final layer(s) to have the same number of outputs as the\n",
        "   number of classes in the new dataset\n",
        "-  Define for the optimization algorithm which parameters we want to\n",
        "   update during training\n",
        "-  Run the training step\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bUgJmgqKmciT",
        "colab_type": "text"
      },
      "source": [
        "We will use the\n",
        "*hymenoptera_data* dataset which can be downloaded\n",
        "`here <https://download.pytorch.org/tutorial/hymenoptera_data.zip>`__.\n",
        "This dataset contains two classes, **bees** and **ants**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oE-9mhGClKEJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%matplotlib inline"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S4xhFd4xE9v8",
        "colab_type": "code",
        "outputId": "6fd4da52-5eb5-47f7-cc6d-21b96c9bf3f2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "from __future__ import print_function \n",
        "from __future__ import division\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import numpy as np\n",
        "import torchvision\n",
        "from torchvision import datasets, models, transforms\n",
        "import matplotlib.pyplot as plt\n",
        "import time\n",
        "import os\n",
        "import copy\n",
        "print(\"PyTorch Version: \",torch.__version__)\n",
        "print(\"Torchvision Version: \",torchvision.__version__)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "PyTorch Version:  1.4.0\n",
            "Torchvision Version:  0.5.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9C1bt8gEAZor",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!wget https://download.pytorch.org/tutorial/hymenoptera_data.zip\n",
        "!unzip hymenoptera_data.zip\n",
        "!rm hymenoptera_data.zip"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w3qYxgWsE9v_",
        "colab_type": "text"
      },
      "source": [
        "Inputs\n",
        "------\n",
        "\n",
        " data_dir = input to the root directory of the dataset. \n",
        " \n",
        "model_name = the name of the model you wish to use and must\n",
        "be selected from this list:\n",
        "\n",
        "   [resnet, alexnet, vgg, squeezenet, densenet, inception]\n",
        "\n",
        "num_classes = the number of\n",
        "classes in the dataset, \n",
        "\n",
        "batch_size = the batch size used for\n",
        "training and may be adjusted according to the capability of your\n",
        "machine, \n",
        "\n",
        "num_epochs = the number of training epochs we want to run,\n",
        "and \n",
        "\n",
        "feature_extract = a boolean that defines if we are finetuning\n",
        "or feature extracting. \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RN_oHwKOE9wA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "# Top level data directory. Here we assume the format of the directory conforms \n",
        "#   to the ImageFolder structure\n",
        "data_dir = \"./hymenoptera_data\"\n",
        "\n",
        "# Models to choose from [resnet, alexnet, vgg, squeezenet, densenet, inception]\n",
        "model_name = \"squeezenet\"\n",
        "\n",
        "# Number of classes in the dataset\n",
        "num_classes = 2\n",
        "\n",
        "# Batch size for training (change depending on how much memory you have)\n",
        "batch_size = 8\n",
        "\n",
        "# Number of epochs to train for \n",
        "num_epochs = 15\n",
        "\n",
        "# Flag for feature extracting. When False, we finetune the whole model, \n",
        "#   when True we only update the reshaped layer params\n",
        "#feature_extract = False\n",
        "feature_extract = True"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "78fWIL1YE9wE",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "# Model Training and Validation Code\n",
        "\n",
        "The ``train_model`` function handles the training and validation of a\n",
        "given model. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eGaeg2cwE9wE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def train_model(model, dataloaders, criterion, optimizer, num_epochs=25, is_inception=False):\n",
        "    since = time.time()\n",
        "\n",
        "    val_acc_history = []\n",
        "    \n",
        "    best_model_wts = copy.deepcopy(model.state_dict())\n",
        "    best_acc = 0.0\n",
        "\n",
        "    for epoch in range(num_epochs):\n",
        "        print('Epoch {}/{}'.format(epoch, num_epochs - 1))\n",
        "        print('-' * 10)\n",
        "\n",
        "        # Each epoch has a training and validation phase\n",
        "        for phase in ['train', 'val']:\n",
        "            if phase == 'train':\n",
        "                model.train()  # Set model to training mode\n",
        "            else:\n",
        "                model.eval()   # Set model to evaluate mode\n",
        "\n",
        "            running_loss = 0.0\n",
        "            running_corrects = 0\n",
        "\n",
        "            # Iterate over data.\n",
        "            for inputs, labels in dataloaders[phase]:\n",
        "                inputs = inputs.to(device)\n",
        "                labels = labels.to(device)\n",
        "\n",
        "                # zero the parameter gradients\n",
        "                optimizer.zero_grad()\n",
        "\n",
        "                # forward\n",
        "                # track history if only in train\n",
        "                with torch.set_grad_enabled(phase == 'train'):\n",
        "                    # Get model outputs and calculate loss\n",
        "                    # Special case for inception because in training it has an auxiliary output. In train\n",
        "                    #   mode we calculate the loss by summing the final output and the auxiliary output\n",
        "                    #   but in testing we only consider the final output.\n",
        "                    if is_inception and phase == 'train':\n",
        "                        # From https://discuss.pytorch.org/t/how-to-optimize-inception-model-with-auxiliary-classifiers/7958\n",
        "                        outputs, aux_outputs = model(inputs)\n",
        "                        loss1 = criterion(outputs, labels)\n",
        "                        loss2 = criterion(aux_outputs, labels)\n",
        "                        loss = loss1 + 0.4*loss2\n",
        "                    else:\n",
        "                        outputs = model(inputs)\n",
        "                        loss = criterion(outputs, labels)\n",
        "\n",
        "                    _, preds = torch.max(outputs, 1)\n",
        "\n",
        "                    # backward + optimize only if in training phase\n",
        "                    if phase == 'train':\n",
        "                        loss.backward()\n",
        "                        optimizer.step()\n",
        "\n",
        "                # statistics\n",
        "                running_loss += loss.item() * inputs.size(0)\n",
        "                running_corrects += torch.sum(preds == labels.data)\n",
        "\n",
        "            epoch_loss = running_loss / len(dataloaders[phase].dataset)\n",
        "            epoch_acc = running_corrects.double() / len(dataloaders[phase].dataset)\n",
        "\n",
        "            print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))\n",
        "\n",
        "            # deep copy the model\n",
        "            if phase == 'val' and epoch_acc > best_acc:\n",
        "                best_acc = epoch_acc\n",
        "                best_model_wts = copy.deepcopy(model.state_dict())\n",
        "            if phase == 'val':\n",
        "                val_acc_history.append(epoch_acc)\n",
        "\n",
        "        print()\n",
        "\n",
        "    time_elapsed = time.time() - since\n",
        "    print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))\n",
        "    print('Best val Acc: {:4f}'.format(best_acc))\n",
        "\n",
        "    # load best model weights\n",
        "    model.load_state_dict(best_model_wts)\n",
        "    return model, val_acc_history"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ejBenurBE9wJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def set_parameter_requires_grad(model, feature_extracting):\n",
        "    if feature_extracting:\n",
        "        for param in model.parameters():\n",
        "            param.requires_grad = False"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-05e4pxxE9wM",
        "colab_type": "text"
      },
      "source": [
        "Initialize and Reshape the Networks\n",
        "-----------------------------------\n",
        "\n",
        "Now to the most interesting part. Here is where we handle the reshaping\n",
        "of each network. Note, this is not an automatic procedure and is unique\n",
        "to each model. Recall, the final layer of a CNN model, which is often\n",
        "times an FC layer, has the same number of nodes as the number of output\n",
        "classes in the dataset. Since all of the models have been pretrained on\n",
        "Imagenet, they all have output layers of size 1000, one node for each\n",
        "class. The goal here is to reshape the last layer to have the same\n",
        "number of inputs as before, AND to have the same number of outputs as\n",
        "the number of classes in the dataset. \n",
        "\n",
        "When feature extracting, we only want to update the parameters of the\n",
        "last layer, or in other words, we only want to update the parameters for\n",
        "the layer(s) we are reshaping. Therefore, we do not need to compute the\n",
        "gradients of the parameters that we are not changing, so for efficiency\n",
        "we set the .requires_grad attribute to False. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OJiZWESpE9wN",
        "colab_type": "code",
        "outputId": "5dd8ce47-4a3a-423e-fce7-f85eaeb9709d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000,
          "referenced_widgets": [
            "a517164c526a4d728cb1cd1dc43a38be",
            "7970a1268e3348558818f4c5419ae5f2",
            "df71252281264d8aabb7d2cc3a211049",
            "05ba9c708e054ebaae476c7944b1e288",
            "1d75bee240dd43b38b8055183215b28f",
            "aed7892bce9b403f88f6e13218bb52cb",
            "0f0f6dbd723c4a81a9adf7819b455464",
            "1388484c8cbc45b38d6bb3c5b25b2749"
          ]
        }
      },
      "source": [
        "def initialize_model(model_name, num_classes, feature_extract, use_pretrained=True):\n",
        "    # Initialize these variables which will be set in this if statement. Each of these\n",
        "    #   variables is model specific.\n",
        "    model_ft = None\n",
        "    input_size = 0\n",
        "\n",
        "    if model_name == \"resnet\":\n",
        "        \"\"\" Resnet18\n",
        "        \"\"\"\n",
        "        model_ft = models.resnet18(pretrained=use_pretrained)\n",
        "        set_parameter_requires_grad(model_ft, feature_extract)\n",
        "        num_ftrs = model_ft.fc.in_features\n",
        "        model_ft.fc = nn.Linear(num_ftrs, num_classes)\n",
        "        input_size = 224\n",
        "\n",
        "    elif model_name == \"alexnet\":\n",
        "        \"\"\" Alexnet\n",
        "        \"\"\"\n",
        "        model_ft = models.alexnet(pretrained=use_pretrained)\n",
        "        set_parameter_requires_grad(model_ft, feature_extract)\n",
        "        num_ftrs = model_ft.classifier[6].in_features\n",
        "        model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes)\n",
        "        input_size = 224\n",
        "\n",
        "    elif model_name == \"vgg\":\n",
        "        \"\"\" VGG11_bn\n",
        "        \"\"\"\n",
        "        model_ft = models.vgg11_bn(pretrained=use_pretrained)\n",
        "        set_parameter_requires_grad(model_ft, feature_extract)\n",
        "        num_ftrs = model_ft.classifier[6].in_features\n",
        "        model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes)\n",
        "        input_size = 224\n",
        "\n",
        "    elif model_name == \"squeezenet\":\n",
        "        \"\"\" Squeezenet\n",
        "        \"\"\"\n",
        "        model_ft = models.squeezenet1_0(pretrained=use_pretrained)\n",
        "        set_parameter_requires_grad(model_ft, feature_extract)\n",
        "        model_ft.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1,1), stride=(1,1))\n",
        "        model_ft.num_classes = num_classes\n",
        "        input_size = 224\n",
        "\n",
        "    elif model_name == \"densenet\":\n",
        "        \"\"\" Densenet\n",
        "        \"\"\"\n",
        "        model_ft = models.densenet121(pretrained=use_pretrained)\n",
        "        set_parameter_requires_grad(model_ft, feature_extract)\n",
        "        num_ftrs = model_ft.classifier.in_features\n",
        "        model_ft.classifier = nn.Linear(num_ftrs, num_classes) \n",
        "        input_size = 224\n",
        "\n",
        "    elif model_name == \"inception\":\n",
        "        \"\"\" Inception v3 \n",
        "        Be careful, expects (299,299) sized images and has auxiliary output\n",
        "        \"\"\"\n",
        "        model_ft = models.inception_v3(pretrained=use_pretrained)\n",
        "        set_parameter_requires_grad(model_ft, feature_extract)\n",
        "        # Handle the auxilary net\n",
        "        num_ftrs = model_ft.AuxLogits.fc.in_features\n",
        "        model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes)\n",
        "        # Handle the primary net\n",
        "        num_ftrs = model_ft.fc.in_features\n",
        "        model_ft.fc = nn.Linear(num_ftrs,num_classes)\n",
        "        input_size = 299\n",
        "\n",
        "    else:\n",
        "        print(\"Invalid model name, exiting...\")\n",
        "        exit()\n",
        "    \n",
        "    return model_ft, input_size\n",
        "\n",
        "# Initialize the model for this run\n",
        "model_ft, input_size = initialize_model(model_name, num_classes, feature_extract, use_pretrained=True)\n",
        "\n",
        "# Print the model we just instantiated\n",
        "print(model_ft)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading: \"https://download.pytorch.org/models/squeezenet1_0-a815701f.pth\" to /root/.cache/torch/checkpoints/squeezenet1_0-a815701f.pth\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "a517164c526a4d728cb1cd1dc43a38be",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": [
              "HBox(children=(IntProgress(value=0, max=5017600), HTML(value='')))"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "SqueezeNet(\n",
            "  (features): Sequential(\n",
            "    (0): Conv2d(3, 96, kernel_size=(7, 7), stride=(2, 2))\n",
            "    (1): ReLU(inplace=True)\n",
            "    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)\n",
            "    (3): Fire(\n",
            "      (squeeze): Conv2d(96, 16, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (squeeze_activation): ReLU(inplace=True)\n",
            "      (expand1x1): Conv2d(16, 64, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (expand1x1_activation): ReLU(inplace=True)\n",
            "      (expand3x3): Conv2d(16, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "      (expand3x3_activation): ReLU(inplace=True)\n",
            "    )\n",
            "    (4): Fire(\n",
            "      (squeeze): Conv2d(128, 16, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (squeeze_activation): ReLU(inplace=True)\n",
            "      (expand1x1): Conv2d(16, 64, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (expand1x1_activation): ReLU(inplace=True)\n",
            "      (expand3x3): Conv2d(16, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "      (expand3x3_activation): ReLU(inplace=True)\n",
            "    )\n",
            "    (5): Fire(\n",
            "      (squeeze): Conv2d(128, 32, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (squeeze_activation): ReLU(inplace=True)\n",
            "      (expand1x1): Conv2d(32, 128, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (expand1x1_activation): ReLU(inplace=True)\n",
            "      (expand3x3): Conv2d(32, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "      (expand3x3_activation): ReLU(inplace=True)\n",
            "    )\n",
            "    (6): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)\n",
            "    (7): Fire(\n",
            "      (squeeze): Conv2d(256, 32, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (squeeze_activation): ReLU(inplace=True)\n",
            "      (expand1x1): Conv2d(32, 128, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (expand1x1_activation): ReLU(inplace=True)\n",
            "      (expand3x3): Conv2d(32, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "      (expand3x3_activation): ReLU(inplace=True)\n",
            "    )\n",
            "    (8): Fire(\n",
            "      (squeeze): Conv2d(256, 48, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (squeeze_activation): ReLU(inplace=True)\n",
            "      (expand1x1): Conv2d(48, 192, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (expand1x1_activation): ReLU(inplace=True)\n",
            "      (expand3x3): Conv2d(48, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "      (expand3x3_activation): ReLU(inplace=True)\n",
            "    )\n",
            "    (9): Fire(\n",
            "      (squeeze): Conv2d(384, 48, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (squeeze_activation): ReLU(inplace=True)\n",
            "      (expand1x1): Conv2d(48, 192, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (expand1x1_activation): ReLU(inplace=True)\n",
            "      (expand3x3): Conv2d(48, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "      (expand3x3_activation): ReLU(inplace=True)\n",
            "    )\n",
            "    (10): Fire(\n",
            "      (squeeze): Conv2d(384, 64, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (squeeze_activation): ReLU(inplace=True)\n",
            "      (expand1x1): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (expand1x1_activation): ReLU(inplace=True)\n",
            "      (expand3x3): Conv2d(64, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "      (expand3x3_activation): ReLU(inplace=True)\n",
            "    )\n",
            "    (11): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)\n",
            "    (12): Fire(\n",
            "      (squeeze): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (squeeze_activation): ReLU(inplace=True)\n",
            "      (expand1x1): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
            "      (expand1x1_activation): ReLU(inplace=True)\n",
            "      (expand3x3): Conv2d(64, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "      (expand3x3_activation): ReLU(inplace=True)\n",
            "    )\n",
            "  )\n",
            "  (classifier): Sequential(\n",
            "    (0): Dropout(p=0.5, inplace=False)\n",
            "    (1): Conv2d(512, 2, kernel_size=(1, 1), stride=(1, 1))\n",
            "    (2): ReLU(inplace=True)\n",
            "    (3): AdaptiveAvgPool2d(output_size=(1, 1))\n",
            "  )\n",
            ")\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9dnelAhmE9wQ",
        "colab_type": "text"
      },
      "source": [
        "Data augmentation and Load Data\n",
        "---------\n",
        "\n",
        "Now that we know what the input size must be, we can initialize the data\n",
        "transforms, image datasets, and the dataloaders. \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "euZ0Sqy1poKj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "03-4tFUYE9wR",
        "colab_type": "code",
        "outputId": "4c548877-4800-41dc-caab-4ac5d42bfa9f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# Data augmentation and normalization for training\n",
        "# Just normalization for validation\n",
        "data_transforms = {\n",
        "    'train': transforms.Compose([\n",
        "        transforms.RandomResizedCrop(input_size),\n",
        "        transforms.RandomHorizontalFlip(),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
        "    ]),\n",
        "    'val': transforms.Compose([\n",
        "        transforms.Resize(input_size),\n",
        "        transforms.CenterCrop(input_size),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
        "    ]),\n",
        "}\n",
        "\n",
        "print(\"Initializing Datasets and Dataloaders...\")\n",
        "\n",
        "# Create training and validation datasets\n",
        "image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x]) for x in ['train', 'val']}\n",
        "# Create training and validation dataloaders\n",
        "dataloaders_dict = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True, num_workers=4) for x in ['train', 'val']}\n",
        "\n",
        "class_names = image_datasets['train'].classes\n",
        "\n",
        "# Detect if we have a GPU available\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Initializing Datasets and Dataloaders...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bw26ikglUXyd",
        "colab_type": "code",
        "outputId": "ee8fca9f-0746-4f09-93ff-97d9e81d64ae",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 106
        }
      },
      "source": [
        "def imshow(inp, title=None):\n",
        "    \"\"\"Imshow for Tensor.\"\"\"\n",
        "    inp = inp.numpy().transpose((1, 2, 0))\n",
        "    mean = np.array([0.485, 0.456, 0.406])\n",
        "    std = np.array([0.229, 0.224, 0.225])\n",
        "    inp = std * inp + mean\n",
        "    inp = np.clip(inp, 0, 1)\n",
        "    plt.imshow(inp)\n",
        "    if title is not None:\n",
        "        plt.title(title)\n",
        "\n",
        "# Get a batch of training data\n",
        "inputs, classes = next(iter(dataloaders_dict['train']))\n",
        "\n",
        "# Make a grid from batch\n",
        "out = torchvision.utils.make_grid(inputs)\n",
        "\n",
        "imshow(out, title=[class_names[x] for x in classes])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FAqw2ICxE9wV",
        "colab_type": "text"
      },
      "source": [
        "Create the Optimizer\n",
        "--------------------\n",
        "\n",
        "Now that the model structure is correct, the final step for finetuning\n",
        "and feature extracting is to create an optimizer that only updates the\n",
        "desired parameters. Recall that after loading the pretrained model, but\n",
        "before reshaping, if ``feature_extract=True`` we manually set all of the\n",
        "parameter’s ``.requires_grad`` attributes to False. Then the\n",
        "reinitialized layer’s parameters have ``.requires_grad=True`` by\n",
        "default. So now we know that *all parameters that have\n",
        ".requires_grad=True should be optimized.* Next, we make a list of such\n",
        "parameters and input this list to the SGD algorithm constructor.\n",
        "\n",
        "To verify this, check out the printed parameters to learn. When\n",
        "finetuning, this list should be long and include all of the model\n",
        "parameters. However, when feature extracting this list should be short\n",
        "and only include the weights and biases of the reshaped layers.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O5GnwRXSE9wV",
        "colab_type": "code",
        "outputId": "38861a17-d077-467c-b49a-6f5c516dd30d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "# Send the model to GPU\n",
        "model_ft = model_ft.to(device)\n",
        "\n",
        "# Gather the parameters to be optimized/updated in this run. If we are\n",
        "#  finetuning we will be updating all parameters. However, if we are \n",
        "#  doing feature extract method, we will only update the parameters\n",
        "#  that we have just initialized, i.e. the parameters with requires_grad\n",
        "#  is True.\n",
        "params_to_update = model_ft.parameters()\n",
        "print(\"Params to learn:\")\n",
        "if feature_extract:\n",
        "    params_to_update = []\n",
        "    for name,param in model_ft.named_parameters():\n",
        "        if param.requires_grad == True:\n",
        "            params_to_update.append(param)\n",
        "            print(\"\\t\",name)\n",
        "else:\n",
        "    for name,param in model_ft.named_parameters():\n",
        "        if param.requires_grad == True:\n",
        "            print(\"\\t\",name)\n",
        "\n",
        "# Observe that all parameters are being optimized\n",
        "optimizer_ft = optim.SGD(params_to_update, lr=0.001, momentum=0.9)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Params to learn:\n",
            "\t classifier.1.weight\n",
            "\t classifier.1.bias\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zsScS3Z8E9wZ",
        "colab_type": "text"
      },
      "source": [
        "Run Training and Validation Step\n",
        "--------------------------------\n",
        "\n",
        "Finally, the last step is to setup the loss for the model, then run the\n",
        "training and validation function for the set number of epochs. Notice,\n",
        "depending on the number of epochs this step may take a while on a CPU.\n",
        "Also, the default learning rate is not optimal for all of the models, so\n",
        "to achieve maximum accuracy it would be necessary to tune for each model\n",
        "separately.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U840Nj7JE9wZ",
        "colab_type": "code",
        "outputId": "b81b6d48-20b5-4bb5-deeb-bfb03cb0f069",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "# Setup the loss fxn\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "\n",
        "# Train and evaluate\n",
        "model_ft, hist = train_model(model_ft, dataloaders_dict, criterion, optimizer_ft, num_epochs=num_epochs, is_inception=(model_name==\"inception\"))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 0/14\n",
            "----------\n",
            "train Loss: 0.5917 Acc: 0.7008\n",
            "val Loss: 0.4306 Acc: 0.8366\n",
            "\n",
            "Epoch 1/14\n",
            "----------\n",
            "train Loss: 0.3460 Acc: 0.8484\n",
            "val Loss: 0.2950 Acc: 0.9150\n",
            "\n",
            "Epoch 2/14\n",
            "----------\n",
            "train Loss: 0.2264 Acc: 0.9016\n",
            "val Loss: 0.2615 Acc: 0.9346\n",
            "\n",
            "Epoch 3/14\n",
            "----------\n",
            "train Loss: 0.2201 Acc: 0.9221\n",
            "val Loss: 0.2595 Acc: 0.9346\n",
            "\n",
            "Epoch 4/14\n",
            "----------\n",
            "train Loss: 0.2093 Acc: 0.9139\n",
            "val Loss: 0.3133 Acc: 0.9346\n",
            "\n",
            "Epoch 5/14\n",
            "----------\n",
            "train Loss: 0.2002 Acc: 0.9139\n",
            "val Loss: 0.2608 Acc: 0.9216\n",
            "\n",
            "Epoch 6/14\n",
            "----------\n",
            "train Loss: 0.2304 Acc: 0.8893\n",
            "val Loss: 0.2725 Acc: 0.9281\n",
            "\n",
            "Epoch 7/14\n",
            "----------\n",
            "train Loss: 0.1673 Acc: 0.9262\n",
            "val Loss: 0.3172 Acc: 0.9150\n",
            "\n",
            "Epoch 8/14\n",
            "----------\n",
            "train Loss: 0.2081 Acc: 0.9221\n",
            "val Loss: 0.3274 Acc: 0.9216\n",
            "\n",
            "Epoch 9/14\n",
            "----------\n",
            "train Loss: 0.1464 Acc: 0.9426\n",
            "val Loss: 0.3706 Acc: 0.8889\n",
            "\n",
            "Epoch 10/14\n",
            "----------\n",
            "train Loss: 0.2408 Acc: 0.8934\n",
            "val Loss: 0.2945 Acc: 0.9346\n",
            "\n",
            "Epoch 11/14\n",
            "----------\n",
            "train Loss: 0.1934 Acc: 0.9057\n",
            "val Loss: 0.2978 Acc: 0.9412\n",
            "\n",
            "Epoch 12/14\n",
            "----------\n",
            "train Loss: 0.1170 Acc: 0.9590\n",
            "val Loss: 0.3051 Acc: 0.9412\n",
            "\n",
            "Epoch 13/14\n",
            "----------\n",
            "train Loss: 0.1245 Acc: 0.9508\n",
            "val Loss: 0.3392 Acc: 0.9346\n",
            "\n",
            "Epoch 14/14\n",
            "----------\n",
            "train Loss: 0.1399 Acc: 0.9426\n",
            "val Loss: 0.3443 Acc: 0.9281\n",
            "\n",
            "Training complete in 0m 46s\n",
            "Best val Acc: 0.941176\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qFzDqd67CxY5",
        "colab_type": "code",
        "outputId": "095230f4-b279-4362-c308-1c63e983f515",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 264
        }
      },
      "source": [
        "def visualize_model(model, num_images=6):\n",
        "    was_training = model.training\n",
        "    model.eval()\n",
        "    images_so_far = 0\n",
        "    fig = plt.figure()\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for i, (inputs, labels) in enumerate(dataloaders_dict['val']):\n",
        "            inputs = inputs.to(device)\n",
        "            labels = labels.to(device)\n",
        "\n",
        "            outputs = model(inputs)\n",
        "            _, preds = torch.max(outputs, 1)\n",
        "\n",
        "            for j in range(inputs.size()[0]):\n",
        "                images_so_far += 1\n",
        "                ax = plt.subplot(num_images//2, 2, images_so_far)\n",
        "                ax.axis('off')\n",
        "                ax.set_title('predicted: {}'.format(class_names[preds[j]]))\n",
        "                imshow(inputs.cpu().data[j])\n",
        "\n",
        "                if images_so_far == num_images:\n",
        "                    model.train(mode=was_training)\n",
        "                    return\n",
        "        model.train(mode=was_training)\n",
        "\n",
        "visualize_model(model_ft)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 6 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zzCODf0hpvWr",
        "colab_type": "text"
      },
      "source": [
        "Ending of code"
      ]
    }
  ]
}