DL_ass3.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "q1_4n0BqFB3v"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Load and normalize dataset"
      ],
      "metadata": {
        "id": "rgSqfe6LMW48"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "gNOSCp0zFB3x",
        "outputId": "a52cb95c-5015-40c7-b2a0-3339b26d6874",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n"
          ]
        }
      ],
      "source": [
        "transform = transforms.Compose(\n",
        "    [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
        "\n",
        "batch_size = 8\n",
        "\n",
        "trainset = torchvision.datasets.CIFAR10(root='./data', train=True,\n",
        "                                        download=True, transform=transform)\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
        "                                          shuffle=True, num_workers=2)\n",
        "\n",
        "testset = torchvision.datasets.CIFAR10(root='./data', train=False,\n",
        "                                       download=True, transform=transform)\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\n",
        "                                         shuffle=False, num_workers=2)\n",
        "\n",
        "classes = ('plane', 'car', 'bird', 'cat',\n",
        "           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NtEjwT2yFB3y"
      },
      "source": [
        "### 2. Convolutional Neural Network\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "OvTdihg_FB3y"
      },
      "outputs": [],
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "\n",
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.conv1 = nn.Conv2d(3, 6, 5) #This layer has 3 input channels (e.g., for RGB images), 6 output channels, and a kernel size of 5x5\n",
        "        self.pool = nn.MaxPool2d(2, 2) #max-pooling layer with a 2x2 window size and a stride of 2\n",
        "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
        "        self.fc1 = nn.Linear(16 * 5 * 5, 120) #This line creates a fully connected (linear) layer with 16 * 5 * 5 input features (which is the result of flattening the output of the second convolutional layer) and 120 output features.\n",
        "        self.fc2 = nn.Linear(120, 84)\n",
        "        self.fc3 = nn.Linear(84, 10) #output layer has 10 nodes because there are 10 classes in the dataset.\n",
        "\n",
        "    def forward(self, x):\n",
        "        # print(x.size())\n",
        "        x = self.pool(F.relu(self.conv1(x)))\n",
        "        # print(x.size())\n",
        "        x = self.pool(F.relu(self.conv2(x))) #same pool on 2nd convolution\n",
        "        # print(x.size())\n",
        "        x = torch.flatten(x, 1) # flatten all dimensions except batch\n",
        "        # print(x.size())\n",
        "        x = F.relu(self.fc1(x))\n",
        "        # print(x.size())\n",
        "        x = F.relu(self.fc2(x))\n",
        "        # print(x.size())\n",
        "        x = self.fc3(x)\n",
        "        # print(x.size())\n",
        "        return x\n",
        "\n",
        "\n",
        "net = Net()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KAaJDbWVFB3z"
      },
      "source": [
        "### 3. Loss function and optimizer\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "SckumtAwFB3z"
      },
      "outputs": [],
      "source": [
        "import torch.optim as optim\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.SGD(net.parameters(), lr=0.0001, momentum=0.8)\n",
        "\n",
        "# optimizer = optim.Adam(net.parameters(), lr=0.0001)\n",
        "# optimizer3 = optim.RMSprop(net.parameters(), lr=0.01, alpha=0.9)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S-ESligRFB3z"
      },
      "source": [
        "### 4. Training\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "HR738RSDFB3z",
        "outputId": "7c9c577d-9e2d-402a-f39e-86138de69935",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1,  2000] loss: 2.306\n",
            "[1,  4000] loss: 2.302\n",
            "[1,  6000] loss: 2.300\n",
            "[2,  2000] loss: 2.296\n",
            "[2,  4000] loss: 2.291\n",
            "[2,  6000] loss: 2.284\n",
            "[3,  2000] loss: 2.263\n",
            "[3,  4000] loss: 2.226\n",
            "[3,  6000] loss: 2.173\n",
            "[4,  2000] loss: 2.134\n",
            "[4,  4000] loss: 2.111\n",
            "[4,  6000] loss: 2.091\n",
            "[5,  2000] loss: 2.068\n",
            "[5,  4000] loss: 2.049\n",
            "[5,  6000] loss: 2.015\n",
            "[6,  2000] loss: 1.971\n",
            "[6,  4000] loss: 1.941\n",
            "[6,  6000] loss: 1.917\n",
            "[7,  2000] loss: 1.892\n",
            "[7,  4000] loss: 1.868\n",
            "[7,  6000] loss: 1.841\n",
            "[8,  2000] loss: 1.813\n",
            "[8,  4000] loss: 1.795\n",
            "[8,  6000] loss: 1.761\n",
            "Finished Training\n"
          ]
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Initialize an empty list to store the loss values\n",
        "loss_values = []\n",
        "\n",
        "# Training loop\n",
        "for epoch in range(8):  # loop over the dataset multiple times\n",
        "    running_loss = 0.0\n",
        "    for i, data in enumerate(trainloader, 0):\n",
        "        # get the inputs; data is a list of [inputs, labels]\n",
        "        inputs, labels = data\n",
        "\n",
        "        # zero the parameter gradients\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        # forward + backward + optimize\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # Store the loss value in the list\n",
        "        running_loss += loss.item()\n",
        "\n",
        "        if i % 2000 == 1999:  # print every 2000 mini-batches\n",
        "            print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')\n",
        "            loss_values.append(running_loss / 2000)  # Append the average loss to the list\n",
        "            running_loss = 0.0\n",
        "\n",
        "\n",
        "print('Finished Training')\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the loss values\n",
        "plt.plot(loss_values)\n",
        "plt.title('Training Loss')\n",
        "plt.xlabel('Mini-batch')\n",
        "plt.ylabel('Loss')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "5VfyY_U9IoLY",
        "outputId": "4c2364a6-a794-4148-8695-8f606c700f1f"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.savefig(\"exp-1.png\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "id": "lq2oNmg2RXex",
        "outputId": "e747043c-3adb-4856-e922-c07411925e2c"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 0 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "wFIW40WSFB30"
      },
      "outputs": [],
      "source": [
        "PATH = './cifar_net.pth'\n",
        "torch.save(net.state_dict(), PATH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "1QCPPAkkFB30",
        "outputId": "a1cdbfbf-5076-436d-f469-d8cba15a58e3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ],
      "source": [
        "net = Net()\n",
        "net.load_state_dict(torch.load(PATH))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
        "\n",
        "correct = 0\n",
        "total = 0\n",
        "true_labels = []\n",
        "predicted_labels = []\n",
        "\n",
        "with torch.no_grad():\n",
        "    for data in testloader:\n",
        "        images, labels = data\n",
        "        # calculate outputs by running images through the network\n",
        "        outputs = net(images)\n",
        "        # the class with the highest energy is what we choose as prediction\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        total += labels.size(0)\n",
        "        correct += (predicted == labels).sum().item()\n",
        "        true_labels.extend(labels.numpy())\n",
        "        predicted_labels.extend(predicted.numpy())\n",
        "\n",
        "accuracy = accuracy_score(true_labels, predicted_labels)\n",
        "precision = precision_score(true_labels, predicted_labels, average='weighted')\n",
        "recall = recall_score(true_labels, predicted_labels, average='weighted')\n",
        "f1 = f1_score(true_labels, predicted_labels, average='weighted')\n",
        "\n",
        "print(f'Accuracy of the network on the test data: {accuracy * 100:.2f}%')\n",
        "print(f'Precision: {precision:.2f}')\n",
        "print(f'Recall: {recall:.2f}')\n",
        "print(f'F1 Score: {f1:.2f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3GhQUtISNhd2",
        "outputId": "b5cb64d8-a3f1-4b89-f3b4-2095ac308610"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy of the network on the test data: 37.17%\n",
            "Precision: 0.36\n",
            "Recall: 0.37\n",
            "F1 Score: 0.35\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "BUyhLYV6CqrS"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.13"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}