{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "id": "NMrQFk3he4cE",
        "outputId": "4deda298-9598-465b-cd17-fbbb2ee52cc7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: torch in /usr/local/lib/python3.12/dist-packages (2.8.0+cu126)\n",
            "Requirement already satisfied: torchvision in /usr/local/lib/python3.12/dist-packages (0.23.0+cu126)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from torch) (3.20.0)\n",
            "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.12/dist-packages (from torch) (4.15.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.12/dist-packages (from torch) (75.2.0)\n",
            "Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.12/dist-packages (from torch) (1.13.3)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.12/dist-packages (from torch) (3.5)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.12/dist-packages (from torch) (3.1.6)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.12/dist-packages (from torch) (2025.3.0)\n",
            "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.6.77 in /usr/local/lib/python3.12/dist-packages (from torch) (12.6.77)\n",
            "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.6.77 in /usr/local/lib/python3.12/dist-packages (from torch) (12.6.77)\n",
            "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.6.80 in /usr/local/lib/python3.12/dist-packages (from torch) (12.6.80)\n",
            "Requirement already satisfied: nvidia-cudnn-cu12==9.10.2.21 in /usr/local/lib/python3.12/dist-packages (from torch) (9.10.2.21)\n",
            "Requirement already satisfied: nvidia-cublas-cu12==12.6.4.1 in /usr/local/lib/python3.12/dist-packages (from torch) (12.6.4.1)\n",
            "Requirement already satisfied: nvidia-cufft-cu12==11.3.0.4 in /usr/local/lib/python3.12/dist-packages (from torch) (11.3.0.4)\n",
            "Requirement already satisfied: nvidia-curand-cu12==10.3.7.77 in /usr/local/lib/python3.12/dist-packages (from torch) (10.3.7.77)\n",
            "Requirement already satisfied: nvidia-cusolver-cu12==11.7.1.2 in /usr/local/lib/python3.12/dist-packages (from torch) (11.7.1.2)\n",
            "Requirement already satisfied: nvidia-cusparse-cu12==12.5.4.2 in /usr/local/lib/python3.12/dist-packages (from torch) (12.5.4.2)\n",
            "Requirement already satisfied: nvidia-cusparselt-cu12==0.7.1 in /usr/local/lib/python3.12/dist-packages (from torch) (0.7.1)\n",
            "Requirement already satisfied: nvidia-nccl-cu12==2.27.3 in /usr/local/lib/python3.12/dist-packages (from torch) (2.27.3)\n",
            "Requirement already satisfied: nvidia-nvtx-cu12==12.6.77 in /usr/local/lib/python3.12/dist-packages (from torch) (12.6.77)\n",
            "Requirement already satisfied: nvidia-nvjitlink-cu12==12.6.85 in /usr/local/lib/python3.12/dist-packages (from torch) (12.6.85)\n",
            "Requirement already satisfied: nvidia-cufile-cu12==1.11.1.6 in /usr/local/lib/python3.12/dist-packages (from torch) (1.11.1.6)\n",
            "Requirement already satisfied: triton==3.4.0 in /usr/local/lib/python3.12/dist-packages (from torch) (3.4.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from torchvision) (2.0.2)\n",
            "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.12/dist-packages (from torchvision) (11.3.0)\n",
            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from sympy>=1.13.3->torch) (1.3.0)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.12/dist-packages (from jinja2->torch) (3.0.3)\n"
          ]
        }
      ],
      "source": [
        "!pip install torch torchvision\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "from torch.utils.data import DataLoader, random_split\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "rP8RtSdbe_j5"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Transformations\n",
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize((0.5,), (0.5,))\n",
        "])\n",
        "\n",
        "# Download MNIST\n",
        "train_full = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
        "test_set = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n",
        "\n",
        "# Split train → train + validation\n",
        "train_size = int(0.8 * len(train_full))\n",
        "val_size = len(train_full) - train_size\n",
        "train_set, val_set = random_split(train_full, [train_size, val_size])\n",
        "\n",
        "# Data loaders\n",
        "train_loader = DataLoader(train_set, batch_size=100, shuffle=True)\n",
        "val_loader = DataLoader(val_set, batch_size=100, shuffle=False)\n",
        "test_loader = DataLoader(test_set, batch_size=100, shuffle=False)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IhLkyqWpe_nT",
        "outputId": "34af7d74-8b0f-4735-dc82-5ecdef2a0cb3"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 9.91M/9.91M [00:00<00:00, 64.4MB/s]\n",
            "100%|██████████| 28.9k/28.9k [00:00<00:00, 1.65MB/s]\n",
            "100%|██████████| 1.65M/1.65M [00:00<00:00, 14.5MB/s]\n",
            "100%|██████████| 4.54k/4.54k [00:00<00:00, 10.7MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class CNN_NoDropout(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(CNN_NoDropout, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(1, 32, 3, padding=1)\n",
        "        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)\n",
        "        self.pool = nn.MaxPool2d(2, 2)\n",
        "        self.fc1 = nn.Linear(64 * 7 * 7, 128)\n",
        "        self.fc2 = nn.Linear(128, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(torch.relu(self.conv1(x)))\n",
        "        x = self.pool(torch.relu(self.conv2(x)))\n",
        "        x = x.view(-1, 64 * 7 * 7)\n",
        "        x = torch.relu(self.fc1(x))\n",
        "        x = self.fc2(x)\n",
        "        return x\n"
      ],
      "metadata": {
        "id": "y902p-eyfKmF"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class CNN_WithDropout(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(CNN_WithDropout, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(1, 32, 3, padding=1)\n",
        "        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)\n",
        "        self.pool = nn.MaxPool2d(2, 2)\n",
        "        self.dropout = nn.Dropout(p=0.5)\n",
        "        self.fc1 = nn.Linear(64 * 7 * 7, 128)\n",
        "        self.fc2 = nn.Linear(128, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(torch.relu(self.conv1(x)))\n",
        "        x = self.pool(torch.relu(self.conv2(x)))\n",
        "        x = x.view(-1, 64 * 7 * 7)\n",
        "        x = self.dropout(torch.relu(self.fc1(x)))\n",
        "        x = self.fc2(x)\n",
        "        return x\n"
      ],
      "metadata": {
        "id": "-3cze2SRfKon"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train_and_validate(model, train_loader, val_loader, optimizer, criterion, epochs=10):\n",
        "    train_loss_list, val_loss_list = [], []\n",
        "    train_acc_list, val_acc_list = [], []\n",
        "\n",
        "    for epoch in range(epochs):\n",
        "        model.train()\n",
        "        total, correct, running_loss = 0, 0, 0\n",
        "\n",
        "        for images, labels in train_loader:\n",
        "            outputs = model(images)\n",
        "            loss = criterion(outputs, labels)\n",
        "\n",
        "            optimizer.zero_grad()\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "            running_loss += loss.item()\n",
        "            _, pred = torch.max(outputs, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (pred == labels).sum().item()\n",
        "\n",
        "        train_loss_list.append(running_loss / len(train_loader))\n",
        "        train_acc_list.append(100 * correct / total)\n",
        "\n",
        "        # Validation\n",
        "        model.eval()\n",
        "        total, correct, val_loss = 0, 0, 0\n",
        "        with torch.no_grad():\n",
        "            for images, labels in val_loader:\n",
        "                outputs = model(images)\n",
        "                loss = criterion(outputs, labels)\n",
        "                val_loss += loss.item()\n",
        "                _, pred = torch.max(outputs, 1)\n",
        "                total += labels.size(0)\n",
        "                correct += (pred == labels).sum().item()\n",
        "\n",
        "        val_loss_list.append(val_loss / len(val_loader))\n",
        "        val_acc_list.append(100 * correct / total)\n",
        "\n",
        "        print(f\"Epoch [{epoch+1}/{epochs}]  Train Acc: {train_acc_list[-1]:.2f}%  Val Acc: {val_acc_list[-1]:.2f}%\")\n",
        "\n",
        "    return train_loss_list, val_loss_list, train_acc_list, val_acc_list\n"
      ],
      "metadata": {
        "id": "iZmp08_jfKsA"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "criterion = nn.CrossEntropyLoss()\n",
        "\n",
        "# No Dropout Model\n",
        "model_no = CNN_NoDropout()\n",
        "optimizer_no = optim.SGD(model_no.parameters(), lr=0.01, momentum=0.9)\n",
        "\n",
        "loss_no_train, loss_no_val, acc_no_train, acc_no_val = train_and_validate(model_no, train_loader, val_loader, optimizer_no, criterion)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PUMW_66jfUPu",
        "outputId": "729472f3-ee41-41fc-f667-7ee8c8cc6f2f"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/10]  Train Acc: 88.33%  Val Acc: 96.10%\n",
            "Epoch [2/10]  Train Acc: 97.77%  Val Acc: 97.97%\n",
            "Epoch [3/10]  Train Acc: 98.43%  Val Acc: 98.41%\n",
            "Epoch [4/10]  Train Acc: 98.69%  Val Acc: 98.57%\n",
            "Epoch [5/10]  Train Acc: 99.03%  Val Acc: 98.58%\n",
            "Epoch [6/10]  Train Acc: 99.09%  Val Acc: 98.86%\n",
            "Epoch [7/10]  Train Acc: 99.33%  Val Acc: 98.79%\n",
            "Epoch [8/10]  Train Acc: 99.39%  Val Acc: 98.87%\n",
            "Epoch [9/10]  Train Acc: 99.51%  Val Acc: 98.98%\n",
            "Epoch [10/10]  Train Acc: 99.56%  Val Acc: 98.99%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# With Dropout Model\n",
        "model_do = CNN_WithDropout()\n",
        "optimizer_do = optim.SGD(model_do.parameters(), lr=0.01, momentum=0.9)\n",
        "\n",
        "loss_do_train, loss_do_val, acc_do_train, acc_do_val = train_and_validate(model_do, train_loader, val_loader, optimizer_do, criterion)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m04QnGHffUTV",
        "outputId": "f754984d-3c4c-407d-d6b5-56f1a070c9e5"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/10]  Train Acc: 83.69%  Val Acc: 97.16%\n",
            "Epoch [2/10]  Train Acc: 96.30%  Val Acc: 97.82%\n",
            "Epoch [3/10]  Train Acc: 97.30%  Val Acc: 98.28%\n",
            "Epoch [4/10]  Train Acc: 97.83%  Val Acc: 98.60%\n",
            "Epoch [5/10]  Train Acc: 98.11%  Val Acc: 98.78%\n",
            "Epoch [6/10]  Train Acc: 98.35%  Val Acc: 98.83%\n",
            "Epoch [7/10]  Train Acc: 98.46%  Val Acc: 98.86%\n",
            "Epoch [8/10]  Train Acc: 98.60%  Val Acc: 98.78%\n",
            "Epoch [9/10]  Train Acc: 98.74%  Val Acc: 99.01%\n",
            "Epoch [10/10]  Train Acc: 98.83%  Val Acc: 98.99%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def test_accuracy(model):\n",
        "    model.eval()\n",
        "    correct, total = 0, 0\n",
        "    with torch.no_grad():\n",
        "        for images, labels in test_loader:\n",
        "            outputs = model(images)\n",
        "            _, pred = torch.max(outputs, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (pred == labels).sum().item()\n",
        "    return 100 * correct / total\n",
        "\n",
        "acc_test_no = test_accuracy(model_no)\n",
        "acc_test_do = test_accuracy(model_do)\n",
        "\n",
        "print(f\"Test Accuracy (No Dropout): {acc_test_no:.2f}%\")\n",
        "print(f\"Test Accuracy (With Dropout): {acc_test_do:.2f}%\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "udeQY2AFfcxM",
        "outputId": "2ae88a41-3f27-4abc-c28a-4b419054ca28"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracy (No Dropout): 99.00%\n",
            "Test Accuracy (With Dropout): 99.11%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(14,10))\n",
        "\n",
        "plt.subplot(2,2,1)\n",
        "plt.plot(loss_no_train, label='No Dropout')\n",
        "plt.plot(loss_do_train, label='With Dropout')\n",
        "plt.title(\"Training Loss\")\n",
        "plt.legend()\n",
        "\n",
        "plt.subplot(2,2,2)\n",
        "plt.plot(loss_no_val, label='No Dropout')\n",
        "plt.plot(loss_do_val, label='With Dropout')\n",
        "plt.title(\"Validation Loss\")\n",
        "plt.legend()\n",
        "\n",
        "plt.subplot(2,2,3)\n",
        "plt.plot(acc_no_train, label='No Dropout')\n",
        "plt.plot(acc_do_train, label='With Dropout')\n",
        "plt.title(\"Training Accuracy\")\n",
        "plt.legend()\n",
        "\n",
        "plt.subplot(2,2,4)\n",
        "plt.plot(acc_no_val, label='No Dropout')\n",
        "plt.plot(acc_do_val, label='With Dropout')\n",
        "plt.title(\"Validation Accuracy\")\n",
        "plt.legend()\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "23ar7HfVfc-k",
        "outputId": "e80a3e2c-e873-46d4-d1ee-a1aeb6c9ab56"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1400x1000 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "5t3et4vMlJqr"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}