{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Samuel Díaz    26472702\\\n",
        "Efrain Sánchez 27223322"
      ],
      "metadata": {
        "id": "Dr2W4Ql3DZrn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Installations\n"
      ],
      "metadata": {
        "id": "6cyB5DxkEnNG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install sklearn\n",
        "!pip install pytorch_lightning"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8PL3jJei2thB",
        "outputId": "e2c8b478-085e-452d-864e-eec23f69cb39"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting sklearn\n",
            "  Downloading sklearn-0.0.post1.tar.gz (3.6 kB)\n",
            "Building wheels for collected packages: sklearn\n",
            "  Building wheel for sklearn (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for sklearn: filename=sklearn-0.0.post1-py3-none-any.whl size=2344 sha256=e77cc75caa181ef35d3b88729f7f5b1d64eccb3cc937a8ebd78c031a38ad2004\n",
            "  Stored in directory: /root/.cache/pip/wheels/14/25/f7/1cc0956978ae479e75140219088deb7a36f60459df242b1a72\n",
            "Successfully built sklearn\n",
            "Installing collected packages: sklearn\n",
            "Successfully installed sklearn-0.0.post1\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting pytorch_lightning\n",
            "  Downloading pytorch_lightning-1.8.4-py3-none-any.whl (799 kB)\n",
            "\u001b[K     |████████████████████████████████| 799 kB 34.5 MB/s \n",
            "\u001b[?25hRequirement already satisfied: PyYAML>=5.4 in /usr/local/lib/python3.8/dist-packages (from pytorch_lightning) (6.0)\n",
            "Collecting lightning-utilities!=0.4.0,>=0.3.0\n",
            "  Downloading lightning_utilities-0.4.2-py3-none-any.whl (16 kB)\n",
            "Requirement already satisfied: tqdm>=4.57.0 in /usr/local/lib/python3.8/dist-packages (from pytorch_lightning) (4.64.1)\n",
            "Requirement already satisfied: fsspec[http]>2021.06.0 in /usr/local/lib/python3.8/dist-packages (from pytorch_lightning) (2022.11.0)\n",
            "Requirement already satisfied: numpy>=1.17.2 in /usr/local/lib/python3.8/dist-packages (from pytorch_lightning) (1.21.6)\n",
            "Collecting tensorboardX>=2.2\n",
            "  Downloading tensorboardX-2.5.1-py2.py3-none-any.whl (125 kB)\n",
            "\u001b[K     |████████████████████████████████| 125 kB 79.9 MB/s \n",
            "\u001b[?25hCollecting torchmetrics>=0.7.0\n",
            "  Downloading torchmetrics-0.11.0-py3-none-any.whl (512 kB)\n",
            "\u001b[K     |████████████████████████████████| 512 kB 51.1 MB/s \n",
            "\u001b[?25hRequirement already satisfied: typing-extensions>=4.0.0 in /usr/local/lib/python3.8/dist-packages (from pytorch_lightning) (4.4.0)\n",
            "Requirement already satisfied: torch>=1.9.0 in /usr/local/lib/python3.8/dist-packages (from pytorch_lightning) (1.13.0+cu116)\n",
            "Requirement already satisfied: packaging>=17.0 in /usr/local/lib/python3.8/dist-packages (from pytorch_lightning) (21.3)\n",
            "Requirement already satisfied: aiohttp!=4.0.0a0,!=4.0.0a1 in /usr/local/lib/python3.8/dist-packages (from fsspec[http]>2021.06.0->pytorch_lightning) (3.8.3)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.8/dist-packages (from fsspec[http]>2021.06.0->pytorch_lightning) (2.23.0)\n",
            "Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.8/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>2021.06.0->pytorch_lightning) (4.0.2)\n",
            "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.8/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>2021.06.0->pytorch_lightning) (1.3.3)\n",
            "Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.8/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>2021.06.0->pytorch_lightning) (1.8.2)\n",
            "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.8/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>2021.06.0->pytorch_lightning) (1.3.1)\n",
            "Requirement already satisfied: charset-normalizer<3.0,>=2.0 in /usr/local/lib/python3.8/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>2021.06.0->pytorch_lightning) (2.1.1)\n",
            "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.8/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>2021.06.0->pytorch_lightning) (22.1.0)\n",
            "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.8/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>2021.06.0->pytorch_lightning) (6.0.3)\n",
            "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.8/dist-packages (from packaging>=17.0->pytorch_lightning) (3.0.9)\n",
            "Requirement already satisfied: protobuf<=3.20.1,>=3.8.0 in /usr/local/lib/python3.8/dist-packages (from tensorboardX>=2.2->pytorch_lightning) (3.19.6)\n",
            "Requirement already satisfied: idna>=2.0 in /usr/local/lib/python3.8/dist-packages (from yarl<2.0,>=1.0->aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>2021.06.0->pytorch_lightning) (2.10)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests->fsspec[http]>2021.06.0->pytorch_lightning) (1.24.3)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests->fsspec[http]>2021.06.0->pytorch_lightning) (3.0.4)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests->fsspec[http]>2021.06.0->pytorch_lightning) (2022.9.24)\n",
            "Installing collected packages: torchmetrics, tensorboardX, lightning-utilities, pytorch-lightning\n",
            "Successfully installed lightning-utilities-0.4.2 pytorch-lightning-1.8.4 tensorboardX-2.5.1 torchmetrics-0.11.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Imports"
      ],
      "metadata": {
        "id": "qP3osZIzDVpq"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "pnvTcJc0YIEb"
      },
      "outputs": [],
      "source": [
        "# import the tools we need\n",
        "import os \n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "from PIL import Image\n",
        "from sklearn.preprocessing import LabelEncoder\n",
        "import torch\n",
        "import torch.nn.functional as F\n",
        "import torchvision\n",
        "from torchvision import transforms\n",
        "import torchvision.models as models\n",
        "from torchvision.datasets import ImageFolder\n",
        "from torch.utils.data.dataset import Dataset\n",
        "from torch.utils.data import Dataset, random_split, DataLoader\n",
        "from torch.utils.data import DataLoader\n",
        "from sklearn.model_selection import train_test_split\n",
        "import torchmetrics\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "from tqdm.notebook import tqdm\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Downloading Dataset"
      ],
      "metadata": {
        "id": "_oyzuqDYEIXq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "files.upload()"
      ],
      "metadata": {
        "id": "G72U28oDm9wk",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        },
        "outputId": "c061162e-21e2-4956-8ac9-d09aa367b5cf"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-003f2ffe-365d-4058-8da8-9121ea5ff49e\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-003f2ffe-365d-4058-8da8-9121ea5ff49e\">\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\":\"efransnchez\",\"key\":\"2b6e91f5ae1e3475d2291f78d6990e2d\"}'}"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!mkdir ~/.kaggle\n",
        "!cp kaggle.json ~/.kaggle/\n",
        "!chmod 600 ~/.kaggle/kaggle.json"
      ],
      "metadata": {
        "id": "Gk5klHn9nK2Y"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!kaggle datasets download -d jessicali9530/stanford-dogs-dataset"
      ],
      "metadata": {
        "id": "y4_Y-NHUnFqE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "10616b1c-98e0-4ab7-8e28-8025328d74a1"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading stanford-dogs-dataset.zip to /content\n",
            "100% 750M/750M [00:36<00:00, 22.5MB/s]\n",
            "100% 750M/750M [00:36<00:00, 21.7MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "3QR-BWtadQ3d"
      },
      "outputs": [],
      "source": [
        "!unzip -qq stanford-dogs-dataset.zip"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dataset = ImageFolder('./images/Images')"
      ],
      "metadata": {
        "id": "L0d2U_GZqNdO"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "breeds = []\n",
        "\n",
        "def rename(name):\n",
        "    return ' '.join(' '.join(name.split('-')[1:]).split('_')) # Getting Labels from Filenames\n",
        "\n",
        "for n in dataset.classes:\n",
        "    breeds.append(rename(n))"
      ],
      "metadata": {
        "id": "zXHXkTIVw3pe"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Splitting and Transforming Data"
      ],
      "metadata": {
        "id": "1a8dOA7HFtai"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "test_pct = 0.3\n",
        "test_size = int(len(dataset)*test_pct)\n",
        "dataset_size = len(dataset) - test_size\n",
        "\n",
        "val_pct = 0.1\n",
        "val_size = int(dataset_size*val_pct)\n",
        "train_size = dataset_size - val_size\n",
        "\n",
        "\n",
        "train_size, val_size, test_size"
      ],
      "metadata": {
        "id": "o0BBT5jxxJjd",
        "outputId": "c4eeedca-9527-4d38-8c4f-38670460c6aa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(12966, 1440, 6174)"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_ds, val_ds, test_ds = random_split(dataset, [train_size, val_size, test_size])\n",
        "len(train_ds), len(val_ds), len(test_ds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3_OsShMy6XHN",
        "outputId": "108b402f-1e54-48e6-e1ac-a94d11990192"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(12966, 1440, 6174)"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "img, label = train_ds[6]\n",
        "print(dataset.classes[label])\n",
        "plt.imshow(img)\n",
        "print(type(img))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 304
        },
        "id": "cKEAXZRm6a47",
        "outputId": "f079e72b-368b-4208-d085-821ef4a998f5"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "n02100583-vizsla\n",
            "<class 'PIL.Image.Image'>\n"
          ]
        },
        {
          "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": "markdown",
      "source": [
        "In this step we'll create a custom dataset class that we will be using to apply a couple preprocessing transformations to our images. This includes randomly flipping, rotating and resizing our images for data augmentation. We also apply a transformation to normalize our images according to the optimal parameters for ImageNet."
      ],
      "metadata": {
        "id": "sZJCKInBZAyd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class img_dataset(Dataset):\n",
        "    def __init__(self,dataframe,transform=None,test=False):\n",
        "        self.dataframe = dataframe\n",
        "        self.transform = transform\n",
        "        self.test = test\n",
        "        \n",
        "    def __getitem__(self,index):\n",
        "        x = Image.open(self.dataframe.iloc[index,0])\n",
        "        if self.transform:\n",
        "            x = self.transform(x)\n",
        "        if self.test:\n",
        "            return x\n",
        "        else:\n",
        "            y = self.dataframe.iloc[index,1]\n",
        "            return x,y\n",
        "        \n",
        "    def __len__(self):\n",
        "        return self.dataframe.shape[0]"
      ],
      "metadata": {
        "id": "1v98HQe86i73"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "imagenet_stats = ([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])   # This value is standard for all ImageNet datasets\n",
        "\n",
        "train_transform = transforms.Compose([\n",
        "    transforms.Resize((224, 224)),\n",
        "    transforms.RandomHorizontalFlip(p=0.21),\n",
        "    transforms.RandomRotation(degrees=27),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(*imagenet_stats, inplace=True)\n",
        "    \n",
        "])\n",
        "\n",
        "val_transform = transforms.Compose([\n",
        "    transforms.Resize((224,224)),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(*imagenet_stats, inplace=True)\n",
        "])\n",
        "\n",
        "test_transform = transforms.Compose([\n",
        "    transforms.Resize((224,224)), \n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(*imagenet_stats, inplace=True)\n",
        "])"
      ],
      "metadata": {
        "id": "1aHO2BXW6iyf"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class DogBreedDataset(Dataset):\n",
        "    \n",
        "    def __init__(self, ds, transform=None):\n",
        "        self.ds = ds\n",
        "        self.transform = transform\n",
        "        \n",
        "    def __len__(self):\n",
        "        return len(self.ds)\n",
        "    \n",
        "    def __getitem__(self, idx):\n",
        "        img, label = self.ds[idx]\n",
        "        if self.transform:\n",
        "            img = self.transform(img)  \n",
        "            return img, label"
      ],
      "metadata": {
        "id": "o2c_9J9AAcpZ"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_dataset = DogBreedDataset(train_ds, train_transform)\n",
        "val_dataset = DogBreedDataset(val_ds, val_transform)\n",
        "test_dataset = DogBreedDataset(test_ds, test_transform)"
      ],
      "metadata": {
        "id": "Wul1KX_m__VU"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "batch_size =64\n",
        "\n",
        "# Create DataLoaders\n",
        "train_dl = DataLoader(train_dataset, batch_size, shuffle=True, num_workers=2, pin_memory=True)\n",
        "val_dl = DataLoader(val_dataset, batch_size*2, num_workers=2, pin_memory=True)\n",
        "test_dl = DataLoader(test_dataset, batch_size*2, num_workers=2, pin_memory=True)"
      ],
      "metadata": {
        "id": "pwxm7Y5s_3RW"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Defining the model"
      ],
      "metadata": {
        "id": "opUvxcQZGLYX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Setting up gpu\n",
        "device = torch.device('cuda:0' if torch.cuda.is_available else 'cpu')"
      ],
      "metadata": {
        "id": "z2nZ7Opz6r89"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We'll be using a creating a model based off of the pretrained ResNet50 model. We're adding two Linear layers, as well as freezing all the previous layers so the weight don't get messy when retraining."
      ],
      "metadata": {
        "id": "jqntO5vfaKkH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class net50(torch.nn.Module):\n",
        "    def __init__(self, base_model, base_out_features, num_classes):\n",
        "        super(net50,self).__init__()\n",
        "        self.base_model=base_model\n",
        "        self.linear1 = torch.nn.Linear(base_out_features, 512)\n",
        "        self.output = torch.nn.Linear(512,num_classes)\n",
        "    def forward(self,x):\n",
        "        x = F.relu(self.base_model(x))\n",
        "        x = F.relu(self.linear1(x))\n",
        "        x = self.output(x)\n",
        "        return x"
      ],
      "metadata": {
        "id": "StMb2Kql8cyj"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "res = torchvision.models.resnet50(pretrained=True)\n",
        "for param in res.parameters():    ## Freezing layers\n",
        "    param.requires_grad=False\n",
        "\n",
        "model1 = net50(base_model=res, base_out_features=res.fc.out_features, num_classes=120)"
      ],
      "metadata": {
        "id": "DdyLeYk18f0J"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def to_device(data, device):\n",
        "    if isinstance(data, (list, tuple)):\n",
        "        return [to_device(d, device) for d in data]\n",
        "    else:\n",
        "        return data.to(device, non_blocking=True)"
      ],
      "metadata": {
        "id": "HK8LgNqsB3n8"
      },
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class DeviceDataLoader:\n",
        "    def __init__(self, dl, device):\n",
        "        self.dl = dl\n",
        "        self.device = device\n",
        "    \n",
        "    def __len__(self):\n",
        "        return len(self.dl)\n",
        "    \n",
        "    def __iter__(self):\n",
        "        for batch in self.dl:\n",
        "            yield to_device(batch, self.device)"
      ],
      "metadata": {
        "id": "n5kqwND4B5uV"
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# moving train dataloader and val dataloader to gpu\n",
        "train_dl = DeviceDataLoader(train_dl, device)\n",
        "val_dl = DeviceDataLoader(val_dl, device)\n",
        "\n",
        "\n",
        "# moving model to gpu\n",
        "to_device(model1, device);"
      ],
      "metadata": {
        "id": "T6GM39gsB83K"
      },
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Fitting Model"
      ],
      "metadata": {
        "id": "YBDOUEz7IpxU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The actual fitting of the model."
      ],
      "metadata": {
        "id": "Rqv8E4x1c-6Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the result of 1 epoch\n",
        "def print_epoch_result(train_loss,train_acc,val_loss,val_acc):\n",
        "    print('loss: {:.3f}, acc: {:.3f}, val_loss: {:.3f}, val_acc: {:.3f}'.format(train_loss,\n",
        "                                                                              train_acc,\n",
        "                                                                              val_loss,\n",
        "                                                                              val_acc))\n",
        "# Main Training function\n",
        "def train_model(model, cost_function, optimizer, num_epochs=5):\n",
        "    train_losses = []\n",
        "    val_losses = []\n",
        "    train_acc = []\n",
        "    val_acc = []\n",
        "    \n",
        "    # Metrics object\n",
        "    train_acc_object = torchmetrics.Accuracy(task='multiclass',num_classes=120)\n",
        "    val_acc_object = torchmetrics.Accuracy(task='multiclass',num_classes=120)\n",
        "    \n",
        "    for epoch in range(num_epochs):\n",
        "        \"\"\"\n",
        "        On epoch start\n",
        "        \"\"\"\n",
        "        print('-'*15)\n",
        "        print('Start training {}/{}'.format(epoch+1, num_epochs))\n",
        "        print('-'*15)\n",
        "        \n",
        "        # Training\n",
        "        train_sub_losses = []\n",
        "        model.train()\n",
        "        for x,y in train_dl:\n",
        "            optimizer.zero_grad()\n",
        "            x,y = x.to(device),y.to(device)\n",
        "            y_hat = model(x)\n",
        "            loss = cost_function(y_hat,y)\n",
        "            #y_hat = y_hat.transpose(0,1)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "            # update loss sublist\n",
        "            train_sub_losses.append(loss.item())\n",
        "            # update accuracy object\n",
        "            train_acc_object(y_hat.cpu(),y.cpu())\n",
        "            \n",
        "        # Validation\n",
        "        val_sub_losses = []\n",
        "        model.eval()\n",
        "        for x,y in val_dl:\n",
        "            x,y = x.to(device),y.to(device)\n",
        "            y_hat = model(x)\n",
        "            loss = cost_function(y_hat,y)\n",
        "            val_sub_losses.append(loss.item())\n",
        "            val_acc_object(y_hat.cpu(),y.cpu())\n",
        "            \n",
        "        \"\"\"\n",
        "        On epoch end\n",
        "        \"\"\"\n",
        "        # Update the loss list\n",
        "        train_losses.append(np.mean(train_sub_losses))\n",
        "        val_losses.append(np.mean(val_sub_losses))\n",
        "        \n",
        "        # Update the accuracy list and reset the metrics object \n",
        "        train_epoch_acc = train_acc_object.compute()\n",
        "        val_epoch_acc = val_acc_object.compute()\n",
        "        train_acc.append(train_epoch_acc)\n",
        "        val_acc.append(val_epoch_acc)\n",
        "        train_acc_object.reset()\n",
        "        val_acc_object.reset()\n",
        "        \n",
        "        # print the result of epoch\n",
        "        print_epoch_result(np.mean(train_sub_losses),train_epoch_acc,np.mean(val_sub_losses),val_epoch_acc)\n",
        "        \n",
        "    print('Finish Training.')\n",
        "    return train_losses, train_acc, val_losses, val_acc"
      ],
      "metadata": {
        "id": "UJyeo15hNha6"
      },
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# set hyperparams\n",
        "num_epochs = 10\n",
        "opt_func = torch.optim.SGD\n",
        "cost_function = torch.nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam([param for param in model1.parameters() if param.requires_grad], lr=0.0003)\n",
        "\n",
        "max_lr = 0.01\n",
        "grad_clip = 0.1\n",
        "weight_decay = 1e-4\n",
        "\n",
        "train_losses, train_acc, val_losses, val_acc = train_model(model=model1, \n",
        "                                                           cost_function=cost_function, \n",
        "                                                           optimizer=optimizer,\n",
        "                                                           num_epochs=num_epochs)"
      ],
      "metadata": {
        "id": "7i_0kJD_CMM6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "34d6fe93-6408-4bda-995a-981a3b9e6c81"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "---------------\n",
            "Start training 1/10\n",
            "---------------\n",
            "loss: 2.201, acc: 0.501, val_loss: 1.039, val_acc: 0.688\n",
            "---------------\n",
            "Start training 2/10\n",
            "---------------\n",
            "loss: 1.000, acc: 0.721, val_loss: 0.817, val_acc: 0.756\n",
            "---------------\n",
            "Start training 3/10\n",
            "---------------\n",
            "loss: 0.853, acc: 0.746, val_loss: 0.805, val_acc: 0.764\n",
            "---------------\n",
            "Start training 4/10\n",
            "---------------\n",
            "loss: 0.776, acc: 0.764, val_loss: 0.758, val_acc: 0.769\n",
            "---------------\n",
            "Start training 5/10\n",
            "---------------\n",
            "loss: 0.736, acc: 0.776, val_loss: 0.754, val_acc: 0.760\n",
            "---------------\n",
            "Start training 6/10\n",
            "---------------\n",
            "loss: 0.685, acc: 0.792, val_loss: 0.779, val_acc: 0.754\n",
            "---------------\n",
            "Start training 7/10\n",
            "---------------\n",
            "loss: 0.653, acc: 0.803, val_loss: 0.730, val_acc: 0.772\n",
            "---------------\n",
            "Start training 8/10\n",
            "---------------\n",
            "loss: 0.619, acc: 0.808, val_loss: 0.753, val_acc: 0.769\n",
            "---------------\n",
            "Start training 9/10\n",
            "---------------\n",
            "loss: 0.597, acc: 0.815, val_loss: 0.717, val_acc: 0.778\n",
            "---------------\n",
            "Start training 10/10\n",
            "---------------\n",
            "loss: 0.572, acc: 0.819, val_loss: 0.745, val_acc: 0.768\n",
            "Finish Training.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_result(train_loss,val_loss,train_acc,val_acc):\n",
        "    plt.style.use('ggplot')\n",
        "    fig, (ax1,ax2) = plt.subplots(2,1,figsize=(10,8))\n",
        "    ax1.plot(train_loss,label='loss')\n",
        "    ax1.plot(val_loss,label='val_loss')\n",
        "    ax1.legend()\n",
        "    ax1.set_xlabel('epoch')\n",
        "    ax1.set_xticks(range(0,num_epochs+1))\n",
        "    ax2.plot(train_acc, label='acc')\n",
        "    ax2.plot(val_acc,label='val_acc')\n",
        "    ax2.legend()\n",
        "    ax2.set_xlabel('epoch')\n",
        "    ax2.set_xticks(range(0,num_epochs+1))\n",
        "    plt.show()\n",
        "plot_result(train_losses,val_losses, train_acc,  val_acc)"
      ],
      "metadata": {
        "id": "KRM_SPbWCjPr",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 500
        },
        "outputId": "b3ed3134-f69a-45d4-c1e1-0c19ca70f367"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x576 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.save(model1.state_dict(), \"model.zip\")"
      ],
      "metadata": {
        "id": "X9A4sHMaHz15"
      },
      "execution_count": 32,
      "outputs": []
    }
  ]
}