Day 03 Seq2Seq_NMT_Class.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Py3 research env",
      "language": "python",
      "name": "py3_research"
    },
    "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.6.7"
    },
    "colab": {
      "name": "Copy of practice03_seq2seq_NMT.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/lagom-QB/M12/blob/master/practice03_seq2seq_NMT.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aZ4shsYahtvx",
        "colab_type": "text"
      },
      "source": [
        "## Practice: Sequence to Sequence for Neural Machne Translation.\n",
        "\n",
        "*This notebook is based on [open-source implementation](https://github.com/bentrevett/pytorch-seq2seq/blob/master/1%20-%20Sequence%20to%20Sequence%20Learning%20with%20Neural%20Networks.ipynb) of seq2seq NMT in PyTorch.*\n",
        "\n",
        "We are going to implement the model from the [Sequence to Sequence Learning with Neural Networks](https://arxiv.org/abs/1409.3215) paper. \n",
        "\n",
        "The model will be trained for German to English translations, but it can be applied to any problem that involves going from one sequence to another, such as summarization.\n",
        "\n",
        "\n",
        "## Introduction\n",
        "\n",
        "The most common sequence-to-sequence (seq2seq) models are *encoder-decoder* models, which (commonly) use a *recurrent neural network* (RNN) to *encode* the source (input) sentence into a single vector. In this notebook, we'll refer to this single vector as a *context vector*. You can think of the context vector as being an abstract representation of the entire input sentence. This vector is then *decoded* by a second RNN which learns to output the target (output) sentence by generating it one word at a time.\n",
        "\n",
        "![](https://github.com/neychev/harbour_dlia2020/blob/master/day03/img/seq2seq1.png?raw=1)\n",
        "\n",
        "The above image shows an example translation. The input/source sentence, \"guten morgen\", is input into the encoder (green) one word at a time. We also append a *start of sequence* (`<sos>`) and *end of sequence* (`<eos>`) token to the start and end of sentence, respectively. At each time-step, the input to the encoder RNN is both the current word, $x_t$, as well as the hidden state from the previous time-step, $h_{t-1}$, and the encoder RNN outputs a new hidden state $h_t$. You can think of the hidden state as a vector representation of the sentence so far. The RNN can be represented as a function of both of $x_t$ and $h_{t-1}$:\n",
        "\n",
        "$$h_t = \\text{EncoderRNN}(x_t, h_{t-1})$$\n",
        "\n",
        "We're using the term RNN generally here, it could be any recurrent architecture, such as an *LSTM* (Long Short-Term Memory) or a *GRU* (Gated Recurrent Unit). \n",
        "\n",
        "Here, we have $X = \\{x_1, x_2, ..., x_T\\}$, where $x_1 = \\text{<sos>}, x_2 = \\text{guten}$, etc. The initial hidden state, $h_0$, is usually either initialized to zeros or a learned parameter.\n",
        "\n",
        "Once the final word, $x_T$, has been passed into the RNN, we use the final hidden state, $h_T$, as the context vector, i.e. $h_T = z$. This is a vector representation of the entire source sentence.\n",
        "\n",
        "Now we have our context vector, $z$, we can start decoding it to get the target sentence, \"good morning\". Again, we append start and end of sequence tokens to the target sentence. At each time-step, the input to the decoder RNN (blue) is the current word, $y_t$, as well as the hidden state from the previous time-step, $s_{t-1}$, where the initial decoder hidden state, $s_0$, is the context vector, $s_0 = z = h_T$, i.e. the initial decoder hidden state is the final encoder hidden state. Thus, similar to the encoder, we can represent the decoder as:\n",
        "\n",
        "$$s_t = \\text{DecoderRNN}(y_t, s_{t-1})$$\n",
        "\n",
        "In the decoder, we need to go from the hidden state to an actual word, therefore at each time-step we use $s_t$ to predict (by passing it through a `Linear` layer, shown in purple) what we think is the next word in the sequence, $\\hat{y}_t$. \n",
        "\n",
        "$$\\hat{y}_t = f(s_t)$$\n",
        "\n",
        "We always use `<sos>` for the first input to the decoder, $y_1$, but for subsequent inputs, $y_{t>1}$, we will sometimes use the actual, ground truth next word in the sequence, $y_t$ and sometimes use the word predicted by our decoder, $\\hat{y}_{t-1}$. This is called *teacher forcing*, and you can read about it more [here](https://machinelearningmastery.com/teacher-forcing-for-recurrent-neural-networks/).\n",
        "\n",
        "When training/testing our model, we always know how many words are in our target sentence, so we stop generating words once we hit that many. During inference (i.e. real world usage) it is common to keep generating words until the model outputs an `<eos>` token or after a certain amount of words have been generated.\n",
        "\n",
        "Once we have our predicted target sentence, $\\hat{Y} = \\{ \\hat{y}_1, \\hat{y}_2, ..., \\hat{y}_T \\}$, we compare it against our actual target sentence, $Y = \\{ y_1, y_2, ..., y_T \\}$, to calculate our loss. We then use this loss to update all of the parameters in our model.\n",
        "\n",
        "## Preparing Data\n",
        "\n",
        "We'll be coding up the models in PyTorch and using TorchText to help us do all of the pre-processing required. We'll also be using spaCy to assist in the tokenization of the data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RWCqIpulhtv1",
        "colab_type": "text"
      },
      "source": [
        "Uncomment the next cell if `torchtext` is not present on your machine."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u1YiACOMhtv6",
        "colab_type": "code",
        "outputId": "9c412836-df60-4f74-b88c-4d9b317bd60e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 133
        }
      },
      "source": [
        "! pip install torchtext"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: torchtext in /usr/local/lib/python3.6/dist-packages (0.3.1)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.6/dist-packages (from torchtext) (2.23.0)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.6/dist-packages (from torchtext) (4.41.1)\n",
            "Requirement already satisfied: torch in /usr/local/lib/python3.6/dist-packages (from torchtext) (1.5.0+cu101)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from torchtext) (1.18.5)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext) (1.24.3)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext) (2020.4.5.1)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext) (3.0.4)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext) (2.9)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.6/dist-packages (from torch->torchtext) (0.16.0)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NIyeXTMlhtwY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "\n",
        "from torchtext.datasets import TranslationDataset, Multi30k\n",
        "from torchtext.data import Field, BucketIterator\n",
        "\n",
        "import spacy\n",
        "\n",
        "import random\n",
        "import math\n",
        "import time"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bgr3A6oFhtwm",
        "colab_type": "text"
      },
      "source": [
        "We'll set the random seeds for deterministic results."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KjmtVdZMhtwq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "SEED = 1234\n",
        "\n",
        "random.seed(SEED)\n",
        "torch.manual_seed(SEED)\n",
        "torch.backends.cudnn.deterministic = True"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ewraOWTPhtw0",
        "colab_type": "text"
      },
      "source": [
        "Next, we'll create the tokenizers. A tokenizer is used to turn a string containing a sentence into a list of individual tokens that make up that string, e.g. \"good morning!\" becomes [\"good\", \"morning\", \"!\"]. We'll start talking about the sentences being a sequence of tokens from now, instead of saying they're a sequence of words. What's the difference? Well, \"good\" and \"morning\" are both words and tokens, but \"!\" is a token, not a word. \n",
        "\n",
        "spaCy has model for each language (\"de\" for German and \"en\" for English) which need to be loaded so we can access the tokenizer of each model. \n",
        "\n",
        "**Note**: the models must first be downloaded using the following on the command line: \n",
        "```\n",
        "python -m spacy download en\n",
        "python -m spacy download de\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KsfGBNpYhtw2",
        "colab_type": "text"
      },
      "source": [
        "Uncomment the next cell if you are using Colab or it's the first time you work with this notebook.\n",
        "\n",
        "__If you a working on local machine and in special env, you should run the code below in the exact env the current jupyter kernel is based on.__ E.g. using the following command if you use `conda`:\n",
        "\n",
        "```\n",
        "conda activate my_special_env\n",
        "python -m spacy download en\n",
        "python -m spacy download de\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rfz8v6MAhtw5",
        "colab_type": "code",
        "outputId": "1b2e99b9-bbe2-45e1-86ac-2169f167991d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 770
        }
      },
      "source": [
        "! python -m spacy download en\n",
        "! python -m spacy download de"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: en_core_web_sm==2.2.5 from https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-2.2.5/en_core_web_sm-2.2.5.tar.gz#egg=en_core_web_sm==2.2.5 in /usr/local/lib/python3.6/dist-packages (2.2.5)\n",
            "Requirement already satisfied: spacy>=2.2.2 in /usr/local/lib/python3.6/dist-packages (from en_core_web_sm==2.2.5) (2.2.4)\n",
            "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->en_core_web_sm==2.2.5) (2.0.3)\n",
            "Requirement already satisfied: tqdm<5.0.0,>=4.38.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->en_core_web_sm==2.2.5) (4.41.1)\n",
            "Requirement already satisfied: plac<1.2.0,>=0.9.6 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->en_core_web_sm==2.2.5) (1.1.3)\n",
            "Requirement already satisfied: requests<3.0.0,>=2.13.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->en_core_web_sm==2.2.5) (2.23.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->en_core_web_sm==2.2.5) (47.1.1)\n",
            "Requirement already satisfied: thinc==7.4.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->en_core_web_sm==2.2.5) (7.4.0)\n",
            "Requirement already satisfied: numpy>=1.15.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->en_core_web_sm==2.2.5) (1.18.5)\n",
            "Requirement already satisfied: blis<0.5.0,>=0.4.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->en_core_web_sm==2.2.5) (0.4.1)\n",
            "Requirement already satisfied: catalogue<1.1.0,>=0.0.7 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->en_core_web_sm==2.2.5) (1.0.0)\n",
            "Requirement already satisfied: srsly<1.1.0,>=1.0.2 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->en_core_web_sm==2.2.5) (1.0.2)\n",
            "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->en_core_web_sm==2.2.5) (3.0.2)\n",
            "Requirement already satisfied: wasabi<1.1.0,>=0.4.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->en_core_web_sm==2.2.5) (0.6.0)\n",
            "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->en_core_web_sm==2.2.5) (1.0.2)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests<3.0.0,>=2.13.0->spacy>=2.2.2->en_core_web_sm==2.2.5) (1.24.3)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests<3.0.0,>=2.13.0->spacy>=2.2.2->en_core_web_sm==2.2.5) (2.9)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests<3.0.0,>=2.13.0->spacy>=2.2.2->en_core_web_sm==2.2.5) (2020.4.5.1)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests<3.0.0,>=2.13.0->spacy>=2.2.2->en_core_web_sm==2.2.5) (3.0.4)\n",
            "Requirement already satisfied: importlib-metadata>=0.20; python_version < \"3.8\" in /usr/local/lib/python3.6/dist-packages (from catalogue<1.1.0,>=0.0.7->spacy>=2.2.2->en_core_web_sm==2.2.5) (1.6.0)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.6/dist-packages (from importlib-metadata>=0.20; python_version < \"3.8\"->catalogue<1.1.0,>=0.0.7->spacy>=2.2.2->en_core_web_sm==2.2.5) (3.1.0)\n",
            "\u001b[38;5;2m✔ Download and installation successful\u001b[0m\n",
            "You can now load the model via spacy.load('en_core_web_sm')\n",
            "\u001b[38;5;2m✔ Linking successful\u001b[0m\n",
            "/usr/local/lib/python3.6/dist-packages/en_core_web_sm -->\n",
            "/usr/local/lib/python3.6/dist-packages/spacy/data/en\n",
            "You can now load the model via spacy.load('en')\n",
            "Collecting de_core_news_sm==2.2.5\n",
            "\u001b[?25l  Downloading https://github.com/explosion/spacy-models/releases/download/de_core_news_sm-2.2.5/de_core_news_sm-2.2.5.tar.gz (14.9MB)\n",
            "\u001b[K     |████████████████████████████████| 14.9MB 738kB/s \n",
            "\u001b[?25hRequirement already satisfied: spacy>=2.2.2 in /usr/local/lib/python3.6/dist-packages (from de_core_news_sm==2.2.5) (2.2.4)\n",
            "Requirement already satisfied: requests<3.0.0,>=2.13.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->de_core_news_sm==2.2.5) (2.23.0)\n",
            "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->de_core_news_sm==2.2.5) (2.0.3)\n",
            "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->de_core_news_sm==2.2.5) (1.0.2)\n",
            "Requirement already satisfied: srsly<1.1.0,>=1.0.2 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->de_core_news_sm==2.2.5) (1.0.2)\n",
            "Requirement already satisfied: tqdm<5.0.0,>=4.38.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->de_core_news_sm==2.2.5) (4.41.1)\n",
            "Requirement already satisfied: numpy>=1.15.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->de_core_news_sm==2.2.5) (1.18.5)\n",
            "Requirement already satisfied: blis<0.5.0,>=0.4.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->de_core_news_sm==2.2.5) (0.4.1)\n",
            "Requirement already satisfied: wasabi<1.1.0,>=0.4.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->de_core_news_sm==2.2.5) (0.6.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->de_core_news_sm==2.2.5) (47.1.1)\n",
            "Requirement already satisfied: plac<1.2.0,>=0.9.6 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->de_core_news_sm==2.2.5) (1.1.3)\n",
            "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->de_core_news_sm==2.2.5) (3.0.2)\n",
            "Requirement already satisfied: catalogue<1.1.0,>=0.0.7 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->de_core_news_sm==2.2.5) (1.0.0)\n",
            "Requirement already satisfied: thinc==7.4.0 in /usr/local/lib/python3.6/dist-packages (from spacy>=2.2.2->de_core_news_sm==2.2.5) (7.4.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests<3.0.0,>=2.13.0->spacy>=2.2.2->de_core_news_sm==2.2.5) (2020.4.5.1)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests<3.0.0,>=2.13.0->spacy>=2.2.2->de_core_news_sm==2.2.5) (3.0.4)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests<3.0.0,>=2.13.0->spacy>=2.2.2->de_core_news_sm==2.2.5) (1.24.3)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests<3.0.0,>=2.13.0->spacy>=2.2.2->de_core_news_sm==2.2.5) (2.9)\n",
            "Requirement already satisfied: importlib-metadata>=0.20; python_version < \"3.8\" in /usr/local/lib/python3.6/dist-packages (from catalogue<1.1.0,>=0.0.7->spacy>=2.2.2->de_core_news_sm==2.2.5) (1.6.0)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.6/dist-packages (from importlib-metadata>=0.20; python_version < \"3.8\"->catalogue<1.1.0,>=0.0.7->spacy>=2.2.2->de_core_news_sm==2.2.5) (3.1.0)\n",
            "Building wheels for collected packages: de-core-news-sm\n",
            "  Building wheel for de-core-news-sm (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for de-core-news-sm: filename=de_core_news_sm-2.2.5-cp36-none-any.whl size=14907056 sha256=bf16d9fcd4c539d2818134443376dad5d9c0c098688d604f1422ae18c3bdd465\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-tm0tbzl7/wheels/ba/3f/ed/d4aa8e45e7191b7f32db4bfad565e7da1edbf05c916ca7a1ca\n",
            "Successfully built de-core-news-sm\n",
            "Installing collected packages: de-core-news-sm\n",
            "Successfully installed de-core-news-sm-2.2.5\n",
            "\u001b[38;5;2m✔ Download and installation successful\u001b[0m\n",
            "You can now load the model via spacy.load('de_core_news_sm')\n",
            "\u001b[38;5;2m✔ Linking successful\u001b[0m\n",
            "/usr/local/lib/python3.6/dist-packages/de_core_news_sm -->\n",
            "/usr/local/lib/python3.6/dist-packages/spacy/data/de\n",
            "You can now load the model via spacy.load('de')\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RrLVR075htxE",
        "colab_type": "text"
      },
      "source": [
        "We load the models as such:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AZFvdvzIhtxI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "spacy_de = spacy.load('de')\n",
        "spacy_en = spacy.load('en')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P3_XnstfhtxX",
        "colab_type": "text"
      },
      "source": [
        "Next, we create the tokenizer functions. These can be passed to TorchText and will take in the sentence as a string and return the sentence as a list of tokens.\n",
        "\n",
        "In the paper we are implementing, they find it beneficial to reverse the order of the input which they believe \"introduces many short term dependencies in the data that make the optimization problem much easier\"."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XREnviUbhtxY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def tokenize_de(text):\n",
        "    \"\"\"\n",
        "    Tokenizes German text from a string into a list of strings (tokens) and reverses it\n",
        "    \"\"\"\n",
        "    return [tok.text for tok in spacy_de.tokenizer(text)][::-1]\n",
        "\n",
        "def tokenize_en(text):\n",
        "    \"\"\"\n",
        "    Tokenizes English text from a string into a list of strings (tokens)\n",
        "    \"\"\"\n",
        "    return [tok.text for tok in spacy_en.tokenizer(text)]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "64qvwFYIhtxh",
        "colab_type": "text"
      },
      "source": [
        "TorchText's `Field`s handle how data should be processed. You can read all of the possible arguments [here](https://github.com/pytorch/text/blob/master/torchtext/data/field.py#L61). \n",
        "\n",
        "We set the `tokenize` argument to the correct tokenization function for each, with German being the `SRC` (source) field and English being the `TRG` (target) field. The field also appends the \"start of sequence\" and \"end of sequence\" tokens via the `init_token` and `eos_token` arguments, and converts all words to lowercase."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mXKUUIPhhtxi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "SRC = Field(tokenize = tokenize_de, \n",
        "            init_token = '<sos>', \n",
        "            eos_token = '<eos>', \n",
        "            lower = True)\n",
        "\n",
        "TRG = Field(tokenize = tokenize_en, \n",
        "            init_token = '<sos>', \n",
        "            eos_token = '<eos>', \n",
        "            lower = True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mu-kiYZWhtxr",
        "colab_type": "text"
      },
      "source": [
        "Next, we download and load the train, validation and test data. \n",
        "\n",
        "The dataset we'll be using is the [Multi30k dataset](https://github.com/multi30k/dataset). This is a dataset with ~30,000 parallel English, German and French sentences, each with ~12 words per sentence. \n",
        "\n",
        "`exts` specifies which languages to use as the source and target (source goes first) and `fields` specifies which field to use for the source and target."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qNAtXeU8htxt",
        "colab_type": "code",
        "outputId": "28248371-7fe6-4d84-d965-06decadb30c6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        }
      },
      "source": [
        "train_data, valid_data, test_data = Multi30k.splits(exts = ('.de', '.en'), \n",
        "                                                    fields = (SRC, TRG))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "downloading training.tar.gz\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "training.tar.gz: 100%|██████████| 1.21M/1.21M [00:04<00:00, 281kB/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "downloading validation.tar.gz\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "validation.tar.gz: 100%|██████████| 46.3k/46.3k [00:00<00:00, 80.7kB/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "downloading mmt_task1_test2016.tar.gz\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "mmt_task1_test2016.tar.gz: 100%|██████████| 66.2k/66.2k [00:00<00:00, 75.5kB/s]\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H5E_QZzthtx4",
        "colab_type": "code",
        "outputId": "9f071755-f858-48c2-ca8f-7ed09c263173",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 145
        }
      },
      "source": [
        "train_data[0].trg"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['two',\n",
              " 'young',\n",
              " ',',\n",
              " 'white',\n",
              " 'males',\n",
              " 'are',\n",
              " 'outside',\n",
              " 'near',\n",
              " 'many',\n",
              " 'bushes',\n",
              " '.']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uuGtO42jhtyB",
        "colab_type": "text"
      },
      "source": [
        "We can double check that we've loaded the right number of examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V6-Fa4UxhtyD",
        "colab_type": "code",
        "outputId": "0d91d822-aee0-429d-94bf-8f0337865b1c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "print(f\"Number of training examples: {len(train_data.examples)}\")\n",
        "print(f\"Number of validation examples: {len(valid_data.examples)}\")\n",
        "print(f\"Number of testing examples: {len(test_data.examples)}\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number of training examples: 29000\n",
            "Number of validation examples: 1014\n",
            "Number of testing examples: 1000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M0j9xb36htyP",
        "colab_type": "text"
      },
      "source": [
        "We can also print out an example, making sure the source sentence is reversed:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S6qMchePhtyR",
        "colab_type": "code",
        "outputId": "cb510620-e1c1-4a05-87c6-d45b011a3146",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 29
        }
      },
      "source": [
        "print(vars(train_data.examples[0]))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'src': ['.', 'büsche', 'vieler', 'nähe', 'der', 'in', 'freien', 'im', 'sind', 'männer', 'weiße', 'junge', 'zwei'], 'trg': ['two', 'young', ',', 'white', 'males', 'are', 'outside', 'near', 'many', 'bushes', '.']}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gVEACltkhtyc",
        "colab_type": "text"
      },
      "source": [
        "The period is at the beginning of the German (src) sentence, so looks good!\n",
        "\n",
        "Next, we'll build the *vocabulary* for the source and target languages. The vocabulary is used to associate each unique token with an index (an integer) and this is used to build a one-hot encoding for each token (a vector of all zeros except for the position represented by the index, which is 1). The vocabularies of the source and target languages are distinct.\n",
        "\n",
        "Using the `min_freq` argument, we only allow tokens that appear at least 2 times to appear in our vocabulary. Tokens that appear only once are converted into an `<unk>` (unknown) token.\n",
        "\n",
        "It is important to note that your vocabulary should only be built from the training set and not the validation/test set. This prevents \"information leakage\" into your model, giving you artifically inflated validation/test scores."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qtdcF5tMhtye",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "SRC.build_vocab(train_data, min_freq = 2)\n",
        "TRG.build_vocab(train_data, min_freq = 2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Oni_XA77htyl",
        "colab_type": "code",
        "outputId": "085d6208-1c53-491f-ee6c-1c21d5a74c62",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 40
        }
      },
      "source": [
        "print(f\"Unique tokens in source (de) vocabulary: {len(SRC.vocab)}\")\n",
        "print(f\"Unique tokens in target (en) vocabulary: {len(TRG.vocab)}\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Unique tokens in source (de) vocabulary: 7855\n",
            "Unique tokens in target (en) vocabulary: 5893\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NTdabRxQhtyu",
        "colab_type": "text"
      },
      "source": [
        "The final step of preparing the data is to create the iterators. These can be iterated on to return a batch of data which will have a `src` attribute (the PyTorch tensors containing a batch of numericalized source sentences) and a `trg` attribute (the PyTorch tensors containing a batch of numericalized target sentences). Numericalized is just a fancy way of saying they have been converted from a sequence of readable tokens to a sequence of corresponding indexes, using the vocabulary. \n",
        "\n",
        "We also need to define a `torch.device`. This is used to tell TorchText to put the tensors on the GPU or not. We use the `torch.cuda.is_available()` function, which will return `True` if a GPU is detected on our computer. We pass this `device` to the iterator.\n",
        "\n",
        "When we get a batch of examples using an iterator we need to make sure that all of the source sentences are padded to the same length, the same with the target sentences. Luckily, TorchText iterators handle this for us! \n",
        "\n",
        "We use a `BucketIterator` instead of the standard `Iterator` as it creates batches in such a way that it minimizes the amount of padding in both the source and target sentences. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rHaLXqpkhtyv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AW-yhvJ8hty2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "BATCH_SIZE = 128\n",
        "\n",
        "train_iterator, valid_iterator, test_iterator = BucketIterator.splits(\n",
        "    (train_data, valid_data, test_data), \n",
        "    batch_size = BATCH_SIZE, \n",
        "    device = device)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3DRqhdKKhtzA",
        "colab_type": "text"
      },
      "source": [
        "Let's look up what's stored in train and test iterators:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vCQKLudRhtzC",
        "colab_type": "code",
        "outputId": "010c13f4-2ad0-438f-e12e-a370552fca0f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 75
        }
      },
      "source": [
        "for x in train_iterator:\n",
        "    break\n",
        "print(x)\n",
        "print(x.src.shape, x.trg.shape)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "[torchtext.data.batch.Batch of size 128 from MULTI30K]\n",
            "\t[.src]:[torch.cuda.LongTensor of size 23x128 (GPU 0)]\n",
            "\t[.trg]:[torch.cuda.LongTensor of size 21x128 (GPU 0)]\n",
            "torch.Size([23, 128]) torch.Size([21, 128])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ODYM_eo1htzI",
        "colab_type": "text"
      },
      "source": [
        "One could mention, that the first dimention is now `seq_len`, not `batch` as used to be. It's because in PyTorch LSTM (and other recurrent units) await for input in format `(seq_len, batch, input_size)`. Be careful with that (especially in your homework assignment)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rJMZuvzthtzK",
        "colab_type": "text"
      },
      "source": [
        "## Building the Seq2Seq Model\n",
        "\n",
        "We'll be building our model in three parts. The encoder, the decoder and a seq2seq model that encapsulates the encoder and decoder and will provide a way to interface with each.\n",
        "\n",
        "### Encoder\n",
        "\n",
        "First, the encoder, a 2 layer LSTM. The paper we are implementing uses a 4-layer LSTM, but in the interest of training time we cut this down to 2-layers. The concept of multi-layer RNNs is easy to expand from 2 to 4 layers. \n",
        "\n",
        "For a multi-layer RNN, the input sentence, $X$, goes into the first (bottom) layer of the RNN and hidden states, $H=\\{h_1, h_2, ..., h_T\\}$, output by this layer are used as inputs to the RNN in the layer above. Thus, representing each layer with a superscript, the hidden states in the first layer are given by:\n",
        "\n",
        "$$h_t^1 = \\text{EncoderRNN}^1(x_t, h_{t-1}^1)$$\n",
        "\n",
        "The hidden states in the second layer are given by:\n",
        "\n",
        "$$h_t^2 = \\text{EncoderRNN}^2(h_t^1, h_{t-1}^2)$$\n",
        "\n",
        "Using a multi-layer RNN also means we'll also need an initial hidden state as input per layer, $h_0^l$, and we will also output a context vector per layer, $z^l$.\n",
        "\n",
        "Without going into too much detail about LSTMs (see [this](https://colah.github.io/posts/2015-08-Understanding-LSTMs/) blog post if you want to learn more about them), all we need to know is that they're a type of RNN which instead of just taking in a hidden state and returning a new hidden state per time-step, also take in and return a *cell state*, $c_t$, per time-step.\n",
        "\n",
        "$$\\begin{align*}\n",
        "h_t &= \\text{RNN}(x_t, h_{t-1})\\\\\n",
        "(h_t, c_t) &= \\text{LSTM}(x_t, (h_{t-1}, c_{t-1}))\n",
        "\\end{align*}$$\n",
        "\n",
        "\n",
        "You can just think of $c_t$ as another type of hidden state. Similar to $h_0^l$, $c_0^l$ will be initialized to a tensor of all zeros. Also, our context vector will now be both the final hidden state and the final cell state, i.e. $z^l = (h_T^l, c_T^l)$.\n",
        "\n",
        "Extending our multi-layer equations to LSTMs, we get:\n",
        "\n",
        "$$\\begin{align*}\n",
        "(h_t^1, c_t^1) &= \\text{EncoderLSTM}^1(x_t, (h_{t-1}^1, c_{t-1}^1))\\\\\n",
        "(h_t^2, c_t^2) &= \\text{EncoderLSTM}^2(h_t^1, (h_{t-1}^2, c_{t-1}^2))\n",
        "\\end{align*}$$\n",
        "\n",
        "Note how only our hidden state from the first layer is passed as input to the second layer, and not the cell state.\n",
        "\n",
        "So our encoder looks something like this: \n",
        "\n",
        "![](https://github.com/neychev/harbour_dlia2020/blob/master/day03/img/seq2seq2.png?raw=1)\n",
        "\n",
        "We create this in code by making an `Encoder` module, which requires we inherit from `torch.nn.Module` and use the `super().__init__()` as some boilerplate code. The encoder takes the following arguments:\n",
        "- `input_dim` is the size/dimensionality of the one-hot vectors that will be input to the encoder. This is equal to the input (source) vocabulary size.\n",
        "- `emb_dim` is the dimensionality of the embedding layer. This layer converts the one-hot vectors into dense vectors with `emb_dim` dimensions. \n",
        "- `hid_dim` is the dimensionality of the hidden and cell states.\n",
        "- `n_layers` is the number of layers in the RNN.\n",
        "- `dropout` is the amount of dropout to use. This is a regularization parameter to prevent overfitting. Check out [this](https://www.coursera.org/lecture/deep-neural-network/understanding-dropout-YaGbR) for more details about dropout.\n",
        "\n",
        "To get more info about `nn.Embedding` one could refer to these articles: [1](https://monkeylearn.com/blog/word-embeddings-transform-text-numbers/), [2](http://p.migdal.pl/2017/01/06/king-man-woman-queen-why.html), [3](http://mccormickml.com/2016/04/19/word2vec-tutorial-the-skip-gram-model/), [4](http://mccormickml.com/2017/01/11/word2vec-tutorial-part-2-negative-sampling/). \n",
        "\n",
        "The embedding layer is created using `nn.Embedding`, the LSTM with `nn.LSTM` and a dropout layer with `nn.Dropout`. Check the PyTorch [documentation](https://pytorch.org/docs/stable/nn.html) for more about these.\n",
        "\n",
        "One thing to note is that the `dropout` argument to the LSTM is how much dropout to apply between the layers of a multi-layer RNN, i.e. between the hidden states output from layer $l$ and those same hidden states being used for the input of layer $l+1$.\n",
        "\n",
        "In the `forward` method, we pass in the source sentence, $X$, which is converted into dense vectors using the `embedding` layer, and then dropout is applied. These embeddings are then passed into the RNN. As we pass a whole sequence to the RNN, it will automatically do the recurrent calculation of the hidden states over the whole sequence for us! You may notice that we do not pass an initial hidden or cell state to the RNN. This is because, as noted in the [documentation](https://pytorch.org/docs/stable/nn.html#torch.nn.LSTM), that if no hidden/cell state is passed to the RNN, it will automatically create an initial hidden/cell state as a tensor of all zeros. \n",
        "\n",
        "The RNN returns: `outputs` (the top-layer hidden state for each time-step), `hidden` (the final hidden state for each layer, $h_T$, stacked on top of each other) and `cell` (the final cell state for each layer, $c_T$, stacked on top of each other).\n",
        "\n",
        "As we only need the final hidden and cell states (to make our context vector), `forward` only returns `hidden` and `cell`. \n",
        "\n",
        "The sizes of each of the tensors is left as comments in the code. In this implementation `n_directions` will always be 1, because for now we are working only with one-direction LSTM."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bl2TN7GQhtzL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Encoder(nn.Module):\n",
        "    def __init__(self, input_dim, emb_dim, hid_dim, n_layers, dropout):\n",
        "        super().__init__()\n",
        "       \n",
        "        self.input_dim = input_dim\n",
        "        self.emb_dim = emb_dim\n",
        "        self.hid_dim = hid_dim\n",
        "        self.n_layers = n_layers\n",
        "       \n",
        "        self.embedding = nn.Embedding(\n",
        "            num_embeddings=input_dim,\n",
        "            embedding_dim=emb_dim\n",
        "        )                                                                                   # <YOUR CODE HERE>\n",
        "       \n",
        "        self.rnn = nn.LSTM(\n",
        "            input_size=emb_dim,\n",
        "            hidden_size=hid_dim,\n",
        "            num_layers=n_layers,\n",
        "            dropout=dropout\n",
        "        )                                                                                   # <YOUR CODE HERE>\n",
        "       \n",
        "        self.dropout = nn.Dropout(p=dropout)                                                # <YOUR CODE HERE>\n",
        "       \n",
        "    def forward(self, src):\n",
        "       \n",
        "        #src = [src sent len, batch size]\n",
        "       \n",
        "        # Compute an embedding from the src data and apply dropout to it\n",
        "        embedded = self.embedding(src)# <YOUR CODE HERE>\n",
        "               \n",
        "        #embedded = [src sent len, batch size, emb dim]\n",
        "       \n",
        "        # Compute the RNN output values of the encoder RNN.\n",
        "        # outputs, hidden and cell should be initialized here. Refer to nn.LSTM docs ;)\n",
        "       \n",
        "        output, (hidden, cell) = self.rnn(embedded)                                         # <YOUR CODE HERE>\n",
        " \n",
        "       \n",
        "        #outputs = [src sent len, batch size, hid dim * n directions]\n",
        "        #hidden = [n layers * n directions, batch size, hid dim]\n",
        "        #cell = [n layers * n directions, batch size, hid dim]\n",
        "       \n",
        "        #outputs are always from the top hidden layer\n",
        "       \n",
        "        return hidden, cell"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I87QI8gxhtzR",
        "colab_type": "text"
      },
      "source": [
        "### Decoder\n",
        "\n",
        "Next, we'll build our decoder, which will also be a 2-layer (4 in the paper) LSTM.\n",
        "\n",
        "![](https://github.com/neychev/harbour_dlia2020/blob/master/day03/img/seq2seq3.png?raw=1)\n",
        "\n",
        "The `Decoder` class does a single step of decoding. The first layer will receive a hidden and cell state from the previous time-step, $(s_{t-1}^1, c_{t-1}^1)$, and feed it through the LSTM with the current token, $y_t$, to produce a new hidden and cell state, $(s_t^1, c_t^1)$. The subsequent layers will use the hidden state from the layer below, $s_t^{l-1}$, and the previous hidden and cell states from their layer, $(s_{t-1}^l, c_{t-1}^l)$. This provides equations very similar to those in the encoder.\n",
        "\n",
        "$$\\begin{align*}\n",
        "(s_t^1, c_t^1) = \\text{DecoderLSTM}^1(y_t, (s_{t-1}^1, c_{t-1}^1))\\\\\n",
        "(s_t^2, c_t^2) = \\text{DecoderLSTM}^2(s_t^1, (s_{t-1}^2, c_{t-1}^2))\n",
        "\\end{align*}$$\n",
        "\n",
        "Remember that the initial hidden and cell states to our decoder are our context vectors, which are the final hidden and cell states of our encoder from the same layer, i.e. $(s_0^l,c_0^l)=z^l=(h_T^l,c_T^l)$.\n",
        "\n",
        "We then pass the hidden state from the top layer of the RNN, $s_t^L$, through a linear layer, $f$, to make a prediction of what the next token in the target (output) sequence should be, $\\hat{y}_{t+1}$. \n",
        "\n",
        "$$\\hat{y}_{t+1} = f(s_t^L)$$\n",
        "\n",
        "The arguments and initialization are similar to the `Encoder` class, except we now have an `output_dim` which is the size of the one-hot vectors that will be input to the decoder. These are equal to the vocabulary size of the output/target. There is also the addition of the `Linear` layer, used to make the predictions from the top layer hidden state.\n",
        "\n",
        "Within the `forward` method, we accept a batch of input tokens, previous hidden states and previous cell states. We `unsqueeze` the input tokens to add a sentence length dimension of 1. Then, similar to the encoder, we pass through an embedding layer and apply dropout. This batch of embedded tokens is then passed into the RNN with the previous hidden and cell states. This produces an `output` (hidden state from the top layer of the RNN), a new `hidden` state (one for each layer, stacked on top of each other) and a new `cell` state (also one per layer, stacked on top of each other). We then pass the `output` (after getting rid of the sentence length dimension) through the linear layer to receive our `prediction`. We then return the `prediction`, the new `hidden` state and the new `cell` state."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B1b_zp3WhtzU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Decoder(nn.Module):\n",
        "    def __init__(self, output_dim, emb_dim, hid_dim, n_layers, dropout):\n",
        "        super().__init__()\n",
        " \n",
        "        self.emb_dim = emb_dim\n",
        "        self.hid_dim = hid_dim\n",
        "        self.output_dim = output_dim\n",
        "        self.n_layers = n_layers\n",
        "       \n",
        "        self.embedding = nn.Embedding(\n",
        "            num_embeddings=output_dim,\n",
        "            embedding_dim=emb_dim\n",
        "        )                                                                                   # <YOUR CODE HERE>\n",
        "       \n",
        "        self.rnn = nn.LSTM(\n",
        "            input_size=emb_dim,\n",
        "            hidden_size=hid_dim,\n",
        "            num_layers=n_layers,\n",
        "            dropout=dropout\n",
        "        )                                                                                   # <YOUR CODE HERE>\n",
        "       \n",
        "        self.out = nn.Linear(hid_dim, output_dim)                                           # <YOUR CODE HERE>\n",
        "       \n",
        "        self.dropout = nn.Dropout(p=dropout)                                                # <YOUR CODE HERE>\n",
        "       \n",
        "    def forward(self, input, hidden, cell):\n",
        "       \n",
        "        #input = [batch size]\n",
        "        #hidden = [n layers * n directions, batch size, hid dim]\n",
        "        #cell = [n layers * n directions, batch size, hid dim]\n",
        "       \n",
        "        #n directions in the decoder will both always be 1, therefore:\n",
        "        #hidden = [n layers, batch size, hid dim]\n",
        "        #context = [n layers, batch size, hid dim]\n",
        "       \n",
        "        input = input.unsqueeze(0)\n",
        "       \n",
        "        #input = [1, batch size]\n",
        "       \n",
        "        # Compute an embedding from the input data and apply dropout to it\n",
        "        embedded = self.dropout(self.embedding(input))                                      # <YOUR CODE HERE>\n",
        "       \n",
        "        #embedded = [1, batch size, emb dim]\n",
        "       \n",
        "        # Compute the RNN output values of the encoder RNN.\n",
        "        # outputs, hidden and cell should be initialized here. Refer to nn.LSTM docs ;)\n",
        " \n",
        "        output, (hidden, cell) = self.rnn(embedded, (hidden, cell))                         # <YOUR CODE HERE>\n",
        "       \n",
        "       \n",
        "        #output = [sent len, batch size, hid dim * n directions]\n",
        "        #hidden = [n layers * n directions, batch size, hid dim]\n",
        "        #cell = [n layers * n directions, batch size, hid dim]\n",
        "       \n",
        "        #sent len and n directions will always be 1 in the decoder, therefore:\n",
        "        #output = [1, batch size, hid dim]\n",
        "        #hidden = [n layers, batch size, hid dim]\n",
        "        #cell = [n layers, batch size, hid dim]\n",
        "       \n",
        "       \n",
        "        prediction = self.out(output.squeeze(0))\n",
        "       \n",
        "        #prediction = [batch size, output dim]\n",
        "       \n",
        "        return prediction, hidden, cell"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ivPhPNNQhtzZ",
        "colab_type": "text"
      },
      "source": [
        "### Seq2Seq\n",
        "\n",
        "For the final part of the implemenetation, we'll implement the seq2seq model. This will handle: \n",
        "- receiving the input/source sentence\n",
        "- using the encoder to produce the context vectors \n",
        "- using the decoder to produce the predicted output/target sentence\n",
        "\n",
        "Our full model will look like this:\n",
        "\n",
        "![](https://github.com/neychev/harbour_dlia2020/blob/master/day03/img/seq2seq4.png?raw=1)\n",
        "\n",
        "The `Seq2Seq` model takes in an `Encoder`, `Decoder`, and a `device` (used to place tensors on the GPU, if it exists).\n",
        "\n",
        "For this implementation, we have to ensure that the number of layers and the hidden (and cell) dimensions are equal in the `Encoder` and `Decoder`. This is not always the case, you do not necessarily need the same number of layers or the same hidden dimension sizes in a sequence-to-sequence model. However, if you do something like having a different number of layers you will need to make decisions about how this is handled. For example, if your encoder has 2 layers and your decoder only has 1, how is this handled? Do you average the two context vectors output by the decoder? Do you pass both through a linear layer? Do you only use the context vector from the highest layer? Etc.\n",
        "\n",
        "Our `forward` method takes the source sentence, target sentence and a teacher-forcing ratio. The teacher forcing ratio is used when training our model. When decoding, at each time-step we will predict what the next token in the target sequence will be from the previous tokens decoded, $\\hat{y}_{t+1}=f(s_t^L)$. With probability equal to the teaching forcing ratio (`teacher_forcing_ratio`) we will use the actual ground-truth next token in the sequence as the input to the decoder during the next time-step. However, with probability `1 - teacher_forcing_ratio`, we will use the token that the model predicted as the next input to the model, even if it doesn't match the actual next token in the sequence.  \n",
        "\n",
        "The first thing we do in the `forward` method is to create an `outputs` tensor that will store all of our predictions, $\\hat{Y}$.\n",
        "\n",
        "We then feed the input/source sentence, $X$/`src`, into the encoder and receive out final hidden and cell states.\n",
        "\n",
        "The first input to the decoder is the start of sequence (`<sos>`) token. As our `trg` tensor already has the `<sos>` token appended (all the way back when we defined the `init_token` in our `TRG` field) we get our $y_1$ by slicing into it. We know how long our target sentences should be (`max_len`), so we loop that many times. During each iteration of the loop, we:\n",
        "- pass the input, previous hidden and previous cell states ($y_t, s_{t-1}, c_{t-1}$) into the decoder\n",
        "- receive a prediction, next hidden state and next cell state ($\\hat{y}_{t+1}, s_{t}, c_{t}$) from the decoder\n",
        "- place our prediction, $\\hat{y}_{t+1}$/`output` in our tensor of predictions, $\\hat{Y}$/`outputs`\n",
        "- decide if we are going to \"teacher force\" or not\n",
        "    - if we do, the next `input` is the ground-truth next token in the sequence, $y_{t+1}$/`trg[t]`\n",
        "    - if we don't, the next `input` is the predicted next token in the sequence, $\\hat{y}_{t+1}$/`top1`\n",
        "    \n",
        "Once we've made all of our predictions, we return our tensor full of predictions, $\\hat{Y}$/`outputs`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WUZ2etlKhtzb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Seq2Seq(nn.Module):\n",
        "    def __init__(self, encoder, decoder, device):\n",
        "        super().__init__()\n",
        "        \n",
        "        self.encoder = encoder\n",
        "        self.decoder = decoder\n",
        "        self.device = device\n",
        "        \n",
        "        assert encoder.hid_dim == decoder.hid_dim, \\\n",
        "            \"Hidden dimensions of encoder and decoder must be equal!\"\n",
        "        assert encoder.n_layers == decoder.n_layers, \\\n",
        "            \"Encoder and decoder must have equal number of layers!\"\n",
        "        \n",
        "    def forward(self, src, trg, teacher_forcing_ratio = 0.5):\n",
        "        \n",
        "        #src = [src sent len, batch size]\n",
        "        #trg = [trg sent len, batch size]\n",
        "        #teacher_forcing_ratio is probability to use teacher forcing\n",
        "        #e.g. if teacher_forcing_ratio is 0.75 we use ground-truth inputs 75% of the time\n",
        "        \n",
        "        # Again, now batch is the first dimention instead of zero\n",
        "        batch_size = trg.shape[1]\n",
        "        max_len = trg.shape[0]\n",
        "        trg_vocab_size = self.decoder.output_dim\n",
        "        \n",
        "        #tensor to store decoder outputs\n",
        "        outputs = torch.zeros(max_len, batch_size, trg_vocab_size).to(self.device)\n",
        "        \n",
        "        #last hidden state of the encoder is used as the initial hidden state of the decoder\n",
        "        hidden, cell = self.encoder(src)\n",
        "        \n",
        "        #first input to the decoder is the <sos> tokens\n",
        "        input = trg[0,:]\n",
        "        \n",
        "        for t in range(1, max_len):\n",
        "            \n",
        "            output, hidden, cell = self.decoder(input, hidden, cell)\n",
        "            outputs[t] = output\n",
        "            teacher_force = random.random() < teacher_forcing_ratio\n",
        "            top1 = output.max(1)[1]\n",
        "            input = (trg[t] if teacher_force else top1)\n",
        "        \n",
        "        return outputs"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FTAgcaP1htzn",
        "colab_type": "text"
      },
      "source": [
        "# Training the Seq2Seq Model\n",
        "\n",
        "Now we have our model implemented, we can begin training it. \n",
        "\n",
        "First, we'll initialize our model. As mentioned before, the input and output dimensions are defined by the size of the vocabulary. The embedding dimesions and dropout for the encoder and decoder can be different, but the number of layers and the size of the hidden/cell states must be the same. \n",
        "\n",
        "We then define the encoder, decoder and then our Seq2Seq model, which we place on the `device`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vfJt7hdHhtzp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "INPUT_DIM = len(SRC.vocab)\n",
        "OUTPUT_DIM = len(TRG.vocab)\n",
        "ENC_EMB_DIM = 256\n",
        "DEC_EMB_DIM = 256\n",
        "HID_DIM = 512\n",
        "N_LAYERS = 2\n",
        "ENC_DROPOUT = 0.5\n",
        "DEC_DROPOUT = 0.5\n",
        "\n",
        "enc = Encoder(INPUT_DIM, ENC_EMB_DIM, HID_DIM, N_LAYERS, ENC_DROPOUT)\n",
        "dec = Decoder(OUTPUT_DIM, DEC_EMB_DIM, HID_DIM, N_LAYERS, DEC_DROPOUT)\n",
        "\n",
        "# dont forget to put the model to the right device\n",
        "model = Seq2Seq(enc, dec, device).to(device)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YRJDDKL2htzy",
        "colab_type": "text"
      },
      "source": [
        "Next up is initializing the weights of our model. In the paper they state they initialize all weights from a uniform distribution between -0.08 and +0.08, i.e. $\\mathcal{U}(-0.08, 0.08)$.\n",
        "\n",
        "We initialize weights in PyTorch by creating a function which we `apply` to our model. When using `apply`, the `init_weights` function will be called on every module and sub-module within our model. For each module we loop through all of the parameters and sample them from a uniform distribution with `nn.init.uniform_`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8zyQ05pYhtzz",
        "colab_type": "code",
        "outputId": "321227f0-d509-401c-e2aa-104241f8610a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 168
        }
      },
      "source": [
        "def init_weights(m):\n",
        "    for name, param in m.named_parameters():\n",
        "        nn.init.uniform_(param, -0.02, 0.02)                                                # <YOUR CODE HERE>\n",
        "        \n",
        "model.apply(init_weights)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Seq2Seq(\n",
              "  (encoder): Encoder(\n",
              "    (embedding): Embedding(7855, 256)\n",
              "    (rnn): LSTM(256, 512, num_layers=2, dropout=0.5)\n",
              "    (dropout): Dropout(p=0.5, inplace=False)\n",
              "  )\n",
              "  (decoder): Decoder(\n",
              "    (embedding): Embedding(5893, 256)\n",
              "    (rnn): LSTM(256, 512, num_layers=2, dropout=0.5)\n",
              "    (out): Linear(in_features=512, out_features=5893, bias=True)\n",
              "    (dropout): Dropout(p=0.5, inplace=False)\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vktFX4ENhtz8",
        "colab_type": "text"
      },
      "source": [
        "We also define a function that will calculate the number of trainable parameters in the model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8T0j4iTzht0B",
        "colab_type": "code",
        "outputId": "90bdbb18-1b56-493b-f467-461be9b34958",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 29
        }
      },
      "source": [
        "def count_parameters(model):\n",
        "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
        "\n",
        "print(f'The model has {count_parameters(model):,} trainable parameters')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The model has 13,899,013 trainable parameters\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mbQAZtMLht0K",
        "colab_type": "text"
      },
      "source": [
        "We define our optimizer, which we use to update our parameters in the training loop. Check out [this](http://ruder.io/optimizing-gradient-descent/) post for information about different optimizers. Here, we'll use Adam."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l2xnAJujht0L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "optimizer = optim.Adam(model.parameters())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s_p-qee9ht0S",
        "colab_type": "text"
      },
      "source": [
        "Next, we define our loss function. The `CrossEntropyLoss` function calculates both the log softmax as well as the negative log-likelihood of our predictions. \n",
        "\n",
        "Our loss function calculates the average loss per token, however by passing the index of the `<pad>` token as the `ignore_index` argument we ignore the loss whenever the target token is a padding token. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RWjDHJ_2ht0T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "PAD_IDX = TRG.vocab.stoi['<pad>']\n",
        "\n",
        "criterion = nn.CrossEntropyLoss(ignore_index = PAD_IDX)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kdXBO-9fht0c",
        "colab_type": "text"
      },
      "source": [
        "Next, we'll define our training loop. \n",
        "\n",
        "First, we'll set the model into \"training mode\" with `model.train()`. This will turn on dropout (and batch normalization, which we aren't using) and then iterate through our data iterator.\n",
        "\n",
        "At each iteration:\n",
        "- get the source and target sentences from the batch, $X$ and $Y$\n",
        "- zero the gradients calculated from the last batch\n",
        "- feed the source and target into the model to get the output, $\\hat{Y}$\n",
        "- as the loss function only works on 2d inputs with 1d targets we need to flatten each of them with `.view`\n",
        "    - we also don't want to measure the loss of the `<sos>` token, hence we slice off the first column of the output and target tensors\n",
        "- calculate the gradients with `loss.backward()`\n",
        "- clip the gradients to prevent them from exploding (a common issue in RNNs)\n",
        "- update the parameters of our model by doing an optimizer step\n",
        "- sum the loss value to a running total\n",
        "\n",
        "Finally, we return the loss that is averaged over all batches."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LvVJ-amdht0d",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "PLOT_STEP = 0"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IOFXcpF0ht0m",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def train(model, iterator, optimizer, criterion, clip, train_history=None, valid_history=None, plot_local=True, writer=None):\n",
        "    global PLOT_STEP\n",
        "    model.train()\n",
        "    \n",
        "    epoch_loss = 0\n",
        "    history = []\n",
        "    for i, batch in enumerate(iterator):\n",
        "        \n",
        "        src = batch.src\n",
        "        trg = batch.trg\n",
        "        \n",
        "        optimizer.zero_grad()\n",
        "        \n",
        "        output = model(src, trg)\n",
        "        \n",
        "        #trg = [trg sent len, batch size]\n",
        "        #output = [trg sent len, batch size, output dim]\n",
        "        \n",
        "        output = output[1:].view(-1, output.shape[-1])\n",
        "        trg = trg[1:].view(-1)\n",
        "        \n",
        "        #trg = [(trg sent len - 1) * batch size]\n",
        "        #output = [(trg sent len - 1) * batch size, output dim]\n",
        "        \n",
        "        loss = criterion(output, trg)\n",
        "        \n",
        "        loss.backward()\n",
        "        \n",
        "        # Let's clip the gradient\n",
        "        torch.nn.utils.clip_grad_norm_(model.parameters(), clip)\n",
        "        \n",
        "        optimizer.step()\n",
        "        \n",
        "        epoch_loss += loss.item()\n",
        "        \n",
        "        history.append(loss.cpu().data.numpy())\n",
        "        if (i+1)%10==0:\n",
        "            PLOT_STEP += i\n",
        "            if writer is not None:\n",
        "                writer.add_scalar('train loss', history[-1], PLOT_STEP)\n",
        "            \n",
        "            if plot_local:\n",
        "                fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 8))\n",
        "\n",
        "                clear_output(True)\n",
        "                ax[0].plot(history, label='train loss')\n",
        "                ax[0].set_xlabel('Batch')\n",
        "                ax[0].set_title('Train loss')\n",
        "                if train_history is not None:\n",
        "                    ax[1].plot(train_history, label='general train history')\n",
        "                    ax[1].set_xlabel('Epoch')\n",
        "                if valid_history is not None:\n",
        "                    ax[1].plot(valid_history, label='general valid history')\n",
        "                plt.legend()\n",
        "\n",
        "                plt.show()\n",
        "\n",
        "        \n",
        "    return epoch_loss / len(iterator)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZaF2NqdTht0t",
        "colab_type": "text"
      },
      "source": [
        "Our evaluation loop is similar to our training loop, however as we aren't updating any parameters we don't need to pass an optimizer or a clip value.\n",
        "\n",
        "We must remember to set the model to evaluation mode with `model.eval()`. This will turn off dropout (and batch normalization, if used).\n",
        "\n",
        "We use the `with torch.no_grad()` block to ensure no gradients are calculated within the block. This reduces memory consumption and speeds things up. \n",
        "\n",
        "The iteration loop is similar (without the parameter updates), however we must ensure we turn teacher forcing off for evaluation. This will cause the model to only use it's own predictions to make further predictions within a sentence, which mirrors how it would be used in deployment."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V5CyPGDDht0v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def evaluate(model, iterator, criterion):\n",
        "    \n",
        "    model.eval()\n",
        "    \n",
        "    epoch_loss = 0\n",
        "    \n",
        "    history = []\n",
        "    \n",
        "    with torch.no_grad():\n",
        "    \n",
        "        for i, batch in enumerate(iterator):\n",
        "\n",
        "            src = batch.src\n",
        "            trg = batch.trg\n",
        "\n",
        "            output = model(src, trg, 0) #turn off teacher forcing\n",
        "\n",
        "            #trg = [trg sent len, batch size]\n",
        "            #output = [trg sent len, batch size, output dim]\n",
        "\n",
        "            output = output[1:].view(-1, output.shape[-1])\n",
        "            trg = trg[1:].view(-1)\n",
        "\n",
        "            #trg = [(trg sent len - 1) * batch size]\n",
        "            #output = [(trg sent len - 1) * batch size, output dim]\n",
        "\n",
        "            loss = criterion(output, trg)\n",
        "            \n",
        "            epoch_loss += loss.item()\n",
        "        \n",
        "    return epoch_loss / len(iterator)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vrd8pnBOht00",
        "colab_type": "text"
      },
      "source": [
        "Next, we'll create a function that we'll use to tell us how long an epoch takes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U6Rrhiiaht00",
        "colab_type": "code",
        "colab": {}
      },
      "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"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1UiSwUzXht06",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib\n",
        "matplotlib.rcParams.update({'figure.figsize': (16, 12), 'font.size': 14})\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "from IPython.display import clear_output\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mopy_ooBht0_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "example_input = next(iter(train_iterator))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZPacfzAoht1J",
        "colab_type": "code",
        "outputId": "4ae8f462-e7b8-42e7-aadc-d6c902d2d912",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 29
        }
      },
      "source": [
        "example_input.src.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([33, 128])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LGX62rFSht1S",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from torch.utils.tensorboard import SummaryWriter\n",
        "\n",
        "# default `log_dir` is \"runs\" - we can be more specific here\n",
        "writer = SummaryWriter()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rvzx56XXht1X",
        "colab_type": "code",
        "outputId": "5ac5fc53-b4e3-464a-ecf3-c40bdbbcd7bc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 49
        }
      },
      "source": [
        "writer.add_graph(model, (example_input.src[:1], example_input.trg[:1]))\n",
        "writer.close()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:33: TracerWarning: Converting a tensor to a Python index might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iTaDzS3Nht1d",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bejbwkX9ht1i",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def translate_sentence(sentence, src_field, trg_field, model, device, max_len = 50):\n",
        "\n",
        "    model.eval()\n",
        "        \n",
        "    if isinstance(sentence, str):\n",
        "        nlp = spacy.load('de')\n",
        "        tokens = [token.text.lower() for token in nlp(sentence)]\n",
        "    else:\n",
        "        tokens = [token.lower() for token in sentence]\n",
        "\n",
        "    tokens = [src_field.init_token] + tokens + [src_field.eos_token]\n",
        "        \n",
        "    src_indexes = [src_field.vocab.stoi[token] for token in tokens]\n",
        "    \n",
        "    src_tensor = torch.LongTensor(src_indexes).unsqueeze(1).to(device)\n",
        "\n",
        "    src_len = torch.LongTensor([len(src_indexes)]).to(device)\n",
        "    \n",
        "    with torch.no_grad():\n",
        "        hidden, cell = model.encoder(src_tensor)\n",
        "        \n",
        "    trg_indexes = [trg_field.vocab.stoi[trg_field.init_token]]\n",
        "\n",
        "    for t in range(1, max_len):\n",
        "        trg_tensor = torch.LongTensor([trg_indexes[-1]]).to(device)\n",
        "\n",
        "        #insert input token embedding, previous hidden state and all encoder hidden states\n",
        "        #receive output tensor (predictions) and new hidden state\n",
        "        output, hidden, cell = model.decoder(trg_tensor, hidden, cell)\n",
        "\n",
        "        pred_token = output.argmax(1).item()\n",
        "        \n",
        "        trg_indexes.append(pred_token)\n",
        "\n",
        "        if pred_token == trg_field.vocab.stoi[trg_field.eos_token]:\n",
        "            break\n",
        "    \n",
        "    trg_tokens = [trg_field.vocab.itos[i] for i in trg_indexes]\n",
        "    \n",
        "    return trg_tokens[1:]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-luBXP1hht1l",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def get_example_translation():\n",
        "    example_idx = np.random.choice(np.arange(len(test_data)))\n",
        "\n",
        "    src = vars(train_data.examples[example_idx])['src']\n",
        "    trg = vars(train_data.examples[example_idx])['trg']\n",
        "    \n",
        "    src_string = f'src = {\" \".join(src)}'\n",
        "    trg_string = f'trg = {\" \".join(trg)}'\n",
        "\n",
        "    translation = translate_sentence(src, SRC, TRG, model, device)\n",
        "    \n",
        "    translation_string = f'predicted trg = {\" \".join(translation)}'\n",
        "\n",
        "#     print(src_string)\n",
        "#     print()\n",
        "#     print(trg_string)\n",
        "#     print()\n",
        "#     print(translation_string)\n",
        "    \n",
        "    return ('\\n\\n'.join([src_string, trg_string, translation_string]))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xYU4VUgQht1q",
        "colab_type": "text"
      },
      "source": [
        "Let's call the `tensorboard` here (if you are working on Colab). If you work locally better run it as another process in your terminal using the command\n",
        "```\n",
        "tensorboard --logdir .runs/ --reload_interval=5\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oSCA8GEAht1r",
        "colab_type": "code",
        "outputId": "33b3b595-9dfd-46d4-ef57-0bd708182bab",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 820
        }
      },
      "source": [
        "# On Colab just uncomment and run this cell\n",
        "\n",
        "%load_ext tensorboard\n",
        "%tensorboard --logdir runs"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "        (async () => {\n",
              "            const url = await google.colab.kernel.proxyPort(6006, {\"cache\": true});\n",
              "            const iframe = document.createElement('iframe');\n",
              "            iframe.src = url;\n",
              "            iframe.setAttribute('width', '100%');\n",
              "            iframe.setAttribute('height', '800');\n",
              "            iframe.setAttribute('frameborder', 0);\n",
              "            document.body.appendChild(iframe);\n",
              "        })();\n",
              "    "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8ARsYitnht1w",
        "colab_type": "text"
      },
      "source": [
        "We can finally start training our model!\n",
        "\n",
        "At each epoch, we'll be checking if our model has achieved the best validation loss so far. If it has, we'll update our best validation loss and save the parameters of our model (called `state_dict` in PyTorch). Then, when we come to test our model, we'll use the saved parameters used to achieve the best validation loss. \n",
        "\n",
        "We'll be printing out both the loss and the perplexity at each epoch. It is easier to see a change in perplexity than a change in loss as the numbers are much bigger."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pg9-16YZht1x",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train_history = []\n",
        "valid_history = []\n",
        "\n",
        "N_EPOCHS = 15\n",
        "CLIP = 1\n",
        "\n",
        "best_valid_loss = float('inf')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0O415br8ht12",
        "colab_type": "code",
        "outputId": "5fc1b27c-c1c1-4e0f-b0a5-ce8fce9ba950",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 513
        }
      },
      "source": [
        "for epoch in range(N_EPOCHS):\n",
        "    \n",
        "    start_time = time.time()\n",
        "    \n",
        "    train_loss = train(model, train_iterator, optimizer, criterion, CLIP, train_history, valid_history, writer=writer)\n",
        "    valid_loss = evaluate(model, valid_iterator, criterion)\n",
        "    \n",
        "    end_time = time.time()\n",
        "    \n",
        "    epoch_mins, epoch_secs = epoch_time(start_time, end_time)\n",
        "    \n",
        "    if valid_loss < best_valid_loss:\n",
        "        best_valid_loss = valid_loss\n",
        "        torch.save(model.state_dict(), 'tut1-model.pt')\n",
        "    \n",
        "    train_history.append(train_loss)\n",
        "    valid_history.append(valid_loss)\n",
        "    writer.add_scalar('mean train loss per epoch', train_loss, global_step=epoch)\n",
        "    writer.add_scalar('mean val loss per epoch', valid_loss, global_step=epoch)\n",
        "\n",
        "    val_example_data = next(iter(valid_iterator))\n",
        "    to_print = []\n",
        "    \n",
        "    \n",
        "    writer.add_text('translation example', get_example_translation(), global_step=epoch)\n",
        "    writer.close()\n",
        "\n",
        "#     print(f'Epoch: {epoch+1:02} | Time: {epoch_mins}m {epoch_secs}s')\n",
        "#     print(f'\\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}')\n",
        "#     print(f'\\t Val. Loss: {valid_loss:.3f} |  Val. PPL: {math.exp(valid_loss):7.3f}')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gFse4OjVht19",
        "colab_type": "code",
        "outputId": "b0d73b2a-d6d7-43ea-e2b4-52a41ec2c956",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 75
        }
      },
      "source": [
        "print(get_example_translation())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "src = . arbeiten zugwaggons eines nähe der in die , warnwesten mit arbeiter\n",
            "\n",
            "trg = workers wearing reflective vests working near a train car .\n",
            "\n",
            "predicted trg = the men in in uniforms are on a a . <eos>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2_CjC-5zht2E",
        "colab_type": "text"
      },
      "source": [
        "We'll load the parameters (`state_dict`) that gave our model the best validation loss and run it the model on the test set."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5_rQzpGJht2G",
        "colab_type": "code",
        "outputId": "3c691d49-64af-4e5b-f880-8d000f76db9e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 29
        }
      },
      "source": [
        "model.load_state_dict(torch.load('tut1-model.pt'))\n",
        "\n",
        "test_loss = evaluate(model, test_iterator, criterion)\n",
        "\n",
        "print(f'| Test Loss: {test_loss:.3f} | Test PPL: {math.exp(test_loss):7.3f} |')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "| Test Loss: 3.951 | Test PPL:  52.003 |\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}