2_lstm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f23a152d",
   "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": "c661e3c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f37d143a9d0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 0\n",
    "\n",
    "torch.manual_seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "638a120e",
   "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": "7b34799a",
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenizer = torchtext.data.utils.get_tokenizer('basic_english')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6fa2f2e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def tokenize_data(example, tokenizer, max_length):\n",
    "    tokens = tokenizer(example['text'])[:max_length]\n",
    "    length = len(tokens)\n",
    "    return {'tokens': tokens, 'length': length}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1f3a3894",
   "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-98e263656f586667.arrow\n",
      "Loading cached processed dataset at /home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a/cache-08f9ff60341e8990.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": "7e5bd85d",
   "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-28b136fb2a4d67fd.arrow and /home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a/cache-8fa05fb343b1e79a.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": "0bf984df",
   "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": "5147a8fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "unk_index = vocab['<unk>']\n",
    "pad_index = vocab['<pad>']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8b97bda7",
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab.set_default_index(unk_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "843282aa",
   "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": "885b504a",
   "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-631f583ffb0d9c68.arrow\n",
      "Loading cached processed dataset at /home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a/cache-6f5a6c52dcbaf2d0.arrow\n",
      "Loading cached processed dataset at /home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a/cache-c455c5d5c41c2779.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": "2b956558",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = train_data.with_format(type='torch', columns=['ids', 'label', 'length'])\n",
    "valid_data = valid_data.with_format(type='torch', columns=['ids', 'label', 'length'])\n",
    "test_data = test_data.with_format(type='torch', columns=['ids', 'label', 'length'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "53575424",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'label': tensor(1),\n",
       " 'length': tensor(256),\n",
       " 'ids': tensor([   98,    13,  6329,     6,   559,    13,  6491,     4,     2,   763,\n",
       "             6,  6300,    17,    34,     7,     2,   195,   116,    98,    40,\n",
       "          2302,   102,  3497,    44,  3318, 15422,    21,   261,  3609,  3433,\n",
       "             3,   474,     4,  6093,     6, 10888,    54,   396,  1198,   338,\n",
       "          4479,     4,    14,    23,  1481,  3596,    19,     5, 13453,   850,\n",
       "            23,     3,     2,   639,     7,    14,    23,    10,  1073,    20,\n",
       "          2302,     9,  7180,  9372,     7,  1045,  2522,     4,  1706,  2115,\n",
       "             4,   212,  8127,     6,  3179,  1485,     3,     2,   386,     7,\n",
       "         13210,   860,   233,    10,     5, 12948,     8,     2,   984,   212,\n",
       "           628,   346,    13,  1228,     7,   462,     4,     6,     2,  1236,\n",
       "          1675,   114,     6,     2,   905,    13, 10802,    59,    71,    35,\n",
       "          1132,    19,     2,  3009,     4,    13,   117,   771,     4,     8,\n",
       "          3582,  3534,     9,    16, 10802,     3,   446,     4,    11,    10,\n",
       "          2302,     9,  3013,    20,  1810,  6389,    15,  4846,    14,    23,\n",
       "            13,   100,  6865,     3,     2,   113,     7,    14,    64,    10,\n",
       "           406,   443,   527,     5,   525,  4470, 10812,     7,    23,  3324,\n",
       "             3,   190,     4,   500,    14,  3049,     4,     2,    64,  2675,\n",
       "            20,   356,   389,    40,  2302,     4,  7843,     6,   262,  3111,\n",
       "         14039,    25,  2146,    24,   106,    14,    23,     5,  1777,     8,\n",
       "           108,     3,  4281,  2302,  2890,   137,    29,    71,     2,  2386,\n",
       "             0,     4,    22,     2,  3544,  7847,    19,     2,  1172,    22,\n",
       "          1813,  7915,     3,  6041,  7843,     4,    42,    17,   922,     8,\n",
       "          2302,    38,     2,    65,     4,  2100,    20,    50,   604,   556,\n",
       "            19,     5,   416, 11476,     6,   310,    27,     5,   221,     7,\n",
       "           158,  1248,     6, 16505,     3,   454,     4,  3111, 14039,   637,\n",
       "             6,  1079,  1074,    49,  8928,     9])}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "53427b55",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSTM(nn.Module):\n",
    "    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim, n_layers, bidirectional,\n",
    "                 dropout_rate, pad_index):\n",
    "        super().__init__()\n",
    "        self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=pad_index)\n",
    "        self.lstm = nn.LSTM(embedding_dim, hidden_dim, n_layers, bidirectional=bidirectional,\n",
    "                            dropout=dropout_rate, batch_first=True)\n",
    "        self.fc = nn.Linear(hidden_dim * 2 if bidirectional else hidden_dim, output_dim)\n",
    "        self.dropout = nn.Dropout(dropout_rate)\n",
    "        \n",
    "    def forward(self, ids, length):\n",
    "        # ids = [batch size, seq len]\n",
    "        # length = [batch size]\n",
    "        embedded = self.dropout(self.embedding(ids))\n",
    "        # embedded = [batch size, seq len, embedding dim]\n",
    "        packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, length, batch_first=True, \n",
    "                                                            enforce_sorted=False)\n",
    "        packed_output, (hidden, cell) = self.lstm(packed_embedded)\n",
    "        # hidden = [n layers * n directions, batch size, hidden dim]\n",
    "        # cell = [n layers * n directions, batch size, hidden dim]\n",
    "        output, output_length = nn.utils.rnn.pad_packed_sequence(packed_output)\n",
    "        # output = [batch size, seq len, hidden dim * n directions]\n",
    "        if self.lstm.bidirectional:\n",
    "            hidden = self.dropout(torch.cat([hidden[-1], hidden[-2]], dim=-1))\n",
    "            # hidden = [batch size, hidden dim * 2]\n",
    "        else:\n",
    "            hidden = self.dropout(hidden[-1])\n",
    "            # hidden = [batch size, hidden dim]\n",
    "        prediction = self.fc(hidden)\n",
    "        # prediction = [batch size, output dim]\n",
    "        return prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "11206188",
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_size = len(vocab)\n",
    "embedding_dim = 300\n",
    "hidden_dim = 300\n",
    "output_dim = len(train_data.unique('label'))\n",
    "n_layers = 2\n",
    "bidirectional = True\n",
    "dropout_rate = 0.5\n",
    "\n",
    "model = LSTM(vocab_size, embedding_dim, hidden_dim, output_dim, n_layers, bidirectional, dropout_rate, \n",
    "             pad_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5feb9512",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model has 10,073,702 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": 18,
   "id": "3edc8e02",
   "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.LSTM):\n",
    "        for name, param in m.named_parameters():\n",
    "            if 'bias' in name:\n",
    "                nn.init.zeros_(param)\n",
    "            elif 'weight' in name:\n",
    "                nn.init.orthogonal_(param)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "98490c40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LSTM(\n",
       "  (embedding): Embedding(21543, 300, padding_idx=1)\n",
       "  (lstm): LSTM(300, 300, num_layers=2, batch_first=True, dropout=0.5, bidirectional=True)\n",
       "  (fc): Linear(in_features=600, out_features=2, bias=True)\n",
       "  (dropout): Dropout(p=0.5, inplace=False)\n",
       ")"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.apply(initialize_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "72bfd654",
   "metadata": {},
   "outputs": [],
   "source": [
    "vectors = torchtext.vocab.FastText()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6ec1ed34",
   "metadata": {},
   "outputs": [],
   "source": [
    "pretrained_embedding = vectors.get_vecs_by_tokens(vocab.get_itos())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "7489711f",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.embedding.weight.data = pretrained_embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e2d0b14e",
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = 5e-4\n",
    "\n",
    "optimizer = optim.Adam(model.parameters(), lr=lr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d798a6bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4a780705",
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "5c8302f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model.to(device)\n",
    "criterion = criterion.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "070a2098",
   "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_length = [i['length'] for i in batch]\n",
    "    batch_length = torch.stack(batch_length)\n",
    "    batch_label = [i['label'] for i in batch]\n",
    "    batch_label = torch.stack(batch_label)\n",
    "    batch = {'ids': batch_ids,\n",
    "             'length': batch_length,\n",
    "             'label': batch_label}\n",
    "    return batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "48efdace",
   "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": 29,
   "id": "8a1e9b07",
   "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",
    "        length = batch['length']\n",
    "        label = batch['label'].to(device)\n",
    "        prediction = model(ids, length)\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": 30,
   "id": "c7988786",
   "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",
    "            length = batch['length']\n",
    "            label = batch['label'].to(device)\n",
    "            prediction = model(ids, length)\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": 31,
   "id": "d66535bd",
   "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": 32,
   "id": "24c05b57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training...: 100%|██████████| 37/37 [00:09<00:00,  3.80it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:01<00:00,  8.70it/s]\n",
      "epoch: 1\n",
      "train_loss: 0.632, train_acc: 0.632\n",
      "valid_loss: 0.470, valid_acc: 0.779\n",
      "training...: 100%|██████████| 37/37 [00:09<00:00,  3.91it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:01<00:00,  8.53it/s]\n",
      "epoch: 2\n",
      "train_loss: 0.522, train_acc: 0.743\n",
      "valid_loss: 0.465, valid_acc: 0.775\n",
      "training...: 100%|██████████| 37/37 [00:09<00:00,  4.08it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:01<00:00,  8.66it/s]\n",
      "epoch: 3\n",
      "train_loss: 0.443, train_acc: 0.804\n",
      "valid_loss: 0.393, valid_acc: 0.830\n",
      "training...: 100%|██████████| 37/37 [00:09<00:00,  4.05it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:01<00:00,  8.67it/s]\n",
      "epoch: 4\n",
      "train_loss: 0.369, train_acc: 0.840\n",
      "valid_loss: 0.367, valid_acc: 0.848\n",
      "training...: 100%|██████████| 37/37 [00:09<00:00,  4.03it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:01<00:00,  8.60it/s]\n",
      "epoch: 5\n",
      "train_loss: 0.336, train_acc: 0.857\n",
      "valid_loss: 0.393, valid_acc: 0.842\n",
      "training...: 100%|██████████| 37/37 [00:09<00:00,  4.05it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:01<00:00,  8.63it/s]\n",
      "epoch: 6\n",
      "train_loss: 0.375, train_acc: 0.837\n",
      "valid_loss: 0.387, valid_acc: 0.842\n",
      "training...: 100%|██████████| 37/37 [00:09<00:00,  4.04it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:01<00:00,  8.56it/s]\n",
      "epoch: 7\n",
      "train_loss: 0.368, train_acc: 0.848\n",
      "valid_loss: 0.437, valid_acc: 0.791\n",
      "training...: 100%|██████████| 37/37 [00:09<00:00,  4.05it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:01<00:00,  8.59it/s]\n",
      "epoch: 8\n",
      "train_loss: 0.324, train_acc: 0.866\n",
      "valid_loss: 0.343, valid_acc: 0.854\n",
      "training...: 100%|██████████| 37/37 [00:09<00:00,  4.04it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:01<00:00,  8.53it/s]\n",
      "epoch: 9\n",
      "train_loss: 0.276, train_acc: 0.890\n",
      "valid_loss: 0.362, valid_acc: 0.866\n",
      "training...: 100%|██████████| 37/37 [00:09<00:00,  4.05it/s]\n",
      "evaluating...: 100%|██████████| 13/13 [00:01<00:00,  8.57it/s]\n",
      "epoch: 10\n",
      "train_loss: 0.245, train_acc: 0.899\n",
      "valid_loss: 0.330, valid_acc: 0.873\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(), 'lstm.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": 33,
   "id": "b360d0cd",
   "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": 34,
   "id": "742a6855",
   "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": 35,
   "id": "8b89f53f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "evaluating...: 100%|██████████| 49/49 [00:06<00:00,  8.03it/s]\n",
      "test_loss: 0.351, test_acc: 0.859\n"
     ]
    }
   ],
   "source": [
    "model.load_state_dict(torch.load('lstm.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": 36,
   "id": "c07df383",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_sentiment(text, model, tokenizer, vocab, device):\n",
    "    tokens = tokenizer(text)\n",
    "    ids = [vocab[t] for t in tokens]\n",
    "    length = torch.LongTensor([len(ids)])\n",
    "    tensor = torch.LongTensor(ids).unsqueeze(dim=0).to(device)\n",
    "    prediction = model(tensor, length).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": 37,
   "id": "8d9d591d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 0.8874172568321228)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"This film is terrible!\"\n",
    "\n",
    "predict_sentiment(text, model, tokenizer, vocab, device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "f392b05a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 0.9508437514305115)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"This film is great!\"\n",
    "\n",
    "predict_sentiment(text, model, tokenizer, vocab, device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "3196951d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 0.5246995091438293)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"This film is not terrible, it's great!\"\n",
    "\n",
    "predict_sentiment(text, model, tokenizer, vocab, device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "c35aeb03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 0.5568666458129883)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"This film is not great, it's terrible!\"\n",
    "\n",
    "predict_sentiment(text, model, tokenizer, vocab, device)"
   ]
  }
 ],
 "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
}