Sentiment_Analysis.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "cite2c": {
      "citations": {
        "7971447/2EP5P4QP": {
          "id": "7971447/2EP5P4QP",
          "title": "wvSent_acl2011.bib",
          "type": "article"
        }
      }
    },
    "colab": {
      "name": "Sentiment Analysis-new.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "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.7.7"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NiU07mzh6tfd",
        "colab_type": "text"
      },
      "source": [
        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Karthik-Bhaskar/Sentiment-Analysis/blob/master/Sentiment_Analysis.ipynb#scrollTo=NiU07mzh6tfd)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "6Gc-nsKPMXbf"
      },
      "source": [
        "### Sentiment Analysis on IMDB Dataset Using Word Embeddings "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "wSXINwrrMXbh"
      },
      "source": [
        "**Dataset: IMDB movies review dataset, containing binary classes of Positive and Negative sentiments about the movies**\n",
        "\n",
        "**Problem Statement: Binary Classification on Sentiments**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "MiSwN0DWMXbk"
      },
      "source": [
        "Let's get started by importing the required libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "1APodJ6OMXbl",
        "scrolled": true,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "da096b7b-7ed3-41c0-f3bc-6c62a3f25aff"
      },
      "source": [
        "\n",
        "import sys\n",
        "import os\n",
        "import re\n",
        "import pickle\n",
        "import random\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
        "from sklearn.metrics import classification_report, accuracy_score, plot_confusion_matrix\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.model_selection import KFold,train_test_split,GridSearchCV\n",
        "from sklearn.feature_extraction.text import CountVectorizer\n",
        "from sklearn.metrics import roc_curve, roc_auc_score\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.colors as pltc\n",
        "\n",
        "from wordcloud import WordCloud\n",
        "from PIL import Image\n",
        "\n",
        "\n",
        "import gensim\n",
        "from gensim.models import Word2Vec, KeyedVectors\n",
        "from collections import Counter, defaultdict\n",
        "from tqdm import tqdm\n",
        "\n",
        "\n",
        "# For Preprocessing and nlp \n",
        "import nltk\n",
        "from bs4 import BeautifulSoup\n",
        "from nltk.tokenize.toktok import ToktokTokenizer\n",
        "tokenizer = ToktokTokenizer()\n",
        "nltk.download('stopwords')\n",
        "stopword_list = nltk.corpus.stopwords.words('english')\n",
        "stopword_list.remove('no')\n",
        "stopword_list.remove('not')\n",
        "import unicodedata\n",
        "nltk.download('wordnet')\n",
        "nltk.download('punkt')\n",
        "nltk.download('averaged_perceptron_tagger')\n",
        "from nltk.corpus import wordnet\n",
        "nltk_lemmatizer = nltk.stem.WordNetLemmatizer()\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[nltk_data] Downloading package stopwords to\n",
            "[nltk_data]     /Users/karthik/nltk_data...\n",
            "[nltk_data]   Package stopwords is already up-to-date!\n",
            "[nltk_data] Downloading package wordnet to /Users/karthik/nltk_data...\n",
            "[nltk_data]   Package wordnet is already up-to-date!\n",
            "[nltk_data] Downloading package punkt to /Users/karthik/nltk_data...\n",
            "[nltk_data]   Package punkt is already up-to-date!\n",
            "[nltk_data] Downloading package averaged_perceptron_tagger to\n",
            "[nltk_data]     /Users/karthik/nltk_data...\n",
            "[nltk_data]   Package averaged_perceptron_tagger is already up-to-\n",
            "[nltk_data]       date!\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "K5Hy9Tu5MXb1"
      },
      "source": [
        "#### Data Import"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "3JC4oYDxMXb4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d5b634f3-94e4-4571-cc02-a04255ecee9b"
      },
      "source": [
        "def load_data(filename,no_of_records):\n",
        "    process_records = True\n",
        "    data_load = pd.read_csv(filename)\n",
        "    if filename == \"processed.csv\":\n",
        "        process_records = False\n",
        "        data_load = data_load.drop(columns=['Unnamed: 0'])\n",
        "    data_load= data_load[0:no_of_records]\n",
        "    return data_load,process_records\n",
        "\n",
        "# Original dataset - IMDB Dataset.csv\n",
        "# Pre-processed dataset - processed.csv\n",
        "\n",
        "\n",
        "\n",
        "data_orig,process_records = load_data('IMDB Dataset.csv',50000)\n",
        "print(\"Dataset shape:\",data_orig.shape)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dataset shape: (50000, 2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "8ODW2jOJMXb_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "0d0d9a5d-f574-4cab-c65b-69add6444c21"
      },
      "source": [
        "data_orig.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>review</th>\n",
              "      <th>sentiment</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>One of the other reviewers has mentioned that ...</td>\n",
              "      <td>positive</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>A wonderful little production. &lt;br /&gt;&lt;br /&gt;The...</td>\n",
              "      <td>positive</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>I thought this was a wonderful way to spend ti...</td>\n",
              "      <td>positive</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>Basically there's a family where a little boy ...</td>\n",
              "      <td>negative</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>Petter Mattei's \"Love in the Time of Money\" is...</td>\n",
              "      <td>positive</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                              review sentiment\n",
              "0  One of the other reviewers has mentioned that ...  positive\n",
              "1  A wonderful little production. <br /><br />The...  positive\n",
              "2  I thought this was a wonderful way to spend ti...  positive\n",
              "3  Basically there's a family where a little boy ...  negative\n",
              "4  Petter Mattei's \"Love in the Time of Money\" is...  positive"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "3_RfQKRzMXcG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "7674b7e5-b2a5-4c04-df98-50813931cb51"
      },
      "source": [
        "def class_div(data):\n",
        "    data_orig['sentiment'] = data\n",
        "    if process_records == False:\n",
        "        pos = 1\n",
        "        neg = 0\n",
        "\n",
        "    else:\n",
        "        pos = 'positive'\n",
        "        neg = 'negative'\n",
        "\n",
        "\n",
        "    total_counts = data_orig['sentiment'].value_counts().to_dict()\n",
        "    print(total_counts)\n",
        "\n",
        "    pos_percent = round((total_counts[pos]/data_orig.shape[0])*100,2)\n",
        "    neg_percent = round((total_counts[neg]/data_orig.shape[0])*100,2)\n",
        "\n",
        "    labels = 'Positive', 'Negative'\n",
        "    sizes = [pos_percent,neg_percent]\n",
        "    explode = (0.1, 0) \n",
        "    fig1, ax1 = plt.subplots()\n",
        "    ax1.pie(sizes, explode=explode, labels=labels, autopct='%1.2f%%',\n",
        "            shadow=True, startangle=90)\n",
        "    ax1.axis('equal')  \n",
        "\n",
        "    plt.show()\n",
        "    \n",
        "    return\n",
        "\n",
        "class_div(data_orig['sentiment'])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'positive': 25000, 'negative': 25000}\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "cRqqQ1X8MXcO"
      },
      "source": [
        "let's review a sample."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "MV8hsUZZMXcP",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "66e953db-7058-43d0-8689-e833ff1c9185"
      },
      "source": [
        "data_orig['review'].iloc[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"One of the other reviewers has mentioned that after watching just 1 Oz episode you'll be hooked. They are right, as this is exactly what happened with me.<br /><br />The first thing that struck me about Oz was its brutality and unflinching scenes of violence, which set in right from the word GO. Trust me, this is not a show for the faint hearted or timid. This show pulls no punches with regards to drugs, sex or violence. Its is hardcore, in the classic use of the word.<br /><br />It is called OZ as that is the nickname given to the Oswald Maximum Security State Penitentary. It focuses mainly on Emerald City, an experimental section of the prison where all the cells have glass fronts and face inwards, so privacy is not high on the agenda. Em City is home to many..Aryans, Muslims, gangstas, Latinos, Christians, Italians, Irish and more....so scuffles, death stares, dodgy dealings and shady agreements are never far away.<br /><br />I would say the main appeal of the show is due to the fact that it goes where other shows wouldn't dare. Forget pretty pictures painted for mainstream audiences, forget charm, forget romance...OZ doesn't mess around. The first episode I ever saw struck me as so nasty it was surreal, I couldn't say I was ready for it, but as I watched more, I developed a taste for Oz, and got accustomed to the high levels of graphic violence. Not just violence, but injustice (crooked guards who'll be sold out for a nickel, inmates who'll kill on order and get away with it, well mannered, middle class inmates being turned into prison bitches due to their lack of street skills or prison experience) Watching Oz, you may become comfortable with what is uncomfortable viewing....thats if you can get in touch with your darker side.\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "udgZVNynMXcR",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "263361a6-50b1-42e6-8b9f-b718df8fa67f"
      },
      "source": [
        "data_orig['sentiment'].iloc[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'positive'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "cMjHVPBQMXcV"
      },
      "source": [
        "As we can see in the review text sample there are HTML tags, special characters, Un-even textcases in-between. So, text pre-processing is performed in order to make the text look more presentable and clean as it  helps in maining the vocabulary size."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "w_zwtzueMXcV"
      },
      "source": [
        "#### Text Pre-processing\n",
        "\n",
        "The main pre-processing done here are,\n",
        "1. Striping the in-between html tags\n",
        "2. Getting rid of underscores and white spaces\n",
        "3. Making the text look uniform by converting to lower case, which also helps in reducing vocabulary size\n",
        "4. Converting the accented characters to normal characters (Example: Café -> Cafe)\n",
        "5. Removing special characters and numbers\n",
        "6. Stop word removal as it does not help much in our analysis\n",
        "7. Lemmatizing in-order to obtain lemma from the text (Example: Mice -> Mouse)\n",
        "8. Converting the the textual categories to numerical categories (Positive -> 1, Negative -> 0)\n",
        "\n",
        "And the list does not end here, other text pre-processing can be done (Example: Spell Correction) and some of these pre-processing can also be performed using sklearn, textblob."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "yAJl8j5RMXcW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "8e455240-c01d-4626-da83-60d8b185bbf6"
      },
      "source": [
        "\n",
        "def strip_html_tags(text):\n",
        "    soup = BeautifulSoup(text, \"html.parser\")\n",
        "    stripped_text = soup.get_text()\n",
        "    return stripped_text\n",
        "\n",
        "def remove_underscore(text):\n",
        "    text = text.replace(\"_\",\" \")\n",
        "    return text\n",
        "\n",
        "def remove_white_spaces(text):\n",
        "    text = \" \".join(text.split())\n",
        "    return text\n",
        "\n",
        "def to_lower_case(text):\n",
        "    text = text.lower()\n",
        "    return text\n",
        "\n",
        "def remove_accented_chars(text):\n",
        "    text = unicodedata.normalize('NFKD', text).encode('ascii', 'ignore').decode('utf-8', 'ignore')\n",
        "    return text\n",
        "\n",
        "# Removes Numbers\n",
        "def remove_special_characters(text, remove_digits=False):\n",
        "    pattern = r'[^a-zA-z0-9\\s]' if not remove_digits else r'[^a-zA-z\\s]'\n",
        "    text = re.sub(pattern, '', text)\n",
        "    return text\n",
        "\n",
        "\n",
        "def stop_word_remover(text):\n",
        "    tokens = tokenizer.tokenize(text)\n",
        "    filtered_sentence = []\n",
        "    for token in tokens: \n",
        "        if token not in stopword_list: \n",
        "            filtered_sentence.append(token)\n",
        "            \n",
        "    return \" \".join(filtered_sentence)\n",
        "\n",
        "def get_wordnet_pos(word):\n",
        "    \"\"\"Map POS tag to first character lemmatize() accepts\"\"\"\n",
        "    tag = nltk.pos_tag([word])[0][1][0].upper()\n",
        "    tag_dict = {\"J\": wordnet.ADJ,\n",
        "                \"N\": wordnet.NOUN,\n",
        "                \"V\": wordnet.VERB,\n",
        "                \"R\": wordnet.ADV}\n",
        "    return tag_dict.get(tag, wordnet.NOUN)\n",
        "\n",
        "def lemmatize_text(text):\n",
        "    tokens = nltk.word_tokenize(text)\n",
        "    lemmatized_output = ' '.join([nltk_lemmatizer.lemmatize(token,get_wordnet_pos(token)) for token in tokens])\n",
        "    return lemmatized_output\n",
        "\n",
        "def pre_process(text):\n",
        "    text = strip_html_tags(text)\n",
        "    text = remove_underscore(text)\n",
        "    text = remove_white_spaces(text)\n",
        "    text = to_lower_case(text)\n",
        "    text = remove_accented_chars(text)\n",
        "    text = remove_special_characters(text, remove_digits=True)\n",
        "    text = stop_word_remover(text)\n",
        "    text = lemmatize_text(text)\n",
        "    return text\n",
        "\n",
        "def start_pre_process():\n",
        "    data_proc = data_orig\n",
        "    if process_records == True:\n",
        "        for i in tqdm(range(len(data_orig['review']))):\n",
        "            data_proc['review'].iloc[i] = pre_process(data_orig['review'].iloc[i])\n",
        "            if data_orig['sentiment'].iloc[i] == 'positive':\n",
        "                data_proc['sentiment'].iloc[i] = 1\n",
        "            else:\n",
        "                data_proc['sentiment'].iloc[i] = 0   \n",
        "\n",
        "        data_proc.to_csv('processed.csv')\n",
        "    return data_proc\n",
        "\n",
        "data_proc = start_pre_process()\n",
        "process_records = False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 50000/50000 [19:14<00:00, 43.30it/s]\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "t6O_q744MXcZ"
      },
      "source": [
        "After pre-processing. The samples looks like this,"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "lebYnr6WMXca",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "0d1a968e-81f2-4364-9a99-80b2b63bbe97"
      },
      "source": [
        "data_proc['review'].iloc[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'one reviewer mention watch oz episode youll hooked right exactly happen methe first thing struck oz brutality unflinching scene violence set right word go trust not show faint hearted timid show pull no punch regard drug sex violence hardcore classic use wordit call oz nickname give oswald maximum security state penitentary focus mainly emerald city experimental section prison cell glass front face inwards privacy not high agenda em city home manyaryans muslim gangsta latino christian italian irish moreso scuffle death stare dodgy dealing shady agreement never far awayi would say main appeal show due fact go show wouldnt dare forget pretty picture paint mainstream audience forget charm forget romanceoz doesnt mess around first episode ever saw struck nasty surreal couldnt say ready watch developed taste oz get accustom high level graphic violence not violence injustice crooked guard wholl sell nickel inmate wholl kill order get away well mannered middle class inmate turn prison bitch due lack street skill prison experience watch oz may become comfortable uncomfortable viewingthats get touch darker side'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "TVd3Aw9BMXcd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e50d6fe9-b9a3-4980-ce45-0e2e73353467"
      },
      "source": [
        "data_proc['sentiment'].iloc[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "a7Hw5Nw3MXcf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "outputId": "8f288604-dafe-422f-b7c2-73203a27f16c"
      },
      "source": [
        "def split_data():\n",
        "    data_proc['sentiment']=data_proc['sentiment'].astype('int')\n",
        "    X_train,X_test,y_train,y_test = train_test_split(data_proc['review'],data_proc['sentiment'] ,random_state=42,test_size=0.2)\n",
        "    return X_train,X_test,y_train,y_test\n",
        "\n",
        "X_train,X_test,y_train,y_test = split_data()\n",
        "\n",
        "print(\"Train set class division\")\n",
        "class_div(y_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Train set class division\n",
            "{0.0: 20039, 1.0: 19961}\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "BTNd9wWiMXcq"
      },
      "source": [
        "Let's see which are the most repeated words in the corpus"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "C9St90DSMXcr",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 232
        },
        "outputId": "a0a58ad0-8e2e-4f76-e021-c36ab808c09b"
      },
      "source": [
        "\n",
        "corpus = X_train\n",
        "vec = CountVectorizer().fit(corpus)\n",
        "bag_of_words = vec.transform(corpus)\n",
        "sum_words = bag_of_words.sum(axis=0) \n",
        "words_freq = [(word, sum_words[0, idx]) for word, idx in     vec.vocabulary_.items()]\n",
        "words_freq =sorted(words_freq, key = lambda x: x[1], reverse=True)\n",
        "words_freq[:10]\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[('movie', 79096),\n",
              " ('film', 73614),\n",
              " ('not', 49439),\n",
              " ('one', 42232),\n",
              " ('make', 35221),\n",
              " ('like', 34321),\n",
              " ('see', 32672),\n",
              " ('get', 27788),\n",
              " ('well', 23784),\n",
              " ('time', 23565)]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "FU34tzV3MXct",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        },
        "outputId": "b55fdba2-7ac2-4ccc-8974-2d5e820a2c9b"
      },
      "source": [
        "w = WordCloud(width=800,height=700,mode='RGBA',background_color='black',max_words=2000).fit_words(dict(words_freq))\n",
        "plt.imshow(w)\n",
        "plt.axis(\"off\")\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "r0sC45P2MXcu"
      },
      "source": [
        "The next step in the process is to convert the textual data to vectorized numerical format. So we can train a model. \n",
        "\n",
        "To achieve this I will use Word Embeddings learned using Word2Vec.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "CxKsgVrcMXc0"
      },
      "source": [
        "#### Word Embeddings\n",
        "\n",
        "\n",
        "<blockquote> A word embedding is a learned representation for text where words that have the same meaning have a similar representation. Word embeddings are in fact a class of techniques where individual words are represented as real-valued vectors in a predefined vector space. Each word is mapped to one vector and the vector values are learned in a way that resembles a neural network, and hence the technique is often lumped into the field of deep learning. \n",
        "    \n",
        "\\- Jason Brownlee ([What Are Word Embeddings for Text?](https://machinelearningmastery.com/what-are-word-embeddings/))\n",
        "\n",
        "</blockquote>\n",
        "\n",
        "Word2Vec is an algorithm which is used to learn word embeddings. \n",
        "\n",
        "\n",
        "\n",
        "There are 2 learning methods in Word2Vec,\n",
        "<ul>\n",
        "    <li> Continuous Bag of words (CBOW) </li>\n",
        "    <li> Skip-gram </li>\n",
        "</ul>\n",
        "\n",
        "Here in Word2Vec approach, I will train a Word2Vec model using CBOW method on the IMDB dataset and also use the pretrained Word2Vec model from Google, trained on Google News. I will analyse the performance of the classifiers based on Word2Vec trained on IMDB dataset and Pre-trained Word2Vec \n",
        "\n",
        "Later, I will encode the features by the below 2 methods in order to train the classifier,\n",
        "<ul>\n",
        "    <li> Computing the mean of embeddings in a sentence </li>\n",
        "    <li> Computing TF-IDF of embeddings in a sentence </li>\n",
        "    \n",
        "</ul>\n",
        "\n",
        "TF-IDF tells us how important the word is in the particular document.\n",
        "\n",
        "\n",
        "The Formula for TF-IDF is,\n",
        "\n",
        "$$ Term\\;Frequency\\;(TF) = \\frac{ Number\\;of\\;times\\;particular\\;word\\;(W)\\;appeared\\;in\\;the\\;document}{Total\\;Number\\;words\\;in\\;that\\;document} $$ <br />\n",
        "\n",
        "$$ Inverse\\;Document\\;Frequency\\;(IDF)\\;=  \\log{\\frac{Number\\;of\\;documents\\;in\\;corpus}{Number\\;of\\;documents\\;in\\;which\\;the\\;particular\\;word\\;(W)\\;appeared}}$$ <br />\n",
        "\n",
        "$$ TFIDF\\;=TF * IDF $$\n",
        "\n",
        "\n",
        "\n",
        "In further section, I will show the difference between mean and tf-idf methods of feature encoding based on Word2Vec vocabulary.\n",
        "\n",
        "\n",
        "#### Word2Vec model trained on IMDB dataset using CBOW\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "2BmEvjXlMXc1",
        "colab": {}
      },
      "source": [
        "def train_w2v():\n",
        "    data_proc_w2v = []\n",
        "    for i in tqdm(range (0,len(X_train))):\n",
        "        data_proc_w2v.append(gensim.utils.simple_preprocess(X_train.iloc[i]))\n",
        "    print(\"Training Word2Vec model ..\")\n",
        "    model = gensim.models.Word2Vec (data_proc_w2v, size=300, window=10, min_count=2, workers=10)\n",
        "    model.train(data_proc_w2v,total_examples=len(data_proc_w2v),epochs=100)\n",
        "    w2v_vocab = model.wv.vocab\n",
        "    #model.save(\"word2vec.model\")\n",
        "    return data_proc_w2v,model,w2v_vocab\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "LJ3Rf4BlMXc3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "4d604013-e5d9-4ce8-f69b-964fa939abcc"
      },
      "source": [
        "data_proc_w2v,model,w2v_vocab = train_w2v()\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 40000/40000 [00:09<00:00, 4228.68it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Training Word2Vec model ..\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "QimplYt7MXc6"
      },
      "source": [
        "Let's see the vocabulary generated using Word2Vec"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "prZ8Wv3VMXc6",
        "scrolled": true,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "30b39804-5b3d-46a3-e312-1e0229be8156"
      },
      "source": [
        "w2v_vocab"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'thats': <gensim.models.keyedvectors.Vocab at 0x13e9bec50>,\n",
              " 'kept': <gensim.models.keyedvectors.Vocab at 0x11e672290>,\n",
              " 'ask': <gensim.models.keyedvectors.Vocab at 0x13ec6a3d0>,\n",
              " 'many': <gensim.models.keyedvectors.Vocab at 0x13ec6a450>,\n",
              " 'fight': <gensim.models.keyedvectors.Vocab at 0x11da07690>,\n",
              " 'scream': <gensim.models.keyedvectors.Vocab at 0x11da072d0>,\n",
              " 'match': <gensim.models.keyedvectors.Vocab at 0x13ef52510>,\n",
              " 'swear': <gensim.models.keyedvectors.Vocab at 0x13ef52390>,\n",
              " 'general': <gensim.models.keyedvectors.Vocab at 0x13ec6a5d0>,\n",
              " 'mayhem': <gensim.models.keyedvectors.Vocab at 0x11da077d0>,\n",
              " 'permeate': <gensim.models.keyedvectors.Vocab at 0x13ef52450>,\n",
              " 'minute': <gensim.models.keyedvectors.Vocab at 0x13ef52490>,\n",
              " 'comparison': <gensim.models.keyedvectors.Vocab at 0x13ef524d0>,\n",
              " 'also': <gensim.models.keyedvectors.Vocab at 0x13ef52550>,\n",
              " 'stand': <gensim.models.keyedvectors.Vocab at 0x13ef52590>,\n",
              " 'think': <gensim.models.keyedvectors.Vocab at 0x13ef52610>,\n",
              " 'onedimensional': <gensim.models.keyedvectors.Vocab at 0x13ef52650>,\n",
              " 'character': <gensim.models.keyedvectors.Vocab at 0x13ef52690>,\n",
              " 'little': <gensim.models.keyedvectors.Vocab at 0x13ef526d0>,\n",
              " 'depth': <gensim.models.keyedvectors.Vocab at 0x13ef52710>,\n",
              " 'virtually': <gensim.models.keyedvectors.Vocab at 0x13ef52750>,\n",
              " 'impossible': <gensim.models.keyedvectors.Vocab at 0x13ef52790>,\n",
              " 'care': <gensim.models.keyedvectors.Vocab at 0x13ef527d0>,\n",
              " 'happens': <gensim.models.keyedvectors.Vocab at 0x13ef52810>,\n",
              " 'badly': <gensim.models.keyedvectors.Vocab at 0x13ef52850>,\n",
              " 'write': <gensim.models.keyedvectors.Vocab at 0x13ef52890>,\n",
              " 'cypher': <gensim.models.keyedvectors.Vocab at 0x13ef528d0>,\n",
              " 'director': <gensim.models.keyedvectors.Vocab at 0x13ef52910>,\n",
              " 'hang': <gensim.models.keyedvectors.Vocab at 0x13ef52950>,\n",
              " 'multicultural': <gensim.models.keyedvectors.Vocab at 0x13ef52990>,\n",
              " 'belief': <gensim.models.keyedvectors.Vocab at 0x13ef529d0>,\n",
              " 'topic': <gensim.models.keyedvectors.Vocab at 0x13ef52a10>,\n",
              " 'do': <gensim.models.keyedvectors.Vocab at 0x13ef52a50>,\n",
              " 'much': <gensim.models.keyedvectors.Vocab at 0x13ef52a90>,\n",
              " 'well': <gensim.models.keyedvectors.Vocab at 0x13ef52ad0>,\n",
              " 'drama': <gensim.models.keyedvectors.Vocab at 0x13ef52b10>,\n",
              " 'tv': <gensim.models.keyedvectors.Vocab at 0x13ef52b50>,\n",
              " 'cinemai': <gensim.models.keyedvectors.Vocab at 0x13ef52b90>,\n",
              " 'must': <gensim.models.keyedvectors.Vocab at 0x13ef52bd0>,\n",
              " 'confess': <gensim.models.keyedvectors.Vocab at 0x13ef52c10>,\n",
              " 'im': <gensim.models.keyedvectors.Vocab at 0x13ef52c50>,\n",
              " 'not': <gensim.models.keyedvectors.Vocab at 0x13ef52c90>,\n",
              " 'really': <gensim.models.keyedvectors.Vocab at 0x13ef52cd0>,\n",
              " 'one': <gensim.models.keyedvectors.Vocab at 0x13ef52d10>,\n",
              " 'spot': <gensim.models.keyedvectors.Vocab at 0x13ef52d50>,\n",
              " 'bad': <gensim.models.keyedvectors.Vocab at 0x13ef52d90>,\n",
              " 'performance': <gensim.models.keyedvectors.Vocab at 0x13ef52dd0>,\n",
              " 'film': <gensim.models.keyedvectors.Vocab at 0x13ef52e10>,\n",
              " 'say': <gensim.models.keyedvectors.Vocab at 0x13ef52e50>,\n",
              " 'burley': <gensim.models.keyedvectors.Vocab at 0x13ef52e90>,\n",
              " 'heroine': <gensim.models.keyedvectors.Vocab at 0x13ef52ed0>,\n",
              " 'slutty': <gensim.models.keyedvectors.Vocab at 0x13ef52f10>,\n",
              " 'best': <gensim.models.keyedvectors.Vocab at 0x13ef52f50>,\n",
              " 'friend': <gensim.models.keyedvectors.Vocab at 0x13ef52f90>,\n",
              " 'wasim': <gensim.models.keyedvectors.Vocab at 0x13ef52fd0>,\n",
              " 'zakir': <gensim.models.keyedvectors.Vocab at 0x13ef67050>,\n",
              " 'nasty': <gensim.models.keyedvectors.Vocab at 0x13ef67090>,\n",
              " 'bullying': <gensim.models.keyedvectors.Vocab at 0x13ef670d0>,\n",
              " 'brother': <gensim.models.keyedvectors.Vocab at 0x13ef67110>,\n",
              " 'absolutely': <gensim.models.keyedvectors.Vocab at 0x13ef67150>,\n",
              " 'terrible': <gensim.models.keyedvectors.Vocab at 0x13ef67190>,\n",
              " 'dont': <gensim.models.keyedvectors.Vocab at 0x13ef671d0>,\n",
              " 'know': <gensim.models.keyedvectors.Vocab at 0x13ef67210>,\n",
              " 'act': <gensim.models.keyedvectors.Vocab at 0x13ef67250>,\n",
              " 'school': <gensim.models.keyedvectors.Vocab at 0x13ef67290>,\n",
              " 'graduate': <gensim.models.keyedvectors.Vocab at 0x13ef672d0>,\n",
              " 'id': <gensim.models.keyedvectors.Vocab at 0x13ef67310>,\n",
              " 'apply': <gensim.models.keyedvectors.Vocab at 0x13ef67350>,\n",
              " 'full': <gensim.models.keyedvectors.Vocab at 0x13ef67390>,\n",
              " 'refund': <gensim.models.keyedvectors.Vocab at 0x13ef673d0>,\n",
              " 'post': <gensim.models.keyedvectors.Vocab at 0x13ef67410>,\n",
              " 'haste': <gensim.models.keyedvectors.Vocab at 0x13ef67450>,\n",
              " 'lead': <gensim.models.keyedvectors.Vocab at 0x13ef67490>,\n",
              " 'role': <gensim.models.keyedvectors.Vocab at 0x13ef674d0>,\n",
              " 'manages': <gensim.models.keyedvectors.Vocab at 0x13ef67510>,\n",
              " 'impress': <gensim.models.keyedvectors.Vocab at 0x13ef67550>,\n",
              " 'cast': <gensim.models.keyedvectors.Vocab at 0x13ef67590>,\n",
              " 'socalled': <gensim.models.keyedvectors.Vocab at 0x13ef675d0>,\n",
              " 'british': <gensim.models.keyedvectors.Vocab at 0x13ef67610>,\n",
              " 'talent': <gensim.models.keyedvectors.Vocab at 0x13ef67650>,\n",
              " 'probably': <gensim.models.keyedvectors.Vocab at 0x13ef67690>,\n",
              " 'never': <gensim.models.keyedvectors.Vocab at 0x13ef676d0>,\n",
              " 'hear': <gensim.models.keyedvectors.Vocab at 0x13ef67710>,\n",
              " 'least': <gensim.models.keyedvectors.Vocab at 0x13ef67750>,\n",
              " 'hope': <gensim.models.keyedvectors.Vocab at 0x13ef67790>,\n",
              " 'next': <gensim.models.keyedvectors.Vocab at 0x13ef677d0>,\n",
              " 'time': <gensim.models.keyedvectors.Vocab at 0x13ef67810>,\n",
              " 'hire': <gensim.models.keyedvectors.Vocab at 0x13ef67850>,\n",
              " 'different': <gensim.models.keyedvectors.Vocab at 0x13ef67890>,\n",
              " 'intrigue': <gensim.models.keyedvectors.Vocab at 0x13ef678d0>,\n",
              " 'thought': <gensim.models.keyedvectors.Vocab at 0x13ef67910>,\n",
              " 'hideously': <gensim.models.keyedvectors.Vocab at 0x13ef67950>,\n",
              " 'fashionable': <gensim.models.keyedvectors.Vocab at 0x13ef67990>,\n",
              " 'soundtrack': <gensim.models.keyedvectors.Vocab at 0x13ef679d0>,\n",
              " 'feature': <gensim.models.keyedvectors.Vocab at 0x13ef67a10>,\n",
              " 'like': <gensim.models.keyedvectors.Vocab at 0x13ef67a50>,\n",
              " 'snow': <gensim.models.keyedvectors.Vocab at 0x13ef67a90>,\n",
              " 'patrol': <gensim.models.keyedvectors.Vocab at 0x13ef67ad0>,\n",
              " 'ian': <gensim.models.keyedvectors.Vocab at 0x13ef67b10>,\n",
              " 'brown': <gensim.models.keyedvectors.Vocab at 0x13ef67b50>,\n",
              " 'keane': <gensim.models.keyedvectors.Vocab at 0x13ef67b90>,\n",
              " 'bit': <gensim.models.keyedvectors.Vocab at 0x13ef67bd0>,\n",
              " 'music': <gensim.models.keyedvectors.Vocab at 0x13ef67c10>,\n",
              " 'fan': <gensim.models.keyedvectors.Vocab at 0x13ef67c50>,\n",
              " 'familiar': <gensim.models.keyedvectors.Vocab at 0x13ef67c90>,\n",
              " 'artist': <gensim.models.keyedvectors.Vocab at 0x13ef67cd0>,\n",
              " 'output': <gensim.models.keyedvectors.Vocab at 0x13ef67d10>,\n",
              " 'didnt': <gensim.models.keyedvectors.Vocab at 0x13ef67d50>,\n",
              " 'recognise': <gensim.models.keyedvectors.Vocab at 0x13ef67d90>,\n",
              " 'track': <gensim.models.keyedvectors.Vocab at 0x13ef67dd0>,\n",
              " 'movie': <gensim.models.keyedvectors.Vocab at 0x13ef67e10>,\n",
              " 'apart': <gensim.models.keyedvectors.Vocab at 0x13ef67e50>,\n",
              " 'omnipresent': <gensim.models.keyedvectors.Vocab at 0x13ef67e90>,\n",
              " 'run': <gensim.models.keyedvectors.Vocab at 0x13ef67ed0>,\n",
              " 'anyone': <gensim.models.keyedvectors.Vocab at 0x13ef67f10>,\n",
              " 'get': <gensim.models.keyedvectors.Vocab at 0x13ef67f50>,\n",
              " 'musical': <gensim.models.keyedvectors.Vocab at 0x13ef67f90>,\n",
              " 'montage': <gensim.models.keyedvectors.Vocab at 0x13ef67fd0>,\n",
              " 'telegraph': <gensim.models.keyedvectors.Vocab at 0x13ef69050>,\n",
              " 'suppose': <gensim.models.keyedvectors.Vocab at 0x13ef69090>,\n",
              " 'feel': <gensim.models.keyedvectors.Vocab at 0x13ef690d0>,\n",
              " 'accompany': <gensim.models.keyedvectors.Vocab at 0x13ef69110>,\n",
              " 'startlingly': <gensim.models.keyedvectors.Vocab at 0x13ef69150>,\n",
              " 'original': <gensim.models.keyedvectors.Vocab at 0x13ef69190>,\n",
              " 'image': <gensim.models.keyedvectors.Vocab at 0x13ef691d0>,\n",
              " 'couple': <gensim.models.keyedvectors.Vocab at 0x13ef69210>,\n",
              " 'kiss': <gensim.models.keyedvectors.Vocab at 0x13ef69250>,\n",
              " 'swollen': <gensim.models.keyedvectors.Vocab at 0x13ef69290>,\n",
              " 'lake': <gensim.models.keyedvectors.Vocab at 0x13ef692d0>,\n",
              " 'canoodle': <gensim.models.keyedvectors.Vocab at 0x13ef69310>,\n",
              " 'doorway': <gensim.models.keyedvectors.Vocab at 0x13ef69350>,\n",
              " 'problem': <gensim.models.keyedvectors.Vocab at 0x13ef69390>,\n",
              " 'none': <gensim.models.keyedvectors.Vocab at 0x13ef693d0>,\n",
              " 'song': <gensim.models.keyedvectors.Vocab at 0x13ef69410>,\n",
              " 'convey': <gensim.models.keyedvectors.Vocab at 0x13ef69450>,\n",
              " 'mood': <gensim.models.keyedvectors.Vocab at 0x13ef69490>,\n",
              " 'efficiently': <gensim.models.keyedvectors.Vocab at 0x13ef694d0>,\n",
              " 'realise': <gensim.models.keyedvectors.Vocab at 0x13ef69510>,\n",
              " 'lack': <gensim.models.keyedvectors.Vocab at 0x13ef69550>,\n",
              " 'ability': <gensim.models.keyedvectors.Vocab at 0x13ef69590>,\n",
              " 'carry': <gensim.models.keyedvectors.Vocab at 0x13ef695d0>,\n",
              " 'emotional': <gensim.models.keyedvectors.Vocab at 0x13ef69610>,\n",
              " 'journey': <gensim.models.keyedvectors.Vocab at 0x13ef69650>,\n",
              " 'audience': <gensim.models.keyedvectors.Vocab at 0x13ef69690>,\n",
              " 'storytelling': <gensim.models.keyedvectors.Vocab at 0x13ef696d0>,\n",
              " 'dialogue': <gensim.models.keyedvectors.Vocab at 0x13ef69710>,\n",
              " 'alonethe': <gensim.models.keyedvectors.Vocab at 0x13ef69750>,\n",
              " 'end': <gensim.models.keyedvectors.Vocab at 0x13ef69790>,\n",
              " 'presumably': <gensim.models.keyedvectors.Vocab at 0x13ef697d0>,\n",
              " 'meant': <gensim.models.keyedvectors.Vocab at 0x13ef69810>,\n",
              " 'dessert': <gensim.models.keyedvectors.Vocab at 0x13ef69850>,\n",
              " 'everybody': <gensim.models.keyedvectors.Vocab at 0x13ef69890>,\n",
              " 'comeuppance': <gensim.models.keyedvectors.Vocab at 0x13ef698d0>,\n",
              " 'big': <gensim.models.keyedvectors.Vocab at 0x13ef69910>,\n",
              " 'shock': <gensim.models.keyedvectors.Vocab at 0x13ef69950>,\n",
              " 'store': <gensim.models.keyedvectors.Vocab at 0x13ef69990>,\n",
              " 'remain': <gensim.models.keyedvectors.Vocab at 0x13ef699d0>,\n",
              " 'resolutely': <gensim.models.keyedvectors.Vocab at 0x13ef69a10>,\n",
              " 'unmoved': <gensim.models.keyedvectors.Vocab at 0x13ef69a50>,\n",
              " 'script': <gensim.models.keyedvectors.Vocab at 0x13ef69a90>,\n",
              " 'give': <gensim.models.keyedvectors.Vocab at 0x13ef69ad0>,\n",
              " 'noone': <gensim.models.keyedvectors.Vocab at 0x13ef69b10>,\n",
              " 'root': <gensim.models.keyedvectors.Vocab at 0x13ef69b50>,\n",
              " 'enough': <gensim.models.keyedvectors.Vocab at 0x13ef69b90>,\n",
              " 'tackle': <gensim.models.keyedvectors.Vocab at 0x13ef69bd0>,\n",
              " 'hotbutton': <gensim.models.keyedvectors.Vocab at 0x13ef69c10>,\n",
              " 'issue': <gensim.models.keyedvectors.Vocab at 0x13ef69c50>,\n",
              " 'actually': <gensim.models.keyedvectors.Vocab at 0x13ef69c90>,\n",
              " 'plot': <gensim.models.keyedvectors.Vocab at 0x13ef69cd0>,\n",
              " 'hasnt': <gensim.models.keyedvectors.Vocab at 0x13ef69d10>,\n",
              " 'already': <gensim.models.keyedvectors.Vocab at 0x13ef69d50>,\n",
              " 'death': <gensim.models.keyedvectors.Vocab at 0x13ef69d90>,\n",
              " 'individual': <gensim.models.keyedvectors.Vocab at 0x13ef69dd0>,\n",
              " 'window': <gensim.models.keyedvectors.Vocab at 0x13ef69e10>,\n",
              " 'dress': <gensim.models.keyedvectors.Vocab at 0x13ef69e50>,\n",
              " 'noble': <gensim.models.keyedvectors.Vocab at 0x13ef69e90>,\n",
              " 'failure': <gensim.models.keyedvectors.Vocab at 0x13ef69ed0>,\n",
              " 'promising': <gensim.models.keyedvectors.Vocab at 0x13ef69f10>,\n",
              " 'actress': <gensim.models.keyedvectors.Vocab at 0x13ef69f50>,\n",
              " 'mildly': <gensim.models.keyedvectors.Vocab at 0x13ef69f90>,\n",
              " 'divert': <gensim.models.keyedvectors.Vocab at 0x13ef69fd0>,\n",
              " 'punchups': <gensim.models.keyedvectors.Vocab at 0x13ef6c050>,\n",
              " 'save': <gensim.models.keyedvectors.Vocab at 0x13ef6c090>,\n",
              " 'bin': <gensim.models.keyedvectors.Vocab at 0x13ef6c0d0>,\n",
              " 'try': <gensim.models.keyedvectors.Vocab at 0x13ef6c110>,\n",
              " 'harder': <gensim.models.keyedvectors.Vocab at 0x13ef6c150>,\n",
              " 'watch': <gensim.models.keyedvectors.Vocab at 0x13ef6c190>,\n",
              " 'entire': <gensim.models.keyedvectors.Vocab at 0x13ef6c1d0>,\n",
              " 'could': <gensim.models.keyedvectors.Vocab at 0x13ef6c210>,\n",
              " 'stop': <gensim.models.keyedvectors.Vocab at 0x13ef6c250>,\n",
              " 'dvd': <gensim.models.keyedvectors.Vocab at 0x13ef6c290>,\n",
              " 'half': <gensim.models.keyedvectors.Vocab at 0x13ef6c2d0>,\n",
              " 'hour': <gensim.models.keyedvectors.Vocab at 0x13ef6c310>,\n",
              " 'suggest': <gensim.models.keyedvectors.Vocab at 0x13ef6c350>,\n",
              " 'take': <gensim.models.keyedvectors.Vocab at 0x13ef6c390>,\n",
              " 'disc': <gensim.models.keyedvectors.Vocab at 0x13ef6c3d0>,\n",
              " 'casei': <gensim.models.keyedvectors.Vocab at 0x13ef6c410>,\n",
              " 'mafia': <gensim.models.keyedvectors.Vocab at 0x13ef6c450>,\n",
              " 'tragic': <gensim.models.keyedvectors.Vocab at 0x13ef6c490>,\n",
              " 'comic': <gensim.models.keyedvectors.Vocab at 0x13ef6c4d0>,\n",
              " 'corky': <gensim.models.keyedvectors.Vocab at 0x13ef6c510>,\n",
              " 'romano': <gensim.models.keyedvectors.Vocab at 0x13ef6c550>,\n",
              " 'described': <gensim.models.keyedvectors.Vocab at 0x13ef6c590>,\n",
              " 'attempt': <gensim.models.keyedvectors.Vocab at 0x13ef6c5d0>,\n",
              " 'comedythe': <gensim.models.keyedvectors.Vocab at 0x13ef6c610>,\n",
              " 'simply': <gensim.models.keyedvectors.Vocab at 0x13ef6c650>,\n",
              " 'hard': <gensim.models.keyedvectors.Vocab at 0x13ef6c690>,\n",
              " 'laugh': <gensim.models.keyedvectors.Vocab at 0x13ef6c6d0>,\n",
              " 'seem': <gensim.models.keyedvectors.Vocab at 0x13ef6c710>,\n",
              " 'excuse': <gensim.models.keyedvectors.Vocab at 0x13ef6c750>,\n",
              " 'move': <gensim.models.keyedvectors.Vocab at 0x13ef6c790>,\n",
              " 'chris': <gensim.models.keyedvectors.Vocab at 0x13ef6c7d0>,\n",
              " 'kattan': <gensim.models.keyedvectors.Vocab at 0x13ef6c810>,\n",
              " 'scene': <gensim.models.keyedvectors.Vocab at 0x13ef6c850>,\n",
              " 'another': <gensim.models.keyedvectors.Vocab at 0x13ef6c890>,\n",
              " 'completely': <gensim.models.keyedvectors.Vocab at 0x13ef6c8d0>,\n",
              " 'overplayed': <gensim.models.keyedvectors.Vocab at 0x13ef6c910>,\n",
              " 'subtlety': <gensim.models.keyedvectors.Vocab at 0x13ef6c950>,\n",
              " 'credulity': <gensim.models.keyedvectors.Vocab at 0x13ef6c990>,\n",
              " 'strange': <gensim.models.keyedvectors.Vocab at 0x13ef6c9d0>,\n",
              " 'mannerism': <gensim.models.keyedvectors.Vocab at 0x13ef6ca10>,\n",
              " 'come': <gensim.models.keyedvectors.Vocab at 0x13ef6ca50>,\n",
              " 'across': <gensim.models.keyedvectors.Vocab at 0x13ef6ca90>,\n",
              " 'contrive': <gensim.models.keyedvectors.Vocab at 0x13ef6cad0>,\n",
              " 'clearly': <gensim.models.keyedvectors.Vocab at 0x13ef6cb10>,\n",
              " 'rather': <gensim.models.keyedvectors.Vocab at 0x13ef6cb50>,\n",
              " 'bounce': <gensim.models.keyedvectors.Vocab at 0x13ef6cb90>,\n",
              " 'right': <gensim.models.keyedvectors.Vocab at 0x13ef6cbd0>,\n",
              " 'story': <gensim.models.keyedvectors.Vocab at 0x13ef6cc10>,\n",
              " 'utterly': <gensim.models.keyedvectors.Vocab at 0x13ef6cc50>,\n",
              " 'predictable': <gensim.models.keyedvectors.Vocab at 0x13ef6cc90>,\n",
              " 'comedic': <gensim.models.keyedvectors.Vocab at 0x13ef6ccd0>,\n",
              " 'event': <gensim.models.keyedvectors.Vocab at 0x13ef6cd10>,\n",
              " 'occur': <gensim.models.keyedvectors.Vocab at 0x13ef6cd50>,\n",
              " 'set': <gensim.models.keyedvectors.Vocab at 0x13ef6cd90>,\n",
              " 'obvious': <gensim.models.keyedvectors.Vocab at 0x13ef6cdd0>,\n",
              " 'soon': <gensim.models.keyedvectors.Vocab at 0x13ef6ce10>,\n",
              " 'introduce': <gensim.models.keyedvectors.Vocab at 0x13ef6ce50>,\n",
              " 'comedy': <gensim.models.keyedvectors.Vocab at 0x13ef6ce90>,\n",
              " 'mr': <gensim.models.keyedvectors.Vocab at 0x13ef6ced0>,\n",
              " 'bean': <gensim.models.keyedvectors.Vocab at 0x13ef6cf10>,\n",
              " 'disaster': <gensim.models.keyedvectors.Vocab at 0x13ef6cf50>,\n",
              " 'cause': <gensim.models.keyedvectors.Vocab at 0x13ef6cf90>,\n",
              " 'title': <gensim.models.keyedvectors.Vocab at 0x13ef6cfd0>,\n",
              " 'funny': <gensim.models.keyedvectors.Vocab at 0x13ef6f050>,\n",
              " 'empathise': <gensim.models.keyedvectors.Vocab at 0x13ef6f090>,\n",
              " 'motivation': <gensim.models.keyedvectors.Vocab at 0x13ef6f0d0>,\n",
              " 'initial': <gensim.models.keyedvectors.Vocab at 0x13ef6f110>,\n",
              " 'situation': <gensim.models.keyedvectors.Vocab at 0x13ef6f150>,\n",
              " 'however': <gensim.models.keyedvectors.Vocab at 0x13ef6f190>,\n",
              " 'deliberately': <gensim.models.keyedvectors.Vocab at 0x13ef6f1d0>,\n",
              " 'screw': <gensim.models.keyedvectors.Vocab at 0x13ef6f210>,\n",
              " 'desperate': <gensim.models.keyedvectors.Vocab at 0x13ef6f250>,\n",
              " 'draw': <gensim.models.keyedvectors.Vocab at 0x13ef6f290>,\n",
              " 'audienceif': <gensim.models.keyedvectors.Vocab at 0x13ef6f2d0>,\n",
              " 'played': <gensim.models.keyedvectors.Vocab at 0x13ef6f310>,\n",
              " 'alien': <gensim.models.keyedvectors.Vocab at 0x13ef6f350>,\n",
              " 'connects': <gensim.models.keyedvectors.Vocab at 0x13ef6f390>,\n",
              " 'whose': <gensim.models.keyedvectors.Vocab at 0x13ef6f3d0>,\n",
              " 'behaviour': <gensim.models.keyedvectors.Vocab at 0x13ef6f410>,\n",
              " 'entirely': <gensim.models.keyedvectors.Vocab at 0x13ef6f450>,\n",
              " 'inexplicable': <gensim.models.keyedvectors.Vocab at 0x13ef6f490>,\n",
              " 'except': <gensim.models.keyedvectors.Vocab at 0x13ef6f4d0>,\n",
              " 'werent': <gensim.models.keyedvectors.Vocab at 0x13ef6f510>,\n",
              " 'stereotype': <gensim.models.keyedvectors.Vocab at 0x13ef6f550>,\n",
              " 'joke': <gensim.models.keyedvectors.Vocab at 0x13ef6f590>,\n",
              " 'far': <gensim.models.keyedvectors.Vocab at 0x13ef6f5d0>,\n",
              " 'watchable': <gensim.models.keyedvectors.Vocab at 0x13ef6f610>,\n",
              " 'isnt': <gensim.models.keyedvectors.Vocab at 0x13ef6f650>,\n",
              " 'touch': <gensim.models.keyedvectors.Vocab at 0x13ef6f690>,\n",
              " 'love': <gensim.models.keyedvectors.Vocab at 0x13ef6f6d0>,\n",
              " 'reminiscent': <gensim.models.keyedvectors.Vocab at 0x13ef6f710>,\n",
              " 'heavily': <gensim.models.keyedvectors.Vocab at 0x13ef6f750>,\n",
              " 'chinese': <gensim.models.keyedvectors.Vocab at 0x13ef6f790>,\n",
              " 'poetry': <gensim.models.keyedvectors.Vocab at 0x13ef6f7d0>,\n",
              " 'use': <gensim.models.keyedvectors.Vocab at 0x13ef6f810>,\n",
              " 'eastern': <gensim.models.keyedvectors.Vocab at 0x13ef6f850>,\n",
              " 'people': <gensim.models.keyedvectors.Vocab at 0x13ef6f890>,\n",
              " 'communicate': <gensim.models.keyedvectors.Vocab at 0x13ef6f8d0>,\n",
              " 'feeling': <gensim.models.keyedvectors.Vocab at 0x13ef6f910>,\n",
              " 'focus': <gensim.models.keyedvectors.Vocab at 0x13ef6f950>,\n",
              " 'schoolteacher': <gensim.models.keyedvectors.Vocab at 0x13ef6f990>,\n",
              " 'want': <gensim.models.keyedvectors.Vocab at 0x13ef6f9d0>,\n",
              " 'model': <gensim.models.keyedvectors.Vocab at 0x13ef6fa10>,\n",
              " 'teacher': <gensim.models.keyedvectors.Vocab at 0x13ef6fa50>,\n",
              " 'good': <gensim.models.keyedvectors.Vocab at 0x13ef6fa90>,\n",
              " 'husband': <gensim.models.keyedvectors.Vocab at 0x13ef6fad0>,\n",
              " 'father': <gensim.models.keyedvectors.Vocab at 0x13ef6fb10>,\n",
              " 'senior': <gensim.models.keyedvectors.Vocab at 0x13ef6fb50>,\n",
              " 'student': <gensim.models.keyedvectors.Vocab at 0x13ef6fb90>,\n",
              " 'attract': <gensim.models.keyedvectors.Vocab at 0x13ef6fbd0>,\n",
              " 'unfolds': <gensim.models.keyedvectors.Vocab at 0x13ef6fc10>,\n",
              " 'see': <gensim.models.keyedvectors.Vocab at 0x13ef6fc50>,\n",
              " 'emotion': <gensim.models.keyedvectors.Vocab at 0x13ef6fc90>,\n",
              " 'surface': <gensim.models.keyedvectors.Vocab at 0x13ef6fcd0>,\n",
              " 'year': <gensim.models.keyedvectors.Vocab at 0x13ef6fd10>,\n",
              " 'marriage': <gensim.models.keyedvectors.Vocab at 0x13ef6fd50>,\n",
              " 'grapple': <gensim.models.keyedvectors.Vocab at 0x13ef6fd90>,\n",
              " 'moral': <gensim.models.keyedvectors.Vocab at 0x13ef6fdd0>,\n",
              " 'dilemma': <gensim.models.keyedvectors.Vocab at 0x13ef6fe10>,\n",
              " 'face': <gensim.models.keyedvectors.Vocab at 0x13ef6fe50>,\n",
              " 'beautiful': <gensim.models.keyedvectors.Vocab at 0x13ef6fe90>,\n",
              " 'latterday': <gensim.models.keyedvectors.Vocab at 0x13ef6fed0>,\n",
              " 'fulci': <gensim.models.keyedvectors.Vocab at 0x13ef6ff10>,\n",
              " 'schlocker': <gensim.models.keyedvectors.Vocab at 0x13ef6ff50>,\n",
              " 'totally': <gensim.models.keyedvectors.Vocab at 0x13ef6ff90>,\n",
              " 'abysmal': <gensim.models.keyedvectors.Vocab at 0x13ef6ffd0>,\n",
              " 'concoction': <gensim.models.keyedvectors.Vocab at 0x13ef73050>,\n",
              " 'deal': <gensim.models.keyedvectors.Vocab at 0x13ef73090>,\n",
              " 'incurable': <gensim.models.keyedvectors.Vocab at 0x13ef730d0>,\n",
              " 'gambler': <gensim.models.keyedvectors.Vocab at 0x13ef73110>,\n",
              " 'brett': <gensim.models.keyedvectors.Vocab at 0x13ef73150>,\n",
              " 'halsey': <gensim.models.keyedvectors.Vocab at 0x13ef73190>,\n",
              " 'decides': <gensim.models.keyedvectors.Vocab at 0x13ef731d0>,\n",
              " 'pay': <gensim.models.keyedvectors.Vocab at 0x13ef73210>,\n",
              " 'debt': <gensim.models.keyedvectors.Vocab at 0x13ef73250>,\n",
              " 'seduce': <gensim.models.keyedvectors.Vocab at 0x13ef73290>,\n",
              " 'ugliest': <gensim.models.keyedvectors.Vocab at 0x13ef732d0>,\n",
              " 'bitch': <gensim.models.keyedvectors.Vocab at 0x13ef73310>,\n",
              " 'ever': <gensim.models.keyedvectors.Vocab at 0x13ef73350>,\n",
              " 'lay': <gensim.models.keyedvectors.Vocab at 0x13ef73390>,\n",
              " 'eye': <gensim.models.keyedvectors.Vocab at 0x13ef733d0>,\n",
              " 'happen': <gensim.models.keyedvectors.Vocab at 0x13ef73410>,\n",
              " 'wealthy': <gensim.models.keyedvectors.Vocab at 0x13ef73450>,\n",
              " 'widow': <gensim.models.keyedvectors.Vocab at 0x13ef73490>,\n",
              " 'contrives': <gensim.models.keyedvectors.Vocab at 0x13ef734d0>,\n",
              " 'incorporate': <gensim.models.keyedvectors.Vocab at 0x13ef73510>,\n",
              " 'blackly': <gensim.models.keyedvectors.Vocab at 0x13ef73550>,\n",
              " 'element': <gensim.models.keyedvectors.Vocab at 0x13ef73590>,\n",
              " 'result': <gensim.models.keyedvectors.Vocab at 0x13ef735d0>,\n",
              " 'unfunny': <gensim.models.keyedvectors.Vocab at 0x13ef73610>,\n",
              " 'business': <gensim.models.keyedvectors.Vocab at 0x13ef73650>,\n",
              " 'involve': <gensim.models.keyedvectors.Vocab at 0x13ef73690>,\n",
              " 'corpse': <gensim.models.keyedvectors.Vocab at 0x13ef736d0>,\n",
              " 'wont': <gensim.models.keyedvectors.Vocab at 0x13ef73710>,\n",
              " 'stay': <gensim.models.keyedvectors.Vocab at 0x13ef73750>,\n",
              " 'put': <gensim.models.keyedvectors.Vocab at 0x13ef73790>,\n",
              " 'opera': <gensim.models.keyedvectors.Vocab at 0x13ef737d0>,\n",
              " 'singer': <gensim.models.keyedvectors.Vocab at 0x13ef73810>,\n",
              " 'victim': <gensim.models.keyedvectors.Vocab at 0x13ef73850>,\n",
              " 'sing': <gensim.models.keyedvectors.Vocab at 0x13ef73890>,\n",
              " 'etc': <gensim.models.keyedvectors.Vocab at 0x13ef738d0>,\n",
              " 'mention': <gensim.models.keyedvectors.Vocab at 0x13ef73910>,\n",
              " 'doppelganger': <gensim.models.keyedvectors.Vocab at 0x13ef73950>,\n",
              " 'theme': <gensim.models.keyedvectors.Vocab at 0x13ef73990>,\n",
              " 'straight': <gensim.models.keyedvectors.Vocab at 0x13ef739d0>,\n",
              " 'prague': <gensim.models.keyedvectors.Vocab at 0x13ef73a10>,\n",
              " 'although': <gensim.models.keyedvectors.Vocab at 0x13ef73a50>,\n",
              " 'case': <gensim.models.keyedvectors.Vocab at 0x13ef73a90>,\n",
              " 'two': <gensim.models.keyedvectors.Vocab at 0x13ef73ad0>,\n",
              " 'persona': <gensim.models.keyedvectors.Vocab at 0x13ef73b10>,\n",
              " 'via': <gensim.models.keyedvectors.Vocab at 0x13ef73b50>,\n",
              " 'prerecord': <gensim.models.keyedvectors.Vocab at 0x13ef73b90>,\n",
              " 'radio': <gensim.models.keyedvectors.Vocab at 0x13ef73bd0>,\n",
              " 'message': <gensim.models.keyedvectors.Vocab at 0x13ef73c10>,\n",
              " 'cant': <gensim.models.keyedvectors.Vocab at 0x13ef73c50>,\n",
              " 'surprised': <gensim.models.keyedvectors.Vocab at 0x13ef73c90>,\n",
              " 'show': <gensim.models.keyedvectors.Vocab at 0x13ef73cd0>,\n",
              " 'no': <gensim.models.keyedvectors.Vocab at 0x13ef73d10>,\n",
              " 'sign': <gensim.models.keyedvectors.Vocab at 0x13ef73d50>,\n",
              " 'sophistication': <gensim.models.keyedvectors.Vocab at 0x13ef73d90>,\n",
              " 'mario': <gensim.models.keyedvectors.Vocab at 0x13ef73dd0>,\n",
              " 'bavas': <gensim.models.keyedvectors.Vocab at 0x13ef73e10>,\n",
              " 'hatchet': <gensim.models.keyedvectors.Vocab at 0x13ef73e50>,\n",
              " 'honeymoon': <gensim.models.keyedvectors.Vocab at 0x13ef73e90>,\n",
              " 'resembles': <gensim.models.keyedvectors.Vocab at 0x13ef73ed0>,\n",
              " 'several': <gensim.models.keyedvectors.Vocab at 0x13ef73f10>,\n",
              " 'way': <gensim.models.keyedvectors.Vocab at 0x13ef73f50>,\n",
              " 'content': <gensim.models.keyedvectors.Vocab at 0x13ef73f90>,\n",
              " 'merely': <gensim.models.keyedvectors.Vocab at 0x13ef73fd0>,\n",
              " 'pile': <gensim.models.keyedvectors.Vocab at 0x13ef76050>,\n",
              " 'disgustingly': <gensim.models.keyedvectors.Vocab at 0x13ef76090>,\n",
              " 'gory': <gensim.models.keyedvectors.Vocab at 0x13ef760d0>,\n",
              " 'effect': <gensim.models.keyedvectors.Vocab at 0x13ef76110>,\n",
              " 'dismember': <gensim.models.keyedvectors.Vocab at 0x13ef76150>,\n",
              " 'limb': <gensim.models.keyedvectors.Vocab at 0x13ef76190>,\n",
              " 'squash': <gensim.models.keyedvectors.Vocab at 0x13ef761d0>,\n",
              " 'melt': <gensim.models.keyedvectors.Vocab at 0x13ef76210>,\n",
              " 'ala': <gensim.models.keyedvectors.Vocab at 0x13ef76250>,\n",
              " 'become': <gensim.models.keyedvectors.Vocab at 0x13ef76290>,\n",
              " 'associate': <gensim.models.keyedvectors.Vocab at 0x13ef762d0>,\n",
              " 'first': <gensim.models.keyedvectors.Vocab at 0x13ef76310>,\n",
              " 'firmly': <gensim.models.keyedvectors.Vocab at 0x13ef76350>,\n",
              " 'believe': <gensim.models.keyedvectors.Vocab at 0x13ef76390>,\n",
              " 'norwegian': <gensim.models.keyedvectors.Vocab at 0x13ef763d0>,\n",
              " 'continually': <gensim.models.keyedvectors.Vocab at 0x13ef76410>,\n",
              " 'tedious': <gensim.models.keyedvectors.Vocab at 0x13ef76450>,\n",
              " 'place': <gensim.models.keyedvectors.Vocab at 0x13ef76490>,\n",
              " 'start': <gensim.models.keyedvectors.Vocab at 0x13ef764d0>,\n",
              " 'contain': <gensim.models.keyedvectors.Vocab at 0x13ef76510>,\n",
              " 'humour': <gensim.models.keyedvectors.Vocab at 0x13ef76550>,\n",
              " 'imagine': <gensim.models.keyedvectors.Vocab at 0x13ef76590>,\n",
              " 'actual': <gensim.models.keyedvectors.Vocab at 0x13ef765d0>,\n",
              " 'make': <gensim.models.keyedvectors.Vocab at 0x13ef76610>,\n",
              " 'entertain': <gensim.models.keyedvectors.Vocab at 0x13ef76650>,\n",
              " 'oppose': <gensim.models.keyedvectors.Vocab at 0x13ef76690>,\n",
              " 'long': <gensim.models.keyedvectors.Vocab at 0x13ef766d0>,\n",
              " 'dark': <gensim.models.keyedvectors.Vocab at 0x13ef76710>,\n",
              " 'depress': <gensim.models.keyedvectors.Vocab at 0x13ef76750>,\n",
              " 'great': <gensim.models.keyedvectors.Vocab at 0x13ef76790>,\n",
              " 'new': <gensim.models.keyedvectors.Vocab at 0x13ef767d0>,\n",
              " 'generation': <gensim.models.keyedvectors.Vocab at 0x13ef76810>,\n",
              " 'filmmaker': <gensim.models.keyedvectors.Vocab at 0x13ef76850>,\n",
              " 'praise': <gensim.models.keyedvectors.Vocab at 0x13ef76890>,\n",
              " 'critic': <gensim.models.keyedvectors.Vocab at 0x13ef768d0>,\n",
              " 'load': <gensim.models.keyedvectors.Vocab at 0x13ef76910>,\n",
              " 'money': <gensim.models.keyedvectors.Vocab at 0x13ef76950>,\n",
              " 'spoiler': <gensim.models.keyedvectors.Vocab at 0x13ef76990>,\n",
              " 'thing': <gensim.models.keyedvectors.Vocab at 0x13ef769d0>,\n",
              " 'especially': <gensim.models.keyedvectors.Vocab at 0x13ef76a10>,\n",
              " 'comedian': <gensim.models.keyedvectors.Vocab at 0x13ef76a50>,\n",
              " 'neither': <gensim.models.keyedvectors.Vocab at 0x13ef76a90>,\n",
              " 'anything': <gensim.models.keyedvectors.Vocab at 0x13ef76ad0>,\n",
              " 'wheres': <gensim.models.keyedvectors.Vocab at 0x13ef76b10>,\n",
              " 'humor': <gensim.models.keyedvectors.Vocab at 0x13ef76b50>,\n",
              " 'awkward': <gensim.models.keyedvectors.Vocab at 0x13ef76b90>,\n",
              " 'clerk': <gensim.models.keyedvectors.Vocab at 0x13ef76bd0>,\n",
              " 'harald': <gensim.models.keyedvectors.Vocab at 0x13ef76c10>,\n",
              " 'overact': <gensim.models.keyedvectors.Vocab at 0x13ef76c50>,\n",
              " 'ridiculously': <gensim.models.keyedvectors.Vocab at 0x13ef76c90>,\n",
              " 'unrealistic': <gensim.models.keyedvectors.Vocab at 0x13ef76cd0>,\n",
              " 'football': <gensim.models.keyedvectors.Vocab at 0x13ef76d10>,\n",
              " 'coach': <gensim.models.keyedvectors.Vocab at 0x13ef76d50>,\n",
              " 'commentary': <gensim.models.keyedvectors.Vocab at 0x13ef76d90>,\n",
              " 'arne': <gensim.models.keyedvectors.Vocab at 0x13ef76dd0>,\n",
              " 'scheie': <gensim.models.keyedvectors.Vocab at 0x13ef76e10>,\n",
              " 'funnybut': <gensim.models.keyedvectors.Vocab at 0x13ef76e50>,\n",
              " 'main': <gensim.models.keyedvectors.Vocab at 0x13ef76e90>,\n",
              " 'rant': <gensim.models.keyedvectors.Vocab at 0x13ef76ed0>,\n",
              " 'united': <gensim.models.keyedvectors.Vocab at 0x13ef76f10>,\n",
              " 'namely': <gensim.models.keyedvectors.Vocab at 0x13ef76f50>,\n",
              " 'predictability': <gensim.models.keyedvectors.Vocab at 0x13ef76f90>,\n",
              " 'fear': <gensim.models.keyedvectors.Vocab at 0x13ef76fd0>,\n",
              " 'standstill': <gensim.models.keyedvectors.Vocab at 0x13ef79050>,\n",
              " 'since': <gensim.models.keyedvectors.Vocab at 0x13ef79090>,\n",
              " 'go': <gensim.models.keyedvectors.Vocab at 0x13ef790d0>,\n",
              " 'exactly': <gensim.models.keyedvectors.Vocab at 0x13ef79110>,\n",
              " 'present': <gensim.models.keyedvectors.Vocab at 0x13ef79150>,\n",
              " 'deserve': <gensim.models.keyedvectors.Vocab at 0x13ef79190>,\n",
              " 'there': <gensim.models.keyedvectors.Vocab at 0x13ef791d0>,\n",
              " 'room': <gensim.models.keyedvectors.Vocab at 0x13ef79210>,\n",
              " 'surprise': <gensim.models.keyedvectors.Vocab at 0x13ef79250>,\n",
              " 'allall': <gensim.models.keyedvectors.Vocab at 0x13ef79290>,\n",
              " 'sat': <gensim.models.keyedvectors.Vocab at 0x13ef792d0>,\n",
              " 'realize': <gensim.models.keyedvectors.Vocab at 0x13ef79310>,\n",
              " 'need': <gensim.models.keyedvectors.Vocab at 0x13ef79350>,\n",
              " 'blood': <gensim.models.keyedvectors.Vocab at 0x13ef79390>,\n",
              " 'receive': <gensim.models.keyedvectors.Vocab at 0x13ef793d0>,\n",
              " 'positive': <gensim.models.keyedvectors.Vocab at 0x13ef79410>,\n",
              " 'review': <gensim.models.keyedvectors.Vocab at 0x13ef79450>,\n",
              " 'site': <gensim.models.keyedvectors.Vocab at 0x13ef79490>,\n",
              " 'vonnegut': <gensim.models.keyedvectors.Vocab at 0x13ef794d0>,\n",
              " 'showtime': <gensim.models.keyedvectors.Vocab at 0x13ef79510>,\n",
              " 'bastardize': <gensim.models.keyedvectors.Vocab at 0x13ef79550>,\n",
              " 'beyond': <gensim.models.keyedvectors.Vocab at 0x13ef79590>,\n",
              " 'even': <gensim.models.keyedvectors.Vocab at 0x13ef795d0>,\n",
              " 'wasnt': <gensim.models.keyedvectors.Vocab at 0x13ef79610>,\n",
              " 'poor': <gensim.models.keyedvectors.Vocab at 0x13ef79650>,\n",
              " 'sean': <gensim.models.keyedvectors.Vocab at 0x13ef79690>,\n",
              " 'astin': <gensim.models.keyedvectors.Vocab at 0x13ef796d0>,\n",
              " 'brilliant': <gensim.models.keyedvectors.Vocab at 0x13ef79710>,\n",
              " 'athletic': <gensim.models.keyedvectors.Vocab at 0x13ef79750>,\n",
              " 'around': <gensim.models.keyedvectors.Vocab at 0x13ef79790>,\n",
              " 'harrison': <gensim.models.keyedvectors.Vocab at 0x13ef797d0>,\n",
              " 'guy': <gensim.models.keyedvectors.Vocab at 0x13ef79810>,\n",
              " 'generic': <gensim.models.keyedvectors.Vocab at 0x13ef79850>,\n",
              " 'substandard': <gensim.models.keyedvectors.Vocab at 0x13ef79890>,\n",
              " 'render': <gensim.models.keyedvectors.Vocab at 0x13ef798d0>,\n",
              " 'tripe': <gensim.models.keyedvectors.Vocab at 0x13ef79910>,\n",
              " 'barely': <gensim.models.keyedvectors.Vocab at 0x13ef79950>,\n",
              " 'someone': <gensim.models.keyedvectors.Vocab at 0x13ef79990>,\n",
              " 'point': <gensim.models.keyedvectors.Vocab at 0x13ef799d0>,\n",
              " 'cute': <gensim.models.keyedvectors.Vocab at 0x13ef79a10>,\n",
              " 'culkin': <gensim.models.keyedvectors.Vocab at 0x13ef79a50>,\n",
              " 'line': <gensim.models.keyedvectors.Vocab at 0x13ef79a90>,\n",
              " 'read': <gensim.models.keyedvectors.Vocab at 0x13ef79ad0>,\n",
              " 'pure': <gensim.models.keyedvectors.Vocab at 0x13ef79b10>,\n",
              " 'brilliance': <gensim.models.keyedvectors.Vocab at 0x13ef79b50>,\n",
              " 'sadly': <gensim.models.keyedvectors.Vocab at 0x13ef79b90>,\n",
              " 'intentionally': <gensim.models.keyedvectors.Vocab at 0x13ef79bd0>,\n",
              " 'part': <gensim.models.keyedvectors.Vocab at 0x13ef79c10>,\n",
              " 'maybe': <gensim.models.keyedvectors.Vocab at 0x13ef79c50>,\n",
              " 'youll': <gensim.models.keyedvectors.Vocab at 0x13ef79c90>,\n",
              " 'youre': <gensim.models.keyedvectors.Vocab at 0x13ef79cd0>,\n",
              " 'insane': <gensim.models.keyedvectors.Vocab at 0x13ef79d10>,\n",
              " 'please': <gensim.models.keyedvectors.Vocab at 0x13ef79d50>,\n",
              " 'nightmare': <gensim.models.keyedvectors.Vocab at 0x13ef79d90>,\n",
              " 'weekend': <gensim.models.keyedvectors.Vocab at 0x13ef79dd0>,\n",
              " 'star': <gensim.models.keyedvectors.Vocab at 0x13ef79e10>,\n",
              " 'ridiculous': <gensim.models.keyedvectors.Vocab at 0x13ef79e50>,\n",
              " 'actor': <gensim.models.keyedvectors.Vocab at 0x13ef79e90>,\n",
              " 'less': <gensim.models.keyedvectors.Vocab at 0x13ef79ed0>,\n",
              " 'idea': <gensim.models.keyedvectors.Vocab at 0x13ef79f10>,\n",
              " 'decipherable': <gensim.models.keyedvectors.Vocab at 0x13ef79f50>,\n",
              " 'special': <gensim.models.keyedvectors.Vocab at 0x13ef79f90>,\n",
              " 'sound': <gensim.models.keyedvectors.Vocab at 0x13ef79fd0>,\n",
              " 'direct': <gensim.models.keyedvectors.Vocab at 0x13ef7d050>,\n",
              " 'henry': <gensim.models.keyedvectors.Vocab at 0x13ef7d090>,\n",
              " 'sala': <gensim.models.keyedvectors.Vocab at 0x13ef7d0d0>,\n",
              " 'reason': <gensim.models.keyedvectors.Vocab at 0x13ef7d110>,\n",
              " 'arnies': <gensim.models.keyedvectors.Vocab at 0x13ef7d150>,\n",
              " 'incident': <gensim.models.keyedvectors.Vocab at 0x13ef7d190>,\n",
              " 'helicopter': <gensim.models.keyedvectors.Vocab at 0x13ef7d1d0>,\n",
              " 'disobey': <gensim.models.keyedvectors.Vocab at 0x13ef7d210>,\n",
              " 'order': <gensim.models.keyedvectors.Vocab at 0x13ef7d250>,\n",
              " 'he': <gensim.models.keyedvectors.Vocab at 0x13ef7d290>,\n",
              " 'sent': <gensim.models.keyedvectors.Vocab at 0x13ef7d2d0>,\n",
              " 'jail': <gensim.models.keyedvectors.Vocab at 0x13ef7d310>,\n",
              " 'sort': <gensim.models.keyedvectors.Vocab at 0x13ef7d350>,\n",
              " 'work': <gensim.models.keyedvectors.Vocab at 0x13ef7d390>,\n",
              " 'camp': <gensim.models.keyedvectors.Vocab at 0x13ef7d3d0>,\n",
              " 'escape': <gensim.models.keyedvectors.Vocab at 0x13ef7d410>,\n",
              " 'short': <gensim.models.keyedvectors.Vocab at 0x13ef7d450>,\n",
              " 'caught': <gensim.models.keyedvectors.Vocab at 0x13ef7d490>,\n",
              " 'freakish': <gensim.models.keyedvectors.Vocab at 0x13ef7d4d0>,\n",
              " 'reality': <gensim.models.keyedvectors.Vocab at 0x13ef7d510>,\n",
              " 'bunch': <gensim.models.keyedvectors.Vocab at 0x13ef7d550>,\n",
              " 'tough': <gensim.models.keyedvectors.Vocab at 0x13ef7d590>,\n",
              " 'eventually': <gensim.models.keyedvectors.Vocab at 0x13ef7d5d0>,\n",
              " 'die': <gensim.models.keyedvectors.Vocab at 0x13ef7d610>,\n",
              " 'arnie': <gensim.models.keyedvectors.Vocab at 0x13ef7d650>,\n",
              " 'tougher': <gensim.models.keyedvectors.Vocab at 0x13ef7d690>,\n",
              " 'toughest': <gensim.models.keyedvectors.Vocab at 0x13ef7d6d0>,\n",
              " 'guysi': <gensim.models.keyedvectors.Vocab at 0x13ef7d710>,\n",
              " 'man': <gensim.models.keyedvectors.Vocab at 0x13ef7d750>,\n",
              " 'contains': <gensim.models.keyedvectors.Vocab at 0x13ef7d790>,\n",
              " 'flaw': <gensim.models.keyedvectors.Vocab at 0x13ef7d7d0>,\n",
              " 'annoy': <gensim.models.keyedvectors.Vocab at 0x13ef7d810>,\n",
              " 'crap': <gensim.models.keyedvectors.Vocab at 0x13ef7d850>,\n",
              " 'eg': <gensim.models.keyedvectors.Vocab at 0x13ef7d890>,\n",
              " 'reconstruction': <gensim.models.keyedvectors.Vocab at 0x13ef7d8d0>,\n",
              " 'inside': <gensim.models.keyedvectors.Vocab at 0x13ef7d910>,\n",
              " 'summary': <gensim.models.keyedvectors.Vocab at 0x13ef7d950>,\n",
              " 'complete': <gensim.models.keyedvectors.Vocab at 0x13ef7d990>,\n",
              " 'camera': <gensim.models.keyedvectors.Vocab at 0x13ef7d9d0>,\n",
              " 'angle': <gensim.models.keyedvectors.Vocab at 0x13ef7da10>,\n",
              " 'mean': <gensim.models.keyedvectors.Vocab at 0x13ef7da50>,\n",
              " 'military': <gensim.models.keyedvectors.Vocab at 0x13ef7da90>,\n",
              " 'flew': <gensim.models.keyedvectors.Vocab at 0x13ef7dad0>,\n",
              " 'equip': <gensim.models.keyedvectors.Vocab at 0x13ef7db10>,\n",
              " 'almost': <gensim.models.keyedvectors.Vocab at 0x13ef7db50>,\n",
              " 'crew': <gensim.models.keyedvectors.Vocab at 0x13ef7db90>,\n",
              " 'member': <gensim.models.keyedvectors.Vocab at 0x13ef7dbd0>,\n",
              " 'theory': <gensim.models.keyedvectors.Vocab at 0x13ef7dc10>,\n",
              " 'interest': <gensim.models.keyedvectors.Vocab at 0x13ef7dc50>,\n",
              " 'innovative': <gensim.models.keyedvectors.Vocab at 0x13ef7dc90>,\n",
              " 'creates': <gensim.models.keyedvectors.Vocab at 0x13ef7dcd0>,\n",
              " 'pool': <gensim.models.keyedvectors.Vocab at 0x13ef7dd10>,\n",
              " 'stupidness': <gensim.models.keyedvectors.Vocab at 0x13ef7dd50>,\n",
              " 'unrealism': <gensim.models.keyedvectors.Vocab at 0x13ef7dd90>,\n",
              " 'sub': <gensim.models.keyedvectors.Vocab at 0x13ef7ddd0>,\n",
              " 'par': <gensim.models.keyedvectors.Vocab at 0x13ef7de10>,\n",
              " 'average': <gensim.models.keyedvectors.Vocab at 0x13ef7de50>,\n",
              " 'rest': <gensim.models.keyedvectors.Vocab at 0x13ef7de90>,\n",
              " 'without': <gensim.models.keyedvectors.Vocab at 0x13ef7ded0>,\n",
              " 'badthe': <gensim.models.keyedvectors.Vocab at 0x13ef7df10>,\n",
              " 'ok': <gensim.models.keyedvectors.Vocab at 0x13ef7df50>,\n",
              " 'badmouthing': <gensim.models.keyedvectors.Vocab at 0x13ef7df90>,\n",
              " 'understand': <gensim.models.keyedvectors.Vocab at 0x13ef7dfd0>,\n",
              " 'begin': <gensim.models.keyedvectors.Vocab at 0x13ef81050>,\n",
              " 'blockbuster': <gensim.models.keyedvectors.Vocab at 0x13ef81090>,\n",
              " 'adverse': <gensim.models.keyedvectors.Vocab at 0x13ef810d0>,\n",
              " 'doesnt': <gensim.models.keyedvectors.Vocab at 0x13ef81110>,\n",
              " 'leonardo': <gensim.models.keyedvectors.Vocab at 0x13ef81150>,\n",
              " 'dicaprio': <gensim.models.keyedvectors.Vocab at 0x13ef81190>,\n",
              " 'wilder': <gensim.models.keyedvectors.Vocab at 0x13ef811d0>,\n",
              " 'napalm': <gensim.models.keyedvectors.Vocab at 0x13ef81210>,\n",
              " 'neat': <gensim.models.keyedvectors.Vocab at 0x13ef81250>,\n",
              " 'may': <gensim.models.keyedvectors.Vocab at 0x13ef81290>,\n",
              " 'quirky': <gensim.models.keyedvectors.Vocab at 0x13ef812d0>,\n",
              " 'stupid': <gensim.models.keyedvectors.Vocab at 0x13ef81310>,\n",
              " 'particular': <gensim.models.keyedvectors.Vocab at 0x13ef81350>,\n",
              " 'impressed': <gensim.models.keyedvectors.Vocab at 0x13ef81390>,\n",
              " 'play': <gensim.models.keyedvectors.Vocab at 0x13ef813d0>,\n",
              " 'large': <gensim.models.keyedvectors.Vocab at 0x13ef81410>,\n",
              " 'notice': <gensim.models.keyedvectors.Vocab at 0x13ef81450>,\n",
              " 'important': <gensim.models.keyedvectors.Vocab at 0x13ef81490>,\n",
              " 'vida': <gensim.models.keyedvectors.Vocab at 0x13ef814d0>,\n",
              " 'life': <gensim.models.keyedvectors.Vocab at 0x13ef81510>,\n",
              " 'background': <gensim.models.keyedvectors.Vocab at 0x13ef81550>,\n",
              " 'vidas': <gensim.models.keyedvectors.Vocab at 0x13ef81590>,\n",
              " 'wallace': <gensim.models.keyedvectors.Vocab at 0x13ef815d0>,\n",
              " 'heard': <gensim.models.keyedvectors.Vocab at 0x13ef81610>,\n",
              " 'opening': <gensim.models.keyedvectors.Vocab at 0x13ef81650>,\n",
              " 'sequence': <gensim.models.keyedvectors.Vocab at 0x13ef81690>,\n",
              " 'lyric': <gensim.models.keyedvectors.Vocab at 0x13ef816d0>,\n",
              " 'instance': <gensim.models.keyedvectors.Vocab at 0x13ef81710>,\n",
              " 'men': <gensim.models.keyedvectors.Vocab at 0x13ef81750>,\n",
              " 'duke': <gensim.models.keyedvectors.Vocab at 0x13ef81790>,\n",
              " 'earl': <gensim.models.keyedvectors.Vocab at 0x13ef817d0>,\n",
              " 'something': <gensim.models.keyedvectors.Vocab at 0x13ef81810>,\n",
              " 'girl': <gensim.models.keyedvectors.Vocab at 0x13ef81850>,\n",
              " 'cleverly': <gensim.models.keyedvectors.Vocab at 0x13ef81890>,\n",
              " 'tension': <gensim.models.keyedvectors.Vocab at 0x13ef818d0>,\n",
              " 'intricacy': <gensim.models.keyedvectors.Vocab at 0x13ef81910>,\n",
              " 'look': <gensim.models.keyedvectors.Vocab at 0x13ef81950>,\n",
              " 'flop': <gensim.models.keyedvectors.Vocab at 0x13ef81990>,\n",
              " 'outside': <gensim.models.keyedvectors.Vocab at 0x13ef819d0>,\n",
              " 'real': <gensim.models.keyedvectors.Vocab at 0x13ef81a10>,\n",
              " 'usual': <gensim.models.keyedvectors.Vocab at 0x13ef81a50>,\n",
              " 'forward': <gensim.models.keyedvectors.Vocab at 0x13ef81a90>,\n",
              " 'tvfilm': <gensim.models.keyedvectors.Vocab at 0x13ef81ad0>,\n",
              " 'favourite': <gensim.models.keyedvectors.Vocab at 0x13ef81b10>,\n",
              " 'subject': <gensim.models.keyedvectors.Vocab at 0x13ef81b50>,\n",
              " 'mine': <gensim.models.keyedvectors.Vocab at 0x13ef81b90>,\n",
              " 'nice': <gensim.models.keyedvectors.Vocab at 0x13ef81bd0>,\n",
              " 'change': <gensim.models.keyedvectors.Vocab at 0x13ef81c10>,\n",
              " 'strangely': <gensim.models.keyedvectors.Vocab at 0x13ef81c50>,\n",
              " 'documentary': <gensim.models.keyedvectors.Vocab at 0x13ef81c90>,\n",
              " 'stalingrad': <gensim.models.keyedvectors.Vocab at 0x13ef81cd0>,\n",
              " 'history': <gensim.models.keyedvectors.Vocab at 0x13ef81d10>,\n",
              " 'channeli': <gensim.models.keyedvectors.Vocab at 0x13ef81d50>,\n",
              " 'avidly': <gensim.models.keyedvectors.Vocab at 0x13ef81d90>,\n",
              " 'pearl': <gensim.models.keyedvectors.Vocab at 0x13ef81dd0>,\n",
              " 'harbour': <gensim.models.keyedvectors.Vocab at 0x13ef81e10>,\n",
              " 'enemy': <gensim.models.keyedvectors.Vocab at 0x13ef81e50>,\n",
              " 'gate': <gensim.models.keyedvectors.Vocab at 0x13ef81e90>,\n",
              " 'rudely': <gensim.models.keyedvectors.Vocab at 0x13ef81ed0>,\n",
              " 'brought': <gensim.models.keyedvectors.Vocab at 0x13ef81f10>,\n",
              " 'earth': <gensim.models.keyedvectors.Vocab at 0x13ef81f50>,\n",
              " 'realisation': <gensim.models.keyedvectors.Vocab at 0x13ef81f90>,\n",
              " 'malevolent': <gensim.models.keyedvectors.Vocab at 0x13ef81fd0>,\n",
              " 'power': <gensim.models.keyedvectors.Vocab at 0x13ef84050>,\n",
              " 'hollywood': <gensim.models.keyedvectors.Vocab at 0x13ef84090>,\n",
              " 'spend': <gensim.models.keyedvectors.Vocab at 0x13ef840d0>,\n",
              " 'absolute': <gensim.models.keyedvectors.Vocab at 0x13ef84110>,\n",
              " 'fortune': <gensim.models.keyedvectors.Vocab at 0x13ef84150>,\n",
              " 'yet': <gensim.models.keyedvectors.Vocab at 0x13ef84190>,\n",
              " 'excite': <gensim.models.keyedvectors.Vocab at 0x13ef841d0>,\n",
              " 'rise': <gensim.models.keyedvectors.Vocab at 0x13ef84210>,\n",
              " 'evil': <gensim.models.keyedvectors.Vocab at 0x13ef84250>,\n",
              " 'kershaw': <gensim.models.keyedvectors.Vocab at 0x13ef84290>,\n",
              " 'ive': <gensim.models.keyedvectors.Vocab at 0x13ef842d0>,\n",
              " 'enjoy': <gensim.models.keyedvectors.Vocab at 0x13ef84310>,\n",
              " 'book': <gensim.models.keyedvectors.Vocab at 0x13ef84350>,\n",
              " 'quote': <gensim.models.keyedvectors.Vocab at 0x13ef84390>,\n",
              " 'responsible': <gensim.models.keyedvectors.Vocab at 0x13ef843d0>,\n",
              " 'rubbishthe': <gensim.models.keyedvectors.Vocab at 0x13ef84410>,\n",
              " 'academic': <gensim.models.keyedvectors.Vocab at 0x13ef84450>,\n",
              " 'piece': <gensim.models.keyedvectors.Vocab at 0x13ef84490>,\n",
              " 'dry': <gensim.models.keyedvectors.Vocab at 0x13ef844d0>,\n",
              " 'nut': <gensim.models.keyedvectors.Vocab at 0x13ef84510>,\n",
              " 'hitler': <gensim.models.keyedvectors.Vocab at 0x13ef84550>,\n",
              " 'can': <gensim.models.keyedvectors.Vocab at 0x13ef84590>,\n",
              " 'yes': <gensim.models.keyedvectors.Vocab at 0x13ef845d0>,\n",
              " 'volume': <gensim.models.keyedvectors.Vocab at 0x13ef84610>,\n",
              " 'biography': <gensim.models.keyedvectors.Vocab at 0x13ef84650>,\n",
              " 'detailed': <gensim.models.keyedvectors.Vocab at 0x13ef84690>,\n",
              " 'bethe': <gensim.models.keyedvectors.Vocab at 0x13ef846d0>,\n",
              " 'thesis': <gensim.models.keyedvectors.Vocab at 0x13ef84710>,\n",
              " 'behind': <gensim.models.keyedvectors.Vocab at 0x13ef84750>,\n",
              " 'hat': <gensim.models.keyedvectors.Vocab at 0x13ef84790>,\n",
              " 'jew': <gensim.models.keyedvectors.Vocab at 0x13ef847d0>,\n",
              " 'miss': <gensim.models.keyedvectors.Vocab at 0x13ef84810>,\n",
              " 'emphasise': <gensim.models.keyedvectors.Vocab at 0x13ef84850>,\n",
              " 'fact': <gensim.models.keyedvectors.Vocab at 0x13ef84890>,\n",
              " 'every': <gensim.models.keyedvectors.Vocab at 0x13ef848d0>,\n",
              " 'filmthere': <gensim.models.keyedvectors.Vocab at 0x13ef84910>,\n",
              " 'effort': <gensim.models.keyedvectors.Vocab at 0x13ef84950>,\n",
              " 'whatsoever': <gensim.models.keyedvectors.Vocab at 0x13ef84990>,\n",
              " 'explain': <gensim.models.keyedvectors.Vocab at 0x13ef849d0>,\n",
              " 'adopt': <gensim.models.keyedvectors.Vocab at 0x13ef84a10>,\n",
              " 'view': <gensim.models.keyedvectors.Vocab at 0x13ef84a50>,\n",
              " 'strategy': <gensim.models.keyedvectors.Vocab at 0x13ef84a90>,\n",
              " 'needle': <gensim.models.keyedvectors.Vocab at 0x13ef84ad0>,\n",
              " 'unlike': <gensim.models.keyedvectors.Vocab at 0x13ef84b10>,\n",
              " 'generally': <gensim.models.keyedvectors.Vocab at 0x13ef84b50>,\n",
              " 'excellent': <gensim.models.keyedvectors.Vocab at 0x13ef84b90>,\n",
              " 'nazi': <gensim.models.keyedvectors.Vocab at 0x13ef84bd0>,\n",
              " 'warn': <gensim.models.keyedvectors.Vocab at 0x13ef84c10>,\n",
              " 'neglect': <gensim.models.keyedvectors.Vocab at 0x13ef84c50>,\n",
              " 'nearly': <gensim.models.keyedvectors.Vocab at 0x13ef84c90>,\n",
              " 'leader': <gensim.models.keyedvectors.Vocab at 0x13ef84cd0>,\n",
              " 'munich': <gensim.models.keyedvectors.Vocab at 0x13ef84d10>,\n",
              " 'communist': <gensim.models.keyedvectors.Vocab at 0x13ef84d50>,\n",
              " 'jewish': <gensim.models.keyedvectors.Vocab at 0x13ef84d90>,\n",
              " 'colour': <gensim.models.keyedvectors.Vocab at 0x13ef84dd0>,\n",
              " 'link': <gensim.models.keyedvectors.Vocab at 0x13ef84e10>,\n",
              " 'bolshevism': <gensim.models.keyedvectors.Vocab at 0x13ef84e50>,\n",
              " 'crucial': <gensim.models.keyedvectors.Vocab at 0x13ef84e90>,\n",
              " 'aspect': <gensim.models.keyedvectors.Vocab at 0x13ef84ed0>,\n",
              " 'stuff': <gensim.models.keyedvectors.Vocab at 0x13ef84f10>,\n",
              " 'knew': <gensim.models.keyedvectors.Vocab at 0x13ef84f50>,\n",
              " 'anyway': <gensim.models.keyedvectors.Vocab at 0x13ef84f90>,\n",
              " 'certainly': <gensim.models.keyedvectors.Vocab at 0x13ef84fd0>,\n",
              " 'fascinate': <gensim.models.keyedvectors.Vocab at 0x13ef87050>,\n",
              " 'alludes': <gensim.models.keyedvectors.Vocab at 0x13ef87090>,\n",
              " 'briefly': <gensim.models.keyedvectors.Vocab at 0x13ef870d0>,\n",
              " 'immediately': <gensim.models.keyedvectors.Vocab at 0x13ef87110>,\n",
              " 'ww': <gensim.models.keyedvectors.Vocab at 0x13ef87150>,\n",
              " 'would': <gensim.models.keyedvectors.Vocab at 0x13ef87190>,\n",
              " 'course': <gensim.models.keyedvectors.Vocab at 0x13ef871d0>,\n",
              " 'complex': <gensim.models.keyedvectors.Vocab at 0x13ef87210>,\n",
              " 'handle': <gensim.models.keyedvectors.Vocab at 0x13ef87250>,\n",
              " 'might': <gensim.models.keyedvectors.Vocab at 0x13ef87290>,\n",
              " 'detract': <gensim.models.keyedvectors.Vocab at 0x13ef872d0>,\n",
              " 'relentless': <gensim.models.keyedvectors.Vocab at 0x13ef87310>,\n",
              " 'mantra': <gensim.models.keyedvectors.Vocab at 0x13ef87350>,\n",
              " 'bang': <gensim.models.keyedvectors.Vocab at 0x13ef87390>,\n",
              " 'away': <gensim.models.keyedvectors.Vocab at 0x13ef873d0>,\n",
              " 'mesmerise': <gensim.models.keyedvectors.Vocab at 0x13ef87410>,\n",
              " 'figure': <gensim.models.keyedvectors.Vocab at 0x13ef87450>,\n",
              " 'public': <gensim.models.keyedvectors.Vocab at 0x13ef87490>,\n",
              " 'speaker': <gensim.models.keyedvectors.Vocab at 0x13ef874d0>,\n",
              " 'private': <gensim.models.keyedvectors.Vocab at 0x13ef87510>,\n",
              " 'polite': <gensim.models.keyedvectors.Vocab at 0x13ef87550>,\n",
              " 'sympathetic': <gensim.models.keyedvectors.Vocab at 0x13ef87590>,\n",
              " 'espouse': <gensim.models.keyedvectors.Vocab at 0x13ef875d0>,\n",
              " 'vegetarianism': <gensim.models.keyedvectors.Vocab at 0x13ef87610>,\n",
              " 'antismoking': <gensim.models.keyedvectors.Vocab at 0x13ef87650>,\n",
              " 'guardian': <gensim.models.keyedvectors.Vocab at 0x13ef87690>,\n",
              " 'reader': <gensim.models.keyedvectors.Vocab at 0x13ef876d0>,\n",
              " 'agree': <gensim.models.keyedvectors.Vocab at 0x13ef87710>,\n",
              " 'famously': <gensim.models.keyedvectors.Vocab at 0x13ef87750>,\n",
              " 'fond': <gensim.models.keyedvectors.Vocab at 0x13ef87790>,\n",
              " 'animal': <gensim.models.keyedvectors.Vocab at 0x13ef877d0>,\n",
              " 'hence': <gensim.models.keyedvectors.Vocab at 0x13ef87810>,\n",
              " 'wholly': <gensim.models.keyedvectors.Vocab at 0x13ef87850>,\n",
              " 'invent': <gensim.models.keyedvectors.Vocab at 0x13ef87890>,\n",
              " 'account': <gensim.models.keyedvectors.Vocab at 0x13ef878d0>,\n",
              " 'brave': <gensim.models.keyedvectors.Vocab at 0x13ef87910>,\n",
              " 'soldier': <gensim.models.keyedvectors.Vocab at 0x13ef87950>,\n",
              " 'whilst': <gensim.models.keyedvectors.Vocab at 0x13ef87990>,\n",
              " 'saw': <gensim.models.keyedvectors.Vocab at 0x13ef879d0>,\n",
              " 'iron': <gensim.models.keyedvectors.Vocab at 0x13ef87a10>,\n",
              " 'cross': <gensim.models.keyedvectors.Vocab at 0x13ef87a50>,\n",
              " 'bravery': <gensim.models.keyedvectors.Vocab at 0x13ef87a90>,\n",
              " 'insight': <gensim.models.keyedvectors.Vocab at 0x13ef87ad0>,\n",
              " 'fire': <gensim.models.keyedvectors.Vocab at 0x13ef87b10>,\n",
              " 'war': <gensim.models.keyedvectors.Vocab at 0x13ef87b50>,\n",
              " 'experience': <gensim.models.keyedvectors.Vocab at 0x13ef87b90>,\n",
              " 'sassoon': <gensim.models.keyedvectors.Vocab at 0x13ef87bd0>,\n",
              " 'owen': <gensim.models.keyedvectors.Vocab at 0x13ef87c10>,\n",
              " 'brook': <gensim.models.keyedvectors.Vocab at 0x13ef87c50>,\n",
              " 'remarque': <gensim.models.keyedvectors.Vocab at 0x13ef87c90>,\n",
              " 'others': <gensim.models.keyedvectors.Vocab at 0x13ef87cd0>,\n",
              " 'found': <gensim.models.keyedvectors.Vocab at 0x13ef87d10>,\n",
              " 'repellent': <gensim.models.keyedvectors.Vocab at 0x13ef87d50>,\n",
              " 'vital': <gensim.models.keyedvectors.Vocab at 0x13ef87d90>,\n",
              " 'anyones': <gensim.models.keyedvectors.Vocab at 0x13ef87dd0>,\n",
              " 'always': <gensim.models.keyedvectors.Vocab at 0x13ef87e10>,\n",
              " 'despite': <gensim.models.keyedvectors.Vocab at 0x13ef87e50>,\n",
              " 'massive': <gensim.models.keyedvectors.Vocab at 0x13ef87e90>,\n",
              " 'evidence': <gensim.models.keyedvectors.Vocab at 0x13ef87ed0>,\n",
              " 'contrary': <gensim.models.keyedvectors.Vocab at 0x13ef87f10>,\n",
              " 'colleague': <gensim.models.keyedvectors.Vocab at 0x13ef87f50>,\n",
              " 'still': <gensim.models.keyedvectors.Vocab at 0x13ef87f90>,\n",
              " 'drew': <gensim.models.keyedvectors.Vocab at 0x13ef87fd0>,\n",
              " 'wrong': <gensim.models.keyedvectors.Vocab at 0x13ef8c050>,\n",
              " 'conclusionsthis': <gensim.models.keyedvectors.Vocab at 0x13ef8c090>,\n",
              " 'eitheras': <gensim.models.keyedvectors.Vocab at 0x13ef8c0d0>,\n",
              " 'often': <gensim.models.keyedvectors.Vocab at 0x13ef8c110>,\n",
              " 'day': <gensim.models.keyedvectors.Vocab at 0x13ef8c150>,\n",
              " 'classic': <gensim.models.keyedvectors.Vocab at 0x13ef8c190>,\n",
              " 'example': <gensim.models.keyedvectors.Vocab at 0x13ef8c1d0>,\n",
              " 'relevant': <gensim.models.keyedvectors.Vocab at 0x13ef8c210>,\n",
              " 'leave': <gensim.models.keyedvectors.Vocab at 0x13ef8c250>,\n",
              " 'fit': <gensim.models.keyedvectors.Vocab at 0x13ef8c290>,\n",
              " 'cater': <gensim.models.keyedvectors.Vocab at 0x13ef8c2d0>,\n",
              " 'low': <gensim.models.keyedvectors.Vocab at 0x13ef8c310>,\n",
              " 'common': <gensim.models.keyedvectors.Vocab at 0x13ef8c350>,\n",
              " 'denominator': <gensim.models.keyedvectors.Vocab at 0x13ef8c390>,\n",
              " 'trust': <gensim.models.keyedvectors.Vocab at 0x13ef8c3d0>,\n",
              " 'inch': <gensim.models.keyedvectors.Vocab at 0x13ef8c410>,\n",
              " 'ram': <gensim.models.keyedvectors.Vocab at 0x13ef8c450>,\n",
              " 'throat': <gensim.models.keyedvectors.Vocab at 0x13ef8c490>,\n",
              " 'correctly': <gensim.models.keyedvectors.Vocab at 0x13ef8c4d0>,\n",
              " 'dumb': <gensim.models.keyedvectors.Vocab at 0x13ef8c510>,\n",
              " 'fool': <gensim.models.keyedvectors.Vocab at 0x13ef8c550>,\n",
              " 'past': <gensim.models.keyedvectors.Vocab at 0x13ef8c590>,\n",
              " 'rubbish': <gensim.models.keyedvectors.Vocab at 0x13ef8c5d0>,\n",
              " 'opportunity': <gensim.models.keyedvectors.Vocab at 0x13ef8c610>,\n",
              " 'lose': <gensim.models.keyedvectors.Vocab at 0x13ef8c650>,\n",
              " 'spent': <gensim.models.keyedvectors.Vocab at 0x13ef8c690>,\n",
              " 'million': <gensim.models.keyedvectors.Vocab at 0x13ef8c6d0>,\n",
              " 'location': <gensim.models.keyedvectors.Vocab at 0x13ef8c710>,\n",
              " 'impressive': <gensim.models.keyedvectors.Vocab at 0x13ef8c750>,\n",
              " 'told': <gensim.models.keyedvectors.Vocab at 0x13ef8c790>,\n",
              " 'nothing': <gensim.models.keyedvectors.Vocab at 0x13ef8c7d0>,\n",
              " 'promote': <gensim.models.keyedvectors.Vocab at 0x13ef8c810>,\n",
              " 'period': <gensim.models.keyedvectors.Vocab at 0x13ef8c850>,\n",
              " 'human': <gensim.models.keyedvectors.Vocab at 0x13ef8c890>,\n",
              " 'liberally': <gensim.models.keyedvectors.Vocab at 0x13ef8c8d0>,\n",
              " 'fastforward': <gensim.models.keyedvectors.Vocab at 0x13ef8c910>,\n",
              " 'button': <gensim.models.keyedvectors.Vocab at 0x13ef8c950>,\n",
              " 'shot': <gensim.models.keyedvectors.Vocab at 0x13ef8c990>,\n",
              " 'stewart': <gensim.models.keyedvectors.Vocab at 0x13ef8c9d0>,\n",
              " 'michael': <gensim.models.keyedvectors.Vocab at 0x13ef8ca10>,\n",
              " 'zelniker': <gensim.models.keyedvectors.Vocab at 0x13ef8ca50>,\n",
              " 'walk': <gensim.models.keyedvectors.Vocab at 0x13ef8ca90>,\n",
              " 'hallway': <gensim.models.keyedvectors.Vocab at 0x13ef8cad0>,\n",
              " 'door': <gensim.models.keyedvectors.Vocab at 0x13ef8cb10>,\n",
              " 'street': <gensim.models.keyedvectors.Vocab at 0x13ef8cb50>,\n",
              " 'pensive': <gensim.models.keyedvectors.Vocab at 0x13ef8cb90>,\n",
              " 'confuse': <gensim.models.keyedvectors.Vocab at 0x13ef8cbd0>,\n",
              " 'impression': <gensim.models.keyedvectors.Vocab at 0x13ef8cc10>,\n",
              " 'originally': <gensim.models.keyedvectors.Vocab at 0x13ef8cc50>,\n",
              " 'stretch': <gensim.models.keyedvectors.Vocab at 0x13ef8cc90>,\n",
              " 'labour': <gensim.models.keyedvectors.Vocab at 0x13ef8ccd0>,\n",
              " 'grieve': <gensim.models.keyedvectors.Vocab at 0x13ef8cd10>,\n",
              " 'cowrote': <gensim.models.keyedvectors.Vocab at 0x13ef8cd50>,\n",
              " 'hadnt': <gensim.models.keyedvectors.Vocab at 0x13ef8cd90>,\n",
              " 'disappointingly': <gensim.models.keyedvectors.Vocab at 0x13ef8cdd0>,\n",
              " 'predict': <gensim.models.keyedvectors.Vocab at 0x13ef8ce10>,\n",
              " 'three': <gensim.models.keyedvectors.Vocab at 0x13ef8ce50>,\n",
              " 'atypical': <gensim.models.keyedvectors.Vocab at 0x13ef8ce90>,\n",
              " 'studio': <gensim.models.keyedvectors.Vocab at 0x13ef8ced0>,\n",
              " 'heart': <gensim.models.keyedvectors.Vocab at 0x13ef8cf10>,\n",
              " 'standard': <gensim.models.keyedvectors.Vocab at 0x13ef8cf50>,\n",
              " 'formulaic': <gensim.models.keyedvectors.Vocab at 0x13ef8cf90>,\n",
              " 'manipulative': <gensim.models.keyedvectors.Vocab at 0x13ef8cfd0>,\n",
              " 'nonsense': <gensim.models.keyedvectors.Vocab at 0x13f7a2050>,\n",
              " 'cheap': <gensim.models.keyedvectors.Vocab at 0x13f7a2090>,\n",
              " 'corny': <gensim.models.keyedvectors.Vocab at 0x13f7a20d0>,\n",
              " 'boring': <gensim.models.keyedvectors.Vocab at 0x13f7a2110>,\n",
              " 'slow': <gensim.models.keyedvectors.Vocab at 0x13f7a2150>,\n",
              " 'pace': <gensim.models.keyedvectors.Vocab at 0x13f7a2190>,\n",
              " 'early': <gensim.models.keyedvectors.Vocab at 0x13f7a21d0>,\n",
              " 'horror': <gensim.models.keyedvectors.Vocab at 0x13f7a2210>,\n",
              " 'rent': <gensim.models.keyedvectors.Vocab at 0x13f7a2250>,\n",
              " 'sense': <gensim.models.keyedvectors.Vocab at 0x13f7a2290>,\n",
              " 'family': <gensim.models.keyedvectors.Vocab at 0x13f7a22d0>,\n",
              " 'wood': <gensim.models.keyedvectors.Vocab at 0x13f7a2310>,\n",
              " 'invite': <gensim.models.keyedvectors.Vocab at 0x13f7a2350>,\n",
              " 'son': <gensim.models.keyedvectors.Vocab at 0x13f7a2390>,\n",
              " 'wife': <gensim.models.keyedvectors.Vocab at 0x13f7a23d0>,\n",
              " 'daughter': <gensim.models.keyedvectors.Vocab at 0x13f7a2410>,\n",
              " 'holiday': <gensim.models.keyedvectors.Vocab at 0x13f7a2450>,\n",
              " 'mother': <gensim.models.keyedvectors.Vocab at 0x13f7a2490>,\n",
              " 'law': <gensim.models.keyedvectors.Vocab at 0x13f7a24d0>,\n",
              " 'along': <gensim.models.keyedvectors.Vocab at 0x13f7a2510>,\n",
              " 'till': <gensim.models.keyedvectors.Vocab at 0x13f7a2550>,\n",
              " 'form': <gensim.models.keyedvectors.Vocab at 0x13f7a2590>,\n",
              " 'esp': <gensim.models.keyedvectors.Vocab at 0x13f7a25d0>,\n",
              " 'flashback': <gensim.models.keyedvectors.Vocab at 0x13f7a2610>,\n",
              " 'catastrophe': <gensim.models.keyedvectors.Vocab at 0x13f7a2650>,\n",
              " 'unfortunate': <gensim.models.keyedvectors.Vocab at 0x13f7a2690>,\n",
              " 'clue': <gensim.models.keyedvectors.Vocab at 0x13f7a26d0>,\n",
              " 'bright': <gensim.models.keyedvectors.Vocab at 0x13f7a2710>,\n",
              " 'light': <gensim.models.keyedvectors.Vocab at 0x13f7a2750>,\n",
              " 'signal': <gensim.models.keyedvectors.Vocab at 0x13f7a2790>,\n",
              " 'approach': <gensim.models.keyedvectors.Vocab at 0x13f7a27d0>,\n",
              " 'interpretation': <gensim.models.keyedvectors.Vocab at 0x13f7a2810>,\n",
              " 'darth': <gensim.models.keyedvectors.Vocab at 0x13f7a2850>,\n",
              " 'vadar': <gensim.models.keyedvectors.Vocab at 0x13f7a2890>,\n",
              " 'voice': <gensim.models.keyedvectors.Vocab at 0x13f7a28d0>,\n",
              " 'steal': <gensim.models.keyedvectors.Vocab at 0x13f7a2910>,\n",
              " 'various': <gensim.models.keyedvectors.Vocab at 0x13f7a2950>,\n",
              " 'finally': <gensim.models.keyedvectors.Vocab at 0x13f7a2990>,\n",
              " 'find': <gensim.models.keyedvectors.Vocab at 0x13f7a29d0>,\n",
              " 'killer': <gensim.models.keyedvectors.Vocab at 0x13f7a2a10>,\n",
              " 'turn': <gensim.models.keyedvectors.Vocab at 0x13f7a2a50>,\n",
              " 'kind': <gensim.models.keyedvectors.Vocab at 0x13f7a2a90>,\n",
              " 'japanese': <gensim.models.keyedvectors.Vocab at 0x13f7a2ad0>,\n",
              " 'warrior': <gensim.models.keyedvectors.Vocab at 0x13f7a2b10>,\n",
              " 'apparently': <gensim.models.keyedvectors.Vocab at 0x13f7a2b50>,\n",
              " 'back': <gensim.models.keyedvectors.Vocab at 0x13f7a2b90>,\n",
              " 'claim': <gensim.models.keyedvectors.Vocab at 0x13f7a2bd0>,\n",
              " 'front': <gensim.models.keyedvectors.Vocab at 0x13f7a2c10>,\n",
              " 'living': <gensim.models.keyedvectors.Vocab at 0x13f7a2c50>,\n",
              " 'shake': <gensim.models.keyedvectors.Vocab at 0x13f7a2c90>,\n",
              " 'hand': <gensim.models.keyedvectors.Vocab at 0x13f7a2cd0>,\n",
              " 'shes': <gensim.models.keyedvectors.Vocab at 0x13f7a2d10>,\n",
              " 'convulsion': <gensim.models.keyedvectors.Vocab at 0x13f7a2d50>,\n",
              " 'pathetic': <gensim.models.keyedvectors.Vocab at 0x13f7a2d90>,\n",
              " 'avoid': <gensim.models.keyedvectors.Vocab at 0x13f7a2dd0>,\n",
              " 'worth': <gensim.models.keyedvectors.Vocab at 0x13f7a2e10>,\n",
              " 'miniseries': <gensim.models.keyedvectors.Vocab at 0x13f7a2e50>,\n",
              " 'civil': <gensim.models.keyedvectors.Vocab at 0x13f7a2e90>,\n",
              " 'tell': <gensim.models.keyedvectors.Vocab at 0x13f7a2ed0>,\n",
              " 'friendship': <gensim.models.keyedvectors.Vocab at 0x13f7a2f10>,\n",
              " 'divide': <gensim.models.keyedvectors.Vocab at 0x13f7a2f50>,\n",
              " 'costume': <gensim.models.keyedvectors.Vocab at 0x13f7a2f90>,\n",
              " 'jump': <gensim.models.keyedvectors.Vocab at 0x13f7a2fd0>,\n",
              " 'keep': <gensim.models.keyedvectors.Vocab at 0x13f7a5050>,\n",
              " 'guess': <gensim.models.keyedvectors.Vocab at 0x13f7a5090>,\n",
              " 'whats': <gensim.models.keyedvectors.Vocab at 0x13f7a50d0>,\n",
              " 'balance': <gensim.models.keyedvectors.Vocab at 0x13f7a5110>,\n",
              " 'opinion': <gensim.models.keyedvectors.Vocab at 0x13f7a5150>,\n",
              " 'despicable': <gensim.models.keyedvectors.Vocab at 0x13f7a5190>,\n",
              " 'last': <gensim.models.keyedvectors.Vocab at 0x13f7a51d0>,\n",
              " 'curse': <gensim.models.keyedvectors.Vocab at 0x13f7a5210>,\n",
              " 'engage': <gensim.models.keyedvectors.Vocab at 0x13f7a5250>,\n",
              " 'advise': <gensim.models.keyedvectors.Vocab at 0x13f7a5290>,\n",
              " 'third': <gensim.models.keyedvectors.Vocab at 0x13f7a52d0>,\n",
              " 'series': <gensim.models.keyedvectors.Vocab at 0x13f7a5310>,\n",
              " 'let': <gensim.models.keyedvectors.Vocab at 0x13f7a5350>,\n",
              " 'compare': <gensim.models.keyedvectors.Vocab at 0x13f7a5390>,\n",
              " 'return': <gensim.models.keyedvectors.Vocab at 0x13f7a53d0>,\n",
              " 'wish': <gensim.models.keyedvectors.Vocab at 0x13f7a5410>,\n",
              " 'remember': <gensim.models.keyedvectors.Vocab at 0x13f7a5450>,\n",
              " 'prefer': <gensim.models.keyedvectors.Vocab at 0x13f7a5490>,\n",
              " 'live': <gensim.models.keyedvectors.Vocab at 0x13f7a54d0>,\n",
              " 'second': <gensim.models.keyedvectors.Vocab at 0x13f7a5510>,\n",
              " 'happy': <gensim.models.keyedvectors.Vocab at 0x13f7a5550>,\n",
              " 'elvira': <gensim.models.keyedvectors.Vocab at 0x13f7a5590>,\n",
              " 'mistress': <gensim.models.keyedvectors.Vocab at 0x13f7a55d0>,\n",
              " 'james': <gensim.models.keyedvectors.Vocab at 0x13f7a5610>,\n",
              " 'cassandra': <gensim.models.keyedvectors.Vocab at 0x13f7a5650>,\n",
              " 'peterson': <gensim.models.keyedvectors.Vocab at 0x13f7a5690>,\n",
              " 'morgan': <gensim.models.keyedvectors.Vocab at 0x13f7a56d0>,\n",
              " 'sheppard': <gensim.models.keyedvectors.Vocab at 0x13f7a5710>,\n",
              " 'daniel': <gensim.models.keyedvectors.Vocab at 0x13f7a5750>,\n",
              " 'greene': <gensim.models.keyedvectors.Vocab at 0x13f7a5790>,\n",
              " 'edie': <gensim.models.keyedvectors.Vocab at 0x13f7a57d0>,\n",
              " 'quits': <gensim.models.keyedvectors.Vocab at 0x13f7a5810>,\n",
              " 'head': <gensim.models.keyedvectors.Vocab at 0x13f7a5850>,\n",
              " 'small': <gensim.models.keyedvectors.Vocab at 0x13f7a5890>,\n",
              " 'christian': <gensim.models.keyedvectors.Vocab at 0x13f7a58d0>,\n",
              " 'town': <gensim.models.keyedvectors.Vocab at 0x13f7a5910>,\n",
              " 'fallwell': <gensim.models.keyedvectors.Vocab at 0x13f7a5950>,\n",
              " 'massachusettes': <gensim.models.keyedvectors.Vocab at 0x13f7a5990>,\n",
              " 'collect': <gensim.models.keyedvectors.Vocab at 0x13f7a59d0>,\n",
              " 'dead': <gensim.models.keyedvectors.Vocab at 0x13f7a5a10>,\n",
              " 'aunt': <gensim.models.keyedvectors.Vocab at 0x13f7a5a50>,\n",
              " 'inheritance': <gensim.models.keyedvectors.Vocab at 0x13f7a5a90>,\n",
              " 'hop': <gensim.models.keyedvectors.Vocab at 0x13f7a5ad0>,\n",
              " 'buck': <gensim.models.keyedvectors.Vocab at 0x13f7a5b10>,\n",
              " 'open': <gensim.models.keyedvectors.Vocab at 0x13f7a5b50>,\n",
              " 'vega': <gensim.models.keyedvectors.Vocab at 0x13f7a5b90>,\n",
              " 'unfortunately': <gensim.models.keyedvectors.Vocab at 0x13f7a5bd0>,\n",
              " 'creepy': <gensim.models.keyedvectors.Vocab at 0x13f7a5c10>,\n",
              " 'old': <gensim.models.keyedvectors.Vocab at 0x13f7a5c50>,\n",
              " 'house': <gensim.models.keyedvectors.Vocab at 0x13f7a5c90>,\n",
              " 'poodle': <gensim.models.keyedvectors.Vocab at 0x13f7a5cd0>,\n",
              " 'magic': <gensim.models.keyedvectors.Vocab at 0x13f7a5d10>,\n",
              " 'cookbook': <gensim.models.keyedvectors.Vocab at 0x13f7a5d50>,\n",
              " 'breathe': <gensim.models.keyedvectors.Vocab at 0x13f7a5d90>,\n",
              " 'teenager': <gensim.models.keyedvectors.Vocab at 0x13f7a5dd0>,\n",
              " 'win': <gensim.models.keyedvectors.Vocab at 0x13f7a5e10>,\n",
              " 'stud': <gensim.models.keyedvectors.Vocab at 0x13f7a5e50>,\n",
              " 'burn': <gensim.models.keyedvectors.Vocab at 0x13f7a5e90>,\n",
              " 'stake': <gensim.models.keyedvectors.Vocab at 0x13f7a5ed0>,\n",
              " 'uncle': <gensim.models.keyedvectors.Vocab at 0x13f7a5f10>,\n",
              " 'planning': <gensim.models.keyedvectors.Vocab at 0x13f7a5f50>,\n",
              " 'alterego': <gensim.models.keyedvectors.Vocab at 0x13f7a5f90>,\n",
              " 'successful': <gensim.models.keyedvectors.Vocab at 0x13f7a5fd0>,\n",
              " 'woman': <gensim.models.keyedvectors.Vocab at 0x13f7a8050>,\n",
              " 'plus': <gensim.models.keyedvectors.Vocab at 0x13f7a8090>,\n",
              " 'morbid': <gensim.models.keyedvectors.Vocab at 0x13f7a80d0>,\n",
              " 'hilariously': <gensim.models.keyedvectors.Vocab at 0x13f7a8110>,\n",
              " 'naive': <gensim.models.keyedvectors.Vocab at 0x13f7a8150>,\n",
              " 'amaze': <gensim.models.keyedvectors.Vocab at 0x13f7a8190>,\n",
              " 'pair': <gensim.models.keyedvectors.Vocab at 0x13f7a81d0>,\n",
              " 'knocker': <gensim.models.keyedvectors.Vocab at 0x13f7a8210>,\n",
              " 'charm': <gensim.models.keyedvectors.Vocab at 0x13f7a8250>,\n",
              " 'usei': <gensim.models.keyedvectors.Vocab at 0x13f7a8290>,\n",
              " 'whole': <gensim.models.keyedvectors.Vocab at 0x13f7a82d0>,\n",
              " 'fish': <gensim.models.keyedvectors.Vocab at 0x13f7a8310>,\n",
              " 'water': <gensim.models.keyedvectors.Vocab at 0x13f7a8350>,\n",
              " 'lowcut': <gensim.models.keyedvectors.Vocab at 0x13f7a8390>,\n",
              " 'black': <gensim.models.keyedvectors.Vocab at 0x13f7a83d0>,\n",
              " 'hair': <gensim.models.keyedvectors.Vocab at 0x13f7a8410>,\n",
              " 'enormous': <gensim.models.keyedvectors.Vocab at 0x13f7a8450>,\n",
              " 'twin': <gensim.models.keyedvectors.Vocab at 0x13f7a8490>,\n",
              " 'arent': <gensim.models.keyedvectors.Vocab at 0x13f7a84d0>,\n",
              " 'allow': <gensim.models.keyedvectors.Vocab at 0x13f7a8510>,\n",
              " 'wear': <gensim.models.keyedvectors.Vocab at 0x13f7a8550>,\n",
              " 'makeup': <gensim.models.keyedvectors.Vocab at 0x13f7a8590>,\n",
              " 'bob': <gensim.models.keyedvectors.Vocab at 0x13f7a85d0>,\n",
              " 'lot': <gensim.models.keyedvectors.Vocab at 0x13f7a8610>,\n",
              " 'equally': <gensim.models.keyedvectors.Vocab at 0x13f7a8650>,\n",
              " 'elviras': <gensim.models.keyedvectors.Vocab at 0x13f7a8690>,\n",
              " 'vincent': <gensim.models.keyedvectors.Vocab at 0x13f7a86d0>,\n",
              " 'presence': <gensim.models.keyedvectors.Vocab at 0x13f7a8710>,\n",
              " 'everything': <gensim.models.keyedvectors.Vocab at 0x13f7a8750>,\n",
              " 'boob': <gensim.models.keyedvectors.Vocab at 0x13f7a8790>,\n",
              " 'spoof': <gensim.models.keyedvectors.Vocab at 0x13f7a87d0>,\n",
              " 'scary': <gensim.models.keyedvectors.Vocab at 0x13f7a8810>,\n",
              " 'sequel': <gensim.models.keyedvectors.Vocab at 0x13f7a8850>,\n",
              " 'roger': <gensim.models.keyedvectors.Vocab at 0x13f7a8890>,\n",
              " 'corman': <gensim.models.keyedvectors.Vocab at 0x13f7a88d0>,\n",
              " 'bhorror': <gensim.models.keyedvectors.Vocab at 0x13f7a8910>,\n",
              " 'flick': <gensim.models.keyedvectors.Vocab at 0x13f7a8950>,\n",
              " 'filmif': <gensim.models.keyedvectors.Vocab at 0x13f7a8990>,\n",
              " 'check': <gensim.models.keyedvectors.Vocab at 0x13f7a89d0>,\n",
              " 'haunt': <gensim.models.keyedvectors.Vocab at 0x13f7a8a10>,\n",
              " 'hill': <gensim.models.keyedvectors.Vocab at 0x13f7a8a50>,\n",
              " 'knowledge': <gensim.models.keyedvectors.Vocab at 0x13f7a8a90>,\n",
              " 'author': <gensim.models.keyedvectors.Vocab at 0x13f7a8ad0>,\n",
              " 'phillipa': <gensim.models.keyedvectors.Vocab at 0x13f7a8b10>,\n",
              " 'pearce': <gensim.models.keyedvectors.Vocab at 0x13f7a8b50>,\n",
              " 'novel': <gensim.models.keyedvectors.Vocab at 0x13f7a8b90>,\n",
              " 'tom': <gensim.models.keyedvectors.Vocab at 0x13f7a8bd0>,\n",
              " 'midnight': <gensim.models.keyedvectors.Vocab at 0x13f7a8c10>,\n",
              " 'garden': <gensim.models.keyedvectors.Vocab at 0x13f7a8c50>,\n",
              " 'typical': <gensim.models.keyedvectors.Vocab at 0x13f7a8c90>,\n",
              " 'child': <gensim.models.keyedvectors.Vocab at 0x13f7a8cd0>,\n",
              " 'interested': <gensim.models.keyedvectors.Vocab at 0x13f7a8d10>,\n",
              " 'unless': <gensim.models.keyedvectors.Vocab at 0x13f7a8d50>,\n",
              " 'monster': <gensim.models.keyedvectors.Vocab at 0x13f7a8d90>,\n",
              " 'high': <gensim.models.keyedvectors.Vocab at 0x13f7a8dd0>,\n",
              " 'body': <gensim.models.keyedvectors.Vocab at 0x13f7a8e10>,\n",
              " 'count': <gensim.models.keyedvectors.Vocab at 0x13f7a8e50>,\n",
              " 'judging': <gensim.models.keyedvectors.Vocab at 0x13f7a8e90>,\n",
              " 'version': <gensim.models.keyedvectors.Vocab at 0x13f7a8ed0>,\n",
              " 'writes': <gensim.models.keyedvectors.Vocab at 0x13f7a8f10>,\n",
              " 'middle': <gensim.models.keyedvectors.Vocab at 0x13f7a8f50>,\n",
              " 'class': <gensim.models.keyedvectors.Vocab at 0x13f7a8f90>,\n",
              " 'kid': <gensim.models.keyedvectors.Vocab at 0x13f7a8fd0>,\n",
              " ...}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "pBZgQNb8MXc8"
      },
      "source": [
        "#### Using Pre-trained Word2Vec model\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "2r9ViJq7MXc8",
        "colab": {}
      },
      "source": [
        "pre_trained_model = KeyedVectors.load_word2vec_format(\"GoogleNews-vectors-negative300.bin\",binary=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "C1wr7ok7MXc_"
      },
      "source": [
        "#### Feature encoding based on Word2Vec vocabulary\n",
        "\n",
        "<ul>\n",
        "    <li> Mean </li>\n",
        "    <li> TF-IDF </li>\n",
        "</ul>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "pEdaYvwMMXc_",
        "colab": {}
      },
      "source": [
        "# The code to encode the features using Word2Vec is reused and modified.\n",
        "\n",
        "class MeanEmbeddingVectorizer(object):\n",
        "\n",
        "    def __init__(self, word_model,pre_trained):\n",
        "        self.pre_trained = pre_trained\n",
        "        self.word_model = word_model\n",
        "        if self.pre_trained == False:\n",
        "            self.vector_size = word_model.wv.vector_size\n",
        "        else:\n",
        "            self.vector_size = word_model.vector_size\n",
        "\n",
        "    def fit(self):  # comply with scikit-learn transformer requirement\n",
        "        return self\n",
        "\n",
        "    def transform(self, docs):  # comply with scikit-learn transformer requirement\n",
        "        doc_word_vector = self.word_average_list(docs)\n",
        "        return doc_word_vector\n",
        "\n",
        "    def word_average(self, sent):\n",
        "        \"\"\"\n",
        "        Compute average word vector for a single doc/sentence.\n",
        "\n",
        "\n",
        "        :param sent: list of sentence tokens\n",
        "        :return:\n",
        "            mean: float of averaging word vectors\n",
        "        \"\"\"\n",
        "        mean = []\n",
        "        for word in sent:\n",
        "            if self.pre_trained == False:\n",
        "                if word in self.word_model.wv.vocab:\n",
        "                    mean.append(self.word_model.wv.get_vector(word))\n",
        "            else:\n",
        "                if word in self.word_model.vocab:\n",
        "                    mean.append(self.word_model.get_vector(word))\n",
        "        if not mean:  # empty words\n",
        "            # If a text is empty, return a vector of zeros.\n",
        "            #logging.warning(\"cannot compute average owing to no vector for {}\".format(sent))\n",
        "            return np.zeros(self.vector_size)\n",
        "        else:\n",
        "            mean = np.array(mean).mean(axis=0)\n",
        "            return mean\n",
        "\n",
        "\n",
        "    def word_average_list(self, docs):\n",
        "        \"\"\"\n",
        "        Compute average word vector for multiple docs, where docs had been tokenized.\n",
        "\n",
        "        :param docs: list of sentence in list of separated tokens\n",
        "        :return:\n",
        "            array of average word vector in shape (len(docs),)\n",
        "        \"\"\"\n",
        "        return np.vstack([self.word_average(sent) for sent in docs])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "dn-nSeuhMXdB",
        "colab": {}
      },
      "source": [
        "class TfidfEmbeddingVectorizer(object):\n",
        "\n",
        "    def __init__(self, word_model,pre_trained):\n",
        "        self.pre_trained = pre_trained\n",
        "        self.word_model = word_model\n",
        "        self.word_idf_weight = None\n",
        "        if self.pre_trained == False:\n",
        "            self.vector_size = word_model.wv.vector_size\n",
        "        else:\n",
        "            self.vector_size = word_model.vector_size\n",
        "\n",
        "\n",
        "\n",
        "    def fit(self, docs):  # comply with scikit-learn transformer requirement\n",
        "        \"\"\"\n",
        "        Fit in a list of docs, which had been preprocessed and tokenized,\n",
        "        such as word bi-grammed, stop-words removed, lemmatized, part of speech filtered.\n",
        "\n",
        "        Then build up a tfidf model to compute each word's idf as its weight.\n",
        "        Noted that tf weight is already involved when constructing average word vectors, and thus omitted.\n",
        "\n",
        "        :param\n",
        "            pre_processed_docs: list of docs, which are tokenized\n",
        "        :return:\n",
        "            self\n",
        "        \"\"\"\n",
        "\n",
        "        text_docs = []\n",
        "        for doc in docs:\n",
        "            text_docs.append(\" \".join(doc))\n",
        "\n",
        "        tfidf = TfidfVectorizer()\n",
        "        tfidf.fit(text_docs)  # must be list of text string\n",
        "\n",
        "        # if a word was never seen - it must be at least as infrequent\n",
        "        # as any of the known words - so the default idf is the max of\n",
        "        # known idf's\n",
        "        max_idf = max(tfidf.idf_)  # used as default value for defaultdict\n",
        "        self.word_idf_weight = defaultdict(lambda: max_idf,[(word, tfidf.idf_[i]) for word, i in tfidf.vocabulary_.items()])\n",
        "        return self\n",
        "\n",
        "\n",
        "    def transform(self, docs):  # comply with scikit-learn transformer requirement\n",
        "        doc_word_vector = self.word_average_list(docs)\n",
        "        return doc_word_vector\n",
        "\n",
        "\n",
        "    def word_average(self, sent):\n",
        "        \"\"\"\n",
        "        Compute average word vector for a single doc/sentence.\n",
        "\n",
        "\n",
        "        :param sent: list of sentence tokens\n",
        "        :return:\n",
        "        mean: float of averaging word vectors\n",
        "        \"\"\"\n",
        "\n",
        "        mean = []\n",
        "        for word in sent:\n",
        "            if self.pre_trained == False:\n",
        "                if word in self.word_model.wv.vocab:\n",
        "                    mean.append(self.word_model.wv.get_vector(word) * self.word_idf_weight[word])  # idf weighted\n",
        "            else:\n",
        "                if word in self.word_model.vocab:\n",
        "                    mean.append(self.word_model.get_vector(word) * self.word_idf_weight[word])  # idf weighted\n",
        "\n",
        "\n",
        "\n",
        "        if not mean:  # empty words\n",
        "            # If a text is empty, return a vector of zeros.\n",
        "            #logging.warning(\"cannot compute average owing to no vector for {}\".format(sent))\n",
        "            return np.zeros(self.vector_size)\n",
        "        else:\n",
        "            mean = np.array(mean).mean(axis=0)\n",
        "            return mean\n",
        "\n",
        "\n",
        "    def word_average_list(self, docs):\n",
        "        \"\"\"\n",
        "        Compute average word vector for multiple docs, where docs had been tokenized.\n",
        "\n",
        "        :param docs: list of sentence in list of separated tokens\n",
        "        :return:\n",
        "            array of average word vector in shape (len(docs),)\n",
        "        \"\"\"\n",
        "        return np.vstack([self.word_average(sent) for sent in docs])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "1JdIrCHWMXdI"
      },
      "source": [
        "#### Model training and plots\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "c6EBYqOuMXdJ"
      },
      "source": [
        "I will be using below classifiers for the analysis,\n",
        "<ul>\n",
        "    <li> Logistic Regression </li>\n",
        "    <li> SVM </li>\n",
        " </ul>\n",
        " \n",
        " "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "vlku9FvsMXdJ",
        "colab": {}
      },
      "source": [
        "model_params = {\n",
        "    'svm': {\n",
        "        'model': SVC(probability=True,verbose=1),\n",
        "        'params' : {\n",
        "            'C': [1,10],\n",
        "            'kernel': ['rbf']\n",
        "        }  \n",
        "    },\n",
        "    'logistic_regression' : {\n",
        "        'model': LogisticRegression(max_iter=1000,verbose=1),\n",
        "        'params': {\n",
        "            'C': [1,10],\n",
        "        }\n",
        "    }\n",
        "}\n",
        "\n",
        "# Due to time and resource constraints I am using fewer number of hyper-parameters for the tuning "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "-q_p1sA2MXdK",
        "colab": {}
      },
      "source": [
        "scoring = 'f1'\n",
        "folds = KFold(n_splits=5,shuffle=True,random_state=42)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "uoXCiZEoMXdL",
        "colab": {}
      },
      "source": [
        "def get_X(vocab_type):   \n",
        "    if vocab_type == \"mean_w2v\":\n",
        "        mean_vec_tr = MeanEmbeddingVectorizer(model,pre_trained = False)\n",
        "        X = mean_vec_tr.transform(data_proc_w2v)\n",
        "        return X\n",
        " \n",
        "        \n",
        "    elif vocab_type == \"tfidf_w2v\":\n",
        "        tfidf_vec_tr = TfidfEmbeddingVectorizer(model,pre_trained = False)\n",
        "        tfidf_vec_tr.fit(data_proc_w2v)  # fit tfidf model first\n",
        "        X = tfidf_vec_tr.transform(data_proc_w2v)\n",
        "        return X\n",
        "        \n",
        "    elif vocab_type == \"pre_mean_w2v\":        \n",
        "        pre_mean_vec_tr = MeanEmbeddingVectorizer(pre_trained_model,pre_trained = True)\n",
        "        X = pre_mean_vec_tr.transform(data_proc_w2v)\n",
        "        return X\n",
        "\n",
        "        \n",
        "    elif vocab_type == \"pre_tfidf_w2v\":\n",
        "        pre_tfidf_vec_tr = TfidfEmbeddingVectorizer(pre_trained_model,pre_trained = True)\n",
        "        pre_tfidf_vec_tr.fit(data_proc_w2v)  # fit tfidf model first\n",
        "        X = pre_tfidf_vec_tr.transform(data_proc_w2v)\n",
        "        return X\n",
        "    \n",
        "    else:\n",
        "        print(\"Invalid\")\n",
        "    \n",
        "    return\n",
        "        \n",
        "   "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "RutgKyA-MXdO",
        "colab": {}
      },
      "source": [
        "def fit(X,y,model_params,scoring,folds):\n",
        "    scores = []\n",
        "    for model_name, mp in model_params.items():\n",
        "        clf =  GridSearchCV(mp['model'], mp['params'], return_train_score=False,scoring=scoring,cv=folds)\n",
        "        clf.fit(X, y)\n",
        "        scores.append({\n",
        "            'model': model_name,\n",
        "            'best_score': clf.best_score_,\n",
        "            'best_params': clf.best_params_,\n",
        "            'best_estimator':clf.best_estimator_\n",
        "        })\n",
        "    df = pd.DataFrame(scores,columns=['model','best_score','best_params','best_estimator'])\n",
        "    best_score = max(df['best_score'])\n",
        "    best_clf = df['best_estimator'][df['best_score'].argmax()]\n",
        "    return best_clf,df\n",
        "    \n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "b3pnNUQZMXde",
        "colab": {}
      },
      "source": [
        "# Mean of vector representation\n",
        "def fit_mean_w2v():\n",
        "    X  = get_X(\"mean_w2v\")\n",
        "    print(\"Train data shape(Mean W2V): \",X.shape)\n",
        "    clf_mean_w2v, df_mean_w2v= fit(X,y_train,model_params,scoring,folds)\n",
        "    mean_w2v_clf_name = df_mean_w2v['model'][df_mean_w2v['best_score'].argmax()]\n",
        "    return X,clf_mean_w2v, df_mean_w2v,mean_w2v_clf_name\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "RKbAFUAiMXdg",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "outputId": "550256b3-f1a5-4fce-8f05-4f3127e16f6d"
      },
      "source": [
        "X,clf_mean_w2v, df_mean_w2v,mean_w2v_clf_name = fit_mean_w2v()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Train data shape(Mean W2V):  (40000, 300)\n",
            "[LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM]"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.9s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.6s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    2.0s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.7s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.6s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.9s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    2.0s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.9s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.9s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.6s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    2.1s finished\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "JQKEQI21YSr4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 111
        },
        "outputId": "b6d4bd88-642f-4b6d-e9b0-452be2559942"
      },
      "source": [
        "df_mean_w2v"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>model</th>\n",
              "      <th>best_score</th>\n",
              "      <th>best_params</th>\n",
              "      <th>best_estimator</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>svm</td>\n",
              "      <td>0.889880</td>\n",
              "      <td>{'C': 1, 'kernel': 'rbf'}</td>\n",
              "      <td>SVC(C=1, probability=True, verbose=1)</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>logistic_regression</td>\n",
              "      <td>0.883095</td>\n",
              "      <td>{'C': 1}</td>\n",
              "      <td>LogisticRegression(C=1, max_iter=1000, verbose=1)</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                 model  best_score                best_params  \\\n",
              "0                  svm    0.889880  {'C': 1, 'kernel': 'rbf'}   \n",
              "1  logistic_regression    0.883095                   {'C': 1}   \n",
              "\n",
              "                                      best_estimator  \n",
              "0              SVC(C=1, probability=True, verbose=1)  \n",
              "1  LogisticRegression(C=1, max_iter=1000, verbose=1)  "
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "kR_XHmAQMXdh",
        "colab": {}
      },
      "source": [
        "# TF-IDF of vector representation\n",
        "def fit_tfidf_w2v():\n",
        "    X  = get_X(\"tfidf_w2v\")\n",
        "    print(\"Train data shape(TFIDF W2V): \",X.shape)\n",
        "    clf_tfidf_w2v, df_tfidf_w2v = fit(X,y_train,model_params,scoring,folds)\n",
        "    tfidf_w2v_clf_name = df_tfidf_w2v['model'][df_tfidf_w2v['best_score'].argmax()]\n",
        "    return X,clf_tfidf_w2v, df_tfidf_w2v,tfidf_w2v_clf_name \n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "9NgF_CZBMXdi",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "outputId": "dd264b9a-5a8e-4af2-d06f-e41220aa1a01"
      },
      "source": [
        "X,clf_tfidf_w2v, df_tfidf_w2v,tfidf_w2v_clf_name  = fit_tfidf_w2v()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Train data shape(TFIDF W2V):  (40000, 300)\n",
            "[LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM]"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.7s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.6s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.1s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.7s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.1s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.6s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.9s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.1s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.6s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.0s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.8s finished\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Qu9HVZ37MXdj",
        "colab": {}
      },
      "source": [
        " # Pre-trained Mean of vector representation\n",
        "def fit_pre_mean_w2v():\n",
        "    X  = get_X(\"pre_mean_w2v\")\n",
        "    print(\"Train data shape(Pre-trained Mean W2V): \",X.shape)\n",
        "    clf_pre_mean_w2v, df_pre_mean_w2v = fit(X,y_train,model_params,scoring,folds)\n",
        "    pre_mean_w2v_clf_name = df_pre_mean_w2v['model'][df_pre_mean_w2v['best_score'].argmax()]\n",
        "    return X,clf_pre_mean_w2v, df_pre_mean_w2v,pre_mean_w2v_clf_name\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "bwOHZENVMXdk",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "outputId": "f2c0ce2a-c512-4f1e-ffe3-9d5d661c1fd1"
      },
      "source": [
        "X,clf_pre_mean_w2v, df_pre_mean_w2v,pre_mean_w2v_clf_name = fit_pre_mean_w2v()\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Train data shape(Pre-trained Mean W2V):  (40000, 300)\n",
            "[LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM]"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.3s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.2s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.9s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.1s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.0s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    2.0s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.7s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.8s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    2.0s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.1s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    2.9s finished\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "l3mPc1-GMXdl",
        "colab": {}
      },
      "source": [
        "# Pre-trained TF-IDF of vector representation\n",
        "def fit_pre_tfidf_w2v():\n",
        "    X  = get_X(\"pre_tfidf_w2v\")\n",
        "    print(\"Train data shape(Pre-trained TFIDF W2V): \",X.shape)\n",
        "    clf_pre_tfidf_w2v, df_pre_tfidf_w2v = fit(X,y_train,model_params,scoring,folds)\n",
        "    pre_tfidf_w2v_clf_name = df_pre_tfidf_w2v['model'][df_pre_tfidf_w2v['best_score'].argmax()]\n",
        "    return X,clf_pre_tfidf_w2v, df_pre_tfidf_w2v,pre_tfidf_w2v_clf_name\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "2S1ZXihzMXdn",
        "colab": {},
        "outputId": "5eaa18f0-8061-4bad-8cbb-427cd3f7824b"
      },
      "source": [
        "X,clf_pre_tfidf_w2v, df_pre_tfidf_w2v,pre_tfidf_w2v_clf_name = fit_pre_tfidf_w2v()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Train data shape(Pre-trained TFIDF W2V):  (40000, 300)\n",
            "[LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM][LibSVM]"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.5s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.5s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.8s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.7s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.2s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.5s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.7s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.4s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.5s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    1.7s finished\n",
            "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
            "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    2.4s finished\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "6hVGcIa2MXdo"
      },
      "source": [
        "#### The Best models comparison\n",
        "\n",
        "Making a common ground for testing on X_test."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "weWPD95wMXdo",
        "colab": {}
      },
      "source": [
        "def generate_comparison(w2v=True,pre_w2v=True,mean_w2v=True,tfidf_w2v=True,pre_mean_w2v=True,pre_tfidf_w2v=True):\n",
        "\n",
        "    all_clf = dict()\n",
        "    all_clf_names = dict()\n",
        "    all_X_test = dict()\n",
        "    auc = dict()\n",
        "\n",
        "    r_proba = [0 for _ in range(len(X_test))]\n",
        "    r_auc = roc_auc_score(y_test,r_proba)\n",
        "    print('Random (chance) Prediction: AUROC = %.3f' % (r_auc))\n",
        "    r_fpr, r_tpr, _ = roc_curve(y_test, r_proba)\n",
        "    plt.plot(r_fpr, r_tpr, linestyle='--', label='Random prediction (AUROC = %0.3f)' % r_auc)\n",
        "\n",
        "    if w2v:\n",
        "        w2v_model_vocab = model \n",
        "        w2v_test = []\n",
        "        for i in tqdm(range (0,len(X_test))):\n",
        "            w2v_test.append(gensim.utils.simple_preprocess(X_test.iloc[i]))\n",
        "    \n",
        "\n",
        "    if mean_w2v:\n",
        "        all_clf['mean_w2v'] = clf_mean_w2v\n",
        "        all_clf_names['mean_w2v'] = mean_w2v_clf_name\n",
        "        w2v_mean = MeanEmbeddingVectorizer(w2v_model_vocab,pre_trained=False)\n",
        "        mean_w2v_test = w2v_mean.transform(w2v_test)\n",
        "        all_X_test['mean_w2v'] = mean_w2v_test\n",
        "        mean_w2v_proba = clf_mean_w2v.predict_proba(mean_w2v_test)\n",
        "        mean_w2v_proba = mean_w2v_proba[:, 1]\n",
        "        mean_w2v_auc = roc_auc_score(y_test,mean_w2v_proba)\n",
        "        print('Mean W2V: AUROC = %.3f' % (mean_w2v_auc))\n",
        "        mean_w2v_fpr, mean_w2v_tpr, _ = roc_curve(y_test, mean_w2v_proba)\n",
        "        plt.plot(mean_w2v_fpr, mean_w2v_tpr, marker='.', label='Mean W2V (AUROC = %0.3f)' % mean_w2v_auc)\n",
        "        auc['mean_w2v'] = mean_w2v_auc\n",
        "        \n",
        "        \n",
        "    if tfidf_w2v:       \n",
        "        all_clf['tfidf_w2v'] = clf_tfidf_w2v\n",
        "        all_clf_names['tfidf_w2v'] = tfidf_w2v_clf_name        \n",
        "        w2v_tfid = TfidfEmbeddingVectorizer(w2v_model_vocab,pre_trained=False)\n",
        "        w2v_tfid.fit(w2v_test)\n",
        "        tfid_w2v_test = w2v_tfid.transform(w2v_test)\n",
        "        all_X_test['tfidf_w2v'] = tfid_w2v_test\n",
        "        tfidf_w2v_proba = clf_tfidf_w2v.predict_proba(tfid_w2v_test)\n",
        "        tfidf_w2v_proba = tfidf_w2v_proba[:, 1]\n",
        "        tfidf_w2v_auc = roc_auc_score(y_test,tfidf_w2v_proba)\n",
        "        print('Tfidf W2V: AUROC = %.3f' % (tfidf_w2v_auc))\n",
        "        tfidf_w2v_fpr,tfidf_w2v_tpr, _ = roc_curve(y_test,tfidf_w2v_proba)\n",
        "        plt.plot(tfidf_w2v_fpr, tfidf_w2v_tpr, marker='.', label='Tfidf W2V (AUROC = %0.3f)' % tfidf_w2v_auc)\n",
        "        auc['tfidf_w2v'] = tfidf_w2v_auc\n",
        "        \n",
        "    if pre_w2v:\n",
        "        #pre_trained_model = KeyedVectors.load_word2vec_format(\"GoogleNews-vectors-negative300.bin\",binary=True)\n",
        "        w2v_test = []\n",
        "        for i in tqdm(range (0,len(X_test))):\n",
        "            w2v_test.append(gensim.utils.simple_preprocess(X_test.iloc[i]))\n",
        "        \n",
        "    if pre_mean_w2v:\n",
        "        all_clf['pre_trained_mean_w2v'] = clf_pre_mean_w2v\n",
        "        all_clf_names['pre_trained_mean_w2v'] = pre_mean_w2v_clf_name\n",
        "        pre_w2v_mean = MeanEmbeddingVectorizer(pre_trained_model,pre_trained=True)\n",
        "        pre_mean_w2v_test = pre_w2v_mean.transform(w2v_test)\n",
        "        all_X_test['pre_trained_mean_w2v'] = pre_mean_w2v_test\n",
        "        pre_mean_w2v_proba = clf_pre_mean_w2v.predict_proba(pre_mean_w2v_test)\n",
        "        pre_mean_w2v_proba = pre_mean_w2v_proba[:, 1]\n",
        "        pre_mean_w2v_auc = roc_auc_score(y_test,pre_mean_w2v_proba)\n",
        "        print('Pre-Mean W2V: AUROC = %.3f' % (pre_mean_w2v_auc))\n",
        "        pre_mean_w2v_fpr, pre_mean_w2v_tpr, _ = roc_curve(y_test, pre_mean_w2v_proba)\n",
        "        plt.plot(pre_mean_w2v_fpr, pre_mean_w2v_tpr, marker='.', label='Pre-Mean W2V (AUROC = %0.3f)' % pre_mean_w2v_auc)\n",
        "        auc['pre_trained_mean_w2v'] = pre_mean_w2v_auc\n",
        "\n",
        "    if pre_tfidf_w2v:\n",
        "        all_clf['pre_trained_tfidf_w2v']= clf_pre_tfidf_w2v\n",
        "        all_clf_names['pre_trained_tfidf_w2v'] =pre_tfidf_w2v_clf_name\n",
        "        pre_w2v_tfid = TfidfEmbeddingVectorizer(pre_trained_model,pre_trained=True)\n",
        "        pre_w2v_tfid.fit(w2v_test)\n",
        "        pre_tfid_w2v_test = pre_w2v_tfid.transform(w2v_test)\n",
        "        all_X_test['pre_trained_tfidf_w2v'] = pre_tfid_w2v_test\n",
        "        pre_tfidf_w2v_proba = clf_pre_tfidf_w2v.predict_proba(pre_tfid_w2v_test)\n",
        "        pre_tfidf_w2v_proba = pre_tfidf_w2v_proba[:, 1]\n",
        "        pre_tfidf_w2v_auc = roc_auc_score(y_test,pre_tfidf_w2v_proba)\n",
        "        print('Pre-Tfidf W2V: AUROC = %.3f' % (pre_tfidf_w2v_auc))\n",
        "        pre_tfidf_w2v_fpr,pre_tfidf_w2v_tpr, _ = roc_curve(y_test,pre_tfidf_w2v_proba)\n",
        "        plt.plot(pre_tfidf_w2v_fpr, pre_tfidf_w2v_tpr, marker='.', label='Pre-Tfidf W2V (AUROC = %0.3f)' % pre_tfidf_w2v_auc)\n",
        "        auc['pre_trained_tfidf_w2v'] = pre_tfidf_w2v_auc\n",
        "    \n",
        "    # Title\n",
        "    plt.title('ROC Plot for classifiers trained on dataset of size '+ str(len(X_train)))\n",
        "    # Axis labels\n",
        "    plt.xlabel('False Positive Rate')\n",
        "    plt.ylabel('True Positive Rate')\n",
        "    # Show legend\n",
        "    plt.legend() # \n",
        "    # Show plot\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "    best_clf_vocab = max(auc, key=auc.get)\n",
        "    best_clf = all_clf[best_clf_vocab]\n",
        "    print(\"The best performing classifier is\" ,all_clf_names[best_clf_vocab],\" on the \",best_clf_vocab,\" vocabulary\")\n",
        "    y_pred = best_clf.predict(all_X_test[best_clf_vocab])\n",
        "    print(\"Accuracy is \",accuracy_score(y_test, y_pred))\n",
        "    plot_confusion_matrix(best_clf, all_X_test[best_clf_vocab], y_test)\n",
        "    plt.show()\n",
        "    print(classification_report(y_test, y_pred, target_names=['0','1']))\n",
        "\n",
        "\n",
        "    least_clf_vocab = min(auc, key=auc.get)\n",
        "    least_clf = all_clf[least_clf_vocab]\n",
        "    print(\"The least performing classifier is\" ,all_clf_names[least_clf_vocab],\" on the\",least_clf_vocab,\"vocabulary\")\n",
        "    y_pred = least_clf.predict(all_X_test[least_clf_vocab])\n",
        "    print(\"Accuracy is \",accuracy_score(y_test, y_pred))\n",
        "    plot_confusion_matrix(least_clf, all_X_test[least_clf_vocab], y_test)\n",
        "    plt.show()\n",
        "    print(classification_report(y_test, y_pred, target_names=['0','1']))\n",
        "\n",
        "    save_model = \"best_model_\" + all_clf_names[best_clf_vocab]+\".sav\"\n",
        "    pickle.dump(best_clf, open(save_model, 'wb'))\n",
        "    print(\"Best model is saved to the disk as \",save_model)\n",
        "\n",
        "    if best_clf_vocab == \"mean_w2v\" or best_clf_vocab == \"tfidf_w2v\":\n",
        "        model.save(\"word2vec.model\")\n",
        "        print(\"The best clf vocabulary is saved as word2vec.model\")\n",
        "    else:\n",
        "        print(\"The pre-trained w2v model is already on the disk.\")\n",
        "    \n",
        "    return best_clf_vocab,save_model"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "LvwjhxYSMXdu",
        "scrolled": false,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "e79e3ff8-135a-48ab-8ad2-7beadfff0a6f"
      },
      "source": [
        "vocab_name, clf_name = generate_comparison()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  5%|▌         | 538/10000 [00:00<00:01, 5379.99it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Random (chance) Prediction: AUROC = 0.500\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 10000/10000 [00:01<00:00, 5860.85it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Mean W2V: AUROC = 0.957\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  6%|▋         | 650/10000 [00:00<00:01, 6479.48it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Tfidf W2V: AUROC = 0.956\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 10000/10000 [00:01<00:00, 6030.47it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Pre-Mean W2V: AUROC = 0.940\n",
            "Pre-Tfidf W2V: AUROC = 0.930\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "The best performing classifier is svm  on the  mean_w2v  vocabulary\n",
            "Accuracy is  0.89\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.90      0.88      0.89      4961\n",
            "           1       0.88      0.90      0.89      5039\n",
            "\n",
            "    accuracy                           0.89     10000\n",
            "   macro avg       0.89      0.89      0.89     10000\n",
            "weighted avg       0.89      0.89      0.89     10000\n",
            "\n",
            "The least performing classifier is svm  on the pre_trained_tfidf_w2v vocabulary\n",
            "Accuracy is  0.8501\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.85      0.85      0.85      4961\n",
            "           1       0.85      0.85      0.85      5039\n",
            "\n",
            "    accuracy                           0.85     10000\n",
            "   macro avg       0.85      0.85      0.85     10000\n",
            "weighted avg       0.85      0.85      0.85     10000\n",
            "\n",
            "Best model is saved to the disk as  best_model_svm.sav\n",
            "The best clf vocabulary is saved as word2vec.model\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "1NshCHnnMXdw"
      },
      "source": [
        "#### Testing sentiment with random movie review\n",
        "\n",
        "Type any random review and test\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HEHKvgWl6Buq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "clf = pickle.load(open(clf_name, 'rb'))\n",
        "\n",
        "if vocab_name == \"mean_w2v\" or vocab_name == \"pre_trained_mean_w2v\":\n",
        "    if vocab_name == \"mean_w2v\":\n",
        "        vocab = Word2Vec.load(\"word2vec.model\")\n",
        "        w2v_mean =MeanEmbeddingVectorizer(vocab,pre_trained=False)\n",
        "\n",
        "    else:\n",
        "        pre_trained_model = KeyedVectors.load_word2vec_format(\"GoogleNews-vectors-negative300.bin\",binary=True)   \n",
        "        w2v_mean = MeanEmbeddingVectorizer(pre_trained_model,pre_trained=True)\n",
        "\n",
        "elif vocab_name == \"tfidf_w2v\" or vocab_name == \"pre_trained_tfidf_w2v\":\n",
        "    if vocab_name == \"tfidf_w2v\":\n",
        "        vocab = Word2Vec.load(\"word2vec.model\")\n",
        "        w2v_tfid = TfidfEmbeddingVectorizer(vocab,pre_trained=False)\n",
        "    else:\n",
        "        pre_trained_model = KeyedVectors.load_word2vec_format(\"GoogleNews-vectors-negative300.bin\",binary=True)   \n",
        "        w2v_tfid = TfidfEmbeddingVectorizer(pre_trained_model,pre_trained=True)\n",
        "\n",
        "else:\n",
        "    print(\"Invalid Input\")\n",
        "        \n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QUa6_oel6But",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def get_rl_test_pred(processed_sentence):\n",
        "    if vocab_name == \"mean_w2v\" or vocab_name == \"pre_trained_mean_w2v\":\n",
        "        rl_test_x = []\n",
        "        rl_test_x.append(gensim.utils.simple_preprocess(processed_sentence))\n",
        "\n",
        "\n",
        "        rl_test_x = w2v_mean.transform(rl_test_x)\n",
        "        y_pred = clf.predict(rl_test_x)\n",
        "\n",
        "    elif vocab_name == \"tfidf_w2v\" or vocab_name == \"pre_trained_tfidf_w2v\":\n",
        "\n",
        "        rl_test_x = gensim.utils.simple_preprocess(processed_sentence)\n",
        "        w2v_tfid.fit([rl_test_x])\n",
        "        rl_test_x = w2v_tfid.transform([rl_test_x])\n",
        "        y_pred = clf.predict(rl_test_x)\n",
        "\n",
        "\n",
        "    else:\n",
        "        print(\"Invalid Input\")\n",
        "\n",
        "\n",
        "    if y_pred == 1:\n",
        "        print(\"It is a Positive Sentiment\")\n",
        "\n",
        "    if y_pred == 0:\n",
        "        print(\"It is a Negative Sentiment\")\n",
        "        \n",
        "    return"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Btk4logq6Buu",
        "colab_type": "code",
        "colab": {},
        "outputId": "f6cccc90-3ff2-4ca6-a68f-ee7990a66b4f"
      },
      "source": [
        "sentence = \"I love the Iron Man movie\"\n",
        "processed_sentence = pre_process(sentence)\n",
        "get_rl_test_pred(processed_sentence)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "It is a Positive Sentiment\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rrIXFTtu6Buv",
        "colab_type": "code",
        "colab": {},
        "outputId": "07853f0e-d0ec-4fce-ca84-a9a1f27aaa1e"
      },
      "source": [
        "sentence = \"This movie is one of the awful movie ever!!!\"\n",
        "processed_sentence = pre_process(sentence)\n",
        "get_rl_test_pred(processed_sentence)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "It is a Negative Sentiment\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "hs4NNjrjMXdy"
      },
      "source": [
        "#### Conclusion"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RQR6VeU96Bux",
        "colab_type": "text"
      },
      "source": [
        "The SVM classifier performed best on the word embeddings trained using Word2Vec on IMDB dataset using Mean scoring and there is no much difference w.r.t the scoring compared to TF-IDF. And as we can see in the ROC plot, that the AUROC for model trained on word embeddings with mean scoring is greater compared to other models.\n",
        "\n",
        "The model was trained with f1 scoring as a performance measure by giving equal importance to both the classes. Hence the obtained f1 score for both the classes is 0.89 and accuracy is also 0.89.\n",
        "\n",
        "Bag of words(BOW)  approach can also be used in generating the vocabulary, but the size of vocabulary and time for training grows larger when the dataset is large and also when using n-grams method with n > 1. We can use TF-IDF scoring for feature extraction with BOW approach, but using this method with BOW results in sparse values for large number of features. So, using word embeddings is good option.\n",
        "\n",
        "\n",
        "The performance of the model can be increased a bit more with proper hyper parameter tuning and also using word embeddings with deep learning approach will yield a good performing model.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "kCy524kRMXdy",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AssTJILC6Buz",
        "colab_type": "text"
      },
      "source": [
        " **The model trained using this dataset is deployed in a web app, which is developed using flask. \n",
        " Check out the sentiment analysis web app [here.](https://analyze-sentiments.herokuapp.com)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Jc4zU-cRMXdz"
      },
      "source": [
        "#### References and Acknowledgements (**A Big Thank You** )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ms4ZpnUSMXdz"
      },
      "source": [
        "* [IMDB Dataset of 50K Movie Reviews](https://www.kaggle.com/lakshmi25npathi/imdb-dataset-of-50k-movie-reviews)\n",
        "\n",
        "* [A General Approach to Preprocessing Text Data](https://www.kdnuggets.com/2017/12/general-approach-preprocessing-text-data.html)\n",
        "\n",
        "* [NLP Text Preprocessing: A Practical Guide and Template](https://towardsdatascience.com/nlp-text-preprocessing-a-practical-guide-and-template-d80874676e79)\n",
        "\n",
        "* [Text Wrangling & Pre-processing: A Practitioner’s Guide to NLP](https://www.kdnuggets.com/2018/08/practitioners-guide-processing-understanding-text-2.html)\n",
        "\n",
        "* [Text Classification with Python and Scikit-Learn](https://stackabuse.com/text-classification-with-python-and-scikit-learn/)\n",
        "\n",
        "* [Lemmatization Approaches with Examples in Python](https://www.machinelearningplus.com/nlp/lemmatization-examples-python/)\n",
        "\n",
        "* [Building a wordcloud using a TD-IDF vectorizer on twitter data](https://hampao.wordpress.com/2016/04/08/building-a-wordcloud-using-a-td-idf-vectorizer-on-twitter-data/)\n",
        "\n",
        "* [How to list the most common words from text corpus using Scikit-Learn?](https://medium.com/@cristhianboujon/how-to-list-the-most-common-words-from-text-corpus-using-scikit-learn-dad4d0cab41d)\n",
        "\n",
        "* [A Gentle Introduction to the Bag-of-Words Model](https://machinelearningmastery.com/gentle-introduction-bag-words-model/)\n",
        "\n",
        "* [What Are Word Embeddings for Text?](https://machinelearningmastery.com/what-are-word-embeddings/)\n",
        "\n",
        "* [How to Develop Word Embeddings in Python with Gensim](https://machinelearningmastery.com/develop-word-embeddings-python-gensim/)\n",
        "\n",
        "* [Text Classification With Word2Vec](http://nadbordrozd.github.io/blog/2016/05/20/text-classification-with-word2vec/)\n",
        "\n",
        "* [Gensim Word2Vec Tutorial – Full Working Example](https://kavita-ganesan.com/gensim-word2vec-tutorial-starter-code/#.XuvyOi-w3OR)\n",
        "\n",
        "* [Word2Vec with Gensim - Python](https://www.youtube.com/watch?v=Z1VsHYcNXDI&t=362s)\n",
        "\n",
        "* [Machine Learning in Python: Making Receiver Operating Characteristic (ROC) curve](https://github.com/dataprofessor/code/blob/master/python/ROC_curve.ipynb)\n",
        "\n",
        "* [How to Use ROC Curves and Precision-Recall Curves for Classification in Python](https://machinelearningmastery.com/roc-curves-and-precision-recall-curves-for-classification-in-python/)\n",
        "\n",
        "* [Finding best model and hyper parameter tunning using GridSearchCV](https://github.com/codebasics/py/blob/master/ML/15_gridsearch/15_grid_search.ipynb)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aCdKX8t28Rhy",
        "colab_type": "text"
      },
      "source": [
        "There is always a room for improvements and any constructive criticism is much appreciated."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zqC3jmQ86Bu2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}