classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rvn/.envs/torch-2.2.0-cu-12.1/lib/python3.8/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import collections\n",
    "\n",
    "import datasets\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import torchtext"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Seeding to ensure reproducibility\n",
    "seed = 0\n",
    "\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed(seed)\n",
    "torch.backends.cudnn.deterministic = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# IMDB Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loading the dataset is very easy using the `datasets` package! The command below will download (if required in the *data/classification* directory) and load the IMDB dataset in a variable named `dataset`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = datasets.load_dataset(\"zapsdcn/imdb\", cache_dir=\"../data/classification/\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The loaded `dataset` is already split into training, validation and testing sets. Looking at the outputs, we can see the number of examples (`num_rows`) in each split and three features named `id`, `text` and `label`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Dataset({\n",
       "     features: ['id', 'text', 'label'],\n",
       "     num_rows: 20000\n",
       " }),\n",
       " Dataset({\n",
       "     features: ['id', 'text', 'label'],\n",
       "     num_rows: 5000\n",
       " }),\n",
       " Dataset({\n",
       "     features: ['id', 'text', 'label'],\n",
       "     num_rows: 25000\n",
       " }))"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_dataset = dataset['train'] \n",
    "validation_dataset = dataset['validation']\n",
    "test_dataset = dataset['test']\n",
    "\n",
    "train_dataset, validation_dataset, test_dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at one such training example, we can see that \n",
    "- `id` contains information related to some index. Don't bother too much about this as this is not relevant for the application at hand.\n",
    "- `text` is where we have the actual review!\n",
    "- `label` denotes whether it's a good (if 1) or bad (if 0) review! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'id': 'train_10348',\n",
       " 'text': 'This movie is very good. The screenplay is enchanting. But Meryl Streep is most impressive. Her performance is excellent. She brings me to go into the heart of her role.',\n",
       " 'label': 1}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_dataset[-3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenization and Vocabulary Building"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computers only understand numbers. So we have to find a way to modify such that we can represent each word as a number. But first we have to split sentences into individual words. This is called Tokenization and is done using a tokenizer! \n",
    "\n",
    "I'm using a simple tokenizer provided by `torchtext`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenizer = torchtext.data.utils.get_tokenizer(\"basic_english\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, a tokenizer splits a text into words!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['this', 'movie', 'is', 'very', 'good', '.', 'the', 'screenplay', 'is', 'enchanting', '.', 'but', 'meryl', 'streep', 'is', 'most', 'impressive', '.', 'her', 'performance', 'is', 'excellent', '.', 'she', 'brings', 'me', 'to', 'go', 'into', 'the', 'heart', 'of', 'her', 'role', '.']\n"
     ]
    }
   ],
   "source": [
    "print(tokenizer(train_dataset[-3][\"text\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do this for all of the training, validation and testing dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tokenize(example, tokenizer, max_length):\n",
    "    tokens = tokenizer(example[\"text\"])[:max_length]\n",
    "    return {\"tokens\": tokens}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Truncating the max length of a review because some of them ramble on for quite some time!\n",
    "max_length = 512\n",
    "\n",
    "train_dataset = train_dataset.map(\n",
    "    tokenize, fn_kwargs={\"tokenizer\": tokenizer, \"max_length\": max_length}\n",
    ")\n",
    "validation_dataset = validation_dataset.map(\n",
    "    tokenize, fn_kwargs={\"tokenizer\": tokenizer, \"max_length\": max_length}\n",
    ")\n",
    "test_dataset = test_dataset.map(\n",
    "    tokenize, fn_kwargs={\"tokenizer\": tokenizer, \"max_length\": max_length}\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's build a volcabulary out of these tokens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Only selecting words at occur at least 5 times in the whole dataset\n",
    "min_freq = 5\n",
    "\n",
    "# Special tokens for unknown words and paddings (these will come in later)\n",
    "special_tokens = [\"<unk>\", \"<pad>\"]\n",
    "\n",
    "vocab = torchtext.vocab.build_vocab_from_iterator(\n",
    "    train_dataset[\"tokens\"],\n",
    "    min_freq=min_freq,\n",
    "    specials=special_tokens,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vocab Size:  25473\n"
     ]
    }
   ],
   "source": [
    "print(\"Vocab Size: \", len(vocab))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Making sure that words that are not in the vocabulary gets mapped to `\"<unk>\"` and assiging a token for padding as well (we'll cover padding later)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "unk_index = vocab[\"<unk>\"]\n",
    "pad_index = vocab[\"<pad>\"]\n",
    "\n",
    "vocab.set_default_index(unk_index)\n",
    "\n",
    "print(vocab[\"some_token_that_is_not_in_vocab\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now with this we can easily map any review to a sequence of numbers!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[14, 19, 10, 59, 57, 3, 2, 875, 10, 6752, 3, 22, 5124, 4287, 10, 97, 1168, 3, 47, 246, 10, 301, 3, 62, 934, 76, 8, 149, 90, 2, 534, 7, 47, 219, 3]\n"
     ]
    }
   ],
   "source": [
    "print(vocab.lookup_indices(train_dataset[-3][\"tokens\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do this in a more refined way for all of the datasets and store these number in the `id` feature!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def numericalize(example, vocab):\n",
    "    id = vocab.lookup_indices(example[\"tokens\"])\n",
    "    return {\"id\": id}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = train_dataset.map(numericalize, fn_kwargs={\"vocab\": vocab})\n",
    "validation_dataset = validation_dataset.map(numericalize, fn_kwargs={\"vocab\": vocab})\n",
    "test_dataset = test_dataset.map(numericalize, fn_kwargs={\"vocab\": vocab})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Converting to torch tensors to be loaded into Transformer!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = train_dataset.with_format(type=\"torch\", columns=[\"id\", \"label\"])\n",
    "validation_dataset = validation_dataset.with_format(type=\"torch\", columns=[\"id\", \"label\"])\n",
    "test_dataset = test_dataset.with_format(type=\"torch\", columns=[\"id\", \"label\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Loader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now pad the sequences to make them of equal lengths and then load the dataset into pytorch data loaders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_collate_fn(pad_index):\n",
    "    def collate_fn(batch):\n",
    "        batch_ids = [i[\"id\"] for i in batch]\n",
    "        batch_ids = torch.nn.utils.rnn.pad_sequence(\n",
    "            batch_ids, padding_value=pad_index, batch_first=True\n",
    "        )\n",
    "        batch_label = [i[\"label\"] for i in batch]\n",
    "        batch_label = torch.stack(batch_label)\n",
    "        batch = {\"id\": batch_ids, \"label\": batch_label}\n",
    "        return batch\n",
    "\n",
    "    return collate_fn\n",
    "\n",
    "def get_data_loader(dataset, batch_size, pad_index, shuffle=False):\n",
    "    collate_fn = get_collate_fn(pad_index)\n",
    "    data_loader = torch.utils.data.DataLoader(\n",
    "        dataset=dataset,\n",
    "        batch_size=batch_size,\n",
    "        collate_fn=collate_fn,\n",
    "        shuffle=shuffle,\n",
    "    )\n",
    "    return data_loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Batch Size\n",
    "batch_size = 512\n",
    "\n",
    "train_data_loader = get_data_loader(train_dataset, batch_size, pad_index, shuffle=True)\n",
    "validation_data_loader = get_data_loader(validation_dataset, batch_size, pad_index)\n",
    "test_data_loader = get_data_loader(test_dataset, batch_size, pad_index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can think of pytorch data loaders as an iterable over which you can loop and get batches one by one!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transformers Neural Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi-Head Self Attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SelfAttention(torch.nn.Module):\n",
    "    def __init__(self, emb, heads):\n",
    "        super().__init__()\n",
    "        assert emb % heads == 0\n",
    "        self.emb, self.heads = emb, heads\n",
    "\n",
    "        # Three emb x emb matrix multiplications to get queries, keys and values\n",
    "        self.to_queries = torch.nn.Linear(emb, emb)\n",
    "        self.to_keys = torch.nn.Linear(emb, emb)\n",
    "        self.to_values = torch.nn.Linear(emb, emb)\n",
    "\n",
    "        # One last Linear layer at the end with emb x emb matrix multiplication\n",
    "        self.unify = torch.nn.Linear(emb, emb)\n",
    "\n",
    "    def forward(self, x):\n",
    "        b, t, emb = x.shape # Batch Size, Sequence Length, embedding dim\n",
    "        h = self.heads\n",
    "\n",
    "        # Computing queries, keys and values\n",
    "        queries = self.to_queries(x)\n",
    "        keys = self.to_keys(x)\n",
    "        values = self.to_values(x)\n",
    "\n",
    "        # Slicing out the heads\n",
    "        queries = queries.view(b, t, h, emb//h)\n",
    "        keys = keys.view(b, t, h, emb//h)\n",
    "        values = values.view(b, t, h, emb//h)\n",
    "\n",
    "        # Folding heads into batch dims (Remember head computations can run in parallel)\n",
    "        queries = queries.transpose(1, 2).reshape(b*h, t, emb//h)\n",
    "        keys = keys.transpose(1, 2).reshape(b*h, t, emb//h)\n",
    "        values = values.transpose(1, 2).reshape(b*h, t, emb//h)\n",
    "\n",
    "        # Here comes Self Attention...\n",
    "        W = torch.bmm(queries, keys.transpose(1,2)) # Computing Weights\n",
    "        W = W / (emb**(1/2)) # Scaling for stability\n",
    "        W = F.softmax(W, dim=2) # Row-wise Softmax\n",
    "        y = torch.bmm(W, values).view(b, h, t, emb//h) # Computing y\n",
    "        y = y.transpose(1, 2).reshape(b, t, emb) # Concatenating heads\n",
    "\n",
    "        # Final Linear NN Layer\n",
    "        return self.unify(y), W"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transformer Block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransformerBlock(torch.nn.Module):\n",
    "    def __init__(self, emb, heads):\n",
    "        super().__init__()\n",
    "\n",
    "        # Attention Block\n",
    "        self.attention = SelfAttention(emb, heads)\n",
    "\n",
    "        # Layer Normalizations\n",
    "        self.norm1 = torch.nn.LayerNorm(emb)\n",
    "        self.norm2 = torch.nn.LayerNorm(emb)\n",
    "\n",
    "        # FCN\n",
    "        self.fcn = torch.nn.Sequential(\n",
    "            torch.nn.Linear(emb, 4*emb),\n",
    "            torch.nn.ReLU(),\n",
    "            torch.nn.Linear(4*emb, emb)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        attented, W = self.attention(x)\n",
    "        x = self.norm1(attented + x)\n",
    "        ff = self.fcn(x)\n",
    "        \n",
    "        return self.norm2(ff + x), W"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transformer Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Transformer(torch.nn.Module):\n",
    "    def __init__(self, emb, heads, max_seq_length, vocab_size):\n",
    "        super().__init__()\n",
    "        self.vocab_size = vocab_size\n",
    "\n",
    "        self.token_embedding = torch.nn.Embedding(embedding_dim=emb, num_embeddings=vocab_size)\n",
    "        self.pos_embedding = torch.nn.Embedding(embedding_dim=emb, num_embeddings=max_seq_length)\n",
    "\n",
    "        self.tblock = TransformerBlock(emb=emb, heads=heads)\n",
    "\n",
    "        self.toprobs = torch.nn.Linear(emb, 2)\n",
    "\n",
    "    def forward(self, x):\n",
    "        tokens = self.token_embedding(x)\n",
    "        b, t, e = tokens.shape\n",
    "        \n",
    "        positions = self.pos_embedding(torch.arange(t, device=\"cuda\"))[None, :, :].expand(b, t, e)\n",
    "        x = tokens + positions\n",
    "\n",
    "        x, W = self.tblock(x)\n",
    "        x = torch.mean(x, dim=1)\n",
    "        x = self.toprobs(x)\n",
    "\n",
    "        return F.log_softmax(x, dim=1), W"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = 0.001\n",
    "num_epochs = 20\n",
    "heads = 4\n",
    "\n",
    "model = Transformer(emb=32, heads=heads, max_seq_length=max_length, vocab_size=len(vocab)).to(\"cuda\")\n",
    "\n",
    "opt = torch.optim.Adam(lr=lr, params=model.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:0; Loss: 0.690449595451355; Accuracy: 0.5142\n",
      "Epoch:1; Loss: 0.6767212748527527; Accuracy: 0.63248\n",
      "Epoch:2; Loss: 0.6255638599395752; Accuracy: 0.672\n",
      "Epoch:3; Loss: 0.5867947340011597; Accuracy: 0.71212\n",
      "Epoch:4; Loss: 0.6983010172843933; Accuracy: 0.75448\n",
      "Epoch:5; Loss: 0.37280407547950745; Accuracy: 0.77428\n",
      "Epoch:6; Loss: 0.6024116277694702; Accuracy: 0.79\n",
      "Epoch:7; Loss: 0.2825118899345398; Accuracy: 0.80928\n",
      "Epoch:8; Loss: 0.2175906002521515; Accuracy: 0.81792\n",
      "Epoch:9; Loss: 0.3413735628128052; Accuracy: 0.80576\n",
      "Epoch:10; Loss: 0.20638501644134521; Accuracy: 0.82916\n",
      "Epoch:11; Loss: 0.0660647600889206; Accuracy: 0.83424\n",
      "Epoch:12; Loss: 0.23274169862270355; Accuracy: 0.8392\n",
      "Epoch:13; Loss: 0.21374528110027313; Accuracy: 0.84268\n",
      "Epoch:14; Loss: 0.30939772725105286; Accuracy: 0.84324\n",
      "Epoch:15; Loss: 0.16323070228099823; Accuracy: 0.83836\n",
      "Epoch:16; Loss: 0.12363114207983017; Accuracy: 0.83632\n",
      "Epoch:17; Loss: 0.13967354595661163; Accuracy: 0.84076\n",
      "Epoch:18; Loss: 0.115811787545681; Accuracy: 0.84512\n",
      "Epoch:19; Loss: 0.02503775618970394; Accuracy: 0.84468\n"
     ]
    }
   ],
   "source": [
    "accs = []\n",
    "for epoch in range(num_epochs):\n",
    "    for batch in train_data_loader:\n",
    "        opt.zero_grad()\n",
    "\n",
    "        input = batch[\"id\"].to(\"cuda\")\n",
    "        output = batch[\"label\"].to(\"cuda\")\n",
    "\n",
    "        preds, _ = model(input)\n",
    "        loss = F.nll_loss(preds, output)\n",
    "\n",
    "        loss.backward()\n",
    "        opt.step()\n",
    "\n",
    "        with torch.no_grad():\n",
    "            tot, cor= 0.0, 0.0\n",
    "            for batch in validation_data_loader:\n",
    "                input = batch[\"id\"].to(\"cuda\")\n",
    "                output = batch[\"label\"].to(\"cuda\")\n",
    "\n",
    "                if input.shape[1] > max_length:\n",
    "                    input = input[:, :max_length]\n",
    "                preds, _ = model(input)\n",
    "                preds = preds.argmax(dim=1)\n",
    "\n",
    "                tot += float(input.size(0))\n",
    "                cor += float((output == preds).sum().item())\n",
    "\n",
    "            acc = cor / tot\n",
    "            accs.append(acc)\n",
    "\n",
    "    print(\"Epoch:{}; Loss: {}; Validation Accuracy: {}\".format(epoch, loss.item(), acc))\n",
    "\n",
    "torch.save(model.state_dict(), \"trained_models/clasify_{}heads.pt\".format(heads))\n",
    "np.save(\"trained_models/acc.npy\", accs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot Validation Accuracy\n",
    "accs = np.load(\"trained_models/acc.npy\")\n",
    "plt.style.use('default')\n",
    "plt.plot(np.linspace(0, 20, len(accs)), accs, label=\"Validation Accuracy\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.ylim(0.45, 1)\n",
    "plt.grid()\n",
    "plt.title(\"Transformer Neural Network\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load model with heads. Options: {1 or 4}\n",
    "heads = 4 \n",
    "\n",
    "# Loading Model\n",
    "model.load_state_dict(torch.load(\"trained_models/clasify_{}heads.pt\".format(heads)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing Accuracy:  0.8306\n"
     ]
    }
   ],
   "source": [
    "acc = 0\n",
    "with torch.no_grad():\n",
    "    tot, cor= 0.0, 0.0\n",
    "    for batch in validation_data_loader:\n",
    "        input = batch[\"id\"].to(\"cuda\")\n",
    "        output = batch[\"label\"].to(\"cuda\")\n",
    "\n",
    "        if input.shape[1] > max_length:\n",
    "            input = input[:, :max_length]\n",
    "        preds, _ = model(input)\n",
    "        preds = preds.argmax(dim=1)\n",
    "\n",
    "        tot += float(input.size(0))\n",
    "        cor += float((output == preds).sum().item())\n",
    "\n",
    "    acc = cor / tot\n",
    "\n",
    "print(\"Testing Accuracy: \", acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizing Attention Weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i\n",
      "went\n",
      "and\n",
      "saw\n",
      "this\n",
      "movie\n",
      "last\n",
      "night\n",
      "after\n",
      "being\n"
     ]
    }
   ],
   "source": [
    "# Picking a random testing review\n",
    "test_review = next(iter(test_data_loader))[\"id\"][0]\n",
    "\n",
    "# Printing 1st 10 words of the review\n",
    "text = []\n",
    "for num in list(test_review.numpy())[:10]:\n",
    "    text.append(str(vocab.get_itos()[num]))\n",
    "    print(vocab.get_itos()[num])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 512])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_review.unsqueeze(0).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with torch.no_grad():\n",
    "    _, attention = model(test_review.unsqueeze(0).to(\"cuda\"))\n",
    "\n",
    "    attention_weights = attention.cpu().numpy()\n",
    "    \n",
    "for (i, attention) in enumerate(attention_weights):\n",
    "    plt.style.use('default')\n",
    "    plt.figure(figsize=(10,10))\n",
    "    plt.imshow(attention[:10, :10]) \n",
    "    plt.xticks(np.arange(0, 10), text[:10])\n",
    "    plt.yticks(np.arange(0, 10), text[:10])\n",
    "    plt.colorbar()\n",
    "    plt.title(\"Attention Weight {}\".format(i))\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch-2.2.0-cu-12.1",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}