diff --git "a/Copie_de_08_sentiment_analysis_with_bert.ipynb" "b/Copie_de_08_sentiment_analysis_with_bert.ipynb" new file mode 100644--- /dev/null +++ "b/Copie_de_08_sentiment_analysis_with_bert.ipynb" @@ -0,0 +1,4625 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "PGnlRWvkY-2c" + }, + "source": [ + "# Sentiment Analysis with BERT\n", + "\n", + "> TL;DR In this tutorial, you'll learn how to fine-tune BERT for sentiment analysis. You'll do the required text preprocessing (special tokens, padding, and attention masks) and build a Sentiment Classifier using the amazing Transformers library by Hugging Face!\n", + "\n", + "- [Read the tutorial](https://www.curiousily.com/posts/sentiment-analysis-with-bert-and-hugging-face-using-pytorch-and-python/)\n", + "- [Run the notebook in your browser (Google Colab)](https://colab.research.google.com/drive/1PHv-IRLPCtv7oTcIGbsgZHqrB5LPvB7S)\n", + "- [Read the `Getting Things Done with Pytorch` book](https://github.com/curiousily/Getting-Things-Done-with-Pytorch)\n", + "\n", + "You'll learn how to:\n", + "\n", + "- Intuitively understand what BERT is\n", + "- Preprocess text data for BERT and build PyTorch Dataset (tokenization, attention masks, and padding)\n", + "- Use Transfer Learning to build Sentiment Classifier using the Transformers library by Hugging Face\n", + "- Evaluate the model on test data\n", + "- Predict sentiment on raw text\n", + "\n", + "Let's get started!" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 441 + }, + "id": "fH8xHMfdX974", + "outputId": "a417ae99-a1de-4683-f1bf-b86bbda8ca4e" + }, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#@title Watch the video tutorial\n", + "\n", + "from IPython.display import YouTubeVideo\n", + "YouTubeVideo('8N-nM3QW7O0', width=720, height=420)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NJ6MhJYYBCwu", + "outputId": "f07a7d16-bec0-4cdc-bb9a-630c3be37075" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wed Jun 28 17:10:17 2023 \n", + "+-----------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 525.85.12 Driver Version: 525.85.12 CUDA Version: 12.0 |\n", + "|-------------------------------+----------------------+----------------------+\n", + "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|===============================+======================+======================|\n", + "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n", + "| N/A 70C P8 11W / 70W | 0MiB / 15360MiB | 0% Default |\n", + "| | | N/A |\n", + "+-------------------------------+----------------------+----------------------+\n", + " \n", + "+-----------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=============================================================================|\n", + "| No running processes found |\n", + "+-----------------------------------------------------------------------------+\n" + ] + } + ], + "source": [ + "!nvidia-smi" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "Tbodro8Fpmwr" + }, + "source": [ + "## What is BERT?\n", + "\n", + "BERT (introduced in [this paper](https://arxiv.org/abs/1810.04805)) stands for Bidirectional Encoder Representations from Transformers. If you don't know what most of that means - you've come to the right place! Let's unpack the main ideas:\n", + "\n", + "- Bidirectional - to understand the text you're looking you'll have to look back (at the previous words) and forward (at the next words)\n", + "- Transformers - The [Attention Is All You Need](https://arxiv.org/abs/1706.03762) paper presented the Transformer model. The Transformer reads entire sequences of tokens at once. In a sense, the model is non-directional, while LSTMs read sequentially (left-to-right or right-to-left). The attention mechanism allows for learning contextual relations between words (e.g. `his` in a sentence refers to Jim).\n", + "- (Pre-trained) contextualized word embeddings - [The ELMO paper](https://arxiv.org/abs/1802.05365v2) introduced a way to encode words based on their meaning/context. Nails has multiple meanings - fingernails and metal nails.\n", + "\n", + "BERT was trained by masking 15% of the tokens with the goal to guess them. An additional objective was to predict the next sentence. Let's look at examples of these tasks:\n", + "\n", + "### Masked Language Modeling (Masked LM)\n", + "\n", + "The objective of this task is to guess the masked tokens. Let's look at an example, and try to not make it harder than it has to be:\n", + "\n", + "That's `[mask]` she `[mask]` -> That's what she said\n", + "\n", + "### Next Sentence Prediction (NSP)\n", + "\n", + "Given a pair of two sentences, the task is to say whether or not the second follows the first (binary classification). Let's continue with the example:\n", + "\n", + "*Input* = `[CLS]` That's `[mask]` she `[mask]`. [SEP] Hahaha, nice! [SEP]\n", + "\n", + "*Label* = *IsNext*\n", + "\n", + "*Input* = `[CLS]` That's `[mask]` she `[mask]`. [SEP] Dwight, you ignorant `[mask]`! [SEP]\n", + "\n", + "*Label* = *NotNext*\n", + "\n", + "The training corpus was comprised of two entries: [Toronto Book Corpus](https://arxiv.org/abs/1506.06724) (800M words) and English Wikipedia (2,500M words). While the original Transformer has an encoder (for reading the input) and a decoder (that makes the prediction), BERT uses only the decoder.\n", + "\n", + "BERT is simply a pre-trained stack of Transformer Encoders. How many Encoders? We have two versions - with 12 (BERT base) and 24 (BERT Large).\n", + "\n", + "### Is This Thing Useful in Practice?\n", + "\n", + "The BERT paper was released along with [the source code](https://github.com/google-research/bert) and pre-trained models.\n", + "\n", + "The best part is that you can do Transfer Learning (thanks to the ideas from OpenAI Transformer) with BERT for many NLP tasks - Classification, Question Answering, Entity Recognition, etc. You can train with small amounts of data and achieve great performance!" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "wmj22-TcZMef" + }, + "source": [ + "## Setup\n", + "\n", + "We'll need [the Transformers library](https://huggingface.co/transformers/) by Hugging Face:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Kj_7Tz0-pK69", + "outputId": "5b72004f-c34c-4fc2-a5fe-51b52efc990b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/55.5 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.5/55.5 kB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/1.6 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.6/1.6 MB\u001b[0m \u001b[31m61.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h" + ] + } + ], + "source": [ + "!pip install -q -U watermark" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Jjsbi1u3QFEM", + "outputId": "17c7203e-853a-4b34-ad04-280ea83da05b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.2/7.2 MB\u001b[0m \u001b[31m43.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m236.8/236.8 kB\u001b[0m \u001b[31m24.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.8/7.8 MB\u001b[0m \u001b[31m76.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m81.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h" + ] + } + ], + "source": [ + "!pip install -qq transformers" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AJqoaFpVpoM8", + "outputId": "22e292c3-8154-483b-ce04-b16e2f52027f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Python implementation: CPython\n", + "Python version : 3.10.12\n", + "IPython version : 7.34.0\n", + "\n", + "numpy : 1.22.4\n", + "pandas : 1.5.3\n", + "torch : 2.0.1+cu118\n", + "transformers: 4.30.2\n", + "\n" + ] + } + ], + "source": [ + "%reload_ext watermark\n", + "%watermark -v -p numpy,pandas,torch,transformers" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "w68CZpOwFoly", + "outputId": "6d9115dd-96e7-4244-b6a9-f7238b1da4c3" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "device(type='cuda', index=0)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#@title Setup & Config\n", + "import transformers\n", + "from transformers import BertModel, BertTokenizer, AdamW, get_linear_schedule_with_warmup\n", + "import torch\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "from pylab import rcParams\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import rc\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import confusion_matrix, classification_report\n", + "from collections import defaultdict\n", + "from textwrap import wrap\n", + "\n", + "from torch import nn, optim\n", + "from torch.utils.data import Dataset, DataLoader\n", + "import torch.nn.functional as F\n", + "\n", + "%matplotlib inline\n", + "%config InlineBackend.figure_format='retina'\n", + "\n", + "sns.set(style='whitegrid', palette='muted', font_scale=1.2)\n", + "\n", + "HAPPY_COLORS_PALETTE = [\"#01BEFE\", \"#FFDD00\", \"#FF7D00\", \"#FF006D\", \"#ADFF02\", \"#8F00FF\"]\n", + "\n", + "sns.set_palette(sns.color_palette(HAPPY_COLORS_PALETTE))\n", + "\n", + "rcParams['figure.figsize'] = 12, 8\n", + "\n", + "RANDOM_SEED = 42\n", + "np.random.seed(RANDOM_SEED)\n", + "torch.manual_seed(RANDOM_SEED)\n", + "\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "device" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "ufzPdoTtNikq" + }, + "source": [ + "## Data Exploration\n", + "\n", + "We'll load the Google Play app reviews dataset, that we've put together in the previous part:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SgPRhuMzi9ot", + "outputId": "68b8fe7b-942a-48d7-f45e-67f108f15872" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/gdown/cli.py:121: FutureWarning: Option `--id` was deprecated in version 4.3.1 and will be removed in 5.0. You don't need to pass it anymore to use a file ID.\n", + " warnings.warn(\n", + "Downloading...\n", + "From: https://drive.google.com/uc?id=1S6qMioqPJjyBLpLVz4gmRTnJHnjitnuV\n", + "To: /content/apps.csv\n", + "100% 134k/134k [00:00<00:00, 91.6MB/s]\n", + "/usr/local/lib/python3.10/dist-packages/gdown/cli.py:121: FutureWarning: Option `--id` was deprecated in version 4.3.1 and will be removed in 5.0. You don't need to pass it anymore to use a file ID.\n", + " warnings.warn(\n", + "Downloading...\n", + "From: https://drive.google.com/uc?id=1zdmewp7ayS4js4VtrJEHzAheSW-5NBZv\n", + "To: /content/reviews.csv\n", + "100% 7.17M/7.17M [00:00<00:00, 138MB/s]\n" + ] + } + ], + "source": [ + "!gdown --id 1S6qMioqPJjyBLpLVz4gmRTnJHnjitnuV\n", + "!gdown --id 1zdmewp7ayS4js4VtrJEHzAheSW-5NBZv" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "mUKLyKc7I6Qp", + "outputId": "9810e8b3-7979-484c-eff1-e67f70460a3b" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
userNameuserImagecontentscorethumbsUpCountreviewCreatedVersionatreplyContentrepliedAtsortOrderappId
0Andrew Thomashttps://lh3.googleusercontent.com/a-/AOh14GiHd...Update: After getting a response from the deve...1214.17.0.32020-04-05 22:25:57According to our TOS, and the term you have ag...2020-04-05 15:10:24most_relevantcom.anydo
1Craig Haineshttps://lh3.googleusercontent.com/-hoe0kwSJgPQ...Used it for a fair amount of time without any ...1114.17.0.32020-04-04 13:40:01It sounds like you logged in with a different ...2020-04-05 15:11:35most_relevantcom.anydo
2steven adkinshttps://lh3.googleusercontent.com/a-/AOh14GiXw...Your app sucks now!!!!! Used to be good but no...1174.17.0.32020-04-01 16:18:13This sounds odd! We are not aware of any issue...2020-04-02 16:05:56most_relevantcom.anydo
3Lars Panzerbjørnhttps://lh3.googleusercontent.com/a-/AOh14Gg-h...It seems OK, but very basic. Recurring tasks n...11924.17.0.22020-03-12 08:17:34We do offer this option as part of the Advance...2020-03-15 06:20:13most_relevantcom.anydo
4Scott Prewitthttps://lh3.googleusercontent.com/-K-X1-YsVd6U...Absolutely worthless. This app runs a prohibit...1424.17.0.22020-03-14 17:41:01We're sorry you feel this way! 90% of the app ...2020-03-15 23:45:51most_relevantcom.anydo
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + " userName userImage \\\n", + "0 Andrew Thomas https://lh3.googleusercontent.com/a-/AOh14GiHd... \n", + "1 Craig Haines https://lh3.googleusercontent.com/-hoe0kwSJgPQ... \n", + "2 steven adkins https://lh3.googleusercontent.com/a-/AOh14GiXw... \n", + "3 Lars Panzerbjørn https://lh3.googleusercontent.com/a-/AOh14Gg-h... \n", + "4 Scott Prewitt https://lh3.googleusercontent.com/-K-X1-YsVd6U... \n", + "\n", + " content score thumbsUpCount \\\n", + "0 Update: After getting a response from the deve... 1 21 \n", + "1 Used it for a fair amount of time without any ... 1 11 \n", + "2 Your app sucks now!!!!! Used to be good but no... 1 17 \n", + "3 It seems OK, but very basic. Recurring tasks n... 1 192 \n", + "4 Absolutely worthless. This app runs a prohibit... 1 42 \n", + "\n", + " reviewCreatedVersion at \\\n", + "0 4.17.0.3 2020-04-05 22:25:57 \n", + "1 4.17.0.3 2020-04-04 13:40:01 \n", + "2 4.17.0.3 2020-04-01 16:18:13 \n", + "3 4.17.0.2 2020-03-12 08:17:34 \n", + "4 4.17.0.2 2020-03-14 17:41:01 \n", + "\n", + " replyContent repliedAt \\\n", + "0 According to our TOS, and the term you have ag... 2020-04-05 15:10:24 \n", + "1 It sounds like you logged in with a different ... 2020-04-05 15:11:35 \n", + "2 This sounds odd! We are not aware of any issue... 2020-04-02 16:05:56 \n", + "3 We do offer this option as part of the Advance... 2020-03-15 06:20:13 \n", + "4 We're sorry you feel this way! 90% of the app ... 2020-03-15 23:45:51 \n", + "\n", + " sortOrder appId \n", + "0 most_relevant com.anydo \n", + "1 most_relevant com.anydo \n", + "2 most_relevant com.anydo \n", + "3 most_relevant com.anydo \n", + "4 most_relevant com.anydo " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.read_csv(\"reviews.csv\")\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dB2jE6am7Dpo", + "outputId": "88d5bdf9-a95d-4f2f-b712-7385a3532aae" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(15746, 11)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.shape" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "TWqVNHJbn10l" + }, + "source": [ + "We have about 16k examples. Let's check for missing values:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VA_wGSLQLKCh", + "outputId": "244a9422-e781-4d45-d9f3-c0bb4c5ce1b9" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 15746 entries, 0 to 15745\n", + "Data columns (total 11 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 userName 15746 non-null object\n", + " 1 userImage 15746 non-null object\n", + " 2 content 15746 non-null object\n", + " 3 score 15746 non-null int64 \n", + " 4 thumbsUpCount 15746 non-null int64 \n", + " 5 reviewCreatedVersion 13533 non-null object\n", + " 6 at 15746 non-null object\n", + " 7 replyContent 7367 non-null object\n", + " 8 repliedAt 7367 non-null object\n", + " 9 sortOrder 15746 non-null object\n", + " 10 appId 15746 non-null object\n", + "dtypes: int64(2), object(9)\n", + "memory usage: 1.3+ MB\n" + ] + } + ], + "source": [ + "df.info()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "H3cL_1qVn_6h" + }, + "source": [ + "Great, no missing values in the score and review texts! Do we have class imbalance?" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QzqfEbgjo5p8", + "outputId": "0a0c490f-f216-44a6-a6a6-3f5685b995c3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 1\n", + "1 1\n", + "2 1\n", + "3 1\n", + "4 1\n", + " ..\n", + "15741 5\n", + "15742 5\n", + "15743 5\n", + "15744 5\n", + "15745 5\n", + "Name: score, Length: 15746, dtype: int64\n" + ] + } + ], + "source": [ + "print(df.score)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 710 + }, + "id": "Wwh_rW4Efhs3", + "outputId": "099f692b-9151-42ac-c30d-a5fba9f7abf4" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 693, + "width": 1035 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.countplot(x='score', data = df)\n", + "plt.xlabel('review score');" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "nZM0GKviobjM" + }, + "source": [ + "That's hugely imbalanced, but it's okay. We're going to convert the dataset into negative, neutral and positive sentiment:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "ei0xmdi1Chp0" + }, + "outputs": [], + "source": [ + "def to_sentiment(rating):\n", + " rating = int(rating)\n", + " if rating <= 2:\n", + " return 0\n", + " elif rating == 3:\n", + " return 1\n", + " else:\n", + " return 2\n", + "\n", + "df['sentiment'] = df.score.apply(to_sentiment)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "V-155O-SFSqE" + }, + "outputs": [], + "source": [ + "class_names = ['negative', 'neutral', 'positive']" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KM69l8w6oM-s", + "outputId": "49cc4503-ca75-4bcc-eb14-c214319265ff" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 0\n", + "1 0\n", + "2 0\n", + "3 0\n", + "4 0\n", + " ..\n", + "15741 2\n", + "15742 2\n", + "15743 2\n", + "15744 2\n", + "15745 2\n", + "Name: sentiment, Length: 15746, dtype: int64\n" + ] + } + ], + "source": [ + "print(df.sentiment)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 710 + }, + "id": "y3tY3ECJDPaz", + "outputId": "2a4003f3-c32e-43ac-9ea1-17af9fb4b707" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 693, + "width": 1035 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = sns.countplot(x='sentiment', data = df)\n", + "plt.xlabel('review sentiment')\n", + "ax.set_xticklabels(class_names);" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "tOssB4CKnAX2" + }, + "source": [ + "The balance was (mostly) restored." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "9aHyGuTFgyPO" + }, + "source": [ + "## Data Preprocessing\n", + "\n", + "You might already know that Machine Learning models don't work with raw text. You need to convert text to numbers (of some sort). BERT requires even more attention (good one, right?). Here are the requirements:\n", + "\n", + "- Add special tokens to separate sentences and do classification\n", + "- Pass sequences of constant length (introduce padding)\n", + "- Create array of 0s (pad token) and 1s (real token) called *attention mask*\n", + "\n", + "The Transformers library provides (you've guessed it) a wide variety of Transformer models (including BERT). It works with TensorFlow and PyTorch! It also includes prebuild tokenizers that do the heavy lifting for us!\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "E7Mj-0ne--5t" + }, + "outputs": [], + "source": [ + "PRE_TRAINED_MODEL_NAME = 'bert-base-cased'" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "fMSr7C-F_sey" + }, + "source": [ + "> You can use a cased and uncased version of BERT and tokenizer. I've experimented with both. The cased version works better. Intuitively, that makes sense, since \"BAD\" might convey more sentiment than \"bad\"." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "NiLb-ltM-ZRz" + }, + "source": [ + "Let's load a pre-trained [BertTokenizer](https://huggingface.co/transformers/model_doc/bert.html#berttokenizer):" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 113, + "referenced_widgets": [ + "5968e9e39f1b466dbacf6cece45d7ee2", + "5b828d7f8bd747619cddc4b28d1d5383", + "c8135ded16e24ec1bb3ab6b26aa1e01d", + "cdbbeea71cf1478a93df34da79abb1e1", + "acd7b4228d984976b0aa16eda3a74e2a", + "a5aaec5b93e04200bf59024dd6497283", + "300407d9c525447cbc2223a30c17deac", + "f59117f9fb414783b339226908a3d32f", + "6f54d4cafe384c67a459065119006b4e", + "fabf9140688d49d99dd799a2b364ec27", + "3dac470fee3c4f9eb8bebb1992c19688", + "c5c2e50239a44566b376e233b36e1220", + "841966fa79134f75a1fed6db97f34dc9", + "5d54820c46e44b54aaeb002e1054d495", + "30cc769f98f9447eae28e7060c943d6f", + "a7733a2a0059411db9f7edb5e4dd1a92", + "62b3f7375b0243239eed24bd9b342939", + "c23dcfab453442b4b41a90c2f096302d", + "34bbd61a5c844010bbd47539fcf2abc6", + "b389a069f9aa433b97f81043b5dc573a", + "ce8cb11f151b45a69431a11d0789bb93", + "6652821599284ab3bcb86f8dfee60da5", + "7fb2d01f05914c7b97e58dc877c67c62", + "3ed9609b1b804e079e548c6e87410911", + "7022e627b3934baababd16449a13ab16", + "b376b41872cd490e8bcd7d64db66941a", + "0c85e11e27d6484ea31b766aecf0a06e", + "5f9e170e18d8413ea9811e3cd501fcb7", + "c65deba3b9c1414eb489317f2fb18b12", + "b7336a3c03804a1889bd4539e8574100", + "44b33027973c41d69730f66aeef675ef", + "9ff5213e4251453b92de1eeeb9c7acb6", + "0a3631a4ad9c49909c63b9cabdd926d8" + ] + }, + "id": "H3AfJSZ8NNLF", + "outputId": "c9d366bd-dc31-452e-bcb4-c9cff5c3898e" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5968e9e39f1b466dbacf6cece45d7ee2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading (…)solve/main/vocab.txt: 0%| | 0.00/213k [00:00:1: UserWarning: \n", + "\n", + "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n", + "\n", + "Please adapt your code to use either `displot` (a figure-level function with\n", + "similar flexibility) or `histplot` (an axes-level function for histograms).\n", + "\n", + "For a guide to updating your code to use the new functions, please see\n", + "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n", + "\n", + " sns.distplot(token_lens)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 693, + "width": 1052 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(token_lens)\n", + "plt.xlim([0, 256]);\n", + "plt.xlabel('Token count');" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "oW6ajl30t6du" + }, + "source": [ + "Most of the reviews seem to contain less than 128 tokens, but we'll be on the safe side and choose a maximum length of 160." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "id": "t7xSmJtLuoxW" + }, + "outputs": [], + "source": [ + "MAX_LEN = 160" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "XvvcoU6nurHy" + }, + "source": [ + "We have all building blocks required to create a PyTorch dataset. Let's do it:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "id": "E2BPgRJ7YBK0" + }, + "outputs": [], + "source": [ + "class GPReviewDataset(Dataset):\n", + "\n", + " def __init__(self, reviews, targets, tokenizer, max_len):\n", + " self.reviews = reviews\n", + " self.targets = targets\n", + " self.tokenizer = tokenizer\n", + " self.max_len = max_len\n", + "\n", + " def __len__(self):\n", + " return len(self.reviews)\n", + "\n", + " def __getitem__(self, item):\n", + " review = str(self.reviews[item])\n", + " target = self.targets[item]\n", + "\n", + " encoding = self.tokenizer.encode_plus(\n", + " review,\n", + " add_special_tokens=True,\n", + " max_length=self.max_len,\n", + " return_token_type_ids=False,\n", + " pad_to_max_length=True,\n", + " return_attention_mask=True,\n", + " return_tensors='pt',\n", + " )\n", + "\n", + " return {\n", + " 'review_text': review,\n", + " 'input_ids': encoding['input_ids'].flatten(),\n", + " 'attention_mask': encoding['attention_mask'].flatten(),\n", + " 'targets': torch.tensor(target, dtype=torch.long)\n", + " }" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "x2uwsvCYqDJK" + }, + "source": [ + "The tokenizer is doing most of the heavy lifting for us. We also return the review texts, so it'll be easier to evaluate the predictions from our model. Let's split the data:" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "id": "B-vWzoo81dvO" + }, + "outputs": [], + "source": [ + "df_train, df_test = train_test_split(df, test_size=0.1, random_state=RANDOM_SEED)\n", + "df_val, df_test = train_test_split(df_test, test_size=0.5, random_state=RANDOM_SEED)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xz3ZOQXVPCwh", + "outputId": "fd7343ac-5f64-4fab-8694-4684bfdd1ff5" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((14171, 12), (787, 12), (788, 12))" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_train.shape, df_val.shape, df_test.shape" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "J4tQ1x-vqNab" + }, + "source": [ + "We also need to create a couple of data loaders. Here's a helper function to do it:" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "id": "KEGqcvkuOuTX" + }, + "outputs": [], + "source": [ + "def create_data_loader(df, tokenizer, max_len, batch_size):\n", + " ds = GPReviewDataset(\n", + " reviews=df.content.to_numpy(),\n", + " targets=df.sentiment.to_numpy(),\n", + " tokenizer=tokenizer,\n", + " max_len=max_len\n", + " )\n", + "\n", + " return DataLoader(\n", + " ds,\n", + " batch_size=batch_size,\n", + " num_workers=4\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vODDxMKsPHqI", + "outputId": "b177c19e-503c-4af3-e707-afa365afe0a0" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 4 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", + " warnings.warn(_create_warning_msg(\n" + ] + } + ], + "source": [ + "BATCH_SIZE = 16\n", + "\n", + "train_data_loader = create_data_loader(df_train, tokenizer, MAX_LEN, BATCH_SIZE)\n", + "val_data_loader = create_data_loader(df_val, tokenizer, MAX_LEN, BATCH_SIZE)\n", + "test_data_loader = create_data_loader(df_test, tokenizer, MAX_LEN, BATCH_SIZE)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "A6dlOptwqlhF" + }, + "source": [ + "Let's have a look at an example batch from our training data loader:" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Y93ldSN47FeT", + "outputId": "d21fc9dd-c4b7-4ed3-c312-82275db23d1c" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "dict_keys(['review_text', 'input_ids', 'attention_mask', 'targets'])" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = next(iter(train_data_loader))\n", + "data.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IdU4YVqb7N8M", + "outputId": "d8b1d7db-e725-4f87-9702-42c59f8e9c0f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([16, 160])\n", + "torch.Size([16, 160])\n", + "torch.Size([16])\n" + ] + } + ], + "source": [ + "print(data['input_ids'].shape)\n", + "print(data['attention_mask'].shape)\n", + "print(data['targets'].shape)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "H63Y-TjyRC7S" + }, + "source": [ + "## Sentiment Classification with BERT and Hugging Face" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 121, + "referenced_widgets": [ + "8432242e44044eb48b132453b519947e", + "924c0e3b25054a68b37090823bd07a96", + "fa802e4f8a3c4d20b0fabeaeaab7ee18", + "d48ccf851db0492d805f2ac9342839b4", + "7532b67ceaf74f6c8263ae7185a7b04d", + "fdd1cbca5dd74a7e9c91d15cb6abd7ce", + "b3940458f5134c4a8a16432113ef2561", + "648c9e36f406464b8a5be4d19a69a4e7", + "a364d729ab9342dfa53bb39e8f068688", + "e8592109366842438c9295552aac501a", + "90ececf282a94f6ca593d361ad6d9212" + ] + }, + "id": "0P41FayISNRI", + "outputId": "f189569f-338e-4a1f-dbfc-fd14e876918a" + }, + "outputs": [], + "source": [ + "from transformers import AutoModelForSequenceClassification\n", + "\n", + "model = AutoModelForSequenceClassification.from_pretrained(\n", + " 'bert-base-cased',\n", + " num_labels=len(class_names),\n", + " output_attentions=False,\n", + " output_hidden_states=False\n", + ")\n", + "\n", + "last_hidden_state = model.bert(\n", + " input_ids=encoding['input_ids'],\n", + " attention_mask=encoding['attention_mask']\n", + ").last_hidden_state\n", + "\n", + "last_hidden_state.shape\n", + "\n", + "pooled_output = model.bert(\n", + " input_ids=encoding['input_ids'],\n", + " attention_mask=encoding['attention_mask']\n", + ").pooler_output\n", + "\n", + "pooled_output.shape" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "0o_NiS3WgOFf" + }, + "source": [ + "We can use all of this knowledge to create a classifier that uses the BERT model:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "id": "m_mRflxPl32F" + }, + "outputs": [], + "source": [ + "class SentimentClassifier(nn.Module):\n", + "\n", + " def __init__(self, n_classes):\n", + " super(SentimentClassifier, self).__init__()\n", + " self.bert = BertModel.from_pretrained(PRE_TRAINED_MODEL_NAME)\n", + " self.drop = nn.Dropout(p=0.3)\n", + " self.out = nn.Linear(self.bert.config.hidden_size, n_classes)\n", + "\n", + " def forward(self, input_ids, attention_mask):\n", + " returned = self.bert(\n", + " input_ids=input_ids,\n", + " attention_mask=attention_mask\n", + " )\n", + " pooled_output = returned[\"pooler_output\"]\n", + " output = self.drop(pooled_output)\n", + " return self.out(output)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "UJg8m3NQJahc" + }, + "source": [ + "Our classifier delegates most of the heavy lifting to the BertModel. We use a dropout layer for some regularization and a fully-connected layer for our output. Note that we're returning the raw output of the last layer since that is required for the cross-entropy loss function in PyTorch to work.\n", + "\n", + "This should work like any other PyTorch model. Let's create an instance and move it to the GPU:" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "i0yQnuSFsjDp", + "outputId": "d404ee38-b875-4e30-b85a-30ea0fef33be" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of the model checkpoint at bert-base-cased were not used when initializing BertModel: ['cls.predictions.transform.dense.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.bias', 'cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.bias']\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": [ + "model = SentimentClassifier(len(class_names))\n", + "model = model.to(device)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "VCPCFDLlKIQd" + }, + "source": [ + "We'll move the example batch of our training data to the GPU:" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "mz7p__CqdaMO", + "outputId": "bedb8633-6ab1-47f1-ec51-eb2b76d2ad5e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([16, 160])\n", + "torch.Size([16, 160])\n" + ] + } + ], + "source": [ + "input_ids = data['input_ids'].to(device)\n", + "attention_mask = data['attention_mask'].to(device)\n", + "\n", + "print(input_ids.shape) # batch size x seq length\n", + "print(attention_mask.shape) # batch size x seq length" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "Hr1EgkEtKOIB" + }, + "source": [ + "To get the predicted probabilities from our trained model, we'll apply the softmax function to the outputs:" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "2rTCj46Zamry", + "outputId": "dc98bf73-9918-46c0-dd2a-9fe6a5e3b996" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[0.2332, 0.4717, 0.2951],\n", + " [0.2219, 0.3612, 0.4168],\n", + " [0.3589, 0.2427, 0.3984],\n", + " [0.2221, 0.3218, 0.4561],\n", + " [0.5762, 0.2056, 0.2181],\n", + " [0.2249, 0.4422, 0.3329],\n", + " [0.2750, 0.3181, 0.4069],\n", + " [0.3732, 0.2454, 0.3813],\n", + " [0.3927, 0.1892, 0.4181],\n", + " [0.3349, 0.1948, 0.4703],\n", + " [0.3043, 0.2263, 0.4695],\n", + " [0.3710, 0.1894, 0.4396],\n", + " [0.2090, 0.4449, 0.3462],\n", + " [0.3396, 0.2594, 0.4010],\n", + " [0.3456, 0.2260, 0.4284],\n", + " [0.1500, 0.3302, 0.5198]], device='cuda:0', grad_fn=)" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "F.softmax(model(input_ids, attention_mask), dim=1)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "g9xikRdtRN1N" + }, + "source": [ + "### Training" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "76g7FV85H-T8" + }, + "source": [ + "To reproduce the training procedure from the BERT paper, we'll use the [AdamW](https://huggingface.co/transformers/main_classes/optimizer_schedules.html#adamw) optimizer provided by Hugging Face. It corrects weight decay, so it's similar to the original paper. We'll also use a linear scheduler with no warmup steps:" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5v-ArJ2fCCcU", + "outputId": "5ac88e1a-670a-4d50-d21c-0d0874d1b649" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/optimization.py:411: FutureWarning: This implementation of AdamW is deprecated and will be removed in a future version. Use the PyTorch implementation torch.optim.AdamW instead, or set `no_deprecation_warning=True` to disable this warning\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "EPOCHS = 6\n", + "\n", + "optimizer = AdamW(model.parameters(), lr=2e-5, correct_bias=False)\n", + "total_steps = len(train_data_loader) * EPOCHS\n", + "\n", + "scheduler = get_linear_schedule_with_warmup(\n", + " optimizer,\n", + " num_warmup_steps=0,\n", + " num_training_steps=total_steps\n", + ")\n", + "\n", + "loss_fn = nn.CrossEntropyLoss().to(device)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "A8522g7JIu5J" + }, + "source": [ + "How do we come up with all hyperparameters? The BERT authors have some recommendations for fine-tuning:\n", + "\n", + "- Batch size: 16, 32\n", + "- Learning rate (Adam): 5e-5, 3e-5, 2e-5\n", + "- Number of epochs: 2, 3, 4\n", + "\n", + "We're going to ignore the number of epochs recommendation but stick with the rest. Note that increasing the batch size reduces the training time significantly, but gives you lower accuracy.\n", + "\n", + "Let's continue with writing a helper function for training our model for one epoch:" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "id": "bzl9UhuNx1_Q" + }, + "outputs": [], + "source": [ + "def train_epoch(\n", + " model,\n", + " data_loader,\n", + " loss_fn,\n", + " optimizer,\n", + " device,\n", + " scheduler,\n", + " n_examples\n", + "):\n", + " model = model.train()\n", + "\n", + " losses = []\n", + " correct_predictions = 0\n", + "\n", + " for d in data_loader:\n", + " input_ids = d[\"input_ids\"].to(device)\n", + " attention_mask = d[\"attention_mask\"].to(device)\n", + " targets = d[\"targets\"].to(device)\n", + "\n", + " outputs = model(\n", + " input_ids=input_ids,\n", + " attention_mask=attention_mask\n", + " )\n", + "\n", + " _, preds = torch.max(outputs, dim=1)\n", + " loss = loss_fn(outputs, targets)\n", + "\n", + " correct_predictions += torch.sum(preds == targets)\n", + " losses.append(loss.item())\n", + "\n", + " loss.backward()\n", + " nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n", + " optimizer.step()\n", + " scheduler.step()\n", + " optimizer.zero_grad()\n", + "\n", + " return correct_predictions.double() / n_examples, np.mean(losses)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "E4PniYIte0fr" + }, + "source": [ + "Training the model should look familiar, except for two things. The scheduler gets called every time a batch is fed to the model. We're avoiding exploding gradients by clipping the gradients of the model using [clip_grad_norm_](https://pytorch.org/docs/stable/nn.html#clip-grad-norm).\n", + "\n", + "Let's write another one that helps us evaluate the model on a given data loader:" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "id": "CXeRorVGIKre" + }, + "outputs": [], + "source": [ + "def eval_model(model, data_loader, loss_fn, device, n_examples):\n", + " model = model.eval()\n", + "\n", + " losses = []\n", + " correct_predictions = 0\n", + "\n", + " with torch.no_grad():\n", + " for d in data_loader:\n", + " input_ids = d[\"input_ids\"].to(device)\n", + " attention_mask = d[\"attention_mask\"].to(device)\n", + " targets = d[\"targets\"].to(device)\n", + "\n", + " outputs = model(\n", + " input_ids=input_ids,\n", + " attention_mask=attention_mask\n", + " )\n", + " _, preds = torch.max(outputs, dim=1)\n", + "\n", + " loss = loss_fn(outputs, targets)\n", + "\n", + " correct_predictions += torch.sum(preds == targets)\n", + " losses.append(loss.item())\n", + "\n", + " return correct_predictions.double() / n_examples, np.mean(losses)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "a_rdSDBHhhCh" + }, + "source": [ + "Using those two, we can write our training loop. We'll also store the training history:" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1zhHoFNsxufs", + "outputId": "fa239d8b-385a-40d1-cd45-d05a6494a388" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/6\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train loss 0.7357264192392272 accuracy 0.6690424105567709\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Val loss 0.559217081964016 accuracy 0.7789072426937739\n", + "\n", + "Epoch 2/6\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train loss 0.42908171780878346 accuracy 0.8358619716322067\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Val loss 0.5046901363134384 accuracy 0.8373570520965693\n", + "\n", + "Epoch 3/6\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train loss 0.2530873617710247 accuracy 0.9162373862112766\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Val loss 0.6362524032965302 accuracy 0.8398983481575604\n", + "\n", + "Epoch 4/6\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train loss 0.16919020543878258 accuracy 0.9513090113612307\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Val loss 0.6386195559287444 accuracy 0.8640406607369759\n", + "\n", + "Epoch 5/6\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train loss 0.11795092619438897 accuracy 0.9676099075576883\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Val loss 0.7068283748999238 accuracy 0.866581956797967\n", + "\n", + "Epoch 6/6\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train loss 0.08801285981362382 accuracy 0.9757956389810176\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Val loss 0.7396833367331419 accuracy 0.866581956797967\n", + "\n", + "CPU times: user 37min 33s, sys: 22.2 s, total: 37min 55s\n", + "Wall time: 38min 45s\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "history = defaultdict(list)\n", + "best_accuracy = 0\n", + "\n", + "for epoch in range(EPOCHS):\n", + "\n", + " print(f'Epoch {epoch + 1}/{EPOCHS}')\n", + " print('-' * 10)\n", + "\n", + " train_acc, train_loss = train_epoch(\n", + " model,\n", + " train_data_loader,\n", + " loss_fn,\n", + " optimizer,\n", + " device,\n", + " scheduler,\n", + " len(df_train)\n", + " )\n", + "\n", + " print(f'Train loss {train_loss} accuracy {train_acc}')\n", + "\n", + " val_acc, val_loss = eval_model(\n", + " model,\n", + " val_data_loader,\n", + " loss_fn,\n", + " device,\n", + " len(df_val)\n", + " )\n", + "\n", + " print(f'Val loss {val_loss} accuracy {val_acc}')\n", + " print()\n", + "\n", + " history['train_acc'].append(train_acc)\n", + " history['train_loss'].append(train_loss)\n", + " history['val_acc'].append(val_acc)\n", + " history['val_loss'].append(val_loss)\n", + "\n", + " if val_acc > best_accuracy:\n", + " torch.save(model.state_dict(), 'best_model_state.bin')\n", + " best_accuracy = val_acc" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "4r8-5zWsiVur" + }, + "source": [ + "Note that we're storing the state of the best model, indicated by the highest validation accuracy." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "wLQf52c7fbzr" + }, + "source": [ + "Whoo, this took some time! We can look at the training vs validation accuracy:" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DX8VC8xiKaX-", + "outputId": "6a3e7fe5-0865-42b7-cc89-5d93d0cf1e15" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[tensor(0.6690, device='cuda:0', dtype=torch.float64), tensor(0.8359, device='cuda:0', dtype=torch.float64), tensor(0.9162, device='cuda:0', dtype=torch.float64), tensor(0.9513, device='cuda:0', dtype=torch.float64), tensor(0.9676, device='cuda:0', dtype=torch.float64), tensor(0.9758, device='cuda:0', dtype=torch.float64)]\n" + ] + } + ], + "source": [ + "print(history['train_acc'])" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "t9hOVE-XO74-", + "outputId": "557e727d-9ab5-4280-a08a-2c877a3dff67" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[array(0.66904241),\n", + " array(0.83586197),\n", + " array(0.91623739),\n", + " array(0.95130901),\n", + " array(0.96760991),\n", + " array(0.97579564)]" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_of_train_accuracy= [t.cpu().numpy() for t in history['train_acc']]\n", + "list_of_train_accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dZPHZf3gPccd", + "outputId": "807f278a-aa9e-4ecb-d9f7-d4a611990345" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[tensor(0.7789, device='cuda:0', dtype=torch.float64), tensor(0.8374, device='cuda:0', dtype=torch.float64), tensor(0.8399, device='cuda:0', dtype=torch.float64), tensor(0.8640, device='cuda:0', dtype=torch.float64), tensor(0.8666, device='cuda:0', dtype=torch.float64), tensor(0.8666, device='cuda:0', dtype=torch.float64)]\n" + ] + } + ], + "source": [ + "print(history['val_acc'])" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "G8HIB1IaPP3x", + "outputId": "fcf6ac92-a94f-40e9-d77c-6551058a48e6" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[array(0.77890724),\n", + " array(0.83735705),\n", + " array(0.83989835),\n", + " array(0.86404066),\n", + " array(0.86658196),\n", + " array(0.86658196)]" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_of_val_accuracy= [t.cpu().numpy() for t in history['val_acc']]\n", + "list_of_val_accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 734 + }, + "id": "-FWG7kBm372V", + "outputId": "e05f378b-3b4e-4747-9b3b-d9c55bafbe1e" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 717, + "width": 1017 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(list_of_train_accuracy, label='train accuracy')\n", + "plt.plot(list_of_val_accuracy, label='validation accuracy')\n", + "\n", + "plt.title('Training history')\n", + "plt.ylabel('Accuracy')\n", + "plt.xlabel('Epoch')\n", + "plt.legend()\n", + "plt.ylim([0, 1]);" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "ZsHqkLAuf8pv" + }, + "source": [ + "The training accuracy starts to approach 100% after 10 epochs or so. You might try to fine-tune the parameters a bit more, but this will be good enough for us.\n", + "\n", + "Don't want to wait? Uncomment the next cell to download my pre-trained model:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zoGUH8VZ-pPQ" + }, + "outputs": [], + "source": [ + "# !gdown --id 1V8itWtowCYnb2Bc9KlK9SxGff9WwmogA\n", + "\n", + "# model = SentimentClassifier(len(class_names))\n", + "# model.load_state_dict(torch.load('best_model_state.bin'))\n", + "# model = model.to(device)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "U3HZb3NWFtFf" + }, + "source": [ + "## Evaluation\n", + "\n", + "So how good is our model on predicting sentiment? Let's start by calculating the accuracy on the test data:" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jS3gJ_qBEljD", + "outputId": "67e6e276-fd88-4467-f3cb-270bdfa253fa" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 4 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", + " warnings.warn(_create_warning_msg(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Test Accuracy : 0.8781725888324873\n" + ] + } + ], + "source": [ + "test_acc, _ = eval_model(\n", + " model,\n", + " test_data_loader,\n", + " loss_fn,\n", + " device,\n", + " len(df_test)\n", + ")\n", + "\n", + "print(('\\n'))\n", + "print('Test Accuracy : ', test_acc.item())" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "mdQ7-ylCj8Gd" + }, + "source": [ + "The accuracy is about 1% lower on the test set. Our model seems to generalize well.\n", + "\n", + "We'll define a helper function to get the predictions from our model:" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "id": "EgR6MuNS8jr_" + }, + "outputs": [], + "source": [ + "def get_predictions(model, data_loader):\n", + " model = model.eval()\n", + "\n", + " review_texts = []\n", + " predictions = []\n", + " prediction_probs = []\n", + " real_values = []\n", + "\n", + " with torch.no_grad():\n", + " for d in data_loader:\n", + "\n", + " texts = d[\"review_text\"]\n", + " input_ids = d[\"input_ids\"].to(device)\n", + " attention_mask = d[\"attention_mask\"].to(device)\n", + " targets = d[\"targets\"].to(device)\n", + "\n", + " outputs = model(\n", + " input_ids=input_ids,\n", + " attention_mask=attention_mask\n", + " )\n", + " _, preds = torch.max(outputs, dim=1)\n", + "\n", + " probs = F.softmax(outputs, dim=1)\n", + "\n", + " review_texts.extend(texts)\n", + " predictions.extend(preds)\n", + " prediction_probs.extend(probs)\n", + " real_values.extend(targets)\n", + "\n", + " predictions = torch.stack(predictions).cpu()\n", + " prediction_probs = torch.stack(prediction_probs).cpu()\n", + " real_values = torch.stack(real_values).cpu()\n", + " return review_texts, predictions, prediction_probs, real_values" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "dkbnBTI7kd_y" + }, + "source": [ + "This is similar to the evaluation function, except that we're storing the text of the reviews and the predicted probabilities (by applying the softmax on the model outputs):" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zHdPZr60-0c_", + "outputId": "1724a178-afeb-4b24-ce1a-91d3a866d777" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "y_review_texts, y_pred, y_pred_probs, y_test = get_predictions(\n", + " model,\n", + " test_data_loader\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "gVwoVij2lC7F" + }, + "source": [ + "Let's have a look at the classification report" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "L8a9_8-ND3Is", + "outputId": "bcafa022-4a17-4dd8-b570-f3dd0fafd16f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " negative 0.92 0.84 0.88 245\n", + " neutral 0.82 0.87 0.84 254\n", + " positive 0.91 0.91 0.91 289\n", + "\n", + " accuracy 0.88 788\n", + " macro avg 0.88 0.88 0.88 788\n", + "weighted avg 0.88 0.88 0.88 788\n", + "\n" + ] + } + ], + "source": [ + "print(classification_report(y_test, y_pred, target_names=class_names))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "rFAekw3mmWUi" + }, + "source": [ + "Looks like it is really hard to classify neutral (3 stars) reviews. And I can tell you from experience, looking at many reviews, those are hard to classify.\n", + "\n", + "We'll continue with the confusion matrix:" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 747 + }, + "id": "6d1qxsc__DTh", + "outputId": "6b579751-1f15-44d5-eb27-10925823974c" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 730, + "width": 1008 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "def show_confusion_matrix(confusion_matrix):\n", + " hmap = sns.heatmap(confusion_matrix, annot=True, fmt=\"d\", cmap=\"Blues\")\n", + " hmap.yaxis.set_ticklabels(hmap.yaxis.get_ticklabels(), rotation=0, ha='right')\n", + " hmap.xaxis.set_ticklabels(hmap.xaxis.get_ticklabels(), rotation=30, ha='right')\n", + " plt.ylabel('True sentiment')\n", + " plt.xlabel('Predicted sentiment');\n", + "\n", + "cm = confusion_matrix(y_test, y_pred)\n", + "df_cm = pd.DataFrame(cm, index=class_names, columns=class_names)\n", + "show_confusion_matrix(df_cm)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "wx0U7oNsnZ3A" + }, + "source": [ + "This confirms that our model is having difficulty classifying neutral reviews. It mistakes those for negative and positive at a roughly equal frequency.\n", + "\n", + "That's a good overview of the performance of our model. But let's have a look at an example from our test data:" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": { + "id": "iANBiY3sLo-K" + }, + "outputs": [], + "source": [ + "idx = 2\n", + "\n", + "review_text = y_review_texts[idx]\n", + "true_sentiment = y_test[idx]\n", + "pred_df = pd.DataFrame({\n", + " 'class_names': class_names,\n", + " 'values': y_pred_probs[idx]\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-8D0rb1yfnv4", + "outputId": "ceb8ccc8-9b77-46e1-8865-3ebb692422cb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I used to use Habitica, and I must say this is a great step up. I'd\n", + "like to see more social features, such as sharing tasks - only one\n", + "person has to perform said task for it to be checked off, but only\n", + "giving that person the experience and gold. Otherwise, the price for\n", + "subscription is too steep, thus resulting in a sub-perfect score. I\n", + "could easily justify $0.99/month or eternal subscription for $15. If\n", + "that price could be met, as well as fine tuning, this would be easily\n", + "worth 5 stars.\n", + "\n", + "True sentiment: neutral\n" + ] + } + ], + "source": [ + "print(\"\\n\".join(wrap(review_text)))\n", + "print()\n", + "print(f'True sentiment: {class_names[true_sentiment]}')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "f7hj_IZFnn2X" + }, + "source": [ + "Now we can look at the confidence of each sentiment of our model:" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 710 + }, + "id": "qj4d8lZyMkhf", + "outputId": "64d33548-ae81-476d-e30f-664f8bf29726" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 693, + "width": 1083 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.barplot(x='values', y='class_names', data=pred_df, orient='h')\n", + "plt.ylabel('sentiment')\n", + "plt.xlabel('probability')\n", + "plt.xlim([0, 1]);" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "7WL5pDmvFyaU" + }, + "source": [ + "### Predicting on Raw Text\n", + "\n", + "Let's use our model to predict the sentiment of some raw text:" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "id": "QEPi7zQRsDhH" + }, + "outputs": [], + "source": [ + "review_text = \"I love completing my todos! Best app ever!!!\"" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "GaN4RnqMnxYw" + }, + "source": [ + "We have to use the tokenizer to encode the text:" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zA5Or4D2sLc9", + "outputId": "10b0fd44-4818-4567-b98a-74bed7aa44ed" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2377: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "encoded_review = tokenizer.encode_plus(\n", + " review_text,\n", + " max_length=MAX_LEN,\n", + " add_special_tokens=True,\n", + " return_token_type_ids=False,\n", + " pad_to_max_length=True,\n", + " return_attention_mask=True,\n", + " return_tensors='pt',\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "et8xlDrKpH60" + }, + "source": [ + "Let's get the predictions from our model:" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Qr_t3rUksumr", + "outputId": "a7419338-d63e-40ff-ba9d-a7446d1362bb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Review text: I love completing my todos! Best app ever!!!\n", + "Sentiment : positive\n" + ] + } + ], + "source": [ + "input_ids = encoded_review['input_ids'].to(device)\n", + "attention_mask = encoded_review['attention_mask'].to(device)\n", + "\n", + "output = model(input_ids, attention_mask)\n", + "_, prediction = torch.max(output, dim=1)\n", + "\n", + "print(f'Review text: {review_text}')\n", + "print(f'Sentiment : {class_names[prediction]}')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "PVhwzq7bpPRl" + }, + "source": [ + "## Summary\n", + "\n", + "Nice job! You learned how to use BERT for sentiment analysis. You built a custom classifier using the Hugging Face library and trained it on our app reviews dataset!\n", + "\n", + "- [Read the tutorial](https://www.curiousily.com/posts/sentiment-analysis-with-bert-and-hugging-face-using-pytorch-and-python/)\n", + "- [Run the notebook in your browser (Google Colab)](https://colab.research.google.com/drive/1PHv-IRLPCtv7oTcIGbsgZHqrB5LPvB7S)\n", + "- [Read the `Getting Things Done with Pytorch` book](https://github.com/curiousily/Getting-Things-Done-with-Pytorch)\n", + "\n", + "You learned how to:\n", + "\n", + "- Intuitively understand what BERT is\n", + "- Preprocess text data for BERT and build PyTorch Dataset (tokenization, attention masks, and padding)\n", + "- Use Transfer Learning to build Sentiment Classifier using the Transformers library by Hugging Face\n", + "- Evaluate the model on test data\n", + "- Predict sentiment on raw text\n", + "\n", + "Next, we'll learn how to deploy our trained model behind a REST API and build a simple web app to access it." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "Wf39tauBa2V2" + }, + "source": [ + "## References\n", + "\n", + "- [BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding](https://arxiv.org/abs/1810.04805)\n", + "- [L11 Language Models - Alec Radford (OpenAI)](https://www.youtube.com/watch?v=BnpB3GrpsfM)\n", + "- [The Illustrated BERT, ELMo, and co.](https://jalammar.github.io/illustrated-bert/)\n", + "- [BERT Fine-Tuning Tutorial with PyTorch](https://mccormickml.com/2019/07/22/BERT-fine-tuning/)\n", + "- [How to Fine-Tune BERT for Text Classification?](https://arxiv.org/pdf/1905.05583.pdf)\n", + "- [Huggingface Transformers](https://huggingface.co/transformers/)\n", + "- [BERT Explained: State of the art language model for NLP](https://towardsdatascience.com/bert-explained-state-of-the-art-language-model-for-nlp-f8b21a9b6270)" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "0a3631a4ad9c49909c63b9cabdd926d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0c85e11e27d6484ea31b766aecf0a06e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "300407d9c525447cbc2223a30c17deac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "30cc769f98f9447eae28e7060c943d6f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ce8cb11f151b45a69431a11d0789bb93", + "placeholder": "​", + "style": "IPY_MODEL_6652821599284ab3bcb86f8dfee60da5", + "value": " 29.0/29.0 [00:00<00:00, 576B/s]" + } + }, + "34bbd61a5c844010bbd47539fcf2abc6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3dac470fee3c4f9eb8bebb1992c19688": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3ed9609b1b804e079e548c6e87410911": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5f9e170e18d8413ea9811e3cd501fcb7", + "placeholder": "​", + "style": "IPY_MODEL_c65deba3b9c1414eb489317f2fb18b12", + "value": "Downloading (…)lve/main/config.json: 100%" + } + }, + "44b33027973c41d69730f66aeef675ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5968e9e39f1b466dbacf6cece45d7ee2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5b828d7f8bd747619cddc4b28d1d5383", + "IPY_MODEL_c8135ded16e24ec1bb3ab6b26aa1e01d", + "IPY_MODEL_cdbbeea71cf1478a93df34da79abb1e1" + ], + "layout": "IPY_MODEL_acd7b4228d984976b0aa16eda3a74e2a" + } + }, + "5b828d7f8bd747619cddc4b28d1d5383": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a5aaec5b93e04200bf59024dd6497283", + "placeholder": "​", + "style": "IPY_MODEL_300407d9c525447cbc2223a30c17deac", + "value": "Downloading (…)solve/main/vocab.txt: 100%" + } + }, + "5d54820c46e44b54aaeb002e1054d495": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_34bbd61a5c844010bbd47539fcf2abc6", + "max": 29, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b389a069f9aa433b97f81043b5dc573a", + "value": 29 + } + }, + "5f9e170e18d8413ea9811e3cd501fcb7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "62b3f7375b0243239eed24bd9b342939": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "648c9e36f406464b8a5be4d19a69a4e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6652821599284ab3bcb86f8dfee60da5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6f54d4cafe384c67a459065119006b4e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7022e627b3934baababd16449a13ab16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b7336a3c03804a1889bd4539e8574100", + "max": 570, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_44b33027973c41d69730f66aeef675ef", + "value": 570 + } + }, + "7532b67ceaf74f6c8263ae7185a7b04d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7fb2d01f05914c7b97e58dc877c67c62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3ed9609b1b804e079e548c6e87410911", + "IPY_MODEL_7022e627b3934baababd16449a13ab16", + "IPY_MODEL_b376b41872cd490e8bcd7d64db66941a" + ], + "layout": "IPY_MODEL_0c85e11e27d6484ea31b766aecf0a06e" + } + }, + "841966fa79134f75a1fed6db97f34dc9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_62b3f7375b0243239eed24bd9b342939", + "placeholder": "​", + "style": "IPY_MODEL_c23dcfab453442b4b41a90c2f096302d", + "value": "Downloading (…)okenizer_config.json: 100%" + } + }, + "8432242e44044eb48b132453b519947e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_924c0e3b25054a68b37090823bd07a96", + "IPY_MODEL_fa802e4f8a3c4d20b0fabeaeaab7ee18", + "IPY_MODEL_d48ccf851db0492d805f2ac9342839b4" + ], + "layout": "IPY_MODEL_7532b67ceaf74f6c8263ae7185a7b04d" + } + }, + "90ececf282a94f6ca593d361ad6d9212": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "924c0e3b25054a68b37090823bd07a96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fdd1cbca5dd74a7e9c91d15cb6abd7ce", + "placeholder": "​", + "style": "IPY_MODEL_b3940458f5134c4a8a16432113ef2561", + "value": "Downloading model.safetensors: 100%" + } + }, + "9ff5213e4251453b92de1eeeb9c7acb6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a364d729ab9342dfa53bb39e8f068688": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a5aaec5b93e04200bf59024dd6497283": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a7733a2a0059411db9f7edb5e4dd1a92": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "acd7b4228d984976b0aa16eda3a74e2a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b376b41872cd490e8bcd7d64db66941a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9ff5213e4251453b92de1eeeb9c7acb6", + "placeholder": "​", + "style": "IPY_MODEL_0a3631a4ad9c49909c63b9cabdd926d8", + "value": " 570/570 [00:00<00:00, 13.0kB/s]" + } + }, + "b389a069f9aa433b97f81043b5dc573a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b3940458f5134c4a8a16432113ef2561": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b7336a3c03804a1889bd4539e8574100": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c23dcfab453442b4b41a90c2f096302d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c5c2e50239a44566b376e233b36e1220": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_841966fa79134f75a1fed6db97f34dc9", + "IPY_MODEL_5d54820c46e44b54aaeb002e1054d495", + "IPY_MODEL_30cc769f98f9447eae28e7060c943d6f" + ], + "layout": "IPY_MODEL_a7733a2a0059411db9f7edb5e4dd1a92" + } + }, + "c65deba3b9c1414eb489317f2fb18b12": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c8135ded16e24ec1bb3ab6b26aa1e01d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f59117f9fb414783b339226908a3d32f", + "max": 213450, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6f54d4cafe384c67a459065119006b4e", + "value": 213450 + } + }, + "cdbbeea71cf1478a93df34da79abb1e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fabf9140688d49d99dd799a2b364ec27", + "placeholder": "​", + "style": "IPY_MODEL_3dac470fee3c4f9eb8bebb1992c19688", + "value": " 213k/213k [00:00<00:00, 1.30MB/s]" + } + }, + "ce8cb11f151b45a69431a11d0789bb93": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d48ccf851db0492d805f2ac9342839b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e8592109366842438c9295552aac501a", + "placeholder": "​", + "style": "IPY_MODEL_90ececf282a94f6ca593d361ad6d9212", + "value": " 436M/436M [00:01<00:00, 204MB/s]" + } + }, + "e8592109366842438c9295552aac501a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f59117f9fb414783b339226908a3d32f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fa802e4f8a3c4d20b0fabeaeaab7ee18": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_648c9e36f406464b8a5be4d19a69a4e7", + "max": 435755784, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a364d729ab9342dfa53bb39e8f068688", + "value": 435755784 + } + }, + "fabf9140688d49d99dd799a2b364ec27": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fdd1cbca5dd74a7e9c91d15cb6abd7ce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}