Vgg16.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Nishaanth4969/pytorch-vggnet16/blob/main/Vgg16.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "CcBU7tQy0heo"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torch.functional as F\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import torchvision.datasets as datasets\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "4XX8qaC8xhS_"
      },
      "outputs": [],
      "source": [
        "train_transform = transforms.Compose([\n",
        "    transforms.Resize((224, 224)),\n",
        "    transforms.TrivialAugmentWide(num_magnitude_bins=31), \n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) \n",
        "])\n",
        "\n",
        "test_transform = transforms.Compose([\n",
        "    transforms.Resize((224,224)),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
        "])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "47R6jVzsoFZZ",
        "outputId": "2d562adc-0b51-4abf-cc8c-f283e0a856c5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 3 directories and 1 images in '/content/drive/MyDrive/tumor'.\n",
            "There are 0 directories and 501 images in '/content/drive/MyDrive/tumor/TRAIN'.\n",
            "There are 0 directories and 202 images in '/content/drive/MyDrive/tumor/VAL'.\n",
            "There are 0 directories and 100 images in '/content/drive/MyDrive/tumor/TEST'.\n"
          ]
        }
      ],
      "source": [
        "import os\n",
        "def dir(dir_path):\n",
        "  for dirpath, dirnames, filenames in os.walk(dir_path):\n",
        "    print(f\"There are {len(dirnames)} directories and {len(filenames)} images in '{dirpath}'.\")\n",
        "dir('/content/drive/MyDrive/tumor')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "17yuQQ2W2AY5",
        "outputId": "e38302b9-1a1c-4448-9b36-1b528e717515"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train data:\n",
            "Dataset ImageFolder\n",
            "    Number of datapoints: 644\n",
            "    Root location: /content/drive/MyDrive/marvel/train\n",
            "    StandardTransform\n",
            "Transform: Compose(\n",
            "               Resize(size=(224, 224), interpolation=bilinear, max_size=None, antialias=warn)\n",
            "               TrivialAugmentWide(num_magnitude_bins=31, interpolation=InterpolationMode.NEAREST, fill=None)\n",
            "               ToTensor()\n",
            "               Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
            "           )\n",
            "Test data:\n",
            "Dataset ImageFolder\n",
            "    Number of datapoints: 112\n",
            "    Root location: /content/drive/MyDrive/marvel/valid\n",
            "    StandardTransform\n",
            "Transform: Compose(\n",
            "               Resize(size=(224, 224), interpolation=bilinear, max_size=None, antialias=warn)\n",
            "               ToTensor()\n",
            "               Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
            "           )\n"
          ]
        }
      ],
      "source": [
        "train_data = datasets.ImageFolder(root='/content/drive/MyDrive/marvel/train',\n",
        "                                     transform=train_transform)\n",
        "test_data = datasets.ImageFolder(root='/content/drive/MyDrive/marvel/valid', \n",
        "                                    transform=test_transform)\n",
        "print(f\"Train data:\\n{train_data}\\nTest data:\\n{test_data}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QtKtqi4eqQ5R",
        "outputId": "f06cb155-e3c5-4c72-801e-f94e248c0b9f"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['black widow', 'captain america']"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "class_names = train_data.classes\n",
        "class_names"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e3WsHhtFqQaI",
        "outputId": "b390356d-cc77-445b-b3f9-734fe7ce35c7"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<torch.utils.data.dataloader.DataLoader at 0x7fa8cb3f7c10>,\n",
              " <torch.utils.data.dataloader.DataLoader at 0x7fa8cb3f7b20>)"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ],
      "source": [
        "train_dataloader = DataLoader(dataset=train_data, \n",
        "                              batch_size=32, \n",
        "                              num_workers=os.cpu_count(), \n",
        "                              shuffle=True) \n",
        "\n",
        "test_dataloader = DataLoader(dataset=test_data, \n",
        "                             batch_size=32, \n",
        "                             num_workers=os.cpu_count(), \n",
        "                             shuffle=False) \n",
        "\n",
        "train_dataloader, test_dataloader"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m-xRdHx6vhAx",
        "outputId": "d53f0bcb-6e08-4a75-979f-59845cccdefe"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Image shape: torch.Size([32, 3, 224, 224]) -> [batch_size, color_channels, height, width]\n",
            "Label shape: torch.Size([32])\n"
          ]
        }
      ],
      "source": [
        "img, label = next(iter(train_dataloader))\n",
        "print(f\"Image shape: {img.shape} -> [batch_size, color_channels, height, width]\")\n",
        "print(f\"Label shape: {label.shape}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "id": "3qDiRcyAIBHP"
      },
      "outputs": [],
      "source": [
        "class VGGNet(nn.Module):\n",
        "    def __init__(self, num_classes=2):\n",
        "        super(VGGNet, self).__init__()\n",
        "        \n",
        "        self.features = nn.Sequential(\n",
        "            \n",
        "            nn.Conv2d(3, 64, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(64),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Conv2d(64, 64, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(64),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
        "\n",
        "            nn.Conv2d(64, 128, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(128),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Conv2d(128, 128, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(128),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
        "\n",
        "            nn.Conv2d(128, 256, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(256),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Conv2d(256, 256, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(256),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Conv2d(256, 256, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(256),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
        "\n",
        "            nn.Conv2d(256, 512, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(512),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Conv2d(512, 512, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(512),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Conv2d(512, 512, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(512),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
        "\n",
        "            nn.Conv2d(512, 512, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(512),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Conv2d(512, 512, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(512),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Conv2d(512, 512, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(512),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2)\n",
        "        )\n",
        "\n",
        "        self.avgpool = nn.AdaptiveAvgPool2d((7, 7))\n",
        "\n",
        "        self.classifier = nn.Sequential(\n",
        "            nn.Linear(512 * 7 * 7, 4096),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Dropout(),\n",
        "            nn.Linear(4096, 4096),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Dropout(),\n",
        "            nn.Linear(4096, 1),\n",
        "            nn.Sigmoid()\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.features(x)\n",
        "        x = self.avgpool(x)\n",
        "        x = torch.flatten(x, 1)\n",
        "        x = self.classifier(x)\n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tCnVJ4ZGnDvT",
        "outputId": "75509a43-61c4-49b8-a939-13b1cfaf161d"
      },
      "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 torchinfo\n",
            "  Downloading torchinfo-1.7.2-py3-none-any.whl (22 kB)\n",
            "Installing collected packages: torchinfo\n",
            "Successfully installed torchinfo-1.7.2\n"
          ]
        }
      ],
      "source": [
        "!pip install torchinfo\n",
        "import torchinfo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3TaYsPf5ny7E",
        "outputId": "d177dcbf-a4e2-417f-aca3-a847f6bb16dc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torchinfo/torchinfo.py:477: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly.  To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n",
            "  action_fn=lambda data: sys.getsizeof(data.storage()),\n",
            "/usr/local/lib/python3.10/dist-packages/torch/storage.py:665: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly.  To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n",
            "  return super().__sizeof__() + self.nbytes()\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "==========================================================================================\n",
              "Layer (type:depth-idx)                   Output Shape              Param #\n",
              "==========================================================================================\n",
              "VGGNet                                   [1, 1]                    --\n",
              "├─Sequential: 1-1                        [1, 512, 7, 7]            --\n",
              "│    └─Conv2d: 2-1                       [1, 64, 224, 224]         1,792\n",
              "│    └─BatchNorm2d: 2-2                  [1, 64, 224, 224]         128\n",
              "│    └─ReLU: 2-3                         [1, 64, 224, 224]         --\n",
              "│    └─Conv2d: 2-4                       [1, 64, 224, 224]         36,928\n",
              "│    └─BatchNorm2d: 2-5                  [1, 64, 224, 224]         128\n",
              "│    └─ReLU: 2-6                         [1, 64, 224, 224]         --\n",
              "│    └─MaxPool2d: 2-7                    [1, 64, 112, 112]         --\n",
              "│    └─Conv2d: 2-8                       [1, 128, 112, 112]        73,856\n",
              "│    └─BatchNorm2d: 2-9                  [1, 128, 112, 112]        256\n",
              "│    └─ReLU: 2-10                        [1, 128, 112, 112]        --\n",
              "│    └─Conv2d: 2-11                      [1, 128, 112, 112]        147,584\n",
              "│    └─BatchNorm2d: 2-12                 [1, 128, 112, 112]        256\n",
              "│    └─ReLU: 2-13                        [1, 128, 112, 112]        --\n",
              "│    └─MaxPool2d: 2-14                   [1, 128, 56, 56]          --\n",
              "│    └─Conv2d: 2-15                      [1, 256, 56, 56]          295,168\n",
              "│    └─BatchNorm2d: 2-16                 [1, 256, 56, 56]          512\n",
              "│    └─ReLU: 2-17                        [1, 256, 56, 56]          --\n",
              "│    └─Conv2d: 2-18                      [1, 256, 56, 56]          590,080\n",
              "│    └─BatchNorm2d: 2-19                 [1, 256, 56, 56]          512\n",
              "│    └─ReLU: 2-20                        [1, 256, 56, 56]          --\n",
              "│    └─Conv2d: 2-21                      [1, 256, 56, 56]          590,080\n",
              "│    └─BatchNorm2d: 2-22                 [1, 256, 56, 56]          512\n",
              "│    └─ReLU: 2-23                        [1, 256, 56, 56]          --\n",
              "│    └─MaxPool2d: 2-24                   [1, 256, 28, 28]          --\n",
              "│    └─Conv2d: 2-25                      [1, 512, 28, 28]          1,180,160\n",
              "│    └─BatchNorm2d: 2-26                 [1, 512, 28, 28]          1,024\n",
              "│    └─ReLU: 2-27                        [1, 512, 28, 28]          --\n",
              "│    └─Conv2d: 2-28                      [1, 512, 28, 28]          2,359,808\n",
              "│    └─BatchNorm2d: 2-29                 [1, 512, 28, 28]          1,024\n",
              "│    └─ReLU: 2-30                        [1, 512, 28, 28]          --\n",
              "│    └─Conv2d: 2-31                      [1, 512, 28, 28]          2,359,808\n",
              "│    └─BatchNorm2d: 2-32                 [1, 512, 28, 28]          1,024\n",
              "│    └─ReLU: 2-33                        [1, 512, 28, 28]          --\n",
              "│    └─MaxPool2d: 2-34                   [1, 512, 14, 14]          --\n",
              "│    └─Conv2d: 2-35                      [1, 512, 14, 14]          2,359,808\n",
              "│    └─BatchNorm2d: 2-36                 [1, 512, 14, 14]          1,024\n",
              "│    └─ReLU: 2-37                        [1, 512, 14, 14]          --\n",
              "│    └─Conv2d: 2-38                      [1, 512, 14, 14]          2,359,808\n",
              "│    └─BatchNorm2d: 2-39                 [1, 512, 14, 14]          1,024\n",
              "│    └─ReLU: 2-40                        [1, 512, 14, 14]          --\n",
              "│    └─Conv2d: 2-41                      [1, 512, 14, 14]          2,359,808\n",
              "│    └─BatchNorm2d: 2-42                 [1, 512, 14, 14]          1,024\n",
              "│    └─ReLU: 2-43                        [1, 512, 14, 14]          --\n",
              "│    └─MaxPool2d: 2-44                   [1, 512, 7, 7]            --\n",
              "├─AdaptiveAvgPool2d: 1-2                 [1, 512, 7, 7]            --\n",
              "├─Sequential: 1-3                        [1, 1]                    --\n",
              "│    └─Linear: 2-45                      [1, 4096]                 102,764,544\n",
              "│    └─ReLU: 2-46                        [1, 4096]                 --\n",
              "│    └─Dropout: 2-47                     [1, 4096]                 --\n",
              "│    └─Linear: 2-48                      [1, 4096]                 16,781,312\n",
              "│    └─ReLU: 2-49                        [1, 4096]                 --\n",
              "│    └─Dropout: 2-50                     [1, 4096]                 --\n",
              "│    └─Linear: 2-51                      [1, 1]                    4,097\n",
              "│    └─Sigmoid: 2-52                     [1, 1]                    --\n",
              "==========================================================================================\n",
              "Total params: 134,273,089\n",
              "Trainable params: 134,273,089\n",
              "Non-trainable params: 0\n",
              "Total mult-adds (G): 15.48\n",
              "==========================================================================================\n",
              "Input size (MB): 0.60\n",
              "Forward/backward pass size (MB): 216.83\n",
              "Params size (MB): 537.09\n",
              "Estimated Total Size (MB): 754.52\n",
              "=========================================================================================="
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ],
      "source": [
        "from torchinfo import summary\n",
        "model0 = VGGNet(num_classes=2)\n",
        "summary(model0, input_size=(1, 3, 224, 224))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "_kI_HvvjxYyO"
      },
      "outputs": [],
      "source": [
        "def train_step(model: torch.nn.Module, \n",
        "               dataloader: torch.utils.data.DataLoader, \n",
        "               loss_fn: torch.nn.Module, \n",
        "               optimizer: torch.optim.Optimizer):\n",
        "  \n",
        "    model.train()\n",
        "    train_loss, train_acc = 0, 0\n",
        "    \n",
        "    for batch, (X, y) in enumerate(dataloader):\n",
        "\n",
        "        y_pred = model(X)\n",
        "\n",
        "        loss = loss_fn(y_pred, y)\n",
        "        train_loss += loss.item() \n",
        "\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        loss.backward()\n",
        "\n",
        "        optimizer.step()\n",
        "\n",
        "        y_pred_class = torch.argmax(torch.softmax(y_pred, dim=1), dim=1)\n",
        "        train_acc += (y_pred_class == y).sum().item()/len(y_pred)\n",
        "\n",
        "    train_loss = train_loss / len(dataloader)\n",
        "    train_acc = train_acc / len(dataloader)\n",
        "    return train_loss, train_acc"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "lGyjvrSlxd56"
      },
      "outputs": [],
      "source": [
        "def test_step(model: torch.nn.Module, \n",
        "              dataloader: torch.utils.data.DataLoader, \n",
        "              loss_fn: torch.nn.Module):\n",
        "  \n",
        "    model.eval() \n",
        "    \n",
        "    test_loss, test_acc = 0, 0\n",
        "    \n",
        "    with torch.inference_mode():\n",
        "\n",
        "        for batch, (X, y) in enumerate(dataloader):\n",
        "    \n",
        "            test_pred_logits = model(X)\n",
        "\n",
        "            loss = loss_fn(test_pred_logits, y)\n",
        "            test_loss += loss.item()\n",
        "            \n",
        "            test_pred_labels = test_pred_logits.argmax(dim=1)\n",
        "            test_acc += ((test_pred_labels == y).sum().item()/len(test_pred_labels))\n",
        "\n",
        "    test_loss = test_loss / len(dataloader)\n",
        "    test_acc = test_acc / len(dataloader)\n",
        "    return test_loss, test_acc"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "id": "4WjNR7oOxrbT"
      },
      "outputs": [],
      "source": [
        "from tqdm.auto import tqdm\n",
        "\n",
        "def train(model: torch.nn.Module, \n",
        "          train_dataloader: torch.utils.data.DataLoader, \n",
        "          test_dataloader: torch.utils.data.DataLoader, \n",
        "          optimizer: torch.optim.Optimizer,\n",
        "          loss_fn: torch.nn.Module = nn.BCELoss(),\n",
        "          epochs: int = 5):\n",
        "    \n",
        "    results = {\"train_loss\": [],\n",
        "        \"train_acc\": [],\n",
        "        \"test_loss\": [],\n",
        "        \"test_acc\": []\n",
        "    }\n",
        "    \n",
        "    for epoch in tqdm(range(epochs)):\n",
        "        train_loss, train_acc = train_step(model=model,\n",
        "                                           dataloader=train_dataloader,\n",
        "                                           loss_fn=loss_fn,\n",
        "                                           optimizer=optimizer)\n",
        "        test_loss, test_acc = test_step(model=model,\n",
        "            dataloader=test_dataloader,\n",
        "            loss_fn=loss_fn)\n",
        "        \n",
        "        print(\n",
        "            f\"Epoch: {epoch+1} | \"\n",
        "            f\"train_loss: {train_loss:.4f} | \"\n",
        "            f\"train_acc: {train_acc:.4f} | \"\n",
        "            f\"test_loss: {test_loss:.4f} | \"\n",
        "            f\"test_acc: {test_acc:.4f}\"\n",
        "        )\n",
        "\n",
        "        results[\"train_loss\"].append(train_loss)\n",
        "        results[\"train_acc\"].append(train_acc)\n",
        "        results[\"test_loss\"].append(test_loss)\n",
        "        results[\"test_acc\"].append(test_acc)\n",
        "\n",
        "    return results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85,
          "referenced_widgets": [
            "32b8e7228d5c46d8b505dbebe1710b38",
            "df514a00c64446ac9b30e8897b57f4b9",
            "bbac0fcda14a4cd7ba11a74702472b4c",
            "d761b15b0b954d7fa89c5ab1aac1ae50",
            "66b51f08b36c4bc8b76141d8e7a61fb7",
            "92a12fb37d4749f78e97272e580b7739",
            "bd4b2be8f8cf4adfbd6f77126e0861e3",
            "0a7716a19a51445f9476bf67a683df39",
            "0b29afa5a9344f0490045a49e10489d0",
            "9824afa47dd248a784249f06ac41ea61",
            "39bf110795e946fc900d2ac69a91d671"
          ]
        },
        "id": "o9yjAduNyFoW",
        "outputId": "559fb20b-6135-494f-8deb-5998dbdea385"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/2 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "32b8e7228d5c46d8b505dbebe1710b38"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 1 | train_loss: 1.0062 | train_acc: 0.5259 | test_loss: 0.6905 | test_acc: 0.5703\n",
            "Epoch: 2 | train_loss: 0.6959 | train_acc: 0.5000 | test_loss: 0.6917 | test_acc: 0.5703\n"
          ]
        }
      ],
      "source": [
        "NUM_EPOCHS = 2\n",
        "\n",
        "model0 = VGGNet(num_classes=2)\n",
        "\n",
        "loss_fn = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(params=model0.parameters(), lr=0.0013)\n",
        "\n",
        "\n",
        "model_0_results = train(model=model0, \n",
        "                        train_dataloader=train_dataloader,\n",
        "                        test_dataloader=test_dataloader,\n",
        "                        optimizer=optimizer,\n",
        "                        loss_fn=loss_fn, \n",
        "                        epochs=NUM_EPOCHS)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_0_results.keys()\n",
        "from typing import Dict, List"
      ],
      "metadata": {
        "id": "M9T5eTtHKbLQ"
      },
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_loss_curves(results: Dict[str, List[float]]):\n",
        "\n",
        "    \n",
        "    loss = results['train_loss']\n",
        "    test_loss = results['test_loss']\n",
        "\n",
        "    accuracy = results['train_acc']\n",
        "    test_accuracy = results['test_acc']\n",
        "\n",
        "    epochs = range(len(results['train_loss']))\n",
        "\n",
        "    plt.figure(figsize=(15, 7))\n",
        "\n",
        "    plt.subplot(1, 2, 1)\n",
        "    plt.plot(epochs, loss, label='train_loss')\n",
        "    plt.plot(epochs, test_loss, label='test_loss')\n",
        "    plt.title('Loss')\n",
        "    plt.xlabel('Epochs')\n",
        "    plt.legend()\n",
        "\n",
        "    plt.subplot(1, 2, 2)\n",
        "    plt.plot(epochs, accuracy, label='train_accuracy')\n",
        "    plt.plot(epochs, test_accuracy, label='test_accuracy')\n",
        "    plt.title('Accuracy')\n",
        "    plt.xlabel('Epochs')\n",
        "    plt.legend();"
      ],
      "metadata": {
        "id": "MAsqOl3IY8q2"
      },
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_loss_curves(model_0_results)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 623
        },
        "id": "x5cDID2IZSPq",
        "outputId": "9e915cdf-5902-47ae-98f9-d81f63d5ff00"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x700 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
        "\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "model0.eval()\n",
        "y_true = []\n",
        "y_pred = []\n",
        "\n",
        "with torch.no_grad():\n",
        "    for images, labels in test_dataloader:\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        outputs = model0(images)\n",
        "        predictions = torch.sigmoid(outputs) > 0.5\n",
        "        y_true += labels.cpu().numpy().tolist()\n",
        "        y_pred += predictions.cpu().numpy().tolist()\n",
        "\n",
        "precision = precision_score(y_true, y_pred)\n",
        "recall = recall_score(y_true, y_pred)\n",
        "f1 = f1_score(y_true, y_pred)\n",
        "\n",
        "print(f'Precision: {precision:.4f}, Recall: {recall:.4f}, F1-score: {f1:.4f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LtaKlJJJZwf5",
        "outputId": "46e79b74-da25-4b91-da4c-157decd4c0fd"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Precision: 0.5089, Recall: 1.0000, F1-score: 0.6746\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "mount_file_id": "1LRhzUIrqzIlbLm93n4L8flF35TGxn6Yv",
      "authorship_tag": "ABX9TyMMcb5ogaLRY3+oOyQtOMYN",
      "include_colab_link": true
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "32b8e7228d5c46d8b505dbebe1710b38": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_df514a00c64446ac9b30e8897b57f4b9",
              "IPY_MODEL_bbac0fcda14a4cd7ba11a74702472b4c",
              "IPY_MODEL_d761b15b0b954d7fa89c5ab1aac1ae50"
            ],
            "layout": "IPY_MODEL_66b51f08b36c4bc8b76141d8e7a61fb7"
          }
        },
        "df514a00c64446ac9b30e8897b57f4b9": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_92a12fb37d4749f78e97272e580b7739",
            "placeholder": "​",
            "style": "IPY_MODEL_bd4b2be8f8cf4adfbd6f77126e0861e3",
            "value": "100%"
          }
        },
        "bbac0fcda14a4cd7ba11a74702472b4c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_0a7716a19a51445f9476bf67a683df39",
            "max": 2,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_0b29afa5a9344f0490045a49e10489d0",
            "value": 2
          }
        },
        "d761b15b0b954d7fa89c5ab1aac1ae50": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_9824afa47dd248a784249f06ac41ea61",
            "placeholder": "​",
            "style": "IPY_MODEL_39bf110795e946fc900d2ac69a91d671",
            "value": " 2/2 [44:00&lt;00:00, 1321.15s/it]"
          }
        },
        "66b51f08b36c4bc8b76141d8e7a61fb7": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "92a12fb37d4749f78e97272e580b7739": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "bd4b2be8f8cf4adfbd6f77126e0861e3": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "0a7716a19a51445f9476bf67a683df39": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "0b29afa5a9344f0490045a49e10489d0": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "9824afa47dd248a784249f06ac41ea61": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "39bf110795e946fc900d2ac69a91d671": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}