Seq2Seq_BiDirectional_Encoding.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sequence - To - Sequence Bi-directional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ! pip install torchtext==0.6.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import locale\n",
    "# locale.getpreferredencoding = lambda: \"UTF-8\"\n",
    "\n",
    "# ! pip install -U spacy\n",
    "# ! python -m spacy download fr_core_news_sm\n",
    "# ! python -m spacy download en_core_web_sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-07-04 07:42:54.232657: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX_VNNI FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-07-04 07:42:54.307860: I tensorflow/core/util/port.cc:104] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-07-04 07:42:54.634689: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n",
      "2023-07-04 07:42:54.634752: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n",
      "2023-07-04 07:42:54.634755: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n",
      "2023-07-04 07:42:55.001132: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-07-04 07:42:55.018243: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-07-04 07:42:55.018348: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torchtext\n",
    "\n",
    "import time\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import spacy\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import IPython.display as display\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.backends.mps.is_available():\n",
    "    DEVICE = torch.device(device='mps')\n",
    "elif torch.cuda.is_available():\n",
    "    DEVICE = torch.device(device='cuda')\n",
    "else:\n",
    "    DEVICE = torch.device(device='cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "print(DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "spacy_en = spacy.load('en_core_web_sm')\n",
    "spacy_fr = spacy.load('fr_core_news_sm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "french = torchtext.data.Field(tokenize= lambda text: [token.text for token in spacy_en.tokenizer(text)],\n",
    "                              lower = True,\n",
    "                              init_token = '<sos>',\n",
    "                              eos_token = '<eos>')\n",
    "\n",
    "english = torchtext.data.Field(tokenize= lambda text: [token.text for token in spacy_fr.tokenizer(text)],\n",
    "                              lower = True,\n",
    "                              init_token = '<sos>',\n",
    "                              eos_token = '<eos>')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "fields = {\n",
    "    'English': ('eng', english),\n",
    "    'French': ('fre', french)\n",
    "}\n",
    "\n",
    "train_data, test_data = torchtext.data.TabularDataset.splits(\n",
    "    path='data/',\n",
    "    train='train_full.csv',\n",
    "    test = 'test_full.csv',\n",
    "    format='csv',\n",
    "    fields=fields\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "english.build_vocab(train_data, max_size = 10000, min_freq = 2)\n",
    "french.build_vocab(train_data, max_size = 10000, min_freq = 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 64\n",
    "train_iterator, test_iterator = torchtext.data.BucketIterator.splits(\n",
    "    (train_data, test_data),\n",
    "    batch_size = batch_size,\n",
    "    sort_within_batch = True, # Protizes to have examples are of similar length in a batch, because it reduces padding and save compute.\n",
    "    sort_key = lambda x: len(getattr(x, 'eng')), # Protizes to have examples are of similar length in a batch, because it reduces padding and save compute.\n",
    "    device=DEVICE\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "pad_idx = french.vocab.stoi['<pad>']\n",
    "criterion = torch.nn.CrossEntropyLoss(ignore_index=pad_idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_epoch_train(model: torch.nn.Module, data_loader_train: torch.utils.data.DataLoader,\n",
    "                    loss_criterion: torch.nn, optim_alog: torch.optim) -> tuple:\n",
    "    \"\"\"Function that trains the model for one epoch.\n",
    "\n",
    "    Args:\n",
    "        model (torch.nn.Module): Pytorch model we want to train.\n",
    "        data_loader_train (torch.utils.data.DataLoader): Pytorch dataloader that carries training data.\n",
    "        loss_criterion (torch.nn): Pytorch loss criteria on which we calculate loss.\n",
    "        optim_alog (torch.optim): Opimiztion algoritham that we use to update model weights.\n",
    "\n",
    "    Returns:\n",
    "        tuple: Tuple carrying Train loss and accuracy\n",
    "    \"\"\"\n",
    "    batch_loss_train = []\n",
    "    batch_counter = 0\n",
    "    for batch in data_loader_train:\n",
    "        input_text = batch.eng.to(DEVICE).permute(1,0)\n",
    "        target_text = batch.fre.to(DEVICE).permute(1,0)\n",
    "\n",
    "\n",
    "        # Enabling model training.\n",
    "        model.train(True)\n",
    "\n",
    "\n",
    "        #Setting gradients to zero to prevent gradient accumulation.\n",
    "        optim_alog.zero_grad()\n",
    "\n",
    "        # Forward pass.\n",
    "        y_pred_prob = model(input_text, target_text)\n",
    "        \n",
    "        y_pred_prob = y_pred_prob[:,1:,:].reshape(-1, y_pred_prob.shape[2])\n",
    "        target_text = target_text[:, 1:].reshape(-1)\n",
    "\n",
    "        loss = loss_criterion(y_pred_prob, target_text)\n",
    "\n",
    "        batch_loss_train.append(loss.item())\n",
    "\n",
    "        # Back Propagation\n",
    "        loss.backward()\n",
    "\n",
    "        # Gradient clipping to prevent exploding gradients\n",
    "        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1)\n",
    "\n",
    "        # Updating weights\n",
    "        optim_alog.step()\n",
    "        \n",
    "        batch_counter += 1\n",
    "\n",
    "        del(input_text)\n",
    "        del(target_text)\n",
    "\n",
    "    return sum(batch_loss_train)/batch_counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inference(model: torch.nn.Module, data_loader_val: torch.utils.data.DataLoader, loss_criterion: torch.nn) -> tuple:\n",
    "    \"\"\"Function that calculates test accuracy\n",
    "\n",
    "    Args:\n",
    "        model (torch.nn.Module): Pytorch model we want to make inference on.\n",
    "        data_loader_val (torch.utils.data.DataLoader): Pytorch dataloader that carries validation data.\n",
    "        loss_criterion (torch.nn): Pytorch loss criteria on which we calculate loss.\n",
    "\n",
    "    Returns:\n",
    "        tuple: Tuple carrying Test loss and accuracy\n",
    "    \"\"\"\n",
    "\n",
    "    batch_loss_train = []\n",
    "    batch_counter = 0\n",
    "\n",
    "    for batch in data_loader_val:\n",
    "        input_text = batch.eng.to(DEVICE).permute(1,0)\n",
    "        target_text = batch.fre.to(DEVICE).permute(1,0)\n",
    "\n",
    "        # Disabiling model training.\n",
    "        model.train(False)\n",
    "\n",
    "        with torch.inference_mode():\n",
    "            # Forward Pass\n",
    "            y_pred_prob = model(input_text, target_text)\n",
    "\n",
    "            y_pred_prob = y_pred_prob[:,1:,:].reshape(-1, y_pred_prob.shape[2])\n",
    "            target_text = target_text[:, 1:].reshape(-1)\n",
    "\n",
    "            # Calculating Loss\n",
    "            loss = loss_criterion(y_pred_prob, target_text)\n",
    "            batch_loss_train.append(loss.item())\n",
    "\n",
    "        batch_counter += 1\n",
    "\n",
    "        del(input_text)\n",
    "        del(target_text)\n",
    "\n",
    "    return sum(batch_loss_train)/batch_counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def training_loop(\n",
    "    model: torch.nn.Module,\n",
    "    data_loader_train: torch.utils.data.DataLoader,\n",
    "    data_loader_val: torch.utils.data.DataLoader,\n",
    "    epochs:int,\n",
    "    loss_criterion: torch.nn,\n",
    "    optim_alog: torch.optim,\n",
    "    chkpt_file:str,\n",
    "    final_load_file:str\n",
    ")-> dict:\n",
    "    \"\"\"Function that trains the model for the given number of epochs\n",
    "\n",
    "    Args:\n",
    "        model (torch.nn.Module): Pytorch model we want to train.\n",
    "        data_loader_train (torch.utils.data.DataLoader): Pytorch dataloader that carries training data.\n",
    "        data_loader_val (torch.utils.data.DataLoader): Pytorch dataloader that carries validation data.\n",
    "        epochs (int): Count of EPOCHS\n",
    "        loss_criterion (torch.nn): Pytorch loss criteria on which we calculate loss.\n",
    "        optim_alog (torch.optim): Opimiztion algoritham that we use to update model weights.\n",
    "\n",
    "    Returns:\n",
    "        dict: A dictionary that carries the output metrics.\n",
    "    \"\"\"\n",
    "    start_time = time.time()\n",
    "\n",
    "    loss_train = []\n",
    "    loss_val = []\n",
    "    \n",
    "    best_loss_val = 1e5\n",
    "    # Loop that iterates over each EPOCH\n",
    "    for epoch in range(epochs):\n",
    "\n",
    "        #Train the model for one EPOCH\n",
    "        epoch_loss = one_epoch_train(model, data_loader_train, loss_criterion, optim_alog)\n",
    "        loss_train.append(epoch_loss)\n",
    "\n",
    "        # Caluclating Testing results\n",
    "        val_loss = inference(model, data_loader_val, loss_criterion)\n",
    "        loss_val.append(val_loss)\n",
    "\n",
    "        if val_loss < best_loss_val:\n",
    "            best_loss_val = val_loss\n",
    "            torch.save(model.state_dict(), chkpt_file)\n",
    "\n",
    "        if (epoch+1)%1 == 0:\n",
    "            print('For Epoch {} We Train Loss:{:.4f}, Val Loss:{:.4f}, Time Elapsed:{:.4f} mins'.format(epoch+1, epoch_loss,val_loss, (time.time() - start_time)/60))\n",
    "            \n",
    "    torch.save(model.state_dict(), final_load_file)\n",
    "    return {'training_loss':loss_train, 'val_loss':loss_val}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_metrics(epochs: int,metrics: dict) -> None:\n",
    "    \"\"\"Plot the graphs of Training and Testing Accuracy and Loss across Epoches\n",
    "\n",
    "    Args:\n",
    "        epochs (int): Number of Epochs\n",
    "        metrics (dict): A dictionary containing Test and Training datasets' Loss and accuracy\n",
    "    \"\"\"\n",
    "\n",
    "    plt.figure(figsize=(10,10))\n",
    "    plt.plot(list(range(epochs)), metrics['training_loss'])\n",
    "    plt.plot(list(range(epochs)), metrics['val_loss'])\n",
    "    plt.grid()\n",
    "    plt.legend(['Train', 'Test'])\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.title('Train and Validation loss across epochs')\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sentence_translator(model: torch.nn.Module, sentence: str, src_corpus: torchtext.data.Field, tgt_corpus: torchtext.data.Field) -> list:\n",
    "    \"\"\"Given the model and english sentence it will translate the english sentence to french.\n",
    "\n",
    "    Args:\n",
    "        model (torch.nn.Model): Pytorch Model\n",
    "        sentence (str): English sentence\n",
    "        src_corpus (torchtext.data.Field): English Corpus (Source Torchtext data field)\n",
    "        tgt_corpus (torchtext.data.Field): French Corpus (Destination Torchtext data field)\n",
    "\n",
    "    Returns:\n",
    "        list: List of words \n",
    "    \"\"\"\n",
    "    \n",
    "    # Checking If the sentence is string or not.\n",
    "    if isinstance(sentence, str):\n",
    "        tokens = [token.text.lower() for token in spacy_en(sentence)]\n",
    "    else:\n",
    "        tokens = [token.lower() for token in sentence]\n",
    "        \n",
    "    # Attaching <SOS> token at the beginning of the source sentence\n",
    "    tokens.insert(0, src_corpus.init_token)\n",
    "    \n",
    "    # Attaching <EOS> token at the end of the source sentence\n",
    "    tokens.append(src_corpus.eos_token)\n",
    "    \n",
    "    # Converting the soruce text to sentence vector \n",
    "    sentence_vector =[]\n",
    "    for token in tokens:\n",
    "        sentence_vector.append(src_corpus.vocab.stoi[token])\n",
    "        \n",
    "    # Creating a tensor from the vector\n",
    "    sentence_tensor = torch.tensor(sentence_vector, dtype=torch.long).unsqueeze(1).to(DEVICE).permute(1,0)\n",
    "    \n",
    "    # Performing encoding\n",
    "    with torch.inference_mode():\n",
    "        hidden_state, cell_state = model.encoder(sentence_tensor)\n",
    "        \n",
    "    # Attaching <SOS> token at the beginning of the destination sentence. \n",
    "    outputs = [tgt_corpus.vocab.stoi[\"<sos>\"]]\n",
    "    \n",
    "    # Iteration over and producing the sequnce of words of the translated sentence. \n",
    "    for _ in range(30):\n",
    "        \n",
    "        # Getting previous word to pass it to decoder\n",
    "        prev_word = torch.tensor([outputs[-1]], dtype=torch.long).to(DEVICE)\n",
    "        \n",
    "        # Performing Decoding\n",
    "        with torch.inference_mode():\n",
    "            output, hidden_state, cell_state = model.decoder(prev_word, hidden_state, cell_state)\n",
    "            # Predicting the word\n",
    "            word_pred = torch.argmax(output, axis=1).item()\n",
    "            \n",
    "        # Append the Predicted word \n",
    "        outputs.append(word_pred)\n",
    "        \n",
    "        # On reaching end of the sentence break the loop\n",
    "        if word_pred == tgt_corpus.vocab.stoi[\"<eos>\"]:\n",
    "            break\n",
    "    \n",
    "    # Converting translated sentence vector to translated sentence.\n",
    "    translated_sentence = []\n",
    "    for idx in outputs:\n",
    "        translated_sentence.append(tgt_corpus.vocab.itos[idx])\n",
    "\n",
    "    return translated_sentence[1:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def score_bleu(\n",
    "    dataset: torchtext.data.TabularDataset.splits,\n",
    "    model: torch.nn.Module,\n",
    "    src_corpus: torchtext.data.Field,\n",
    "    tgt_corpus: torchtext.data.Field\n",
    ") -> int:\n",
    "\n",
    "    \"\"\" Get BLeU score of the given dataset and its translation.\n",
    "\n",
    "    Args:\n",
    "        dataset (torchtext.data.TabularDataset.splits): torch text data set\n",
    "        model (torch.nn.Model): pytorch model\n",
    "        src_corpus (torchtext.data.Field): English Corpus (Source Torchtext data field)\n",
    "        tgt_corpus (torchtext.data.Field): French Corpus (Destination Torchtext data field)\n",
    "\n",
    "    Returns:\n",
    "        int: Bleu score of the translation.\n",
    "    \"\"\"\n",
    "    targets = []\n",
    "    outputs = []\n",
    "\n",
    "    for translation_record in dataset:\n",
    "        source_sentence = vars(translation_record)[\"eng\"]\n",
    "        target_sentence = vars(translation_record)[\"fre\"]\n",
    "\n",
    "        translated_sentence = sentence_translator(model, source_sentence, src_corpus, tgt_corpus)\n",
    "\n",
    "        targets.append([target_sentence])\n",
    "        outputs.append(translated_sentence)\n",
    "\n",
    "    return torchtext.data.metrics.bleu_score(outputs, targets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def score_bleu_by_length(\n",
    "    dataset: torchtext.data.TabularDataset.splits,\n",
    "    model: torch.nn.Module,\n",
    "    src_corpus: torchtext.data.Field,\n",
    "    tgt_corpus: torchtext.data.Field\n",
    ") -> dict:\n",
    "    \"\"\" Get BLeU score of the given dataset and its translation.\n",
    "\n",
    "    Args:\n",
    "        dataset (torchtext.data.TabularDataset.splits): torch text data set\n",
    "        model (torch.nn.Model): pytorch model\n",
    "        src_corpus (torchtext.data.Field): English Corpus (Source Torchtext data field)\n",
    "        tgt_corpus (torchtext.data.Field): French Corpus (Destination Torchtext data field)\n",
    "\n",
    "    Returns:\n",
    "        dict: Bleu score of the translation.\n",
    "    \"\"\"\n",
    "    data_map = {}\n",
    "\n",
    "    for translation_record in dataset:\n",
    "        source_sentence = vars(translation_record)[\"eng\"]\n",
    "        target_sentence = vars(translation_record)[\"fre\"]\n",
    "\n",
    "        translated_sentence = sentence_translator(model, source_sentence, src_corpus, tgt_corpus)\n",
    "        \n",
    "        src_length = len(source_sentence)\n",
    "        \n",
    "        if data_map.get(src_length) is None:\n",
    "            data_map[src_length] = {\n",
    "                \"targets\": [],\n",
    "                \"outputs\": []\n",
    "            }\n",
    "\n",
    "        data_map[src_length][\"targets\"].append([target_sentence])\n",
    "        data_map[src_length][\"outputs\"].append(translated_sentence)\n",
    "    \n",
    "    results = {\n",
    "        \"length\": [],\n",
    "        \"count\": [],\n",
    "        \"bleu_score\": []\n",
    "    }\n",
    "    for length, data in data_map.items():\n",
    "        bleu_score = torchtext.data.metrics.bleu_score(data[\"outputs\"], data[\"targets\"])\n",
    "        \n",
    "        results[\"length\"].append(length)\n",
    "        results[\"count\"].append(len(data[\"targets\"]))\n",
    "        results[\"bleu_score\"].append(bleu_score)\n",
    "        \n",
    "    return results "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Building"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Encoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Encoder(torch.nn.Module):\n",
    "    \"\"\"\n",
    "    Encode the original sentence to context vector\n",
    "    \n",
    "    Args:\n",
    "        input_size (int): Input Dimension\n",
    "        embedding_size (int): Word Embedding Size\n",
    "        hidden_size (int): RNN Output Size\n",
    "        num_layers (int): Num of Layers of RNN\n",
    "        droput_prob (float): Dropout Probability\n",
    "    \"\"\"\n",
    "    def __init__(\n",
    "        self,\n",
    "        input_size: int,\n",
    "        embedding_size: int,\n",
    "        hidden_size: int,\n",
    "        num_layers: int,\n",
    "        droput_prob: float\n",
    "    ):\n",
    "        super(Encoder, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.num_layers = num_layers\n",
    "\n",
    "        self.dropout = torch.nn.Dropout(droput_prob)\n",
    "        self.embedding = torch.nn.Embedding(input_size, embedding_size)\n",
    "\n",
    "        self.lstm = torch.nn.LSTM(embedding_size, hidden_size, num_layers, batch_first=True, \n",
    "                                  bidirectional = True, dropout=droput_prob)\n",
    "        \n",
    "        self.linear_hidden = torch.nn.Linear(hidden_size*2, hidden_size)\n",
    "        self.linear_cell = torch.nn.Linear(hidden_size*2, hidden_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        word_embedding = self.dropout(self.embedding(x))\n",
    "\n",
    "        _ , (hidden_state, cell_state) = self.lstm(word_embedding)\n",
    "        \n",
    "        hidden_state = torch.cat((\n",
    "            hidden_state[0:self.num_layers],\n",
    "            hidden_state[self.num_layers:2*self.num_layers]\n",
    "        ), dim=2)\n",
    "        hidden_state = self.linear_hidden(hidden_state)\n",
    "        \n",
    "        cell_state = torch.cat((\n",
    "            cell_state[0:self.num_layers],\n",
    "            cell_state[self.num_layers:2*self.num_layers]\n",
    "        ), dim=2)\n",
    "        cell_state = self.linear_cell(cell_state)\n",
    "        \n",
    "        return hidden_state, cell_state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Decoder(torch.nn.Module):\n",
    "    \"\"\"\n",
    "    Decode the context vector to target sentence word by word\n",
    "    \n",
    "    Args:\n",
    "        input_size (int): Input Dimension\n",
    "        embedding_size (int): Word Embedding Size\n",
    "        hidden_size (int): RNN Output Size\n",
    "        output_size (int): Target language Vocab Size\n",
    "        num_layers (int): Num of Layers of RNN\n",
    "        droput_prob (float): Dropout Probability\n",
    "    \"\"\"\n",
    "    def __init__(\n",
    "        self,\n",
    "        input_size: int,\n",
    "        embedding_size: int,\n",
    "        hidden_size: int,\n",
    "        output_size: int,\n",
    "        num_layers: int,\n",
    "        droput_prob: float\n",
    "    ):\n",
    "        super(Decoder, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.num_layers = num_layers\n",
    "\n",
    "        self.droput = torch.nn.Dropout(droput_prob)\n",
    "        self.embedding = torch.nn.Embedding(input_size, embedding_size)\n",
    "\n",
    "        self.lstm = torch.nn.LSTM(embedding_size, hidden_size, num_layers, batch_first=True, dropout=droput_prob)\n",
    "        self.linear = torch.nn.Linear(hidden_size, output_size)\n",
    "\n",
    "    def forward(self, x, hidden_state, cell_state):\n",
    "        x = x.unsqueeze(1)\n",
    "\n",
    "        word_embedding = self.droput(self.embedding(x))\n",
    "        \n",
    "        output, (hidden_state, cell_state) = self.lstm(word_embedding, (hidden_state, cell_state))\n",
    "\n",
    "        pred = self.linear(output)        \n",
    "        pred = pred.squeeze(1)\n",
    "     \n",
    "        return pred, hidden_state, cell_state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Seq-2-Seq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Seq2Seq(torch.nn.Module):\n",
    "    \"\"\"\n",
    "    Takes Src texts and translates into target word by word\n",
    "    \n",
    "    Args:\n",
    "        input_size_encoder (int): Encoder Input Dimension\n",
    "        encoder_embedding_size (int): Encoder Word Embedding Size\n",
    "        input_size_decoder (int): Decoder Input Dimension\n",
    "        decoder_embedding_size (int): Decoder Word Embedding Size\n",
    "        hidden_size (int): RNN Output Size\n",
    "        output_size (int): Target language Vocab Size\n",
    "        num_layers (int): Num of Layers of RNN\n",
    "        encoder_dropout (float): Encoder Dropout Probability\n",
    "        decoder_dropout (float): Decoder Dropout Probability\n",
    "        word_alignment_ratio(float): Word Alignment Ratio\n",
    "    \"\"\"\n",
    "    def __init__(\n",
    "        self,\n",
    "        input_size_encoder: int,\n",
    "        encoder_embedding_size: int,\n",
    "        input_size_decoder: int ,\n",
    "        decoder_embedding_size: int,\n",
    "        hidden_size: int, \n",
    "        num_layers: int,\n",
    "        output_size: int,\n",
    "        encoder_dropout: float,\n",
    "        decoder_dropout: float,\n",
    "        word_alignment_ratio=0.6\n",
    "    ):\n",
    "        \n",
    "        super(Seq2Seq, self).__init__()\n",
    "\n",
    "        self.encoder = Encoder(\n",
    "            input_size_encoder,\n",
    "            encoder_embedding_size,\n",
    "            hidden_size,\n",
    "            num_layers,\n",
    "            encoder_dropout\n",
    "        ).to(DEVICE)\n",
    "\n",
    "        self.decoder = Decoder(\n",
    "            input_size_decoder,\n",
    "            decoder_embedding_size,\n",
    "            hidden_size,\n",
    "            output_size,\n",
    "            num_layers,\n",
    "            decoder_dropout\n",
    "        ).to(DEVICE)\n",
    "        \n",
    "        # Probability Mass Function defined for the word_selection we should choose\n",
    "        self.next_word_selection_actions = [\n",
    "            'Guess',\n",
    "            'Truth'\n",
    "        ]\n",
    "        self.next_word_selection_probability_distribution = [\n",
    "            word_alignment_ratio,\n",
    "            1 - word_alignment_ratio\n",
    "        ]\n",
    "\n",
    "    def forward(self, src_text, tgt_text):\n",
    "        batch_size = src_text.shape[0]\n",
    "        target_len = tgt_text.shape[1]\n",
    "        target_vocab_size = len(french.vocab)\n",
    "\n",
    "        outputs = torch.zeros(batch_size, target_len,target_vocab_size).to(device=DEVICE)\n",
    "\n",
    "        hidden_state, cell_state = self.encoder(src_text)\n",
    "        \n",
    "        # Grab Start Token\n",
    "        x = tgt_text[:,0]\n",
    "\n",
    "        for t in range(1, target_len):\n",
    "            output, hidden_state, cell_state = self.decoder(x, hidden_state, cell_state)\n",
    "            outputs[:, t, :] = output\n",
    "            \n",
    "            # Sampling type word to select based on the above defined Probability Mass Function.\n",
    "            word_to_choose = np.random.choice(\n",
    "                a = self.next_word_selection_actions,\n",
    "                size = 1, \n",
    "                p= self.next_word_selection_probability_distribution\n",
    "            )\n",
    "            \n",
    "            if word_to_choose == 'Guess':\n",
    "                x = torch.argmax(output, dim=1)\n",
    "            else:\n",
    "                x = tgt_text[:,t]\n",
    "\n",
    "\n",
    "        return outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq_2_seq_model = Seq2Seq(\n",
    "    input_size_encoder=len(english.vocab),\n",
    "    encoder_embedding_size = 300, \n",
    "    input_size_decoder = len(french.vocab),\n",
    "    decoder_embedding_size = 300,\n",
    "    hidden_size = 512, \n",
    "    num_layers = 2,\n",
    "    output_size = len(french.vocab),\n",
    "    encoder_dropout = 0.5,\n",
    "    decoder_dropout = 0.5\n",
    ").to(DEVICE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "chkpt_file = 'saved_files/bidirectional_best.pt'\n",
    "final_load_file = 'saved_files/bidirectional_final.pt'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "EPOCHS = 50\n",
    "optimizer = torch.optim.Adam(seq_2_seq_model.parameters(), lr=3e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For Epoch 1 We Train Loss:4.6388, Val Loss:3.9407, Time Elapsed:2.6123 mins\n",
      "For Epoch 2 We Train Loss:3.7265, Val Loss:3.3916, Time Elapsed:5.2854 mins\n",
      "For Epoch 3 We Train Loss:3.2700, Val Loss:3.0381, Time Elapsed:7.9065 mins\n",
      "For Epoch 4 We Train Loss:2.9559, Val Loss:2.7925, Time Elapsed:10.6022 mins\n",
      "For Epoch 5 We Train Loss:2.7104, Val Loss:2.5666, Time Elapsed:13.2789 mins\n",
      "For Epoch 6 We Train Loss:2.5224, Val Loss:2.4611, Time Elapsed:15.9338 mins\n",
      "For Epoch 7 We Train Loss:2.3658, Val Loss:2.3680, Time Elapsed:18.5553 mins\n",
      "For Epoch 8 We Train Loss:2.2342, Val Loss:2.2332, Time Elapsed:21.1885 mins\n",
      "For Epoch 9 We Train Loss:2.1226, Val Loss:2.2156, Time Elapsed:23.7990 mins\n",
      "For Epoch 10 We Train Loss:2.0252, Val Loss:2.1510, Time Elapsed:26.4377 mins\n",
      "For Epoch 11 We Train Loss:1.9396, Val Loss:2.1112, Time Elapsed:29.0466 mins\n",
      "For Epoch 12 We Train Loss:1.8586, Val Loss:2.0787, Time Elapsed:31.6575 mins\n",
      "For Epoch 13 We Train Loss:1.8001, Val Loss:2.0557, Time Elapsed:34.2673 mins\n",
      "For Epoch 14 We Train Loss:1.7341, Val Loss:2.0199, Time Elapsed:36.8815 mins\n",
      "For Epoch 15 We Train Loss:1.6835, Val Loss:1.9813, Time Elapsed:39.5321 mins\n",
      "For Epoch 16 We Train Loss:1.6316, Val Loss:1.9962, Time Elapsed:42.1530 mins\n",
      "For Epoch 17 We Train Loss:1.5863, Val Loss:1.9567, Time Elapsed:44.7374 mins\n",
      "For Epoch 18 We Train Loss:1.5427, Val Loss:1.9622, Time Elapsed:47.3195 mins\n",
      "For Epoch 19 We Train Loss:1.4982, Val Loss:1.9343, Time Elapsed:49.9050 mins\n",
      "For Epoch 20 We Train Loss:1.4643, Val Loss:1.9557, Time Elapsed:52.4925 mins\n",
      "For Epoch 21 We Train Loss:1.4333, Val Loss:1.8956, Time Elapsed:55.1339 mins\n",
      "For Epoch 22 We Train Loss:1.3915, Val Loss:1.8982, Time Elapsed:57.7221 mins\n",
      "For Epoch 23 We Train Loss:1.3655, Val Loss:1.8839, Time Elapsed:60.3781 mins\n",
      "For Epoch 24 We Train Loss:1.3401, Val Loss:1.9292, Time Elapsed:63.0024 mins\n",
      "For Epoch 25 We Train Loss:1.3066, Val Loss:1.9609, Time Elapsed:65.6366 mins\n",
      "For Epoch 26 We Train Loss:1.2847, Val Loss:1.9074, Time Elapsed:68.2924 mins\n",
      "For Epoch 27 We Train Loss:1.2568, Val Loss:1.9526, Time Elapsed:71.0245 mins\n",
      "For Epoch 28 We Train Loss:1.2396, Val Loss:1.9167, Time Elapsed:73.7630 mins\n",
      "For Epoch 29 We Train Loss:1.2211, Val Loss:1.9043, Time Elapsed:76.3702 mins\n",
      "For Epoch 30 We Train Loss:1.1990, Val Loss:1.9451, Time Elapsed:78.9617 mins\n",
      "For Epoch 31 We Train Loss:1.1768, Val Loss:1.8872, Time Elapsed:81.6174 mins\n",
      "For Epoch 32 We Train Loss:1.1594, Val Loss:1.9090, Time Elapsed:84.2092 mins\n",
      "For Epoch 33 We Train Loss:1.1405, Val Loss:1.9504, Time Elapsed:86.8098 mins\n",
      "For Epoch 34 We Train Loss:1.1237, Val Loss:1.9476, Time Elapsed:89.4155 mins\n",
      "For Epoch 35 We Train Loss:1.1073, Val Loss:1.9391, Time Elapsed:92.0405 mins\n",
      "For Epoch 36 We Train Loss:1.0904, Val Loss:1.9415, Time Elapsed:94.7138 mins\n",
      "For Epoch 37 We Train Loss:1.0716, Val Loss:1.9527, Time Elapsed:97.3457 mins\n",
      "For Epoch 38 We Train Loss:1.0596, Val Loss:1.9195, Time Elapsed:100.0348 mins\n",
      "For Epoch 39 We Train Loss:1.0496, Val Loss:1.9059, Time Elapsed:102.6761 mins\n",
      "For Epoch 40 We Train Loss:1.0387, Val Loss:1.9273, Time Elapsed:105.3263 mins\n",
      "For Epoch 41 We Train Loss:1.0182, Val Loss:1.9536, Time Elapsed:107.9703 mins\n",
      "For Epoch 42 We Train Loss:1.0114, Val Loss:1.9383, Time Elapsed:110.6105 mins\n",
      "For Epoch 43 We Train Loss:1.0014, Val Loss:1.9630, Time Elapsed:113.2634 mins\n",
      "For Epoch 44 We Train Loss:0.9834, Val Loss:1.9750, Time Elapsed:116.0511 mins\n",
      "For Epoch 45 We Train Loss:0.9708, Val Loss:1.9528, Time Elapsed:119.1309 mins\n",
      "For Epoch 46 We Train Loss:0.9641, Val Loss:1.9606, Time Elapsed:122.2156 mins\n",
      "For Epoch 47 We Train Loss:0.9475, Val Loss:2.0100, Time Elapsed:125.3022 mins\n",
      "For Epoch 48 We Train Loss:0.9440, Val Loss:1.9942, Time Elapsed:128.3870 mins\n",
      "For Epoch 49 We Train Loss:0.9359, Val Loss:2.0005, Time Elapsed:131.4937 mins\n",
      "For Epoch 50 We Train Loss:0.9259, Val Loss:2.0064, Time Elapsed:134.5902 mins\n"
     ]
    }
   ],
   "source": [
    "output_metrics = training_loop(\n",
    "    model = seq_2_seq_model,\n",
    "    data_loader_train = train_iterator,\n",
    "    data_loader_val = test_iterator,\n",
    "    epochs = EPOCHS,\n",
    "    loss_criterion = criterion,\n",
    "    optim_alog = optimizer,\n",
    "    chkpt_file = chkpt_file,\n",
    "    final_load_file = final_load_file\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_metrics(EPOCHS, output_metrics)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test BLEU Score:0.36593355704993386\n"
     ]
    }
   ],
   "source": [
    "print('Test BLEU Score:{0}'.format(score_bleu(test_data, seq_2_seq_model, english, french)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "metrics_df = pd.DataFrame(output_metrics)\n",
    "metrics_df.to_csv('saved_files/bidirectional_metrics.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "bleu_score_results = score_bleu_by_length(test_data, seq_2_seq_model, english, french)\n",
    "bleu_score_results_df = pd.DataFrame(bleu_score_results)\n",
    "bleu_score_results_df.to_csv('saved_files/bidirectional_bleu.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.scatter(bleu_score_results_df[\"length\"], bleu_score_results_df[\"bleu_score\"])\n",
    "plt.ylabel(\"Bleu Score\")\n",
    "plt.xlabel(\"Sentence Length\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print('Train BLEU Score:{0}'.format(score_bleu(train_data, seq_2_seq_model, english, french)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}