diff --git a/4_transformer.ipynb b/4_transformer.ipynb new file mode 100644 index 0000000..75c17c2 --- /dev/null +++ b/4_transformer.ipynb @@ -0,0 +1,1074 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "891b5e34", + "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\n", + "import transformers" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "895ef909", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "seed = 0\n", + "\n", + "torch.manual_seed(seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "98f4ab7c", + "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": "d0a1e49f", + "metadata": {}, + "outputs": [], + "source": [ + "transformer_name = 'bert-base-uncased'\n", + "\n", + "tokenizer = transformers.AutoTokenizer.from_pretrained(transformer_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4c814ae1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['hello', 'world', '!']" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tokenizer.tokenize('hello world!')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ab3e4c32", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[101, 7592, 2088, 999, 102]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tokenizer.encode('hello world!')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8f10453a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['[CLS]', 'hello', 'world', '[SEP]']" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tokenizer.convert_ids_to_tokens(tokenizer.encode('hello world'))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "824ba733", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'input_ids': [101, 7592, 2088, 999, 102], 'token_type_ids': [0, 0, 0, 0, 0], 'attention_mask': [1, 1, 1, 1, 1]}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tokenizer('hello world!')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9358a7aa", + "metadata": {}, + "outputs": [], + "source": [ + "def tokenize_and_numericalize_data(example, tokenizer):\n", + " ids = tokenizer(example['text'], truncation=True)['input_ids']\n", + " return {'ids': ids}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d0259875", + "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-2d2ddeb0d544c918.arrow\n", + "Loading cached processed dataset at /home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a/cache-1c96c2577c929948.arrow\n" + ] + } + ], + "source": [ + "train_data = train_data.map(tokenize_and_numericalize_data, fn_kwargs={'tokenizer': tokenizer})\n", + "test_data = test_data.map(tokenize_and_numericalize_data, fn_kwargs={'tokenizer': tokenizer})" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e39e64b1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'label': 1,\n", + " 'text': 'Bromwell High is a cartoon comedy. It ran at the same time as some other programs about school life, such as \"Teachers\". My 35 years in the teaching profession lead me to believe that Bromwell High\\'s satire is much closer to reality than is \"Teachers\". The scramble to survive financially, the insightful students who can see right through their pathetic teachers\\' pomp, the pettiness of the whole situation, all remind me of the schools I knew and their students. When I saw the episode in which a student repeatedly tried to burn down the school, I immediately recalled ......... at .......... High. A classic line: INSPECTOR: I\\'m here to sack one of your teachers. STUDENT: Welcome to Bromwell High. I expect that many adults of my age think that Bromwell High is far fetched. What a pity that it isn\\'t!',\n", + " 'ids': [101,\n", + " 22953,\n", + " 2213,\n", + " 4381,\n", + " 2152,\n", + " 2003,\n", + " 1037,\n", + " 9476,\n", + " 4038,\n", + " 1012,\n", + " 2009,\n", + " 2743,\n", + " 2012,\n", + " 1996,\n", + " 2168,\n", + " 2051,\n", + " 2004,\n", + " 2070,\n", + " 2060,\n", + " 3454,\n", + " 2055,\n", + " 2082,\n", + " 2166,\n", + " 1010,\n", + " 2107,\n", + " 2004,\n", + " 1000,\n", + " 5089,\n", + " 1000,\n", + " 1012,\n", + " 2026,\n", + " 3486,\n", + " 2086,\n", + " 1999,\n", + " 1996,\n", + " 4252,\n", + " 9518,\n", + " 2599,\n", + " 2033,\n", + " 2000,\n", + " 2903,\n", + " 2008,\n", + " 22953,\n", + " 2213,\n", + " 4381,\n", + " 2152,\n", + " 1005,\n", + " 1055,\n", + " 18312,\n", + " 2003,\n", + " 2172,\n", + " 3553,\n", + " 2000,\n", + " 4507,\n", + " 2084,\n", + " 2003,\n", + " 1000,\n", + " 5089,\n", + " 1000,\n", + " 1012,\n", + " 1996,\n", + " 25740,\n", + " 2000,\n", + " 5788,\n", + " 13732,\n", + " 1010,\n", + " 1996,\n", + " 12369,\n", + " 3993,\n", + " 2493,\n", + " 2040,\n", + " 2064,\n", + " 2156,\n", + " 2157,\n", + " 2083,\n", + " 2037,\n", + " 17203,\n", + " 5089,\n", + " 1005,\n", + " 13433,\n", + " 8737,\n", + " 1010,\n", + " 1996,\n", + " 9004,\n", + " 10196,\n", + " 4757,\n", + " 1997,\n", + " 1996,\n", + " 2878,\n", + " 3663,\n", + " 1010,\n", + " 2035,\n", + " 10825,\n", + " 2033,\n", + " 1997,\n", + " 1996,\n", + " 2816,\n", + " 1045,\n", + " 2354,\n", + " 1998,\n", + " 2037,\n", + " 2493,\n", + " 1012,\n", + " 2043,\n", + " 1045,\n", + " 2387,\n", + " 1996,\n", + " 2792,\n", + " 1999,\n", + " 2029,\n", + " 1037,\n", + " 3076,\n", + " 8385,\n", + " 2699,\n", + " 2000,\n", + " 6402,\n", + " 2091,\n", + " 1996,\n", + " 2082,\n", + " 1010,\n", + " 1045,\n", + " 3202,\n", + " 7383,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 2012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 1012,\n", + " 2152,\n", + " 1012,\n", + " 1037,\n", + " 4438,\n", + " 2240,\n", + " 1024,\n", + " 7742,\n", + " 1024,\n", + " 1045,\n", + " 1005,\n", + " 1049,\n", + " 2182,\n", + " 2000,\n", + " 12803,\n", + " 2028,\n", + " 1997,\n", + " 2115,\n", + " 5089,\n", + " 1012,\n", + " 3076,\n", + " 1024,\n", + " 6160,\n", + " 2000,\n", + " 22953,\n", + " 2213,\n", + " 4381,\n", + " 2152,\n", + " 1012,\n", + " 1045,\n", + " 5987,\n", + " 2008,\n", + " 2116,\n", + " 6001,\n", + " 1997,\n", + " 2026,\n", + " 2287,\n", + " 2228,\n", + " 2008,\n", + " 22953,\n", + " 2213,\n", + " 4381,\n", + " 2152,\n", + " 2003,\n", + " 2521,\n", + " 18584,\n", + " 2098,\n", + " 1012,\n", + " 2054,\n", + " 1037,\n", + " 12063,\n", + " 2008,\n", + " 2009,\n", + " 3475,\n", + " 1005,\n", + " 1056,\n", + " 999,\n", + " 102]}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "96d87205", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "999" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tokenizer.vocab['!']" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "614d747b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'[PAD]'" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tokenizer.pad_token" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "18f18b66", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tokenizer.pad_token_id" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2a0d0a6d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tokenizer.vocab[tokenizer.pad_token]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "3cdaa10f", + "metadata": {}, + "outputs": [], + "source": [ + "pad_index = tokenizer.pad_token_id" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "8532b705", + "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-0b46d41b3a9a5f87.arrow and /home/ben/.cache/huggingface/datasets/imdb/plain_text/1.0.0/e3c66f1788a67a89c7058d97ff62b6c30531e05b549de56d3ab91891f0561f9a/cache-83b98d9279b85695.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": 18, + "id": "cc54e1eb", + "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": 19, + "id": "c7bf1626", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.predictions.bias', 'cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.bias', 'cls.seq_relationship.weight']\n", + "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", + "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n" + ] + } + ], + "source": [ + "transformer = transformers.AutoModel.from_pretrained(transformer_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "269344e7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "768" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transformer.config.hidden_size" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "01a637ac", + "metadata": {}, + "outputs": [], + "source": [ + "class Transformer(nn.Module):\n", + " def __init__(self, transformer, output_dim, freeze):\n", + " super().__init__()\n", + " self.transformer = transformer\n", + " hidden_dim = transformer.config.hidden_size\n", + " self.fc = nn.Linear(hidden_dim, output_dim)\n", + " \n", + " if freeze:\n", + " for param in self.transformer.parameters():\n", + " param.requires_grad = False\n", + " \n", + " def forward(self, ids):\n", + " # ids = [batch size, seq len]\n", + " output = self.transformer(ids, output_attentions=True)\n", + " hidden = output.last_hidden_state\n", + " # hidden = [batch size, seq len, hidden dim]\n", + " attention = output.attentions[-1]\n", + " # attention = [batch size, n heads, seq len, seq len]\n", + " cls_hidden = hidden[:,0,:]\n", + " prediction = self.fc(torch.tanh(cls_hidden))\n", + " # prediction = [batch size, output dim]\n", + " return prediction" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "ff995192", + "metadata": {}, + "outputs": [], + "source": [ + "output_dim = len(train_data['label'].unique())\n", + "freeze = False\n", + "\n", + "model = Transformer(transformer, output_dim, freeze)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "8e2f95bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The model has 109,483,778 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": 24, + "id": "d2a9f4f7", + "metadata": {}, + "outputs": [], + "source": [ + "lr = 1e-5\n", + "\n", + "optimizer = optim.Adam(model.parameters(), lr=lr)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e82c640f", + "metadata": {}, + "outputs": [], + "source": [ + "criterion = nn.CrossEntropyLoss()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "0bb2a2a4", + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "6fc62ff8", + "metadata": {}, + "outputs": [], + "source": [ + "model = model.to(device)\n", + "criterion = criterion.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "63ca51df", + "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": 29, + "id": "611063db", + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 8\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": 30, + "id": "98f54638", + "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": 31, + "id": "df0424bd", + "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": 32, + "id": "34331854", + "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": 33, + "id": "df33ac5d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training...: 100%|██████████| 2344/2344 [06:41<00:00, 5.84it/s]\n", + "evaluating...: 100%|██████████| 782/782 [00:40<00:00, 19.24it/s]\n", + "epoch: 1\n", + "train_loss: 0.249, train_acc: 0.894\n", + "valid_loss: 0.196, valid_acc: 0.925\n", + "training...: 100%|██████████| 2344/2344 [06:37<00:00, 5.89it/s]\n", + "evaluating...: 100%|██████████| 782/782 [00:40<00:00, 19.26it/s]\n", + "epoch: 2\n", + "train_loss: 0.135, train_acc: 0.950\n", + "valid_loss: 0.202, valid_acc: 0.927\n", + "training...: 100%|██████████| 2344/2344 [06:36<00:00, 5.91it/s]\n", + "evaluating...: 100%|██████████| 782/782 [00:40<00:00, 19.25it/s]\n", + "epoch: 3\n", + "train_loss: 0.067, train_acc: 0.978\n", + "valid_loss: 0.249, valid_acc: 0.929\n" + ] + } + ], + "source": [ + "n_epochs = 3\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(), 'transformer.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": 34, + "id": "8ac2a935", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "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": 35, + "id": "8796527d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "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": 36, + "id": "c9f36818", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "evaluating...: 100%|██████████| 3125/3125 [02:45<00:00, 18.89it/s]\n", + "test_loss: 0.178, test_acc: 0.932\n" + ] + } + ], + "source": [ + "model.load_state_dict(torch.load('transformer.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": 37, + "id": "fca30739", + "metadata": {}, + "outputs": [], + "source": [ + "def predict_sentiment(text, model, tokenizer, device):\n", + " ids = tokenizer(text)['input_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": 38, + "id": "bd35e378", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0, 0.9898680448532104)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "text = \"This film is terrible!\"\n", + "\n", + "predict_sentiment(text, model, tokenizer, device)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "b53900c7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 0.9934925436973572)" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "text = \"This film is great!\"\n", + "\n", + "predict_sentiment(text, model, tokenizer, device)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "ad677cd1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 0.99724280834198)" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "text = \"This film is not terrible, it's great!\"\n", + "\n", + "predict_sentiment(text, model, tokenizer, device)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "e7c35353", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0, 0.9856145977973938)" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "text = \"This film is not great, it's terrible!\"\n", + "\n", + "predict_sentiment(text, model, tokenizer, 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 +}