{ "cells": [ { "cell_type": "markdown", "metadata": { "colab_type": "text", "execution": {}, "id": "view-in-github" }, "source": [ "\"Open   \"Open" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "# Twitter Sentiment Analysis\n", "\n", "**By Neuromatch Academy**\n", "\n", "__Content creators:__ Juan Manuel Rodriguez, Salomey Osei, Gonzalo Uribarri\n", "\n", "__Production editors:__ Amita Kapoor, Spiros Chavlis" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "---\n", "# Welcome to the NLP project template\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "---\n", "# Step 1: Questions and goals\n", "\n", "* Can we infer emotion from a tweet text?\n", "* How words are distributed accross the dataset?\n", "* Are words related to one kind of emotion?" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "---\n", "# Step 2: Literature review\n", "\n", "[Original Dataset Paper](https://cs.stanford.edu/people/alecmgo/papers/TwitterDistantSupervision09.pdf)\n", "\n", "[Papers with code](https://paperswithcode.com/dataset/imdb-movie-reviews)" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "---\n", "# Step 3: Load and explore the dataset" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Install dependencies\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "cellView": "form", "execution": {}, "tags": [ "hide-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", "torchvision 0.14.0 requires torch==1.13.0, but you have torch 2.3.1 which is incompatible.\u001b[0m\u001b[31m\n", "\u001b[0m\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", "torchvision 0.14.0 requires torch==1.13.0, but you have torch 2.3.1 which is incompatible.\u001b[0m\u001b[31m\n", "\u001b[0m" ] } ], "source": [ "# @title Install dependencies\n", "!pip install pandas --quiet\n", "!pip install torchtext --quiet\n", "!pip install datasets --quiet" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/yuda/code/neuromatch/course-content-dl/venv/lib/python3.9/site-packages/torchtext/data/__init__.py:4: UserWarning: \n", "/!\\ IMPORTANT WARNING ABOUT TORCHTEXT STATUS /!\\ \n", "Torchtext is deprecated and the last released version will be 0.18 (this one). You can silence this warning by calling the following at the beginnign of your scripts: `import torchtext; torchtext.disable_torchtext_deprecation_warning()`\n", " warnings.warn(torchtext._TORCHTEXT_DEPRECATION_MSG)\n" ] } ], "source": [ "# We import some libraries to load the dataset\n", "import os\n", "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "\n", "from collections import Counter\n", "from tqdm.notebook import tqdm\n", "\n", "import torch\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "import torch.nn.functional as F\n", "from torch.utils.data import TensorDataset, DataLoader\n", "\n", "import torchtext\n", "from torchtext.data import get_tokenizer\n", "\n", "from sklearn.utils import shuffle\n", "from sklearn.metrics import classification_report\n", "from sklearn.linear_model import LogisticRegression\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.feature_extraction.text import CountVectorizer" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "You can find the dataset we are going to use in [this website](https://huggingface.co/datasets/stanfordnlp/sentiment140)." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "cd6b527daf25440a8acc7a7645af679d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Downloading builder script: 0%| | 0.00/4.03k [00:00\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", "
polarityuserdatequeryusertext
00_TheSpecialOne_Mon Apr 06 22:19:45 PDT 2009NO_QUERY_TheSpecialOne_@switchfoot http://twitpic.com/2y1zl - Awww, t...
10scotthamiltonMon Apr 06 22:19:49 PDT 2009NO_QUERYscotthamiltonis upset that he can't update his Facebook by ...
20mattycusMon Apr 06 22:19:53 PDT 2009NO_QUERYmattycus@Kenichan I dived many times for the ball. Man...
30ElleCTFMon Apr 06 22:19:57 PDT 2009NO_QUERYElleCTFmy whole body feels itchy and like its on fire
40KaroliMon Apr 06 22:19:57 PDT 2009NO_QUERYKaroli@nationwideclass no, it's not behaving at all....
\n", "" ], "text/plain": [ " polarity user date query \\\n", "0 0 _TheSpecialOne_ Mon Apr 06 22:19:45 PDT 2009 NO_QUERY \n", "1 0 scotthamilton Mon Apr 06 22:19:49 PDT 2009 NO_QUERY \n", "2 0 mattycus Mon Apr 06 22:19:53 PDT 2009 NO_QUERY \n", "3 0 ElleCTF Mon Apr 06 22:19:57 PDT 2009 NO_QUERY \n", "4 0 Karoli Mon Apr 06 22:19:57 PDT 2009 NO_QUERY \n", "\n", " user text \n", "0 _TheSpecialOne_ @switchfoot http://twitpic.com/2y1zl - Awww, t... \n", "1 scotthamilton is upset that he can't update his Facebook by ... \n", "2 mattycus @Kenichan I dived many times for the ball. Man... \n", "3 ElleCTF my whole body feels itchy and like its on fire \n", "4 Karoli @nationwideclass no, it's not behaving at all.... " ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# We load the dataset\n", "train_data = dataset[\"train\"]\n", "df = pd.DataFrame(train_data)\n", "df = df.rename(columns={'sentiment': 'polarity'})\n", "df = df[['polarity', 'user', 'date', 'query', 'user', 'text']]\n", "df.head()" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "For this project we will use only the text and the polarity of the tweet. Notice that polarity is 0 for negative tweets and 4 for positive tweet." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [], "source": [ "X = df.text.values\n", "\n", "# Changes values from [0,4] to [0,1]\n", "y = (df.polarity.values > 1).astype(int)\n", "\n", "\n", "# Split the data into train and test\n", "x_train_text, x_test_text, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42,stratify=y)" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "The first thing we have to do before working on the models is to familiarize ourselves with the dataset. This is called Exploratory Data Analisys (EDA)." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1: @paisleypaisley LOL why do i get ideas so far in advance? it's not even june yet! we need a third knitter to have our own summer group \n", "0: worst headache ever \n", "0: @ewaniesciuszko i am so sad i wont see you! I miss you already. and yeah! that's perfect; i come back the 18th!\n", "1: doesn't know how to spell conked \n", "0: "So we stand here now and no one knows us at all I won't get used to this I won't get used to being gone"...I miss home and everyone -a\n" ] } ], "source": [ "for s, l in zip(x_train_text[:5], y_train[:5]):\n", " print('{}: {}'.format(l, s))" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "An interesting thing to analyze is the Word Distribution. In order to count the occurrences of each word, we should tokenize the sentences first." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Before Tokenize: worst headache ever \n", "After Tokenize: ['worst', 'headache', 'ever']\n" ] } ], "source": [ "tokenizer = get_tokenizer(\"basic_english\")\n", "\n", "print('Before Tokenize: ', x_train_text[1])\n", "print('After Tokenize: ', tokenizer(x_train_text[1]))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "cd7802db570b408eb5f29af92ca95be1", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/1280000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.bar(range(100), [words[w] for w in sorted_words[:100]])\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "It is very common to find this kind of distribution when analyzing corpus of text. This is referred to as the [zipf's law](https://en.wikipedia.org/wiki/Zipf%27s_law)." ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "Usually the number of words in the dictionary will be very large. \n", "\n", "Here are some thing we can do to reduce that number:\n", "\n", "* Remove puntuation.\n", "* Remove stop-words.\n", "* Steaming.\n", "* Remove very uncommon words (the words that appears in fewer than N occations).\n", "* Nothing: we can use a pretrain model that handles this kind of situations.\n", "\n", "\n", "We used one of the simplest tokenizers availables. This tokenizer does not take into account many quirks of the language. Moreover, diferent languages have different quirks, so there is no \"universal\" tokenizers. There are many libraries that have \"better\" tokenizers:\n", "\n", "* [Spacy](https://spacy.io/): it can be accessed using: `get_tokenizer(\"spacy\")`. Spacy supports a wide range of languages.\n", "* [Huggingface](https://huggingface.co/): it has many tokenizers for different laguages. [Doc](https://huggingface.co/transformers/main_classes/tokenizer.html)\n", "* [NLTK](https://www.nltk.org/): it provides several tokenizers. One of them can be accessed using: `get_tokenizer(\"toktok\")`\n" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "---\n", "# Step 4: choose toolkit\n", "\n", "Our goal is to train a model capable of estimating the sentiment of a tweet (positive or negative) by reading its content. To that end we will try 2 different approaches:\n", "\n", "* A logistic regression using sklearn. **NOTE**: it can probaly work better than an SVM model.\n", "* A simple Embedding + RNN." ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "## Logistic regression\n", "\n", "We will represent our senteces using binary vectorization. This means that our data would be represented as a matrix of instances by word with a one if the word is in the instance, and zero otherwise. Sklean vectorizers can also do things such as stop-word removal and puntuation removal, you can read more about in [the documentation](https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.CountVectorizer.html)." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [], "source": [ "vectorizer = CountVectorizer(binary=True)\n", "x_train_cv = vectorizer.fit_transform(x_train_text)\n", "x_test_cv = vectorizer.transform(x_test_text)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Before Vectorize: doesn't know how to spell conked \n" ] } ], "source": [ "print('Before Vectorize: ', x_train_text[3])" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "After Vectorize: \n", " (0, 528584)\t1\n", " (0, 165468)\t1\n", " (0, 300381)\t1\n", " (0, 242211)\t1\n", " (0, 489893)\t1\n", " (0, 134160)\t1\n" ] } ], "source": [ "# Notice that the matriz is sparse\n", "print('After Vectorize: ')\n", "print(x_train_cv[3])" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "Now we can train our model. You can check the documentation of this logistic regressor [here](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic#sklearn.linear_model.LogisticRegression)." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "data": { "text/html": [ "
LogisticRegression(solver='saga')
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "LogisticRegression(solver='saga')" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model = LogisticRegression(solver='saga')\n", "model.fit(x_train_cv, y_train)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " 0 0.81 0.79 0.80 160000\n", " 1 0.79 0.81 0.80 160000\n", "\n", " accuracy 0.80 320000\n", " macro avg 0.80 0.80 0.80 320000\n", "weighted avg 0.80 0.80 0.80 320000\n", "\n" ] } ], "source": [ "y_pred = model.predict(x_test_cv)\n", "\n", "print(classification_report(y_test, y_pred))" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "## Explainable AI\n", "The best thing about logistic regresion is that it is simple, and we can get some explanations." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1, 589260)\n", "589260\n" ] } ], "source": [ "print(model.coef_.shape)\n", "print(len(vectorizer.vocabulary_))\n", "\n", "words_sk = list(vectorizer.vocabulary_.keys())\n", "words_sk.sort(key=lambda w: model.coef_[0, vectorizer.vocabulary_[w]])" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "roni: -3.8625743295204957\n", "inaperfectworld: -3.5734332703128837\n", "dontyouhate: -3.5001974848534263\n", "xbllygbsn: -3.4126706055950495\n", "anqju: -3.3363734662876445\n", "sad: -3.200515320038219\n", "pakcricket: -3.1949201520762647\n", "condolences: -3.1325044251779404\n", "heartbreaking: -3.066490736238656\n", "saddest: -3.0420206470077464\n", "sadd: -3.0290359193094782\n", "heartbroken: -3.028758057376751\n", "boohoo: -3.0225999274601483\n", "sadface: -2.9918433622017107\n", "rachelle_lefevr: -2.9250755659458325\n", "disappointing: -2.9025305172931777\n", "lvbu: -2.8947126358841744\n", "saddens: -2.885505898962137\n", "bummed: -2.8364963698917003\n", "neda: -2.792965453263205\n" ] } ], "source": [ "for w in words_sk[:20]:\n", " print('{}: {}'.format(w, model.coef_[0, vectorizer.vocabulary_[w]]))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iamsoannoyed: 2.849404979800149\n", "myfax: 2.7974231693128444\n", "jennamadison: 2.566709062644627\n", "yeyy: 2.4780376468589687\n", "tryout: 2.4383326853311327\n", "goldymom: 2.4374101525708456\n", "wooohooo: 2.4029624310379774\n", "thesupergirl: 2.3565547667359015\n", "iammaxathotspot: 2.3116516945468017\n", "londicreations: 2.3074597815514477\n", "smilin: 2.2991641364971334\n", "worries: 2.2899475148214545\n", "sinfulsignorita: 2.2798843862743605\n", "finchensnail: 2.264277870479377\n", "smackthis: 2.237665085200092\n", "kv: 2.215872609715896\n", "tojosan: 2.2117820541821733\n", "russmarshalek: 2.2095325084648705\n", "traciknoppe: 2.1768517653116426\n", "congratulations: 2.1715832459661644\n" ] } ], "source": [ "for w in reversed(words_sk[-20:]):\n", " print('{}: {}'.format(w, model.coef_[0, vectorizer.vocabulary_[w]]))" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "What does this mean?\n", "\n", "Remember the `model.coef_` is the $W$ in:\n", "\n", "$$h(x)=\\sigma(WX + b)$$\n", "\n", "where the label 1 is a positive tweet and the label 0 is a negative tweet." ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "## Recurrent Neural Network with Pytorch" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "In the previous section we use a Bag-Of-Words approach to represent each of the tweets. That meas that we only consider how many times each of the words appear in each of the tweets, we didnt take into account the order of the words. But we know that the word order is very important and carries relevant information.\n", "\n", "In this section we will solve the same task, but this time we will implement a Recurrent Neural Network (RNN) instead of using a simple Logistic Regression.Unlike feedforward neural networks, RNNs have cyclic connections making them powerful for modeling sequences.\n", "\n", "Let's start by importing the relevant libraries.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [], "source": [ "def set_device():\n", " device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", " if device != \"cuda\":\n", " print(\"WARNING: For this notebook to perform best, \"\n", " \"if possible, in the menu under `Runtime` -> \"\n", " \"`Change runtime type.` select `GPU` \")\n", " else:\n", " print(\"GPU is enabled in this notebook.\")\n", "\n", " return device" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "WARNING: For this notebook to perform best, if possible, in the menu under `Runtime` -> `Change runtime type.` select `GPU` \n" ] } ], "source": [ "# Set the device (check if gpu is available)\n", "device = set_device()" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "First we will create a Dictionary (`word_to_idx`). This dictionary will map each Token (usually words) to an index (an integer number). We want to limit our dictionary to a certain number of tokens (`num_words_dict`), so we will include in our ditionary those with more occurrences." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "data": { "text/plain": [ "['.', 'i', '!', \"'\", 'to', 'the', ',', 'a', 'my', 'it']" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# From previous section, we have a list with the most used tokens\n", "sorted_words[:10]" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "Let's select only the most used." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [], "source": [ "num_words_dict = 30000\n", "# We reserve two numbers for special tokens.\n", "most_used_words = sorted_words[:num_words_dict-2]" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "We will add two extra Tokens to the dictionary, one for words outside the dictionary (`'UNK'`) and one for padding the sequences (`'PAD'`)." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [], "source": [ "# dictionary to go from words to idx\n", "word_to_idx = {}\n", "# dictionary to go from idx to words (just in case)\n", "idx_to_word = {}\n", "\n", "\n", "# We include the special tokens first\n", "PAD_token = 0\n", "UNK_token = 1\n", "\n", "word_to_idx['PAD'] = PAD_token\n", "word_to_idx['UNK'] = UNK_token\n", "\n", "idx_to_word[PAD_token] = 'PAD'\n", "idx_to_word[UNK_token] = 'UNK'\n", "\n", "# We popullate our dictionaries with the most used words\n", "for num,word in enumerate(most_used_words):\n", " word_to_idx[word] = num + 2\n", " idx_to_word[num+2] = word" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "Our goal now is to transform each tweet from a sequence of tokens to a sequence of indexes. These sequences of indexes will be the input to our pytorch model." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [], "source": [ "# A function to convert list of tokens to list of indexes\n", "def tokens_to_idx(sentences_tokens,word_to_idx):\n", " sentences_idx = []\n", " for sent in sentences_tokens:\n", " sent_idx = []\n", " for word in sent:\n", " if word in word_to_idx:\n", " sent_idx.append(word_to_idx[word])\n", " else:\n", " sent_idx.append(word_to_idx['UNK'])\n", " sentences_idx.append(sent_idx)\n", " return sentences_idx" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [], "source": [ "x_train_idx = tokens_to_idx(x_train_token,word_to_idx)\n", "x_test_idx = tokens_to_idx(x_test_token,word_to_idx)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Before converting: ['worst', 'headache', 'ever']\n", "After converting: [721, 458, 237]\n" ] } ], "source": [ "some_number = 1\n", "print('Before converting: ', x_train_token[some_number])\n", "print('After converting: ', x_train_idx[some_number])" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "We need all the sequences to have the same length. To select an adequate sequence length, let's explore some statistics about the length of the tweets:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Max tweet word length: 229\n", "Mean tweet word length: 15.0\n", "99% percent under: 37.0\n" ] } ], "source": [ "tweet_lens = np.asarray([len(sentence) for sentence in x_train_idx])\n", "print('Max tweet word length: ',tweet_lens.max())\n", "print('Mean tweet word length: ',np.median(tweet_lens))\n", "print('99% percent under: ',np.quantile(tweet_lens,0.99))" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "We cut the sequences which are larger than our chosen maximum length (`max_lenght`) and fill with zeros the ones that are shorter." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [], "source": [ " # We choose the max length\n", " max_length = 40\n", "\n", "# A function to make all the sequence have the same lenght\n", "# Note that the output is a Numpy matrix\n", " def padding(sentences, seq_len):\n", " features = np.zeros((len(sentences), seq_len),dtype=int)\n", " for ii, tweet in enumerate(sentences):\n", " len_tweet = len(tweet)\n", " if len_tweet != 0:\n", " if len_tweet <= seq_len:\n", " # If its shorter, we fill with zeros (the padding Token index)\n", " features[ii, -len(tweet):] = np.array(tweet)[:seq_len]\n", " if len_tweet > seq_len:\n", " # If its larger, we take the last 'seq_len' indexes\n", " features[ii, :] = np.array(tweet)[-seq_len:]\n", " return features" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [], "source": [ "# We convert our list of tokens into a numpy matrix\n", "# where all instances have the same lenght\n", "x_train_pad = padding(x_train_idx,max_length)\n", "x_test_pad = padding(x_test_idx,max_length)\n", "\n", "# We convert our target list a numpy matrix\n", "y_train_np = np.asarray(y_train)\n", "y_test_np = np.asarray(y_test)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Before padding: [1, 3, 71, 24, 122, 3, 533, 74, 13, 4, 3, 102, 13, 209, 2, 12, 150, 4, 22, 5, 18, 667, 3, 138, 61, 7, 3296, 4]\n", "After padding: [ 0 0 0 0 0 0 0 0 0 0 0 0 1 3\n", " 71 24 122 3 533 74 13 4 3 102 13 209 2 12\n", " 150 4 22 5 18 667 3 138 61 7 3296 4]\n" ] } ], "source": [ "some_number = 2\n", "print('Before padding: ', x_train_idx[some_number])\n", "print('After padding: ', x_train_pad[some_number])" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "Now, let's convert the data to pytorch format.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [], "source": [ "# create Tensor datasets\n", "train_data = TensorDataset(torch.from_numpy(x_train_pad), torch.from_numpy(y_train_np))\n", "valid_data = TensorDataset(torch.from_numpy(x_test_pad), torch.from_numpy(y_test_np))\n", "\n", "# Batch size (this is an important hyperparameter)\n", "batch_size = 100\n", "\n", "# dataloaders\n", "# make sure to SHUFFLE your data\n", "train_loader = DataLoader(train_data, shuffle=True, batch_size=batch_size,drop_last = True)\n", "valid_loader = DataLoader(valid_data, shuffle=True, batch_size=batch_size,drop_last = True)" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "Each batch of data in our traning proccess will have the folllowing format:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Sample input size: torch.Size([100, 40])\n", "Sample input: \n", " tensor([[ 0, 0, 0, ..., 12, 4491, 2],\n", " [ 0, 0, 0, ..., 0, 1, 383],\n", " [ 0, 0, 0, ..., 6, 246, 2],\n", " ...,\n", " [ 0, 0, 0, ..., 108, 14, 4],\n", " [ 0, 0, 0, ..., 2434, 29, 1],\n", " [ 0, 0, 0, ..., 1150, 20247, 2]])\n", "Sample input: \n", " tensor([1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", " 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1,\n", " 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0,\n", " 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0,\n", " 0, 0, 1, 1])\n" ] } ], "source": [ "# Obtain one batch of training data\n", "dataiter = iter(train_loader)\n", "sample_x, sample_y = dataiter.__next__()\n", "\n", "print('Sample input size: ', sample_x.size()) # batch_size, seq_length\n", "print('Sample input: \\n', sample_x)\n", "print('Sample input: \\n', sample_y)" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "Now, we will define the `SentimentRNN` class. Most of the model's class will be familiar to you, but there are two important layers we would like you to pay attention to:\n", "\n", "* Embedding Layer\n", "> This layer is like a linear layer, but it makes it posible to use a sequence of inedexes as inputs (instead of a sequence of one-hot-encoded vectors). During training, the Embedding layer learns a linear transformation from the space of words (a vector space of dimension `num_words_dict`) into the a new, smaller, vector space of dimension `embedding_dim`. We suggest you to read this [thread](https://discuss.pytorch.org/t/how-does-nn-embedding-work/88518/3) and the [pytorch documentation](https://pytorch.org/docs/stable/generated/torch.nn.Embedding.html) if you want to learn more about this particular kind of layers.\n", "\n", "\n", "* LSTM layer\n", "> This is one of the most used class of Recurrent Neural Networks. In Pytorch we can add several stacked layers in just one line of code. In our case, the number of layers added are decided with the parameter `no_layers`. If you want to learn more about LSTMs we strongly recommend you this [Colahs thread](https://colah.github.io/posts/2015-08-Understanding-LSTMs/) about them.\n", "\n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [], "source": [ "class SentimentRNN(nn.Module):\n", " def __init__(self,no_layers,vocab_size,hidden_dim,embedding_dim,drop_prob=0.1):\n", " super(SentimentRNN,self).__init__()\n", "\n", " self.output_dim = output_dim\n", " self.hidden_dim = hidden_dim\n", " self.no_layers = no_layers\n", " self.vocab_size = vocab_size\n", " self.drop_prob = drop_prob\n", "\n", " # Embedding Layer\n", " self.embedding = nn.Embedding(vocab_size, embedding_dim)\n", "\n", " # LSTM Layers\n", " self.lstm = nn.LSTM(input_size=embedding_dim,hidden_size=self.hidden_dim,\n", " num_layers=no_layers, batch_first=True,\n", " dropout=self.drop_prob)\n", "\n", " # Dropout layer\n", " self.dropout = nn.Dropout(drop_prob)\n", "\n", " # Linear and Sigmoid layer\n", " self.fc = nn.Linear(self.hidden_dim, output_dim)\n", " self.sig = nn.Sigmoid()\n", "\n", " def forward(self,x,hidden):\n", " batch_size = x.size(0)\n", "\n", " # Embedding out\n", " embeds = self.embedding(x)\n", " #Shape: [batch_size x max_length x embedding_dim]\n", "\n", " # LSTM out\n", " lstm_out, hidden = self.lstm(embeds, hidden)\n", " # Shape: [batch_size x max_length x hidden_dim]\n", "\n", " # Select the activation of the last Hidden Layer\n", " lstm_out = lstm_out[:,-1,:].contiguous()\n", " # Shape: [batch_size x hidden_dim]\n", "\n", " ## You can instead average the activations across all the times\n", " # lstm_out = torch.mean(lstm_out, 1).contiguous()\n", "\n", " # Dropout and Fully connected layer\n", " out = self.dropout(lstm_out)\n", " out = self.fc(out)\n", "\n", " # Sigmoid function\n", " sig_out = self.sig(out)\n", "\n", " # return last sigmoid output and hidden state\n", " return sig_out, hidden\n", "\n", " def init_hidden(self, batch_size):\n", " ''' Initializes hidden state '''\n", " # Create two new tensors with sizes n_layers x batch_size x hidden_dim,\n", " # initialized to zero, for hidden state and cell state of LSTM\n", " h0 = torch.zeros((self.no_layers,batch_size,self.hidden_dim)).to(device)\n", " c0 = torch.zeros((self.no_layers,batch_size,self.hidden_dim)).to(device)\n", " hidden = (h0,c0)\n", " return hidden" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "We choose the parameters of the model." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [], "source": [ "# Parameters of our network\n", "\n", "# Size of our vocabulary\n", "vocab_size = num_words_dict\n", "\n", "# Embedding dimension\n", "embedding_dim = 32\n", "\n", "# Number of stacked LSTM layers\n", "no_layers = 2\n", "\n", "# Dimension of the hidden layer in LSTMs\n", "hidden_dim = 64\n", "\n", "# Dropout parameter for regularization\n", "output_dim = 1\n", "\n", "# Dropout parameter for regularization\n", "drop_prob = 0.25" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SentimentRNN(\n", " (embedding): Embedding(30000, 32)\n", " (lstm): LSTM(32, 64, num_layers=2, batch_first=True, dropout=0.25)\n", " (dropout): Dropout(p=0.25, inplace=False)\n", " (fc): Linear(in_features=64, out_features=1, bias=True)\n", " (sig): Sigmoid()\n", ")\n" ] } ], "source": [ "# Let's define our model\n", "model = SentimentRNN(no_layers, vocab_size, hidden_dim,\n", " embedding_dim, drop_prob=drop_prob)\n", "# Moving to gpu\n", "model.to(device)\n", "print(model)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Total Number of parameters: 1018433\n" ] } ], "source": [ "# How many trainable parameters does our model have?\n", "model_parameters = filter(lambda p: p.requires_grad, model.parameters())\n", "params = sum([np.prod(p.size()) for p in model_parameters])\n", "print('Total Number of parameters: ',params)" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "We choose the losses and the optimizer for the training procces." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/yuda/code/neuromatch/course-content-dl/venv/lib/python3.9/site-packages/torch/cuda/__init__.py:619: UserWarning: Can't initialize NVML\n", " warnings.warn(\"Can't initialize NVML\")\n" ] } ], "source": [ "# loss and optimization functions\n", "lr = 0.001\n", "\n", "# Binary crossentropy is a good loss function for a binary classification problem\n", "criterion = nn.BCELoss()\n", "\n", "# We choose an Adam optimizer\n", "optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n", "\n", "# function to predict accuracy\n", "def acc(pred,label):\n", " pred = torch.round(pred.squeeze())\n", " return torch.sum(pred == label.squeeze()).item()" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "We are ready to train our model." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1\n", "train_loss : 0.4357354193425272 val_loss : 0.3897459434857592\n", "train_accuracy : 79.552578125 val_accuracy : 82.34125\n", "Validation loss decreased (inf --> 0.389746). Saving model ...\n", "==================================================\n", "Epoch 2\n", "train_loss : 0.3756973787629977 val_loss : 0.37125814022496345\n", "train_accuracy : 83.20953125 val_accuracy : 83.41875\n", "Validation loss decreased (0.389746 --> 0.371258). Saving model ...\n", "==================================================\n", "Epoch 3\n", "train_loss : 0.35649536208133215 val_loss : 0.36528081766329706\n", "train_accuracy : 84.24179687499999 val_accuracy : 83.76593749999999\n", "Validation loss decreased (0.371258 --> 0.365281). Saving model ...\n", "==================================================\n", "Epoch 4\n", "train_loss : 0.3434784019400831 val_loss : 0.361129659358412\n", "train_accuracy : 84.91164062499999 val_accuracy : 83.9671875\n", "Validation loss decreased (0.365281 --> 0.361130). Saving model ...\n", "==================================================\n", "Epoch 5\n", "train_loss : 0.33264520978555084 val_loss : 0.3602768037747592\n", "train_accuracy : 85.53132812499999 val_accuracy : 84.0209375\n", "Validation loss decreased (0.361130 --> 0.360277). Saving model ...\n", "==================================================\n" ] } ], "source": [ "# Number of training Epochs\n", "epochs = 5\n", "\n", "# Maximum absolute value accepted for the gradeint\n", "clip = 5\n", "\n", "# Initial Loss value (assumed big)\n", "valid_loss_min = np.inf\n", "\n", "# Lists to follow the evolution of the loss and accuracy\n", "epoch_tr_loss,epoch_vl_loss = [],[]\n", "epoch_tr_acc,epoch_vl_acc = [],[]\n", "\n", "# Train for a number of Epochs\n", "for epoch in range(epochs):\n", " train_losses = []\n", " train_acc = 0.0\n", " model.train()\n", "\n", " for inputs, labels in train_loader:\n", "\n", " # Initialize hidden state\n", " h = model.init_hidden(batch_size)\n", " # Creating new variables for the hidden state\n", " h = tuple([each.data.to(device) for each in h])\n", "\n", " # Move batch inputs and labels to gpu\n", " inputs, labels = inputs.to(device), labels.to(device)\n", "\n", " # Set gradient to zero\n", " model.zero_grad()\n", "\n", " # Compute model output\n", " output,h = model(inputs,h)\n", "\n", " # Calculate the loss and perform backprop\n", " loss = criterion(output.squeeze(), labels.float())\n", " loss.backward()\n", " train_losses.append(loss.item())\n", "\n", " # calculating accuracy\n", " accuracy = acc(output,labels)\n", " train_acc += accuracy\n", "\n", " #`clip_grad_norm` helps prevent the exploding gradient problem in RNNs / LSTMs.\n", " nn.utils.clip_grad_norm_(model.parameters(), clip)\n", " optimizer.step()\n", "\n", "\n", " # Evaluate on the validation set for this epoch\n", " val_losses = []\n", " val_acc = 0.0\n", " model.eval()\n", " for inputs, labels in valid_loader:\n", "\n", " # Initialize hidden state\n", " val_h = model.init_hidden(batch_size)\n", " val_h = tuple([each.data.to(device) for each in val_h])\n", "\n", " # Move batch inputs and labels to gpu\n", " inputs, labels = inputs.to(device), labels.to(device)\n", "\n", " # Compute model output\n", " output, val_h = model(inputs, val_h)\n", "\n", " # Compute Loss\n", " val_loss = criterion(output.squeeze(), labels.float())\n", "\n", " val_losses.append(val_loss.item())\n", "\n", " accuracy = acc(output,labels)\n", " val_acc += accuracy\n", "\n", " epoch_train_loss = np.mean(train_losses)\n", " epoch_val_loss = np.mean(val_losses)\n", " epoch_train_acc = train_acc/len(train_loader.dataset)\n", " epoch_val_acc = val_acc/len(valid_loader.dataset)\n", " epoch_tr_loss.append(epoch_train_loss)\n", " epoch_vl_loss.append(epoch_val_loss)\n", " epoch_tr_acc.append(epoch_train_acc)\n", " epoch_vl_acc.append(epoch_val_acc)\n", " print(f'Epoch {epoch+1}')\n", " print(f'train_loss : {epoch_train_loss} val_loss : {epoch_val_loss}')\n", " print(f'train_accuracy : {epoch_train_acc*100} val_accuracy : {epoch_val_acc*100}')\n", " if epoch_val_loss <= valid_loss_min:\n", " print('Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...'.format(valid_loss_min,epoch_val_loss))\n", " # torch.save(model.state_dict(), '../working/state_dict.pt')\n", " valid_loss_min = epoch_val_loss\n", " print(25*'==')" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "execution": {} }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig = plt.figure(figsize = (20, 6))\n", "plt.subplot(1, 2, 1)\n", "plt.plot(epoch_tr_acc, label='Train Acc')\n", "plt.plot(epoch_vl_acc, label='Validation Acc')\n", "plt.title(\"Accuracy\")\n", "plt.legend()\n", "plt.grid()\n", "\n", "plt.subplot(1, 2, 2)\n", "plt.plot(epoch_tr_loss, label='Train loss')\n", "plt.plot(epoch_vl_loss, label='Validation loss')\n", "plt.title(\"Loss\")\n", "plt.legend()\n", "plt.grid()\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "execution": {} }, "source": [ "---\n", "# What's Next?\n", "\n", "You can use this project template as a starting point to think about your own project. There are a lot of ways to continue, here we share with you some ideas you migth find useful:\n", "\n", "* **Work on the Preproccesing.** We used a very rudimentary way to tokenize tweets. But there are better ways to preprocess the data. Can you think of a suitable way to preprocess the data for this particular task? How does the performance of the model change when the data is processed correctly?\n", "* **Work on the Model.** The RNN model proposed in this notebook is not optimized at all. You can work on finding a better architecture or better hyperparamenters. May be using bidirectonal LSTMs or increasing the number of stacked layers can improve the performance, feel free to try different approaches.\n", "* **Work on the Embedding.** Our model learnt an embedding during the training on this Twitter corpus for a particular task. You can explore the representation of different words in this learned embedding. Also, you can try using different word embeddings. You can train them on this corpus or you can use an embedding trained on another corpus of data. How does the change of the embedding affect the model performance?\n", "* **Try sentiment analysis on another dataset.** There are lots of available dataset to work with, we can help you find one that is interesting to you. Do you belive that a sentiment analysis model trained on some corpus (Twitter dataset) will perform well on another type of data (for example, youtube comments)?\n", "\n" ] } ], "metadata": { "accelerator": "GPU", "colab": { "collapsed_sections": [], "include_colab_link": true, "name": "sentiment_analysis", "provenance": [], "toc_visible": true }, "kernel": { "display_name": "Python 3", "language": "python", "name": "python3" }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.16" } }, "nbformat": 4, "nbformat_minor": 4 }