CIFAR_10_Convolutional_Neural_Network.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPVxOPJ/1PeiK4Mv9JD4OG5",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Aryan-401/GoogleColabProjects/blob/main/CIFAR_10_Convolutional_Neural_Network.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "As_4HHyOuBco"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fqh8-8nBZquF"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QLR7spODbIzX",
        "outputId": "e83bbf04-bf0d-479c-ef49-33a71f3bf9c3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cuda')"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "num_epochs = 4\n",
        "batch_size = 4\n",
        "learning_rate = 0.001\n",
        "\n",
        "transform = transforms.Compose(\n",
        "    [\n",
        "        transforms.ToTensor(),\n",
        "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
        "    ]\n",
        ")\n"
      ],
      "metadata": {
        "id": "jtUBOtiFbWl5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download =True, transform = transform)\n",
        "test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download =True, transform = transform)\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
        "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FlJPu7aHcQAp",
        "outputId": "2de55e9d-be4b-4ecd-9e4f-e076310baf0b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
      ],
      "metadata": {
        "id": "LyXOpmR4c2EP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class ConvNet(nn.Module):\n",
        "  def __init__(self):\n",
        "    super(ConvNet, self).__init__()\n",
        "    self.conf1 = nn.Conv2d(3, 6, 5)\n",
        "    self.pool = nn.MaxPool2d(2, 2)\n",
        "    self.conf2 = nn.Conv2d(6, 16, 5)\n",
        "    self.fc1 = nn.Linear(16*5*5, 120)\n",
        "    self.fc2 = nn.Linear(120, 84)\n",
        "    self.fc3 = nn.Linear(84, 10)\n",
        "  def forward(self, x):\n",
        "    x = self.pool(F.relu(self.conf1(x)))\n",
        "    x = self.pool(F.relu(self.conf2(x)))\n",
        "    x = x.view(-1, 16*5*5)\n",
        "    x = F.relu(self.fc1(x))\n",
        "    x = F.relu(self.fc2(x))\n",
        "    x = self.fc3(x)\n",
        "    return x\n"
      ],
      "metadata": {
        "id": "0RTuBmqWdL4G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = ConvNet()\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimiser = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
        "\n",
        "n_total_steps = len(train_loader)\n",
        "model.to(device)\n",
        "for epoch in range(num_epochs):\n",
        "  for i,(images, labels) in enumerate(train_loader):\n",
        "    images = images.to(device)\n",
        "    labels = labels.to(device)\n",
        "\n",
        "    outputs = model(images)\n",
        "    loss = criterion(outputs, labels)\n",
        "    optimiser.zero_grad()\n",
        "    loss.backward()\n",
        "    optimiser.step()\n",
        "\n",
        "    if (i+1)%2000 == 0:\n",
        "      print(f'epoch #{epoch+1}/{num_epochs} | Step:{(i+1)}/{n_total_steps} | Loss:{loss.item():.4f}')\n",
        "print(\"Finished Training\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "02ggXgKldOP9",
        "outputId": "f374c0cd-f9e5-4fa4-e472-d1f8d83520ef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "epoch #1/4 | Step:2000/10000 | Loss:2.3082\n",
            "epoch #1/4 | Step:4000/10000 | Loss:2.3053\n",
            "epoch #1/4 | Step:6000/10000 | Loss:2.2728\n",
            "epoch #1/4 | Step:8000/10000 | Loss:2.2948\n",
            "epoch #1/4 | Step:10000/10000 | Loss:2.2597\n",
            "epoch #2/4 | Step:2000/10000 | Loss:2.1894\n",
            "epoch #2/4 | Step:4000/10000 | Loss:1.8801\n",
            "epoch #2/4 | Step:6000/10000 | Loss:2.0926\n",
            "epoch #2/4 | Step:8000/10000 | Loss:2.1120\n",
            "epoch #2/4 | Step:10000/10000 | Loss:1.3645\n",
            "epoch #3/4 | Step:2000/10000 | Loss:1.9317\n",
            "epoch #3/4 | Step:4000/10000 | Loss:1.9912\n",
            "epoch #3/4 | Step:6000/10000 | Loss:1.3274\n",
            "epoch #3/4 | Step:8000/10000 | Loss:0.8921\n",
            "epoch #3/4 | Step:10000/10000 | Loss:1.3863\n",
            "epoch #4/4 | Step:2000/10000 | Loss:1.7328\n",
            "epoch #4/4 | Step:4000/10000 | Loss:1.7411\n",
            "epoch #4/4 | Step:6000/10000 | Loss:1.2210\n",
            "epoch #4/4 | Step:8000/10000 | Loss:1.7922\n",
            "epoch #4/4 | Step:10000/10000 | Loss:0.9294\n",
            "Finished Training\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with torch.no_grad():\n",
        "    n_correct = 0\n",
        "    n_samples = 0\n",
        "    n_class_correct = [0 for i in range(10)]\n",
        "    n_class_samples = [0 for i in range(10)]\n",
        "    for images, labels in test_loader:\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        outputs = model(images)\n",
        "        # max returns (value ,index)\n",
        "        _, predicted = torch.max(outputs, 1)\n",
        "        n_samples += labels.size(0)\n",
        "        n_correct += (predicted == labels).sum().item()\n",
        "        \n",
        "        for i in range(batch_size):\n",
        "            label = labels[i]\n",
        "            pred = predicted[i]\n",
        "            if (label == pred):\n",
        "                n_class_correct[label] += 1\n",
        "            n_class_samples[label] += 1\n",
        "\n",
        "    acc = 100.0 * n_correct / n_samples\n",
        "    print(f'Accuracy of the network: {acc} %')\n",
        "\n",
        "    for i in range(10):\n",
        "        acc = 100.0 * n_class_correct[i] / n_class_samples[i]\n",
        "        print(f'Accuracy of {classes[i]}: {acc} %')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VIE08vMKey1c",
        "outputId": "7068cefb-5933-4cba-b7db-a2876a2c5ae6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy of the network: 41.97 %\n",
            "Accuracy of plane: 59.42211055276382 %\n",
            "Accuracy of car: 69.36708860759494 %\n",
            "Accuracy of bird: 8.663366336633663 %\n",
            "Accuracy of cat: 37.37623762376238 %\n",
            "Accuracy of deer: 25.985221674876847 %\n",
            "Accuracy of dog: 35.57814485387548 %\n",
            "Accuracy of frog: 50.92936802973978 %\n",
            "Accuracy of horse: 47.3551637279597 %\n",
            "Accuracy of ship: 39.75 %\n",
            "Accuracy of truck: 44.987468671679196 %\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ookvst-Nk_VX"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}