ResNet_CIFAR_10_with_PyTorch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyMN7UPLXEJQdCz6XEB36BWq",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/PSLeon24/Artificial_Intelligence/blob/main/ResNet_CIFAR_10_with_PyTorch.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "J4eLol4mhHQR"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "class BasicBlock(nn.Module):\n",
        "  def __init__(self, in_channels, out_channels, kernel_size = 3):\n",
        "    super(BasicBlock, self).__init__()\n",
        "\n",
        "    # Define convolutional layers\n",
        "    self.c1 = nn.Conv2d(in_channels, out_channels,\n",
        "                          kernel_size = kernel_size, padding = 1)\n",
        "    self.c2 = nn.Conv2d(out_channels, out_channels,\n",
        "                          kernel_size = kernel_size, padding = 1)\n",
        "    self.downsample = nn.Conv2d(in_channels, out_channels,\n",
        "                                kernel_size = 1)\n",
        "\n",
        "    # Define batch normalization layers\n",
        "    self.bn1 = nn.BatchNorm2d(num_features = out_channels)\n",
        "    self.bn2 = nn.BatchNorm2d(num_features = out_channels)\n",
        "\n",
        "    self.relu = nn.ReLU()\n",
        "\n",
        "  def forward(self, x):\n",
        "    x_ = x\n",
        "\n",
        "    x = self.c1(x)\n",
        "    x = self.bn1(x)\n",
        "    x = self.relu(x)\n",
        "    x = self.c2(x)\n",
        "    x = self.bn2(x)\n",
        "\n",
        "    x_ = self.downsample(x_)\n",
        "\n",
        "    x += x_\n",
        "    x = self.relu(x)\n",
        "\n",
        "    return x"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class ResNet(nn.Module):\n",
        "  def __init__(self, num_classes = 10):\n",
        "    super(ResNet, self).__init__()\n",
        "\n",
        "    self.b1 = BasicBlock(in_channels = 3, out_channels = 64)\n",
        "    self.b2 = BasicBlock(in_channels = 64, out_channels = 128)\n",
        "    self.b3 = BasicBlock(in_channels = 128, out_channels = 256)\n",
        "\n",
        "    self.pool = nn.AvgPool2d(kernel_size = 2, stride = 2)\n",
        "\n",
        "    self.fc1 = nn.Linear(in_features = 4096, out_features = 2048)\n",
        "    self.fc2 = nn.Linear(in_features = 2048, out_features = 512)\n",
        "    self.fc3 = nn.Linear(in_features = 512, out_features = num_classes)\n",
        "\n",
        "    self.relu = nn.ReLU()\n",
        "\n",
        "  def forward(self, x):\n",
        "    x = self.b1(x)\n",
        "    x = self.pool(x)\n",
        "    x = self.b2(x)\n",
        "    x = self.pool(x)\n",
        "    x = self.b3(x)\n",
        "    x = self.pool(x)\n",
        "\n",
        "    x = torch.flatten(x, start_dim = 1)\n",
        "\n",
        "    x = self.fc1(x)\n",
        "    x = self.relu(x)\n",
        "    x = self.fc2(x)\n",
        "    x = self.relu(x)\n",
        "    x = self.fc3(x)\n",
        "\n",
        "    return x"
      ],
      "metadata": {
        "id": "_qBMGPpticmz"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import tqdm\n",
        "\n",
        "from torchvision.datasets.cifar import CIFAR10\n",
        "from torchvision.transforms import Compose, ToTensor\n",
        "from torchvision.transforms import RandomHorizontalFlip, RandomCrop\n",
        "from torchvision.transforms import Normalize\n",
        "from torch.utils.data.dataloader import DataLoader\n",
        "\n",
        "from torch.optim.adam import Adam\n",
        "\n",
        "transforms = Compose([\n",
        "    RandomCrop((32, 32), padding = 4),\n",
        "    RandomHorizontalFlip(p = 0.5),\n",
        "    ToTensor(),\n",
        "    Normalize(mean = (0.4914, 0.4822, 0.4465), std = (0.247, 0.243, 0.261))\n",
        "])"
      ],
      "metadata": {
        "id": "PJd09i3RjYdE"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "training_data = CIFAR10(root = \"./\", train = True, transform = transforms, download = True)\n",
        "test_data = CIFAR10(root = \"./\", train = False, transform = transforms, download = True)\n",
        "\n",
        "train_loader = DataLoader(training_data, batch_size = 32, shuffle = True)\n",
        "test_loader = DataLoader(test_data, batch_size = 32, shuffle = False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PsWV4P4JkJu4",
        "outputId": "a9989550-16bd-4789-ed46-acecd3776241"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./cifar-10-python.tar.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 170498071/170498071 [00:13<00:00, 12799810.05it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./cifar-10-python.tar.gz to ./\n",
            "Files already downloaded and verified\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "\n",
        "model = ResNet(num_classes = 10)\n",
        "model.to(device)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CIpfjMHUkkYg",
        "outputId": "23d1dd9f-b8ac-48ec-98e5-96180ebdc32a"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "ResNet(\n",
              "  (b1): BasicBlock(\n",
              "    (c1): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (c2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (downsample): Conv2d(3, 64, kernel_size=(1, 1), stride=(1, 1))\n",
              "    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (relu): ReLU()\n",
              "  )\n",
              "  (b2): BasicBlock(\n",
              "    (c1): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (c2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (downsample): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1))\n",
              "    (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (relu): ReLU()\n",
              "  )\n",
              "  (b3): BasicBlock(\n",
              "    (c1): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (c2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (downsample): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1))\n",
              "    (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (relu): ReLU()\n",
              "  )\n",
              "  (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
              "  (fc1): Linear(in_features=4096, out_features=2048, bias=True)\n",
              "  (fc2): Linear(in_features=2048, out_features=512, bias=True)\n",
              "  (fc3): Linear(in_features=512, out_features=10, bias=True)\n",
              "  (relu): ReLU()\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lr = 1e-4\n",
        "optim = Adam(model.parameters(), lr = lr)\n",
        "\n",
        "for epoch in range(30):\n",
        "  iterator = tqdm.tqdm(train_loader)\n",
        "  for data, label in iterator:\n",
        "    optim.zero_grad()\n",
        "\n",
        "    preds = model(data.to(device))\n",
        "\n",
        "    loss = nn.CrossEntropyLoss()(preds, label.to(device))\n",
        "    loss.backward()\n",
        "    optim.step()\n",
        "\n",
        "    iterator.set_description(f\"epoch: {epoch + 1}, loss: {loss.item()}\")\n",
        "\n",
        "torch.save(model.state_dict(), \"ResNet.pth\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v0vDmq8ukt8U",
        "outputId": "045a8e44-12df-4639-f8d2-e59f3538c099"
      },
      "execution_count": 9,
      "outputs": [
        {
          "metadata": {
            "tags": null
          },
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "epoch: 1, loss: 0.3694911301136017: 100%|██████████| 1563/1563 [00:46<00:00, 33.29it/s]\n",
            "epoch: 2, loss: 0.7665402293205261: 100%|██████████| 1563/1563 [00:49<00:00, 31.71it/s]\n",
            "epoch: 3, loss: 0.6997523307800293: 100%|██████████| 1563/1563 [00:47<00:00, 32.57it/s]\n",
            "epoch: 4, loss: 0.4882102608680725: 100%|██████████| 1563/1563 [00:46<00:00, 33.36it/s]\n",
            "epoch: 5, loss: 0.552060604095459: 100%|██████████| 1563/1563 [00:47<00:00, 32.83it/s]\n",
            "epoch: 6, loss: 0.4996434152126312: 100%|██████████| 1563/1563 [00:47<00:00, 32.76it/s]\n",
            "epoch: 7, loss: 0.3295142352581024: 100%|██████████| 1563/1563 [00:46<00:00, 33.58it/s]\n",
            "epoch: 8, loss: 0.8468450903892517: 100%|██████████| 1563/1563 [00:47<00:00, 32.98it/s]\n",
            "epoch: 9, loss: 0.1518683135509491: 100%|██████████| 1563/1563 [00:47<00:00, 32.82it/s]\n",
            "epoch: 10, loss: 0.06409507244825363: 100%|██████████| 1563/1563 [00:46<00:00, 33.62it/s]\n",
            "epoch: 11, loss: 0.28471311926841736: 100%|██████████| 1563/1563 [00:46<00:00, 33.31it/s]\n",
            "epoch: 12, loss: 0.3270482122898102: 100%|██████████| 1563/1563 [00:47<00:00, 32.62it/s]\n",
            "epoch: 13, loss: 0.12191484123468399: 100%|██████████| 1563/1563 [00:46<00:00, 33.42it/s]\n",
            "epoch: 14, loss: 0.6407263278961182: 100%|██████████| 1563/1563 [00:46<00:00, 33.38it/s]\n",
            "epoch: 15, loss: 0.09273514896631241: 100%|██████████| 1563/1563 [00:47<00:00, 32.58it/s]\n",
            "epoch: 16, loss: 0.08266895264387131: 100%|██████████| 1563/1563 [00:46<00:00, 33.40it/s]\n",
            "epoch: 17, loss: 0.0204607080668211: 100%|██████████| 1563/1563 [00:47<00:00, 33.20it/s]\n",
            "epoch: 18, loss: 0.18210841715335846: 100%|██████████| 1563/1563 [00:47<00:00, 32.72it/s]\n",
            "epoch: 19, loss: 0.2667931616306305: 100%|██████████| 1563/1563 [00:46<00:00, 33.50it/s]\n",
            "epoch: 20, loss: 0.37232616543769836: 100%|██████████| 1563/1563 [00:46<00:00, 33.38it/s]\n",
            "epoch: 21, loss: 0.03960932791233063: 100%|██████████| 1563/1563 [00:48<00:00, 32.14it/s]\n",
            "epoch: 22, loss: 0.21053248643875122: 100%|██████████| 1563/1563 [00:47<00:00, 33.24it/s]\n",
            "epoch: 23, loss: 0.1217363104224205: 100%|██████████| 1563/1563 [00:46<00:00, 33.34it/s]\n",
            "epoch: 24, loss: 0.00998536217957735: 100%|██████████| 1563/1563 [00:47<00:00, 32.84it/s]\n",
            "epoch: 25, loss: 0.014092085883021355: 100%|██████████| 1563/1563 [00:47<00:00, 33.05it/s]\n",
            "epoch: 26, loss: 0.02138543501496315: 100%|██████████| 1563/1563 [00:46<00:00, 33.39it/s]\n",
            "epoch: 27, loss: 0.00820030178874731: 100%|██████████| 1563/1563 [00:47<00:00, 32.89it/s]\n",
            "epoch: 28, loss: 0.14086878299713135: 100%|██████████| 1563/1563 [00:48<00:00, 32.51it/s]\n",
            "epoch: 29, loss: 0.01245071366429329: 100%|██████████| 1563/1563 [00:47<00:00, 32.98it/s]\n",
            "epoch: 30, loss: 0.003367370693013072: 100%|██████████| 1563/1563 [00:47<00:00, 33.01it/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# evaluation on the model\n",
        "\n",
        "model.load_state_dict(torch.load(\"ResNet.pth\", map_location = device))\n",
        "\n",
        "num_corr = 0\n",
        "\n",
        "with torch.no_grad():\n",
        "  for data, label in test_loader:\n",
        "\n",
        "    output = model(data.to(device))\n",
        "    preds = output.data.max(1)[1]\n",
        "    corr = preds.eq(label.to(device).data).sum().item()\n",
        "    num_corr += corr\n",
        "\n",
        "  print(f\"Accuracy: {num_corr / len(test_data)}%\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fMtdh4bSlSKy",
        "outputId": "8b3bcd99-4789-4f84-d3ec-a02f3ab75209"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 0.8855%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "qShCsC72l3CE"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}