LSTM_GRU_Classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1SlelRhAZjE5"
   },
   "source": [
    "# LSTM/GRU_Classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lcpDZK6njYN9"
   },
   "source": [
    "## Import useful libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tZbypE894o-C",
    "outputId": "f809b3d3-c594-4756-9239-c1f2bfe9c810"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drive already mounted at /content/drive/; to attempt to forcibly remount, call drive.mount(\"/content/drive/\", force_remount=True).\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt \n",
    "import string\n",
    "import re\n",
    "import nltk\n",
    "import pickle\n",
    "import time\n",
    "import torch\n",
    "import torchtext\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "from gensim.utils import simple_preprocess\n",
    "from gensim import corpora\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression \n",
    "from sklearn.feature_extraction.text import TfidfVectorizer,CountVectorizer\n",
    "from sklearn.metrics import recall_score,f1_score,precision_score,classification_report,roc_curve,auc\n",
    "from sklearn.preprocessing import label_binarize\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from torchtext import data\n",
    "from google.colab import drive\n",
    "drive.mount('/content/drive/')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s4O3_rlbYX_D"
   },
   "source": [
    "## Load Prepared-Cleaned Datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "shD-jQ8LLSaM",
    "outputId": "873e3271-a7ea-4d28-c9bf-79ee75389084"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train's shape: (495012, 1)\n",
      "X_val's shape: (2488, 1)\n",
      "X_test's shape: (2500, 1) \n",
      "\n",
      "Y_train's shape: (495012, 1)\n",
      "Y_val's shape: (2488, 1)\n",
      "Y_test's shape: (2500, 1)\n"
     ]
    }
   ],
   "source": [
    "# Load GloVe vectorized Χ_train.\n",
    "x_train_file = open('/content/drive/My Drive/AI(II)/prepared_datasets/X_train.pkl', 'rb')\n",
    "X_train = pickle.load(x_train_file)\n",
    "x_train_file.close()\n",
    "  \n",
    "# Load GloVe vectorized Χ_val.\n",
    "x_val_file = open('/content/drive/My Drive/AI(II)/prepared_datasets/X_val.pkl', 'rb')\n",
    "X_val = pickle.load(x_val_file)\n",
    "x_val_file.close()\n",
    "\n",
    "# Load GloVe vectorized Χ_test.\n",
    "x_test_file = open('/content/drive/My Drive/AI(II)/prepared_datasets/X_test.pkl', 'rb')\n",
    "X_test = pickle.load(x_test_file)\n",
    "x_test_file.close()\n",
    "\n",
    "# Load Y_train.\n",
    "y_train_file = open('/content/drive/My Drive/AI(II)/prepared_datasets/Y_train.pkl', 'rb')\n",
    "Y_train = pickle.load(y_train_file)\n",
    "y_train_file.close()\n",
    "\n",
    "# Load Y_val.\n",
    "y_val_file = open('/content/drive/My Drive/AI(II)/prepared_datasets/Y_val.pkl', 'rb')\n",
    "Y_val = pickle.load(y_val_file)\n",
    "y_val_file.close()\n",
    "\n",
    "# Load Y_test.\n",
    "y_test_file = open('/content/drive/My Drive/AI(II)/prepared_datasets/Y_test.pkl', 'rb')\n",
    "Y_test = pickle.load(y_test_file)\n",
    "y_test_file.close()\n",
    "\n",
    "print(\"X_train's shape:\", X_train.shape)\n",
    "print(\"X_val's shape:\", X_val.shape)\n",
    "print(\"X_test's shape:\", X_test.shape,\"\\n\")\n",
    "print(\"Y_train's shape:\", Y_train.shape)\n",
    "print(\"Y_val's shape:\", Y_val.shape)\n",
    "print(\"Y_test's shape:\", Y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W-hC8wqNyWXP"
   },
   "source": [
    "## Concatenation of tweets with labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "g1PZtGy_ychv",
    "outputId": "213fcda2-8ef6-43d5-d173-a76db1e59256"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(495012, 2)\n",
      "(2488, 2)\n",
      "(2500, 2)\n"
     ]
    }
   ],
   "source": [
    "train = pd.concat([X_train, Y_train], axis=1)\n",
    "print(train.shape)\n",
    "\n",
    "valid = pd.concat([X_val, Y_val], axis=1)\n",
    "print(valid.shape)\n",
    "\n",
    "test = pd.concat([X_test, Y_test], axis=1)\n",
    "print(test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4mtelVElypE_"
   },
   "source": [
    "## Let's check ratio of negative-positive sentiments in our tweets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "FhCxSr_ay0cd",
    "outputId": "8cb88334-5acd-4dfa-a18e-6ffcaf1697ca"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    248360\n",
       "0    246652\n",
       "Name: target, dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.target.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "GF0N0pfqy-Fw",
    "outputId": "92e6a0be-32a3-4789-deca-d78ed1c7ff38"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1267\n",
       "1    1221\n",
       "Name: target, dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "valid.target.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "btRuwSVDy9u7",
    "outputId": "12264d36-c9d3-40b1-97c0-ad588ec09e81"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1281\n",
       "1    1219\n",
       "Name: target, dtype: int64"
      ]
     },
     "execution_count": 6,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.target.value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "I1PvBRCNzHoq"
   },
   "source": [
    "## Save our datasets as .csv files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5Z4LuxAezaGE"
   },
   "outputs": [],
   "source": [
    "train.to_csv(\"/content/drive/My Drive/AI(II)/prepared_datasets/train.csv\", index=False)\n",
    "test.to_csv(\"/content/drive/My Drive/AI(II)/prepared_datasets/test.csv\", index=False)\n",
    "valid.to_csv(\"/content/drive/My Drive/AI(II)/prepared_datasets/valid.csv\", index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "12qQYfLi1Gy9"
   },
   "source": [
    "## Create TEXT,LABEL from torchtext.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "i8IOm0Gm1IIC"
   },
   "outputs": [],
   "source": [
    "TEXT = data.Field(dtype=torch.long,sequential=True, tokenize=\"spacy\",batch_first=True)\n",
    "LABEL = data.LabelField(dtype=torch.long, sequential=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rmC8I6_b1QI9"
   },
   "source": [
    "## Loading train, test and validation set. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6q2Q6ikZ1Rgu",
    "outputId": "49910ec9-9ef6-4772-a521-dfc8fc19036a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training examples: 495012\n",
      "Number of valid examples: 2488\n",
      "Number of testing examples: 2500\n"
     ]
    }
   ],
   "source": [
    "train_data, valid_data, test_data = data.TabularDataset.splits( \n",
    "    path=\"/content/drive/My Drive/AI(II)/prepared_datasets/\", \n",
    "    train=\"train.csv\", \n",
    "    validation=\"valid.csv\", \n",
    "    test=\"test.csv\",\n",
    "    format=\"csv\", \n",
    "    skip_header=True, \n",
    "    fields=[('Text', TEXT), ('Label', LABEL)])\n",
    "\n",
    "print(f'Number of training examples: {len(train_data)}')\n",
    "print(f'Number of valid examples: {len(valid_data)}')\n",
    "print(f'Number of testing examples: {len(test_data)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lPiaZFpK1t9Q"
   },
   "source": [
    "## Build Vocabulary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fkdfuJOX3x9m",
    "outputId": "844c0ed9-2859-412b-c9e7-d4487d1f1078"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique tokens in TEXT vocabulary: 20002\n",
      "Unique tokens in LABEL vocabulary: 2\n"
     ]
    }
   ],
   "source": [
    "TEXT.build_vocab(train_data, vectors=torchtext.vocab.Vectors(\"/content/drive/MyDrive/AI(II)/glove_models/glove.6B.50d.txt\"),max_size=20000,min_freq=5)\n",
    "LABEL.build_vocab(train_data)\n",
    "\n",
    "print(f\"Unique tokens in TEXT vocabulary: {len(TEXT.vocab)}\")\n",
    "print(f\"Unique tokens in LABEL vocabulary: {len(LABEL.vocab)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OsWRMwlR6DwQ"
   },
   "source": [
    "## Prepare GPU Cuda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hN25lAzQ6Jws",
    "outputId": "431305e2-23ce-43b7-fea8-49d5083da72a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device available for running: \n",
      "cuda\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(\"Device available for running: \")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IMIhUC4D5San"
   },
   "source": [
    "## Bucket Iterators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tGrIaW4v5WGr"
   },
   "outputs": [],
   "source": [
    "BATCH_SIZE = 512\n",
    "\n",
    "train_iterator, valid_iterator, test_iterator = data.BucketIterator.splits(\n",
    "    (train_data, valid_data, test_data), \n",
    "    sort_key=lambda x: len(x.Text),\n",
    "    batch_size=BATCH_SIZE,\n",
    "    shuffle=True,\n",
    "    device=device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BCtgZvmbt6PO"
   },
   "source": [
    "## Implementation of class RNN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mgSLE3Xot_Qv"
   },
   "outputs": [],
   "source": [
    "class LSTM_GRU(nn.Module):\n",
    "  \"\"\"\n",
    "  The LSTM/GRU model that will be used to perform Tweet Sentiment Analysis.\n",
    "  \"\"\"\n",
    "\n",
    "  def __init__(self, cell_type, input_size, embedding_size, hidden_size, output_size, embeddings, num_layers, bidirectional, dropout_prob):\n",
    "    \"\"\"\n",
    "    Initialize the model by setting up the layers.\n",
    "    \"\"\"\n",
    "    super(LSTM_GRU, self).__init__()\n",
    "\n",
    "    cells = {\n",
    "    \"LSTM\"    : nn.LSTM,\n",
    "    \"GRU\"     : nn.GRU\n",
    "    }   \n",
    "\n",
    "    # Initializations\n",
    "    self.cell_type = cell_type\n",
    "    self.input_size = input_size\n",
    "    self.embedding_size = embedding_size\n",
    "    self.output_size = output_size\n",
    "    self.num_layers = num_layers\n",
    "    self.bidirectional = bidirectional\n",
    "    self.dropout_prob = dropout_prob\n",
    "    self.hidden_size = hidden_size\n",
    "      \n",
    "    self.embedding = nn.Embedding(input_size, embedding_size)\n",
    "    self.embedding.weight = torch.nn.Parameter(embeddings, requires_grad=False)\n",
    "\n",
    "    self.nn = cells[cell_type](          # Pick the specific model\n",
    "        input_size=self.embedding_size,   # Number of features for each time step\n",
    "        hidden_size=self.hidden_size,     # LSTM/GRU hidden embedding representation\n",
    "        num_layers=self.num_layers,       # Number of layers (if >1 it is a stacked RNN)\n",
    "        bidirectional=self.bidirectional, # If true we have bidirectional \n",
    "        batch_first=True,                 # input & output will have batch size as 1st dimension. e.g. (batch, time_step, input_size)\n",
    "        dropout=self.dropout_prob         # dropout prob >= 0.0\n",
    "    )\n",
    "    \n",
    "    # Dropout layer\n",
    "    if self.dropout_prob > 0.0: \n",
    "      self.dropout = nn.Dropout(self.dropout_prob)\n",
    "    \n",
    "    # Linear layer\n",
    "    if self.bidirectional: \n",
    "      self.linear = nn.Linear(self.hidden_size*2,self.output_size)\n",
    "    else:\n",
    "      self.linear = nn.Linear(self.hidden_size,self.output_size)\n",
    "\n",
    "    # Sigmoid output layer\n",
    "    self.sig = nn.Sigmoid()\n",
    "      \n",
    "  def forward(self, x, hidden):\n",
    "    \"\"\"\n",
    "    Perform a forward pass of our model on some input and hidden state.\n",
    "    \"\"\"\n",
    "    batch_size = x.size(0)\n",
    "\n",
    "    # Embeddings\n",
    "    embed = self.embedding(x)\n",
    "    \n",
    "    # LSTM or GRU\n",
    "    out, hidden = self.nn(embed, hidden)\n",
    "\n",
    "    # Stack up outputs\n",
    "    if self.bidirectional: \n",
    "      out = out.contiguous().view(-1, self.hidden_size*2)\n",
    "    else:\n",
    "      out = out.contiguous().view(-1, self.hidden_size)\n",
    "\n",
    "    # Dropout Layer\n",
    "    if self.dropout_prob > 0.0: \n",
    "      out = self.dropout(out)\n",
    "\n",
    "    # Linear  \n",
    "    out = self.linear(out)\n",
    "    \n",
    "    # Sigmoid function\n",
    "    out = self.sig(out)\n",
    "\n",
    "    # Reshape to be batch_size first and get last batch of labels\n",
    "    out = out.view(batch_size, -1, self.output_size)\n",
    "    out = out[:, -1, :]\n",
    "   \n",
    "    return out.to(device), hidden\n",
    "\n",
    "  def init_hidden(self, batch_size):\n",
    "    ''' Initializes hidden state '''\n",
    "    # Create two new tensors with sizes n_layers x batch_size x hidden_dim, initialized to zero, for hidden state and cell state of LSTM\n",
    "    weight = next(self.parameters()).data\n",
    "    \n",
    "    if self.bidirectional:\n",
    "      if self.cell_type == 'LSTM':\n",
    "        hidden = (weight.new(self.num_layers*2, batch_size, self.hidden_size).zero_().to(device),\n",
    "                  weight.new(self.num_layers*2, batch_size, self.hidden_size).zero_().to(device))\n",
    "      if self.cell_type == 'GRU':\n",
    "        hidden = weight.new(self.num_layers*2, batch_size, self.hidden_size).zero_().to(device)\n",
    "    else:\n",
    "      if self.cell_type == 'LSTM':\n",
    "        hidden = (weight.new(self.num_layers, batch_size, self.hidden_size).zero_().to(device),\n",
    "                  weight.new(self.num_layers, batch_size, self.hidden_size).zero_().to(device))\n",
    "      if self.cell_type == 'GRU':\n",
    "        hidden = weight.new(self.num_layers, batch_size, self.hidden_size).zero_().to(device)\n",
    "\n",
    "    return hidden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3sB-_jnb2kBU"
   },
   "source": [
    "## Initialization of model and valuable functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ErbpremS2qb0",
    "outputId": "1e4c684d-52e3-464a-e214-2a92c54e98d7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LSTM_GRU(\n",
      "  (embedding): Embedding(20002, 50)\n",
      "  (nn): LSTM(50, 128, num_layers=2, batch_first=True, dropout=0.2, bidirectional=True)\n",
      "  (dropout): Dropout(p=0.2, inplace=False)\n",
      "  (linear): Linear(in_features=256, out_features=1, bias=True)\n",
      "  (sig): Sigmoid()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "########################## HYPERPARAMS #########################################\n",
    "INPUT_DIM = len(TEXT.vocab)                # total words of vocabulary\n",
    "EMBEDDING_DIM = 50                         # each glove vector has 50 dimensions \n",
    "HIDDEN_DIM = 128                           # number of hidden neurons\n",
    "OUTPUT_DIM = 1                             # possible choices \n",
    "num_layers = 2                             # number of layers\n",
    "bidirectional = True                       # bidirectional or not\n",
    "cell_type = 'LSTM'                          # LSTM or GRU\n",
    "dropout_prob = 0.2                         # Dropout probality\n",
    "embeddings = TEXT.vocab.vectors.to(device) # pre trained embeddings\n",
    "################################################################################\n",
    "\n",
    "# Instance of model\n",
    "model = LSTM_GRU(cell_type, INPUT_DIM ,EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM, embeddings, num_layers, bidirectional, dropout_prob)\n",
    "print(model)\n",
    "\n",
    "# Initialization of epochs and learning rate\n",
    "epochs = 10\n",
    "learning_rate = 2e-3\n",
    "\n",
    "# Initialization of optimizer and loss function\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)   \n",
    "criterion = nn.BCELoss()\n",
    "\n",
    "# Transfer all the computation to GPU (cuda device).\n",
    "model = model.to(device)\n",
    "criterion = criterion.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aHGm9uBKkMHn"
   },
   "source": [
    "### Function which calculates accuracy of some predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QXgXLwEaEe06"
   },
   "outputs": [],
   "source": [
    "def binary_accuracy(preds, y):\n",
    "  \"\"\"\n",
    "  Returns accuracy per batch, i.e. if you get 85/100 right, this returns 0.85\n",
    "  \"\"\"\n",
    "  # Round predictions to the closest integer\n",
    "  rounded_preds = torch.round(preds)\n",
    "  \n",
    "  # Convert into float for division \n",
    "  correct = (rounded_preds == y).float() \n",
    "\n",
    "  return correct.sum() / len(correct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Be-bYImmkS4c"
   },
   "source": [
    "### Function which is gonna train our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1aFWxu7DEolo"
   },
   "outputs": [],
   "source": [
    "def train(model, iterator, optimizer, criterion, clip, batch_size):\n",
    "  \n",
    "  epoch_loss = 0\n",
    "  epoch_acc = 0\n",
    "  \n",
    "  model.train()\n",
    "  h = model.init_hidden(batch_size)\n",
    "  \n",
    "  for batch in iterator:\n",
    "\n",
    "    if model.cell_type == 'LSTM':\n",
    "      h = tuple([each.data for each in h])\n",
    "    elif model.cell_type == 'GRU':\n",
    "      h.detach_()\n",
    "      h = h.detach()\n",
    "\n",
    "    inputs = batch.Text.to(device)\n",
    "    labels = batch.Label.to(device)\n",
    "    \n",
    "    if inputs.shape[0] == batch_size:\n",
    "    \n",
    "      optimizer.zero_grad()\n",
    "      \n",
    "      predictions, h = model.forward(inputs, h)\n",
    "      \n",
    "      loss = criterion(predictions.squeeze(), labels.float())\n",
    "      loss.backward(retain_graph=True)\n",
    "      \n",
    "      acc = binary_accuracy(predictions.squeeze(), labels.float())\n",
    "      \n",
    "      epoch_loss += loss.item()\n",
    "      epoch_acc += acc.item()\n",
    "\n",
    "      nn.utils.clip_grad_norm_(model.parameters(), clip)\n",
    "\n",
    "      optimizer.step()\n",
    "\n",
    "  return epoch_loss / len(iterator), epoch_acc / len(iterator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1ER-zx01kX0Z"
   },
   "source": [
    "### Function which is gonna evaluate our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EQ3f2aOJEs6j"
   },
   "outputs": [],
   "source": [
    "def evaluate(model, eval_iterator, criterion, batch_size):\n",
    "  \n",
    "  eval_epoch_loss = 0\n",
    "  eval_epoch_acc = 0\n",
    "  \n",
    "  model.eval()\n",
    "  eval_h = model.init_hidden(batch_size)\n",
    "  \n",
    "  with torch.no_grad():\n",
    "  \n",
    "    for eval_batch in eval_iterator:\n",
    "      \n",
    "      if model.cell_type == 'LSTM':\n",
    "        eval_h = tuple([each.data for each in eval_h])\n",
    "      elif model.cell_type == 'GRU':\n",
    "        eval_h.detach_()\n",
    "        eval_h = eval_h.detach()\n",
    "\n",
    "      eval_inputs = eval_batch.Text.to(device)\n",
    "      eval_labels = eval_batch.Label.to(device)\n",
    "\n",
    "      if eval_inputs.shape[0] == batch_size:\n",
    "\n",
    "        eval_predictions, eval_h = model.forward(eval_inputs, eval_h)\n",
    "        \n",
    "        eval_loss = criterion(eval_predictions.squeeze(), eval_labels.float())\n",
    "        \n",
    "        eval_acc = binary_accuracy(eval_predictions.squeeze(), eval_labels.float())\n",
    "\n",
    "        eval_epoch_loss += eval_loss.item()\n",
    "        eval_epoch_acc += eval_acc.item()\n",
    "      \n",
    "  return eval_epoch_loss / len(eval_iterator), eval_epoch_acc / len(eval_iterator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nczHsPowkatE"
   },
   "source": [
    "### Function which calculates each epoch's elapsed time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aMz5OgUcE5i5"
   },
   "outputs": [],
   "source": [
    "def epoch_time(start_time, end_time):\n",
    "  elapsed_time = end_time - start_time\n",
    "  elapsed_mins = int(elapsed_time / 60)\n",
    "  elapsed_secs = int(elapsed_time - (elapsed_mins * 60))\n",
    "  return elapsed_mins, elapsed_secs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kXT9OdX8Ld14"
   },
   "source": [
    "## Train and evaluate our first model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "GlLazd42E9M5",
    "outputId": "6c0ccabf-b3cf-4301-f519-e862e90dc3ab"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 01 | Epoch Time: 0m 32s\n",
      "\tTrain Loss: 0.575 | Val. Loss: 0.469\n",
      "Epoch: 02 | Epoch Time: 0m 32s\n",
      "\tTrain Loss: 0.491 | Val. Loss: 0.449\n",
      "Epoch: 03 | Epoch Time: 0m 32s\n",
      "\tTrain Loss: 0.466 | Val. Loss: 0.439\n",
      "Epoch: 04 | Epoch Time: 0m 34s\n",
      "\tTrain Loss: 0.447 | Val. Loss: 0.418\n",
      "Epoch: 05 | Epoch Time: 0m 32s\n",
      "\tTrain Loss: 0.432 | Val. Loss: 0.406\n",
      "Epoch: 06 | Epoch Time: 0m 32s\n",
      "\tTrain Loss: 0.420 | Val. Loss: 0.408\n",
      "Epoch: 07 | Epoch Time: 0m 32s\n",
      "\tTrain Loss: 0.409 | Val. Loss: 0.400\n",
      "Epoch: 08 | Epoch Time: 0m 32s\n",
      "\tTrain Loss: 0.399 | Val. Loss: 0.385\n",
      "Epoch: 09 | Epoch Time: 0m 32s\n",
      "\tTrain Loss: 0.389 | Val. Loss: 0.385\n",
      "Epoch: 10 | Epoch Time: 0m 33s\n",
      "\tTrain Loss: 0.381 | Val. Loss: 0.404\n"
     ]
    }
   ],
   "source": [
    "train_losses = []\n",
    "val_losses = []\n",
    "train_accs = []\n",
    "val_accs = []\n",
    "clip = 5\n",
    "\n",
    "for epoch in range(epochs):\n",
    "\n",
    "  start_time = time.time()\n",
    "  \n",
    "  train_loss, train_acc = train(model, train_iterator, optimizer, criterion, clip, BATCH_SIZE)\n",
    "  valid_loss, valid_acc = evaluate(model, valid_iterator, criterion, BATCH_SIZE)\n",
    "  \n",
    "  end_time = time.time()\n",
    "\n",
    "  epoch_mins, epoch_secs = epoch_time(start_time, end_time)\n",
    "\n",
    "  train_losses.append(train_loss)\n",
    "  val_losses.append(valid_loss)\n",
    "  train_accs.append(train_acc)\n",
    "  val_accs.append(valid_acc)\n",
    "  \n",
    "  print(f'Epoch: {epoch+1:02} | Epoch Time: {epoch_mins}m {epoch_secs}s') \n",
    "  print(f'\\tTrain Loss: {train_loss:.3f} | Val. Loss: {valid_loss:.3f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IjCUva9S2Wyr"
   },
   "source": [
    "### Loss vs Epochs "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 639
    },
    "id": "99KieYseoo6S",
    "outputId": "035bb1d3-de44-4b97-a008-100c02c25cb9"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,axs = plt.subplots(1,1,figsize=(15,10))\n",
    "\n",
    "early_stopping = 8.1\n",
    "\n",
    "# Plot Train and Validation Losses\n",
    "axs.set_title(\"Train and Validation Losses\",size=25)\n",
    "axs.set_ylabel('Loss', fontsize = 20.0) \n",
    "axs.set_xlabel('Epochs', fontsize = 20) \n",
    "_=axs.plot(train_losses,'-c')\n",
    "_=axs.plot(val_losses,'-m')  \n",
    "_=axs.axvline(x=early_stopping,color='r')\n",
    "_=axs.legend(('Train','Val'),loc='upper right',fontsize='x-large')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uHSNq3seJvZV"
   },
   "source": [
    "> As we can observe after approximately 9th epoch overfitting starts to happen cause training loss keeps falling, but validation loss starts rising up."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GeBHzZWO2hfk"
   },
   "source": [
    "### Classification report "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "z49NXDHf-gV1",
    "outputId": "3355e559-85d8-489a-9c16-02b3b9f5add2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.83      0.69      0.75      1219\n",
      "           1       0.75      0.87      0.80      1281\n",
      "\n",
      "    accuracy                           0.78      2500\n",
      "   macro avg       0.79      0.78      0.78      2500\n",
      "weighted avg       0.79      0.78      0.78      2500\n",
      "\n"
     ]
    }
   ],
   "source": [
    "results = []\n",
    "true_labels = []\n",
    "\n",
    "with torch.no_grad():\n",
    "  for batch in test_iterator:\n",
    "    for temp_label in batch.Label:\n",
    "      true_labels.append(temp_label.item())\n",
    "    for text in batch.Text:\n",
    "      text = text.unsqueeze(0)\n",
    "      res, _ = model.forward(text, hidden=None)\n",
    "      target = np.round(res.cpu().numpy())\n",
    "      results.append(target[0])\n",
    "      \n",
    "print(classification_report(true_labels,results))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pSW0dO_Z2kwT"
   },
   "source": [
    "### ROC Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 520
    },
    "id": "SjxsAEUW_CdV",
    "outputId": "966dfe23-bc82-44f4-ba95-42ef5d266cdd"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Label binarization and store num of classes.\n",
    "y_score = np.array(results)\n",
    "y_test = label_binarize(true_labels, classes=[0, 1])\n",
    "n_classes = y_test.shape[1]\n",
    "\n",
    "# Compute ROC curve and ROC area for each class\n",
    "fpr = dict()\n",
    "tpr = dict()\n",
    "roc_auc = dict()\n",
    "for i in range(n_classes):\n",
    "  fpr[i], tpr[i], _ = roc_curve(y_test[:,i], y_score[:,i])\n",
    "  roc_auc[i] = auc(fpr[i], tpr[i])\n",
    "\n",
    "plt.figure(figsize=(8,8))\n",
    "lw = 2\n",
    "plt.plot(fpr[0], tpr[0], color='darkorange',lw=lw, label='ROC curve (area = %0.2f)' % roc_auc[0])\n",
    "plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate',fontsize=15)\n",
    "plt.ylabel('True Positive Rate',fontsize=15)\n",
    "plt.title('Receiver operating characteristic example',fontsize=15)\n",
    "plt.legend(loc=\"lower right\",fontsize=15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "G-50J5Ff2waC"
   },
   "source": [
    "### Our final model's hyperparameters "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dPdnbAfj21Tv"
   },
   "source": [
    "> 1. ***LSTM or GRU***\n",
    "\n",
    "    This was the most difficult choice among our hyperparameters, cause it seemed that LSTM and GRU gave us same \n",
    "    results, so they performed well both of them. But finaly we prefered LSTM model and we are gonna explain the reasons \n",
    "    later thoroughly!\n",
    "\n",
    "> 2. ***Bidirectional***\n",
    "  \n",
    "    As a project's requirement we created multiple times only bidirectional models! \n",
    "\n",
    "> 3. ***Number of Layers***\n",
    "\n",
    "    We tried different number of stacked layers on our GRU models, in range of  [2,4], but we conclude that a simpler \n",
    "    model performs greater so 2 layers was our best choice.\n",
    "\n",
    "> 4. ***Hidden Size***\n",
    "\n",
    "    We've been experimented with values in range of [32,512] picking up values which are powers of 2 (2^k). And seems \n",
    "    that the magic number for hidden size of GRU model was 128. Note that because we have bidirectional model after LSTM \n",
    "    model our Linear layer's hidden size innerly is multiplied by 2.\n",
    "   \n",
    "> 5. ***Glove Embedding's Dimensions***\n",
    "\n",
    "    GloVe pre trained embeddings give us the flexibility to choose whichever dimensions we prefer from a variety of \n",
    "    dimensions [25,300]. Due to memory's limit we have to choose something that suits us and finally our choice was 50 \n",
    "    dimensions for each vector. Note that with GloVe we created a vocabulary with top 20.000 'popular' words, because we \n",
    "    observed that we get pretty same results with a vocabulary with all words of our tweets.\n",
    "\n",
    "> 6. ***Dropout***\n",
    "\n",
    "    Firstly we put dropout layer inside GRU model and right after GRU model with a small dropout probality equaled to \n",
    "    0.2. This helped train and validation loss decrease with same rhythm. \n",
    "\n",
    "> 7. ***Optimizer***\n",
    "\n",
    "    From our theory and so much information out there Adam optimizer was very popular, so it was our stable choice.\n",
    "\n",
    "> 8. ***Loss Function***\n",
    "\n",
    "    Also here, cause our problem is binary sentiment classification and due to the fact that our model has a final \n",
    "    sigmoid layer, loss function is Binary Cross Entropy Loss.\n",
    "\n",
    "> 9. ***Epochs***\n",
    "\n",
    "    Turns out that we only need 5-10 epochs to reach the appropriate result that we aimed to.\n",
    "\n",
    "> 10. ***Learning Rate***\n",
    "\n",
    "    The most important hyperparameter was learning rate and after many experiments 2e-3 was pretty descent.\n",
    "   \n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qPFy9zeF39CV"
   },
   "source": [
    "#### Notes about model's improvement procedure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Wrz9qI0W3-Xy"
   },
   "source": [
    "    Our mindset was first to experiment with one LSTM bidirectional model and find best hyperparameters. We tried firstly to \n",
    "    give us training input dataset of 1.200.000 tweets with split of train and validation/test set with ratio 99%-1%.\n",
    "    This affected our test's accuracy were we managed to gain around 0.69 score, so we decided to give as input the same \n",
    "    number of tweets that we gave in previous best model, which was half of million, which helped us cause our \n",
    "    experiments last less. So we found our dataset size, 500.000 tweets.\n",
    "\n",
    "    After that we tried to find out number of hidden size and number of (stacked) layers on our LSTM model...so we \n",
    "    started from 512 hidden size and 6 layers, because from theory we knew that deeper and complex models have more \n",
    "    potential to perform better. But in contrast to theory we conclude that our model is too complex and that causes \n",
    "    overfitting too much and very bad performance. So we tried firstly to solve that problem of overfitting with adding \n",
    "    inside our LSTM model and right after it dropout layers, with dropout probability range from 0.3 to 0.9. But still \n",
    "    problem of overfitting was there, even though we add weight regularization parameter in our optimizer. So next step was \n",
    "    to make our model less complex so we gradually tried to decrease number of layers and hidden size, so after many \n",
    "    experiments we saw that overfitting started to be a past problem.\n",
    "\n",
    "    So in that point we have locked hidden size to 128 and num of layers 2 (minimum number of layers cause we have \n",
    "    bidirectional model). Learning rate was under research cause some times 1e-2 was pretty good, however other times \n",
    "    1e-2 was too big so we then change it to 1e-3, until we found that 2e-3 was something like our upper boundary. \n",
    "    \n",
    "    Something pretty important was dropout probability, cause when we tried to experiment with model with dropout at all \n",
    "    our model performed worse than when we had a small dropout probability equaled to 0.2, which was our final choice.\n",
    "\n",
    "    Notice that our final choice of batch size was 512, because with that value we managed to avoid overfitting \n",
    "    (cause with small number of batch size, i.e. 32 our model chunked tweets more pieces and was learning much faster, \n",
    "    leading to huge undefeated overfitting). As a plus, with batch size be 512 our experiments last less than when we gave\n",
    "    small values.\n",
    "\n",
    "    Also, we didn't expect that length of vocabulary of pre trained glove model will affect LSTM model, which is our \n",
    "    Embedding's layer input dimension. More specifically it seems that when we didn't use max_size as a parameter, that\n",
    "    leading to the fact that we gave to embedding layer all words of all tweets (whole information) our model was \n",
    "    getting too much information which maybe confused it. On the other hand when we picked our 20.000 most popular words\n",
    "    with each word have a frequency of at least 5 times, maybe model performed better, cause it had as input an \n",
    "    amount of information that could manipulate.\n",
    "\n",
    "    As a note from theory to avoid vanishing gradients we can use gradient clipping, so I used it in with clip equaled to\n",
    "    5 and only to be sure I removed it so as to check if it helps model's training and this was for sure true!\n",
    "\n",
    "    Last but not least, we have to try GRU model instead of LSTM, which are more complex as structure compared to GRUs. \n",
    "    As we have already refered GRU and LSTM model with same hyperparameters had same performance, with only difference \n",
    "    of them be time of training, where GRU needed half time in each epoch compared to LSTM model. Our theory approves \n",
    "    that these two types of RNNs have slight differences, but GRUs are gradually gaining ground due to their simpler \n",
    "    structure (compared to LSTMs). Although we finally prefered LSTM model, because learning curves were smoothier in \n",
    "    validation and training loss. Note that from theory we expected, that due to different number of gates (2 for GRU \n",
    "    and 3 for LSTM), to have different results-performance from these two types of RNNs but didn't come true, which may \n",
    "    be due to our tweet dataset.\n",
    "\n",
    "    After all these experiments, overfitting was avoided until 9th epoch were we 'early stopped' LSTM's training,because \n",
    "    validation loss starts rising compared to training loss."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fUeuPWliMspN"
   },
   "source": [
    "#### Compare our final LSTM model with our previous TfIdf Vectorized best model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VTHGHKPmQ78d"
   },
   "source": [
    "    1. Firstly we are going to compare our final LSTM model and our previous TfIdf best model based on their scores on \n",
    "    test's dataset. Both models manage to gain a pretty descent score of 0.78 accuracy. Note that in both models train \n",
    "    dataset size was half million cleaned tweets.\n",
    "\n",
    "    2. The big difference between our two models performance is the speed of convergence. More specifically, previous \n",
    "    TfIdf best model achieved 0.78 score in 30 epochs, but our new LSTM model made it in only 10 epochs! This fact is due\n",
    "    to the fact that LSTM model has much more complex structure compared to simple feed forward neural network.\n",
    "\n",
    "    3. Another difference between our two models is that TfIdf model performed 0.78 accuracy in our 3 metrics (Precision,\n",
    "    Recall,F1-Score). However, it seems that our LSTM model gained a variety from 0.69 to 0.87. Also ROC curve for TfIdf \n",
    "    gave us 0.86, but LSTM achieved only 0.78 score. \n",
    "\n",
    "    4. From our theory we expected that our new LSTM model will perform noticeably better than TfIdf model, cause this \n",
    "    kind of problems (classification on text or speech data) is often solved with LSTM or GRU models, or generally with \n",
    "    RNNs, but this belief didn't come true. But maybe the fact, that our previous model had as input TfIdf vectorized \n",
    "    data, with each dimensions of each tweet be 1000 helped our linear layers to have more information leading to \n",
    "    descent score. For our LSTM model embedding layer's dimensions was 50.\n",
    "\n",
    "    5. Some more details about FFNN vs RNN...Let's see firstly about FNNNs!\n",
    "    FFNNs allow signals to travel one way only: from input to output. There are no feedback, loops...so we conclude that \n",
    "    output of any layer does not affect that same layer. Feed-forward ANNs tend to be straightforward networks that \n",
    "    associate inputs with outputs. They are extensively used in pattern recognition. This type of organisation is also \n",
    "    referred to as bottom-up or top-down.\n",
    "    RNNs from the other side, and our specific cell type LSTM models can 'travel' to two ways and for that reason we \n",
    "    call them interactive or dynamic. So all kinds of RNNs have feedback loops in the recurrent layer and thus maintain \n",
    "    information in 'memory' over time. LSTM networks are a type of RNN that uses special units in addition to standard \n",
    "    units. LSTM units include a 'memory cell' that can maintain information in memory for long periods of time. A set of \n",
    "    gates is used to control when information enters the memory, when it's output, and when it's forgotten. This \n",
    "    architecture lets them learn longer-term dependencies. GRUs are similar to LSTMs, but use a simplified structure. \n",
    "    They also use a set of gates to control the flow of information, but they don't use separate memory cells, and they\n",
    "    use fewer gates.\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "LSTM/GRU_Classifier.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}