q2solution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem Statement: \n",
    "For given text sequence, can we predict the for which subject i.e Chemistry, Maths, Biology, or Physics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Importing important library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch.nn.functional as F\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Preparation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Define a custom dataset\n",
    "class TextDataset(Dataset):\n",
    "    def __init__(self, texts, labels, vocab, max_seq_len):\n",
    "        self.texts = texts\n",
    "        self.labels = labels\n",
    "        self.vocab = vocab\n",
    "        self.max_seq_len = max_seq_len\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.texts)\n",
    "        \n",
    "    def __getitem__(self, idx):\n",
    "        text = self.texts[idx]\n",
    "        label = self.labels[idx]\n",
    "        # Tokenize and convert to indices\n",
    "        tokens = text.split()\n",
    "        indices = [self.vocab.get(token, self.vocab['<UNK>']) for token in tokens]\n",
    "        # Pad sequences\n",
    "        if len(indices) < self.max_seq_len:\n",
    "            indices = indices + [self.vocab['<PAD>']] * (self.max_seq_len - len(indices))\n",
    "        else:\n",
    "            indices = indices[:self.max_seq_len]\n",
    "        return torch.tensor(indices), torch.tensor(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "df=pd.read_csv(\"subjects-questions.csv\")\n",
    "df = df.sample(frac=1, random_state=42).reset_index(drop=True)  # Shuffle the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>eng</th>\n",
       "      <th>Subject</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4995</th>\n",
       "      <td>An electrical technician requires a\\ncapacitan...</td>\n",
       "      <td>Physics</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4996</th>\n",
       "      <td>Which is common in respiration and photosynthe...</td>\n",
       "      <td>Biology</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4997</th>\n",
       "      <td>The co-ordination number of a metal in\\nco-ord...</td>\n",
       "      <td>Chemistry</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4998</th>\n",
       "      <td>The ratio of acceleration due to gravity\\nat a...</td>\n",
       "      <td>Physics</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4999</th>\n",
       "      <td>When \\( C l_{2} \\) water is added to an aqueou...</td>\n",
       "      <td>Chemistry</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                    eng    Subject\n",
       "4995  An electrical technician requires a\\ncapacitan...    Physics\n",
       "4996  Which is common in respiration and photosynthe...    Biology\n",
       "4997  The co-ordination number of a metal in\\nco-ord...  Chemistry\n",
       "4998  The ratio of acceleration due to gravity\\nat a...    Physics\n",
       "4999  When \\( C l_{2} \\) water is added to an aqueou...  Chemistry"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Take only 5000 data \n",
    "df=df[:5000]\n",
    "df.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Physics', 'Chemistry', 'Maths', 'Biology'], dtype=object)"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### Number of different Subjects\n",
    "df[\"Subject\"].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build vocabulary for text\n",
    "max_len=0\n",
    "vocab = {'<PAD>': 0, '<UNK>': 1}\n",
    "for text in df['eng']:\n",
    "    for token in text.split():\n",
    "        token=token.lower()\n",
    "        if token not in vocab:\n",
    "            vocab[token] = len(vocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Encode labels\n",
    "labels=list(df[\"Subject\"])\n",
    "label_encoder = LabelEncoder()\n",
    "labels = label_encoder.fit_transform(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split data into training and validation sets ( 70 % train, 30% validation set)\n",
    "texts=list(df[\"eng\"])\n",
    "texts_train, texts_val, labels_train, labels_val = train_test_split(texts, labels, test_size=0.3, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Physics',\n",
       " 'Chemistry',\n",
       " 'Chemistry',\n",
       " 'Maths',\n",
       " 'Biology',\n",
       " 'Physics',\n",
       " 'Maths',\n",
       " 'Maths',\n",
       " 'Chemistry',\n",
       " 'Maths']"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels=list(df[\"Subject\"])[0:10]\n",
    "labels[0:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 1, 1, 2, 0, 3, 2, 2, 1, 2])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels[0:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multi-head Self Attention Layer Model( Transformer Encoder Layer with Fully Connected Layer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/faiyazahmad/anaconda3/envs/deep_learning/lib/python3.12/site-packages/torch/nn/modules/transformer.py:306: UserWarning: enable_nested_tensor is True, but self.use_nested_tensor is False because encoder_layer.self_attn.batch_first was not True(use batch_first for better inference performance)\n",
      "  warnings.warn(f\"enable_nested_tensor is True, but self.use_nested_tensor is False because {why_not_sparsity_fast_path}\")\n"
     ]
    }
   ],
   "source": [
    "class PositionalEncoding(nn.Module):\n",
    "    def __init__(self, max_seq_len, d_model):\n",
    "        super(PositionalEncoding, self).__init__()\n",
    "        self.positional_encoding = nn.Parameter(torch.randn(max_seq_len, d_model))\n",
    "    def forward(self, x):\n",
    "        seq_len = x.size(1)\n",
    "        return x + self.positional_encoding[:seq_len, :]\n",
    "\n",
    "class Transformer(nn.Module):\n",
    "    def __init__(self, vocab_size, d_model, num_heads, num_layers, max_seq_len, num_classes, dropout=0.1):\n",
    "        super(Transformer, self).__init__()\n",
    "        self.embedding = nn.Embedding(vocab_size, d_model)\n",
    "        self.positional_encoding = PositionalEncoding(max_seq_len, d_model)\n",
    "        self.encoder_layer = nn.TransformerEncoderLayer(d_model, num_heads)\n",
    "        self.transformer_encoder = nn.TransformerEncoder(self.encoder_layer, num_layers)\n",
    "        self.fc1=nn.Linear(d_model,256)\n",
    "        self.fc2=nn.Linear(256,128)\n",
    "        self.fc3 = nn.Linear(128,num_classes)\n",
    "        self.layer_norm = nn.LayerNorm(d_model)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.embedding(x)\n",
    "        #x = self.layer_norm(x)\n",
    "        x = self.positional_encoding(x)\n",
    "        x = self.transformer_encoder(x)\n",
    "        x = x.mean(dim=1)\n",
    "        x = self.fc1(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "# Hyperparameters\n",
    "vocab_size = len(vocab)\n",
    "d_model = 64\n",
    "num_heads = 8\n",
    "num_layers = 2\n",
    "max_seq_len = 128\n",
    "num_classes = len(label_encoder.classes_)\n",
    "batch_size = 32\n",
    "num_epochs = 30\n",
    "learning_rate = 1e-4\n",
    "\n",
    "# Create datasets and dataloaders\n",
    "train_dataset = TextDataset(texts_train, labels_train, vocab, max_seq_len)\n",
    "val_dataset = TextDataset(texts_val, labels_val, vocab, max_seq_len)\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "# Create the model\n",
    "model = Transformer(vocab_size, d_model, num_heads, num_layers, max_seq_len, num_classes)\n",
    "optimizer = optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Transformer(\n",
       "  (embedding): Embedding(23311, 64)\n",
       "  (positional_encoding): PositionalEncoding()\n",
       "  (encoder_layer): TransformerEncoderLayer(\n",
       "    (self_attn): MultiheadAttention(\n",
       "      (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
       "    )\n",
       "    (linear1): Linear(in_features=64, out_features=2048, bias=True)\n",
       "    (dropout): Dropout(p=0.1, inplace=False)\n",
       "    (linear2): Linear(in_features=2048, out_features=64, bias=True)\n",
       "    (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
       "    (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
       "    (dropout1): Dropout(p=0.1, inplace=False)\n",
       "    (dropout2): Dropout(p=0.1, inplace=False)\n",
       "  )\n",
       "  (transformer_encoder): TransformerEncoder(\n",
       "    (layers): ModuleList(\n",
       "      (0-1): 2 x TransformerEncoderLayer(\n",
       "        (self_attn): MultiheadAttention(\n",
       "          (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
       "        )\n",
       "        (linear1): Linear(in_features=64, out_features=2048, bias=True)\n",
       "        (dropout): Dropout(p=0.1, inplace=False)\n",
       "        (linear2): Linear(in_features=2048, out_features=64, bias=True)\n",
       "        (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
       "        (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
       "        (dropout1): Dropout(p=0.1, inplace=False)\n",
       "        (dropout2): Dropout(p=0.1, inplace=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (fc1): Linear(in_features=64, out_features=256, bias=True)\n",
       "  (fc2): Linear(in_features=256, out_features=128, bias=True)\n",
       "  (fc3): Linear(in_features=128, out_features=4, bias=True)\n",
       "  (layer_norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
       ")"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Model Architecture details\n",
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:23<00:00,  4.72it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/30], Loss: 1.3285\n",
      "Validation Loss: 1.2967, Validation Accuracy: 38.27%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:23<00:00,  4.77it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [2/30], Loss: 1.2960\n",
      "Validation Loss: 1.2601, Validation Accuracy: 40.07%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:23<00:00,  4.78it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [3/30], Loss: 1.2627\n",
      "Validation Loss: 1.2433, Validation Accuracy: 46.47%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.85it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [4/30], Loss: 1.2399\n",
      "Validation Loss: 1.2027, Validation Accuracy: 47.73%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.79it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [5/30], Loss: 1.2118\n",
      "Validation Loss: 1.1834, Validation Accuracy: 42.27%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.81it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [6/30], Loss: 1.1668\n",
      "Validation Loss: 1.1229, Validation Accuracy: 50.73%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:23<00:00,  4.77it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [7/30], Loss: 1.1013\n",
      "Validation Loss: 1.0554, Validation Accuracy: 55.93%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:23<00:00,  4.77it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [8/30], Loss: 1.0636\n",
      "Validation Loss: 1.0274, Validation Accuracy: 56.07%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:23<00:00,  4.73it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [9/30], Loss: 1.0253\n",
      "Validation Loss: 1.0006, Validation Accuracy: 56.27%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.78it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [10/30], Loss: 0.9928\n",
      "Validation Loss: 1.0434, Validation Accuracy: 52.33%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:23<00:00,  4.76it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [11/30], Loss: 0.9688\n",
      "Validation Loss: 0.9640, Validation Accuracy: 59.13%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.79it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [12/30], Loss: 0.9487\n",
      "Validation Loss: 0.9604, Validation Accuracy: 58.67%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.79it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [13/30], Loss: 0.9177\n",
      "Validation Loss: 0.9632, Validation Accuracy: 57.60%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.82it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [14/30], Loss: 0.8947\n",
      "Validation Loss: 0.9399, Validation Accuracy: 59.27%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.82it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [15/30], Loss: 0.8689\n",
      "Validation Loss: 0.9222, Validation Accuracy: 61.27%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:23<00:00,  4.77it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [16/30], Loss: 0.8471\n",
      "Validation Loss: 0.8995, Validation Accuracy: 62.73%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.84it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [17/30], Loss: 0.8257\n",
      "Validation Loss: 0.8955, Validation Accuracy: 62.00%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:21<00:00,  5.02it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [18/30], Loss: 0.8042\n",
      "Validation Loss: 0.8903, Validation Accuracy: 63.33%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.88it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [19/30], Loss: 0.7703\n",
      "Validation Loss: 0.8940, Validation Accuracy: 64.00%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:23<00:00,  4.78it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [20/30], Loss: 0.7385\n",
      "Validation Loss: 0.8910, Validation Accuracy: 63.67%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:23<00:00,  4.78it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [21/30], Loss: 0.7353\n",
      "Validation Loss: 0.8880, Validation Accuracy: 64.27%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.79it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [22/30], Loss: 0.7001\n",
      "Validation Loss: 0.8832, Validation Accuracy: 64.73%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.82it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [23/30], Loss: 0.6824\n",
      "Validation Loss: 0.8822, Validation Accuracy: 64.80%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.81it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [24/30], Loss: 0.6642\n",
      "Validation Loss: 0.8888, Validation Accuracy: 64.80%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.81it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [25/30], Loss: 0.6449\n",
      "Validation Loss: 0.8821, Validation Accuracy: 64.67%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.82it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [26/30], Loss: 0.6293\n",
      "Validation Loss: 0.8637, Validation Accuracy: 66.67%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.79it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [27/30], Loss: 0.6050\n",
      "Validation Loss: 0.9107, Validation Accuracy: 62.87%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:22<00:00,  4.84it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [28/30], Loss: 0.5907\n",
      "Validation Loss: 0.8661, Validation Accuracy: 66.87%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:23<00:00,  4.78it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [29/30], Loss: 0.5599\n",
      "Validation Loss: 0.8579, Validation Accuracy: 66.27%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 110/110 [00:23<00:00,  4.74it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [30/30], Loss: 0.5434\n",
      "Validation Loss: 0.8715, Validation Accuracy: 66.67%\n"
     ]
    }
   ],
   "source": [
    "# Training loop\n",
    "initial_positional_encodings=model.positional_encoding.positional_encoding.detach().numpy().copy()\n",
    "training_loss=[]\n",
    "validation_loss=[]\n",
    "validation_accuracy=[]\n",
    "for epoch in range(num_epochs):\n",
    "    model.train()\n",
    "    running_loss = 0.0\n",
    "    for inputs, labels in tqdm(train_loader):\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(inputs)\n",
    "        criterion=nn.CrossEntropyLoss()\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        running_loss += loss.item()\n",
    "    training_loss.append(running_loss/len(train_loader))\n",
    "\n",
    "    print(f\"Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}\")\n",
    "\n",
    "    # Validation loop\n",
    "    model.eval()\n",
    "    val_loss = 0.0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    with torch.no_grad():\n",
    "        for inputs, labels in val_loader:\n",
    "            outputs = model(inputs)\n",
    "            loss = criterion(outputs, labels)\n",
    "            val_loss += loss.item()\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            total += labels.size(0)\n",
    "            correct += (predicted == labels).sum().item()\n",
    "    validation_loss.append(val_loss/len(val_loader))\n",
    "    validation_accuracy.append(correct / total)\n",
    "    print(f\"Validation Loss: {val_loss/len(val_loader):.4f}, Validation Accuracy: {100 * correct / total:.2f}%\")\n",
    "final_positional_encodings=model.positional_encoding.positional_encoding.detach().numpy().copy()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualizing the Training vs Validation Loss and validation accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#### Visualization of training, validation loss\n",
    "x=[i+1 for i in range(0,num_epochs)]\n",
    "# Combine data into a DataFrame\n",
    "data = pd.DataFrame({\n",
    "    'Epoch': x,\n",
    "    'Training Loss': training_loss,\n",
    "    'Validation Loss': validation_loss\n",
    "})\n",
    "\n",
    "# Melt the DataFrame to long-form\n",
    "data_melted = data.melt(id_vars=['Epoch'], value_vars=['Training Loss', 'Validation Loss'],\n",
    "                        var_name='Loss Type', value_name='Loss')\n",
    "\n",
    "# Plot using Seaborn\n",
    "plt.figure(figsize=(7,5))\n",
    "sns.lineplot(data=data_melted, x='Epoch', y='Loss', hue='Loss Type', marker='o')\n",
    "plt.title('Training and Validation Loss Over Epochs')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend(title='Loss Type')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot using Seaborn\n",
    "plt.figure(figsize=(7,5))\n",
    "sns.lineplot(x=x, y=validation_accuracy, marker='o')\n",
    "plt.title('Validation Accuracy at each epochs')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Validation Accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing the Learned Positional Encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.8292689 , -0.40304855, -0.0720434 , -0.27324596, -0.42888063,\n",
       "       -0.716838  , -0.40736347, -0.00440647,  0.32306987, -0.27632168,\n",
       "        0.10202568, -0.8778907 ,  0.18734866, -0.34482327, -1.3974146 ,\n",
       "        0.48217985,  0.02559096, -0.28000286,  0.81016624, -0.92299026,\n",
       "        0.637571  ,  2.576903  , -1.617014  ,  1.4501323 , -0.5712062 ,\n",
       "       -0.59345686,  1.9919403 ,  1.1785048 , -0.5351334 , -0.37816644,\n",
       "        0.10282379,  2.7124543 , -1.0451972 ,  0.02296072, -0.5117333 ,\n",
       "        0.02977937,  0.07319611, -0.34227696, -0.12376603,  0.9572331 ,\n",
       "       -0.00789497,  1.5787551 , -0.90378964, -1.1572462 , -1.034859  ,\n",
       "        0.03674366, -0.4013853 , -0.13048269,  0.9275683 ,  0.07714554,\n",
       "       -1.3460909 ,  1.1176661 , -0.4964064 , -1.1345931 ,  0.31628048,\n",
       "        0.65811473, -1.3285292 ,  0.26423708,  1.3275645 , -1.7610738 ,\n",
       "       -0.28284165,  0.02804404,  0.7207609 , -0.732721  ], dtype=float32)"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### Initial positional encoding for '0' index position in sequence ( This is initialized randomly)\n",
    "initial_positional_encodings[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.8454805 , -0.38526672, -0.08493332, -0.29474849, -0.43305466,\n",
       "       -0.7288659 , -0.43820557, -0.00686736,  0.30882034, -0.2713434 ,\n",
       "        0.12330204, -0.8610024 ,  0.17340916, -0.3315462 , -1.3781036 ,\n",
       "        0.45855713,  0.03467004, -0.29573897,  0.79110086, -0.9372233 ,\n",
       "        0.6543137 ,  2.5521562 , -1.6245695 ,  1.4366064 , -0.58558184,\n",
       "       -0.5955834 ,  2.0201972 ,  1.1562918 , -0.5605443 , -0.36518025,\n",
       "        0.08321931,  2.7056808 , -1.0636885 ,  0.00488415, -0.52747947,\n",
       "        0.03519943,  0.10664079, -0.35064927, -0.14041217,  0.94389623,\n",
       "       -0.01791368,  1.558817  , -0.88902277, -1.1655947 , -1.0225405 ,\n",
       "        0.02825371, -0.39749658, -0.10682822,  0.9108547 ,  0.08691549,\n",
       "       -1.3238521 ,  1.1419272 , -0.51814735, -1.1110724 ,  0.3401083 ,\n",
       "        0.67077804, -1.3149837 ,  0.26382   ,  1.3211321 , -1.7336078 ,\n",
       "       -0.26981932,  0.03952186,  0.7398419 , -0.7418793 ], dtype=float32)"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### Final positional encoding for '0' index position in sequence ( After running the 30 epochs)\n",
    "final_positional_encodings[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From above it is clear that value of positional encoding has changed for each embedding vector position for given index. We can say that it is learning how to represent the positional encoding for given task. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Convert to DataFrame\n",
    "df = pd.DataFrame(data)\n",
    "# Pivot the DataFrame\n",
    "pivot_table = df.pivot(index='y', columns='x', values='val')\n",
    "# Plot heatmap\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(final_positional_encodings, annot=False, cmap=\"viridis\", cbar_kws={'label': 'Positional Encoding Value'})\n",
    "plt.title(\"Heatmap of Positional Encoding Value\")\n",
    "plt.xlabel(\"Embedding Vector Position\")\n",
    "plt.ylabel(\"Position of token in Sequence\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From above it is clear that for each position in sequence and embedding vector position, it has learned different values. So, we can say that it is actually learned the positional representation. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}