Cat&Dog_Resnet18.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/danielsoy/ALOCC-CVPR2018/blob/master/Cat%26Dog_Resnet18.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SKXgrDeMjR9I"
      },
      "source": [
        "## **Libraries / Hardware Check / Dataset Download**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lvYKhXpLwyxG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ff09e17c-f0cc-48c9-cfe6-77b1b22c7855"
      },
      "source": [
        "#@title Load Libraries\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.optim import lr_scheduler\n",
        "import torchvision\n",
        "from torchvision import datasets, models, transforms\n",
        "import tensorflow as tf\n",
        "from matplotlib import pyplot\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.image import imread\n",
        "import os\n",
        "import time\n",
        "import copy\n",
        "from os import listdir\n",
        "\n",
        "from tensorflow.keras.utils import load_img\n",
        "from tensorflow.keras.utils import image_dataset_from_directory\n",
        "\n",
        "from os import makedirs\n",
        "from os import listdir\n",
        "from shutil import copyfile\n",
        "from random import seed\n",
        "from random import random\n",
        "from tqdm import tqdm\n",
        "from PIL import Image\n",
        "from google.colab import files\n",
        "!pip install kaggle\n",
        "\n",
        "#Author - Dev Dash MD"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: kaggle in /usr/local/lib/python3.7/dist-packages (1.5.12)\n",
            "Requirement already satisfied: urllib3 in /usr/local/lib/python3.7/dist-packages (from kaggle) (1.24.3)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from kaggle) (2.23.0)\n",
            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.7/dist-packages (from kaggle) (2.8.2)\n",
            "Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.7/dist-packages (from kaggle) (1.15.0)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from kaggle) (4.64.1)\n",
            "Requirement already satisfied: python-slugify in /usr/local/lib/python3.7/dist-packages (from kaggle) (6.1.2)\n",
            "Requirement already satisfied: certifi in /usr/local/lib/python3.7/dist-packages (from kaggle) (2022.9.24)\n",
            "Requirement already satisfied: text-unidecode>=1.3 in /usr/local/lib/python3.7/dist-packages (from python-slugify->kaggle) (1.3)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->kaggle) (3.0.4)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->kaggle) (2.10)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RfK_Tolwy9js",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9197cb30-fb4b-4946-ba22-2e19da56d872"
      },
      "source": [
        "#@title CPU Details - Number & Model\n",
        "!lscpu | grep \"CPU(s):\"\n",
        "!lscpu | grep Hz\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CPU(s):              2\n",
            "NUMA node0 CPU(s):   0,1\n",
            "Model name:          Intel(R) Xeon(R) CPU @ 2.20GHz\n",
            "CPU MHz:             2199.998\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R2ypJlr60FVd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "de7ccf54-126a-468f-caae-114307654bf2"
      },
      "source": [
        "#@title Total Memory:\n",
        "!cat /proc/meminfo | grep MemTotal"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MemTotal:       13297228 kB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YWOc6XAa1G7w",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c76eec9d-0eaf-4066-c928-ac392effea7f"
      },
      "source": [
        "#@title CUDA Check\n",
        "print('Is CUDA Available?',torch.cuda.is_available())\n",
        "if torch.cuda.is_available() == True: print('Current CUDA device:',torch.cuda.get_device_name(0))"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Is CUDA Available? True\n",
            "Current CUDA device: Tesla T4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-0wywXoP5e4O",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        },
        "outputId": "d74c6c0f-02d4-4eab-e13e-3db2669383d4"
      },
      "source": [
        "#@title Upload Kaggle JSON Here\n",
        "files.upload()"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-736d8054-37b7-4181-aee0-526f6383d20f\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-736d8054-37b7-4181-aee0-526f6383d20f\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving kaggle.json to kaggle.json\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'kaggle.json': b'{\"username\":\"tektronix475\",\"key\":\"8c1caa3881374066d6f871bbc076b119\"}'}"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sY_Yv_jS5s1P",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e5fb2518-5486-40c8-cb7e-35380fab0ae6"
      },
      "source": [
        "#@title Download Kaggle Dataset & Unzip:\n",
        "! mkdir ~/.kaggle\n",
        "! cp kaggle.json ~/.kaggle/\n",
        "! chmod 600 ~/.kaggle/kaggle.json\n",
        "!kaggle competitions download -c dogs-vs-cats\n",
        "# train.zip\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading dogs-vs-cats.zip to /content\n",
            "100% 811M/812M [00:35<00:00, 25.3MB/s]\n",
            "100% 812M/812M [00:35<00:00, 23.9MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "! cd /content/\n",
        "! unzip -q -o dogs-vs-cats.zip\n",
        "! unzip -q -o test1.zip\n",
        "! unzip -q -o train.zip\n"
      ],
      "metadata": {
        "id": "eTes1crqCt4n"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m0eYJ8hYjLLz"
      },
      "source": [
        "# **Training Data Preprocessing**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lHIqhswb7PW7"
      },
      "source": [
        "dataset_home = 'dataset_dogs_vs_cats/'\n",
        "subdirs = ['train/', 'val/']\n",
        "for subdir in subdirs:\n",
        "\t# create label subdirectories\n",
        "\tlabeldirs = ['dogs/', 'cats/']\n",
        "\tfor labldir in labeldirs:\n",
        "\t\tnewdir = dataset_home + subdir + labldir\n",
        "\t\tmakedirs(newdir, exist_ok=True)"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CzkXBP7y7z0J"
      },
      "source": [
        "seed(1)\n",
        "# define ratio of pictures to use for validation\n",
        "val_ratio = 0.25\n",
        "# copy training dataset images into subdirectories\n",
        "src_directory = 'train/'\n",
        "for file in listdir(src_directory):\n",
        "\tsrc = src_directory + '/' + file\n",
        "\tdst_dir = 'train/'\n",
        "\tif random() < val_ratio:\n",
        "\t\tdst_dir = 'val/'\n",
        "\tif file.startswith('cat'):\n",
        "\t\tdst = dataset_home + dst_dir + 'cats/'  + file\n",
        "\t\tcopyfile(src, dst)\n",
        "\telif file.startswith('dog'):\n",
        "\t\tdst = dataset_home + dst_dir + 'dogs/'  + file\n",
        "\t\tcopyfile(src, dst)"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1CfQQbz8-VdC"
      },
      "source": [
        "data_transforms = {\n",
        "    'train': transforms.Compose([\n",
        "        transforms.RandomRotation(5),\n",
        "        transforms.RandomHorizontalFlip(),\n",
        "        transforms.RandomResizedCrop(224, scale=(0.96, 1.0), ratio=(0.95, 1.05)),\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([224,224]),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
        "    ]),\n",
        "}"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YkH6KOJY-bCw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9bc9449f-2d87-4dc1-c547-fedc12a3d0e5"
      },
      "source": [
        "batch_size = 16\n",
        "data_dir = 'dataset_dogs_vs_cats/'\n",
        "image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),data_transforms[x]) for x in ['train', 'val']}\n",
        "\n",
        "dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=batch_size,shuffle=True, num_workers=4) for x in ['train', 'val']}\n",
        "dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}\n",
        "class_names = image_datasets['train'].classes\n",
        "\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "print(class_names) # => ['cats', 'dogs']\n",
        "print(f'Train image size: {dataset_sizes[\"train\"]}')\n",
        "print(f'Validation image size: {dataset_sizes[\"val\"]}')\n",
        "\n",
        "train_dataloader = torch.utils.data.DataLoader(image_datasets['train'],batch_size=batch_size,shuffle=True)\n",
        "val_dataloader = torch.utils.data.DataLoader(image_datasets['val'],batch_size=batch_size,shuffle=True)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['cats', 'dogs']\n",
            "Train image size: 18697\n",
            "Validation image size: 6303\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:566: UserWarning: This DataLoader will create 4 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
            "  cpuset_checked))\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lgn_MBl-Bc3A",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 148
        },
        "outputId": "5a4b9a00-0c53-4bfb-ecb2-2e8218741a63"
      },
      "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",
        "    plt.pause(0.001)  # pause a bit so that plots are updated\n",
        "\n",
        "\n",
        "# Get a batch of training data\n",
        "inputs, classes = next(iter(dataloaders['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": 12,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xxMjIvoqBwzw"
      },
      "source": [
        "def train_model(model, criterion, optimizer, scheduler, num_epochs=25):\n",
        "    since = time.time()\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",
        "\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",
        "                    outputs = model(inputs)\n",
        "                    _, preds = torch.max(outputs, 1)\n",
        "                    loss = criterion(outputs, labels)\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",
        "            if phase == 'train':\n",
        "                scheduler.step()\n",
        "\n",
        "            epoch_loss = running_loss / dataset_sizes[phase]\n",
        "            epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
        "\n",
        "\n",
        "            print('{} Loss: {:.4f} Acc: {:.4f}'.format(\n",
        "                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",
        "\n",
        "        print()\n",
        "\n",
        "    time_elapsed = time.time() - since\n",
        "    print('Training complete in {:.0f}m {:.0f}s'.format(\n",
        "        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"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nvwIP9GbB2GY"
      },
      "source": [
        "def visualize_model(model, num_images=8):\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['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)"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Av3X-rH_B6Ts",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ee321cdf-6db2-4169-896c-e16ef4da5c75"
      },
      "source": [
        "model_ft = models.resnet18(pretrained=False)\n",
        "num_ftrs = model_ft.fc.in_features\n",
        "# Here the size of each output sample is set to 2.\n",
        "# Alternatively, it can be generalized to nn.Linear(num_ftrs, len(class_names)).\n",
        "model_ft.fc = nn.Linear(num_ftrs, 2)\n",
        "\n",
        "model_ft = model_ft.to(device)\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "\n",
        "# Observe that all parameters are being optimized\n",
        "optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9)\n",
        "\n",
        "# Decay LR by a factor of 0.1 every 7 epochs\n",
        "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torchvision/models/_utils.py:209: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and will be removed in 0.15, please use 'weights' instead.\n",
            "  f\"The parameter '{pretrained_param}' is deprecated since 0.13 and will be removed in 0.15, \"\n",
            "/usr/local/lib/python3.7/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and will be removed in 0.15. The current behavior is equivalent to passing `weights=None`.\n",
            "  warnings.warn(msg)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "le_icz-XCM5S",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3db6cf46-cd2a-4e9d-d1a9-38b7e03352ec"
      },
      "source": [
        "model_ft = train_model(model_ft, criterion, optimizer_ft, exp_lr_scheduler,\n",
        "                       num_epochs=2)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0/1\n",
            "----------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:566: UserWarning: This DataLoader will create 4 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
            "  cpuset_checked))\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train Loss: 0.6421 Acc: 0.6333\n",
            "val Loss: 0.5876 Acc: 0.6795\n",
            "\n",
            "Epoch 1/1\n",
            "----------\n",
            "train Loss: 0.5579 Acc: 0.7189\n",
            "val Loss: 0.5960 Acc: 0.7233\n",
            "\n",
            "Training complete in 4m 22s\n",
            "Best val Acc: 0.723306\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-UE-KJi8Uurp",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 633
        },
        "outputId": "a776226b-d75b-4ca5-9ffb-f5a12c7b9351"
      },
      "source": [
        "visualize_model(model_ft)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGwAAABNCAYAAABDloFeAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAZHUlEQVR4nO2decxmV33fP79z7vJs7zrvO+OZ8cw7Nl4CtuUJENuACU4hhQRDqpS00DaL0iiqEiVVVKktCY1IlUat1EaKVCEqpYWwlBBoEnVRA1mgbmhNDCUCj8HLeDyefd792e+955xf/zj3fd/Hg5fJAk8mnt/o0XvvPfee7XvPbz93RFW5TtcOmWl34Dr92eg6YNcYXQfsGqPrgF1jdB2wa4yuA3aN0dQBE5FnROQt9fHPi8ivfxvafEBEzv4Fnv+8iPzEX2afrpaSaTT6QqSqv3I194nIh4Gzqvq+b22P/urRX+oKE5G/Ui/AX0d6ScBqlvVeEXlMRDZF5EMi0qjLHhCRsyLyz0TkIvAhETEi8s9F5KSIrIvIb4nI4kR9Pywip+uyX7iirfeLyMcmzu8Xkf8jIlsickZEfkxEfhL4+8A/FZG+iPy3+t5DIvJfRGRVRE6JyM9O1NMUkQ/X/X8M+K4/yySJyPeKyDdEZFtE/j0gE2VGRN5Xj+myiHxEROYmyn9kYrz/4goRcI+IfElEuiJySUR+9SU7o6ov+gOeAR4FjgCLwBeAX67LHgAc8G+AHGgC/xh4GLixvvYfgE/U978K6APfXZf9av38W+ry9wMfq49XgB7wHiAF9gHH67IP7/ShPjfAl4FfBDLgZuBp4K11+b8G/nfd/yP1eM5OPP8B4AMvMP6luh/vqvvxc3Wff6Iu/3HgqbrNDvDbwEevGO/9db/+LVBNjPf/Aj9cH3eA+14Sj6sE7B9NnH8/cHICsBJoTJR/HXjzxPnBupNJPaG/OVHWrp9/PsDeC/zOC/TpSsDuBZ694p73Ah+qj58G3jZR9pOTgL3E+H8EeHjiXICzE4D9IfBTE+W3XzHeT0yUta4Y70PALwFLV9MXVb1qGXZm4vg0cGjifFVVxxPnK8Dv1GxsqwbQAwfq53brUtUBsP4CbR4BTl5l/1aAQztt1u3+fN0mV7Zbj+Fq6co+6xV1HbqivtNEsJ5vvEOeO95/CNwGfENEHhGRB1+qM1erJByZOD4KnJ84v9Ldfwb4cVX9wpWViMgF4JUT5y0iq3s+OgPc8wJlz9fmKVW99QXuv0Acw4n6/OgL3PdizwIgIsJz5+M88YXZoaNElnmpfvb2iWebTIxXVZ8E3iMiBvhB4NMisq9+kZ+XrnaF/bSI3FgrD78AfPJF7v0g8K9EZKXu5LKI/EBd9mngwVqZyIB/+SJ9+DjwFhH5OyKSiMg+ETlel10iyowd+hOgVys/TRGxInKniOwoF78FvFdEFkTkRuBnrnLcAP8DuENEfrDWgn8WuGGi/BPAz4nITSLSAX4F+KSqunq87xCR19fjfT/PVVj+gYgsq2oAturL4cU6c7WA/Wfgs0RZcBL45Re599eA/wp8VkR6RAXkXgBVPQH8dF3fBWCTKA++iVT1WaK8/CfABvCnwN118X8EXlWzv99VVQ88CBwHTgFrwK8DO9raLxFZ1al6HB+dbEtEPigiH3yBfqwBP0RUXNaBW4mK1w79p7q+h+r6x9QvRD3enwF+sx5vH7gMFPWzbwNOiEi/nrd3q+ro+fqx29eXCmCKyDNEAfsHL3rjdXpJqlfgFnCrqp7689QxddfUX3cSkXeISEtE2kS1/mtEzfvPRdcB+9bTDxAVk/NEdvpu/QvkZbwkS7xOf7Xo+gq7xug6YNcYTc27/tDDD6taw4nHvsbq2adotVKSVod2e5ZGo0OaZBhjsdYixiLGICIYE98xI4IGQbCIARFQDYQdM0ZAbALBIihCdO2ICCHEe3bFQf03BAUVQlBCCM9xCYUQ8N6zubXOXXfdyQP33iffNKhvA00NMIsQVLFi6gnUaFI+3zRMXNuZZAWkLjBGIhAK1BNtjEEUQg3WlbRTT3xOCd7H6+GFOhGfEYRpyv2pAaYhIGKw1rLjUxWo3/Cwey3eHFcQSI1UfV3q84lrslMWFDRgVCLj361KiU7veCzKc9uq/+rOC6QgRlAfV5lMZV3t0dRkmDeCNwLWIhhQA2pRFTRE9hRdbCZOuoJBmGvPkiUJqnFlqARUDd4pwccVInVdkCAidf0K6gmqiCYIAcQhCiYoeIcEjxBQAhgFPIhHJCBm5yd7L8UUaLoRYgFjTc1iNLKm4HcZ2A7rCQISAvtm51icm+XZC8O4HuuJ25E3YiTKtpp1wQ7rrBtDMd4x6F5idfVpzp+9xI0HDlGNCwa9HmfOnGHx8AFuu+PVNDvLtczbqx/YlaHToqkCpqqYWoY55zEhENneDtuKIIpAO82Z77TodtcZhwrFRk4nezIlsRabJPE5rzgX9laDwMXzF/iTz3+OZ5/5BvNzKU8+cYbveeMbOHr0KJ1mzvrli6yunWNtdZs3v/1vI2J2FY6JmNZUV9j0Xpd6zIm1hKAocWKiQHnuhChKu9WkqErWe5t4AZVaOdiRRSKogvcR9CRJSNN0ty0BLpy/wJe/+DDbl9cZDxzepzx64imKUtnsj1nvjmgkM2ysbqCE3T5N/qiVlGnR1AAL6hGUVEwETAUbDARBZU9LECAJQrOZs9HvUniD8WA8aC2zolIieO/xTtEghMDEyvAoysLiEonJaORNesOSYekIQNFb4+bDS9x95+2cvbxKWQW8Brx6vDqC+l21PggvU8BCQIgywWnAaXx791jP3qQkiY1ss3KARYPsscz6zffe42vVfHJFTLKxudkZ2rM5YnMuXByQpi3edP89HD68zNxckyNHDrC4vJ9+v08x6BO8r9vYs8WMvpDS/+2h6WmJ9WSIEVQgXMFqlL18kyRJcVUVuaUaVOMKnJRfk393fjuG9s5vbn6eztw8m9s9skbGd9xymD/8oz/m0//986z1Kv7Xw1/hhsMraAiU4+GuQQ0TgBkTtcop0dQA25vUugshEEJUu7U+3nm708RSVRXOKVG539EO4z3eh+esyl15g2KMYIxFgSRrcMedr8GFwP33v5oH3/YAQVJOnVnjqdOX2X/4Vl5x63fwxjc9QJY1Ilv1usted7hCmCJgU9MSvfeICNYIxnvEO9A4yXHqfZ3WZRANnD1/gV6vYv/B/SRJVNFFBA31/SGgAiIViLDzL6r5FhUlqEGyBlm7w/LSAq1Oizc/cDfbaxuYUPK9b/4bOC/ceHSF0vud7ky4rqJLy794FP9bSlMDbEe+GGOiDzCEXR8eUKv28feNrz/Bb/zGRxGxvO8X38uxlSNRyQiBsiwpxiXbWz0GwyHSSqKRLRbE4oOStxLSxNBpzFIVjt5gxP79h5C0xfFXHWft3HnShRtZmL+Bre0tquCihqieHXaoqjjnaDQa05oyYMorbA+wmkU+B7Rkl81dvHiJM89eYmXlIPvm52g3c4JGE6DdSNGZDk98/Uk+8tFPcOzWY7z61a9heXmJRx75Ev1ej3e9629x4/5lGASOH7qFLy4fREnIWgs08zYH2wdpzS9ROo+1hnERCHhUd4ADVdlVaqZJ0/Ml+goRsLUMCyHsMkMNHiWpzaxApzNLo9ngvvvuY3FhAe8KjESgfVCCBpaW5tna3OL3P/sQp06eo9XKOfHoCW64YZnve9ubUV2i6g+4dfEwDz74drrbm7RnBRYOsbj/CI899iSf//3PcsfxOzl60wpePRDNgegqE0LwIIJ/Oar1oh7VgGXPmxBQvHo0RLsnqEfx5I0G99zznbz7Pe8hLizFe0d/MOLchVX6wxFHbzrMd937WoKHJ598kq999VFcEbBYcmtQY0jbDVI1vOHu49z0iptwRcn6hbNsrV2kv73OI1/6Mk8/+wyeULNprZWO6DLz3mF2HM5Toum5pnTPyR5tKN1lk4pGb7sPpFnC7bfexOvufS1LS/O4qkQVxqOK3/vMH/HFL32FH3rXOzl27CgnT56KyowJtZPXULkKQsB4xWeGyjia54YsHp6jGG+ztbFBNT6JiOe19x3nzrvu2O3HnjqvtRfFYwwQ3NSmbaq+xB3DWUNAg+Cci5NVg4VR9u/bx8Hl/aRJguIRUXq9EZ/5zOf4+Cc/RX9UcPddd5ClGWfPnIt+vt08dKEoCorgMUHxKI0jC5z/7afZPl3SumWGohNomhbtNOf7Hnw71YRJMKlwqEa2bQVkioBN1fUsqiCKtTbaYM7ha9C8Rsdtp9XCCHjv8K6iqkr+5+99lo987BOsrm0yHAx5/InHCc4j1mDQmDtbeySKsmJYjgmipAa0ndLLDIOvXmLjxHlUEmwfdCyUzuG9Q2tX1G60WT1BA8E7EiuIeRnKsMiyAiJ12N4HCIr4gIaAD4EkSaI3XwMx0gjBB54+9Qwb293aXVWxtb1Nu5Wz/4Z9tctWotfeB3zw5GlGIMpEMYEjb7qd2aP7+YPf/RwPffxzDE9tIxhcKAnBTaywHQO/Bs/HFT7NiPNUfYlXxpjUB/ABXzmoFRHnHONiSFGMauBgcXEBDXt+xGazSaOZ8aM/9vd4/RvuZXF5nptvPgbiabcbzM/PRTvKO4IU+DmF71zArWQsLS4we3Q/Y1MR3HM9897vKD97npdEBHw1rWmbolq/E2eKJxRFgZUMV5SkWXTkFuMx/X6PECxpmsZJDHDDgRtI0wQ3jinq1iZU1ZjbbjvKLT/1o5w/f57Lq5v82r/7AEvL+2i3W9GGCgHnYVyNadw4z9/8u2+lY1v0U2E0LpAgtbdkr487MTlUarsxarjToqkBZkQRsVityJIW/WrIyI8x0kPSBJNYSoTNzU2MdKJc8YJIwvG77+SWm4/y+ONPUnpHnhmKosD0tsltxtHDy7TbObPzMywvLZEacK4EjUFNIylajFnuLJO1m1zsblM5F0OiE5lZkb3W3n4FDR4jTJUlTg2wyoNqgnNDvvt7XkdRFAz6I7r9Ed3hgOFgwKDbI08Smg1DknbQ4AAlSwzvftc7+dSnPkWe56TW0+tuU40T8kYDEUjThAff8VYOHTqEOkcZPKrgSoc1QnAOsYJqwBcVBHDqdyMAxhgwdbgn7CgyihgzTTNsmnaYIxTbiAjNZptms8P8nHAQQzCA91RlQVEUVFVVh+WVECoUz9K+DocOzjPTmaE1M8Pm+irtZk6z0yZJU6w13HvPHaRJTlkWpGla21cwGHYZDrcZDsYUrqISG5N1rvxpzOXyyET8brppU1MDbPXco6w/PaTR2UezM0ur1aSZz5BmTUyaEDAkiUEkYzgoYxxKDCKBEIS0kfO6N95Pr9ejGI7YWLtMzwpZp83MzAytZo61XTRYWu1XICKMRmP6vQHd7ir93hbBJXiBYEHFAhP5GrWX3hBteNjLS5wmTQ0wNy7JR1tUKNV4ne2g0SayOUmWYUyGTVNm5g5gTItyHGi2oJE3aGSWtY1NGu02JrVoq4krC6qqpChKQtimLFukNsXalGJcMR5VlEXBoLvF1sYlxuMReWOBcUgIoSIxAWMNRhN2MloD7OY9muAQDHET5vTM1+l560UZhYpMKxJNMdZEQ9qPCUWBohTDhNnWMpU4er0+eZ6hJjqH+xsbjLbWoxGrDpFAllkSyVANlEWJN0reEDrtDo1Gk431dVYvnWV9bZVWa4aNjXXWemNMIjTSjDzPaTQ6JEkaE3hq9ifRzVFnedmXpy/x2NE7GGwdoD/oUbpejG+VJYSAtZY0M8wv7qfZnEO9Y3NzjWYzJTQDo9GQy+dP09tcw4eSigoErE0xtkGaJiRJRpKkiJY4VxJCTgiBjfXLlKVjaWmWRhsWly02yRCgrCrKwjMe9uk7h9c6NhciK7TWImKnKsemt8JG28zNz7NvaYm5uQUaeY5KYDAc0O12GfSHtOcWCGlCOeqxubnG/MIcqsLm1iqjoocaRwgVwcVUA+ccXnuMYDfY2Gq10OCpqoqNzXXGxZCFhQXm5pbY7F4mM0Ijz0jzFJskWJNjjI1aoggueMajgu2tbm2XScxSnhJNDbAzZ5+NriIRrM3IsozEWvYt7qPdbnPkyBGc81RiGPS63HxkhUazhVfHYDBmWDiKwlMUFVY9WZZibUJiEkIIZGkrJgkIjEY9hiPPxUunGY4GLC8foNlIeOyx8+RZytz8iEYzp9lskjfnSNMcY1PEWmyW02jMsH9hGecLinJMs9me1rRN0dOBRQTEKJUvKfojXFWxvr4aNTWTMDczz82vfDUA3lU0GjP0+l06rZzX33c/3gm9Xpft7hbr6xusra/htcKHQPAlzVZKwzYYFSWu8gwGffIsJ88bhOBxVYUAg36P8XhAv59ibBdrU6y1ZHmDRpaS5wmukZGmDYwaQjU9a2hqLUdbx4CJu1hEIDEm2jr11qH+YJuyHBNCoNvtcezWGYJTHv3KFxj2t2g2WmR5TqPTYeXm/ew/NE+atUnTlG63R7e7ycLCEs1mh0EYsr3dI1QVedZibXWDqqrIsrgPTSR6M4wG8BVlOWbY3cIUW5Tba/iipNNeIJ+bwzRn4fvfOZV5mxpgaZYSgsOr1hm20TC1xqBiSETwztHrbzM7O8vFc2fY2FjDIIRK2drosVZt4oNHpDZoxZCkGe12O9p1jZSl2Q7FqCCEkjte9Sr62z3AMDc3z+zsDN57RqMhSlR28rRBkiSEoIx626TDS/jeBpcurWFTWF5aYqv/MgxgGiOISZAgVJUnVB5rUlwlBA2IeELwbK9f5Lbb7+b8+XNcunyBlZVXMDO3j7X1dSRx2FDFcIxzBO+pqiGj4SBq5ALN1hw333IDzz5+ktVLZ0nzBkv79zG/uMhKdZCZZos06yCJxVUVg3FJt9ujt73NsL9J78Iz2EKR1jytuYxCK4IULzW8bxlNUYbpLlvMsxxrLMYkaIie+1AnmQ76A4KDV952B9v9LlVZsnzgIE899XhMDk0SUEuemsjTqGNXweN9oD8Y0Wy1GI/GXDh/DkRYnJ/lwP6jjIqEp546gfrA7NwsMzOzpMayMNPh4NIKj1ddtHeWhvQpfI/BaoHHkrc605q26cqwyeMdNoQExCjqYvhlNBzw8Bf+mJWVFU6fOY21liMrN/H1rz9Kv7uNUiGhln3WYkydHiA5YGi3Zmg1W2RZSqPRoCrHXLpwjrvu9By/6zW0s4SvffURuqFia30t5tPXu2mGoxF5yJnJKsajAklmaVvAvQxX2GhcTHwlS0lsQpLEXSdZluzuPfYuMBxu8Pg3tnHB88ypkxx7xW28/vVv4onHT3D69EnSNEanYyYwVFW1m9+4Y0AfPHiIs88+RSOzbKyv8qf/74s08xaDrR775uZRC955nIeqcoxHQ7TwDMc5s+0G64NttsqEhEC71ZzWtE0PsEZnieADZTXCuSHVuCBNEowBYyFN4t5nDZClLUIIFGXJxUsXWLt4gQP7D9O8u4mI59KF07uKR1BoNBpogKJ0DHqbEDzHjt3Co499mWI4ZK7ZYn1zFSuQpRk2s4i1JLnQChVoQtkyrLmScjymHIP3BkkylICkL8MAZtx4B0mSA8Jo2Ce1CXmeET83GBNuTGLxxqAqpGlGnhi+8shD7Fs8wHDYZ3XtPGmexc9CAEkS8xxNYsiAfr/L04+foNOaIVOFTMgyGz3/2Lhl1ydQOQg9it4ZDAFjLAfmW4SZJt45lkZg+hXVAJIpOhOn99kHa+vUZyFLcpIZgzWCtQbnAsGDtRmJTTE+fqMjJJAmHh9KNrcu45ynMzOLGDuxryzUm/scSRo9HU+fPIGvFAmBZhpfkOADuhP3CgHrR1TDNYrukDzPEeOQZIv+aIjahEYq3LS/Q5ou4MKLfiHvW0pT3Azhd7OTAgFrBSPxawAAwWSIWAqvGLXUCWwEaxErZI0U42LyqS9dZIkWQnCYxGITu5sBJQmkSRpzE8sYQU6tofT1KvZ9Rr11uqvnWTq0zKgYkdiU3OS08wSsoSoGZGVBr3eOZHqeqSnbYWLR4LEkNXim3oDgMHUUOASDGIvzHuciAEma4IOAieFEm+eAIiaA96gRvKtIxBDUUZbRBWatxTbiNiSCkgTF+y1kvI4ruuw7sIygJGIQ7+n3+zgVGu2UcRFozDXIZEyS2GlN27T/ZwjF2gSzk10bfJ2nWG+EqDeohzpHEfYymVxV4epQjAUQjWFH20BVSZOULEnI6uysohxTFAWY2EbwnuAKzGiLYXeTVrtT90EQEra3t2imLaqqQEdKmmT0B2OcC2jxMvR0TGbVouzJn5gGuusqwiTflKUUjeUok7zzeF8QgiN+nyVgREjyjGDiZ25saslMk6zRRnGE4KnKIb5YxZUjKqeMRqN675ehKEa0mzP4ymEsDAcFjUzo9XosLHaw+ctQ6ej3+wBkaUpqI/vTWp4ZbG1ERxCNsdFnaA0ERYU6I1ijsSxE36Ov8OJAhMrtpKQFEhKCSv11HADBUFIOt3niqWdZOXYEoxXD0RhrEmyS4V3AhUCSp1inDIYj5uYWCF7orfemNW3TA6zZjLZVWVUUrtzdoJ6lCU1rkSB4hUDY/S4V1F/OgZg/KAl4IUhA1YFNsD7KqJQEg+K0RCpFgse5Ec47POBH56iKktn5GxgVQuqESpWsKYz6Q3zwLC7M0+tv02h1SNKUUaGkFhrN6RnO179Ieo3R9Q9cXmN0HbBrjK4Ddo3RdcCuMboO2DVG1wG7xuj/A1xbFaByUGuQAAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kl_Cy88RfiEQ"
      },
      "source": [
        "def process_image(image_path):\n",
        "\n",
        "    #image = Image.open(image_path)\n",
        "    image = image_path\n",
        "    # Resize\n",
        "    img = image.resize((256, 256))\n",
        "\n",
        "    # Center crop\n",
        "    width = 256\n",
        "    height = 256\n",
        "    new_width = 224\n",
        "    new_height = 224\n",
        "\n",
        "    left = (width - new_width) / 2\n",
        "    top = (height - new_height) / 2\n",
        "    right = (width + new_width) / 2\n",
        "    bottom = (height + new_height) / 2\n",
        "    img = img.crop((left, top, right, bottom))\n",
        "\n",
        "    # Convert to numpy, transpose color dimension and normalize\n",
        "    img = np.array(img).transpose((2, 0, 1)) / 256\n",
        "\n",
        "    # Standardization\n",
        "    means = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))\n",
        "    stds = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))\n",
        "\n",
        "    img = img - means\n",
        "    img = img / stds\n",
        "\n",
        "    img_tensor = torch.Tensor(img)\n",
        "\n",
        "    return img_tensor"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kEtrb9vqa-Pt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 256
        },
        "outputId": "6b39dcbd-35bc-49ad-f83e-b82114c1f303"
      },
      "source": [
        "from io import BytesIO\n",
        "uploaded = files.upload()\n",
        "im = Image.open(BytesIO(uploaded[list(uploaded.keys())[0]]))\n",
        "img_tensor = process_image(im)\n",
        "img_tensor = img_tensor.view(1,3,224,224).cuda()\n",
        "prediction = model_ft(img_tensor.to(device))\n",
        "print(\"-------------------------------------\")\n",
        "print(\"Prediction of Category:\",class_names[prediction.argmax()])\n",
        "print(\"Probability is:\",round(torch.nn.functional.softmax(prediction,dim=1).max().item()*100,2),\"%\")\n",
        "print(\"-------------------------------------\")\n",
        "#Dog = 1, Cat = 0"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-41742de8-4a4d-449d-a986-bd29640e731b\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-41742de8-4a4d-449d-a986-bd29640e731b\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-20-0f334508d8bd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mio\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mBytesIO\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0muploaded\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfiles\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mim\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mImage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBytesIO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0muploaded\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0muploaded\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mimg_tensor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprocess_image\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mim\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mimg_tensor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimg_tensor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mview\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m224\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m224\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mIndexError\u001b[0m: list index out of range"
          ]
        }
      ]
    }
  ]
}