Comparison_Analysis_of_embeddings.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/nisharathod231/Using-word2vec-developed-by-Google-to-analyze-the-quality-of-the-embedding/blob/main/Comparison_Analysis_of_embeddings.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ao135bI9-Ol7"
      },
      "source": [
        "##  Using word2vec developed by Google is to analyze the quality of the embedding\n",
        "**DS: 207 Introduction to Natural Language Processing**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CEUxphOV-Z3l"
      },
      "source": [
        "## Part I Text Classification"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9f1yKrJtFOPs"
      },
      "source": [
        "**Dataset**:\n",
        "The dataset consists of sentences with two different kinds of sentiments- `positive`, and `negative` sentiments. Following are a set of examples,\n",
        "\n",
        "* **`positive`**: *I really like your new haircut!*\n",
        "* **`negative`**: *Your new haircut is awful!*\n",
        "\n",
        "The Dataset has a training set (`train_data.csv`), a validation set (`val_data.csv`) and a blind test set (`test_data.csv`- not provided). The notebook uses a `test_data.csv` file, but it is just a duplicate of `val_data.csv`, and the blind `test_data.csv` will replace it for testing.\n",
        "\n",
        "**Important**: Fix seed as 42 whenever performing any randomized operations, e.g., initializing ML models.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IHepxF62-g8R"
      },
      "source": [
        "### Download the dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gQbwiU59hL1f",
        "outputId": "96a3eff7-1a9b-4ad1-b9e5-a7f32bbf0aba"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-02-05 11:56:25--  https://docs.google.com/spreadsheets/d/176-KrOP8nhLpoW91UnrOY9oq_-I0XYNKS1zmqIErFsA/gviz/tq?tqx=out:csv&sheet=train_data.csv\n",
            "Resolving docs.google.com (docs.google.com)... 74.125.130.138, 74.125.130.139, 74.125.130.100, ...\n",
            "Connecting to docs.google.com (docs.google.com)|74.125.130.138|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: unspecified [text/csv]\n",
            "Saving to: ‘train_data.csv’\n",
            "\n",
            "train_data.csv          [         <=>        ]  15.12M  8.76MB/s    in 1.7s    \n",
            "\n",
            "2024-02-05 11:56:28 (8.76 MB/s) - ‘train_data.csv’ saved [15851033]\n",
            "\n",
            "--2024-02-05 11:56:28--  https://docs.google.com/spreadsheets/d/1YxjoAbatow3F5lbPEODToa8-YWvJoTY0aABS9zaXk-c/gviz/tq?tqx=out:csv&sheet=val_data.csv\n",
            "Resolving docs.google.com (docs.google.com)... 74.125.130.138, 74.125.130.139, 74.125.130.100, ...\n",
            "Connecting to docs.google.com (docs.google.com)|74.125.130.138|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: unspecified [text/csv]\n",
            "Saving to: ‘val_data.csv’\n",
            "\n",
            "val_data.csv            [      <=>           ]   5.14M  4.21MB/s    in 1.2s    \n",
            "\n",
            "2024-02-05 11:56:30 (4.21 MB/s) - ‘val_data.csv’ saved [5387545]\n",
            "\n",
            "--2024-02-05 11:56:30--  https://docs.google.com/spreadsheets/d/1YxjoAbatow3F5lbPEODToa8-YWvJoTY0aABS9zaXk-c/gviz/tq?tqx=out:csv&sheet=val_data.csv\n",
            "Resolving docs.google.com (docs.google.com)... 74.125.130.138, 74.125.130.139, 74.125.130.100, ...\n",
            "Connecting to docs.google.com (docs.google.com)|74.125.130.138|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: unspecified [text/csv]\n",
            "Saving to: ‘test_data.csv’\n",
            "\n",
            "test_data.csv           [      <=>           ]   5.14M  4.33MB/s    in 1.2s    \n",
            "\n",
            "2024-02-05 11:56:32 (4.33 MB/s) - ‘test_data.csv’ saved [5387545]\n",
            "\n"
          ]
        }
      ],
      "source": [
        ",# download train data\n",
        "!wget -O train_data.csv \"https://docs.google.com/spreadsheets/d/176-KrOP8nhLpoW91UnrOY9oq_-I0XYNKS1zmqIErFsA/gviz/tq?tqx=out:csv&sheet=train_data.csv\"\n",
        "\n",
        "# download validation data\n",
        "!wget -O val_data.csv \"https://docs.google.com/spreadsheets/d/1YxjoAbatow3F5lbPEODToa8-YWvJoTY0aABS9zaXk-c/gviz/tq?tqx=out:csv&sheet=val_data.csv\"\n",
        "\n",
        "# download test data\n",
        "!wget -O test_data.csv \"https://docs.google.com/spreadsheets/d/1YxjoAbatow3F5lbPEODToa8-YWvJoTY0aABS9zaXk-c/gviz/tq?tqx=out:csv&sheet=val_data.csv\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 547
        },
        "id": "aSFZVfsahjYe",
        "outputId": "9ab06c7f-c0cc-4db8-813b-a4c2d2681445"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                                              review sentiment\n",
              "0  I've watched this documentary twice - and alth...  positive\n",
              "1  This is probably the worst movie I've seen in ...  negative\n",
              "2  Superb story of a dedicated young teacher who ...  positive\n",
              "3  <br /><br />Spoilers<br /><br />I'm going to b...  negative\n",
              "4  What can be said, really... \"The Tenant\" is a ...  positive"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-f981d613-8948-4774-b403-67e9dd047f12\" class=\"colab-df-container\">\n",
              "    <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>I've watched this documentary twice - and alth...</td>\n",
              "      <td>positive</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>This is probably the worst movie I've seen in ...</td>\n",
              "      <td>negative</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>Superb story of a dedicated young teacher who ...</td>\n",
              "      <td>positive</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>&lt;br /&gt;&lt;br /&gt;Spoilers&lt;br /&gt;&lt;br /&gt;I'm going to b...</td>\n",
              "      <td>negative</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>What can be said, really... \"The Tenant\" is a ...</td>\n",
              "      <td>positive</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-f981d613-8948-4774-b403-67e9dd047f12')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-f981d613-8948-4774-b403-67e9dd047f12 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-f981d613-8948-4774-b403-67e9dd047f12');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-e27926d1-d8ef-4c9d-9a72-aa635a14e15f\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-e27926d1-d8ef-4c9d-9a72-aa635a14e15f')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-e27926d1-d8ef-4c9d-9a72-aa635a14e15f button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "#@title Read data\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "df = pd.read_csv('train_data.csv')\n",
        "df_val = pd.read_csv('val_data.csv')\n",
        "\n",
        "df_test = pd.read_csv('test_data.csv')\n",
        "\n",
        "df.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8Q5bFnoUhlMw"
      },
      "outputs": [],
      "source": [
        "#@title Prepare training, validation and test data.\n",
        "\n",
        "X_train, y_train = df.review.values.tolist(), df.sentiment.values.tolist()\n",
        "X_val, y_val = df_val.review.values.tolist(), df_val.sentiment.values.tolist()\n",
        "X_test, y_test = df_test.review.values.tolist(), df_test.sentiment.values.tolist()\n",
        "\n",
        "labels = ['negative', 'positive']\n",
        "\n",
        "# converting the sentiment labels into labels\n",
        "# class 0 for negagtive, and class 1 for positive\n",
        "y_train = [labels.index(i) for i in y_train]\n",
        "y_val = [labels.index(i) for i in y_val]\n",
        "y_test = [labels.index(i) for i in y_test]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fbph_MYA-ttn"
      },
      "source": [
        "#### Approach 1: Rule based classification\n",
        "\n",
        "The rule-based classification works using a few hand-crafted rules. In sentiment classification, few words are associated with positive sentiment and few others with negative sentiment. Let's attempt to build a classifier that predicts the sentiment of the reviews based on such words."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T2Fw8vUL-xm0"
      },
      "source": [
        "Let's first write a few rules to extract important features about the input movie review. As an example, we provide a function that counts the number of `good` and `bad` words in the input.\n",
        "\n",
        "Below, you can see a sample rule-based classification system. Later, you will be building one yourself."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xOlu1Hd4huMU"
      },
      "outputs": [],
      "source": [
        "def sample_extract_features(X):\n",
        "    \"\"\"\n",
        "    Extracts features from a text input.\n",
        "\n",
        "    Args:\n",
        "        X (string): Text input.\n",
        "\n",
        "    Returns:\n",
        "        dictionary: features extracted from X.\n",
        "    \"\"\"\n",
        "\n",
        "    features = {}\n",
        "    X_split = X.split(' ')\n",
        "\n",
        "    # Count the number of \"good words\" and \"bad words\" in the text\n",
        "    good_words = ['love', 'good', 'brilliant', 'fantastic', 'amazing', 'great']\n",
        "    bad_words = ['hate', 'bad', 'horrible', 'awful', 'terrible', 'mess', 'frustating', 'frustatingly']\n",
        "\n",
        "    features['good_word_count'], features['bad_word_count'] = 0, 0\n",
        "    for x in X_split:\n",
        "        if x in good_words:\n",
        "            features['good_word_count'] = features.get('good_word_count', 0) + 1\n",
        "        if x in bad_words:\n",
        "            features['bad_word_count'] = features.get('bad_word_count', 0) + 1\n",
        "\n",
        "    # The \"bias\" value can be set to one, to allow us to assign a \"default\" score to the text\n",
        "    features['bias'] = 1\n",
        "    return features"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1N_hpoYGh7P-"
      },
      "outputs": [],
      "source": [
        "def sample_predict(X, feature_weights):\n",
        "    \"\"\"\n",
        "    Classifies the sentiment of a text input.\n",
        "\n",
        "    Args:\n",
        "        X (string): Text input.\n",
        "        feature_weights: weightage of different features.\n",
        "\n",
        "    Returns:\n",
        "        int: binary sentiment represented by 0/1.\n",
        "    \"\"\"\n",
        "\n",
        "    score = 0\n",
        "\n",
        "    # Here we just multiply the feature value\n",
        "    # with its corresponding weight and aggregate\n",
        "    for feat_name, feat_value in sample_extract_features(X).items():\n",
        "        score = score + feat_value * feature_weights[feat_name]\n",
        "\n",
        "    # the prediction is based on whether the aggregated score is above 0 or not\n",
        "    if score > 0:\n",
        "        return 1\n",
        "    else:\n",
        "        return 0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t12WsNhUiRqp"
      },
      "outputs": [],
      "source": [
        "def get_sample_features_weights():\n",
        "  \"\"\"\n",
        "    To obtain feature weightage for different features.\n",
        "\n",
        "    Args:\n",
        "        None here.\n",
        "\n",
        "    Returns:\n",
        "        dictionary: feature names and their weightage.\n",
        "    \"\"\"\n",
        "  # Based on the selected features, you can manually assign them weights\n",
        "  feature_weights = {'good_word_count': 1.0, 'bad_word_count': -1.0, 'bias': 0.5}\n",
        "  return feature_weights"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PC2qUmjxiRs4"
      },
      "outputs": [],
      "source": [
        "#@title Computing the accuracy of the system\n",
        "\n",
        "def calculate_accuracy(Y_true, Y_pred):\n",
        "    \"\"\"\n",
        "    Calculates accuracy of predictions given the ground truth.\n",
        "\n",
        "    Args:\n",
        "        Y_true (list): Ground truth labels.\n",
        "        Y_pred (list): Predictions.\n",
        "\n",
        "    Returns:\n",
        "        float: Prediction accuracy in range [0.0-100.0].\n",
        "    \"\"\"\n",
        "    correct = 0.0\n",
        "    total = len(Y_true)\n",
        "\n",
        "    # verify if we have the same number of predictions as labels\n",
        "    assert len(Y_true) == len(Y_pred)\n",
        "\n",
        "    # count the number of correct predictions\n",
        "    for y_true, y_pred in zip(Y_true, Y_pred):\n",
        "        if y_true == y_pred:\n",
        "            correct += 1.0\n",
        "\n",
        "    if total > 0:\n",
        "        return 100. * correct / total\n",
        "\n",
        "    # return 0 if there the total number of examples are zero\n",
        "    return 0.0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LXoux3p8idZr",
        "outputId": "bb97859e-9131-430d-a763-d92a77e338da"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "60.5\n"
          ]
        }
      ],
      "source": [
        "#@title Putting the sample rule-based classifier together\n",
        "\n",
        "# get the sample weights\n",
        "sample_feature_weights = get_sample_features_weights()\n",
        "\n",
        "predictions = []\n",
        "\n",
        "# for each test example, make a prediction\n",
        "for input_example in X_test:\n",
        "    y = sample_predict(input_example, sample_feature_weights)\n",
        "    predictions.append(y)\n",
        "\n",
        "# compute and print the accuracy\n",
        "print (calculate_accuracy(y_test, predictions))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1vsgE786_A7Y"
      },
      "source": [
        "As you can observe here, the model achieves about 60% accuracy (note that the performance of a random classifier would be close to 50%)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "F8w1soRgii7d"
      },
      "outputs": [],
      "source": [
        "def extract_features(X):\n",
        "    \"\"\"\n",
        "    Extracts features from a text input.\n",
        "\n",
        "    Args:\n",
        "        X (string): Text input.\n",
        "\n",
        "    Returns:\n",
        "        dictionary: features extracted from X.\n",
        "    \"\"\"\n",
        "    features = {}\n",
        "    features['bias'] = 1\n",
        "\n",
        "    # ADD YOUR CODE HERE\n",
        "    X_split = X.split(' ')\n",
        "    positive_words = ['excellent', 'wonderfully', 'hilarious', 'perfect', 'hooked', 'awesome', 'amazing', 'loved', 'tight', 'enjoyed', 'rare', 'subtitles', 'subtle', 'freedom', 'winner', 'brutal', 'system', 'refreshing', 'edge', 'terrific']\n",
        "    negative_words = ['waste', 'worst', 'awful', 'dull', 'poor', 'poorly', 'stupid', 'terrible', 'mediocre', 'disappointing', 'lacks', 'boring', 'lousy', 'fails', 'Avoid', 'tedious', 'bland', 'garbage', 'screaming', 'worse']\n",
        "\n",
        "    # please extract features that you think would be useful.\n",
        "\n",
        "    features['positive_word_count'] = sum(1 for word in X_split if word in positive_words)\n",
        "    features['negative_word_count'] = sum(1 for word in X_split if word in negative_words)\n",
        "\n",
        "\n",
        "    return features\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "CSWwAqP1sISc"
      },
      "outputs": [],
      "source": [
        "def get_feature_weights():\n",
        "    \"\"\"\n",
        "    To obtain feature weightage for different features.\n",
        "\n",
        "    Args:\n",
        "        None here.\n",
        "\n",
        "    Returns:\n",
        "        dictionary: feature names and their weightage.\n",
        "    \"\"\"\n",
        "\n",
        "    feature_weights = {}\n",
        "    feature_weights['bias'] = 0.5\n",
        "\n",
        "    # please manually assign feature weights to the features you've extracted\n",
        "    feature_weights['positive_word_count'] = 0.8\n",
        "    feature_weights['negative_word_count'] = -0.8\n",
        "\n",
        "    return feature_weights\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "VCK1MB0JtWVQ"
      },
      "outputs": [],
      "source": [
        "def predict(X, feature_weights):\n",
        "    \"\"\"\n",
        "    Classifies the sentiment of a text input.\n",
        "\n",
        "    Args:\n",
        "        X (string): Text input.\n",
        "        feature_weights: weightage of different features.\n",
        "\n",
        "    Returns:\n",
        "        int: binary sentiment represented by 0/1.\n",
        "    \"\"\"\n",
        "\n",
        "    # ADD YOUR CODE HERE\n",
        "    features = extract_features(X)\n",
        "    weighted_sum = sum(feature_weights[feature] * features[feature] for feature in features)\n",
        "\n",
        "    threshold = 0.2\n",
        "    predicted_sentiment = 1 if weighted_sum > threshold else 0\n",
        "    return predicted_sentiment"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "Ja11MgENt1X7",
        "outputId": "73796540-eba4-4db1-9bc4-2a7116469cee"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "EVALUATION of rule-based classifier is: 70.425\n"
          ]
        }
      ],
      "source": [
        "#@title Evaluating your rule-based classifier\n",
        "\n",
        "## Please do not change anything in this code block.\n",
        "\n",
        "feature_weights = get_feature_weights()\n",
        "\n",
        "predictions = []\n",
        "\n",
        "for input_example in X_test:\n",
        "    y = predict(input_example, feature_weights)\n",
        "    predictions.append(y)\n",
        "\n",
        "print (f\"EVALUATION of rule-based classifier is: {calculate_accuracy(y_test, predictions)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D5ezKoxrAtmw"
      },
      "source": [
        "Below, we will directly learn the feature weights, rather than manually assigning those ourselves as manual assignment can be error-prone and labor intensive.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "FPS-uzfGCpmW"
      },
      "outputs": [],
      "source": [
        "#@title Learning the weights of extracted features using logistic regression.\n",
        "\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "def get_sample_learnable_weights(X_data, Y_data, sample_extract_features):\n",
        "    \"\"\"\n",
        "    Learn feature weights using the training data.\n",
        "\n",
        "    Args:\n",
        "        X_data (list of strings): All the text data points in training data.\n",
        "        Y_data (list of int): Ground truth labels for text data points in X_data.\n",
        "        sample_extract_features: A Function that extracts features from text sample.\n",
        "                                 The sample_extract_features function should be of the\n",
        "                                 same format as sample_extract_features(X) function\n",
        "                                 implemented above.\n",
        "\n",
        "        Returns:\n",
        "            dictionary: feature names and their learned weights.\n",
        "    \"\"\"\n",
        "    # training a logistic regression model for classification using\n",
        "    # the features obtained by sample_extract_features(X) function.\n",
        "\n",
        "    # get all feature names\n",
        "    feature_names = list(sample_extract_features(X_data[0]).keys())\n",
        "\n",
        "    # Below code snippet accumulates features extracted from all the\n",
        "    # text data points in X_data.\n",
        "    all_features = []\n",
        "    # iterate over all text data points in X_data.\n",
        "    for input_example in X_data:\n",
        "      feature = [] # to store features extracted from input_example.\n",
        "      feat_dict = sample_extract_features(input_example)\n",
        "      # iterate over different feature names and store the corresonding values.\n",
        "      for name in feature_names:\n",
        "        feature.append(feat_dict[name])\n",
        "      all_features.append(feature) # append features obtained from input_example to all_features.\n",
        "\n",
        "    # Below, we show how to fit a logistic regression (LR) model using the features and the target labels.\n",
        "    # We use Sklearn's 'LogisticRegression' to do this. While initiating, 'fit_intercept' is set False,\n",
        "    # because 'bias' is already included in the extracted feature (see sample_extract_features() implementation).\n",
        "    # Also, random state is set to 42 to avoid different initialization of the model while running the codebook\n",
        "    # multiple times.\n",
        "    clf = LogisticRegression(fit_intercept=False, random_state=42).fit(all_features, Y_data)\n",
        "\n",
        "    # As training a logistic regression model assigns weights to each of the features (refer class notes),\n",
        "    # these weights are learnable and we will use them as learned feature weights.\n",
        "\n",
        "    # extract feature weights.\n",
        "    coffs = clf.coef_[0]\n",
        "\n",
        "    # convert to dictionary\n",
        "    coffs_dict = {feature_names[i]: coffs[i] for i in range(len(feature_names))}\n",
        "\n",
        "    return coffs_dict"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "vYhYCIHrCtBA",
        "outputId": "bed79ce0-4a6e-4d8f-defd-02b268687355"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "63.775\n"
          ]
        }
      ],
      "source": [
        "#@title Putting the sample rule-based classifier with learnable weights together\n",
        "\n",
        "# get the sample weights\n",
        "sample_feature_weights_lr = get_sample_learnable_weights(X_train, y_train, sample_extract_features)\n",
        "\n",
        "predictions = []\n",
        "\n",
        "for input_example in X_test:\n",
        "    y = sample_predict(input_example, sample_feature_weights_lr)\n",
        "    predictions.append(y)\n",
        "\n",
        "print (calculate_accuracy(y_test, predictions))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TtL_r40MCxxp"
      },
      "source": [
        "As you can observe here, the model achieves about 63% accuracy (note that the performance of a random classifier would be close to 50%). Note that, the performance significantly improves by making the weights learnable as compared to the manual weights."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jivlIOvyDczl"
      },
      "source": [
        "## How does learnable weights-based classifier work on the features you implemented\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "z-zlKnduEB98",
        "outputId": "b194f933-5650-41fb-e4c9-e7fd515ebf14"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "EVALUATION of rule-based classifier with learnable weights is: 70.975\n"
          ]
        }
      ],
      "source": [
        "#@title Evaluating rule-based classifier with learnable weights.\n",
        "\n",
        "feature_weights_lr = get_sample_learnable_weights(X_train, y_train, extract_features)\n",
        "\n",
        "predictions = []\n",
        "\n",
        "for input_example in X_test:\n",
        "    y = predict(input_example, feature_weights_lr)\n",
        "    predictions.append(y)\n",
        "\n",
        "print (f\"EVALUATION of rule-based classifier with learnable weights is: {calculate_accuracy(y_test, predictions)}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "UyQXo76zTt1N",
        "outputId": "50327ef0-136d-4676-b645-a06224444863"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Add some text for labels, title, and custom x-axis tick labels, etc.\n",
        "#@title Visualization and comparison between manual and learnable weights.\n",
        "\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "feature_names = list(feature_weights.keys())\n",
        "manual_weights = [feature_weights[name] for name in feature_names]\n",
        "learnt_weights = [feature_weights_lr[name] for name in feature_names]\n",
        "weights_dict = {\n",
        "    'Manual weights': manual_weights,\n",
        "    'Learnt weights': learnt_weights,\n",
        "}\n",
        "\n",
        "x = np.arange(len(feature_names))  # the label locations\n",
        "width = 0.35  # the width of the bars\n",
        "multiplier = 0\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(10, 6), subplot_kw={'aspect': 'auto'})\n",
        "\n",
        "colors = ['#1f77b4', '#ff7f0e']\n",
        "\n",
        "for attribute, measurement, color in zip(weights_dict.keys(), weights_dict.values(), colors):\n",
        "    offset = width * multiplier\n",
        "    rects = ax.bar(x + offset, measurement, width, label=attribute, color=color, alpha=0.8)\n",
        "    ax.bar_label(rects, padding=3, fontsize=10, color='black')\n",
        "    multiplier += 1\n",
        "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
        "ax.set_ylabel('Weight', fontsize=12)\n",
        "ax.set_title('Manual vs Learnable Weights Comparison', fontsize=14)\n",
        "ax.set_xticks(x + width / 2)\n",
        "ax.set_xticklabels(feature_names, rotation=45, ha='right', fontsize=10)\n",
        "ax.legend(loc='upper left', bbox_to_anchor=(1, 1), fontsize=12)\n",
        "\n",
        "ax.grid(axis='y', linestyle='--', alpha=0.7)\n",
        "\n",
        "ax.axhline(0, color='black', linewidth=0.8, linestyle='--')\n",
        "ax.axhline(1, color='red', linewidth=0.8, linestyle='--', label='Threshold = 1')\n",
        "ax.axhline(-1, color='blue', linewidth=0.8, linestyle='--', label='Threshold = -1')\n",
        "plt.tight_layout()\n",
        "plt.savefig('manual_vs_learned_weights.png', bbox_inches='tight', dpi=300)\n",
        "plt.show()\n",
        "# Refer to the saved manual_vs_learned_weights.png to see how manual and learned weights compare."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NFy5JND8rzDM"
      },
      "source": [
        "### Approach 2: Bag-of-Words (BoW)\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "The BoW vector representations is based on the unordered counts of words piece of text (similar to a \"bag\" of words).\n",
        "\n",
        "Let's attempt to build a classifier that tries to classify the reviews based on such vectors."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "sZvnFl7MUW-v"
      },
      "outputs": [],
      "source": [
        "# implement BoW classifier. In case the total number of words are very large,\n",
        "# consider using top-k most frequent words (e.g. k=10,000) while creating BoW vectors.\n",
        "\n",
        "# The below function finds out all words present in the corpus and assigns each word to\n",
        "# an index.\n",
        "\n",
        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
        "from sklearn.feature_extraction.text import ENGLISH_STOP_WORDS\n",
        "from collections import Counter\n",
        "\n",
        "def word_to_idx_BOW(X_data, K=10000):\n",
        "    \"\"\"\n",
        "    Generates a set of word-index pairs after analyzing all words present in entire\n",
        "    data corpus X_data.\n",
        "\n",
        "    Args:\n",
        "        X_data (list of strings): All the text data points in training data.\n",
        "        K (int): The number of most frequent words to be considered.\n",
        "                 In case (K-p)th to (K+q)th words in most frequent words order\n",
        "                 have the same frequency, you can choose p words randomly from those\n",
        "                 (p+q) number of words.\n",
        "\n",
        "        Returns:\n",
        "            dictionary: words as keys and indices as values.\n",
        "    \"\"\"\n",
        "    all_text = ' '.join(X_data)\n",
        "    words = all_text.split()\n",
        "    word_freq = Counter(words)\n",
        "    top_words = [word for word, _ in word_freq.most_common(K)]\n",
        "    word_to_idx = {word: idx for idx, word in enumerate(top_words)}\n",
        "    return word_to_idx\n",
        "\n",
        "stop_words_list = list(ENGLISH_STOP_WORDS)\n",
        "tfidf_vectorizer = TfidfVectorizer(stop_words=stop_words_list, max_features=10000)\n",
        "tfidf_matrix = tfidf_vectorizer.fit_transform(X_train)\n",
        "feature_names = tfidf_vectorizer.get_feature_names_out()\n",
        "idf_values = tfidf_vectorizer.idf_\n",
        "word_to_idf = dict(zip(feature_names, idf_values))\n",
        "\n",
        "def extract_features_BoW(X, word_to_idx):\n",
        "    \"\"\"\n",
        "    Generates BoW-TFIDF features for X using word_to_idx.\n",
        "\n",
        "    Args:\n",
        "        X (string): text input.\n",
        "        word_to_idx (dictionary): word-index mapping with words as keys and\n",
        "                                  indices as values.\n",
        "\n",
        "        Returns:\n",
        "            dictionary: features of X.\n",
        "    \"\"\"\n",
        "    features = {}\n",
        "\n",
        "    words = X.split()\n",
        "\n",
        "    word_counts = Counter(words)\n",
        "\n",
        "    for word, count in word_counts.items():\n",
        "        if word in word_to_idx and word in word_to_idf:\n",
        "            tfidf_value = count * word_to_idf[word]\n",
        "            features[word_to_idx[word]] = tfidf_value\n",
        "\n",
        "    return features\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "zyVSQx4EaYGJ",
        "outputId": "22990594-e78b-41d0-a0fd-f9da10f2cfaf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{4: 7.827795901169904}\n"
          ]
        }
      ],
      "source": [
        "# checking the outputs of the above functions on a small set of examples\n",
        "\n",
        "sample_data = [\n",
        "    \"When is the homework due ?\",\n",
        "    \"When are the TAs' office hours ?\",\n",
        "    \"How hard is the homework ?\",\n",
        "]\n",
        "word_to_idx = word_to_idx_BOW(sample_data)\n",
        "features = extract_features_BoW(sample_data[0], word_to_idx)\n",
        "print(features)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "J7WZJiMqaftX"
      },
      "outputs": [],
      "source": [
        "#@title Implement  feature weight learning for BoW classifier\n",
        "\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.feature_extraction.text import ENGLISH_STOP_WORDS\n",
        "\n",
        "def get_learnable_weights_BoW(X_data, Y_data, word_to_idx_BOW, extract_features_BoW):\n",
        "    \"\"\"\n",
        "    Learning feature weights for BoW features, using training data.\n",
        "\n",
        "    Args:\n",
        "        X_data (list of strings): All the text data points in training data.\n",
        "        Y_data (list of int): Ground truth labels for text data points in X_data.\n",
        "        word_to_idx_BOW: A Function that looks at all the words in data corpus X_data\n",
        "                         and returns a word-index mapping.\n",
        "        extract_features_BoW: A Function that extracts BoW features from text sample.\n",
        "\n",
        "        Returns:\n",
        "            dictionary: feature names and their learned weights.\n",
        "    \"\"\"\n",
        "\n",
        "    word_to_idx = word_to_idx_BOW(X_data)\n",
        "\n",
        "    all_features = [extract_features_BoW(text, word_to_idx) for text in X_data]\n",
        "\n",
        "    # Convert feature vectors to array\n",
        "    X_array = [[features.get(idx, 0) for idx in range(len(word_to_idx))] for features in all_features]\n",
        "\n",
        "    clf = LogisticRegression(fit_intercept=False, random_state=42, max_iter=1000)\n",
        "\n",
        "    clf.fit(X_array, Y_data)\n",
        "\n",
        "    weights = clf.coef_[0]\n",
        "\n",
        "    coffs_dict = {word: weights[idx] for word, idx in word_to_idx.items()}\n",
        "\n",
        "    return coffs_dict\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "e0uezBgIa_7E",
        "outputId": "a9ee8cad-761f-45f5-af53-0faa6f45aa3a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "EVALUATION of BoW classifier is: 80.675\n"
          ]
        }
      ],
      "source": [
        "#@title Evaluating  BoW classifier\n",
        "\n",
        "from collections import Counter\n",
        "\n",
        "def predict(X, feature_weights):\n",
        "    \"\"\"\n",
        "    Classifies the sentiment of a text input.\n",
        "\n",
        "    Args:\n",
        "        X (string): Text input.\n",
        "        feature_weights: weightage of different features.\n",
        "\n",
        "    Returns:\n",
        "        int: binary sentiment represented by 0/1.\n",
        "    \"\"\"\n",
        "    words = X.split()\n",
        "\n",
        "    word_counts = Counter(words)\n",
        "\n",
        "    sentiment_score = 0.0\n",
        "\n",
        "    for word, count in word_counts.items():\n",
        "        if word in feature_weights:\n",
        "            sentiment_score += count * feature_weights[word]\n",
        "\n",
        "    threshold = 0.0\n",
        "    predicted_sentiment = 1 if sentiment_score > threshold else 0\n",
        "\n",
        "    return predicted_sentiment\n",
        "\n",
        "BoW_feature_weights_lr = get_learnable_weights_BoW(X_train, y_train, word_to_idx_BOW, extract_features_BoW)\n",
        "\n",
        "predictions = []\n",
        "\n",
        "for input_example in X_test:\n",
        "    y = predict(input_example, BoW_feature_weights_lr)\n",
        "    predictions.append(y)\n",
        "\n",
        "print(f\"EVALUATION of BoW classifier is: {calculate_accuracy(y_test, predictions)}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F_4mWuCdHEue"
      },
      "source": [
        "## Finding most positive and most negative words (2 Marks)\n",
        "\n",
        "Based on the magnitude of weights corresponding to different words, write down code to find the 5 most positive words and 5 most negative words."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D4XKTpjPxdQZ"
      },
      "source": [
        "###Most Positive & Negative Words"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "dMsgQzJ_psDO",
        "outputId": "c5e0cd51-a402-45e8-a403-1d9bdaf40392"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "EVALUATION five most positive words: wonderfully extraordinary astonishing pursued flawless\n",
            "EVALUATION five most negative words: waste wasting worst agenda considerably\n"
          ]
        }
      ],
      "source": [
        "most_positive_words = sorted(BoW_feature_weights_lr, key=BoW_feature_weights_lr.get, reverse=True)[:5]\n",
        "most_negative_words = sorted(BoW_feature_weights_lr, key=BoW_feature_weights_lr.get)[:5]\n",
        "\n",
        "## WRITE CODE HERE TO POPULATE THESE LISTS\n",
        "## most_postive_words and most_negative_words should be list of strings\n",
        "\n",
        "print(\"EVALUATION five most positive words: \" + \" \".join(most_positive_words))\n",
        "print(\"EVALUATION five most negative words: \" + \" \".join(most_negative_words))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BjF-QNhRH4IM"
      },
      "source": [
        "## Part II Word2Vec\n",
        "\n",
        "Word2vec is one of the most popular techniques to learn word embeddings. The idea behind word2vec was that the meaning of a word is determined by the context in which it occurs. A word embedding is a learned representation for text where words that have the same meaning have a similar representation.\n",
        "\n",
        "**Word2vec** model has 2 architectures:\n",
        "\n",
        "1. **Continuous bag of word (CBOW):**\n",
        "\n",
        "    CBOW predicts the center word from the surrounding context words.\n",
        "\n",
        "2. **Skip-gram:**\n",
        "\n",
        "    Skip-gram predicts surrounding context words from the center word."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sxZ6Q_zJH9K7"
      },
      "source": [
        "#### SkipGram from Scratch\n",
        "\n",
        "In this exercise, you will code the skipgram model from scratch using the PyTorch library."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uZby7iwVt5IC",
        "outputId": "37610c2b-6dee-4806-879c-2638ed0d4bd5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: portalocker in /usr/local/lib/python3.10/dist-packages (2.8.2)\n"
          ]
        }
      ],
      "source": [
        "!pip install portalocker #make sure you install the library and restart the session"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4Cq-Hto9r46E"
      },
      "outputs": [],
      "source": [
        "# importing the necessary libraries\n",
        "import torch\n",
        "from functools import partial\n",
        "import torch.nn as nn\n",
        "from torch.utils.data import DataLoader\n",
        "from torchtext.data import to_map_style_dataset\n",
        "from torchtext.data.utils import get_tokenizer\n",
        "from torchtext.vocab import build_vocab_from_iterator\n",
        "from torchtext.datasets import WikiText2\n",
        "import torch.optim as optim\n",
        "from torch.optim.lr_scheduler import LambdaLR\n",
        "\n",
        "import os\n",
        "import numpy as np\n",
        "import json\n",
        "import argparse"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QBRUC7hZIHr5"
      },
      "source": [
        "> **In the following code the add your hyperparameters for the network.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UzvHDxtQt3SH"
      },
      "outputs": [],
      "source": [
        "# Initialization\n",
        "\n",
        "\n",
        "\"\"\"choose your hyperparameter and see the difference in performance\"\"\"\n",
        "\n",
        "# ADD YOUR CODE HERE\n",
        "\n",
        "# CHANGE THE None VALUES TO YOUR DESIRED VALUES\n",
        "# Please free to play with these hyperparameters to see the effects on the\n",
        "# quality of generated embeddings\n",
        "\n",
        "\n",
        "SKIPGRAM_N_WORDS = 4 # the length of the context on each side (k)\n",
        "MIN_WORD_FREQUENCY = 280 # only words with a minimum word frequency considered\n",
        "MAX_SEQUENCE_LENGTH = 200 # sentences with length more than this value truncated\n",
        "EMBED_DIMENSION = 300 # dimension of the word2vec vectors\n",
        "EMBED_MAX_NORM = 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qSaj2RHmwFph"
      },
      "outputs": [],
      "source": [
        "def get_english_tokenizer():\n",
        "    \"\"\"\n",
        "    Documentation:\n",
        "    https://pytorch.org/text/stable/_modules/torchtext/data/utils.html#get_tokenizer\n",
        "    \"\"\"\n",
        "    tokenizer = get_tokenizer(\"basic_english\", language=\"en\")\n",
        "    return tokenizer\n",
        "\n",
        "def get_data_iterator(ds_name, ds_type, data_dir):\n",
        "    \"\"\"\n",
        "    input dataset used:\n",
        "    https://paperswithcode.com/dataset/wikitext-2\n",
        "    This is directly imported from PyTorch.\n",
        "    \"\"\"\n",
        "    data_iter = WikiText2(root=data_dir, split=(ds_type))\n",
        "    data_iter = to_map_style_dataset(data_iter)\n",
        "    return data_iter\n",
        "\n",
        "def build_vocab(data_iter, tokenizer):\n",
        "    \"\"\"Builds vocabulary from iterator\"\"\"\n",
        "\n",
        "    vocab = build_vocab_from_iterator(\n",
        "        map(tokenizer, data_iter),\n",
        "        specials=[\"<unk>\"], #adding special tokens to the vocabulary\n",
        "        min_freq=MIN_WORD_FREQUENCY,\n",
        "    )\n",
        "    vocab.set_default_index(vocab[\"<unk>\"])\n",
        "    return vocab\n",
        "\n",
        "\n",
        "def collate_skipgram(batch, text_pipeline):\n",
        "    \"\"\"\n",
        "    This function prepares data for training the skipgram model.\n",
        "    It generates pairs of center and context words from the batch of text.\n",
        "\n",
        "    batch: A batch of text data\n",
        "    text_pipeline: A pipeline function that processes text into tokens\n",
        "    (batch_input, batch_output) -> (center word, context words)\n",
        "    \"\"\"\n",
        "    batch_input, batch_output = [], []\n",
        "\n",
        "    # Process each text in the batch\n",
        "    for text in batch:\n",
        "        text_tokens_ids = text_pipeline(text)\n",
        "\n",
        "        # Skip texts shorter than the required window size\n",
        "        if len(text_tokens_ids) < SKIPGRAM_N_WORDS * 2 + 1:\n",
        "            continue\n",
        "\n",
        "        # Truncate texts to a maximum sequence length if specified\n",
        "        if MAX_SEQUENCE_LENGTH:\n",
        "            text_tokens_ids = text_tokens_ids[:MAX_SEQUENCE_LENGTH]\n",
        "\n",
        "        # Create training pairs for each word in the text\n",
        "        for idx in range(len(text_tokens_ids) - SKIPGRAM_N_WORDS * 2):\n",
        "            token_id_sequence = text_tokens_ids[idx : (idx + SKIPGRAM_N_WORDS * 2 + 1)]\n",
        "            input_ = token_id_sequence.pop(SKIPGRAM_N_WORDS)\n",
        "            outputs = token_id_sequence\n",
        "\n",
        "            # Add each context word with the center word to the output lists\n",
        "            for output in outputs:\n",
        "                batch_input.append(input_)\n",
        "                batch_output.append(output)\n",
        "\n",
        "    # Convert lists to PyTorch tensors\n",
        "    batch_input = torch.tensor(batch_input, dtype=torch.long)\n",
        "    batch_output = torch.tensor(batch_output, dtype=torch.long)\n",
        "\n",
        "    return batch_input, batch_output\n",
        "\n",
        "\n",
        "def get_dataloader_and_vocab(\n",
        "    model_name, ds_name, ds_type, data_dir, batch_size, shuffle, vocab=None\n",
        "    ):\n",
        "    \"\"\"\n",
        "    Prepares a DataLoader and builds a vocabulary for the dataset.\n",
        "    model_name: Name of the model to be used\n",
        "    ds_name: Name of the dataset\n",
        "    ds_type: Type of the dataset (e.g., train, test)\n",
        "    data_dir: Directory where the dataset is stored\n",
        "    batch_size: Size of each batch\n",
        "    vocab: An existing vocabulary, if available\n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    data_iter = get_data_iterator(ds_name, ds_type, data_dir)\n",
        "    tokenizer = get_english_tokenizer()\n",
        "\n",
        "    if not vocab:\n",
        "        vocab = build_vocab(data_iter, tokenizer)\n",
        "\n",
        "    text_pipeline = lambda x: vocab(tokenizer(x))\n",
        "\n",
        "    collate_fn = collate_skipgram\n",
        "\n",
        "    # creates a DataLoader for the dataset\n",
        "\n",
        "    \"\"\"\n",
        "    dataloader documentation\n",
        "    https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader\n",
        "\n",
        "    \"\"\"\n",
        "    dataloader = DataLoader(\n",
        "        data_iter,\n",
        "        batch_size=batch_size,\n",
        "        shuffle=shuffle,\n",
        "        collate_fn=partial(collate_fn, text_pipeline=text_pipeline),\n",
        "        )\n",
        "\n",
        "    return dataloader, vocab\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cOry40-uxJmu"
      },
      "source": [
        "### Initialize the SkipGram Model\n",
        "\n",
        " **Complete the `initialization` and `forward` function in the following  SkipGram_Model class**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wxe9U9YNwYk_"
      },
      "outputs": [],
      "source": [
        "class SkipGram_Model(nn.Module):\n",
        "    \"\"\"\n",
        "    Implementation of Skip-Gram model described in paper:\n",
        "    https://arxiv.org/abs/1301.3781\n",
        "    \"\"\"\n",
        "    def __init__(self, vocab_size: int, embed_dimension: int):\n",
        "        super(SkipGram_Model, self).__init__()\n",
        "\n",
        "        \"\"\"define the embedding and the linear layer of the network\"\"\"\n",
        "        # this is the initialization for the layers in the skipgram model\n",
        "\n",
        "        # ADD YOUR CODE HERE\n",
        "        self.embeddings = nn.Embedding(vocab_size, embed_dimension)\n",
        "        self.linear = nn.Linear(embed_dimension, vocab_size)\n",
        "        self.log_softmax = nn.LogSoftmax(dim=1)\n",
        "\n",
        "    def forward(self, inputs_):\n",
        "        \"\"\"define forward function\"\"\"\n",
        "        # ADD YOUR CODE HERE\n",
        "\n",
        "        # return the output of your final layer to find the minimize the loss\n",
        "        embeds = self.embeddings(inputs_)\n",
        "        output = self.linear(embeds)\n",
        "        log_probs = self.log_softmax(output)\n",
        "\n",
        "        return log_probs\n",
        "\n",
        "    def get_word_embedding(self):\n",
        "        \"\"\" return the associated word embeddings for center words \"\"\"\n",
        "\n",
        "        # ADD YOUR CODE HERE\n",
        "\n",
        "        # return the normalized embeddings as a 2D numpy array (in word2vec models,\n",
        "        # the vector associated with the center word is considered\n",
        "        # word embedding)\n",
        "        word_embeddings = self.embeddings.weight.data.numpy()\n",
        "        norm_word_embeddings = word_embeddings / np.linalg.norm(word_embeddings, axis=1, keepdims=True)\n",
        "\n",
        "        return norm_word_embeddings"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wxAJfW0eI-bl"
      },
      "source": [
        "\n",
        "> The following is the Trainer class for the skip-gram model. Add your code for the training and validation loops.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oDPdXiPewrRg"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "\n",
        "class Trainer:\n",
        "    \"\"\"Main class for model training\"\"\"\n",
        "\n",
        "    # NOTE: you are free to add additional inputs/functions\n",
        "    # to the trainer class to make training better\n",
        "    # make sure to define and add it within the input\n",
        "    # and initialization if you are using any additional inputs\n",
        "    # for usage in the function\n",
        "    def __init__(\n",
        "        self,\n",
        "        model,\n",
        "        epochs,\n",
        "        train_dataloader,\n",
        "        val_dataloader,\n",
        "        criterion,\n",
        "        optimizer,\n",
        "        device,\n",
        "        model_dir,\n",
        "        model_name,\n",
        "    ):\n",
        "        self.model = model\n",
        "        self.epochs = epochs\n",
        "        self.train_dataloader = train_dataloader\n",
        "        self.val_dataloader = val_dataloader\n",
        "        self.criterion = criterion\n",
        "        self.optimizer = optimizer\n",
        "        self.device = device\n",
        "        self.model_dir = model_dir\n",
        "        self.model_name = model_name\n",
        "        self.loss = {\"train\": [], \"val\": []}\n",
        "        self.model.to(self.device)\n",
        "\n",
        "    # ADD YOUR CODE HERE FOR TRAINING & VALIDATION\n",
        "    # This implementation need not include negative sampling.\n",
        "\n",
        "    # NOTE: you can add additional functions to make training better\n",
        "\n",
        "\n",
        "    def train_epoch(self):\n",
        "        self.model.train()\n",
        "        total_loss = 0.0\n",
        "\n",
        "        for batch in self.train_dataloader:\n",
        "            inputs, targets = batch\n",
        "            inputs, targets = inputs.to(self.device), targets.to(self.device)\n",
        "\n",
        "            self.optimizer.zero_grad()\n",
        "            outputs = self.model(inputs)\n",
        "            loss = self.criterion(outputs, targets)\n",
        "            loss.backward()\n",
        "            self.optimizer.step()\n",
        "\n",
        "            total_loss += loss.item()\n",
        "\n",
        "        return total_loss / len(self.train_dataloader)\n",
        "\n",
        "    def validate(self):\n",
        "        self.model.eval()\n",
        "        total_loss = 0.0\n",
        "\n",
        "        with torch.no_grad():\n",
        "            for batch in self.val_dataloader:\n",
        "                inputs, targets = batch\n",
        "                inputs, targets = inputs.to(self.device), targets.to(self.device)\n",
        "\n",
        "                outputs = self.model(inputs)\n",
        "                loss = self.criterion(outputs, targets)\n",
        "\n",
        "                total_loss += loss.item()\n",
        "\n",
        "        return total_loss / len(self.val_dataloader)\n",
        "\n",
        "    def train(self):\n",
        "        for epoch in range(1, self.epochs + 1):\n",
        "            train_loss = self.train_epoch()\n",
        "            val_loss = self.validate()\n",
        "\n",
        "            self.loss[\"train\"].append(train_loss)\n",
        "            self.loss[\"val\"].append(val_loss)\n",
        "\n",
        "            print(f\"Epoch {epoch}/{self.epochs}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}\")\n",
        "\n",
        "        self.save_model()\n",
        "        self.save_loss()\n",
        "\n",
        "    def save_model(self):\n",
        "        \"\"\"\n",
        "        Save final model to directory\n",
        "\n",
        "        \"\"\"\n",
        "        model_path = os.path.join(self.model_dir, f\"{self.model_name}_model.pt\")\n",
        "        torch.save(self.model.state_dict(), model_path)\n",
        "\n",
        "    def save_loss(self):\n",
        "        \"\"\"\n",
        "        Save train/val loss as json file to the directory\n",
        "\n",
        "        \"\"\"\n",
        "        loss_path = os.path.join(self.model_dir, f\"{self.model_name}_loss.json\")\n",
        "        with open(loss_path, \"w\") as fp:\n",
        "            json.dump(self.loss, fp)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l16h2hh4Jk8L"
      },
      "source": [
        "\n",
        "\n",
        "> **The following code block defines the various parameters and nomenclature for the training and saving of the skip-gram model. Add numerical values for the `specified hyperparameters`.**\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Wr85dh05x8ne"
      },
      "outputs": [],
      "source": [
        "# ADD YOUR CODE HERE\n",
        "# CHANGE THE None VALUES TO YOUR DESIRED VALUES\n",
        "\n",
        "model_name = 'skipgram'\n",
        "\n",
        "dataset = 'WikiText2'\n",
        "data_dir = './data/'\n",
        "train_batch_size = 32\n",
        "val_batch_size = 32\n",
        "shuffle = True\n",
        "\n",
        "optimizer = 'Adam'\n",
        "learning_rate = 0.03\n",
        "epochs = 10\n",
        "\n",
        "# ADD YOUR CODE HERE\n",
        "# change the directory name with your SAPname and SRno\n",
        "\n",
        "model_dir = 'Pritam_23754_3'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QD1ORV_0J6xo"
      },
      "source": [
        "> **The following code block is used to train and save the model. Add the code wherever required**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gV2LthqLy6kN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aade7211-1eb7-4de5-efcd-bf0aa9685d27"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Vocabulary size: 706\n",
            "Epoch 1/10, Train Loss: 3.9107, Val Loss: 3.8340\n",
            "Epoch 2/10, Train Loss: 3.8225, Val Loss: 3.8324\n",
            "Epoch 3/10, Train Loss: 3.8238, Val Loss: 3.8257\n",
            "Epoch 4/10, Train Loss: 3.8299, Val Loss: 3.8416\n",
            "Epoch 5/10, Train Loss: 3.8299, Val Loss: 3.8365\n",
            "Epoch 6/10, Train Loss: 3.8314, Val Loss: 3.8419\n",
            "Epoch 7/10, Train Loss: 3.8304, Val Loss: 3.8444\n",
            "Epoch 8/10, Train Loss: 3.8330, Val Loss: 3.8438\n",
            "Epoch 9/10, Train Loss: 3.8328, Val Loss: 3.8295\n",
            "Epoch 10/10, Train Loss: 3.8295, Val Loss: 3.8451\n",
            "Training finished.\n",
            "Model artifacts saved to folder: Pritam_23754_3\n"
          ]
        }
      ],
      "source": [
        "os.makedirs(model_dir)\n",
        "\n",
        "train_dataloader, vocab = get_dataloader_and_vocab(\n",
        "    model_name=model_name,\n",
        "    ds_name=dataset,\n",
        "    ds_type=\"train\",\n",
        "    data_dir=data_dir,\n",
        "    batch_size=train_batch_size,\n",
        "    shuffle=shuffle,\n",
        "    vocab=None,\n",
        ")\n",
        "\n",
        "val_dataloader, _ = get_dataloader_and_vocab(\n",
        "    model_name=model_name,\n",
        "    ds_name=dataset,\n",
        "    ds_type=\"valid\",\n",
        "    data_dir=data_dir,\n",
        "    batch_size=val_batch_size,\n",
        "    shuffle=shuffle,\n",
        "    vocab=vocab,\n",
        ")\n",
        "\n",
        "vocab_size = len(vocab.get_stoi())\n",
        "print(f\"Vocabulary size: {vocab_size}\")\n",
        "\n",
        "model_class = SkipGram_Model\n",
        "model = model_class(vocab_size=vocab_size, embed_dimension=EMBED_DIMENSION)\n",
        "\n",
        "# ADD YOUR CODE HERE\n",
        "# You'll have to specify the loss criterion\n",
        "# Your loss function would depend upon whether you\n",
        "# choose to train with negative sampling or not\n",
        "# either of the two are valid choices\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "\n",
        "# ADD YOUR CODE HERE\n",
        "# You'll have to specify the optimizer here\n",
        "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "# NOTE: if you are **optionally** using additional options for the trainer\n",
        "# (e.g., a training scheduler), please add them below.\n",
        "\n",
        "\n",
        "\n",
        "trainer = Trainer(\n",
        "    model=model,\n",
        "    epochs=epochs,\n",
        "    train_dataloader=train_dataloader,\n",
        "    val_dataloader=val_dataloader,\n",
        "    criterion=criterion,\n",
        "    optimizer=optimizer,\n",
        "    device=device,\n",
        "    model_dir=model_dir,\n",
        "    model_name=model_name,\n",
        ")\n",
        "\n",
        "\n",
        "trainer.train()\n",
        "print(\"Training finished.\")\n",
        "\n",
        "trainer.save_model()\n",
        "trainer.save_loss()\n",
        "vocab_path = os.path.join(model_dir, \"vocab.pt\")\n",
        "torch.save(vocab, vocab_path)\n",
        "print(\"Model artifacts saved to folder:\", model_dir)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9clAXUdEKi9-"
      },
      "source": [
        "### Let us analyze the performance of the model\n",
        "\n",
        "You'll be evaluated on the quality of the word representations as judged by the word similarity test, and word analogy tests.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "R7yeQyhKPLuP"
      },
      "outputs": [],
      "source": [
        "#@title Evaluation\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import torch\n",
        "import sys\n",
        "from sklearn.metrics.pairwise import cosine_similarity\n",
        "import seaborn as sns\n",
        "from sklearn.decomposition import PCA\n",
        "import matplotlib.pyplot as plt\n",
        "import gensim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JgyLGyI2PNyK"
      },
      "outputs": [],
      "source": [
        "# ADD YOUR CODE HERE\n",
        "# change the directory name with your SAPname and SRno\n",
        "\n",
        "folder = \"Pritam_23754_3\"\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "# load the saved model\n",
        "model = torch.load(f\"{folder}/skipgram_model.pt\", map_location=device)\n",
        "vocab = torch.load(f\"{folder}/vocab.pt\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kcleTaJLRBmW"
      },
      "outputs": [],
      "source": [
        "word_embeddings = model['embeddings.weight'].cpu().numpy()\n",
        "\n",
        "# ADD YOUR CODE HERE\n",
        "# Change the directory name with your SAP name and SR no\n",
        "directory_name = 'Pritam_23754_3/'\n",
        "\n",
        "# Save the embeddings to the folder\n",
        "np.save(directory_name + 'word_embeddings.npy', word_embeddings)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dX_ds7kKMHl2"
      },
      "source": [
        "Once the embeddings are trained, we can use a few words to evaluate some desirable properties of word representations.\n",
        "\n",
        "For instance, whether similar words are indeed similar in the high-dimensional space?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pa5ywTHKRQFL"
      },
      "outputs": [],
      "source": [
        "words = ['king', 'queen', 'river', 'water', 'ocean', 'tree', 'plant', 'happy', 'glad', 'mother', 'daughter']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e38ny9TWMMez"
      },
      "source": [
        "> **Write a code to find the similarity of the each word in words with eachother**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tZ9qixmnRUSB"
      },
      "outputs": [],
      "source": [
        "def get_word_similarity(words, word_embeddings):\n",
        "  \"\"\"\n",
        "  This function takes the words as input and outputs the word vectors\n",
        "  corresponding to the words obtained from your word2vec model and the\n",
        "  similarity of every word with each other.\n",
        "  word2vec is the embedding matrix corresponding to the given words and\n",
        "  this has to be returned as a numpy array to apply PCA on it whereas,\n",
        "  w2v_similarity[i][j] should contain the similarity of word i with word j\n",
        "\n",
        "  \"\"\"\n",
        "  # ADD YOUR CODE HERE\n",
        "\n",
        "  # you'll have to compute the similarity matrix for the words given above\n",
        "\n",
        "  word2vec = {}\n",
        "  for i, word in enumerate(words):\n",
        "      word2vec[word] = word_embeddings[i]\n",
        "\n",
        "  # Initialize a matrix to store the similarity values\n",
        "  w2v_similarity = np.zeros((len(words), len(words)))\n",
        "\n",
        "  # Calculate the cosine similarity between each pair of words\n",
        "  for i in range(len(words)):\n",
        "      for j in range(len(words)):\n",
        "          if i != j:\n",
        "              vec_i = word2vec[words[i]]\n",
        "              vec_j = word2vec[words[j]]\n",
        "              similarity = np.dot(vec_i, vec_j) / (np.linalg.norm(vec_i) * np.linalg.norm(vec_j))\n",
        "              w2v_similarity[i][j] = similarity\n",
        "\n",
        "  return word2vec, w2v_similarity\n",
        "\n",
        "word2vec, w2v_similarity = get_word_similarity(words, word_embeddings)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "17pyKzr6Mj0C"
      },
      "source": [
        "Let us visualize this similarity matrix. The similarity of each word with other words in words is displayed as a pandas dataframe and as a heatmap"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nSJfZZooRnyj",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 390
        },
        "outputId": "3e5d6b86-47d4-4f6a-8d47-85300ef9567d"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "              king     queen     river     water     ocean      tree  \\\n",
              "king      0.000000  0.264550  0.255218  0.105012  0.194897  0.114582   \n",
              "queen     0.264550  0.000000  0.090150  0.070809  0.119552  0.128875   \n",
              "river     0.255218  0.090150  0.000000  0.193964  0.007383  0.014870   \n",
              "water     0.105012  0.070809  0.193964  0.000000 -0.028643 -0.019268   \n",
              "ocean     0.194897  0.119552  0.007383 -0.028643  0.000000  0.141951   \n",
              "tree      0.114582  0.128875  0.014870 -0.019268  0.141951  0.000000   \n",
              "plant     0.162829  0.227686  0.197961  0.097908  0.227622  0.076433   \n",
              "happy     0.102379 -0.015477  0.022034  0.120729  0.159119  0.128356   \n",
              "glad      0.144892  0.237828  0.093549  0.013731 -0.051641 -0.049875   \n",
              "mother    0.052716 -0.148219 -0.126403 -0.052386  0.044650  0.172704   \n",
              "daughter  0.038841  0.065345  0.096387  0.093679  0.004682 -0.053449   \n",
              "\n",
              "             plant     happy      glad    mother  daughter  \n",
              "king      0.162829  0.102379  0.144892  0.052716  0.038841  \n",
              "queen     0.227686 -0.015477  0.237828 -0.148219  0.065345  \n",
              "river     0.197961  0.022034  0.093549 -0.126403  0.096387  \n",
              "water     0.097908  0.120729  0.013731 -0.052386  0.093679  \n",
              "ocean     0.227622  0.159119 -0.051641  0.044650  0.004682  \n",
              "tree      0.076433  0.128356 -0.049875  0.172704 -0.053449  \n",
              "plant     0.000000  0.037793 -0.086272 -0.037325  0.066239  \n",
              "happy     0.037793  0.000000  0.084816 -0.064062 -0.018429  \n",
              "glad     -0.086272  0.084816  0.000000 -0.074599  0.125532  \n",
              "mother   -0.037325 -0.064062 -0.074599  0.000000 -0.099623  \n",
              "daughter  0.066239 -0.018429  0.125532 -0.099623  0.000000  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-521ffdb2-55eb-4f6a-ad67-406aa868883f\" class=\"colab-df-container\">\n",
              "    <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>king</th>\n",
              "      <th>queen</th>\n",
              "      <th>river</th>\n",
              "      <th>water</th>\n",
              "      <th>ocean</th>\n",
              "      <th>tree</th>\n",
              "      <th>plant</th>\n",
              "      <th>happy</th>\n",
              "      <th>glad</th>\n",
              "      <th>mother</th>\n",
              "      <th>daughter</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>king</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.264550</td>\n",
              "      <td>0.255218</td>\n",
              "      <td>0.105012</td>\n",
              "      <td>0.194897</td>\n",
              "      <td>0.114582</td>\n",
              "      <td>0.162829</td>\n",
              "      <td>0.102379</td>\n",
              "      <td>0.144892</td>\n",
              "      <td>0.052716</td>\n",
              "      <td>0.038841</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>queen</th>\n",
              "      <td>0.264550</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.090150</td>\n",
              "      <td>0.070809</td>\n",
              "      <td>0.119552</td>\n",
              "      <td>0.128875</td>\n",
              "      <td>0.227686</td>\n",
              "      <td>-0.015477</td>\n",
              "      <td>0.237828</td>\n",
              "      <td>-0.148219</td>\n",
              "      <td>0.065345</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>river</th>\n",
              "      <td>0.255218</td>\n",
              "      <td>0.090150</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.193964</td>\n",
              "      <td>0.007383</td>\n",
              "      <td>0.014870</td>\n",
              "      <td>0.197961</td>\n",
              "      <td>0.022034</td>\n",
              "      <td>0.093549</td>\n",
              "      <td>-0.126403</td>\n",
              "      <td>0.096387</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>water</th>\n",
              "      <td>0.105012</td>\n",
              "      <td>0.070809</td>\n",
              "      <td>0.193964</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>-0.028643</td>\n",
              "      <td>-0.019268</td>\n",
              "      <td>0.097908</td>\n",
              "      <td>0.120729</td>\n",
              "      <td>0.013731</td>\n",
              "      <td>-0.052386</td>\n",
              "      <td>0.093679</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>ocean</th>\n",
              "      <td>0.194897</td>\n",
              "      <td>0.119552</td>\n",
              "      <td>0.007383</td>\n",
              "      <td>-0.028643</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.141951</td>\n",
              "      <td>0.227622</td>\n",
              "      <td>0.159119</td>\n",
              "      <td>-0.051641</td>\n",
              "      <td>0.044650</td>\n",
              "      <td>0.004682</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>tree</th>\n",
              "      <td>0.114582</td>\n",
              "      <td>0.128875</td>\n",
              "      <td>0.014870</td>\n",
              "      <td>-0.019268</td>\n",
              "      <td>0.141951</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.076433</td>\n",
              "      <td>0.128356</td>\n",
              "      <td>-0.049875</td>\n",
              "      <td>0.172704</td>\n",
              "      <td>-0.053449</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>plant</th>\n",
              "      <td>0.162829</td>\n",
              "      <td>0.227686</td>\n",
              "      <td>0.197961</td>\n",
              "      <td>0.097908</td>\n",
              "      <td>0.227622</td>\n",
              "      <td>0.076433</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.037793</td>\n",
              "      <td>-0.086272</td>\n",
              "      <td>-0.037325</td>\n",
              "      <td>0.066239</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>happy</th>\n",
              "      <td>0.102379</td>\n",
              "      <td>-0.015477</td>\n",
              "      <td>0.022034</td>\n",
              "      <td>0.120729</td>\n",
              "      <td>0.159119</td>\n",
              "      <td>0.128356</td>\n",
              "      <td>0.037793</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.084816</td>\n",
              "      <td>-0.064062</td>\n",
              "      <td>-0.018429</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>glad</th>\n",
              "      <td>0.144892</td>\n",
              "      <td>0.237828</td>\n",
              "      <td>0.093549</td>\n",
              "      <td>0.013731</td>\n",
              "      <td>-0.051641</td>\n",
              "      <td>-0.049875</td>\n",
              "      <td>-0.086272</td>\n",
              "      <td>0.084816</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>-0.074599</td>\n",
              "      <td>0.125532</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mother</th>\n",
              "      <td>0.052716</td>\n",
              "      <td>-0.148219</td>\n",
              "      <td>-0.126403</td>\n",
              "      <td>-0.052386</td>\n",
              "      <td>0.044650</td>\n",
              "      <td>0.172704</td>\n",
              "      <td>-0.037325</td>\n",
              "      <td>-0.064062</td>\n",
              "      <td>-0.074599</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>-0.099623</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>daughter</th>\n",
              "      <td>0.038841</td>\n",
              "      <td>0.065345</td>\n",
              "      <td>0.096387</td>\n",
              "      <td>0.093679</td>\n",
              "      <td>0.004682</td>\n",
              "      <td>-0.053449</td>\n",
              "      <td>0.066239</td>\n",
              "      <td>-0.018429</td>\n",
              "      <td>0.125532</td>\n",
              "      <td>-0.099623</td>\n",
              "      <td>0.000000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-521ffdb2-55eb-4f6a-ad67-406aa868883f')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-521ffdb2-55eb-4f6a-ad67-406aa868883f button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-521ffdb2-55eb-4f6a-ad67-406aa868883f');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-c92e6ba5-db5c-4338-b9ea-00b45d09284a\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-c92e6ba5-db5c-4338-b9ea-00b45d09284a')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-c92e6ba5-db5c-4338-b9ea-00b45d09284a button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {},
          "execution_count": 149
        }
      ],
      "source": [
        "pd.DataFrame(w2v_similarity, columns = words, index = words)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ij4_ZcQXRreX",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 496
        },
        "outputId": "c1a8fa7c-ae15-4f25-9e50-be97184d48eb"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Axes: >"
            ]
          },
          "metadata": {},
          "execution_count": 150
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "sns.heatmap(pd.DataFrame(w2v_similarity, columns = words, index = words))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rf2uAwtcMqbw"
      },
      "source": [
        "The size of the words embedding are reduced to to 2D and displayed as a scatterplot for analysis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rreLCMaFMy2j"
      },
      "outputs": [],
      "source": [
        "# Create a 2-dimensional PCA model of the word vectors using the scikit-learn PCA class\n",
        "# n_components in PCA specifies the no.of dimensions\n",
        "pca = PCA(n_components=2)\n",
        "\n",
        "# Fit and transform the vectors using PCA model\n",
        "reduced_w2v = pca.fit_transform(list(word2vec.values()))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "afDWd7jIM9ua",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 451
        },
        "outputId": "57d9b76a-8b92-44e6-87f9-f6817bc95295"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plt.figure(figsize=(8,5))\n",
        "plt.scatter(reduced_w2v[:,0],reduced_w2v[:,1], s = 12, color = 'red')\n",
        "plt.xlim([-2,2])\n",
        "plt.ylim([-2,2])\n",
        "x, y = reduced_w2v[:,0] , reduced_w2v[:,1]\n",
        "offset = 0.5\n",
        "for i in range(len(x)):\n",
        "    label = words[i]\n",
        "    xi, yi = x[i], y[i]\n",
        "    plt.annotate(label, (xi, yi), xytext=(xi + offset, yi + offset),\n",
        "                 textcoords='offset points', ha='center', va='center')\n",
        "\n",
        "plt.savefig(\"word_similarity.png\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UzeJlRHkNE1k"
      },
      "source": [
        "The 10 most similar word to the given word is calculated in the following code blocks"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PEEH4cTjcDWu"
      },
      "outputs": [],
      "source": [
        "def get_top_similar(word: str, topN: int = 10):\n",
        "    \"\"\"\n",
        "    This function calculates the topN words similar to the input word.\n",
        "    If the word is not in vocabulary, then similarity is not calculated.\n",
        "    If the word is in the vocabulary, then the dot product of the embedding\n",
        "    matrix and the word vector is calculated. The topN words are selected.\n",
        "    \"\"\"\n",
        "    if word not in vocab:\n",
        "        print(\"Out of vocabulary word\")\n",
        "        return\n",
        "\n",
        "    word_id = vocab[word]\n",
        "    word_vec = model['embeddings.weight'][word_id].cpu().numpy()\n",
        "    word_vec = np.reshape(word_vec, (len(word_vec), 1))\n",
        "\n",
        "    dists = np.dot(model['embeddings.weight'].cpu().numpy(), word_vec).flatten()\n",
        "    topN_ids = np.argsort(-dists)[1 : topN + 1]\n",
        "\n",
        "    topN_dict = {}\n",
        "    for sim_word_id in topN_ids:\n",
        "        sim_word = vocab.lookup_token(sim_word_id)\n",
        "        topN_dict[sim_word] = dists[sim_word_id]\n",
        "\n",
        "    return topN_dict"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HYZoJ2ukc3Vy"
      },
      "outputs": [],
      "source": [
        "for word, sim in get_top_similar(\"india\").items():\n",
        "   print(\"EVALUATION: most similar words to {}: {:.3f}\".format(word, sim))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uUtV2AKrNhdQ"
      },
      "source": [
        "### Analogy Tests\n",
        "\n",
        "Analogy tests include questions of the format a:b::x:?, such tests are used to intrinsically evaluate the quality of word vectors.\n",
        "\n",
        "Here's one example."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Q7XCS02vc5vz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a21f7f14-eda2-4a31-a06b-d685ab677a7a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "king: 12.614\n",
            "control: 3.903\n",
            "brigade: 3.674\n",
            "troops: 3.613\n",
            "named: 3.466\n"
          ]
        }
      ],
      "source": [
        "def get_analogy(word_1, word_2, word_3):\n",
        "    \"\"\"\n",
        "    top 5 most analogous vector calculated correspond to a set similar to\n",
        "    man: woman :: king: ? . This is calculated similar to the above case.\n",
        "    \"\"\"\n",
        "\n",
        "    emb1 = model['embeddings.weight'][vocab[word_1]].cpu().numpy()\n",
        "    emb2 = model['embeddings.weight'][vocab[word_2]].cpu().numpy()\n",
        "    emb3 = model['embeddings.weight'][vocab[word_3]].cpu().numpy()\n",
        "\n",
        "    emb4 = emb1 - emb2 + emb3\n",
        "\n",
        "    # compute dot products between 'emb4' and all word embeddings in the model.\n",
        "    emb4 = np.reshape(emb4, (len(emb4), 1))\n",
        "    dot_product = np.dot(model['embeddings.weight'].cpu().numpy(), emb4).flatten()\n",
        "\n",
        "    top5 = np.argsort(-dot_product)[:5]\n",
        "\n",
        "    return top5, dot_product\n",
        "\n",
        "top5_analogy, dot_product = get_analogy('king', 'man', 'woman')\n",
        "\n",
        "for word_id in top5_analogy:\n",
        "    print(\"{}: {:.3f}\".format(vocab.lookup_token(word_id), dot_product[word_id]))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vJpc8HIuNmLt"
      },
      "source": [
        "The model performance will be evaluated based on an analogy output for the top 5 words. The following code will used to evaluate the performance of the model on the analogies dataset. We will measure how often the correct answer is a part of the top 5 options."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qEE6woybfDTi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "237f4b85-70b8-4112-d020-4e6b72101a06"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-02-05 13:46:57--  https://drive.google.com/uc?export=download&id=1jHx25dECegjtRKBB587nEfHiJesrH0g2\n",
            "Resolving drive.google.com (drive.google.com)... 142.251.175.138, 142.251.175.100, 142.251.175.101, ...\n",
            "Connecting to drive.google.com (drive.google.com)|142.251.175.138|:443... connected.\n",
            "HTTP request sent, awaiting response... 303 See Other\n",
            "Location: https://drive.usercontent.google.com/download?id=1jHx25dECegjtRKBB587nEfHiJesrH0g2&export=download [following]\n",
            "--2024-02-05 13:46:58--  https://drive.usercontent.google.com/download?id=1jHx25dECegjtRKBB587nEfHiJesrH0g2&export=download\n",
            "Resolving drive.usercontent.google.com (drive.usercontent.google.com)... 64.233.170.132, 2404:6800:4003:c1a::84\n",
            "Connecting to drive.usercontent.google.com (drive.usercontent.google.com)|64.233.170.132|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 286075 (279K) [application/octet-stream]\n",
            "Saving to: ‘analogies.txt’\n",
            "\n",
            "analogies.txt       100%[===================>] 279.37K  --.-KB/s    in 0.003s  \n",
            "\n",
            "2024-02-05 13:46:58 (83.6 MB/s) - ‘analogies.txt’ saved [286075/286075]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Downloading the file containing a few analogies.\n",
        "# We will change the contents of this file while testing.\n",
        "\n",
        "!wget -O analogies.txt \"https://drive.google.com/uc?export=download&id=1jHx25dECegjtRKBB587nEfHiJesrH0g2\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "08o4HkrHfKiM"
      },
      "outputs": [],
      "source": [
        "import random\n",
        "random.seed(42)\n",
        "\n",
        "def load_and_sample_analogies(file_path, sample_size=5000):\n",
        "    with open(file_path, 'r') as file:\n",
        "        analogies = []\n",
        "        for line in file:\n",
        "            # Split the line into words and ensure it has exactly 4 elements\n",
        "            parts = line.strip().split()\n",
        "            if len(parts) == 4:\n",
        "                analogies.append(parts)\n",
        "\n",
        "        # Sample analogies\n",
        "        sampled_analogies = random.sample(analogies, min(sample_size, len(analogies)))\n",
        "        return sampled_analogies\n",
        "\n",
        "# Path to your text file\n",
        "# NOTE: analogies used for grading could be slightly different\n",
        "file_path = '/content/analogies.txt'\n",
        "\n",
        "# Load and sample analogies\n",
        "sampled_analogy_dataset = load_and_sample_analogies(file_path)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YPCtOd8IfN0i",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "36a324cf-d6fb-4152-f883-3ab9de143a69"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EVALUATION: Precision at 5 for the analogy test is 0.1111111111111111\n"
          ]
        }
      ],
      "source": [
        "def get_word_id(word, vocab):\n",
        "    \"\"\"check for out of vocabulary items\"\"\"\n",
        "    return vocab[word] if word in vocab else 0\n",
        "\n",
        "def analogy_score(analogy_dataset):\n",
        "    \"\"\"\n",
        "    The top5 analogous words calculated for each set of words for your\n",
        "    implementation of word2vec and compared with an existing dataset to\n",
        "    calculate if the expected word is in the first 5 predictions.\n",
        "    \"\"\"\n",
        "\n",
        "    correct = 0\n",
        "    total = 0\n",
        "\n",
        "    for a, b, c, d in analogy_dataset:\n",
        "        # Convert words to lowercase\n",
        "        a, b, c, d = a.lower(), b.lower(), c.lower(), d.lower()\n",
        "\n",
        "        # Check if any word is out of vocabulary\n",
        "        if 0 in [get_word_id(word, vocab) for word in [a, b, c, d]]:\n",
        "            continue\n",
        "\n",
        "        #finding the first five words that are analogous to the given set\n",
        "        top5_analogy, dot_product = get_analogy(c, a, b)\n",
        "\n",
        "        predicted_words = []\n",
        "\n",
        "        for word_id in top5_analogy:\n",
        "            word = vocab.lookup_token(word_id)\n",
        "            predicted_words.append(word)\n",
        "\n",
        "        if d in predicted_words:\n",
        "            correct += 1\n",
        "\n",
        "        total += 1\n",
        "    precision_at_5 = correct / total if total > 0 else 0\n",
        "    return precision_at_5\n",
        "\n",
        "precision_at_5 = analogy_score(sampled_analogy_dataset)\n",
        "print(\"EVALUATION: Precision at 5 for the analogy test is\", precision_at_5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yc4HDnCsOuBV"
      },
      "source": [
        "#### Google's word2vec for comparison\n",
        "\n",
        "In the following code blocks, the pretained word2vec developed by Google is used to analyze the quality of the embedding. The word2vec model can be downloaded from [here](https://drive.google.com/file/d/0B7XkCwpI5KDYNlNUTTlSS21pQmM/edit?usp=sharing)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nNR75UeBfceN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d7d3de14-8ae1-4a9c-d776-f6f623f5cee6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-02-05 13:32:28--  https://drive.google.com/uc?export=download&id=12Oicgl5scdJLR7t8jbzKpW6o8QkYOylg\n",
            "Resolving drive.google.com (drive.google.com)... 74.125.24.101, 74.125.24.138, 74.125.24.100, ...\n",
            "Connecting to drive.google.com (drive.google.com)|74.125.24.101|:443... connected.\n",
            "HTTP request sent, awaiting response... 303 See Other\n",
            "Location: https://drive.usercontent.google.com/download?id=12Oicgl5scdJLR7t8jbzKpW6o8QkYOylg&export=download [following]\n",
            "--2024-02-05 13:32:28--  https://drive.usercontent.google.com/download?id=12Oicgl5scdJLR7t8jbzKpW6o8QkYOylg&export=download\n",
            "Resolving drive.usercontent.google.com (drive.usercontent.google.com)... 64.233.170.132, 2404:6800:4003:c1a::84\n",
            "Connecting to drive.usercontent.google.com (drive.usercontent.google.com)|64.233.170.132|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 2446 (2.4K) [text/html]\n",
            "Saving to: ‘GoogleNews-vectors-negative300.bin’\n",
            "\n",
            "GoogleNews-vectors- 100%[===================>]   2.39K  --.-KB/s    in 0s      \n",
            "\n",
            "2024-02-05 13:32:29 (32.3 MB/s) - ‘GoogleNews-vectors-negative300.bin’ saved [2446/2446]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "!wget -O GoogleNews-vectors-negative300.bin \"https://drive.google.com/uc?export=download&id=12Oicgl5scdJLR7t8jbzKpW6o8QkYOylg\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2ymtJfkhfvfI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 66,
          "referenced_widgets": [
            "a52261af048543b0a30384b4c61e9a76",
            "4ab6a87cf5d842c4b149d062c622d566",
            "30151c2cc5994d92a9153405e96f98f7",
            "188c8a11f2fa4cee8b75593b697926e7",
            "abf35d5e2723471887ac6a38a08fc0bd",
            "9526f2e1120b436a824c2b0f9422b25e",
            "e5af380e4151413c82c4834149bc2377",
            "00e35e994b5248b5a6b6e8f9c6dc7c87",
            "d34bd98952694e6ebed999a714de5d16",
            "37076c236e2149ce976e874cad08f8f8",
            "093ec71be50446ff9d6fefcb952d758f"
          ]
        },
        "outputId": "8d6ebbb3-63f4-4f13-9ee3-4c77e2fd92d7"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0.00/3.39G [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "a52261af048543b0a30384b4c61e9a76"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloaded to /content/GoogleNews-vectors-negative300.bin\n"
          ]
        }
      ],
      "source": [
        "import bs4\n",
        "import requests\n",
        "import tqdm.auto as tqdm\n",
        "\n",
        "def download_from_drive(drive_link, target_path):\n",
        "    response = requests.get(drive_link, stream=True)\n",
        "    response.raise_for_status()\n",
        "    if 'html' in response.headers['Content-Type']:\n",
        "        response = requests.get(drive_link)\n",
        "        response.raise_for_status()\n",
        "        page = bs4.BeautifulSoup(response.text, features=\"lxml\")\n",
        "        if form := page.find('form', id='download-form'):\n",
        "            id   = form.select_one(\"input[name='id']\")['value']\n",
        "            uuid = form.select_one(\"input[name='uuid']\")['value']\n",
        "            data = { 'confirm': 't', 'export': 'download', 'id': id, 'uuid': uuid }\n",
        "            response = requests.get(page.find('form')['action'], params=data, stream=True)\n",
        "            response.raise_for_status()\n",
        "    with open(target_path, 'wb+') as file:\n",
        "        with tqdm.tqdm(\n",
        "            total=int(response.headers['Content-Length']),\n",
        "            unit='B', unit_scale=True, unit_divisor=1024\n",
        "        ) as pbar:\n",
        "            for chunk in response.iter_content(chunk_size=4096):\n",
        "                file.write(chunk)\n",
        "                pbar.update(len(chunk))\n",
        "    print(\"Downloaded to\", target_path)\n",
        "\n",
        "drive_link = \"https://drive.google.com/uc?export=download&id=12Oicgl5scdJLR7t8jbzKpW6o8QkYOylg\"\n",
        "target_path = \"/content/GoogleNews-vectors-negative300.bin\"\n",
        "\n",
        "download_from_drive(drive_link, target_path)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DFzu2IeGfxtf"
      },
      "outputs": [],
      "source": [
        "import gensim\n",
        "\n",
        "# Load Google news 300 vectors file\n",
        "model = gensim.models.KeyedVectors.load_word2vec_format('/content/drive/MyDrive/GoogleNews-vectors-negative300.bin', binary=True, limit=500000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f3VkniLbf0s1"
      },
      "outputs": [],
      "source": [
        "# List of words to plot the embeddings\n",
        "words = ['king', 'queen', 'river', 'water', 'ocean', 'tree', 'plant', 'happy', 'glad', 'mother', 'daughter']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mPKcE72YQIS3"
      },
      "source": [
        "> **Write a code to find the similarity of the each word in words with eachother using original word2vec**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "u1lmFifWQf04"
      },
      "outputs": [],
      "source": [
        "def get_word_similarity(words, model):\n",
        "    \"\"\"\n",
        "    This function takes the words and a word2vec model as input and outputs the word vectors\n",
        "    corresponding to the words and the similarity of every word with each other.\n",
        "    \"\"\"\n",
        "  # ADD YOUR CODE HERE\n",
        "\n",
        "  # you'll have to compute the similarity matrix for the words given above\n",
        "\n",
        "    word2vec = {}\n",
        "    for word in words:\n",
        "        if word in model:\n",
        "            word2vec[word] = model[word]\n",
        "\n",
        "    w2v_similarity = np.zeros((len(word2vec), len(word2vec)))\n",
        "\n",
        "    for i, word1 in enumerate(word2vec.keys()):\n",
        "        for j, word2 in enumerate(word2vec.keys()):\n",
        "            if i != j:\n",
        "                vec1 = word2vec[word1]\n",
        "                vec2 = word2vec[word2]\n",
        "                similarity = np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))\n",
        "                w2v_similarity[i][j] = similarity\n",
        "\n",
        "    return word2vec, w2v_similarity\n",
        "\n",
        "word2vec, w2v_similarity = get_word_similarity(words, model)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ats78BccReju",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 390
        },
        "outputId": "16c3c571-61d9-4a1d-fdd1-985e4ace4f8e"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "              king     queen     river     water     ocean      tree  \\\n",
              "king      0.000000  0.651096  0.086155  0.035606  0.065263  0.109141   \n",
              "queen     0.651096  0.000000  0.103566  0.018264  0.099157  0.112222   \n",
              "river     0.086155  0.103566  0.000000  0.576898  0.477181  0.230746   \n",
              "water     0.035606  0.018264  0.576898  0.000000  0.471691  0.196022   \n",
              "ocean     0.065263  0.099157  0.477181  0.471691  0.000000  0.141859   \n",
              "tree      0.109141  0.112222  0.230746  0.196022  0.141859  0.000000   \n",
              "plant     0.057788  0.088803  0.201330  0.271738  0.067005  0.265187   \n",
              "happy     0.113239  0.121214  0.073289  0.067675 -0.000511  0.076933   \n",
              "glad      0.063524  0.082538  0.071341  0.085623  0.014122  0.105760   \n",
              "mother    0.160052  0.288445  0.131063  0.110723  0.105623  0.188985   \n",
              "daughter  0.148813  0.305139  0.116944  0.079457  0.081207  0.173518   \n",
              "\n",
              "             plant     happy      glad    mother  daughter  \n",
              "king      0.057788  0.113239  0.063524  0.160052  0.148813  \n",
              "queen     0.088803  0.121214  0.082538  0.288445  0.305139  \n",
              "river     0.201330  0.073289  0.071341  0.131063  0.116944  \n",
              "water     0.271738  0.067675  0.085623  0.110723  0.079457  \n",
              "ocean     0.067005 -0.000511  0.014122  0.105623  0.081207  \n",
              "tree      0.265187  0.076933  0.105760  0.188985  0.173518  \n",
              "plant     0.000000 -0.010519 -0.000679  0.148805  0.092466  \n",
              "happy    -0.010519  0.000000  0.740889  0.119672  0.152536  \n",
              "glad     -0.000679  0.740889  0.000000  0.125566  0.181102  \n",
              "mother    0.148805  0.119672  0.125566  0.000000  0.870623  \n",
              "daughter  0.092466  0.152536  0.181102  0.870623  0.000000  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-c6023e47-c707-4f81-a94c-7530fc29b263\" class=\"colab-df-container\">\n",
              "    <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>king</th>\n",
              "      <th>queen</th>\n",
              "      <th>river</th>\n",
              "      <th>water</th>\n",
              "      <th>ocean</th>\n",
              "      <th>tree</th>\n",
              "      <th>plant</th>\n",
              "      <th>happy</th>\n",
              "      <th>glad</th>\n",
              "      <th>mother</th>\n",
              "      <th>daughter</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>king</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.651096</td>\n",
              "      <td>0.086155</td>\n",
              "      <td>0.035606</td>\n",
              "      <td>0.065263</td>\n",
              "      <td>0.109141</td>\n",
              "      <td>0.057788</td>\n",
              "      <td>0.113239</td>\n",
              "      <td>0.063524</td>\n",
              "      <td>0.160052</td>\n",
              "      <td>0.148813</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>queen</th>\n",
              "      <td>0.651096</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.103566</td>\n",
              "      <td>0.018264</td>\n",
              "      <td>0.099157</td>\n",
              "      <td>0.112222</td>\n",
              "      <td>0.088803</td>\n",
              "      <td>0.121214</td>\n",
              "      <td>0.082538</td>\n",
              "      <td>0.288445</td>\n",
              "      <td>0.305139</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>river</th>\n",
              "      <td>0.086155</td>\n",
              "      <td>0.103566</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.576898</td>\n",
              "      <td>0.477181</td>\n",
              "      <td>0.230746</td>\n",
              "      <td>0.201330</td>\n",
              "      <td>0.073289</td>\n",
              "      <td>0.071341</td>\n",
              "      <td>0.131063</td>\n",
              "      <td>0.116944</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>water</th>\n",
              "      <td>0.035606</td>\n",
              "      <td>0.018264</td>\n",
              "      <td>0.576898</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.471691</td>\n",
              "      <td>0.196022</td>\n",
              "      <td>0.271738</td>\n",
              "      <td>0.067675</td>\n",
              "      <td>0.085623</td>\n",
              "      <td>0.110723</td>\n",
              "      <td>0.079457</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>ocean</th>\n",
              "      <td>0.065263</td>\n",
              "      <td>0.099157</td>\n",
              "      <td>0.477181</td>\n",
              "      <td>0.471691</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.141859</td>\n",
              "      <td>0.067005</td>\n",
              "      <td>-0.000511</td>\n",
              "      <td>0.014122</td>\n",
              "      <td>0.105623</td>\n",
              "      <td>0.081207</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>tree</th>\n",
              "      <td>0.109141</td>\n",
              "      <td>0.112222</td>\n",
              "      <td>0.230746</td>\n",
              "      <td>0.196022</td>\n",
              "      <td>0.141859</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.265187</td>\n",
              "      <td>0.076933</td>\n",
              "      <td>0.105760</td>\n",
              "      <td>0.188985</td>\n",
              "      <td>0.173518</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>plant</th>\n",
              "      <td>0.057788</td>\n",
              "      <td>0.088803</td>\n",
              "      <td>0.201330</td>\n",
              "      <td>0.271738</td>\n",
              "      <td>0.067005</td>\n",
              "      <td>0.265187</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>-0.010519</td>\n",
              "      <td>-0.000679</td>\n",
              "      <td>0.148805</td>\n",
              "      <td>0.092466</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>happy</th>\n",
              "      <td>0.113239</td>\n",
              "      <td>0.121214</td>\n",
              "      <td>0.073289</td>\n",
              "      <td>0.067675</td>\n",
              "      <td>-0.000511</td>\n",
              "      <td>0.076933</td>\n",
              "      <td>-0.010519</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.740889</td>\n",
              "      <td>0.119672</td>\n",
              "      <td>0.152536</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>glad</th>\n",
              "      <td>0.063524</td>\n",
              "      <td>0.082538</td>\n",
              "      <td>0.071341</td>\n",
              "      <td>0.085623</td>\n",
              "      <td>0.014122</td>\n",
              "      <td>0.105760</td>\n",
              "      <td>-0.000679</td>\n",
              "      <td>0.740889</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.125566</td>\n",
              "      <td>0.181102</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mother</th>\n",
              "      <td>0.160052</td>\n",
              "      <td>0.288445</td>\n",
              "      <td>0.131063</td>\n",
              "      <td>0.110723</td>\n",
              "      <td>0.105623</td>\n",
              "      <td>0.188985</td>\n",
              "      <td>0.148805</td>\n",
              "      <td>0.119672</td>\n",
              "      <td>0.125566</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.870623</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>daughter</th>\n",
              "      <td>0.148813</td>\n",
              "      <td>0.305139</td>\n",
              "      <td>0.116944</td>\n",
              "      <td>0.079457</td>\n",
              "      <td>0.081207</td>\n",
              "      <td>0.173518</td>\n",
              "      <td>0.092466</td>\n",
              "      <td>0.152536</td>\n",
              "      <td>0.181102</td>\n",
              "      <td>0.870623</td>\n",
              "      <td>0.000000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-c6023e47-c707-4f81-a94c-7530fc29b263')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-c6023e47-c707-4f81-a94c-7530fc29b263 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-c6023e47-c707-4f81-a94c-7530fc29b263');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-588325c5-09e5-4c95-a41d-164f4a933151\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-588325c5-09e5-4c95-a41d-164f4a933151')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-588325c5-09e5-4c95-a41d-164f4a933151 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {},
          "execution_count": 117
        }
      ],
      "source": [
        "pd.DataFrame(w2v_similarity, columns = words, index = words)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PzxgvGJeRyqj",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 496
        },
        "outputId": "a38b79d2-eb11-4a42-e053-9be88430e902"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Axes: >"
            ]
          },
          "metadata": {},
          "execution_count": 118
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "sns.heatmap(pd.DataFrame(w2v_similarity, columns = words, index = words))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TL1Ahv0DQqsx"
      },
      "source": [
        "The size of the words embedding are reduced to to 2D and displayed as a scatterplot for analysis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "n1kX7EAQSOyq"
      },
      "outputs": [],
      "source": [
        "#PCA on word2vec embedding\n",
        "pca = PCA(n_components=2)\n",
        "word2vec_array = np.array(list(word2vec.values()))\n",
        "reduced_w2v = pca.fit_transform(word2vec_array)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "J7C-6bXeSSxi",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 445
        },
        "outputId": "17d52b85-bc25-4b41-b0f7-8f9f5fb9eda1"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x500 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAp4AAAGsCAYAAAB0LKeoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA39klEQVR4nO3de3wNd/7H8fdJJJG7pu6EiKBsCVWUVKVL0d/yY/v7tb+qlmholdBQRbdVl1ZTdalLtXqVrGW1v7XUVm9UQxuXKhVbJZqEjaKokkhoEjnf3x/n56zUNZoz5yR5PR+P80hm5jsznzlzHO/MzHfGZowxAgAAAFzMy90FAAAAoGogeAIAAMASBE8AAABYguAJAAAASxA8AQAAYAmCJwAAACxB8AQAAIAlqrm7gCux2+06fPiwgoODZbPZ3F0OAAAAfsUYo9OnT6t+/fry8rryMU2PDp6HDx9WeHi4u8sAAADAVRw8eFANGza8YhuPDp7BwcGSHBsSEhLi5moAAADwa3l5eQoPD3fmtivx6OB5/vR6SEgIwRMAAMCDXctlkXQuAgAAgCUIngAAALAEwRMAAACWIHgCAADAEgRPAAAAWILgCQAAAEsQPAEAAGAJgicAAAAsQfAEAACAJQieAAAAsATBEwAAAJYgeAIAAMASBE8AAABYguAJAAAASxA8AQAAYAmCJwAAACxB8AQAAIAlCJ4Ayl1ERITmzp37m5aRnJysGjVqlEs9AADPQPAEAACAJQieAAAAsATBE0CZnT59WgMHDlRgYKDq1aunl19+WbGxsUpMTLxk+zlz5qh169YKDAxUeHi4RowYofz8/FJtkpOT1ahRIwUEBOiPf/yjTpw4YcGWAACsRPAEUGZjx45VWlqaVq9erbVr1+qLL77Qjh07Ltvey8tL8+fP1+7du5WSkqL169dr/Pjxzulbt25VfHy8EhIStHPnTt155516/vnnrdgUAICFqrm7AAAVy+nTp5WSkqJly5ape/fukqTFixerfv36l53nwiOhERERev755zV8+HC9+uqrkqR58+apd+/ezjDavHlzbdq0SR9//LHrNgQAYDmOeAIok+zsbBUXF6tjx47OcaGhoWrRosVl51m3bp26d++uBg0aKDg4WA899JBOnDihM2fOSJL27NmjTp06lZqnc+fOrtkAAIDbEDwBuNSBAwfUp08ftWnTRitWrND27du1cOFCSVJRUZGbqwMAWIngCaBMIiMj5ePjo23btjnH5ebmat++fZdsv337dtntds2ePVu33XabmjdvrsOHD5dq07JlS23durXUuC1btpR/8QAAt+IaTwBlEhwcrMGDB+vJJ59UWFiYateurcmTJ8vLy0s2m+2i9lFRUSouLtaCBQvUt29fpaWladGiRaXajB49WjExMZo1a5b69eunTz75hOs7AaAS4ogngDKbM2eOOnfurD59+qhHjx6KiYlRy5YtVb169YvaRkdHa86cOZoxY4ZuvvlmLV26VElJSaXa3HbbbXrzzTc1b948RUdH69NPP9Uzzzxj1eYAACxiM8YYdxdxOXl5eQoNDVVubq5CQkLcXQ5Q+Z09Ky1aJGVnS5GR0vDhkr//VWcrKChQgwYNNHv2bMXHx1tQKADAU5Qlr3GqHYDD2bNSTIyUni55e0slJdKSJVJa2kXh85tvvtHevXvVsWNH5ebmatq0aZKkfv36uaNyAEAFwal2AA6LFjlCp90uFRc7fqanO8ZfwqxZsxQdHa0ePXqooKBAX3zxhWrWrGlx0QCAioQjngAcsrMdRzrt9n+P8/Z2jP+Vdu3aafv27RYWBwCoDFx6xDMpKUkdOnRQcHCwateurf79+ysjI8OVqwRwvSIjHafXL1RS4hgPAEA5cGnw3LBhg0aOHKktW7Zo7dq1Ki4uVs+ePVVQUODK1QK4HsOHS9HRkpeX5OPj+Nm2rWM8AADlwNJe7cePH1ft2rW1YcMG3XHHHVdtT692wGLX2asdAFB1eWyv9tzcXElSWFjYJacXFhaqsLDQOZyXl2dJXQD+n7+/NGaMu6sAAFRSlvVqt9vtSkxMVExMjG6++eZLtklKSlJoaKjzFR4eblV5AAAAcDHLTrU/9thj+uijj/Tll1+qYcOGl2xzqSOe4eHhnGoHAADwUB53qj0hIUEffPCBNm7ceNnQKUl+fn7y8/OzoiQAAABYzKXB0xijUaNGaeXKlUpNTVWTJk1cuToAAAB4MJcGz5EjR2rZsmV6//33FRwcrB9//FGSFBoaKn96ygIAAFQpLu1c9Nprryk3N1exsbGqV6+e8/Xuu++6crUAXCg2NlaJiYnuLgMAUAG5/FQ7AAAAIFl4OyUAAABUbQRPAGVmt9s1fvx4hYWFqW7dupoyZYpz2pw5c9S6dWsFBgYqPDxcI0aMUH5+vnN6cnKyatSooVWrVqlZs2aqXr26evXqpYMHDzrbTJkyRW3bttXrr7+u8PBwBQQE6L777nM+hGLjxo3y8fFxXjd+XmJiorp27erajQcAXDeCJ4AyS0lJUWBgoLZu3aqXXnpJ06ZN09q1ayVJXl5emj9/vnbv3q2UlBStX79e48ePLzX/mTNnNH36dP35z39WWlqaTp06pfvvv79Um8zMTL333nv6xz/+oY8//ljffPONRowYIUm64447FBkZqSVLljjbFxcXa+nSpXr44YddvPUAgOtmPFhubq6RZHJzc91dCoD/161bN3P77beXGtehQwczYcKES7b/3//9X3PjjTc6hxcvXmwkmS1btjjH7dmzx0gyW7duNcYYM3nyZOPt7W1++OEHZ5uPPvrIeHl5mSNHjhhjjJkxY4Zp2bKlc/qKFStMUFCQyc/P/+0bCQC4ZmXJaxzxBFBmbdq0KTVcr149HTt2TJK0bt06de/eXQ0aNFBwcLAeeughnThxQmfOnHG2r1atmjp06OAcvummm1SjRg3t2bPHOa5Ro0Zq0KCBc7hz586y2+3KyMiQJMXFxSkzM1NbtmyR5DiFf9999ykwMLD8NxgAUC4IngDKzMfHp9SwzWaT3W7XgQMH1KdPH7Vp00YrVqzQ9u3btXDhQklSUVFRudZQu3Zt9e3bV4sXL9bRo0f10UcfcZodADycJY/MBFA1bN++XXa7XbNnz5aXl+Pv2vfee++idufOndPXX3+tjh07SpIyMjJ06tQptWzZ0tkmJydHhw8fVv369SVJW7ZskZeXl1q0aOFsM3ToUA0YMEANGzZU06ZNFRMT48rNAwD8RhzxBFBuoqKiVFxcrAULFig7O1tLlizRokWLLmrn4+OjUaNGaevWrdq+fbvi4uJ02223OYOoJFWvXl2DBw9Wenq6vvjiC40ePVr33Xef6tat62zTq1cvhYSE6Pnnn9eQIUMs2UYAwPUjeAIoN9HR0ZozZ45mzJihm2++WUuXLlVSUtJF7QICAjRhwgQ98MADiomJUVBQ0EVPNIuKitI999yj//iP/1DPnj3Vpk0bvfrqq6XaeHl5KS4uTiUlJRo0aJBLtw0A8NvZjPHcxwvl5eUpNDRUubm5CgkJcXc5QOV29qy0aJGUnS1FRkrDh0v+/uW+muTkZCUmJurUqVOXbTNlyhStWrVKO3fuvOry4uPjdfz4ca1evbr8igQAXLOy5DWu8QTgCJ0xMVJ6uuTtLZWUSEuWSGlpLgmf5SE3N1f//Oc/tWzZMkInAFQQnGoH4DjSmZ4u2e1ScbHjZ3q6Y7yH6tevn3r27Knhw4frrrvucnc5AIBrwKl2ANKoUdLrrztC53k+PtKjj0oLFrivLgCAxytLXuOIJwDHNZ0lJaXHlZQ4xgMAUE4IngAcHYmioyUvL8eRTi8vqW1bx3gAAMoJnYsAODoQpaVZ0qsdAFB1ETwBOPj7S2PGuLsKAEAlxql2AAAAWILgCQAAAEsQPAEAAGAJgicAAAAsQfAEAACAJQieAAAAsATBEwAAAJYgeAIAAMASBE8AAABYguAJAAAASxA8AQAAYAmCJwAAACxB8AQAAIAlCJ4AAACwBMETAAAAliB4AgAAwBIETwAAAFiC4AkAAABLEDwBAABgCYInAAAALEHwBAAAgCUIngAAALAEwRMAAACWIHgCAADAEgRPAAAAWILgCQAAAEsQPAEAAGAJgicAAAAsQfAEAACAJQieAAAAsATBEwAAAJYgeAIAAMASBE8AAABYguAJAAAASxA8AQAAYAmCJwAAACxB8AQAAIAlCJ4AAACwBMETAAAAliB4AgAAwBIETwAAAFiC4AkAAABLEDwBAABgCYInAAAALEHwBAAAgCUIngAAALAEwRMAAACWIHgCAADAEgRPAAAAWMKlwXPjxo3q27ev6tevL5vNplWrVrlydQAAAPBgLg2eBQUFio6O1sKFC125GgAAAFQA1Vy58Lvvvlt33323K1cBAACACsKlwbOsCgsLVVhY6BzOy8tzYzUAAAAoTx7VuSgpKUmhoaHOV3h4uLtLAgAAQDnxqOD51FNPKTc31/k6ePCgu0sCAABAOfGoU+1+fn7y8/NzdxkAAABwAY864gkAAIDKy6VHPPPz85WZmekc3r9/v3bu3KmwsDA1atTIlasGAACAh3Fp8Pz666915513OofHjh0rSRo8eLCSk5NduWoAAAB4GJcGz9jYWBljXLkKAAAAVBBc4wkAAABLEDwBAABgCYInAAAALEHwBAAAgCUIngAAALAEwRMAAACWIHgCAADAEgRPAAAAWILgCQAAAEsQPAEAAGAJgicAAAAsQfAEAACAJQieAAAAsATBEwAAAJYgeAIAAMASBE8AAABYguAJAAAASxA8AQAAYAmCJwAAACxB8AQAAIAlCJ4AAACwBMETAAAAliB4AgAAwBIETwAAAFiC4AkAAABLEDwBAABgCYInAAAALEHwBAAAgCUIngAAALAEwRMAAACWIHgCAADAEgRPAAAAWILgCQAAAEsQPAEAAGAJgicAAAAsQfAEAACAJQieAAAAsATBEwAAAJYgeAIAAMASBE8AAABYguAJAAAASxA8AQAAYAmCJwAAACxB8AQAAIAlCJ4AAACwBMETAAAAliB4AgAAwBIETwAAAFiC4AkAAABLEDwBAABgCYInAAAALEHwBAAAgCUIngAAALAEwRMAAACWIHgCHig2NlaJiYmWrjMuLk79+/e3dJ2A5J7POyoPPj8VC8ETwDWLiIjQ3Llz3V0GqhhjjM6dO+fuMlDJFRUVubuEKoHgCcByfMHjvLi4OG3YsEHz5s2TzWaTzWZTcnKybDabPvroI7Vv315+fn768ssvZbfblZSUpCZNmsjf31/R0dH629/+Vmp53377re6++24FBQWpTp06euihh/TTTz+5aetwKR988IFq1KihkpISSdLOnTtls9k0ceJEZ5uhQ4fqwQcf1IkTJzRgwAA1aNBAAQEBat26tf761786213q83PgwAFJV/8sxMbGKiEhQYmJiapZs6Z69eplzRtQxRE8ATcrKCjQoEGDFBQUpHr16mn27Nmlpi9ZskS33nqrgoODVbduXT3wwAM6duyYc3pycrJq1KhRap5Vq1bJZrOVGvf888+rdu3aCg4O1tChQzVx4kS1bdv2onpmzZqlevXq6cYbb9TIkSNVXFwsyfEl/a9//UtjxoxxfsGf9+WXX6pr167y9/dXeHi4Ro8erYKCAuf0iIgIPffccxo0aJBCQkL0yCOPXO/bhUpm3rx56ty5s4YNG6YjR47oyJEjCg8PlyRNnDhRL774ovbs2aM2bdooKSlJf/7zn7Vo0SLt3r1bY8aM0YMPPqgNGzZIkk6dOqXf//73ateunb7++mt9/PHHOnr0qO677z53biJ+pWvXrjp9+rS++eYbSdKGDRtUs2ZNpaamOtts2LBBsbGx+uWXX9S+fXutWbNG3377rR555BE99NBD+uqrryRd/vNzrZ+FlJQU+fr6Ki0tTYsWLbLsPajSjAfLzc01kkxubq67SwFc5rHHHjONGjUy69atM7t27TJ9+vQxwcHB5vHHHzfGGPP222+bDz/80GRlZZnNmzebzp07m7vvvts5/+LFi01oaGipZa5cudJc+M/7L3/5i6levbp55513TEZGhpk6daoJCQkx0dHRzjaDBw82ISEhZvjw4WbPnj3mH//4hwkICDBvvPGGMcaYEydOmIYNG5pp06aZI0eOmCNHjhhjjMnMzDSBgYHm5ZdfNvv27TNpaWmmXbt2Ji4uzrnsxo0bm5CQEDNr1iyTmZlpMjMzy/ldREXWrVs35+fdGGM+//xzI8msWrXKOe6XX34xAQEBZtOmTaXmjY+PNwMGDDDGGPPcc8+Znj17lpp+8OBBI8lkZGS4bgNQZrfccouZOXOmMcaY/v37m+nTpxtfX19z+vRp88MPPxhJZt++fZec9w9/+IN54oknnMO//vwYc22fhW7dupl27dqV41ZVXWXJa9XcmHmBKi8/P19vv/22/vKXv6h79+6SHH+BN2zY0Nnm4Ycfdv4eGRmp+fPnq0OHDsrPz1dQUNA1rWfBggWKj4/XkCFDJEnPPvusPv30U+Xn55dqd8MNN+iVV16Rt7e3brrpJv3hD3/QZ599pmHDhiksLEze3t7OI6/nJSUlaeDAgc6L+5s1a6b58+erW7dueu2111S9enVJ0u9//3s98cQTZX+TUGXdeuutzt8zMzN15swZ3XXXXaXaFBUVqV27dpKk9PR0ff7555f8d5GVlaXmzZu7tmBcs27duik1NVVPPPGEvvjiCyUlJem9997Tl19+qZ9//ln169dXs2bNVFJSohdeeEHvvfeeDh06pKKiIhUWFiogIOCKy7/Wz0L79u1dsn24PIIn4EZZWVkqKipSp06dnOPCwsLUokUL5/D27ds1ZcoUpaen6+TJk7Lb7ZKknJwctWrV6prWk5GRoREjRpQa17FjR61fv77UuN/97nfy9vZ2DterV0///Oc/r7js9PR07dq1S0uXLnWOM8bIbrdr//79atmypaTSIQK4FoGBgc7fz/+RtGbNGjVo0KBUOz8/P2ebvn37asaMGRctq169ei6sFGUVGxurd955R+np6fLx8dFNN92k2NhYpaam6uTJk+rWrZskaebMmZo3b57mzp2r1q1bKzAwUImJiVe9TvxaPwsXfsZgDYIn4MEKCgrUq1cv9erVS0uXLlWtWrWUk5OjXr16Ob94vby8ZIwpNd/56zLLysfHp9SwzWZzBt3Lyc/P16OPPqrRo0dfNK1Ro0bO3/mCx+X4+vo6O5pcTqtWreTn56ecnBxnKPm1W265RStWrFBERISqVeO/N092/jrPl19+2bk/Y2Nj9eKLL+rkyZPOsyNpaWnq16+fHnzwQUmS3W7Xvn37Sv3RfanPD58Fz0XnIsCNmjZtKh8fH23dutU57uTJk9q3b58kae/evTpx4oRefPFFde3aVTfddFOpjkWSVKtWLZ0+fbpUZ56dO3eWatOiRQtt27at1LhfD1+Ly33Bf/fdd4qKitIPP/ygZs2aqWbNmoqKipKvr2+Z14GqJyIiQlu3btWBAwf0008/XfKPneDgYI0bN05jxoxRSkqKsrKytGPHDi1YsEApKSmSpJEjR+rnn3/WgAEDtG3bNmVlZemTTz7RkCFDrhpsYa0bbrhBbdq00dKlSxUbGytJuuOOO7Rjxw7t27fPGUabNWumtWvXatOmTdqzZ48effRRHT16tNSyLvX54bPguQiegBsFBQUpPj5eTz75pNavX69vv/1WcXFx8vJy/NNs1KiRfH19tWDBAmVnZ2v16tV67rnnSi2jU6dOCggI0J/+9CdlZWVp2bJlSk5OLtVm1KhRevvtt5WSkqLvv/9ezz//vHbt2nVRz/eriYiI0MaNG3Xo0CHFxMQoMTFREyZM0KZNm5SQkKDMzExJ0ocffqiEhITrf2NQpYwbN07e3t5q1aqV86j+pTz33HOaNGmSkpKS1LJlS/Xu3Vtr1qxRkyZNJEn169dXWlqaSkpK1LNnT7Vu3VqJiYmqUaOG898UPEe3bt1UUlLiDJ5hYWFq1aqV6tat67zc6JlnntEtt9yiXr16KTY2VnXr1r3oQReX+vzwWfBgLu/q9BvQqx1VwenTp82DDz5oAgICTJ06dcxLL71UqpfmsmXLTEREhPHz8zOdO3c2q1evNpLMN99841zGypUrTVRUlPH39zd9+vQxb7zxhvn1P+9p06aZmjVrmqCgIPPwww+b0aNHm9tuu805ffDgwaZfv36l5nn88cdNt27dnMObN282bdq0MX5+fkaSs8avvvrK3HXXXcbf399IMr/73e/M9OnTnfM1btzYvPzyy9f9HhUVFV33vHCzM2eMmTPHmIQEx88zZ9xdEVyJ/V0llSWvETwBV/GgL+Bu3bqZhIQE8/jjj5saNWqY2rVrm5YtW5r777/fxMXFmaCgINO0aVPz4YcfOudJTU01HTp0ML6+vqZu3bpmwoQJpri42BjjCKmSSr3279/vvA3OunXrTPv27Y2/v7/p3Lmz2bt3b6l6Vq1aZdq1a2f8/PxMkyZNzJQpU5zLNsYYSebVV181ffv2NQEBAWby5MmWvE8oZ2fOGNOunTFeXsb4+Dh+tmtHGKms2N9VlscFz1deecU0btzY+Pn5mY4dO5qtW7de03wET1RYHvYFfPvttxs/Pz+TkJBgPvroIxMbG2skmQ4dOpg33njD7Nu3zzz22GPmxhtvNAUFBeaHH34wAQEBZsSIEWbPnj1m5cqVpmbNms4AeOrUKdO5c2czbNgw5z09z5075wyenTp1MqmpqWb37t2ma9eupkuXLs5aNm7caEJCQkxycrLJysoyn376qYmIiDBTpkxxtpFkateubd555x2TlZVl/vWvf1n9lqE8zJnj+OxL/355eTnGo/Jhf1dZHhU8ly9fbnx9fc0777xjdu/ebYYNG2Zq1Khhjh49etV5CZ6osDzsC/j22283oaGhJiwszAQEBDiPNj700EPONkeOHDGSzObNm82f/vQn06JFC2O3253TFy5caIKCgkxJSYkx5tI3bb7wiOd5a9asMZLM2bNnjTHGdO/e3bzwwgul5luyZImpV6+ec1iSSUxMLLfth5skJDj+8Lrw34GPj2M8Kh/2d5VVlrzm8its58yZo2HDhmnIkCFq1aqVFi1apICAAL3zzjuuXjXgPtnZ0gX3w5TkGM7Odks53t7eGjhwoE6cOKGCggLt2LFDderUUevWrZ1t6tSpI0k6duyY9uzZo86dO5fqfBQTE6P8/Hz98MMPV11fmzZtnL+fv2fe+d746enpmjZtmoKCgpyv84+7O3PmjHM+7vtZCURGSr/uQVxS4hiPyof9jWvg0ptbFRUVafv27Xrqqaec47y8vNSjRw9t3rz5ovaFhYUqLCx0Dufl5bmyPMB1PPAL+FL36Lxw3PmQebX7dpZ1Xb9ebn5+vqZOnap77rnnovnOP+VI4r6flcLw4dKSJVJ6uuMPr5ISqW1bx3hUPuxvXAOXBs+ffvpJJSUlziMp59WpU0d79+69qH1SUpKmTp3qypIAa1TwL+CWLVtqxYoVMsY4g2NaWpqCg4Odj/O8lpt+X8ott9yijIwMRUVFlWvN8ED+/lJamrRokeNof2Sk49+Av7+7K4MrsL9xDTzqdv5PPfWUxo4d6xzOy8tTeHi4GysCrlMF/wIeMWKE5s6dq1GjRikhIUEZGRmaPHmyxo4d67wH3oU3bQ4KClJYWNg1LfvZZ59Vnz591KhRI/33f/+3vLy8lJ6erm+//VbPP/+8KzcL7uDvL40Z4+4qYBX2N67CpcGzZs2a8vb2vugpA0ePHlXdunUvau/n5+d85i5Q4VXgL+AGDRroww8/1JNPPqno6GiFhYUpPj5ezzzzjLPNuHHjNHjwYLVq1Upnz57V/v37r2nZvXr10gcffKBp06ZpxowZzuc0Dx061FWbAwDwEDZjfvWQ53LWqVMndezYUQsWLJDkuM6rUaNGSkhI0MSJE684b15enkJDQ5Wbm6uQkBBXlglUXGfPVtgjqwCAiq8sec3lp9rHjh2rwYMH69Zbb1XHjh01d+5cFRQUaMiQIa5eNVD5nT0rxcSUvpZ0yRLHaX7CJwDAw7j8dkr/8z//o1mzZunZZ59V27ZttXPnTn388ccXdTgCcB0WLXKETrtdKi52/ExPd4wHAJQbm82mVatWubuMCs+SzkUJCQlKSEiwYlVA1XL+fqEX3gLJjfcLBYDK6siRI7rhhhvcXUaF51G92gGUkQfeLxQAKpuioqJLdoouTyUlJbLZbM47h1RWlXvrgMpu+HApOlry8pJ8fBw/K9D9QgHAE8XGxiohIUGJiYmqWbOmevXqVepUe5cuXTRhwoRS8xw/flw+Pj7auHGjJMdDccaNG6cGDRooMDBQnTp1UmpqqrN9cnKyatSoodWrV6tVq1by8/NTTk6OVZvoNgRPoCI7f7/QWbOkRx91/PzySzoWAcBvlJKSIl9fX6WlpWnRr66bHzhwoJYvX64Lbwz07rvvqn79+urataskx2WGmzdv1vLly7Vr1y7de++96t27t77//nvnPGfOnNGMGTP01ltvaffu3apdu7Y1G+dGLr+d0m/B7ZQAAIDVYmNjlZeXpx07djjH2Ww2rVy5Uv3799fx48dVv359rV+/3hk0u3TpojvuuEMvvviicnJyFBkZqZycHNWvX9+5jB49eqhjx4564YUXlJycrCFDhmjnzp2Kjo62fBvLU1nyGkc8AQC4jIiICM2dO9fdZcAN2rdvf9lptWrVUs+ePbV06VJJ0v79+7V582YNHDhQkvTPf/5TJSUlat68uYKCgpyvDRs2KCsry7kcX19ftWnTxrUb4mHoXAQAgIXi4uJ06tQpbs3j4QIDA684feDAgRo9erQWLFigZcuWqXXr1mrdurUkKT8/X97e3tq+fbu8vb1LzRcUFOT83d/fXzabrfyL92AETwAAgDLq16+fHnnkEX388cdatmyZBg0a5JzWrl07lZSU6NixY85T8XDgVDsAoMo633s5ISFBoaGhqlmzpiZNmqTLdX+YM2eOWrdurcDAQIWHh2vEiBHKz893Tj/fU/mTTz5Ry5YtFRQUpN69e+vIkSOSpClTpiglJUXvv/++bDabbDZbqZ7OqDgCAwPVv39/TZo0SXv27NGAAQOc05o3b66BAwdq0KBB+vvf/679+/frq6++UlJSktasWePGqt2P4AkAqNJSUlJUrVo1ffXVV5o3b57mzJmjt95665Jtvby8NH/+fO3evVspKSlav369xo8fX6rNmTNnNGvWLC1ZskQbN25UTk6Oxo0bJ0kaN26c7rvvPmcYPXLkiLp06eLybYRrDBw4UOnp6eratasaNWpUatrixYs1aNAgPfHEE2rRooX69++vbdu2XdSuqqFXOwCgyoqNjdWxY8e0e/du57V2EydO1OrVq/Xdd98pIiJCiYmJSkxMvOT8f/vb3zR8+HD99NNPkuTsqZyZmammTZtKkl599VVNmzZNP/74oySu8XSrs2cdjxTOznY8aGP4cG4/Vw7Kkte4xhMAUKXddtttpTp4dO7cWbNnz1bJr58KJmndunVKSkrS3r17lZeXp3PnzumXX37RmTNnFBAQIEkKCAhwhk5Jqlevno4dO+b6DcGVnT0rxcRI6emORwuXlEhLljjuhUz4tAyn2gEAuAYHDhxQnz591KZNG61YsULbt2/XwoULJTkeqXiej49PqflsNttlrxmFhRYtcoROu10qLnb8TE93jIdlOOIJAKjStm7dWmp4y5Ytatas2UW3wdm+fbvsdrtmz57tfJ72e++9V+b1+fr6XvJoKlwsO9txpNNu//c4b2/HeFiGI54AgCotJydHY8eOVUZGhv76179qwYIFevzxxy9qFxUVpeLiYi1YsEDZ2dlasmTJRY9SvBYRERHatWuXMjIy9NNPP6m4uLg8NqNKKCws1OjRo1W7dm1Vr15dt99+u7Zt2+acvnv3bvXp00chISEKDg5W165d/33D9shIvXXunFpKqi7pJkmvnjvnuNbz/02YMEHNmzdXQECAIiMjNWnSpFL7Z8qUKWrbtq2WLFmiiIgIhYaG6v7779fp06eteQMqAYInAKBKGzRokM6ePauOHTtq5MiRevzxx/XII49c1C46Olpz5szRjBkzdPPNN2vp0qVKSkoq8/qGDRumFi1a6NZbb1WtWrWUlpZWHptRJYwfP14rVqxQSkqKduzYoaioKPXq1Us///yzDh06pDvuuEN+fn5av369tm/frocffljnzp2TJC2tUUPPentrus2mPdWq6QWbTZO8vJRywQ3dg4ODlZycrO+++07z5s3Tm2++qZdffrlUDVlZWVq1apU++OADffDBB9qwYYNefPFFS9+Hioxe7QCAyukaejDHxsaqbdu2PBazAigoKNANN9yg5ORkPfDAA5Kk4uJi550HTp48qeXLlysjI+Oi62wlxxHr5yZN0oCff3Z+Jp4/dUofrl2rTZs2XXKds2bN0vLly/X1119LchzxnDlzpn788UcFBwdLcoThjRs3asuWLS7acs9Hr3YAQNVGD+ZKJysrS8XFxYqJiXGO8/HxUceOHbVnzx79+OOP6tq16yVDZ0FBgbKyshT/2GMa5vXvk73nzp1TaGioc/jdd9/V/PnzlZWVpfz8fJ07d+6iIBUREeEMnRJ3LSgrgicAoPK5sAfz+c4k53swjxnj3trgEv5X+IPi/NOl3nzzTXXq1KnUtPOdyDZv3qyBAwdq6tSp6tWrl0JDQ7V8+XLNnj27VPtL3bXAfmGHJVwRwRMAUPlcYw9mHldZcTRt2lS+vr5KS0tT48aNJTlOtW/btk2JiYkqKChQSkqKiouLLwqHderUUf369ZWdna2BAwdecvmbNm1S48aN9fTTTzvH/etf/3LdBlVRBE8AQOUTGek4vX6hkpJSPZhRsQQGBuqxxx7Tk08+qbCwMDVq1EgvvfSSzpw5o/j4eNntdi1YsED333+/nnrqKYWGhmrLli3q2LGjWrRooalTp2r06NEKDQ1V7969VVhYqK+//lonT57U2LFj1axZM+Xk5Gj58uXq0KGD1qxZo5UrV7p7sysderUDACqf4cOl6GjJy0vy8XH8bNvWMR4V1osvvqj/+q//0kMPPaRbbrlFmZmZ+uSTT3TDDTfoxhtv1Pr165Wfn69u3bqpffv2evPNN51HP4cOHaq33npLixcvVuvWrdWtWzclJyerSZMmkqT//M//1JgxY5SQkKC2bdtq06ZNmjRpkjs3t1KiVzsAoHLiudwVB/uqQqNXOwAA/v50JKoIuANBlcKpdgAA4D48Q71KIXgCAAD3OX8HggvxDPVKi+AJAADchzsQVCkETwAA4D7cgaBKoXMRAABwH39/R0cierVXCQRPAADgXtyBoMrgVDsAAAAsQfAEAACAJQieAAAAsATBEwAAAJYgeAIAAMASBE8AAABYguAJAAAASxA8AQAAYAmCJwAAACxB8AQAAIAlCJ4AAACwBMETAAAAliB4AgAAwBIETwAAAFiC4AkAAABLEDwBAABgCYInAAAALEHwBAAAgCUIngAAALAEwRMAAACWIHgCAADAEgRPAAAAWILgCQAAAEsQPAEAAGAJgicAAAAsQfAEAACAJQieAAAAsATBEwAAAJYgeAIAAMASBE8AAABYguAJAAAASxA8AQAAYAmCJwAAACxB8AQAAIAlCJ4AAACwBMETAAAAliB4AgAAwBIuC57Tp09Xly5dFBAQoBo1arhqNQAAAKggXBY8i4qKdO+99+qxxx5z1SoAAABQgVRz1YKnTp0qSUpOTnbVKgAAAFCBuCx4Xo/CwkIVFhY6h/Py8txYDQAAAMqTR3UuSkpKUmhoqPMVHh7u7pIAAABQTsoUPCdOnCibzXbF1969e6+7mKeeekq5ubnO18GDB697WQAAAPAsZTrV/sQTTyguLu6KbSIjI6+7GD8/P/n5+V33/AAAAPBcZQqetWrVUq1atVxVCwAAACoxl3UuysnJ0c8//6ycnByVlJRo586dkqSoqCgFBQW5arUAAADwUC4Lns8++6xSUlKcw+3atZMkff7554qNjXXVagEAAOChbMYY4+4iLicvL0+hoaHKzc1VSEiIu8sBAADAr5Qlr3nU7ZQAAABQeRE8AQAAYAmCJwAAACxB8AQAAIAlCJ4AAACwBMETAAAAliB4AgAAwBIET+AyYmNjlZiYeMlpcXFx6t+/v6X1AABQ0bnsyUVAZTZv3jx58LMXAADwSARP4DqEhoa6uwQAACocTrUD12jNmjUKDQ3V0qVLLzrVHhsbq9GjR2v8+PEKCwtT3bp1NWXKlFLz7927V7fffruqV6+uVq1aad26dbLZbFq1apWl2wEAgLsQPIFrsGzZMg0YMEBLly7VwIEDL9kmJSVFgYGB2rp1q1566SVNmzZNa9eulSSVlJSof//+CggI0NatW/XGG2/o6aeftnITAABwO061A1excOFCPf300/rHP/6hbt26XbZdmzZtNHnyZElSs2bN9Morr+izzz7TXXfdpbVr1yorK0upqamqW7euJGn69Om66667LNkGAAA8AcETuIK//e1vOnbsmNLS0tShQ4crtm3Tpk2p4Xr16unYsWOSpIyMDIWHhztDpyR17Nix/AsGAMCDcaoduIJ27dqpVq1aeuedd67ai93Hx6fUsM1mk91ud2V5AABUKARP4AqaNm2qzz//XO+//75GjRp13ctp0aKFDh48qKNHjzrHbdu2rTxKBACgwiB4AlfRvHlzff7551qxYsVlbyh/NXfddZeaNm2qwYMHa9euXUpLS9MzzzwjyXFkFACAqoBrPIFr0KJFC61fv16xsbHy9vYu8/ze3t5atWqVhg4dqg4dOigyMlIzZ85U3759Vb16dRdUDACA5+GIJyqkgoICDRo0SEFBQapXr55mz55d6hGXl7o/Zo0aNZScnOwYOHtWB599Vvc1a6Ya/v4KCwtTv379dODAAWf71NRU3XzzzWrZsqWqV6+uP/7xj5o8ebJmz56t5ORkzZ07VzabTX//+99ls9n0xhtvKDo6Wps3b5YkrVq16t/rk3TTTTfpyy+/VGFhofbs2aMbbrhBkhQVFeWidwkAAM9C8ESF9OSTT2rDhg16//339emnnyo1NVU7duy4tpnPnlVxly7q9dxzCs7K0heFhUqrW1dB/v7q3bu3ioqKJElLly7Vs88+q+nTp2vPnj164YUXNGnSJKWkpJRa3NNPP61x48Zp586dat68uQYMGKBz585dtNqVK1dq7dq1OnDggNatW6dHHnlEMTExatq06W9+PwAAqAg41Y4KJz8/X2+//bb+8pe/qHv37pIcN29v2LDhtS1g0SK9m54uu6S3jJFNkjIytHjIENVYvVqpqanq2bOn8+jmPffcI0lq0qSJvvvuO73++usaPHiwc3Hjxo3TH/7wB0nS1KlT9bvf/U6ZmZm66aabSq329OnTmjBhgnJyclSzZk316NFDs2fP/q1vBwAAFQbBExVOVlaWioqK1KlTJ+e4sLAwtWjR4toWkJ2tdJtNmcYo+Pw4u116+mn9cu6csrKyVFBQoKysLMXHx2vYsGHOWc+dO3fRc9ovvH9nvXr1JEnHjh27KHgOGjRIgwYNuvYNBQCgkiF4olKy2WwX3XezuLjY8UtkpPLtdrWXtPTfM0jjxkkPP6xatWopPz9fkvTmm2+WCriSLupcdOH9O8/3UOf+nQAAXIxrPFHhNG3aVD4+Ptq6datz3MmTJ7Vv3z7ncK1atXTkyBHn8Pfff68zZ844BoYP1y3h4fpeUu1q1RTl5aWodu0UNWmSoqKiFBoaqjp16qh+/frKzs5WVFRUqVeTJk2s2lQAACoVjniiwgkKClJ8fLyefPJJ3Xjjjapdu7aefvppeXn9+++o3//+93rllVfUuXNnlZSUaMKECf8+Munvr4HffKOZLVuqn6+vpv3xj2o4YoT+tXWr/v73v2v8+PFq2LChpk6dqtGjRys0NFS9e/dWYWGhvv76a508eVJjx45109YDAFBxccQTFdLMmTPVtWtX9e3bVz169NDtt9+u9u3bO6fPnj1b4eHh6tq1qx544AGNGzdOAQEBzukBN96ojbt2qVH37rpn+XK1bNdO8fHx+uWXXxQSEiJJGjp0qN566y0tXrxYrVu3Vrdu3ZScnMwRTwAArpPNXO0B1G6Ul5en0NBQ5ebmOsMAKrmzZ6VFi6TsbCkyUho+XPL3v6ZZY2Nj1bZtW82dO9e1NQIAAKey5DVOtcNznD0rxcRI6emSt7dUUiItWSKlpV1z+AQAAJ6LU+3wHIsWOUKn3S4VFzt+pqc7xgMAgAqPI57wHNnZjiOdF96KyNvbMf4apKamuqYuAABQLjjiCc8RGek4vX6hkhLHeAAAUOERPOE5hg+XoqMlLy/Jx8fxs21bx3gAAFDhcaodnsPf39GR6Dp7tQMAAM9G8IRn8feXxoxxdxUAAMAFONUOAAAASxA8AQAAYAmCJwAAACxB8AQAAIAlCJ4AAACwBMETAAAAliB4AgAAwBIETwAAAFiC4AkAAABLEDwBAABgCYInAAAALEHwBAAAgCUIngAAALAEwRMAAACWIHgCAADAEgRPAAAAWILgCQAAAEsQPAEAAGAJgicAAAAsQfAEAACAJQieAAAAsATBEwAAAJYgeAIAAMASBE8AAABYguAJAAAASxA8AQAAYAmCJwAAACxB8AQAAIAlCJ4AAACwBMETAAAAliB4AgAAwBIETwAAAFjCZcHzwIEDio+PV5MmTeTv76+mTZtq8uTJKioqctUqAQAA4MGquWrBe/fuld1u1+uvv66oqCh9++23GjZsmAoKCjRr1ixXrRYAAAAeymaMMVatbObMmXrttdeUnZ19Te3z8vIUGhqq3NxchYSEuLg6AAAAlFVZ8prLjnheSm5ursLCwi47vbCwUIWFhc7hvLw8K8oCAACABSzrXJSZmakFCxbo0UcfvWybpKQkhYaGOl/h4eFWlQcAAAAXK3PwnDhxomw22xVfe/fuLTXPoUOH1Lt3b917770aNmzYZZf91FNPKTc31/k6ePBg2bcIAAAAHqnM13geP35cJ06cuGKbyMhI+fr6SpIOHz6s2NhY3XbbbUpOTpaX17VnXa7xBAAA8GwuvcazVq1aqlWr1jW1PXTokO688061b99eixcvLlPoBAAAQOXiss5Fhw4dUmxsrBo3bqxZs2bp+PHjzml169Z11WoBAADgoVwWPNeuXavMzExlZmaqYcOGpaZZeAcnAAAAeAiXnfuOi4uTMeaSLwAAAFQ9XHQJAAAASxA8AQAAYAmCJwAAACxB8AQAAIAlCJ4AAACwBMETAAAAliB4AgAAwBIETwAAAFiC4AkAAABLEDwBAABgCYInAAAALEHwBAAAgCUIngAAALAEwRMAAACWIHgCAADAEgRPAAAAWILgCQAAAEsQPAEAAGAJgicAAAAsQfAEAACAJQieAAAAsATBEwAAAJYgeAIAAMASBE8AAABYguAJAAAASxA8AQAAYAmCJwAAACxB8AQAAIAlCJ4AAACwBMETAAAAlqjm7gKuxBgjScrLy3NzJQAAALiU8zntfG67Eo8OnqdPn5YkhYeHu7kSAAAAXMnp06cVGhp6xTY2cy3x1E3sdrsOHz6s4OBg2Ww2d5djmby8PIWHh+vgwYMKCQlxdzlwMfZ31cL+rlrY31VLVd3fxhidPn1a9evXl5fXla/i9Ogjnl5eXmrYsKG7y3CbkJCQKvXBrerY31UL+7tqYX9XLVVxf1/tSOd5dC4CAACAJQieAAAAsATB0wP5+flp8uTJ8vPzc3cpsAD7u2phf1ct7O+qhf19dR7duQgAAACVB0c8AQAAYAmCJwAAACxB8AQAAIAlCJ4AAACwBMETAAAAliB4ergDBw4oPj5eTZo0kb+/v5o2barJkyerqKjI3aXBBaZPn64uXbooICBANWrUcHc5cIGFCxcqIiJC1atXV6dOnfTVV1+5uyS4wMaNG9W3b1/Vr19fNptNq1atcndJcKGkpCR16NBBwcHBql27tvr376+MjAx3l+WRCJ4ebu/evbLb7Xr99de1e/duvfzyy1q0aJH+9Kc/ubs0uEBRUZHuvfdePfbYY+4uBS7w7rvvauzYsZo8ebJ27Nih6Oho9erVS8eOHXN3aShnBQUFio6O1sKFC91dCiywYcMGjRw5Ulu2bNHatWtVXFysnj17qqCgwN2leRzu41kBzZw5U6+99pqys7PdXQpcJDk5WYmJiTp16pS7S0E56tSpkzp06KBXXnlFkmS32xUeHq5Ro0Zp4sSJbq4OrmKz2bRy5Ur179/f3aXAIsePH1ft2rW1YcMG3XHHHe4ux6NwxLMCys3NVVhYmLvLAFAGRUVF2r59u3r06OEc5+XlpR49emjz5s1urAxAecvNzZUk/q++BIJnBZOZmakFCxbo0UcfdXcpAMrgp59+UklJierUqVNqfJ06dfTjjz+6qSoA5c1utysxMVExMTG6+eab3V2OxyF4usnEiRNls9mu+Nq7d2+peQ4dOqTevXvr3nvv1bBhw9xUOcrqevY1AKBiGjlypL799lstX77c3aV4pGruLqCqeuKJJxQXF3fFNpGRkc7fDx8+rDvvvFNdunTRG2+84eLqUJ7Kuq9ROdWsWVPe3t46evRoqfFHjx5V3bp13VQVgPKUkJCgDz74QBs3blTDhg3dXY5HIni6Sa1atVSrVq1ranvo0CHdeeedat++vRYvXiwvLw5UVyRl2deovHx9fdW+fXt99tlnzk4mdrtdn332mRISEtxbHIDfxBijUaNGaeXKlUpNTVWTJk3cXZLHInh6uEOHDik2NlaNGzfWrFmzdPz4cec0jpJUPjk5Ofr555+Vk5OjkpIS7dy5U5IUFRWloKAg9xaH32zs2LEaPHiwbr31VnXs2FFz585VQUGBhgwZ4u7SUM7y8/OVmZnpHN6/f7927typsLAwNWrUyI2VwRVGjhypZcuW6f3331dwcLDzuu3Q0FD5+/u7uTrPwu2UPFxycvJl/1Ni11U+cXFxSklJuWj8559/rtjYWOsLQrl75ZVXNHPmTP34449q27at5s+fr06dOrm7LJSz1NRU3XnnnReNHzx4sJKTk60vCC5ls9kuOX7x4sVXvdSqqiF4AgAAwBJcLAgAAABLEDwBAABgCYInAAAALEHwBAAAgCUIngAAALAEwRMAAACWIHgCAADAEgRPAAAAWILgCQAAAEsQPAEAAGAJgicAAAAs8X/maokPUu6nDwAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "#plotting reduced order embeddings in a 2-D space\n",
        "\n",
        "plt.figure(figsize=(8,5))\n",
        "plt.scatter(reduced_w2v[:,0],reduced_w2v[:,1], s = 12, color = 'red')\n",
        "plt.xlim([-2.5,2.5])\n",
        "plt.ylim([-2.5,2.5])\n",
        "x, y = reduced_w2v[:,0] , reduced_w2v[:,1]\n",
        "for i in range(len(x)):\n",
        "    plt.annotate(words[i],xy=(x[i], y[i]),xytext=(x[i]+0.05,y[i]+0.05))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "O81OEqidSYyc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "867efe65-5699-467d-e005-1f6cde146222"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[('indian', 0.6967039704322815),\n",
              " ('usa', 0.6836211085319519),\n",
              " ('pakistan', 0.681516706943512),\n",
              " ('chennai', 0.6675503253936768),\n",
              " ('america', 0.6589399576187134),\n",
              " ('sri_lanka', 0.64982008934021),\n",
              " ('canada', 0.6490967869758606),\n",
              " ('australia', 0.6368584036827087),\n",
              " ('mexico', 0.6239137649536133),\n",
              " ('uk', 0.6221641898155212)]"
            ]
          },
          "metadata": {},
          "execution_count": 121
        }
      ],
      "source": [
        "model.most_similar('india')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sxrpWYW_RgoT"
      },
      "source": [
        "Analogy test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XPWJ836PSnGn"
      },
      "outputs": [],
      "source": [
        "def analogy(x1, x2, y1): #defining analogy function\n",
        "    result = model.most_similar(positive=[y1, x2], negative=[x1], topn = 5)\n",
        "    return result"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WG8rZoybZF2M",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "32f191f0-8784-4ff4-c9ca-91ff3c5ed84d"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[('queen', 0.7118193507194519),\n",
              " ('monarch', 0.6189674139022827),\n",
              " ('princess', 0.5902431011199951),\n",
              " ('crown_prince', 0.5499460697174072),\n",
              " ('prince', 0.5377321839332581)]"
            ]
          },
          "metadata": {},
          "execution_count": 123
        }
      ],
      "source": [
        "analogy('man', 'king', 'woman')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "V15ouY7tSpzp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9c78ec24-3620-4a98-ec17-33812d09560e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EVALUATION: Precision at 5 for the analogy test with Google skip-gram model is 0.0034\n"
          ]
        }
      ],
      "source": [
        "def analogy_score(analogy_dataset):\n",
        "\n",
        "    \"\"\"\n",
        "    The top5 analogous words calculated for each set of words for Google's\n",
        "    word2vec and compared with an existing dataset to calculate if the word\n",
        "    is in the first 5 predictions.\n",
        "\n",
        "    \"\"\"\n",
        "    correct = 0\n",
        "    total = 0\n",
        "\n",
        "    for a, b, c, d in analogy_dataset:\n",
        "        # Convert words to lowercase\n",
        "        a, b, c, d = a.lower(), b.lower(), c.lower(), d.lower()\n",
        "\n",
        "        words_scores = analogy(c, a, b)\n",
        "\n",
        "        predicted_words = [item[0] for item in words_scores]\n",
        "\n",
        "        if d in predicted_words:\n",
        "            correct += 1\n",
        "\n",
        "        total += 1\n",
        "\n",
        "    precision_at_5 = correct / total if total > 0 else 0\n",
        "    return precision_at_5\n",
        "\n",
        "precision_at_5_Google = analogy_score(sampled_analogy_dataset)\n",
        "print(\"EVALUATION: Precision at 5 for the analogy test with Google skip-gram model is\", precision_at_5_Google)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DiUwTQO0SsQ1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 249
        },
        "outputId": "5d2d5b93-58ea-4c3f-f966-678689230849"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-125-dc6afa8aecd7>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprecision_at_5_Google\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0manalogy_score\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msampled_analogy_dataset\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"EVALUATION: Precision at 5 for the analogy test with Google skip-gram model is\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprecision_at_5_Google\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-124-c049a1bf8e3f>\u001b[0m in \u001b[0;36manalogy_score\u001b[0;34m(analogy_dataset)\u001b[0m\n\u001b[1;32m     14\u001b[0m         \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m         \u001b[0mwords_scores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0manalogy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m         \u001b[0mpredicted_words\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mitem\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mwords_scores\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-122-6cd915c9e937>\u001b[0m in \u001b[0;36manalogy\u001b[0;34m(x1, x2, y1)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0manalogy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m#defining analogy function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmost_similar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpositive\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0my1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnegative\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtopn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/gensim/models/keyedvectors.py\u001b[0m in \u001b[0;36mmost_similar\u001b[0;34m(self, positive, negative, topn, clip_start, clip_end, restrict_vocab, indexer)\u001b[0m\n\u001b[1;32m    847\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mindexer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmost_similar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtopn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    848\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 849\u001b[0;31m         \u001b[0mdists\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvectors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mclip_start\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mclip_end\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmean\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnorms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mclip_start\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mclip_end\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    850\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mtopn\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    851\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mdists\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/numpy/core/overrides.py\u001b[0m in \u001b[0;36mdot\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "precision_at_5_Google = analogy_score(sampled_analogy_dataset)\n",
        "print(\"EVALUATION: Precision at 5 for the analogy test with Google skip-gram model is\", precision_at_5_Google)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O0zdLI6uR2DH"
      },
      "source": [
        "### Submission Instructions\n",
        "\n",
        "Mentioned at the top of the notebook."
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "sxZ6Q_zJH9K7"
      ],
      "mount_file_id": "1hRzngzgyTOiVmW_KXDasa949p19SsltC",
      "authorship_tag": "ABX9TyMI64m+zVsGrGBs/HvrS7P0",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "a52261af048543b0a30384b4c61e9a76": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_4ab6a87cf5d842c4b149d062c622d566",
              "IPY_MODEL_30151c2cc5994d92a9153405e96f98f7",
              "IPY_MODEL_188c8a11f2fa4cee8b75593b697926e7"
            ],
            "layout": "IPY_MODEL_abf35d5e2723471887ac6a38a08fc0bd"
          }
        },
        "4ab6a87cf5d842c4b149d062c622d566": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_9526f2e1120b436a824c2b0f9422b25e",
            "placeholder": "​",
            "style": "IPY_MODEL_e5af380e4151413c82c4834149bc2377",
            "value": "100%"
          }
        },
        "30151c2cc5994d92a9153405e96f98f7": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_00e35e994b5248b5a6b6e8f9c6dc7c87",
            "max": 3644258522,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_d34bd98952694e6ebed999a714de5d16",
            "value": 3644258522
          }
        },
        "188c8a11f2fa4cee8b75593b697926e7": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_37076c236e2149ce976e874cad08f8f8",
            "placeholder": "​",
            "style": "IPY_MODEL_093ec71be50446ff9d6fefcb952d758f",
            "value": " 3.39G/3.39G [00:53&lt;00:00, 124MB/s]"
          }
        },
        "abf35d5e2723471887ac6a38a08fc0bd": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "9526f2e1120b436a824c2b0f9422b25e": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "e5af380e4151413c82c4834149bc2377": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "00e35e994b5248b5a6b6e8f9c6dc7c87": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "d34bd98952694e6ebed999a714de5d16": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "37076c236e2149ce976e874cad08f8f8": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "093ec71be50446ff9d6fefcb952d758f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}