Sentiment_Analysis_NLP.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sentiment Analysis: Large Movie Review Dataset\n",
    "\n",
    "Regarding the data, we are not going to have a __csv file__, that would be too easy :) instead we are going to download the data from [AI Stanford Dataset](https://ai.stanford.edu/~amaas/data/sentiment/). When you download them you will notice that their format is text files, so you will have to work a little there to be able to use and process them. This is a dataset for __binary sentiment classification__.\n",
    "\n",
    "Basically a basic sentiment analysis problem, as in this case, consists of a classification problem, where the possible output labels are: `positive` and `negative`. Which indicates, if the review of a movie speaks positively or negatively. In our case it is a binary problem, but one could have many more \"feelings\" tagged and thus allow a more granular analysis.\n",
    "\n",
    "### These are the objectives of the project:\n",
    "\n",
    "* Read data that is not in a traditional format.\n",
    "* Put together a set of preprocessing functions that we can use later on any NLP or related problems.\n",
    "* Vectorize the data in order to apply a machine learning model to it: using BoW or TF-IDF.\n",
    "* BoW and TF-IDF are classic ways to vectorize text, but currently we have some more complex ways with better performance, for this we are going to train our own word embedding and use it as a vectorization source for our data.\n",
    "* Train a sentiment analysis model that allows us to detect positive and negative opinions in movie reviews."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import classic libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os\n",
    "\n",
    "# Import modules\n",
    "from evaluation import plot_roc\n",
    "import text_normalizer\n",
    "\n",
    "# Import NLP libraries\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from nltk.tokenize.toktok import ToktokTokenizer\n",
    "from concurrent.futures import ProcessPoolExecutor\n",
    "import nltk\n",
    "\n",
    "# Import Model and metric libraries\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.preprocessing import label_binarize\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import recall_score\n",
    "from evaluation import get_performance\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn import metrics\n",
    "import evaluation\n",
    "from gensim.models import Word2Vec\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 1. Get the data\n",
    "\n",
    "#### Download the data and process it in order to obtain:\n",
    "\n",
    "* `X_train:` list with reviews for training.\n",
    "* `y_train:` list with labels for training.\n",
    "* `X_test:` list with reviews for testing.\n",
    "* `y_test:` list with labels for testing.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "reviews = []\n",
    "data_directory = \"/home/app/src/aclImdb\"\n",
    "datasets = [\"train\", \"test\"]\n",
    "labels = {'pos': 1, 'neg': 0}\n",
    "\n",
    "# iterate over datasets directory to generate a list of reviews\n",
    "for dataset in datasets:\n",
    "    for label in labels.keys():\n",
    "        # iterate over classes directory\n",
    "        labeled_directory = f\"{data_directory}/{dataset}/{label}\"\n",
    "        for review in os.listdir(labeled_directory):\n",
    "            #open each file and save the content in a list of reviews\n",
    "            with open(f\"{labeled_directory}/{review}\") as f:\n",
    "                text = f.read()\n",
    "                reviews.append({'dataset': dataset,'sentence': text, 'label': labels[label]})\n",
    "\n",
    "# create a dataframe with the generated reviews list\n",
    "reviews = pd.DataFrame(reviews)\n",
    "X_train = reviews[reviews[\"dataset\"] == \"train\"]\n",
    "y_train = X_train[\"label\"]\n",
    "\n",
    "X_test = reviews[reviews[\"dataset\"] == \"test\"]\n",
    "y_test = X_test[\"label\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Don't change anything in this block, just make it run correctly*\n",
    "\n",
    "We are going to check that you have done it right and for that we are going to see if the dimensions match."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading Data Success!\n"
     ]
    }
   ],
   "source": [
    "def check_data(X_train, y_train, X_test, y_test):\n",
    "    if len(X_train) == len(y_train) == len(X_test) == len(y_test) == 25000:\n",
    "        print('Reading Data Success!')\n",
    "    else:\n",
    "        raise ValueError('Dimensions do not match!')\n",
    "\n",
    "check_data(X_train, y_train, X_test, y_test)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 2. Normalize the data\n",
    "\n",
    "#### Respect names and minimal interfaces:\n",
    "\n",
    "* `remove_html_tags(text):` to remove all HTML tags that may be present in text.\n",
    "* `remove_accented_chars(text):` to remove accented characters from text\n",
    "* `expand_contractions(text):` to expand contractions of the type, \"don't\" to \"do not\". The contractions are already defined in the \"contractions.py\" file.\n",
    "* `lemmatize_text(text):` to lemmatize text.\n",
    "* `stem_text(text):` to apply stemming (NLTK's PorterStemmer) on text.\n",
    "* `remove_special_chars(text):` to remove special characters from text.\n",
    "* `remove_special_chars(text, remove_digits=True):` to remove numbers, note that it is the same function to remove special characters with the addition of an argument that enables or disables the removal of numbers.\n",
    "* `remove_stopwords(text, stopwords=stop_words):` to remove stopwords from text.\n",
    "* `remove_extra_new_lines(text):` to remove extra newlines from text.\n",
    "* `remove_extra_whitespace(text):` to remove extra whitespaces from text.\n",
    "\n",
    "If you want to add more features that would be great, for example you could start by removing emojis, using different stemming algorithms, etc. The more functions you have the better, remember that the texts are very varied and the preprocessing depends a lot on the source of our data.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Don't change anything in this block, just make it run correctly*\n",
    "\n",
    "We are going to check that the pre-processing does what we need it to do, for this we are going to test the functions with predefined inputs and we are going to see if the outputs match what we are looking for.\n",
    "\n",
    "Note that the functions are not defined in the notebook itself, but rather that they are in a python file and you must import them in order to use them. Same thing with names, you're going to have to name your functions the way they were named."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1/10] Remove HTML Success!\n",
      "[2/10] Remove Accented Success!\n",
      "[3/10] Expand Contractions Success!\n",
      "[4/10] Lemmatization Success!\n",
      "[5/10] Stemming Success!\n",
      "[6/10] Remove Specials Success!\n",
      "[7/10] Remove Digits Success!\n",
      "[8/10] Remove Stopwords Success!\n",
      "[9/10] Remove New Lines Success!\n",
      "[10/10] Remove Extra Whitespaces Success!\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Inputs\n",
    "doc_html = \"\"\"\n",
    "<br /><br />But with plague out there and the news being kept a secret,\n",
    "the New Orleans PD starts a dragnet of the city's underworld.\n",
    "\"\"\"\n",
    "doc_accented = \"Héllo, thís is an accented sénténce.\"\n",
    "doc_contractions = \"I can't, because it doesn't work.\"\n",
    "doc_lemma = \"The striped bats are hanging on their feet for best\"\n",
    "doc_stem = \"\"\"\n",
    "Where did he learn to dance like that?\n",
    "His eyes were dancing with humor.\n",
    "She shook her head and danced away.\n",
    "\"\"\"\n",
    "doc_specials = \"hello? there A-Z-R_T(,**), world, welcome to python. this **should? the next line#followed- by@ an#other %million^ %%like $this.\"\n",
    "doc_digits = \"abc123def456ghi789zero0 hello my friend number 10\"\n",
    "doc_stop = \"He is a very good person\"\n",
    "doc_new_lines = \"\"\"we\n",
    "use\n",
    "a\n",
    "lot\n",
    "of\n",
    "lines\"\"\"\n",
    "doc_spaces = \"Hello           my      dear          friend\"\n",
    "\n",
    "# Outputs\n",
    "good_html = \"\"\"\n",
    "But with plague out there and the news being kept a secret,\n",
    "the New Orleans PD starts a dragnet of the city's underworld.\n",
    "\"\"\"\n",
    "good_accented = \"Hello, this is an accented sentence.\"\n",
    "good_contractions = \"I cannot, because it does not work.\"\n",
    "good_lemma = \"the stripe bat be hang on their foot for good\"\n",
    "good_stem = \"where did he learn to danc like that ? hi eye were danc with humor. she shook her head and danc away .\"\n",
    "good_specials = \"hello there AZRT world welcome to python this should the next linefollowed by another million like this\"\n",
    "good_digits = \"abcdefghizero hello my friend number \"\n",
    "good_stop = \"good person\"\n",
    "good_new_lines = \"we use a lot of lines\"\n",
    "good_spaces = \"Hello my dear friend\"\n",
    "stop_words = nltk.corpus.stopwords.words('english')\n",
    "\n",
    "def check_normalization():\n",
    "    if good_html == text_normalizer.remove_html_tags(doc_html):\n",
    "        print('[1/10] Remove HTML Success!')\n",
    "    else:\n",
    "        raise ValueError('[1/10] Remove HTML Fail!')\n",
    "        \n",
    "    if good_accented == text_normalizer.remove_accented_chars(doc_accented):\n",
    "        print('[2/10] Remove Accented Success!')\n",
    "    else:\n",
    "        raise ValueError('[2/10] Remove Accented Fail!')\n",
    "        \n",
    "    if good_contractions == text_normalizer.expand_contractions(doc_contractions):\n",
    "        print('[3/10] Expand Contractions Success!')\n",
    "    else:\n",
    "        raise ValueError('[3/10] Expand Contractions Fail!')\n",
    "        \n",
    "    if good_lemma == text_normalizer.lemmatize_text(doc_lemma):\n",
    "        print('[4/10] Lemmatization Success!')\n",
    "    else:\n",
    "        raise ValueError('[4/10] Lemmatization Fail!')\n",
    "        \n",
    "    #print(text_normalizer.stem_text(doc_stem))\n",
    "    if good_stem == text_normalizer.stem_text(doc_stem):\n",
    "        print('[5/10] Stemming Success!')\n",
    "    else:\n",
    "        raise ValueError('[5/10] Stemming Fail!')\n",
    "        \n",
    "    if good_specials == text_normalizer.remove_special_chars(doc_specials):\n",
    "        print('[6/10] Remove Specials Success!')\n",
    "    else:\n",
    "        raise ValueError('[6/8] Remove Specials Fail!')\n",
    "        \n",
    "    if good_digits == text_normalizer.remove_special_chars(doc_digits, remove_digits=True):\n",
    "        print('[7/10] Remove Digits Success!')\n",
    "    else:\n",
    "        raise ValueError('[7/10] Remove Digits Fail!')\n",
    "        \n",
    "    if good_stop == text_normalizer.remove_stopwords(doc_stop, stopwords=stop_words):\n",
    "        print('[8/10] Remove Stopwords Success!')\n",
    "    else:\n",
    "        raise ValueError('[8/10] Remove Stopwords Fail!')\n",
    "    \n",
    "    if good_new_lines == text_normalizer.remove_extra_new_lines(doc_new_lines):\n",
    "        print('[9/10] Remove New Lines Success!')\n",
    "    else:\n",
    "        raise ValueError('[9/10] Remove New Lines Fail!')\n",
    "        \n",
    "    if good_spaces == text_normalizer.remove_extra_whitespace(doc_spaces):\n",
    "        print('[10/10] Remove Extra Whitespaces Success!')\n",
    "    else:\n",
    "        raise ValueError('[10/10] Remove Extra Whitespaces Fail!')\n",
    "\n",
    "check_normalization()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3. Feature Engineering\n",
    "\n",
    "You already have the pr-eprocessed data, now you must vectorize them, because remember that the models only understand numbers. At this stage choose whether you want to vectorize with BoW or with TF-IDF. Later we will train our own embedding but for now we go with a more \"classic\" vectorization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_norm = text_normalizer.normalize_corpus(X_train.sentence,text_lemmatization=True)\n",
    "X_test_norm = text_normalizer.normalize_corpus(X_test.sentence,text_lemmatization=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "\n",
    "tfidf_vectorizer = TfidfVectorizer(min_df = 0.001, ngram_range = (1,2))\n",
    "\n",
    "X_train_vec = tfidf_vectorizer.fit_transform(X_train_norm)\n",
    "X_test_vec = tfidf_vectorizer.transform(X_test_norm)\n",
    "\n",
    "y_train_vec = np.array(y_train)\n",
    "y_test_vec = np.array(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25000, 16193)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_vec.shape"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Modeling and Performance Evaluation\n",
    "\n",
    "In addition to training the model, I show:\n",
    "\n",
    "* `Precision`\n",
    "* `Recall`\n",
    "* `F1-Score`\n",
    "* `Classification Report`\n",
    "* `Confusion Matrix`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-2 {color: black;background-color: white;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>RandomForestClassifier(max_depth=150, min_samples_leaf=4, min_samples_split=5,\n",
       "                       n_estimators=250)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" checked><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">RandomForestClassifier</label><div class=\"sk-toggleable__content\"><pre>RandomForestClassifier(max_depth=150, min_samples_leaf=4, min_samples_split=5,\n",
       "                       n_estimators=250)</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "RandomForestClassifier(max_depth=150, min_samples_leaf=4, min_samples_split=5,\n",
       "                       n_estimators=250)"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier \n",
    "best_params = {'max_depth': 150, 'min_samples_leaf':4, 'min_samples_split': 5, 'n_estimators': 250}\n",
    "rf_best = RandomForestClassifier(**best_params)\n",
    "rf_best.fit(X_train_vec, y_train_vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Don't change anything in this block, just make it run correctly*\n",
    "\n",
    "Let's check that the `get_performance` function returns the metrics correctly. For that we are going to simulate input/output data of a model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model Performance metrics:\n",
      "------------------------------\n",
      "Accuracy: 0.6\n",
      "Precision: 0.6\n",
      "Recall: 0.6\n",
      "F1 Score: 0.6\n",
      "\n",
      "Model Classification report:\n",
      "------------------------------\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1       0.60      0.60      0.60         5\n",
      "           0       0.60      0.60      0.60         5\n",
      "\n",
      "    accuracy                           0.60        10\n",
      "   macro avg       0.60      0.60      0.60        10\n",
      "weighted avg       0.60      0.60      0.60        10\n",
      "\n",
      "\n",
      "Prediction Confusion Matrix:\n",
      "------------------------------\n",
      "   0  1\n",
      "0  3  2\n",
      "1  2  3\n",
      "Success!\n"
     ]
    }
   ],
   "source": [
    "def check_basic_metrics():\n",
    "    accuracy, precision, recall, f1_score = evaluation.get_performance(\n",
    "        [1, 1, 1, 1, 1, 0, 0, 0, 0, 0], \n",
    "        [1, 1, 1, 0, 0, 1, 1, 0, 0, 0]\n",
    "    )\n",
    "    \n",
    "    if (accuracy, precision, recall, f1_score) == (0.6, 0.6, 0.6, 0.6):\n",
    "        print('Success!')\n",
    "    else:\n",
    "        raise ValueError('You must check your get_performance function!')\n",
    "        \n",
    "check_basic_metrics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "roc_auc  = plot_roc(rf_best, y_test, X_test_vec)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see if your model at least exceeds an ROC-AUC of 0.93"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success!\n"
     ]
    }
   ],
   "source": [
    "def check_roc(roc_auc):\n",
    "    if roc_auc > 0.93:\n",
    "        print('Success!')\n",
    "    else:\n",
    "        raise ValueError('Your model is not good enough!')\n",
    "        \n",
    "check_roc(roc_auc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model Performance metrics:\n",
      "------------------------------\n",
      "Accuracy: 0.85648\n",
      "Precision: 0.8498743718592965\n",
      "Recall: 0.86592\n",
      "F1 Score: 0.8578221588207323\n",
      "\n",
      "Model Classification report:\n",
      "------------------------------\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1       0.85      0.87      0.86     12500\n",
      "           0       0.86      0.85      0.86     12500\n",
      "\n",
      "    accuracy                           0.86     25000\n",
      "   macro avg       0.86      0.86      0.86     25000\n",
      "weighted avg       0.86      0.86      0.86     25000\n",
      "\n",
      "\n",
      "Prediction Confusion Matrix:\n",
      "------------------------------\n",
      "       0      1\n",
      "0  10824   1676\n",
      "1   1912  10588\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.85648, 0.8498743718592965, 0.86592, 0.8578221588207323)"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Performance evaluation\n",
    "y_pred_nn = rf_best.predict(X_test_vec)\n",
    "evaluation.get_performance(y_pred_nn,y_test)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 5. Feature Engineering with Custom Word Embedding\n",
    "\n",
    "### Tokenize reviews and train Word Embedding\n",
    "\n",
    "I have to train my own word embedding, for this I'm going to use the __gensim__ library.\n",
    "\n",
    "[Here](https://radimrehurek.com/gensim/models/word2vec.html) you can read Gensim's Word2Vec documentation so you can train your own embedding, using the review data as a corpus.\n",
    "\n",
    "As a previous step to training your word embedding you must tokenize the corpus, this may take a bit depending on the size of the dataset and the tokenizer we use, if you want you can try the NLTK tokenizer called `ToktokTokenizer`, which turns out to be a little faster (we hope that this recommendation does not bias your work, try and use the ones you want)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenizer = ToktokTokenizer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "token_train=[tokenizer.tokenize(token) for token in X_train.sentence]\n",
    "    \n",
    "token_test=[tokenizer.tokenize(token) for token in X_test.sentence]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Word embedding\n",
    "model_w2v = Word2Vec(token_train, vector_size=100,epochs=15, window=15, min_count=7, negative= 20, workers=12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate averaged word vector features\n",
    "\n",
    "Once the embedding has been trained, we must use it. Remember that embedding will convert each word you pass to it into a vector of a given dimension (in our case $vector\\_size=100$). So in order to obtain a vector for each review, you must average the vectors of all the words that are part of the same review.\n",
    "\n",
    "The function must have the following form:\n",
    "* `vectorizer(corpus, model, num_features=100)`\n",
    "\n",
    "\n",
    "Where:\n",
    "* `corpus:` corresponds to the entire dataset, in this way we obtain an average vector for each review, with a single call to the function.\n",
    "* `model:` is your trained model.\n",
    "* `num_features:` the dimension of the output vector of your embedding (remember that in our case we set this value to 100)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vectorizer(corpus, model, num_features=100):\n",
    "    \n",
    "    # Initiate variables\n",
    "    vector_sum = np.zeros(shape=(num_features,))\n",
    "    x_train_average = list()\n",
    "    corpus_vectors = list()\n",
    "\n",
    "    # Loop to average the vectors in a sentence\n",
    "    for sentence in corpus:\n",
    "        counter = 0\n",
    "        for token in sentence:\n",
    "            if token in model.wv:\n",
    "                word_vector = model.wv[token]           # Get the vector of the word\n",
    "                vector_sum = vector_sum + word_vector   # Sum vectors of the same sentence\n",
    "                counter += 1\n",
    "        average = vector_sum/counter                # Calculate the average of the vectors\n",
    "        corpus_vectors.append(average)              # Create a list of average vectors\n",
    "    return corpus_vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Don't change anything in this block, just make it run correctly*\n",
    "\n",
    "Let's do a simple check of the embedding that you just trained."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success! Your embedding tells me that \"women\" and \"man\" are similar with a score of 0.7156654596328735\n"
     ]
    }
   ],
   "source": [
    "def check_embedding(model):\n",
    "    vector = model.wv['computer']\n",
    "    if len(vector) == 100:\n",
    "        print(\n",
    "            'Success! Your embedding tells me that \"women\" and \"man\" '\n",
    "            f'are similar with a score of {model.wv.similarity(\"woman\", \"man\")}'\n",
    "        )\n",
    "    else:\n",
    "        raise ValueError('You should check your embedding vector size!')\n",
    "        \n",
    "check_embedding(model_w2v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we are going to check the vectorizer, remember that the vectorizer must generate an average vector of all the words present in the same review. So we're going to get two vectors of two words and manually average them, then using those two words we'll simulate a tokenized sentence and see that it matches the manual way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success!\n"
     ]
    }
   ],
   "source": [
    "def check_vectorizer(model):\n",
    "    vector1 = model.wv['personal']\n",
    "    vector2 = model.wv['computer']\n",
    "    avg = vectorizer([['personal', 'computer']], model)[0]\n",
    "\n",
    "    if np.allclose((vector1 + vector2) / 2, avg):\n",
    "        print('Success!')\n",
    "    else:\n",
    "        raise ValueError('You should check your vectorizer!')\n",
    "        \n",
    "check_vectorizer(model_w2v)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modeling\n",
    "\n",
    "Finally train a new model, it can be the same one you used before and compare the results you got using BoW/TF-IDF and Word2Vec.\n",
    "\n",
    "In addition to training the model I show:\n",
    "\n",
    "* `Accuracy`\n",
    "* `Recall`\n",
    "* `F1-Score`\n",
    "* `Classification Report`\n",
    "* `Confusion Matrix`\n",
    "* `ROC Curve`\n",
    "* `Obtain the ROC-AUC value (later we will do a small minimum performance check with this value)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Vectorize x_train, x_test\n",
    "X_train_w2v = vectorizer(token_train, model=model_w2v, num_features=100)\n",
    "X_test_w2v = vectorizer(token_test, model=model_w2v, num_features=100)\n",
    "\n",
    "# Creating the classifier\n",
    "Logisticregression = LogisticRegression(max_iter=2000)   \n",
    "\n",
    "# Training the model\n",
    "Logisticregression.fit(X_train_w2v, y_train)\n",
    "\n",
    "# Predictions\n",
    "predictions = Logisticregression.predict(X_test_w2v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model Performance metrics:\n",
      "------------------------------\n",
      "Accuracy: 0.69668\n",
      "Precision: 1.0\n",
      "Recall: 0.39336\n",
      "F1 Score: 0.5646207728081759\n",
      "\n",
      "Model Classification report:\n",
      "------------------------------\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1       1.00      0.39      0.56     12500\n",
      "           0       0.62      1.00      0.77     12500\n",
      "\n",
      "    accuracy                           0.70     25000\n",
      "   macro avg       0.81      0.70      0.67     25000\n",
      "weighted avg       0.81      0.70      0.67     25000\n",
      "\n",
      "\n",
      "Prediction Confusion Matrix:\n",
      "------------------------------\n",
      "      0      1\n",
      "0  4917   7583\n",
      "1     0  12500\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.69668, 1.0, 0.39336, 0.5646207728081759)"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculate the performance of Word 2 Vec\n",
    "get_performance(predictions.round(), y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculate the roc_auc of Word 2 Vec\n",
    "roc_auc = plot_roc(model=Logisticregression, y_test=y_test, features=X_test_w2v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Don't change anything in this block, just make it run correctly*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success!\n"
     ]
    }
   ],
   "source": [
    "check_roc(roc_auc)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "949777d72b0d2535278d3dc13498b2535136f6dfe0678499012e853ee9abcab1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}