pytorch-sentiment-analysis/3_cnn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b1797021",
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "\n",
    "import datasets\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "\n",
    "import torchtext"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0d5b5146",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f36addef930>"
      ]
     },
     "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 dataloader:\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 dataloader:\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": [
      "epoch: 1\n",
      "train_loss: 0.735, train_acc: 0.594\n",
      "valid_loss: 0.525, valid_acc: 0.753\n",
      "epoch: 2\n",
      "train_loss: 0.476, train_acc: 0.773\n",
      "valid_loss: 0.390, valid_acc: 0.828\n",
      "epoch: 3\n",
      "train_loss: 0.347, train_acc: 0.852\n",
      "valid_loss: 0.344, valid_acc: 0.847\n",
      "epoch: 4\n",
      "train_loss: 0.289, train_acc: 0.879\n",
      "valid_loss: 0.322, valid_acc: 0.862\n",
      "epoch: 5\n",
      "train_loss: 0.248, train_acc: 0.902\n",
      "valid_loss: 0.311, valid_acc: 0.870\n",
      "epoch: 6\n",
      "train_loss: 0.207, train_acc: 0.923\n",
      "valid_loss: 0.296, valid_acc: 0.877\n",
      "epoch: 7\n",
      "train_loss: 0.172, train_acc: 0.941\n",
      "valid_loss: 0.303, valid_acc: 0.878\n",
      "epoch: 8\n",
      "train_loss: 0.144, train_acc: 0.952\n",
      "valid_loss: 0.289, valid_acc: 0.881\n",
      "epoch: 9\n",
      "train_loss: 0.116, train_acc: 0.965\n",
      "valid_loss: 0.290, valid_acc: 0.886\n",
      "epoch: 10\n",
      "train_loss: 0.091, train_acc: 0.974\n",
      "valid_loss: 0.295, valid_acc: 0.887\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": [
      "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.8809852004051208)"
      ]
     },
     "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.935274064540863)"
      ]
     },
     "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.6467499136924744)"
      ]
     },
     "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.6088114380836487)"
      ]
     },
     "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
}