notebookdbcf744817.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1141d453",
   "metadata": {
    "id": "4NMjWL56RH5p",
    "papermill": {
     "duration": 0.005743,
     "end_time": "2025-02-28T08:39:47.236164",
     "exception": false,
     "start_time": "2025-02-28T08:39:47.230421",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 📝 **Assignment Instructions** 📚  \n",
    "\n",
    "### 1️⃣ **Data Loading** (🔟 points)  \n",
    "- ✅ Complete the `load_mnist_data` function  \n",
    "- 🔄 Properly **normalize** and **transform** the data  \n",
    "\n",
    "### 2️⃣ **Custom Dropout** (2️⃣0️⃣ points)  \n",
    "- 🔧 Implement **forward** and **backward** passes  \n",
    "- 🎯 Match **PyTorch’s** `nn.Dropout` behavior  \n",
    "- 📏 Ensure **proper scaling** during training  \n",
    "\n",
    "### 3️⃣ **Custom BatchNorm, CustomRelu, CustomMaxPooling** (3️⃣0️⃣ points)  \n",
    "- 🔍 Implement **forward pass** with proper normalization  \n",
    "- 📊 Track **running statistics** accurately  \n",
    "- 🔄 Handle **both training and evaluation** modes  \n",
    "\n",
    "### 4️⃣ **CNN Architecture** (2️⃣0️⃣ points)  \n",
    "- 🛠️ Implement Your Own **Custom VGG16 Model**  \n",
    "- 🔢 Use appropriate **layer sizes and activations**  \n",
    "- 📐 Properly handle **input/output dimensions**  \n",
    "\n",
    "### 5️⃣ **Training Implementation** (2️⃣0️⃣ points)  \n",
    "- 🚀 Complete **training and evaluation loops**  \n",
    "- 📈 Implement **logging and visualization**    \n",
    "\n",
    "---\n",
    "\n",
    "### ⭐ **Bonus**  \n",
    "- 📦 **Data Augmentation**  \n",
    "- 🔄 **Learning Rate Scheduling**  \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9f69d8d",
   "metadata": {
    "id": "hSkOEXsfjwWw",
    "papermill": {
     "duration": 0.006131,
     "end_time": "2025-02-28T08:39:47.247430",
     "exception": false,
     "start_time": "2025-02-28T08:39:47.241299",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### 📝 **Report Guidelines: What to Include**\n",
    "\n",
    "1️⃣ **Introduction** 📖  \n",
    "   - Briefly introduce the goal of this assignment.  \n",
    "   - Explain the importance of building custom components (e.g., CustomBatchNorm, CustomReLU, CustomMaxPooling) in deep learning.  \n",
    "   - Mention that this exercise will help you understand how these components work internally.\n",
    "\n",
    "---\n",
    "\n",
    "2️⃣ **Implementation Details** 🛠️  \n",
    "   For each component, explain:  \n",
    "   \n",
    "   - Describe how you implemented `CustomBatchNorm2d`, `CustomReLU`, and `CustomMaxPooling2d`.  \n",
    "   - Highlight any key challenges and how you overcame them.  \n",
    "   - Explain the architecture of your VGG16 model.  \n",
    "   - Describe how you used custom components in the model's convolutional blocks.  \n",
    "   - Discuss your choice of activation functions, kernel sizes, and layer design.\n",
    "\n",
    "---\n",
    "\n",
    "3️⃣ **Training Strategy and Results** 📈  \n",
    "   - Describe your training strategy (e.g., hyperparameters, optimizer, learning rate schedule).  \n",
    "   - Present training and testing accuracy/loss curves.  \n",
    "   - Report the final test accuracy and compare it with the baseline accuracy using PyTorch's built-in components.  \n",
    "   - Discuss how your custom components affected the model's performance.  \n",
    "\n",
    "---\n",
    "\n",
    "4️⃣ **Conclusion and Future Work** 🔮  \n",
    "   - Summarize your key findings and insights.  \n",
    "   - Mention any areas where you would like to improve your implementation (e.g., handling edge cases in `CustomMaxPooling`).  \n",
    "\n",
    "---\n",
    "\n",
    "### 📤 **Submission Requirements** 📤  \n",
    "1️⃣ **Notebook** 📒: Complete the notebook with all implementations of `CustomBatchNorm2d`, `CustomReLU`, `CustomMaxPooling2d`, and your custom VGG16 model.  \n",
    "2️⃣ **Training Visualizations** 📈: Include accuracy and loss curves for both training and validation.  \n",
    "3️⃣ **Report** 📝: A concise report explaining your implementation choices, challenges faced, and comparisons with PyTorch's built-in components.  \n",
    "4️⃣ **PDF Submission** 📄:  \n",
    "   - Convert your report into a **PDF format**.  \n",
    "   - Ensure that the PDF includes all sections: Introduction, Implementation Details, Training Results and Conclusion.  \n",
    "   - Include relevant code snippets and result plots in the PDF.\n",
    "\n",
    "---\n",
    "\n",
    "### 📎 **How to Submit:**  \n",
    "- Submit a **single ZIP file** containing:  \n",
    "  - 📁 **Notebook (`.ipynb`)**  \n",
    "  - 📄 **Report (`.pdf`)**  \n",
    "  - 📊 **Training logs and plots (`.png`/`.pdf`)** if applicable.  \n",
    "- **Filename format:** `Assignment_<YourName_RollNumber>.zip`  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cd80568e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-28T08:39:47.257874Z",
     "iopub.status.busy": "2025-02-28T08:39:47.257665Z",
     "iopub.status.idle": "2025-02-28T08:39:54.829747Z",
     "shell.execute_reply": "2025-02-28T08:39:54.829060Z"
    },
    "id": "VKu6QwMCRTdh",
    "papermill": {
     "duration": 7.57907,
     "end_time": "2025-02-28T08:39:54.831311",
     "exception": false,
     "start_time": "2025-02-28T08:39:47.252241",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 🚀 **Importing Helper Modules**\n",
    "\n",
    "import torch  # 🧠 Core PyTorch library for tensor operations and neural networks\n",
    "import torch.nn as nn  # 🏗️ Neural network components (layers, loss functions)\n",
    "import torch.optim as optim  # ⚙️ Optimization algorithms (SGD, Adam, etc.)\n",
    "import torchvision  # 🎨 Computer vision utilities and datasets\n",
    "import torchvision.transforms as transforms  # 🖼️ Data transformations (normalization, augmentation)\n",
    "from torch.utils.data import DataLoader  # 🚚 For loading and batching data\n",
    "import matplotlib.pyplot as plt  # 📊 Visualization for losses and accuracies"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be88676c",
   "metadata": {
    "id": "vHFtYbZ4Rybb",
    "papermill": {
     "duration": 0.004821,
     "end_time": "2025-02-28T08:39:54.841479",
     "exception": false,
     "start_time": "2025-02-28T08:39:54.836658",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 🔢 **MNIST Dataset: The Classic Benchmark** 🖋️✨  \n",
    "\n",
    "**MNIST** is a popular dataset of **70,000 handwritten digits** (0-9) 📝, widely used for training and testing image processing systems.  \n",
    "\n",
    "### 📊 **Dataset Overview**  \n",
    "- 🖼️ **60,000 Training Images**  \n",
    "- 🖼️ **10,000 Test Images**  \n",
    "- 🔲 **Image Size:** 28x28 pixels (grayscale)  \n",
    "- 🔍 **Digits:** Size-normalized and centered  \n",
    "\n",
    "### 🌐 **Want to Learn More?**  \n",
    "Check out the full details here: [📖 Wikipedia - MNIST Database](https://en.wikipedia.org/wiki/MNIST_database)  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3e1fd980",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-28T08:39:54.852101Z",
     "iopub.status.busy": "2025-02-28T08:39:54.851790Z",
     "iopub.status.idle": "2025-02-28T08:40:14.049890Z",
     "shell.execute_reply": "2025-02-28T08:40:14.048870Z"
    },
    "papermill": {
     "duration": 19.205081,
     "end_time": "2025-02-28T08:40:14.051377",
     "exception": false,
     "start_time": "2025-02-28T08:39:54.846296",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2025-02-28 08:39:54--  http://www.di.ens.fr/~lelarge/MNIST.tar.gz\r\n",
      "Resolving www.di.ens.fr (www.di.ens.fr)... 129.199.99.14\r\n",
      "Connecting to www.di.ens.fr (www.di.ens.fr)|129.199.99.14|:80... connected.\r\n",
      "HTTP request sent, awaiting response... 302 Found\r\n",
      "Location: https://www.di.ens.fr/~lelarge/MNIST.tar.gz [following]\r\n",
      "--2025-02-28 08:39:55--  https://www.di.ens.fr/~lelarge/MNIST.tar.gz\r\n",
      "Connecting to www.di.ens.fr (www.di.ens.fr)|129.199.99.14|:443... connected.\r\n",
      "HTTP request sent, awaiting response... 200 OK\r\n",
      "Length: unspecified [application/x-gzip]\r\n",
      "Saving to: ‘MNIST.tar.gz’\r\n",
      "\r\n",
      "MNIST.tar.gz            [         <=>        ]  33.20M  6.77MB/s    in 6.1s    \r\n",
      "\r\n",
      "2025-02-28 08:40:02 (5.47 MB/s) - ‘MNIST.tar.gz’ saved [34813078]\r\n",
      "\r\n",
      "MNIST/\r\n",
      "MNIST/raw/\r\n",
      "MNIST/raw/train-labels-idx1-ubyte\r\n",
      "MNIST/raw/t10k-labels-idx1-ubyte.gz\r\n",
      "MNIST/raw/t10k-labels-idx1-ubyte\r\n",
      "MNIST/raw/t10k-images-idx3-ubyte.gz\r\n",
      "MNIST/raw/train-images-idx3-ubyte\r\n",
      "MNIST/raw/train-labels-idx1-ubyte.gz\r\n",
      "MNIST/raw/t10k-images-idx3-ubyte\r\n",
      "MNIST/raw/train-images-idx3-ubyte.gz\r\n",
      "MNIST/processed/\r\n",
      "MNIST/processed/training.pt\r\n",
      "MNIST/processed/test.pt\r\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
      "Failed to download (trying next):\n",
      "HTTP Error 404: Not Found\n",
      "\n",
      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz\n",
      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 9.91M/9.91M [00:01<00:00, 5.73MB/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
      "Failed to download (trying next):\n",
      "HTTP Error 404: Not Found\n",
      "\n",
      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz\n",
      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 28.9k/28.9k [00:00<00:00, 152kB/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
      "Failed to download (trying next):\n",
      "HTTP Error 404: Not Found\n",
      "\n",
      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz\n",
      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1.65M/1.65M [00:01<00:00, 1.43MB/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
      "Failed to download (trying next):\n",
      "HTTP Error 404: Not Found\n",
      "\n",
      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz\n",
      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4.54k/4.54k [00:00<00:00, 12.5MB/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Dataset MNIST\n",
       "    Number of datapoints: 60000\n",
       "    Root location: ./data\n",
       "    Split: Train"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "!wget www.di.ens.fr/~lelarge/MNIST.tar.gz\n",
    "!tar -zxvf MNIST.tar.gz\n",
    "\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "root_dir = './data'\n",
    "torchvision.datasets.MNIST(root=root_dir,download=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8d6193ee",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-28T08:40:14.069721Z",
     "iopub.status.busy": "2025-02-28T08:40:14.069444Z",
     "iopub.status.idle": "2025-02-28T08:40:14.075463Z",
     "shell.execute_reply": "2025-02-28T08:40:14.074656Z"
    },
    "id": "CwfbcGAeRY0B",
    "papermill": {
     "duration": 0.016276,
     "end_time": "2025-02-28T08:40:14.076643",
     "exception": false,
     "start_time": "2025-02-28T08:40:14.060367",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "from torch.utils.data import DataLoader, Subset\n",
    "import random\n",
    "\n",
    "def load_mnist_data(batch_size=64, sample_percent=1):\n",
    "    \"\"\"\n",
    "    📦 **Load and preprocess the MNIST dataset.**\n",
    "    📜 **Returns:** train_loader and test_loader 🎯\n",
    "    \"\"\"\n",
    "    transform = transforms.Compose([\n",
    "        transforms.ToTensor(),  # 🔄 Convert images to tensors 📊\n",
    "        transforms.Normalize((0.1307,), (0.3081,))  # ⚖️ Normalize with mean and std for MNIST dataset\n",
    "    ])\n",
    "\n",
    "    # 🛠️ **TODO: Load MNIST training and test datasets** 🖼️\n",
    "    # 📌 Hint: Use `torchvision.datasets.MNIST` for dataset loading 📥\n",
    "    #          Use `torch.utils.data.DataLoader` for creating data loaders 🔄\n",
    "\n",
    "    train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n",
    "    test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n",
    "\n",
    "\n",
    "    num_train = len(train_dataset)\n",
    "    indices = list(range(num_train))\n",
    "    split = int(sample_percent * num_train)\n",
    "    random.shuffle(indices)\n",
    "\n",
    "    train_indices = indices[:split]\n",
    "    train_subset = Subset(train_dataset, train_indices)\n",
    "\n",
    "    train_loader = DataLoader(train_subset, batch_size=batch_size, shuffle=True)\n",
    "    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "    return train_loader, test_loader  # 🚚 Return the loaders 📦\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ee51776",
   "metadata": {
    "id": "eEKhzgBHTa8n",
    "papermill": {
     "duration": 0.008124,
     "end_time": "2025-02-28T08:40:14.093269",
     "exception": false,
     "start_time": "2025-02-28T08:40:14.085145",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 🎯 **Understanding Dropout in Deep Learning** 🚀  \n",
    "\n",
    "**Dropout** is a regularization technique 🛡️ used to prevent **overfitting** in deep neural networks by randomly ignoring or **\"dropping out\"** some layer outputs during training.  \n",
    "\n",
    "### 🔍 **Where is Dropout Applied?**  \n",
    "Dropout can be implemented in different types of layers:  \n",
    "- 💡 **Dense (Fully Connected) Layers**  \n",
    "- 🌀 **Convolutional Layers**  \n",
    "- 🔁 **Recurrent Layers**  \n",
    "> 🚫 It is **NOT applied** to the output layer!  \n",
    "\n",
    "### 🎲 **How Dropout Works**  \n",
    "The **dropout probability** 🔢 determines how likely it is for a neuron to be dropped out:  \n",
    "- 🔹 **Input Layer:** Lower dropout probability  \n",
    "- 🔹 **Hidden Layers:** Higher dropout probability  \n",
    "\n",
    "By doing so, we ensure that no single neuron becomes **too specialized** or overly dependent on specific features in the training data. This helps the network generalize better to new, unseen data. 🎯✨  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bc94533a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-28T08:40:14.110515Z",
     "iopub.status.busy": "2025-02-28T08:40:14.110283Z",
     "iopub.status.idle": "2025-02-28T08:40:14.114849Z",
     "shell.execute_reply": "2025-02-28T08:40:14.114029Z"
    },
    "id": "lzh30yJGRcW0",
    "papermill": {
     "duration": 0.014602,
     "end_time": "2025-02-28T08:40:14.116141",
     "exception": false,
     "start_time": "2025-02-28T08:40:14.101539",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 🚀 **Part 2: Custom Dropout Implementation**\n",
    "\n",
    "class CustomDropout(nn.Module):\n",
    "    \"\"\"\n",
    "    🛠️ TODO: Implement custom dropout layer 🎯\n",
    "\n",
    "    📜 **Requirements:**\n",
    "    1️⃣ Initialize with **dropout probability** `p` 🎲\n",
    "    2️⃣ Implement **forward pass** with proper scaling 🔄\n",
    "    3️⃣ **Only drop** units during **training** (`self.training` flag) 🏋️‍♂️\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, p=0.5,is_input_layer=False):\n",
    "        super(CustomDropout, self).__init__()\n",
    "        # 🎲 Store dropout probability (p between 0 and 1)\n",
    "        self.p = p*0.4 if is_input_layer else p\n",
    "        self.is_input_layer = is_input_layer  # 🚧 Initialization complete! Time to implement the logic 🛠️\n",
    "\n",
    "    def forward(self, x):\n",
    "        # 🔄 **TODO: Implement forward pass**\n",
    "        if self.training: # 🏋️‍♂️ Drop units only during training mode\n",
    "            mask=torch.bernoulli(torch.ones_like(x)*(1-self.p))  # 🚧 Work in progress! Apply dropout logic 🧪\n",
    "            return x*mask/(1-self.p)\n",
    "        return x  # 🔄 Return the (possibly dropped) output ✨\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac2fcfe4",
   "metadata": {
    "id": "ZlosZCG9UdJW",
    "papermill": {
     "duration": 0.008189,
     "end_time": "2025-02-28T08:40:14.132893",
     "exception": false,
     "start_time": "2025-02-28T08:40:14.124704",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 🔄 **What is BatchNorm2d?** 🧪  \n",
    "\n",
    "**BatchNorm2d** (Batch Normalization for 2D inputs) is a layer used in deep learning to **normalize** the inputs across a batch during training. It helps your neural network train faster and generalize better! 🚀  \n",
    "\n",
    "### 🌟 **Why Use BatchNorm2d?**  \n",
    "- ⚖️ **Normalizes activations** to reduce internal covariate shift  \n",
    "- 🚀 **Accelerates training**  \n",
    "- 🛡️ **Acts as a regularizer**, reducing the need for dropout  \n",
    "\n",
    "---\n",
    "\n",
    "### 🏗️ **How It Works:**  \n",
    "1️⃣ **Compute the Mean & Variance** 📊 for each feature map across the batch  \n",
    "2️⃣ **Normalize the activations**: Subtract the mean and divide by the standard deviation ⚙️  \n",
    "3️⃣ **Learnable Parameters** 📈: Scale (γ) and Shift (β) to allow flexibility  \n",
    "   \\- **γ (Gamma)** controls the scale 📏  \n",
    "   \\- **β (Beta)** controls the shift ↕️  \n",
    "\n",
    "---\n",
    "\n",
    "### 🖼️ **Where is BatchNorm2d Used?**  \n",
    "- 📦 **Convolutional Neural Networks (CNNs)** after convolution layers  \n",
    "- 🛠️ Helps stabilize training and improve accuracy 🎯  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b25a61aa",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-28T08:40:14.150744Z",
     "iopub.status.busy": "2025-02-28T08:40:14.150471Z",
     "iopub.status.idle": "2025-02-28T08:40:14.157231Z",
     "shell.execute_reply": "2025-02-28T08:40:14.156586Z"
    },
    "id": "7EY35E-ARfwn",
    "papermill": {
     "duration": 0.016791,
     "end_time": "2025-02-28T08:40:14.158300",
     "exception": false,
     "start_time": "2025-02-28T08:40:14.141509",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 🚀 **Part 3: Custom BatchNorm2d Implementation**\n",
    "\n",
    "class CustomBatchNorm2d(nn.Module):\n",
    "    \"\"\"\n",
    "    🛠️ TODO: Implement custom 2D batch normalization 🔄\n",
    "\n",
    "    📜 **Requirements:**\n",
    "    1️⃣ Initialize **running mean**, **variance**, **gamma (scale)**, and **beta (shift)** ⚖️\n",
    "    2️⃣ Implement **forward pass** with proper normalization ✨\n",
    "    3️⃣ Track **running statistics** during training 📊\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, num_features, eps=1e-5, momentum=0.1):\n",
    "        super(CustomBatchNorm2d, self).__init__()\n",
    "        # 🛠️ **TODO: Initialize parameters and buffers**\n",
    "        self.num_features=num_features  # 🚧 Work in progress 🚀\n",
    "        self.eps=eps\n",
    "        self.momentum=momentum\n",
    "        self.gamma = nn.Parameter(torch.ones(num_features))\n",
    "        self.beta = nn.Parameter(torch.zeros(num_features))\n",
    "        self.register_buffer('running_mean', torch.zeros(num_features))\n",
    "        self.register_buffer('running_var', torch.ones(num_features))\n",
    "        \n",
    "\n",
    "    def forward(self, x):\n",
    "        # 🔄 **TODO: Implement forward pass for batch normalization**\n",
    "        # Steps:\n",
    "        if self.training:\n",
    "            # 1️⃣ Calculate batch mean and variance 📊\n",
    "            batch_mean = x.mean(dim=(0, 2, 3), keepdim=True)\n",
    "            batch_var = x.var(dim=(0, 2, 3), keepdim=True,unbiased=False)\n",
    "            # 4️⃣ Update running statistics during training 🏋️‍♂️\n",
    "            self.running_mean = (1 - self.momentum) * self.running_mean + self.momentum * batch_mean.squeeze()\n",
    "            self.running_var = (1 - self.momentum) * self.running_var + self.momentum * batch_var.squeeze()\n",
    "        else:\n",
    "            batch_mean = self.running_mean.view(1, self.num_features, 1, 1)\n",
    "            batch_var = self.running_var.view(1, self.num_features, 1, 1)\n",
    "        # 2️⃣ Normalize the input 🎯\n",
    "        out=(x-batch_mean)/torch.sqrt(batch_var+self.eps)\n",
    "        out*=self.gamma.view(1,self.num_features,1,1)\n",
    "        out+=self.beta.view(1,self.num_features,1,1)\n",
    "        return out # 🚧 Normalize and return the output 🧪\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f76459b",
   "metadata": {
    "id": "cvXwM-45VOrF",
    "papermill": {
     "duration": 0.008021,
     "end_time": "2025-02-28T08:40:14.174733",
     "exception": false,
     "start_time": "2025-02-28T08:40:14.166712",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## ⚡ **What are Activation Functions?** 🔑  \n",
    "\n",
    "**Activation functions** introduce **non-linearity** into neural networks, allowing them to learn and solve **complex tasks**. Without them, the network would only be able to learn **linear relationships** (which isn’t very useful for most problems 😅).  \n",
    "\n",
    "---\n",
    "\n",
    "### 🌟 **Why are Activation Functions Important?**  \n",
    "- 🔄 **Adds non-linearity** to the model  \n",
    "- 🚀 **Enables learning of complex patterns**  \n",
    "- 🛠️ Helps the network make decisions, just like neurons in the brain 🧠  \n",
    "\n",
    "---\n",
    "\n",
    "### 📚 **Common Activation Functions**  \n",
    "\n",
    "#### 1️⃣ **ReLU (Rectified Linear Unit)** ⚡  \n",
    "- **Formula:** `f(x) = max(0, x)`  \n",
    "- **Use:** Most common in hidden layers of CNNs and DNNs  \n",
    "- **Pros:** Simple, fast, reduces vanishing gradient problem  \n",
    "- **Cons:** Can suffer from the **dying ReLU** problem 😵  \n",
    "\n",
    "---\n",
    "\n",
    "#### 2️⃣ **Sigmoid (Logistic Function)** 📈  \n",
    "- **Formula:** `f(x) = 1 / (1 + exp(-x))`  \n",
    "- **Range:** (0, 1)  \n",
    "- **Use:** Good for binary classification tasks 🔢  \n",
    "- **Cons:** Can cause **vanishing gradients** 😬  \n",
    "\n",
    "---\n",
    "\n",
    "#### 3️⃣ **Tanh (Hyperbolic Tangent)** 🔄  \n",
    "- **Formula:** `f(x) = (2 / (1 + exp(-2x))) - 1`  \n",
    "- **Range:** (-1, 1)  \n",
    "- **Use:** Often used in recurrent networks 🔁  \n",
    "- **Pros:** Centered around 0, making optimization easier  \n",
    "- **Cons:** Also prone to vanishing gradients  \n",
    "\n",
    "---\n",
    "\n",
    "#### 4️⃣ **Softmax** 🎯  \n",
    "- **Formula:** Converts logits into probabilities 🔢  \n",
    "- **Range:** (0, 1), sums to 1  \n",
    "- **Use:** Last layer for multi-class classification problems  \n",
    "\n",
    "---\n",
    "\n",
    "### 🎯 **How to Choose an Activation Function?**  \n",
    "- For **hidden layers**, use **ReLU** or its variants (like Leaky ReLU or ELU)  \n",
    "- For **binary classification**, use **Sigmoid**  \n",
    "- For **multi-class classification**, use **Softmax**  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c44d35be",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-28T08:40:14.192022Z",
     "iopub.status.busy": "2025-02-28T08:40:14.191824Z",
     "iopub.status.idle": "2025-02-28T08:40:14.195179Z",
     "shell.execute_reply": "2025-02-28T08:40:14.194556Z"
    },
    "id": "Kxs-RWzbhYB9",
    "papermill": {
     "duration": 0.013174,
     "end_time": "2025-02-28T08:40:14.196258",
     "exception": false,
     "start_time": "2025-02-28T08:40:14.183084",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class CustomReLU(nn.Module):\n",
    "    \"\"\"\n",
    "    🛠️ TODO: Implement custom ReLU activation function ✨\n",
    "\n",
    "    📜 **Requirements:**\n",
    "    1️⃣ Apply ReLU manually using tensor operations (avoid using `F.relu`) 🔄\n",
    "    2️⃣ Output should replace all negative values with 0 (ReLU behavior) 🧹\n",
    "    \"\"\"\n",
    "\n",
    "    def forward(self, x):\n",
    "        # 🔄 **TODO: Implement forward pass for ReLU**\n",
    "        # Hint: Use `torch.max` to replace all negative values with 0 🎯\n",
    "        return torch.max(x, torch.zeros_like(x))\n",
    "        # 🚧 Replace and return the ReLU-activated output ⚡\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "64ce9af6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-28T08:40:14.213359Z",
     "iopub.status.busy": "2025-02-28T08:40:14.213156Z",
     "iopub.status.idle": "2025-02-28T08:40:14.218975Z",
     "shell.execute_reply": "2025-02-28T08:40:14.218361Z"
    },
    "id": "6LOf8k6ohaLf",
    "papermill": {
     "duration": 0.01557,
     "end_time": "2025-02-28T08:40:14.220129",
     "exception": false,
     "start_time": "2025-02-28T08:40:14.204559",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class CustomMaxPooling2d(nn.Module):\n",
    "    \"\"\"\n",
    "    🛠️ TODO: Implement custom 2D MaxPooling layer 🏊\n",
    "\n",
    "    📜 **Requirements:**\n",
    "    1️⃣ Implement a max-pooling operation with a given kernel size and stride 📐\n",
    "    2️⃣ Return the maximum value in each pooling window 🌊\n",
    "    3️⃣ Ensure it supports both training and evaluation modes 🔄\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, kernel_size=2, stride=2):\n",
    "        super(CustomMaxPooling2d, self).__init__()\n",
    "        self.kernel_size = kernel_size\n",
    "        self.stride = stride\n",
    "\n",
    "    def forward(self, x):\n",
    "        batch_size, channels, height, width = x.size()\n",
    "        x_unfolded = x.unfold(2, self.kernel_size, self.stride).unfold(3, self.kernel_size, self.stride)\n",
    "\n",
    "        # Reshape to combine batch and channel dimensions\n",
    "        x_unfolded = x_unfolded.contiguous().view(x.size(0), x.size(1), -1, self.kernel_size * self.kernel_size)\n",
    "        \n",
    "        # Compute max for each window\n",
    "        x_pooled, _ = x_unfolded.max(dim=-1)\n",
    "        x_pooled=x_pooled.view(batch_size,channels,height // self.stride,width//self.stride)\n",
    "        \n",
    "        \n",
    "        return x_pooled\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f2aa94b",
   "metadata": {
    "id": "Y5eNoFsCo5L_",
    "papermill": {
     "duration": 0.00811,
     "end_time": "2025-02-28T08:40:14.236680",
     "exception": false,
     "start_time": "2025-02-28T08:40:14.228570",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### 🔍 **Hint for MaxPooling with `unfold`**  \n",
    "`torch.nn.functional.unfold` is a powerful tool that helps break an input tensor into sliding windows. Here's how you can use it to implement max pooling:  \n",
    "\n",
    "1️⃣ **Unfold the input tensor:** This will give you a collection of overlapping windows based on the `kernel_size` and `stride`.  \n",
    "```python\n",
    "# Unfold the input tensor into sliding windows\n",
    "x_unfolded = x.unfold(2, self.kernel_size, self.stride).unfold(3, self.kernel_size, self.stride)\n",
    "```\n",
    "\n",
    "2️⃣ **Reshape the unfolded tensor:** Convert it to a shape that makes it easier to compute the maximum.  \n",
    "```python\n",
    "x_unfolded = x_unfolded.contiguous().view(x.size(0), x.size(1), -1, self.kernel_size * self.kernel_size)\n",
    "```\n",
    "\n",
    "3️⃣ **Compute the max along the last dimension:** This dimension represents all elements within each window.  \n",
    "```python\n",
    "x_pooled, _ = x_unfolded.max(dim=-1)\n",
    "```\n",
    "\n",
    "4️⃣ **Reshape back to the correct output size:** This ensures that the output matches what you would expect from a typical max pooling layer.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e6893cf",
   "metadata": {
    "id": "_2DAv2wGi0U6",
    "papermill": {
     "duration": 0.0081,
     "end_time": "2025-02-28T08:40:14.253016",
     "exception": false,
     "start_time": "2025-02-28T08:40:14.244916",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## 📜 **Implement Your Own Custom VGG16 Model**\n",
    "\n",
    "1️⃣ Implement both CustomReLU and CustomMaxPooling2d in the provided classes.\n",
    "\n",
    "2️⃣ Use only tensor operations like torch.max or unfold (no built-in F.relu or nn.MaxPool2d).\n",
    "\n",
    "3️⃣ Integrate them into your CustomVGG16 model.\n",
    "\n",
    "### 🌐 **Want to Learn More?**  \n",
    "Check out the full details here: [📖 VGG16 Paper](https://arxiv.org/pdf/1409.1556)  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b721d46e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-28T08:40:14.270169Z",
     "iopub.status.busy": "2025-02-28T08:40:14.269962Z",
     "iopub.status.idle": "2025-02-28T08:40:14.276336Z",
     "shell.execute_reply": "2025-02-28T08:40:14.275694Z"
    },
    "id": "YQ1qSSQzRigE",
    "papermill": {
     "duration": 0.016084,
     "end_time": "2025-02-28T08:40:14.277376",
     "exception": false,
     "start_time": "2025-02-28T08:40:14.261292",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class CustomVGG16(nn.Module):\n",
    "    \"\"\"\n",
    "    📜 Custom VGG16-like Model with:\n",
    "    1️⃣ Convolutional blocks using nn.Conv2d, CustomBatchNorm2d, and CustomDropout 🔄\n",
    "    2️⃣ ReLU activation ⚡ and MaxPooling 🏊\n",
    "    3️⃣ Fully connected layers at the end\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, num_classes=10):  # num_classes = 10 for MNIST\n",
    "        super(CustomVGG16, self).__init__()\n",
    "        \n",
    "        # Convolutional layers\n",
    "        self.features = nn.Sequential(\n",
    "            # Block 1\n",
    "            nn.Conv2d(1, 64, kernel_size=3, padding=1),\n",
    "            CustomBatchNorm2d(64),\n",
    "            CustomReLU(),\n",
    "            nn.Conv2d(64, 64, kernel_size=3, padding=1),\n",
    "            CustomBatchNorm2d(64),\n",
    "            CustomReLU(),\n",
    "            CustomMaxPooling2d(kernel_size=2, stride=2),\n",
    "            \n",
    "            # Block 2\n",
    "            nn.Conv2d(64, 128, kernel_size=3, padding=1),\n",
    "            CustomBatchNorm2d(128),\n",
    "            CustomReLU(),\n",
    "            nn.Conv2d(128, 128, kernel_size=3, padding=1),\n",
    "            CustomBatchNorm2d(128),\n",
    "            CustomReLU(),\n",
    "            CustomMaxPooling2d(kernel_size=2, stride=2),\n",
    "            \n",
    "            # Block 3\n",
    "            nn.Conv2d(128, 256, kernel_size=3, padding=1),\n",
    "            CustomBatchNorm2d(256),\n",
    "            CustomReLU(),\n",
    "            nn.Conv2d(256, 256, kernel_size=3, padding=1),\n",
    "            CustomBatchNorm2d(256),\n",
    "            CustomReLU(),\n",
    "            nn.Conv2d(256, 256, kernel_size=3, padding=1),\n",
    "            CustomBatchNorm2d(256),\n",
    "            CustomReLU(),\n",
    "            CustomMaxPooling2d(kernel_size=2, stride=2)\n",
    "        )\n",
    "        \n",
    "        # Fully connected layers\n",
    "        self.classifier = nn.Sequential(\n",
    "            nn.Flatten(),\n",
    "            CustomDropout(p=0.5,is_input_layer=True),\n",
    "            nn.Linear(256 * 3 * 3, 4096),\n",
    "            CustomReLU(),\n",
    "            CustomDropout(p=0.5),\n",
    "            nn.Linear(4096, 4096),\n",
    "            CustomReLU(),\n",
    "            CustomDropout(p=0.5),\n",
    "            nn.Linear(4096, num_classes),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.features(x)\n",
    "        x = self.classifier(x)\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6063d408",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-28T08:40:14.294505Z",
     "iopub.status.busy": "2025-02-28T08:40:14.294309Z",
     "iopub.status.idle": "2025-02-28T08:40:14.300785Z",
     "shell.execute_reply": "2025-02-28T08:40:14.300161Z"
    },
    "id": "vB-u6IalRk4q",
    "papermill": {
     "duration": 0.016172,
     "end_time": "2025-02-28T08:40:14.301885",
     "exception": false,
     "start_time": "2025-02-28T08:40:14.285713",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "def train_epoch(model, train_loader, criterion, optimizer, device):\n",
    "    \"\"\"\n",
    "    🛠️ Implements training loop for one epoch 🏋️‍♂️\n",
    "    \"\"\"\n",
    "    model.train()  # 📈 Switch to training mode\n",
    "    running_loss = 0.0  # 💰 Track the cumulative loss\n",
    "    correct = 0  # ✅ Correct predictions counter\n",
    "    total = 0  # 📊 Total samples counter\n",
    "\n",
    "    for batch_idx, (data, target) in enumerate(train_loader):  # 🔄 Loop through batches\n",
    "        data, target = data.to(device), target.to(device)\n",
    "        \n",
    "        optimizer.zero_grad()  # Reset gradients\n",
    "        \n",
    "        output = model(data)  # Forward pass\n",
    "        loss = criterion(output, target)  # Calculate loss\n",
    "        \n",
    "        loss.backward()  # Backward pass\n",
    "        optimizer.step()  # Update weights\n",
    "        \n",
    "        running_loss += loss.item()\n",
    "        \n",
    "        _, predicted = output.max(1)  # Get the index of the max log-probability\n",
    "        total += target.size(0)\n",
    "        correct += predicted.eq(target).sum().item()\n",
    "\n",
    "    # 📊 Return average loss and accuracy for the epoch\n",
    "    return running_loss / len(train_loader), 100. * correct / total\n",
    "\n",
    "def evaluate(model, test_loader, criterion, device):\n",
    "    \"\"\"\n",
    "    🧪 Implements evaluation loop 🔍\n",
    "    \"\"\"\n",
    "    model.eval()  # 🔕 Switch to evaluation mode (no gradients)\n",
    "    test_loss = 0  # 💰 Track cumulative test loss\n",
    "    correct = 0  # ✅ Correct predictions counter\n",
    "    total = 0  # 📊 Total samples counter\n",
    "\n",
    "    with torch.no_grad():  # 🚫 No gradient calculation for evaluation\n",
    "        for data, target in test_loader:\n",
    "            data, target = data.to(device), target.to(device)\n",
    "            \n",
    "            output = model(data)  # Forward pass\n",
    "            test_loss += criterion(output, target).item()  # Sum up batch loss\n",
    "            \n",
    "            _, predicted = output.max(1)  # Get the index of the max log-probability\n",
    "            total += target.size(0)\n",
    "            correct += predicted.eq(target).sum().item()\n",
    "\n",
    "    # 📊 Return average test loss and accuracy\n",
    "    return test_loss / len(test_loader), 100. * correct / total\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "93fc88f7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-28T08:40:14.319094Z",
     "iopub.status.busy": "2025-02-28T08:40:14.318875Z",
     "iopub.status.idle": "2025-02-28T08:48:08.191586Z",
     "shell.execute_reply": "2025-02-28T08:48:08.190581Z"
    },
    "id": "r9Tnydj-RpO5",
    "papermill": {
     "duration": 473.883078,
     "end_time": "2025-02-28T08:48:08.193225",
     "exception": false,
     "start_time": "2025-02-28T08:40:14.310147",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/dist-packages/torch/optim/lr_scheduler.py:62: UserWarning: The verbose parameter is deprecated. Please use get_last_lr() to access the learning rate.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "🌟 Epoch 1/10\n",
      "Epoch 1/10, Train Loss: 0.2305, Train Acc: 93.20%, Test Loss: 0.0544, Test Acc: 98.55%\n",
      "🌟 Epoch 2/10\n",
      "Epoch 2/10, Train Loss: 0.0792, Train Acc: 97.95%, Test Loss: 0.0359, Test Acc: 98.97%\n",
      "🌟 Epoch 3/10\n",
      "Epoch 3/10, Train Loss: 0.0593, Train Acc: 98.47%, Test Loss: 0.0429, Test Acc: 98.93%\n",
      "🌟 Epoch 4/10\n",
      "Epoch 4/10, Train Loss: 0.0546, Train Acc: 98.65%, Test Loss: 0.0328, Test Acc: 99.12%\n",
      "🌟 Epoch 5/10\n",
      "Epoch 5/10, Train Loss: 0.0415, Train Acc: 98.90%, Test Loss: 0.0324, Test Acc: 99.23%\n",
      "🌟 Epoch 6/10\n",
      "Epoch 6/10, Train Loss: 0.0406, Train Acc: 98.94%, Test Loss: 0.0311, Test Acc: 99.28%\n",
      "🌟 Epoch 7/10\n",
      "Epoch 7/10, Train Loss: 0.0330, Train Acc: 99.17%, Test Loss: 0.0274, Test Acc: 99.33%\n",
      "🌟 Epoch 8/10\n",
      "Epoch 8/10, Train Loss: 0.0308, Train Acc: 99.27%, Test Loss: 0.0298, Test Acc: 99.28%\n",
      "🌟 Epoch 9/10\n",
      "Epoch 9/10, Train Loss: 0.0306, Train Acc: 99.25%, Test Loss: 0.0378, Test Acc: 99.02%\n",
      "🌟 Epoch 10/10\n",
      "Epoch 10/10, Train Loss: 0.0272, Train Acc: 99.34%, Test Loss: 0.0283, Test Acc: 99.30%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch.optim.lr_scheduler as lr_scheduler\n",
    "\n",
    "def main():\n",
    "    # ⚙️ **Hyperparameters**\n",
    "    BATCH_SIZE = 64  # 📦 Batch size for data loading\n",
    "    EPOCHS = 10  # 🔄 Number of training epochs\n",
    "    LEARNING_RATE = 0.001  # 🚀 Learning rate for optimizer\n",
    "    DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # ⚡ Use GPU if available\n",
    "\n",
    "    # 📊 **Load data**\n",
    "    train_loader, test_loader = load_mnist_data(BATCH_SIZE)\n",
    "\n",
    "    # 🛠️ **Initialize model, criterion, optimizer**\n",
    "    model = CustomVGG16().to(DEVICE)  # 🖥️ Move model to the selected device\n",
    "    criterion = nn.CrossEntropyLoss()  # 🎯 Loss function for classification\n",
    "    optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)  # 🚀 Adam optimizer for better convergence\n",
    "    scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=3, verbose=True)\n",
    "\n",
    "    # 🔄 **Training loop**\n",
    "    train_losses = []  # 📉 Track training losses\n",
    "    test_losses = []  # 📉 Track test losses\n",
    "    train_accs = []  # 📊 Track training accuracy\n",
    "    test_accs = []  # 📊 Track test accuracy\n",
    "\n",
    "    for epoch in range(EPOCHS):\n",
    "        # 🏋️♂️ **TODO: Implement main training loop**\n",
    "        print(f\"🌟 Epoch {epoch+1}/{EPOCHS}\")  # 🕒 Display current epoch\n",
    "        # Example Steps:\n",
    "        # 1️⃣ Train for one epoch\n",
    "        train_loss, train_acc = train_epoch(model, train_loader, criterion, optimizer, DEVICE)\n",
    "       \n",
    "        # 2️⃣ Evaluate on test set\n",
    "        test_loss, test_acc = evaluate(model, test_loader, criterion, DEVICE)\n",
    "        scheduler.step(test_loss)\n",
    "        # 3️⃣ Record losses and accuracies\n",
    "        train_losses.append(train_loss)\n",
    "        test_losses.append(test_loss)\n",
    "        train_accs.append(train_acc)\n",
    "        test_accs.append(test_acc)\n",
    "\n",
    "        # 4️⃣ Print progress 💬\n",
    "        print(f\"Epoch {epoch+1}/{EPOCHS}, Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.2f}%, Test Loss: {test_loss:.4f}, Test Acc: {test_acc:.2f}%\")\n",
    "\n",
    "    # 📈 **Plot results**\n",
    "    plt.figure(figsize=(12, 5))\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(train_losses, label='Train Loss')\n",
    "    plt.plot(test_losses, label='Test Loss')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.title('Training and Test Loss')\n",
    "    plt.legend()\n",
    "\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.plot(train_accs, label='Train Accuracy')\n",
    "    plt.plot(test_accs, label='Test Accuracy')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Accuracy (%)')\n",
    "    plt.title('Training and Test Accuracy')\n",
    "    plt.legend()\n",
    "\n",
    "    plt.show()  # 🎨 Generate and display plots 📊\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81edbf16",
   "metadata": {
    "papermill": {
     "duration": 0.009829,
     "end_time": "2025-02-28T08:48:08.213868",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.204039",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "924f9a0b",
   "metadata": {
    "papermill": {
     "duration": 0.009775,
     "end_time": "2025-02-28T08:48:08.233514",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.223739",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e9ec595",
   "metadata": {
    "papermill": {
     "duration": 0.009897,
     "end_time": "2025-02-28T08:48:08.253346",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.243449",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a1ee51e",
   "metadata": {
    "papermill": {
     "duration": 0.009779,
     "end_time": "2025-02-28T08:48:08.272955",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.263176",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ecbdd4d",
   "metadata": {
    "papermill": {
     "duration": 0.00986,
     "end_time": "2025-02-28T08:48:08.292714",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.282854",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0814f73",
   "metadata": {
    "papermill": {
     "duration": 0.009738,
     "end_time": "2025-02-28T08:48:08.312444",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.302706",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55f87421",
   "metadata": {
    "papermill": {
     "duration": 0.009753,
     "end_time": "2025-02-28T08:48:08.332224",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.322471",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d11970e",
   "metadata": {
    "papermill": {
     "duration": 0.009764,
     "end_time": "2025-02-28T08:48:08.352094",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.342330",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3d0c5b2",
   "metadata": {
    "papermill": {
     "duration": 0.009719,
     "end_time": "2025-02-28T08:48:08.371680",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.361961",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "397009ad",
   "metadata": {
    "papermill": {
     "duration": 0.011326,
     "end_time": "2025-02-28T08:48:08.392876",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.381550",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8a23744",
   "metadata": {
    "papermill": {
     "duration": 0.009767,
     "end_time": "2025-02-28T08:48:08.414102",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.404335",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d187b9b",
   "metadata": {
    "papermill": {
     "duration": 0.009865,
     "end_time": "2025-02-28T08:48:08.433925",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.424060",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81594429",
   "metadata": {
    "papermill": {
     "duration": 0.009862,
     "end_time": "2025-02-28T08:48:08.453750",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.443888",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac21ad22",
   "metadata": {
    "papermill": {
     "duration": 0.009643,
     "end_time": "2025-02-28T08:48:08.473311",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.463668",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aab7d346",
   "metadata": {
    "papermill": {
     "duration": 0.009602,
     "end_time": "2025-02-28T08:48:08.492641",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.483039",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ba7c5ef",
   "metadata": {
    "papermill": {
     "duration": 0.009675,
     "end_time": "2025-02-28T08:48:08.512384",
     "exception": false,
     "start_time": "2025-02-28T08:48:08.502709",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kaggle": {
   "accelerator": "nvidiaTeslaT4",
   "dataSources": [],
   "dockerImageVersionId": 30919,
   "isGpuEnabled": true,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "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.12"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 505.496627,
   "end_time": "2025-02-28T08:48:10.143715",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2025-02-28T08:39:44.647088",
   "version": "2.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}