3_cnn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b1797021",
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "import sys\n",
    "\n",
    "import datasets\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torchtext\n",
    "import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0d5b5146",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7fb81d11a950>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 0\n",
    "\n",
    "torch.manual_seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1f9cda19",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Reusing dataset imdb (/home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a)\n"
     ]
    }
   ],
   "source": [
    "train_data, test_data = datasets.load_dataset('imdb', split=['train', 'test'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "48f4c1f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenizer = torchtext.data.utils.get_tokenizer('basic_english')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ae7e60ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "def tokenize_data(example, tokenizer, max_length):\n",
    "    tokens = tokenizer(example['text'])[:max_length]\n",
    "    return {'tokens': tokens}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "eca685b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading cached processed dataset at /home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a/cache-ad1b7a77180a232c.arrow\n",
      "Loading cached processed dataset at /home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a/cache-01c0069c185da175.arrow\n"
     ]
    }
   ],
   "source": [
    "max_length = 256\n",
    "\n",
    "train_data = train_data.map(tokenize_data, fn_kwargs={'tokenizer': tokenizer, 'max_length': max_length})\n",
    "test_data = test_data.map(tokenize_data, fn_kwargs={'tokenizer': tokenizer, 'max_length': max_length})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cb53b268",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading cached split indices for dataset at /home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a/cache-90b2a85f23273ecd.arrow and /home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a/cache-99371bdf1a536e7c.arrow\n"
     ]
    }
   ],
   "source": [
    "test_size = 0.25\n",
    "\n",
    "train_valid_data = train_data.train_test_split(test_size=test_size)\n",
    "train_data = train_valid_data['train']\n",
    "valid_data = train_valid_data['test']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a7f7d1d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "min_freq = 5\n",
    "special_tokens = ['<unk>', '<pad>']\n",
    "\n",
    "vocab = torchtext.vocab.build_vocab_from_iterator(train_data['tokens'],\n",
    "                                                  min_freq=min_freq,\n",
    "                                                  specials=special_tokens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d029794a",
   "metadata": {},
   "outputs": [],
   "source": [
    "unk_index = vocab['<unk>']\n",
    "pad_index = vocab['<pad>']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "03aa4514",
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab.set_default_index(unk_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0133bdd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def numericalize_data(example, vocab):\n",
    "    ids = [vocab[token] for token in example['tokens']]\n",
    "    return {'ids': ids}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a8deac4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading cached processed dataset at /home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a/cache-4fa96f7122a515e2.arrow\n",
      "Loading cached processed dataset at /home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a/cache-cabd43c688223ded.arrow\n",
      "Loading cached processed dataset at /home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a/cache-087b09fd94e05553.arrow\n"
     ]
    }
   ],
   "source": [
    "train_data = train_data.map(numericalize_data, fn_kwargs={'vocab': vocab})\n",
    "valid_data = valid_data.map(numericalize_data, fn_kwargs={'vocab': vocab})\n",
    "test_data = test_data.map(numericalize_data, fn_kwargs={'vocab': vocab})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "29f4bd82",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = train_data.with_format(type='torch', columns=['ids', 'label'])\n",
    "valid_data = valid_data.with_format(type='torch', columns=['ids', 'label'])\n",
    "test_data = test_data.with_format(type='torch', columns=['ids', 'label'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "65cd046f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN(nn.Module):\n",
    "    def __init__(self, vocab_size, embedding_dim, n_filters, filter_sizes, output_dim, dropout_rate, \n",
    "                 pad_index):\n",
    "        super().__init__()\n",
    "        self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=pad_index)\n",
    "        self.convs = nn.ModuleList([nn.Conv1d(embedding_dim, \n",
    "                                              n_filters, \n",
    "                                              filter_size) \n",
    "                                    for filter_size in filter_sizes])\n",
    "        self.fc = nn.Linear(len(filter_sizes) * n_filters, output_dim)\n",
    "        self.dropout = nn.Dropout(dropout_rate)\n",
    "        \n",
    "    def forward(self, ids):\n",
    "        # ids = [batch size, seq len]\n",
    "        embedded = self.dropout(self.embedding(ids))\n",
    "        # embedded = [batch size, seq len, embedding dim]\n",
    "        embedded = embedded.permute(0,2,1)\n",
    "        # embedded = [batch size, embedding dim, seq len]\n",
    "        conved = [torch.relu(conv(embedded)) for conv in self.convs]\n",
    "        # conved_n = [batch size, n filters, seq len - filter_sizes[n] + 1]\n",
    "        pooled = [conv.max(dim=-1).values for conv in conved]\n",
    "        # pooled_n = [batch size, n filters]\n",
    "        cat = self.dropout(torch.cat(pooled, dim=-1))\n",
    "        # cat = [batch size, n filters * len(filter_sizes)]\n",
    "        prediction = self.fc(cat)\n",
    "        # prediction = [batch size, output dim]\n",
    "        return prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ad3da9c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_size = len(vocab)\n",
    "embedding_dim = 300\n",
    "n_filters = 100\n",
    "filter_sizes = [3,5,7]\n",
    "output_dim = len(train_data.unique('label'))\n",
    "dropout_rate = 0.25\n",
    "\n",
    "model = CNN(vocab_size, embedding_dim, n_filters, filter_sizes, output_dim, dropout_rate, pad_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e5b9314c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model has 6,913,802 trainable parameters\n"
     ]
    }
   ],
   "source": [
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "print(f'The model has {count_parameters(model):,} trainable parameters')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "48dd9079",
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_weights(m):\n",
    "    if isinstance(m, nn.Linear):\n",
    "        nn.init.xavier_normal_(m.weight)\n",
    "        nn.init.zeros_(m.bias)\n",
    "    elif isinstance(m, nn.Conv1d):\n",
    "        nn.init.kaiming_normal_(m.weight, nonlinearity='relu')\n",
    "        nn.init.zeros_(m.bias)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e455a168",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CNN(\n",
       "  (embedding): Embedding(21543, 300, padding_idx=1)\n",
       "  (convs): ModuleList(\n",
       "    (0): Conv1d(300, 100, kernel_size=(3,), stride=(1,))\n",
       "    (1): Conv1d(300, 100, kernel_size=(5,), stride=(1,))\n",
       "    (2): Conv1d(300, 100, kernel_size=(7,), stride=(1,))\n",
       "  )\n",
       "  (fc): Linear(in_features=300, out_features=2, bias=True)\n",
       "  (dropout): Dropout(p=0.25, inplace=False)\n",
       ")"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.apply(initialize_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "cca8ce6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "vectors = torchtext.vocab.FastText()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e8f96c10",
   "metadata": {},
   "outputs": [],
   "source": [
    "pretrained_embedding = vectors.get_vecs_by_tokens(vocab.get_itos())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "bb09a2aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.embedding.weight.data = pretrained_embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "7a5e39e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(model.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e123ae07",
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "825a973d",
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f9512ae1",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model.to(device)\n",
    "criterion = criterion.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2216fbd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def collate(batch, pad_index):\n",
    "    batch_ids = [i['ids'] for i in batch]\n",
    "    batch_ids = nn.utils.rnn.pad_sequence(batch_ids, padding_value=pad_index, batch_first=True)\n",
    "    batch_label = [i['label'] for i in batch]\n",
    "    batch_label = torch.stack(batch_label)\n",
    "    batch = {'ids': batch_ids,\n",
    "             'label': batch_label}\n",
    "    return batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0513db80",
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 512\n",
    "\n",
    "collate = functools.partial(collate, pad_index=pad_index)\n",
    "\n",
    "train_dataloader = torch.utils.data.DataLoader(train_data, \n",
    "                                               batch_size=batch_size, \n",
    "                                               collate_fn=collate, \n",
    "                                               shuffle=True)\n",
    "\n",
    "valid_dataloader = torch.utils.data.DataLoader(valid_data, batch_size=batch_size, collate_fn=collate)\n",
    "test_dataloader = torch.utils.data.DataLoader(test_data, batch_size=batch_size, collate_fn=collate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c3651ca7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(dataloader, model, criterion, optimizer, device):\n",
    "\n",
    "    model.train()\n",
    "    epoch_losses = []\n",
    "    epoch_accs = []\n",
    "\n",
    "    for batch in tqdm.tqdm(dataloader, desc='training...', file=sys.stdout):\n",
    "        ids = batch['ids'].to(device)\n",
    "        label = batch['label'].to(device)\n",
    "        prediction = model(ids)\n",
    "        loss = criterion(prediction, label)\n",
    "        accuracy = get_accuracy(prediction, label)\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        epoch_losses.append(loss.item())\n",
    "        epoch_accs.append(accuracy.item())\n",
    "\n",
    "    return epoch_losses, epoch_accs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f2a96019",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(dataloader, model, criterion, device):\n",
    "    \n",
    "    model.eval()\n",
    "    epoch_losses = []\n",
    "    epoch_accs = []\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for batch in tqdm.tqdm(dataloader, desc='evaluating...', file=sys.stdout):\n",
    "            ids = batch['ids'].to(device)\n",
    "            label = batch['label'].to(device)\n",
    "            prediction = model(ids)\n",
    "            loss = criterion(prediction, label)\n",
    "            accuracy = get_accuracy(prediction, label)\n",
    "            epoch_losses.append(loss.item())\n",
    "            epoch_accs.append(accuracy.item())\n",
    "\n",
    "    return epoch_losses, epoch_accs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "3cf2f1e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_accuracy(prediction, label):\n",
    "    batch_size, _ = prediction.shape\n",
    "    predicted_classes = prediction.argmax(dim=-1)\n",
    "    correct_predictions = predicted_classes.eq(label).sum()\n",
    "    accuracy = correct_predictions / batch_size\n",
    "    return accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "af6e8a15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training...: 100%|██████████| 37/37 [00:03<00:00,  9.32it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:00<00:00, 13.63it/s]\n",
      "epoch: 1\n",
      "train_loss: 0.735, train_acc: 0.594\n",
      "valid_loss: 0.525, valid_acc: 0.753\n",
      "training...: 100%|██████████| 37/37 [00:03<00:00,  9.73it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:00<00:00, 13.57it/s]\n",
      "epoch: 2\n",
      "train_loss: 0.476, train_acc: 0.773\n",
      "valid_loss: 0.390, valid_acc: 0.828\n",
      "training...: 100%|██████████| 37/37 [00:03<00:00,  9.45it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:00<00:00, 13.46it/s]\n",
      "epoch: 3\n",
      "train_loss: 0.347, train_acc: 0.852\n",
      "valid_loss: 0.344, valid_acc: 0.846\n",
      "training...: 100%|██████████| 37/37 [00:04<00:00,  8.96it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:01<00:00, 12.55it/s]\n",
      "epoch: 4\n",
      "train_loss: 0.289, train_acc: 0.879\n",
      "valid_loss: 0.322, valid_acc: 0.861\n",
      "training...: 100%|██████████| 37/37 [00:04<00:00,  9.11it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:00<00:00, 13.16it/s]\n",
      "epoch: 5\n",
      "train_loss: 0.248, train_acc: 0.903\n",
      "valid_loss: 0.310, valid_acc: 0.869\n",
      "training...: 100%|██████████| 37/37 [00:03<00:00,  9.26it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:00<00:00, 13.52it/s]\n",
      "epoch: 6\n",
      "train_loss: 0.206, train_acc: 0.922\n",
      "valid_loss: 0.296, valid_acc: 0.876\n",
      "training...: 100%|██████████| 37/37 [00:03<00:00,  9.40it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:00<00:00, 13.25it/s]\n",
      "epoch: 7\n",
      "train_loss: 0.172, train_acc: 0.941\n",
      "valid_loss: 0.303, valid_acc: 0.876\n",
      "training...: 100%|██████████| 37/37 [00:04<00:00,  9.24it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:00<00:00, 13.03it/s]\n",
      "epoch: 8\n",
      "train_loss: 0.144, train_acc: 0.952\n",
      "valid_loss: 0.289, valid_acc: 0.881\n",
      "training...: 100%|██████████| 37/37 [00:03<00:00,  9.37it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:00<00:00, 13.19it/s]\n",
      "epoch: 9\n",
      "train_loss: 0.116, train_acc: 0.965\n",
      "valid_loss: 0.290, valid_acc: 0.884\n",
      "training...: 100%|██████████| 37/37 [00:03<00:00,  9.36it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:01<00:00, 12.98it/s]\n",
      "epoch: 10\n",
      "train_loss: 0.092, train_acc: 0.975\n",
      "valid_loss: 0.295, valid_acc: 0.886\n"
     ]
    }
   ],
   "source": [
    "n_epochs = 10\n",
    "best_valid_loss = float('inf')\n",
    "\n",
    "train_losses = []\n",
    "train_accs = []\n",
    "valid_losses = []\n",
    "valid_accs = []\n",
    "\n",
    "for epoch in range(n_epochs):\n",
    "\n",
    "    train_loss, train_acc = train(train_dataloader, model, criterion, optimizer, device)\n",
    "    valid_loss, valid_acc = evaluate(valid_dataloader, model, criterion, device)\n",
    "\n",
    "    train_losses.extend(train_loss)\n",
    "    train_accs.extend(train_acc)\n",
    "    valid_losses.extend(valid_loss)\n",
    "    valid_accs.extend(valid_acc)\n",
    "    \n",
    "    epoch_train_loss = np.mean(train_loss)\n",
    "    epoch_train_acc = np.mean(train_acc)\n",
    "    epoch_valid_loss = np.mean(valid_loss)\n",
    "    epoch_valid_acc = np.mean(valid_acc)\n",
    "    \n",
    "    if epoch_valid_loss < best_valid_loss:\n",
    "        best_valid_loss = epoch_valid_loss\n",
    "        torch.save(model.state_dict(), 'cnn.pt')\n",
    "    \n",
    "    print(f'epoch: {epoch+1}')\n",
    "    print(f'train_loss: {epoch_train_loss:.3f}, train_acc: {epoch_train_acc:.3f}')\n",
    "    print(f'valid_loss: {epoch_valid_loss:.3f}, valid_acc: {epoch_valid_acc:.3f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "03860181",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10,6))\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "ax.plot(train_losses, label='train loss')\n",
    "ax.plot(valid_losses, label='valid loss')\n",
    "plt.legend()\n",
    "ax.set_xlabel('updates')\n",
    "ax.set_ylabel('loss');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "df5d03f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10,6))\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "ax.plot(train_accs, label='train accuracy')\n",
    "ax.plot(valid_accs, label='valid accuracy')\n",
    "plt.legend()\n",
    "ax.set_xlabel('updates')\n",
    "ax.set_ylabel('accuracy');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "bb00498a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "evaluating...: 100%|██████████| 49/49 [00:03<00:00, 12.51it/s]\n",
      "test_loss: 0.284, test_acc: 0.879\n"
     ]
    }
   ],
   "source": [
    "model.load_state_dict(torch.load('cnn.pt'))\n",
    "\n",
    "test_loss, test_acc = evaluate(test_dataloader, model, criterion, device)\n",
    "\n",
    "epoch_test_loss = np.mean(test_loss)\n",
    "epoch_test_acc = np.mean(test_acc)\n",
    "\n",
    "print(f'test_loss: {epoch_test_loss:.3f}, test_acc: {epoch_test_acc:.3f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "7c08b412",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_sentiment(text, model, tokenizer, vocab, device, min_length, pad_index):\n",
    "    tokens = tokenizer(text)\n",
    "    ids = [vocab[t] for t in tokens]\n",
    "    if len(ids) < min_length:\n",
    "        ids += [pad_index] * (min_length - len(ids))\n",
    "    tensor = torch.LongTensor(ids).unsqueeze(dim=0).to(device)\n",
    "    prediction = model(tensor).squeeze(dim=0)\n",
    "    probability = torch.softmax(prediction, dim=-1)\n",
    "    predicted_class = prediction.argmax(dim=-1).item()\n",
    "    predicted_probability = probability[predicted_class].item()\n",
    "    return predicted_class, predicted_probability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "4fd0877a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 0.8934109807014465)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"This film is terrible!\"\n",
    "min_length = max(filter_sizes)\n",
    "\n",
    "predict_sentiment(text, model, tokenizer, vocab, device, min_length, pad_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "31063352",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 0.9333373308181763)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"This film is great!\"\n",
    "\n",
    "predict_sentiment(text, model, tokenizer, vocab, device, min_length, pad_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "162aea28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 0.6499875783920288)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"This film is not terrible, it's great!\"\n",
    "\n",
    "predict_sentiment(text, model, tokenizer, vocab, device, min_length, pad_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "83c036aa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 0.6004905700683594)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"This film is not great, it's terrible!\"\n",
    "\n",
    "predict_sentiment(text, model, tokenizer, vocab, device, min_length, pad_index)"
   ]
  }
 ],
 "metadata": {
  "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}