6864_hw1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "6864_hw1_updated.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "FU7xWiY6TyWS"
      },
      "source": [
        "%%bash\n",
        "!(stat -t /usr/local/lib/*/dist-packages/google/colab > /dev/null 2>&1) && exit\n",
        "rm -rf 6864-hw1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5AyMA9rK1Rhf"
      },
      "source": [
        "import os\n",
        "os.makedirs(\"6864-hw1\", exist_ok=True)\n",
        "import sys\n",
        "sys.path.append(\"/content/6864-hw1\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BL1IfnRdPdsl"
      },
      "source": [
        "!pip install sacrebleu"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ilKcWfSHYltK"
      },
      "source": [
        "# **Part 0: Data Loading and Preprocessing**\n",
        "\n",
        "In this section we will load the data that we will be using throughout the lab and perform some preprocessing steps. We will also define some functions that will be useful for training and evaluating your models. You do not need to write any code for this part, but you are encouraged to read through the code carefully and make sure you understand it.\n",
        "\n",
        "First we download the data. The dataset consists of parallel English and Vietnamese sentences (IWSLT'15 English-Vietnamese translation data). In the first two parts of the lab, you will do language modeling using only the English data, and in the final part of the lab you will do translation from Vietnamese to English."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rhqzGV7qZD2d"
      },
      "source": [
        "# Download data\n",
        "!wget -nv -O /content/6864-hw1/train.en https://nlp.stanford.edu/projects/nmt/data/iwslt15.en-vi/train.en\n",
        "!wget -nv -O /content/6864-hw1/train.vi https://nlp.stanford.edu/projects/nmt/data/iwslt15.en-vi/train.vi\n",
        "!wget -nv -O /content/6864-hw1/tst2013.en https://nlp.stanford.edu/projects/nmt/data/iwslt15.en-vi/tst2013.en\n",
        "!wget -nv -O /content/6864-hw1/tst2013.vi https://nlp.stanford.edu/projects/nmt/data/iwslt15.en-vi/tst2013.vi\n",
        "!wget -nv -O /content/6864-hw1/vocab.en https://nlp.stanford.edu/projects/nmt/data/iwslt15.en-vi/vocab.en\n",
        "!wget -nv -O /content/6864-hw1/vocab.vi https://nlp.stanford.edu/projects/nmt/data/iwslt15.en-vi/vocab.vi"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0EUZEwI8ksBe"
      },
      "source": [
        "Next we read and store the data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FzanSf24ZTJa"
      },
      "source": [
        "def read_sentence_file(filename):\n",
        "  sentences_list = []\n",
        "  with open(filename, \"r\") as f:\n",
        "    for line in f:\n",
        "      sentences_list.append(line.strip().split())\n",
        "  return sentences_list\n",
        "\n",
        "def read_vocab_file(filename):\n",
        "  with open(filename, \"r\") as f:\n",
        "    return [line.strip() for line in f]\n",
        "\n",
        "\n",
        "src_vocab_set = read_vocab_file(os.path.join(\"/content/6864-hw1\", \"vocab.vi\"))\n",
        "trg_vocab_set = read_vocab_file(os.path.join(\"/content/6864-hw1\", \"vocab.en\"))\n",
        "\n",
        "train_src_sentences_list = read_sentence_file(os.path.join(\"/content/6864-hw1\",\n",
        "                                                           \"train.vi\"))\n",
        "train_trg_sentences_list = read_sentence_file(os.path.join(\"/content/6864-hw1\",\n",
        "                                                           \"train.en\"))\n",
        "assert len(train_src_sentences_list) == len(train_trg_sentences_list)\n",
        "\n",
        "test_src_sentences_list = read_sentence_file(os.path.join(\"/content/6864-hw1\",\n",
        "                                                          \"tst2013.vi\"))\n",
        "test_trg_sentences_list = read_sentence_file(os.path.join(\"/content/6864-hw1\",\n",
        "                                                          \"tst2013.en\"))\n",
        "assert len(test_src_sentences_list) == len(test_trg_sentences_list)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yo11GNvikUPl"
      },
      "source": [
        "Next we do preprocessing on the dataset, and we perform a preliminary data analysis."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dO2t7gaAZvSc"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "MAX_SENT_LENGTH = 48\n",
        "MAX_SENT_LENGTH_PLUS_SOS_EOS = 50\n",
        "\n",
        "# We only keep sentences that do not exceed 48 words, so that later when we\n",
        "# add <s> and </s> to a sentence it still won't exceed 50 words.\n",
        "def filter_data(src_sentences_list, trg_sentences_list, max_len):\n",
        "  new_src_sentences_list, new_trg_sentences_list = [], []\n",
        "  for src_sent, trg_sent in zip(src_sentences_list, trg_sentences_list):\n",
        "    if (len(src_sent) <= max_len and len(trg_sent) <= max_len\n",
        "        and len(src_sent) > 0 and len(trg_sent)) > 0:\n",
        "      new_src_sentences_list.append(src_sent)\n",
        "      new_trg_sentences_list.append(trg_sent)\n",
        "  return new_src_sentences_list, new_trg_sentences_list\n",
        "\n",
        "train_src_sentences_list, train_trg_sentences_list = filter_data(\n",
        "    train_src_sentences_list, train_trg_sentences_list, max_len=MAX_SENT_LENGTH)\n",
        "test_src_sentences_list, test_trg_sentences_list = filter_data(\n",
        "    test_src_sentences_list, test_trg_sentences_list, max_len=MAX_SENT_LENGTH)\n",
        "\n",
        "# We take 10% of the training data to be the validation set.\n",
        "num_val = int(len(train_src_sentences_list) * 0.1)\n",
        "val_src_sentences_list = train_src_sentences_list[:num_val]\n",
        "val_trg_sentences_list = train_trg_sentences_list[:num_val]\n",
        "train_src_sentences_list = train_src_sentences_list[num_val:]\n",
        "train_trg_sentences_list = train_trg_sentences_list[num_val:]\n",
        "\n",
        "# Show some data stats\n",
        "print(\"Number of training (src, trg) sentence pairs: %d\" %\n",
        "      len(train_src_sentences_list))\n",
        "print(\"Number of validation (src, trg) sentence pairs: %d\" %\n",
        "      len(val_src_sentences_list))\n",
        "print(\"Number of testing (src, trg) sentence pairs: %d\" %\n",
        "      len(test_src_sentences_list))\n",
        "src_vocab_set = ['<pad>'] + src_vocab_set\n",
        "trg_vocab_set = ['<pad>'] + trg_vocab_set\n",
        "print(\"Size of en vocab set (including '<pad>', '<unk>', '<s>', '</s>'): %d\" %\n",
        "      len(src_vocab_set))\n",
        "print(\"Size of vi vocab set (including '<pad>', '<unk>', '<s>', '</s>'): %d\" %\n",
        "      len(trg_vocab_set))\n",
        "\n",
        "length = [len(sent) for sent in train_src_sentences_list]\n",
        "print('Training sentence avg. length: %d ' % np.mean(length))\n",
        "print('Training sentence length at 95-percentile: %d' %\n",
        "      np.percentile(length, 95))\n",
        "print('Training sentence length distribution '\n",
        "      '(x-axis is length range and y-axis is count):\\n')\n",
        "plt.hist(length, bins=5)\n",
        "plt.show()\n",
        "\n",
        "print('Example Vietnamese input: ' + str(train_src_sentences_list[0]))\n",
        "print('Its target English output: ' + str(train_trg_sentences_list[0]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vQI_A47IlPmO"
      },
      "source": [
        "Here we setup our PyTorch environment."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oBNOk0XbZ4i4"
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "assert device == \"cuda\"   # use gpu whenever you can!\n",
        "\n",
        "seed = 42\n",
        "np.random.seed(seed)\n",
        "torch.manual_seed(seed)\n",
        "torch.cuda.manual_seed(seed)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "znPbxQJvleTJ"
      },
      "source": [
        "We define custom dataset classes for both the language modeling task and the machine translation task so that we can use PyTorch's built-in dataset tools."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hYtacoWTaTms"
      },
      "source": [
        "from torch.utils import data\n",
        "\n",
        "\n",
        "# These IDs are reserved.\n",
        "PAD_INDEX = 0\n",
        "UNK_INDEX = 1\n",
        "SOS_INDEX = 2\n",
        "EOS_INDEX = 3\n",
        "\n",
        "class LMDataset(data.Dataset):\n",
        "  def __init__(self, src_sentences, src_vocabs, sampling=1.):\n",
        "    self.src_sentences = src_sentences[:int(len(src_sentences) * sampling)]\n",
        "\n",
        "    self.max_src_seq_length = MAX_SENT_LENGTH_PLUS_SOS_EOS\n",
        "\n",
        "    self.src_vocabs = src_vocabs\n",
        "\n",
        "    self.src_v2id = {v : i for i, v in enumerate(src_vocabs)}\n",
        "    self.src_id2v = {val : key for key, val in self.src_v2id.items()}\n",
        "\n",
        "  def __len__(self):\n",
        "    return len(self.src_sentences)\n",
        "\n",
        "  def __getitem__(self, index):\n",
        "    sent = self.src_sentences[index]\n",
        "    sent_len = len(sent) + 2   # add <s> and </s> to each sentence\n",
        "    sent_id = []\n",
        "    for w in sent:\n",
        "      if w not in self.src_vocabs:\n",
        "        w = '<unk>'\n",
        "      sent_id.append(self.src_v2id[w])\n",
        "    src_id = ([SOS_INDEX] + sent_id + [EOS_INDEX] + [PAD_INDEX] *\n",
        "              (self.max_src_seq_length - sent_len))\n",
        "    trg_id = (sent_id + [EOS_INDEX] + [PAD_INDEX] * \n",
        "              (self.max_src_seq_length - sent_len + 1))\n",
        "    \n",
        "    return torch.tensor(src_id), sent_len, torch.tensor(trg_id), sent_len\n",
        "\n",
        "class MTDataset(data.Dataset):\n",
        "  def __init__(self, src_sentences, src_vocabs, trg_sentences, trg_vocabs,\n",
        "               sampling=1.):\n",
        "    self.src_sentences = src_sentences[:int(len(src_sentences) * sampling)]\n",
        "    self.trg_sentences = trg_sentences[:int(len(src_sentences) * sampling)]\n",
        "\n",
        "    self.max_src_seq_length = MAX_SENT_LENGTH_PLUS_SOS_EOS\n",
        "    self.max_trg_seq_length = MAX_SENT_LENGTH_PLUS_SOS_EOS\n",
        "\n",
        "    self.src_vocabs = src_vocabs\n",
        "    self.trg_vocabs = trg_vocabs\n",
        "\n",
        "    self.src_v2id = {v : i for i, v in enumerate(src_vocabs)}\n",
        "    self.src_id2v = {val : key for key, val in self.src_v2id.items()}\n",
        "    self.trg_v2id = {v : i for i, v in enumerate(trg_vocabs)}\n",
        "    self.trg_id2v = {val : key for key, val in self.trg_v2id.items()}\n",
        "\n",
        "  def __len__(self):\n",
        "    return len(self.src_sentences)\n",
        "\n",
        "  def __getitem__(self, index):\n",
        "    src_sent = self.src_sentences[index]\n",
        "    src_len = len(src_sent) + 2   # add <s> and </s> to each sentence\n",
        "    src_id = []\n",
        "    for w in src_sent:\n",
        "      if w not in self.src_vocabs:\n",
        "        w = '<unk>'\n",
        "      src_id.append(self.src_v2id[w])\n",
        "    src_id = ([SOS_INDEX] + src_id + [EOS_INDEX] + [PAD_INDEX] *\n",
        "              (self.max_src_seq_length - src_len))\n",
        "\n",
        "    trg_sent = self.trg_sentences[index]\n",
        "    trg_len = len(trg_sent) + 2\n",
        "    trg_id = []\n",
        "    for w in trg_sent:\n",
        "      if w not in self.trg_vocabs:\n",
        "        w = '<unk>'\n",
        "      trg_id.append(self.trg_v2id[w])\n",
        "    trg_id = ([SOS_INDEX] + trg_id + [EOS_INDEX] + [PAD_INDEX] *\n",
        "              (self.max_trg_seq_length - trg_len))\n",
        "\n",
        "    return torch.tensor(src_id), src_len, torch.tensor(trg_id), trg_len"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6xfQ4PSYl1Jz"
      },
      "source": [
        "Next we instantiate our datasets and data loaders. The data loaders are what we will iterate over when training and evaluating our models."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CR8M8apZivz-"
      },
      "source": [
        "batch_size = 128 # note that this is a hyperparameter you may want to adjust\n",
        "\n",
        "lm_train_set = LMDataset(train_trg_sentences_list, trg_vocab_set, sampling=1.)\n",
        "lm_train_data_loader = data.DataLoader(lm_train_set, batch_size=batch_size,\n",
        "                                      num_workers=8, shuffle=True)\n",
        "\n",
        "lm_val_set = LMDataset(val_trg_sentences_list, trg_vocab_set, sampling=1.)\n",
        "lm_val_data_loader = data.DataLoader(lm_val_set, batch_size=batch_size, num_workers=8,\n",
        "                                    shuffle=False)\n",
        "\n",
        "# You can try on a smaller training set by setting a smaller `sampling`.\n",
        "mt_train_set = MTDataset(train_src_sentences_list, src_vocab_set,\n",
        "                        train_trg_sentences_list, trg_vocab_set, sampling=1.)\n",
        "mt_train_data_loader = data.DataLoader(mt_train_set, batch_size=batch_size,\n",
        "                                      num_workers=8, shuffle=True)\n",
        "\n",
        "mt_val_set = MTDataset(val_src_sentences_list, src_vocab_set,\n",
        "                      val_trg_sentences_list, trg_vocab_set, sampling=1.)\n",
        "mt_val_data_loader = data.DataLoader(mt_val_set, batch_size=batch_size, num_workers=8,\n",
        "                                    shuffle=False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zEVw2xxRmFIC"
      },
      "source": [
        "Now we define the functions that will actually carry out the training process. You are strongly encouraged to read these carefully; doing so will likely save you time as you work on your model implementations.\n",
        "\n",
        "One important point to take note of here is that while in class we discussed using basic stochastic gradient descent (SGD) for our optimization method, in practice it is often better to use optimizers with adaptive learning rates, such as the Adam optimizer that we use here, the details of which you can find in [this paper](https://arxiv.org/abs/1412.6980)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c6XZLkJbGXcC"
      },
      "source": [
        "import math\n",
        "\n",
        "class SimpleLossCompute:\n",
        "  \"\"\"A simple loss compute and train function.\"\"\"\n",
        "\n",
        "  def __init__(self, generator, criterion, opt=None):\n",
        "    self.generator = generator\n",
        "    self.criterion = criterion\n",
        "    self.opt = opt\n",
        "\n",
        "  def __call__(self, x, y, norm):\n",
        "    x = self.generator(x)\n",
        "    loss = self.criterion(x.contiguous().view(-1, x.size(-1)),\n",
        "                          y.contiguous().view(-1))\n",
        "    loss = loss / norm\n",
        "\n",
        "    if self.opt is not None:  # training mode\n",
        "      loss.backward()          \n",
        "      self.opt.step()\n",
        "      self.opt.zero_grad()\n",
        "\n",
        "    return loss.data.item() * norm\n",
        "\n",
        "\n",
        "def run_epoch(data_loader, model, loss_compute, task, print_every):\n",
        "  \"\"\"Standard Training and Logging Function\"\"\"\n",
        "\n",
        "  total_tokens = 0\n",
        "  total_loss = 0\n",
        "\n",
        "  for i, (src_ids_BxT, src_lengths_B, trg_ids_BxL, trg_lengths_B) in enumerate(data_loader):\n",
        "    # We define some notations here to help you understand the loaded tensor\n",
        "    # shapes:\n",
        "    #   `B`: batch size\n",
        "    #   `T`: max sequence length of source sentences\n",
        "    #   `L`: max sequence length of target sentences; due to our preprocessing\n",
        "    #        in the beginning, `L` == `T` == 50\n",
        "    # An example of `src_ids_BxT` (when B = 2):\n",
        "    #   [[2, 4, 6, 7, ..., 4, 3, 0, 0, 0],\n",
        "    #    [2, 8, 6, 5, ..., 9, 5, 4, 3, 0]]\n",
        "    # The corresponding `src_lengths_B` would be [47, 49].\n",
        "    # Note that SOS_INDEX == 2, EOS_INDEX == 3, and PAD_INDEX = 0.\n",
        "\n",
        "    src_ids_BxT = src_ids_BxT.to(device)\n",
        "    src_lengths_B = src_lengths_B.to(device)\n",
        "    trg_ids_BxL = trg_ids_BxL.to(device)\n",
        "    del trg_lengths_B   # unused\n",
        "\n",
        "    if task == \"seq2seq\":\n",
        "      _, output = model(src_ids_BxT, trg_ids_BxL, src_lengths_B)\n",
        "\n",
        "      loss = loss_compute(x=output, y=trg_ids_BxL[:, 1:],\n",
        "                        norm=src_ids_BxT.size(0))\n",
        "      total_loss += loss\n",
        "      total_tokens += (trg_ids_BxL[:, 1:] != PAD_INDEX).data.sum().item()\n",
        "    elif task == \"lm\":\n",
        "      output = model(src_ids_BxT)\n",
        "\n",
        "      loss = loss_compute(x=output, y=trg_ids_BxL,\n",
        "                        norm=src_ids_BxT.size(0))\n",
        "      total_loss += loss\n",
        "      total_tokens += (trg_ids_BxL != PAD_INDEX).data.sum().item()\n",
        "    else:\n",
        "      raise ValueError(\"unknown task\")\n",
        "    \n",
        "\n",
        "    if model.training and i % print_every == 0:\n",
        "      print(\"Epoch Step: %d Loss: %f\" % (i, loss / src_ids_BxT.size(0)))\n",
        "\n",
        "  return math.exp(total_loss / float(total_tokens))\n",
        "\n",
        "\n",
        "def train(model, num_epochs, learning_rate, train_data_loader, val_data_loader, task, print_every):\n",
        "  # Set `ignore_index` as PAD_INDEX so that pad tokens won't be included when\n",
        "  # computing the loss.\n",
        "  criterion = nn.NLLLoss(reduction=\"sum\", ignore_index=PAD_INDEX)\n",
        "  optim = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
        "\n",
        "  # Keep track of dev ppl for each epoch.\n",
        "  dev_ppls = []\n",
        "\n",
        "  for epoch in range(num_epochs):\n",
        "    print(\"Epoch\", epoch)\n",
        "\n",
        "    model.train()\n",
        "    train_ppl = run_epoch(data_loader=train_data_loader, model=model,\n",
        "                          loss_compute=SimpleLossCompute(model.generator,\n",
        "                                                         criterion, optim),\n",
        "                          task=task,\n",
        "                          print_every=print_every)\n",
        "\n",
        "    model.eval()\n",
        "    with torch.no_grad():      \n",
        "      dev_ppl = run_epoch(data_loader=val_data_loader, model=model,\n",
        "                          loss_compute=SimpleLossCompute(model.generator,\n",
        "                                                         criterion, None),\n",
        "                          task=task,\n",
        "                          print_every=print_every)\n",
        "      print(\"Validation perplexity: %f\" % dev_ppl)\n",
        "      dev_ppls.append(dev_ppl)\n",
        "        \n",
        "  return dev_ppls"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mK6HQOWqnPEA"
      },
      "source": [
        "We provide a function for visualizing your models' learning curves."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s-yM1kPhG4K3"
      },
      "source": [
        "def plot_perplexity(perplexities):\n",
        "  \"\"\"plot perplexities\"\"\"\n",
        "  plt.title(\"Perplexity per Epoch\")\n",
        "  plt.xlabel(\"Epoch\")\n",
        "  plt.ylabel(\"Perplexity\")\n",
        "  plt.plot(perplexities)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kc9p7SGJndhk"
      },
      "source": [
        "This function takes a hidden state, performs a linear transformation on it, and finally takes a log softmax. Note the usage of this class within the above training functions."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "flIf9QdoZL8S"
      },
      "source": [
        "class Generator(nn.Module):\n",
        "  \"\"\"Define standard linear + softmax generation step.\"\"\"\n",
        "  def __init__(self, hidden_size, vocab_size):\n",
        "    super(Generator, self).__init__()\n",
        "    self.proj = nn.Linear(hidden_size, vocab_size, bias=False)\n",
        "\n",
        "  def forward(self, x):\n",
        "    return F.log_softmax(self.proj(x), dim=-1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "60rKlVC6qqV0"
      },
      "source": [
        "Here we define decoding functions for performing inference with our Encoder-Decoder model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "89mr8sGhqo0w"
      },
      "source": [
        "def greedy_decode(model, src_ids, src_lengths, max_len):\n",
        "  \"\"\"Greedily decode a sentence for EncoderDecoder.\"\"\"\n",
        "\n",
        "  with torch.no_grad():\n",
        "    _, encoder_finals = model.encode(src_ids, src_lengths)\n",
        "    prev_y = torch.ones(1, 1).fill_(SOS_INDEX).type_as(src_ids)\n",
        "\n",
        "  output = []\n",
        "  hidden = None\n",
        "\n",
        "  for i in range(max_len):\n",
        "    with torch.no_grad():\n",
        "      hidden, outputs = model.decode(encoder_finals, prev_y, hidden)\n",
        "      prob = model.generator(outputs[:, -1])\n",
        "\n",
        "    _, next_word = torch.max(prob, dim=1)\n",
        "    next_word = next_word.data.item()\n",
        "    output.append(next_word)\n",
        "    prev_y = torch.ones(1, 1).type_as(src_ids).fill_(next_word)\n",
        "\n",
        "  output = np.array(output)\n",
        "\n",
        "  # Cut off everything starting from </s>.\n",
        "  first_eos = np.where(output == EOS_INDEX)[0]\n",
        "  if len(first_eos) > 0:\n",
        "    output = output[:first_eos[0]]\n",
        "  return output\n",
        "\n",
        "def lookup_words(x, vocab):\n",
        "  return [vocab[i] for i in x]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uGOLfO-WrI1_"
      },
      "source": [
        "You will use this function to visualize some examples once you have trained your translation model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NKrsGqQgrKU3"
      },
      "source": [
        "def print_examples(model, data_loader, n=3,\n",
        "                   max_len=MAX_SENT_LENGTH_PLUS_SOS_EOS, \n",
        "                   src_vocab_set=src_vocab_set, trg_vocab_set=trg_vocab_set):\n",
        "  \"\"\"Prints `n` examples. Assumes batch size of 1.\"\"\"\n",
        "\n",
        "  model.eval()\n",
        "\n",
        "  for i, (src_ids, src_lengths, trg_ids, _) in enumerate(data_loader):\n",
        "    if isinstance(model, EncoderDecoder):\n",
        "      result = greedy_decode(model, src_ids.to(device), src_lengths.to(device),\n",
        "                             max_len=max_len)\n",
        "    else:\n",
        "      raise NotImplementedError(\"Unknown model type.\")\n",
        "\n",
        "    # remove <s>\n",
        "    src_ids = src_ids[0, 1:]\n",
        "    trg_ids = trg_ids[0, 1:]\n",
        "    # remove </s> and <pad>\n",
        "    src_ids = src_ids[:np.where(src_ids == EOS_INDEX)[0][0]]\n",
        "    trg_ids = trg_ids[:np.where(trg_ids == EOS_INDEX)[0][0]]\n",
        "\n",
        "    print(\"Example #%d\" % (i + 1))\n",
        "    print(\"Src : \", \" \".join(lookup_words(src_ids, vocab=src_vocab_set)))\n",
        "    print(\"Trg : \", \" \".join(lookup_words(trg_ids, vocab=trg_vocab_set)))\n",
        "    print(\"Pred: \", \" \".join(lookup_words(result, vocab=trg_vocab_set)))\n",
        "    print()\n",
        "\n",
        "    if i == n - 1:\n",
        "      break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GXQFpduzr3ay"
      },
      "source": [
        "The following function will allow you to evaluate your translation model's BLEU score on a test dataset."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jegcU9-ur1jK"
      },
      "source": [
        "import sacrebleu\n",
        "from tqdm import tqdm\n",
        "\n",
        "\n",
        "def compute_BLEU(model, data_loader):\n",
        "  bleu_score = []\n",
        "\n",
        "  model.eval()\n",
        "  for src_ids, src_lengths, trg_ids, _ in tqdm(data_loader):\n",
        "    if isinstance(model, EncoderDecoder):\n",
        "      result = greedy_decode(model, src_ids.to(device), src_lengths.to(device),\n",
        "                             max_len=MAX_SENT_LENGTH_PLUS_SOS_EOS)\n",
        "    else:\n",
        "      raise NotImplementedError(\"Unknown model type.\")\n",
        "\n",
        "    # remove <s>\n",
        "    src_ids = src_ids[0, 1:]\n",
        "    trg_ids = trg_ids[0, 1:]\n",
        "    # remove </s> and <pad>\n",
        "    src_ids = src_ids[:np.where(src_ids == EOS_INDEX)[0][0]]\n",
        "    trg_ids = trg_ids[:np.where(trg_ids == EOS_INDEX)[0][0]]\n",
        "\n",
        "    pred = \" \".join(lookup_words(result, vocab=trg_vocab_set))\n",
        "    targ = \" \".join(lookup_words(trg_ids, vocab=trg_vocab_set))\n",
        "\n",
        "    bleu_score.append(sacrebleu.raw_corpus_bleu([pred], [[targ]], .01).score)\n",
        "\n",
        "  return bleu_score"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "75Xar0RA0HCZ"
      },
      "source": [
        "# **Part 2: Recurrent Neural Network (RNN)**\n",
        "\n",
        "In this part, you will implement a vanilla RNN language model. You are not allowed to use the PyTorch built-in RNN module (or the corresponding LSTM and GRU modules), but you may use the RNNCell module (or the LSTMCell/GRUCell modules)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GOy71ueb0I0G"
      },
      "source": [
        "class RNN(nn.Module):\n",
        "\n",
        "    def __init__(self, input_size, hidden_size, src_embed, generator):\n",
        "      \"\"\"\n",
        "      Inputs:\n",
        "        - `input_size`: a positive integer corresponding to the size of the\n",
        "            word embeddings\n",
        "        - `hidden_size`: a positive integer representing the dimensionality of\n",
        "            the RNN's hidden state vector\n",
        "        - `src_embed`: an nn.Embedding object representing the lookup table for\n",
        "            input (source) sentences\n",
        "        - `generator`: a `Generator` object. Essentially a linear mapping\n",
        "            followed by a softmax. You should not call it within this class; it\n",
        "            is called in the SimpleLossCompute class above\n",
        "      \"\"\"\n",
        "      super(RNN, self).__init__()\n",
        "      # `input_size`, `hidden_size`, and `output_size` are all int.\n",
        "\n",
        "      self.hidden_size = hidden_size\n",
        "      self.src_embed = src_embed\n",
        "      self.generator = generator\n",
        "      # hint: unless you choose to implement the RNN update equations yourself\n",
        "      #       you will want a `self.rnn` module that does that for you, which\n",
        "      #       is where the RNNCell/LSTMCell/GRUCell modules come in handy\n",
        "\n",
        "      ### Your code here!\n",
        "\n",
        "    def forward(self, input_ids):\n",
        "      \"\"\"\n",
        "      Given a sequence of words (represented as IDs), compute and return the\n",
        "      hidden state at each timestep (equivalently, for each input word).\n",
        "      Input:\n",
        "        - `input_ids`: a 2d-tensor of shape\n",
        "           (batch_size, MAX_SENT_LENGTH_PLUS_SOS_EOS) representing a batch of\n",
        "           sentences from the dataset (with IDs instead of words)\n",
        "\n",
        "      Returns:\n",
        "        - `hiddens`: a 3d-tensor of shape\n",
        "            (batch_size, MAX_SENT_LENGTH_PLUS_SOS_EOS, hidden_size) representing\n",
        "            the hidden state of the model at each timestep\n",
        "      \"\"\"\n",
        "      # hint: pay close attention to the shapes of your tensors; you may find\n",
        "      #       pytorch's `permute()` method for tensors useful\n",
        "\n",
        "      ### Your code here!\n",
        "      \n",
        "      return hiddens\n",
        "\n",
        "    def init_hidden(self, batch_size):\n",
        "      \"\"\"\n",
        "      Input:\n",
        "        - `batch_size`: a positive integer\n",
        "\n",
        "      Returns:\n",
        "        - `hidden`: a 2d-tensor of shape (batch_size, hidden_size) representing\n",
        "            the initial hidden state of the RNN\n",
        "      \"\"\"\n",
        "      # Use to initialize hidden state everytime before running a sentence.\n",
        "      hidden = torch.zeros(batch_size, self.hidden_size).to(device)\n",
        "      return hidden"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XRB8Re7eoMZF"
      },
      "source": [
        "Once you have implemented your model, run this cell to train and evaluate it. Note that the hyperparameters chosen here (including `learning_rate`) are not necessarily optimal—you may want to adjust them to improve performance. A simple one-layer implementation of a vanilla RNN should yield a perplexity in the 70s or 80s, but you can do better by adding layers, implementing a GRU/LSTM, and/or optimizing hyperparameters."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-FSlqG1tVsiJ"
      },
      "source": [
        "embed_size = 256   # Each word will be represented as a `embed_size`-dim vector.\n",
        "hidden_size = 256\n",
        "\n",
        "rnn_lm = RNN(input_size=embed_size,\n",
        "             hidden_size=hidden_size,\n",
        "             src_embed=nn.Embedding(len(trg_vocab_set), embed_size),\n",
        "             generator=Generator(hidden_size, len(trg_vocab_set))).to(device)\n",
        "\n",
        "lm_dev_ppls = train(rnn_lm, num_epochs=10,\n",
        "                    learning_rate=1e-3,\n",
        "                    train_data_loader=lm_train_data_loader,\n",
        "                    val_data_loader=lm_val_data_loader,\n",
        "                    task=\"lm\", print_every=100)\n",
        "\n",
        "plot_perplexity(lm_dev_ppls)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5fOArV2r9Piz"
      },
      "source": [
        "# **Part 3: Seq2Seq Model**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mA9JfWiK9eoL"
      },
      "source": [
        "In this part of the lab, you will explore seq2seq to perform a machine translation task. The main task is to implement the naive encoder-decoder architecture without attention.\n",
        "\n",
        "In machine translation (MT), your goal is to translate the correct sentence meaning into another language. In our case, we want to translate Vietnamese sentences into English sentences. See the diagram below for an illustration of how the translation process works with an encoder-decoder architecture.\n",
        "\n",
        "Note that this default Encoder-Decoder sequence-to-sequence model that you will implement is not at all good enough to function as a realistic machine translation system.\n",
        "For those interested, feel free to experiment with the model to try to improve it! \n",
        "\n",
        "Some possible suggestions include:\n",
        "- Playing around with basic hyperparameters (model size, dropout, learning rate, etc.)\n",
        "- Experimenting with different RNN Cells (GRU/LSTM)\n",
        "- Exploring attention-based models (quite difficult)\n",
        "- Using beam search instead of greedy search (moderately difficult)\n",
        "\n",
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kb5gQEp7oVdi"
      },
      "source": [
        "## Encoder\n",
        "\n",
        "We will start with a single-layer unidirectional GRU. You are free to try bidirectional and stack more layers. Note that we are now including *dropout* in our model. Dropout is essentially a regularization technique in which a specified proportion of the model parameters are randomly ignored during a given forward and backward pass of the model. If you want a more detailed explanation, see [this paper](https://arxiv.org/abs/1409.2329) which discusses dropout in the context of RNNs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dnwVGDVkoPt0"
      },
      "source": [
        "from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence\n",
        "\n",
        "\n",
        "class Encoder(nn.Module):\n",
        "  def __init__(self, input_size, hidden_size, dropout=0.):\n",
        "    \"\"\"\n",
        "    Inputs: \n",
        "      - `input_size`: an int representing the RNN input size.\n",
        "      - `hidden_size`: an int representing the RNN hidden size.\n",
        "      - `dropout`: a float representing the dropout rate during training. Note\n",
        "          that for 1-layer RNN this has no effect since dropout only applies to\n",
        "          outputs of intermediate layers.\n",
        "    \"\"\"\n",
        "    super(Encoder, self).__init__()\n",
        "    self.rnn = nn.GRU(input_size, hidden_size, num_layers=1, batch_first=True,\n",
        "                      dropout=dropout, bidirectional=False)\n",
        "\n",
        "  def forward(self, inputs, lengths):\n",
        "    \"\"\"\n",
        "    Inputs:\n",
        "      - `inputs`: a 3d-tensor of shape (batch_size, max_seq_length, embed_size)\n",
        "          representing a batch of padded embedded word vectors of source\n",
        "          sentences.\n",
        "      - `lengths`: a 1d-tensor of shape (batch_size,) representing the sequence\n",
        "          lengths of `inputs`.\n",
        "\n",
        "    Returns:\n",
        "      - `outputs`: a 3d-tensor of shape\n",
        "        (batch_size, max_seq_length, hidden_size).\n",
        "      - `finals`: a 3d-tensor of shape (num_layers, batch_size, hidden_size).\n",
        "      Hint: `outputs` and `finals` are both standard GRU outputs. Check:\n",
        "      https://pytorch.org/docs/stable/nn.html#gru\n",
        "    \"\"\"\n",
        "    # Our variable-length inputs are padded to the same length for batching\n",
        "    # Here we \"pack\" them for computational efficiency (see note below)\n",
        "    packed = pack_padded_sequence(inputs, lengths.cpu(), batch_first=True,\n",
        "                                  enforce_sorted=False)\n",
        "    outputs, finals = self.rnn(packed)\n",
        "    outputs, _ = pad_packed_sequence(outputs, batch_first=True,\n",
        "                                     total_length=MAX_SENT_LENGTH_PLUS_SOS_EOS)\n",
        "    return outputs, finals"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hxs73iWLLXOx"
      },
      "source": [
        "Note: For a clear explanation of padding and packing, see the second answer to this [stackoverflow question](https://stackoverflow.com/questions/51030782/why-do-we-pack-the-sequences-in-pytorch)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lWFWtxhbpSl-"
      },
      "source": [
        "## Decoder\n",
        "\n",
        "The decoder is a conditional GRU. Rather than starting with an empty state like the encoder, its initial hidden state results from a projection of the encoder final vector. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JYT0BlfYUJXj"
      },
      "source": [
        "class Decoder(nn.Module):\n",
        "  \"\"\"An RNN decoder without attention.\"\"\"\n",
        "\n",
        "  def __init__(self, input_size, hidden_size, dropout=0.):\n",
        "    \"\"\"\n",
        "      Inputs:\n",
        "        - `input_size`, `hidden_size`, and `dropout` the same as in Encoder.\n",
        "    \"\"\"\n",
        "    super(Decoder, self).__init__()\n",
        "\n",
        "    # hint 1: while the encoder just needed a single RNN layer, more will be\n",
        "    #         required for the decoder.\n",
        "    # hint 2: think about what you'll need in init_hidden(self, encoder_finals)\n",
        "    # hint 3: what will you use to compute the pre_output (see docstring of\n",
        "    #         forward function)?\n",
        "\n",
        "    ### Your code here!\n",
        "\n",
        "  def forward_step(self, prev_embed, hidden):\n",
        "    \"\"\"Helper function for forward below:\n",
        "       Perform a single decoder step (1 word).\n",
        "\n",
        "       Inputs:\n",
        "      - `prev_embed`: a 3d-tensor of shape (batch_size, 1, embed_size)\n",
        "          representing the padded embedded word vectors at this step in training\n",
        "      - `hidden`: a 3d-tensor of shape (1, batch_size, hidden_size) representing\n",
        "          the current hidden state.\n",
        "\n",
        "      Returns:\n",
        "      - `hidden`: a 3d-tensor of shape (1, batch_size, hidden_size)\n",
        "          representing the current decoder hidden state.\n",
        "      - `pre_output`: a 3d-tensor of shape (batch_size, 1, hidden_size)\n",
        "          representing the total decoder output for one step\n",
        "    \"\"\"\n",
        "    # hint: you'll want to do more here than just run self.rnn (think about\n",
        "    #       what you should do to the output of the self.rnn in order to\n",
        "    #       compute the `pre_output`)\n",
        "\n",
        "    ### Your code here!\n",
        "\n",
        "    return hidden, pre_output\n",
        "    \n",
        "  def forward(self, inputs, encoder_finals, hidden=None, max_len=None):\n",
        "    \"\"\"Unroll the decoder one step at a time.\n",
        "\n",
        "    Inputs:\n",
        "      - `inputs`: a 3d-tensor of shape (batch_size, max_seq_length, embed_size)\n",
        "          representing a batch of padded embedded word vectors of target\n",
        "          sentences (for teacher-forcing during training).\n",
        "      - `encoder_finals`: a 3d-tensor of shape\n",
        "          (num_enc_layers, batch_size, hidden_size) representing the final\n",
        "          encoder hidden states used to initialize the initial decoder hidden\n",
        "          states.\n",
        "      - `hidden`: a 3d-tensor of shape (1, batch_size, hidden_size) representing\n",
        "          the value to be used to initialize the initial decoder hidden states.\n",
        "          If None, then use `encoder_finals`.\n",
        "      - `max_len`: an int representing the maximum decoding length.\n",
        "\n",
        "    Returns:\n",
        "      - `hidden`: a 3d-tensor of shape\n",
        "          (num_layers, batch_size, hidden_size) representing the final hidden\n",
        "          state for each element in the batch.\n",
        "      - `pre_output_vectors`: a 3d-tensor of shape\n",
        "          (batch_size, max_len, hidden_size) representing the raw decoder\n",
        "          outputs (before mapping to a `trg_vocab_size`-dim vector).\n",
        "    \"\"\"\n",
        "\n",
        "    # The maximum number of steps to unroll the RNN.\n",
        "    if max_len is None:\n",
        "      max_len = inputs.size(1)\n",
        "\n",
        "    # Initialize decoder hidden state.\n",
        "    if hidden is None:\n",
        "      hidden = self.init_hidden(encoder_finals)\n",
        "\n",
        "    # hint: you'll want to keep track of the `pre_output` for each timestep,\n",
        "    #       but you only need the final `hidden` state\n",
        "\n",
        "    ### Your code here!\n",
        "\n",
        "    return hidden, pre_output_vectors\n",
        "\n",
        "  def init_hidden(self, encoder_finals):\n",
        "    \"\"\"Use encoder final hidden state to initialize decoder's first hidden\n",
        "       state.\n",
        "\n",
        "       Input: `encoder_finals` is same as in forward()\n",
        "\n",
        "       Returns: \n",
        "         - `decoder_init_hiddens`: a 3d-tensor of shape \n",
        "              (num_layers, batch_size, hidden_size) representing the initial\n",
        "              hidden state of the decoder for each element in the batch \n",
        "    \"\"\"\n",
        "    # hint: think about whether or not an activation function is needed here\n",
        "\n",
        "    ### Your code here!\n",
        "    \n",
        "    return decoder_init_hiddens"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AH0VdHE2_x1k"
      },
      "source": [
        "## Encoder-Decoder\n",
        "\n",
        "Here we define the high level encoder-decoder class to wrap up sub-models, including encoder, decoder, generator, and src/trg embeddings. You do not need to write any code for this module."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nNBaAYB_oHxG"
      },
      "source": [
        "class EncoderDecoder(nn.Module):\n",
        "  \"\"\"A standard Encoder-Decoder architecture without attention.\n",
        "  \"\"\"\n",
        "  def __init__(self, encoder, decoder, src_embed, trg_embed, generator):\n",
        "    \"\"\"\n",
        "    Inputs:\n",
        "      - `encoder`: an `Encoder` object.\n",
        "      - `decoder`: an `Decoder` object.\n",
        "      - `src_embed`: an nn.Embedding object representing the lookup table for\n",
        "          input (source) sentences.\n",
        "      - `trg_embed`: an nn.Embedding object representing the lookup table for\n",
        "          output (target) sentences.\n",
        "      - `generator`: a `Generator` object. Essentially a linear mapping. See\n",
        "          the next code cell.\n",
        "    \"\"\"\n",
        "    super(EncoderDecoder, self).__init__()\n",
        "\n",
        "    self.encoder = encoder\n",
        "    self.decoder = decoder\n",
        "    self.src_embed = src_embed\n",
        "    self.trg_embed = trg_embed\n",
        "    self.generator = generator\n",
        "\n",
        "  def forward(self, src_ids, trg_ids, src_lengths):\n",
        "    \"\"\"Take in and process masked source and target sequences.\n",
        "\n",
        "    Inputs:\n",
        "      `src_ids`: a 2d-tensor of shape (batch_size, max_seq_length) representing\n",
        "        a batch of source sentences of word ids.\n",
        "      `trg_ids`: a 2d-tensor of shape (batch_size, max_seq_length) representing\n",
        "        a batch of target sentences of word ids.\n",
        "      `src_lengths`: a 1d-tensor of shape (batch_size,) representing the\n",
        "        sequence length of `src_ids`.\n",
        "\n",
        "    Returns the decoder outputs, see the above cell.\n",
        "    \"\"\"\n",
        "    encoder_hiddens, encoder_finals = self.encode(src_ids, src_lengths)\n",
        "    del encoder_hiddens\n",
        "    return self.decode(encoder_finals, trg_ids[:, :-1])\n",
        "\n",
        "  def encode(self, src_ids, src_lengths):\n",
        "    return self.encoder(self.src_embed(src_ids), src_lengths)\n",
        "    \n",
        "  def decode(self, encoder_finals, trg_ids, decoder_hidden=None):\n",
        "    return self.decoder(self.trg_embed(trg_ids), encoder_finals, decoder_hidden)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FAGHeLyGp5bA"
      },
      "source": [
        "Once you have implemented your model, run this cell to train and evaluate your model. Note that the hyperparameters chosen here (including `learning_rate`) are not necessarily optimal—you may want to adjust them to improve performance. A reasonable perplexity here would be in the low- to mid-30s after 10 epochs of training."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j7ueW-ZJp4RD"
      },
      "source": [
        "# Hyperparameters for contructing the encoder-decoder model.\n",
        "\n",
        "embed_size = 256   # Each word will be represented as a `embed_size`-dim vector.\n",
        "hidden_size = 256  # RNN hidden size.\n",
        "dropout = 0.2\n",
        "\n",
        "pure_seq2seq = EncoderDecoder(\n",
        "  encoder=Encoder(embed_size, hidden_size, dropout=dropout),\n",
        "  decoder=Decoder(embed_size, hidden_size, dropout=dropout),\n",
        "  src_embed=nn.Embedding(len(src_vocab_set), embed_size),\n",
        "  trg_embed=nn.Embedding(len(trg_vocab_set), embed_size),\n",
        "  generator=Generator(hidden_size, len(trg_vocab_set))).to(device)\n",
        "\n",
        "# Start training. The returned `dev_ppls` is a list of dev perplexity for each\n",
        "# epoch.\n",
        "pure_dev_ppls = train(pure_seq2seq, num_epochs=10, learning_rate=1e-3,\n",
        "                      train_data_loader=mt_train_data_loader,\n",
        "                      val_data_loader=mt_val_data_loader,\n",
        "                      task=\"seq2seq\", print_every=100)\n",
        "\n",
        "plot_perplexity(pure_dev_ppls)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ljzZFE51rj5d"
      },
      "source": [
        "Run the following cell to visualize some of the translations produced by your model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1DcDx_xGriSP"
      },
      "source": [
        "example_set = MTDataset(val_src_sentences_list, src_vocab_set,\n",
        "                        val_trg_sentences_list, trg_vocab_set)\n",
        "example_data_loader = data.DataLoader(mt_val_set, batch_size=1, num_workers=1,\n",
        "                                      shuffle=False)\n",
        "\n",
        "print_examples(pure_seq2seq, example_data_loader)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-Mr6dQSVsP7Z"
      },
      "source": [
        "For translation, BLEU score gives a better measure of performance than perplexity. Run this cell to compute your model's BLEU score on a test dataset. A reasonable BLEU score would be something around 6."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cCqdcglgsMiW"
      },
      "source": [
        "test_set = MTDataset(test_src_sentences_list, src_vocab_set,\n",
        "                     test_trg_sentences_list, trg_vocab_set, sampling=1.)\n",
        "test_data_loader = data.DataLoader(test_set, batch_size=1, num_workers=8,\n",
        "                                   shuffle=False)\n",
        "\n",
        "print(np.mean(compute_BLEU(pure_seq2seq, test_data_loader)))"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}