Sentiment_analysis_simplernn.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Sentiment_analysis_simplernn.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UngCqaEIMz8b",
        "outputId": "adf971be-18da-4006-dc2b-e15e27faa68d"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GKbyIhfvltKz"
      },
      "source": [
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "# Modules for data manipulation\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import re\n",
        "\n",
        "# Modules for visualization\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sb\n",
        "\n",
        "# Tools for preprocessing input data\n",
        "from bs4 import BeautifulSoup\n",
        "from nltk import word_tokenize\n",
        "from nltk.corpus import stopwords\n",
        "from nltk.stem import WordNetLemmatizer\n",
        "\n",
        "# Tools for creating ngrams and vectorizing input data\n",
        "from gensim.models import Word2Vec, Phrases\n",
        "\n",
        "# Tools for building a model\n",
        "from sklearn.model_selection import train_test_split\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense, LSTM, Dropout, Bidirectional\n",
        "from keras.layers.embeddings import Embedding\n",
        "from keras.preprocessing.sequence import pad_sequences\n",
        "\n",
        "# Tools for assessing the quality of model prediction\n",
        "from sklearn.metrics import accuracy_score, confusion_matrix"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2GecYSRFoRkg"
      },
      "source": [
        "# 'content/drive/MyDrive/IMDB Sentiment analysis/data'\n"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nGg5izdPq08-"
      },
      "source": [
        "SMALL_SIZE = 12\n",
        "MEDIUM_SIZE = 14\n",
        "BIG_SIZE = 16\n",
        "LARGE_SIZE = 20\n",
        "\n",
        "params = {\n",
        "    'figure.figsize': (16, 8),\n",
        "    'font.size': SMALL_SIZE,\n",
        "    'xtick.labelsize': MEDIUM_SIZE,\n",
        "    'ytick.labelsize': MEDIUM_SIZE,\n",
        "    'legend.fontsize': BIG_SIZE,\n",
        "    'figure.titlesize': LARGE_SIZE,\n",
        "    'axes.titlesize': MEDIUM_SIZE,\n",
        "    'axes.labelsize': BIG_SIZE\n",
        "}\n",
        "plt.rcParams.update(params)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 203
        },
        "id": "nBhgaQodObT5",
        "outputId": "4bc02c2f-b33f-442a-e7f1-5de1a79d3b13"
      },
      "source": [
        "data = pd.read_csv('/content/drive/MyDrive/IMDB Sentiment analysis/data/IMDB Dataset.csv')\n",
        "data.head()"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>review</th>\n",
              "      <th>sentiment</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>One of the other reviewers has mentioned that ...</td>\n",
              "      <td>positive</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>A wonderful little production. &lt;br /&gt;&lt;br /&gt;The...</td>\n",
              "      <td>positive</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>I thought this was a wonderful way to spend ti...</td>\n",
              "      <td>positive</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>Basically there's a family where a little boy ...</td>\n",
              "      <td>negative</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>Petter Mattei's \"Love in the Time of Money\" is...</td>\n",
              "      <td>positive</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                              review sentiment\n",
              "0  One of the other reviewers has mentioned that ...  positive\n",
              "1  A wonderful little production. <br /><br />The...  positive\n",
              "2  I thought this was a wonderful way to spend ti...  positive\n",
              "3  Basically there's a family where a little boy ...  negative\n",
              "4  Petter Mattei's \"Love in the Time of Money\" is...  positive"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3HcZQgrSP5PB"
      },
      "source": [
        "data['sentiment'] = data['sentiment'].apply(lambda x:1 if x=='negative' else 0)"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 203
        },
        "id": "RjdsfiLjSnmM",
        "outputId": "1c2bb792-2fe3-43a8-cf3b-f58581cb08a9"
      },
      "source": [
        "data.head()"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>review</th>\n",
              "      <th>sentiment</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>One of the other reviewers has mentioned that ...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>A wonderful little production. &lt;br /&gt;&lt;br /&gt;The...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>I thought this was a wonderful way to spend ti...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>Basically there's a family where a little boy ...</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>Petter Mattei's \"Love in the Time of Money\" is...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                              review  sentiment\n",
              "0  One of the other reviewers has mentioned that ...          0\n",
              "1  A wonderful little production. <br /><br />The...          0\n",
              "2  I thought this was a wonderful way to spend ti...          0\n",
              "3  Basically there's a family where a little boy ...          1\n",
              "4  Petter Mattei's \"Love in the Time of Money\" is...          0"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9uxt9BdHPD9s",
        "outputId": "81307dc5-eb3c-4c0b-c31b-0273ebb91691"
      },
      "source": [
        "data.shape"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(50000, 2)"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dA1INnvaPJ9a"
      },
      "source": [
        "train_data = data[0:40000]\n",
        "test_data = data[40000:]"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vd_l8IptVO1G",
        "outputId": "bb3d69b5-9770-4872-be2e-8fd069d6ecbd"
      },
      "source": [
        "y_actual_pred = test_data['sentiment']\n",
        "y_actual_pred.shape"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(10000,)"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 203
        },
        "id": "K_GZX0LvVuJ7",
        "outputId": "e37c7ebf-6f97-4495-de77-c5a3cd9890f1"
      },
      "source": [
        "test_data = test_data.drop(columns='sentiment')\n",
        "test_data.head()"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>review</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>40000</th>\n",
              "      <td>First off I want to say that I lean liberal on...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>40001</th>\n",
              "      <td>I was excited to see a sitcom that would hopef...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>40002</th>\n",
              "      <td>When you look at the cover and read stuff abou...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>40003</th>\n",
              "      <td>Like many others, I counted on the appearance ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>40004</th>\n",
              "      <td>This movie was on t.v the other day, and I did...</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                                  review\n",
              "40000  First off I want to say that I lean liberal on...\n",
              "40001  I was excited to see a sitcom that would hopef...\n",
              "40002  When you look at the cover and read stuff abou...\n",
              "40003  Like many others, I counted on the appearance ...\n",
              "40004  This movie was on t.v the other day, and I did..."
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hQpbynZkPhsM",
        "outputId": "1138cee0-5722-4505-af0a-d1592dab3acc"
      },
      "source": [
        "train_data.shape"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(40000, 2)"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G305ZntZPlxo",
        "outputId": "57910ebf-6e45-4bb0-fb6a-3ed26978bec4"
      },
      "source": [
        "test_data.shape"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(10000, 1)"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 203
        },
        "id": "04ORUe9fszoy",
        "outputId": "4002fe0e-f409-48f0-b5a8-15d1de968951"
      },
      "source": [
        "datasets = [train_data]\n",
        "titles = ['Train data']\n",
        "for dataset, title in zip(datasets,titles):\n",
        "    # print(title)\n",
        "    # dataset.info()\n",
        "    display(dataset.head())"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>review</th>\n",
              "      <th>sentiment</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>One of the other reviewers has mentioned that ...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>A wonderful little production. &lt;br /&gt;&lt;br /&gt;The...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>I thought this was a wonderful way to spend ti...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>Basically there's a family where a little boy ...</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>Petter Mattei's \"Love in the Time of Money\" is...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                              review  sentiment\n",
              "0  One of the other reviewers has mentioned that ...          0\n",
              "1  A wonderful little production. <br /><br />The...          0\n",
              "2  I thought this was a wonderful way to spend ti...          0\n",
              "3  Basically there's a family where a little boy ...          1\n",
              "4  Petter Mattei's \"Love in the Time of Money\" is...          0"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZLjpjwsSU1NX",
        "outputId": "cfb0530f-12ec-4075-e41e-0659a94fe98a"
      },
      "source": [
        "dataset.shape"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(40000, 2)"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 495
        },
        "id": "TH32qHdmvfxN",
        "outputId": "07c10cf0-333e-4df4-acb9-6acda0a8006d"
      },
      "source": [
        "plt.hist(train_data[train_data.sentiment == 1].sentiment,\n",
        "         bins=2, color='green', label='Positive')\n",
        "plt.hist(train_data[train_data.sentiment == 0].sentiment,\n",
        "         bins=2, color='blue', label='Negative')\n",
        "plt.title('Classes distribution in the train data', fontsize=LARGE_SIZE)\n",
        "plt.xticks([])\n",
        "plt.xlim(-0.5, 2)\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1152x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O75YGqWlvsi3"
      },
      "source": [
        "def clean_review(raw_review: str) -> str:\n",
        "    # 1. Remove HTML\n",
        "    review_text = BeautifulSoup(raw_review, \"lxml\").get_text()\n",
        "    # 2. Remove non-letters\n",
        "    letters_only = REPLACE_WITH_SPACE.sub(\" \", review_text)\n",
        "    # 3. Convert to lower case\n",
        "    lowercase_letters = letters_only.lower()\n",
        "    return lowercase_letters\n",
        "\n",
        "\n",
        "def lemmatize(tokens: list) -> list:\n",
        "    # 1. Lemmatize\n",
        "    tokens = list(map(lemmatizer.lemmatize, tokens))\n",
        "    lemmatized_tokens = list(map(lambda x: lemmatizer.lemmatize(x, \"v\"), tokens))\n",
        "    # 2. Remove stop words\n",
        "    meaningful_words = list(filter(lambda x: not x in stop_words, lemmatized_tokens))\n",
        "    return meaningful_words\n",
        "\n",
        "\n",
        "def preprocess(review: str) -> list:\n",
        "   \n",
        "    # if show_progress:\n",
        "    #     global counter\n",
        "    #     counter += 1\n",
        "    #     print('Processing... %6i/%6i'% (counter, total), end='\\r')\n",
        "    # 1. Clean text\n",
        "    review = clean_review(review)\n",
        "    # 2. Split into individual words\n",
        "    tokens = word_tokenize(review)\n",
        "    # 3. Lemmatize\n",
        "    lemmas = lemmatize(tokens)\n",
        "    # 4. Join the words back into one string separated by space,\n",
        "    # and return the result.\n",
        "    return lemmas"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kLalx3NnvwLE",
        "outputId": "019bab72-4c6a-449b-ff8c-f6397a7c48ad"
      },
      "source": [
        "import nltk\n",
        "nltk.download('stopwords')\n",
        "nltk.download('punkt')\n",
        "nltk.download('wordnet')"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[nltk_data] Downloading package stopwords to /root/nltk_data...\n",
            "[nltk_data]   Unzipping corpora/stopwords.zip.\n",
            "[nltk_data] Downloading package punkt to /root/nltk_data...\n",
            "[nltk_data]   Unzipping tokenizers/punkt.zip.\n",
            "[nltk_data] Downloading package wordnet to /root/nltk_data...\n",
            "[nltk_data]   Unzipping corpora/wordnet.zip.\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MCk0s69wv667"
      },
      "source": [
        "counter = 0\n",
        "REPLACE_WITH_SPACE = re.compile(r'[^A-Za-z\\s]')\n",
        "stop_words = set(stopwords.words(\"english\")) \n",
        "lemmatizer = WordNetLemmatizer()"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cXtqtkZJzVwW"
      },
      "source": [
        "all_reviews = []\n",
        "for i in range(len(train_data)):\n",
        "  all_reviews.append(train_data.iloc[i]['review'])"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NKk8ymO9coEh",
        "outputId": "c80e6820-4f7c-4e9a-af24-185947c7f681"
      },
      "source": [
        "len(all_reviews)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "40000"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2z8MjAlg7wuA"
      },
      "source": [
        "x=[]\n",
        "for i in range(len(all_reviews)):\n",
        "  try:\n",
        "    x.append(preprocess(all_reviews[i]))\n",
        "  except:\n",
        "    print('error in ',i)\n",
        "    continue"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CtSsNhd87-_z"
      },
      "source": [
        "all_reviews = x"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9r2lvrEE8o9i"
      },
      "source": [
        "counter = 0"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jVz-NsaPicKr",
        "outputId": "cb344c46-cc58-43fe-9485-d29b28c19537"
      },
      "source": [
        "train_data.shape[0]"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "40000"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RtM9_DPSB9z0"
      },
      "source": [
        "X_train_data = all_reviews[:train_data.shape[0]]\n"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "znvNZkimVgZt",
        "outputId": "d202a90d-49e5-41da-f433-3b10005c25a3"
      },
      "source": [
        "print(X_train_data[0:2])"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[['one', 'reviewer', 'ha', 'mention', 'watch', 'oz', 'episode', 'hook', 'right', 'exactly', 'happen', 'first', 'thing', 'strike', 'oz', 'wa', 'brutality', 'unflinching', 'scene', 'violence', 'set', 'right', 'word', 'go', 'trust', 'show', 'faint', 'hearted', 'timid', 'show', 'pull', 'punch', 'regard', 'drug', 'sex', 'violence', 'hardcore', 'classic', 'use', 'word', 'call', 'oz', 'nickname', 'give', 'oswald', 'maximum', 'security', 'state', 'penitentary', 'focus', 'mainly', 'emerald', 'city', 'experimental', 'section', 'prison', 'cell', 'glass', 'front', 'face', 'inwards', 'privacy', 'high', 'agenda', 'em', 'city', 'home', 'many', 'aryan', 'muslim', 'gangsta', 'latino', 'christian', 'italian', 'irish', 'scuffle', 'death', 'stare', 'dodgy', 'deal', 'shady', 'agreement', 'never', 'far', 'away', 'would', 'say', 'main', 'appeal', 'show', 'due', 'fact', 'go', 'show', 'dare', 'forget', 'pretty', 'picture', 'paint', 'mainstream', 'audience', 'forget', 'charm', 'forget', 'romance', 'oz', 'mess', 'around', 'first', 'episode', 'ever', 'saw', 'strike', 'nasty', 'wa', 'surreal', 'say', 'wa', 'ready', 'watch', 'develop', 'taste', 'oz', 'get', 'accustom', 'high', 'level', 'graphic', 'violence', 'violence', 'injustice', 'crook', 'guard', 'sell', 'nickel', 'inmate', 'kill', 'order', 'get', 'away', 'well', 'mannered', 'middle', 'class', 'inmate', 'turn', 'prison', 'bitch', 'due', 'lack', 'street', 'skill', 'prison', 'experience', 'watch', 'oz', 'may', 'become', 'comfortable', 'uncomfortable', 'view', 'thats', 'get', 'touch', 'darker', 'side'], ['wonderful', 'little', 'production', 'film', 'technique', 'unassuming', 'old', 'time', 'bbc', 'fashion', 'give', 'comfort', 'sometimes', 'discomforting', 'sense', 'realism', 'entire', 'piece', 'actor', 'extremely', 'well', 'choose', 'michael', 'sheen', 'ha', 'get', 'polari', 'ha', 'voice', 'pat', 'truly', 'see', 'seamless', 'edit', 'guide', 'reference', 'williams', 'diary', 'entry', 'well', 'worth', 'watch', 'terrificly', 'write', 'perform', 'piece', 'masterful', 'production', 'one', 'great', 'master', 'comedy', 'life', 'realism', 'really', 'come', 'home', 'little', 'thing', 'fantasy', 'guard', 'rather', 'use', 'traditional', 'dream', 'technique', 'remain', 'solid', 'disappear', 'play', 'knowledge', 'sens', 'particularly', 'scene', 'concern', 'orton', 'halliwell', 'set', 'particularly', 'flat', 'halliwell', 'mural', 'decorate', 'every', 'surface', 'terribly', 'well']]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "guLyG9aDBl3w"
      },
      "source": [
        "Y_train_data = train_data.sentiment.values"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lNmfB-yWCMQH"
      },
      "source": [
        "train_data['review_lenght'] = np.array(list(map(len, X_train_data)))\n",
        "median = train_data['review_lenght'].median()\n",
        "mean = train_data['review_lenght'].mean()\n",
        "mode = train_data['review_lenght'].mode()[0]"
      ],
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 527
        },
        "id": "ettcsbSqCPQT",
        "outputId": "62fb0c22-f366-4dbc-8404-307379bc936b"
      },
      "source": [
        "fig, ax = plt.subplots()\n",
        "sb.distplot(train_data['review_lenght'], bins=train_data['review_lenght'].max(),\n",
        "            hist_kws={\"alpha\": 0.9, \"color\": \"blue\"}, ax=ax,\n",
        "            kde_kws={\"color\": \"black\", 'linewidth': 3})\n",
        "ax.set_xlim(left=0, right=np.percentile(train_data['review_lenght'], 95))\n",
        "ax.set_xlabel('Words in review')\n",
        "ymax = 0.014\n",
        "plt.ylim(0, ymax)\n",
        "ax.plot([mode, mode], [0, ymax], '--', label=f'mode = {mode:.2f}', linewidth=4)\n",
        "ax.plot([mean, mean], [0, ymax], '--', label=f'mean = {mean:.2f}', linewidth=4)\n",
        "ax.plot([median, median], [0, ymax], '--',\n",
        "        label=f'median = {median:.2f}', linewidth=4)\n",
        "ax.set_title('Words per review distribution', fontsize=20)\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1152x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ABi7vtyKTm1m",
        "outputId": "f40ef15b-8b35-4b2d-e9f5-9a84e9ff2da8"
      },
      "source": [
        "%%time\n",
        "bigrams = Phrases(sentences=all_reviews)"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CPU times: user 10.4 s, sys: 230 ms, total: 10.6 s\n",
            "Wall time: 10.6 s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aw38LdWWT21H",
        "outputId": "435b52d4-fead-4d18-b0ab-2b685e56652a"
      },
      "source": [
        "%%time\n",
        "trigrams = Phrases(sentences=bigrams[all_reviews])"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CPU times: user 32.1 s, sys: 285 ms, total: 32.4 s\n",
            "Wall time: 32.4 s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xSxVF9KcT4Ix",
        "outputId": "4c300743-1f75-4778-ece1-0ab8d1c32703"
      },
      "source": [
        "print(bigrams[['space', 'station', 'near', 'the', 'solar', 'system']])"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['space_station', 'near', 'the', 'solar_system']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AU4LBMnWT56n",
        "outputId": "8ce50725-d2e5-42c4-ea01-d2d059c33295"
      },
      "source": [
        "%%time\n",
        "embedding_vector_size = 256\n",
        "trigrams_model = Word2Vec(\n",
        "    sentences = trigrams[bigrams[all_reviews]],\n",
        "    size = embedding_vector_size,\n",
        "    min_count=3, window=5, workers=4)"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CPU times: user 6min 44s, sys: 2.14 s, total: 6min 46s\n",
            "Wall time: 5min 33s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fXwlz1ugkl1g",
        "outputId": "87da737a-a19d-43fd-ef5b-75743c19c232"
      },
      "source": [
        "print(\"Vocabulary size:\", len(trigrams_model.wv.vocab))"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Vocabulary size: 52762\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m8iRDQlVpXBn",
        "outputId": "1ef7425f-ad89-422d-9883-7df5a8742b7b"
      },
      "source": [
        "trigrams_model.wv.most_similar('galaxy')"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[('space_shuttle', 0.9445674419403076),\n",
              " ('deposit', 0.9351761341094971),\n",
              " ('laboratory', 0.9269632697105408),\n",
              " ('space_station', 0.9265759587287903),\n",
              " ('carrier', 0.9243882298469543),\n",
              " ('detonate', 0.9235181212425232),\n",
              " ('federal', 0.9221619367599487),\n",
              " ('shantytown', 0.9209966659545898),\n",
              " ('continent', 0.920053243637085),\n",
              " ('facility', 0.9191067218780518)]"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "j7BFU4VnpdhF",
        "outputId": "c2e6220b-0c4f-4832-9240-b96f8b2ff003"
      },
      "source": [
        "trigrams_model.wv.doesnt_match(['galaxy', 'starship', 'planet', 'dog'])"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'dog'"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zUmUFW1-pf-1",
        "outputId": "d3342b85-bc3f-4ada-fbd9-d8328c1875fc"
      },
      "source": [
        "%%time\n",
        "def vectorize_data(data, vocab: dict) -> list:\n",
        "    print('Vectorize sentences...', end='\\r')\n",
        "    keys = list(vocab.keys())\n",
        "    filter_unknown = lambda word: vocab.get(word, None) is not None\n",
        "    encode = lambda review: list(map(keys.index, filter(filter_unknown, review)))\n",
        "    vectorized = list(map(encode, data))\n",
        "    print('Vectorize sentences... (done)')\n",
        "    return vectorized\n",
        "\n",
        "print('Convert sentences to sentences with ngrams...', end='\\r')\n",
        "X_data = trigrams[bigrams[X_train_data]]\n",
        "print('Convert sentences to sentences with ngrams... (done)')\n",
        "input_length = 150\n",
        "X_pad = pad_sequences(\n",
        "    sequences=vectorize_data(X_data, vocab=trigrams_model.wv.vocab),\n",
        "    maxlen=input_length,\n",
        "    padding='post')\n",
        "print('Transform sentences to sequences... (done)')"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Convert sentences to sentences with ngrams...\rConvert sentences to sentences with ngrams... (done)\n",
            "Vectorize sentences...\rVectorize sentences... (done)\n",
            "Transform sentences to sequences... (done)\n",
            "CPU times: user 7min 35s, sys: 1.93 s, total: 7min 37s\n",
            "Wall time: 7min 36s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0ks9Zy7wps8P"
      },
      "source": [
        "X_train, X_test, y_train, y_test = train_test_split(\n",
        "    X_pad,\n",
        "    Y_train_data,\n",
        "    test_size=0.3,\n",
        "    shuffle=True,\n",
        "    random_state=42)"
      ],
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SNQJediiqr8f",
        "outputId": "e82156e6-1cca-4452-ef67-b954a22eadc4"
      },
      "source": [
        "from keras.layers import SimpleRNN\n",
        "def build_model(embedding_matrix: np.ndarray, input_length: int):\n",
        "    model = Sequential()\n",
        "    model.add(Embedding(\n",
        "        input_dim = embedding_matrix.shape[0],\n",
        "        output_dim = embedding_matrix.shape[1], \n",
        "        input_length = input_length,\n",
        "        weights = [embedding_matrix],\n",
        "        trainable=False))\n",
        "    model.add(SimpleRNN(units=128, activation=\"relu\"))\n",
        "    model.add(Dense(8, activation=\"relu\"))\n",
        "    model.add(Dense(1, activation='sigmoid'))\n",
        "    model.summary()\n",
        "    return model\n",
        "\n",
        "model = build_model(\n",
        "    embedding_matrix=trigrams_model.wv.vectors,\n",
        "    input_length=input_length)"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_5\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "embedding_5 (Embedding)      (None, 150, 256)          13507072  \n",
            "_________________________________________________________________\n",
            "simple_rnn_4 (SimpleRNN)     (None, 128)               49280     \n",
            "_________________________________________________________________\n",
            "dense_6 (Dense)              (None, 8)                 1032      \n",
            "_________________________________________________________________\n",
            "dense_7 (Dense)              (None, 1)                 9         \n",
            "=================================================================\n",
            "Total params: 13,557,393\n",
            "Trainable params: 50,321\n",
            "Non-trainable params: 13,507,072\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vowx732Yq1Li",
        "outputId": "b7e08ed5-a7b7-4a99-8c9a-f4904ff61aeb"
      },
      "source": [
        "model.compile(\n",
        "    loss=\"binary_crossentropy\",\n",
        "    optimizer='adam',\n",
        "    metrics=['accuracy'])\n",
        "\n",
        "history = model.fit(\n",
        "    x=X_train,\n",
        "    y=y_train,\n",
        "    validation_data=(X_test, y_test),\n",
        "\n",
        "    batch_size=100,\n",
        "    epochs=20)"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "280/280 [==============================] - 41s 143ms/step - loss: 0.6933 - accuracy: 0.5040 - val_loss: 0.6920 - val_accuracy: 0.5054\n",
            "Epoch 2/20\n",
            "280/280 [==============================] - 39s 139ms/step - loss: 0.6906 - accuracy: 0.5144 - val_loss: 0.6933 - val_accuracy: 0.5073\n",
            "Epoch 3/20\n",
            "280/280 [==============================] - 39s 140ms/step - loss: 0.6879 - accuracy: 0.5199 - val_loss: 0.6936 - val_accuracy: 0.5149\n",
            "Epoch 4/20\n",
            "280/280 [==============================] - 38s 137ms/step - loss: 0.6841 - accuracy: 0.5251 - val_loss: 0.6915 - val_accuracy: 0.5153\n",
            "Epoch 5/20\n",
            "280/280 [==============================] - 39s 139ms/step - loss: 0.6777 - accuracy: 0.5322 - val_loss: 0.6941 - val_accuracy: 0.5125\n",
            "Epoch 6/20\n",
            "280/280 [==============================] - 38s 137ms/step - loss: 0.6710 - accuracy: 0.5386 - val_loss: 0.6988 - val_accuracy: 0.5185\n",
            "Epoch 7/20\n",
            "280/280 [==============================] - 39s 138ms/step - loss: 0.6617 - accuracy: 0.5460 - val_loss: 0.7101 - val_accuracy: 0.5140\n",
            "Epoch 8/20\n",
            "280/280 [==============================] - 39s 141ms/step - loss: 0.6498 - accuracy: 0.5556 - val_loss: 0.7175 - val_accuracy: 0.5163\n",
            "Epoch 9/20\n",
            "280/280 [==============================] - 39s 139ms/step - loss: 0.6398 - accuracy: 0.5620 - val_loss: 0.7363 - val_accuracy: 0.5134\n",
            "Epoch 10/20\n",
            "280/280 [==============================] - 39s 139ms/step - loss: 0.6267 - accuracy: 0.5707 - val_loss: 0.7655 - val_accuracy: 0.5108\n",
            "Epoch 11/20\n",
            "280/280 [==============================] - 39s 139ms/step - loss: 0.6171 - accuracy: 0.5762 - val_loss: 0.7779 - val_accuracy: 0.5138\n",
            "Epoch 12/20\n",
            "280/280 [==============================] - 39s 139ms/step - loss: 0.6061 - accuracy: 0.5826 - val_loss: 0.8188 - val_accuracy: 0.5121\n",
            "Epoch 13/20\n",
            "280/280 [==============================] - 39s 140ms/step - loss: 0.5979 - accuracy: 0.5861 - val_loss: 0.8705 - val_accuracy: 0.5111\n",
            "Epoch 14/20\n",
            "280/280 [==============================] - 40s 142ms/step - loss: 0.5920 - accuracy: 0.5878 - val_loss: 0.8581 - val_accuracy: 0.5113\n",
            "Epoch 15/20\n",
            "280/280 [==============================] - 39s 141ms/step - loss: 0.5896 - accuracy: 0.5899 - val_loss: 0.8858 - val_accuracy: 0.5098\n",
            "Epoch 16/20\n",
            "280/280 [==============================] - 40s 141ms/step - loss: 0.5837 - accuracy: 0.5919 - val_loss: 0.9286 - val_accuracy: 0.5098\n",
            "Epoch 17/20\n",
            "280/280 [==============================] - 39s 140ms/step - loss: 0.5819 - accuracy: 0.5932 - val_loss: 0.9283 - val_accuracy: 0.5107\n",
            "Epoch 18/20\n",
            "280/280 [==============================] - 40s 141ms/step - loss: 0.5760 - accuracy: 0.5962 - val_loss: 0.9426 - val_accuracy: 0.5157\n",
            "Epoch 19/20\n",
            "280/280 [==============================] - 39s 141ms/step - loss: 0.5783 - accuracy: 0.5950 - val_loss: 0.9856 - val_accuracy: 0.5107\n",
            "Epoch 20/20\n",
            "280/280 [==============================] - 40s 142ms/step - loss: 0.5786 - accuracy: 0.5947 - val_loss: 0.9837 - val_accuracy: 0.5128\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g8b0mc70LZX8"
      },
      "source": [
        "model.save(\"/content/drive/MyDrive/IMDB Sentiment analysis/data/model_imdb_rnn.h5\")"
      ],
      "execution_count": 52,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fx8LaLqHgd1X"
      },
      "source": [
        "from keras.models import load_model\n",
        "model = load_model(\"/content/drive/MyDrive/IMDB Sentiment analysis/data/model_imdb_rnn.h5\")"
      ],
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2HG1_3-YvJ7r",
        "outputId": "1d36e27c-afc8-4b57-daf9-eacf08aaac67"
      },
      "source": [
        "%%time\n",
        "y_train_pred = model.predict(X_train)\n",
        "y_test_pred = model.predict(X_test)"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CPU times: user 21.6 s, sys: 350 ms, total: 22 s\n",
            "Wall time: 26.5 s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ztdnkroYpzc2"
      },
      "source": [
        "y_test_pred = list(map(lambda x: 0 if x<0.3 else 1, y_test_pred))"
      ],
      "execution_count": 55,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eXcyzjxiA5WD"
      },
      "source": [
        "# y_test_pred"
      ],
      "execution_count": 57,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "npoVSfvbsFqZ",
        "outputId": "65b5f976-d465-48eb-c3fb-fd5cdf7046e8"
      },
      "source": [
        "confusion_matrix(y_test,y_test_pred)"
      ],
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 656, 5353],\n",
              "       [ 491, 5500]])"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7XNUxGgKtTDM"
      },
      "source": [
        "from sklearn.metrics import accuracy_score\n",
        "from sklearn.metrics import precision_score\n",
        "from sklearn.metrics import recall_score\n",
        "from sklearn.metrics import f1_score"
      ],
      "execution_count": 59,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mrIuc5UGsJni",
        "outputId": "17310f71-2b24-400e-e79d-0f8b94026b75"
      },
      "source": [
        "accuracy = accuracy_score(y_test,y_test_pred)\n",
        "accuracy"
      ],
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.513"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kKewTGC2tE99",
        "outputId": "b809b197-11a3-4c83-bfee-e27524ca5a38"
      },
      "source": [
        "precision = precision_score(y_test,y_test_pred)\n",
        "print('Precision: %f' % precision)\n",
        "# recall: tp / (tp + fn)\n",
        "recall = recall_score(y_test,y_test_pred)\n",
        "print('Recall: %f' % recall)\n",
        "# f1: 2 tp / (2 tp + fp + fn)\n",
        "f1 = f1_score(y_test,y_test_pred)\n",
        "print('F1 score: %f' % f1)"
      ],
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Precision: 0.506772\n",
            "Recall: 0.918044\n",
            "F1 score: 0.653052\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3wHt9Fk3TqFd"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 203
        },
        "id": "ookrG2oRTqHy",
        "outputId": "541de29f-5d29-4124-dd7f-7c2cfd6c0f88"
      },
      "source": [
        "test_data.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>review</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>40000</th>\n",
              "      <td>First off I want to say that I lean liberal on...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>40001</th>\n",
              "      <td>I was excited to see a sitcom that would hopef...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>40002</th>\n",
              "      <td>When you look at the cover and read stuff abou...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>40003</th>\n",
              "      <td>Like many others, I counted on the appearance ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>40004</th>\n",
              "      <td>This movie was on t.v the other day, and I did...</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                                  review\n",
              "40000  First off I want to say that I lean liberal on...\n",
              "40001  I was excited to see a sitcom that would hopef...\n",
              "40002  When you look at the cover and read stuff abou...\n",
              "40003  Like many others, I counted on the appearance ...\n",
              "40004  This movie was on t.v the other day, and I did..."
            ]
          },
          "execution_count": 50,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ppakVaR7XDCE",
        "outputId": "9cf96de7-a06a-4eb4-e14b-6008e1f164c0"
      },
      "source": [
        "len(test_data)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "10000"
            ]
          },
          "execution_count": 51,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wRSa6XpvTwUY"
      },
      "source": [
        "temp = []\n",
        "for i in range(len(test_data)):\n",
        "  temp.append(test_data.iloc[i]['review'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sDv_C2PLXKak"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sr7_u8KwTMCy"
      },
      "source": [
        "X_submission = temp"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W_JY-2mKWQz_"
      },
      "source": [
        "temp_arr=[]\n",
        "for i in range(len(X_submission)):\n",
        "  try:\n",
        "    temp_arr.append(preprocess(X_submission[i]))\n",
        "  except:\n",
        "    print('error in ',i)\n",
        "    continue"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h5NGwgdTXg7z"
      },
      "source": [
        "X_submission = temp_arr"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xxh3MU6BS9Ro",
        "outputId": "e7a6bc82-ecf3-4e6d-9c82-a53197a471f3"
      },
      "source": [
        "print('Convert sentences to sentences with ngrams...', end='\\r')\n",
        "X_submit = trigrams[bigrams[X_submission]]\n",
        "print('Convert sentences to sentences with ngrams... (done)')\n",
        "X_sub = pad_sequences(\n",
        "    sequences=vectorize_data(X_submit, vocab=trigrams_model.wv.vocab),\n",
        "    maxlen=input_length,\n",
        "    padding='post')\n",
        "print('Transform sentences to sequences... (done)')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Convert sentences to sentences with ngrams...\rConvert sentences to sentences with ngrams... (done)\n",
            "Vectorize sentences...\rVectorize sentences... (done)\n",
            "Transform sentences to sequences... (done)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BtS4lyH6TScS",
        "outputId": "cbb25246-08c0-48a0-fce2-10e3b7eb0c83"
      },
      "source": [
        "%%time\n",
        "Y_sub_pred = model.predict(X_sub)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "CPU times: user 5.28 s, sys: 106 ms, total: 5.38 s\n",
            "Wall time: 5.31 s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gXpPJDxRU8ua",
        "outputId": "ef27a13f-bfea-426d-ee21-db2a952f0a74"
      },
      "source": [
        "len(Y_sub_pred)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "10000"
            ]
          },
          "execution_count": 58,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S9mayc_ZVJHG",
        "outputId": "4e8b90af-a1f3-4dfa-d222-ea77a183f43f"
      },
      "source": [
        "Y_sub_pred"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0.4763329],\n",
              "       [0.4763329],\n",
              "       [0.4763329],\n",
              "       ...,\n",
              "       [0.4763329],\n",
              "       [0.4763329],\n",
              "       [0.4763329]], dtype=float32)"
            ]
          },
          "execution_count": 59,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dEoJxmk9rq4j"
      },
      "source": [
        "Y_sub_pred = list(map(lambda x: 0 if x<0.3 else 1, Y_sub_pred))\n",
        "# Y_sub_pred"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wxxyWeyRsGnT",
        "outputId": "90941241-a727-41a1-e30c-f6dadf5d1edd"
      },
      "source": [
        "print(y_actual_pred[0:5])\n",
        "print(Y_sub_pred[0:5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "40000    1\n",
            "40001    1\n",
            "40002    1\n",
            "40003    1\n",
            "40004    1\n",
            "Name: sentiment, dtype: int64\n",
            "[1, 1, 1, 1, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1N24w8fQrzFr",
        "outputId": "1ca74cfc-2d7e-4ac3-93cf-e33bfe69eb04"
      },
      "source": [
        "accuracy = accuracy_score(y_actual_pred,Y_sub_pred)\n",
        "accuracy"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0.4993"
            ]
          },
          "execution_count": 62,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9OEondAFsEA6",
        "outputId": "62aac8f8-3df3-43de-c3c8-2d8ca4220b55"
      },
      "source": [
        "precision = precision_score(y_actual_pred,Y_sub_pred)\n",
        "print('Precision: %f' % precision)\n",
        "# recall: tp / (tp + fn)\n",
        "recall = recall_score(y_actual_pred,Y_sub_pred)\n",
        "print('Recall: %f' % recall)\n",
        "# f1: 2 tp / (2 tp + fp + fn)\n",
        "f1 = f1_score(y_actual_pred,Y_sub_pred)\n",
        "print('F1 score: %f' % f1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Precision: 0.499300\n",
            "Recall: 1.000000\n",
            "F1 score: 0.666044\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FxurBf3Hsmdb"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}