Aug20/Discussion5/Transformer.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Transformer.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZLiP3-gIZlX1",
        "colab_type": "text"
      },
      "source": [
        "#Importing Libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RvJwdS5rZ_IH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 869
        },
        "outputId": "babdc841-26d7-427e-fcfe-bc9ca05a32ae"
      },
      "source": [
        "!pip install http://download.pytorch.org/whl/cu80/torch-0.3.0.post4-cp36-cp36m-linux_x86_64.whl numpy matplotlib spacy torchtext==0.2.3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting torch==0.3.0.post4\n",
            "\u001b[?25l  Downloading http://download.pytorch.org/whl/cu80/torch-0.3.0.post4-cp36-cp36m-linux_x86_64.whl (592.3MB)\n",
            "\u001b[K     |████████████████████████████████| 592.3MB 1.2MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (1.18.5)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.6/dist-packages (3.2.2)\n",
            "Requirement already satisfied: spacy in /usr/local/lib/python3.6/dist-packages (2.2.4)\n",
            "Collecting torchtext==0.2.3\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/78/90/474d5944d43001a6e72b9aaed5c3e4f77516fbef2317002da2096fd8b5ea/torchtext-0.2.3.tar.gz (42kB)\n",
            "\u001b[K     |████████████████████████████████| 51kB 3.3MB/s \n",
            "\u001b[?25hRequirement already satisfied: pyyaml in /usr/local/lib/python3.6/dist-packages (from torch==0.3.0.post4) (3.13)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.6/dist-packages (from matplotlib) (0.10.0)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib) (2.4.7)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib) (2.8.1)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib) (1.2.0)\n",
            "Requirement already satisfied: plac<1.2.0,>=0.9.6 in /usr/local/lib/python3.6/dist-packages (from spacy) (1.1.3)\n",
            "Requirement already satisfied: srsly<1.1.0,>=1.0.2 in /usr/local/lib/python3.6/dist-packages (from spacy) (1.0.2)\n",
            "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /usr/local/lib/python3.6/dist-packages (from spacy) (2.0.3)\n",
            "Requirement already satisfied: wasabi<1.1.0,>=0.4.0 in /usr/local/lib/python3.6/dist-packages (from spacy) (0.7.1)\n",
            "Requirement already satisfied: catalogue<1.1.0,>=0.0.7 in /usr/local/lib/python3.6/dist-packages (from spacy) (1.0.0)\n",
            "Requirement already satisfied: tqdm<5.0.0,>=4.38.0 in /usr/local/lib/python3.6/dist-packages (from spacy) (4.41.1)\n",
            "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from spacy) (3.0.2)\n",
            "Requirement already satisfied: blis<0.5.0,>=0.4.0 in /usr/local/lib/python3.6/dist-packages (from spacy) (0.4.1)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.6/dist-packages (from spacy) (49.2.0)\n",
            "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /usr/local/lib/python3.6/dist-packages (from spacy) (1.0.2)\n",
            "Requirement already satisfied: requests<3.0.0,>=2.13.0 in /usr/local/lib/python3.6/dist-packages (from spacy) (2.23.0)\n",
            "Requirement already satisfied: thinc==7.4.0 in /usr/local/lib/python3.6/dist-packages (from spacy) (7.4.0)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from cycler>=0.10->matplotlib) (1.15.0)\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) (1.7.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) (2020.6.20)\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) (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) (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.10)\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) (3.1.0)\n",
            "Building wheels for collected packages: torchtext\n",
            "  Building wheel for torchtext (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for torchtext: filename=torchtext-0.2.3-cp36-none-any.whl size=40134 sha256=409a3c3279ce5024fa820708aa2f21c204a18954f722c03fa9bead214360cb4a\n",
            "  Stored in directory: /root/.cache/pip/wheels/42/a6/f4/b267328bde6bb680094a0c173e8e5627ccc99543abded97204\n",
            "Successfully built torchtext\n",
            "\u001b[31mERROR: torchvision 0.7.0+cu101 has requirement torch==1.6.0, but you'll have torch 0.3.0.post4 which is incompatible.\u001b[0m\n",
            "\u001b[31mERROR: fastai 1.0.61 has requirement torch>=1.0.0, but you'll have torch 0.3.0.post4 which is incompatible.\u001b[0m\n",
            "Installing collected packages: torch, torchtext\n",
            "  Found existing installation: torch 1.6.0+cu101\n",
            "    Uninstalling torch-1.6.0+cu101:\n",
            "      Successfully uninstalled torch-1.6.0+cu101\n",
            "  Found existing installation: torchtext 0.3.1\n",
            "    Uninstalling torchtext-0.3.1:\n",
            "      Successfully uninstalled torchtext-0.3.1\n",
            "Successfully installed torch-0.3.0.post4 torchtext-0.2.3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V_1LNRhpJL6p",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "outputId": "b3886480-5950-47c5-cda3-b8abf5de83d0"
      },
      "source": [
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import math, copy, time\n",
        "from torch.autograd import Variable\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn\n",
        "seaborn.set_context(context=\"talk\")\n",
        "%matplotlib inline"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
            "  import pandas.util.testing as tm\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P5QCJT-aaHi2",
        "colab_type": "text"
      },
      "source": [
        "# Model Architecture"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Rb7JMgcZ0q-",
        "colab_type": "text"
      },
      "source": [
        "Most competitive neural sequence transduction models have an encoder-decoder structure. Here, the encoder maps an input sequence of symbol representations $(x_1, ..., x_n)$ to a sequence of continuous representations $\\mathbf{z} = (z_1, ..., z_n)$. Given $\\mathbf{z}$, the decoder then generates an output sequence $(y_1,...,y_m)$ of symbols one element at a time. At each step the model is auto-regressive, consuming the previously generated symbols as additional input when generating the next. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oV8YdYbJaGMp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class EncoderDecoder(nn.Module):\n",
        "    \"\"\"\n",
        "    A standard Encoder-Decoder architecture. Base for this and many \n",
        "    other models.\n",
        "    \"\"\"\n",
        "    def __init__(self, encoder, decoder, src_embed, tgt_embed, generator):\n",
        "        super(EncoderDecoder, self).__init__()\n",
        "        self.encoder = encoder\n",
        "        self.decoder = decoder\n",
        "        self.src_embed = src_embed\n",
        "        self.tgt_embed = tgt_embed\n",
        "        self.generator = generator\n",
        "        \n",
        "    def forward(self, src, tgt, src_mask, tgt_mask):\n",
        "        \"Take in and process masked src and target sequences.\"\n",
        "        return self.decode(self.encode(src, src_mask), src_mask,\n",
        "                            tgt, tgt_mask)\n",
        "    \n",
        "    def encode(self, src, src_mask):\n",
        "        return self.encoder(self.src_embed(src), src_mask)\n",
        "    \n",
        "    def decode(self, memory, src_mask, tgt, tgt_mask):\n",
        "        return self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fz2UhqPZadBi",
        "colab_type": "text"
      },
      "source": [
        "The Transformer follows this overall architecture using stacked self-attention and point-wise, fully connected layers for both the encoder and decoder, shown in the left and right halves of Figure 1, respectively."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fdURhq5car5P",
        "colab_type": "text"
      },
      "source": [
        "<img src=\"https://github.com/harvardnlp/annotated-transformer/blob/master/images/ModalNet-21.png?raw=true\" width=400px>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HmgF4KSWa3dT",
        "colab_type": "text"
      },
      "source": [
        "## Encoder and Decoder Stacks   "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aUtPzbEzbJdY",
        "colab_type": "text"
      },
      "source": [
        "### Encoder: "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nHIzAY6gbQz6",
        "colab_type": "text"
      },
      "source": [
        "The encoder is composed of a stack of $N=6$ identical layers."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GkBXeisEbKIl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def clones(module, N):\n",
        "    \"Produce N identical layers.\"\n",
        "    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lSQaGa-qbViQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Encoder(nn.Module):\n",
        "    \"Core encoder is a stack of N layers\"\n",
        "    def __init__(self, layer, N):\n",
        "        super(Encoder, self).__init__()\n",
        "        self.layers = clones(layer, N)\n",
        "        self.norm = LayerNorm(layer.size)\n",
        "        \n",
        "    def forward(self, x, mask):\n",
        "        \"Pass the input (and mask) through each layer in turn.\"\n",
        "        for layer in self.layers:\n",
        "            x = layer(x, mask)\n",
        "        return self.norm(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5hTjsFMLbb6X",
        "colab_type": "text"
      },
      "source": [
        "We employ a residual connection around each of the two sub-layers, followed by layer normalization."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UBqPqfXdbY2O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class LayerNorm(nn.Module):\n",
        "    \"Construct a layernorm module (See citation for details).\"\n",
        "    def __init__(self, features, eps=1e-6):\n",
        "        super(LayerNorm, self).__init__()\n",
        "        self.a_2 = nn.Parameter(torch.ones(features))\n",
        "        self.b_2 = nn.Parameter(torch.zeros(features))\n",
        "        self.eps = eps\n",
        "\n",
        "    def forward(self, x):\n",
        "        mean = x.mean(-1, keepdim=True)\n",
        "        std = x.std(-1, keepdim=True)\n",
        "        return self.a_2 * (x - mean) / (std + self.eps) + self.b_2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VTRe-AgKbyhj",
        "colab_type": "text"
      },
      "source": [
        "That is, the output of each sub-layer is $\\mathrm{LayerNorm}(x + \\mathrm{Sublayer}(x))$, where $\\mathrm{Sublayer}(x)$ is the function implemented by the sub-layer itself.  We apply dropout to the output of each sub-layer, before it is added to the sub-layer input and normalized.  \n",
        "\n",
        "To facilitate these residual connections, all sub-layers in the model, as well as the embedding layers, produce outputs of dimension $d_{\\text{model}}=512$."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yv_csj-Yb1FQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class SublayerConnection(nn.Module):\n",
        "    \"\"\"\n",
        "    A residual connection followed by a layer norm.\n",
        "    Note for code simplicity the norm is first as opposed to last.\n",
        "    \"\"\"\n",
        "    def __init__(self, size, dropout):\n",
        "        super(SublayerConnection, self).__init__()\n",
        "        self.norm = LayerNorm(size)\n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "\n",
        "    def forward(self, x, sublayer):\n",
        "        \"Apply residual connection to any sublayer with the same size.\"\n",
        "        return x + self.dropout(sublayer(self.norm(x)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TTOcJWB_b5Gs",
        "colab_type": "text"
      },
      "source": [
        "Each layer has two sub-layers. The first is a multi-head self-attention mechanism, and the second is a simple, position-wise fully connected feed- forward network."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6vxJfNJlb7XL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class EncoderLayer(nn.Module):\n",
        "    \"Encoder is made up of self-attn and feed forward (defined below)\"\n",
        "    def __init__(self, size, self_attn, feed_forward, dropout):\n",
        "        super(EncoderLayer, self).__init__()\n",
        "        self.self_attn = self_attn\n",
        "        self.feed_forward = feed_forward\n",
        "        self.sublayer = clones(SublayerConnection(size, dropout), 2)\n",
        "        self.size = size\n",
        "\n",
        "    def forward(self, x, mask):\n",
        "        \"Follow Figure 1 (left) for connections.\"\n",
        "        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))\n",
        "        return self.sublayer[1](x, self.feed_forward)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qRO-lx6dcCSn",
        "colab_type": "text"
      },
      "source": [
        "### Decoder: "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LUKB7ZTGcLEy",
        "colab_type": "text"
      },
      "source": [
        "The decoder is composed of a stack of $N=6$ identical layers."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kJV9hGmNcEz2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Decoder(nn.Module):\n",
        "    \"Generic N layer decoder with masking.\"\n",
        "    def __init__(self, layer, N):\n",
        "        super(Decoder, self).__init__()\n",
        "        self.layers = clones(layer, N)\n",
        "        self.norm = LayerNorm(layer.size)\n",
        "        \n",
        "    def forward(self, x, memory, src_mask, tgt_mask):\n",
        "        for layer in self.layers:\n",
        "            x = layer(x, memory, src_mask, tgt_mask)\n",
        "        return self.norm(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lAGW9SzKipzP",
        "colab_type": "text"
      },
      "source": [
        "In addition to the two sub-layers in each encoder layer, the decoder inserts a third sub-layer, which performs multi-head attention over the output of the encoder stack. Similar to the encoder, we employ residual connections around each of the sub-layers, followed by layer normalization."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WzG5Do0zcSYm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class DecoderLayer(nn.Module):\n",
        "    \"Decoder is made of self-attn, src-attn, and feed forward (defined below)\"\n",
        "    def __init__(self, size, self_attn, src_attn, feed_forward, dropout):\n",
        "        super(DecoderLayer, self).__init__()\n",
        "        self.size = size\n",
        "        self.self_attn = self_attn\n",
        "        self.src_attn = src_attn\n",
        "        self.feed_forward = feed_forward\n",
        "        self.sublayer = clones(SublayerConnection(size, dropout), 3)\n",
        " \n",
        "    def forward(self, x, memory, src_mask, tgt_mask):\n",
        "        \"Follow Figure 1 (right) for connections.\"\n",
        "        m = memory\n",
        "        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, tgt_mask))\n",
        "        x = self.sublayer[1](x, lambda x: self.src_attn(x, m, m, src_mask))\n",
        "        return self.sublayer[2](x, self.feed_forward)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vvg_i0EdiwVg",
        "colab_type": "text"
      },
      "source": [
        "We also modify the self-attention sub-layer in the decoder stack to prevent positions from attending to subsequent positions.  This masking, combined with fact that the output embeddings are offset by one position, ensures that the predictions for position $i$ can depend only on the known outputs at positions less than $i$."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fF1ysgX1i7Ux",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def subsequent_mask(size):\n",
        "    \"Mask out subsequent positions.\"\n",
        "    attn_shape = (1, size, size)\n",
        "    subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')\n",
        "    return torch.from_numpy(subsequent_mask) == 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O-ER7fsMjGKx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 351
        },
        "outputId": "087cc0e1-62b3-4188-ae67-ac4ee9dc6a51"
      },
      "source": [
        "# The attention mask shows the position each tgt word (row) is allowed to look at (column).\n",
        "# Words are blocked for attending to future words during training. \n",
        "plt.figure(figsize=(5,5))\n",
        "plt.imshow(subsequent_mask(20)[0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f55b6d50630>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eocsIgBZjQUk",
        "colab_type": "text"
      },
      "source": [
        "## Scaled-Dot Product Attention:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GBbrRqVQjX04",
        "colab_type": "text"
      },
      "source": [
        "An attention function can be described as mapping a query and a set of key-value pairs to an output, where the query, keys, values, and output are all vectors.  The output is computed as a weighted sum of the values, where the weight assigned to each value is computed by a compatibility function of the query with the corresponding key.                                                                                                                                                                                                                                            \n",
        "\n",
        "We call our particular attention \"Scaled Dot-Product Attention\".   The input consists of queries and keys of dimension $d_k$, and values of dimension $d_v$.  We compute the dot products of the query with all keys, divide each by $\\sqrt{d_k}$, and apply a softmax function to obtain the weights on the values."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UirnI1_5jj2V",
        "colab_type": "text"
      },
      "source": [
        "<img width=\"220px\" src=\"https://github.com/harvardnlp/annotated-transformer/blob/master/images/ModalNet-19.png?raw=true\">"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mxAvtnd7jnD8",
        "colab_type": "text"
      },
      "source": [
        "In practice, we compute the attention function on a set of queries simultaneously, packed together into a matrix $Q$.   The keys and values are also packed together into matrices $K$ and $V$.  We compute the matrix of outputs as:                      \n",
        "                                                                 \n",
        "$$                                                                         \n",
        "   \\mathrm{Attention}(Q, K, V) = \\mathrm{softmax}(\\frac{QK^T}{\\sqrt{d_k}})V               \n",
        "$$ "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZVWxBcfnjSCg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def attention(query, key, value, mask=None, dropout=None):\n",
        "    \"Compute 'Scaled Dot Product Attention'\"\n",
        "    d_k = query.size(-1)\n",
        "    scores = torch.matmul(query, key.transpose(-2, -1)) \\\n",
        "             / math.sqrt(d_k)\n",
        "    if mask is not None:\n",
        "        scores = scores.masked_fill(mask == 0, -1e9)\n",
        "    p_attn = F.softmax(scores, dim = -1)\n",
        "    if dropout is not None:\n",
        "        p_attn = dropout(p_attn)\n",
        "    return torch.matmul(p_attn, value), p_attn"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jKZnHualj4l6",
        "colab_type": "text"
      },
      "source": [
        "The two most commonly used attention functions are additive attention, and dot-product (multiplicative) attention.  Dot-product attention is identical to our algorithm, except for the scaling factor of $\\frac{1}{\\sqrt{d_k}}$. Additive attention computes the compatibility function using a feed-forward network with a single hidden layer.  While the two are similar in theoretical complexity, dot-product attention is much faster and more space-efficient in practice, since it can be implemented using highly optimized matrix multiplication code.                                                                                             \n",
        "\n",
        "                                                                        \n",
        "While for small values of $d_k$ the two mechanisms perform similarly, additive attention outperforms dot product attention without scaling for larger values of $d_k$. We suspect that for large values of $d_k$, the dot products grow large in magnitude, pushing the softmax function into regions where it has extremely small gradients  (To illustrate why the dot products get large, assume that the components of $q$ and $k$ are independent random variables with mean $0$ and variance $1$.  Then their dot product, $q \\cdot k = \\sum_{i=1}^{d_k} q_ik_i$, has mean $0$ and variance $d_k$.). To counteract this effect, we scale the dot products by $\\frac{1}{\\sqrt{d_k}}$.          "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8wLEskZCkgkT",
        "colab_type": "text"
      },
      "source": [
        "## Multi-Headed Attention:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FjcD78m0kqaN",
        "colab_type": "text"
      },
      "source": [
        "Instead of performing a single attention function with $d_{\\text{model}}$-dimensional keys, values and queries, we found it beneficial to linearly project the queries, keys and values $h$ times with different, learned linear projections to $d_k$, $d_k$ and $d_v$ dimensions, respectively.                                                                                                                                                                                                   \n",
        "On each of these projected versions of queries, keys and values we then perform the attention function in parallel, yielding $d_v$-dimensional output values. These are concatenated and once again projected, resulting in the final values:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RHMKkesqktzy",
        "colab_type": "text"
      },
      "source": [
        "<img width=\"270px\" src=\"https://github.com/harvardnlp/annotated-transformer/blob/master/images/ModalNet-20.png?raw=true\">"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5a820Vqdkyct",
        "colab_type": "text"
      },
      "source": [
        "Multi-head attention allows the model to jointly attend to information from different representation subspaces at different positions. With a single attention head, averaging inhibits this.                                                                                                                                                                                                                                                                                             \n",
        "    \n",
        "    \n",
        "   \n",
        "$$    \n",
        "\\mathrm{MultiHead}(Q, K, V) = \\mathrm{Concat}(\\mathrm{head_1}, ..., \\mathrm{head_h})W^O    \\\\                                           \n",
        "    \\text{where}~\\mathrm{head_i} = \\mathrm{Attention}(QW^Q_i, KW^K_i, VW^V_i)                                \n",
        "$$                                                                                                                                                                                                                                                                                                                                                                         \n",
        "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \n",
        "Where the projections are parameter matrices $W^Q_i \\in \\mathbb{R}^{d_{\\text{model}} \\times d_k}$, $W^K_i \\in \\mathbb{R}^{d_{\\text{model}} \\times d_k}$, $W^V_i \\in \\mathbb{R}^{d_{\\text{model}} \\times d_v}$ and $W^O \\in \\mathbb{R}^{hd_v \\times d_{\\text{model}}}$.                                                                                                                                                                                                                                                        \n",
        "   \n",
        "\n",
        "   \n",
        "In this work we employ $h=8$ parallel attention layers, or heads. For each of these we use $d_k=d_v=d_{\\text{model}}/h=64$. Due to the reduced dimension of each head, the total computational cost is similar to that of single-head attention with full dimensionality.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ArTZrvAxkAo_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class MultiHeadedAttention(nn.Module):\n",
        "    def __init__(self, h, d_model, dropout=0.1):\n",
        "        \"Take in model size and number of heads.\"\n",
        "        super(MultiHeadedAttention, self).__init__()\n",
        "        assert d_model % h == 0\n",
        "        # We assume d_v always equals d_k\n",
        "        self.d_k = d_model // h\n",
        "        self.h = h\n",
        "        self.linears = clones(nn.Linear(d_model, d_model), 4)\n",
        "        self.attn = None\n",
        "        self.dropout = nn.Dropout(p=dropout)\n",
        "        \n",
        "    def forward(self, query, key, value, mask=None):\n",
        "        \"Implements Figure 2\"\n",
        "        if mask is not None:\n",
        "            # Same mask applied to all h heads.\n",
        "            mask = mask.unsqueeze(1)\n",
        "        nbatches = query.size(0)\n",
        "        \n",
        "        # 1) Do all the linear projections in batch from d_model => h x d_k \n",
        "        query, key, value = \\\n",
        "            [l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)\n",
        "             for l, x in zip(self.linears, (query, key, value))]\n",
        "        \n",
        "        # 2) Apply attention on all the projected vectors in batch. \n",
        "        x, self.attn = attention(query, key, value, mask=mask, \n",
        "                                 dropout=self.dropout)\n",
        "        \n",
        "        # 3) \"Concat\" using a view and apply a final linear. \n",
        "        x = x.transpose(1, 2).contiguous() \\\n",
        "             .view(nbatches, -1, self.h * self.d_k)\n",
        "        return self.linears[-1](x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9BB6SGOplAYt",
        "colab_type": "text"
      },
      "source": [
        "## Position-wise Feed-Forward Networks "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1buim0oyl6vf",
        "colab_type": "text"
      },
      "source": [
        "In addition to attention sub-layers, each of the layers in our encoder and decoder contains a fully connected feed-forward network, which is applied to each position separately and identically.  This consists of two linear transformations with a ReLU activation in between.\n",
        "\n",
        "$$\\mathrm{FFN}(x)=\\max(0, xW_1 + b_1) W_2 + b_2$$                                                                                                                                                                                                                                                         \n",
        "                                                                                                                                                                                                                                                        \n",
        "While the linear transformations are the same across different positions, they use different parameters from layer to layer. Another way of describing this is as two convolutions with kernel size 1.  The dimensionality of input and output is $d_{\\text{model}}=512$, and the inner-layer has dimensionality $d_{ff}=2048$. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M7rLUhaUlCcu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class PositionwiseFeedForward(nn.Module):\n",
        "    \"Implements FFN equation.\"\n",
        "    def __init__(self, d_model, d_ff, dropout=0.1):\n",
        "        super(PositionwiseFeedForward, self).__init__()\n",
        "        self.w_1 = nn.Linear(d_model, d_ff)\n",
        "        self.w_2 = nn.Linear(d_ff, d_model)\n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.w_2(self.dropout(F.relu(self.w_1(x))))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rkHbbeH2mBi3",
        "colab_type": "text"
      },
      "source": [
        "## Embeddings"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RLvTmEH1mEQE",
        "colab_type": "text"
      },
      "source": [
        "Similarly to other sequence transduction models, we use learned embeddings to convert the input tokens and output tokens to vectors of dimension $d_{\\text{model}}$.  We also use the usual learned linear transformation and softmax function to convert the decoder output to predicted next-token probabilities.  In our model, we share the same weight matrix between the two embedding layers and the pre-softmax linear transformation. In the embedding layers, we multiply those weights by $\\sqrt{d_{\\text{model}}}$.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kCTiQTVdmCUY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Embeddings(nn.Module):\n",
        "    def __init__(self, d_model, vocab):\n",
        "        super(Embeddings, self).__init__()\n",
        "        self.lut = nn.Embedding(vocab, d_model)\n",
        "        self.d_model = d_model\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.lut(x) * math.sqrt(self.d_model)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z5Lqdy6ombRY",
        "colab_type": "text"
      },
      "source": [
        "## Positional Encoding"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zWP0GYssmhFJ",
        "colab_type": "text"
      },
      "source": [
        "Since our model contains no recurrence and no convolution, in order for the model to make use of the order of the sequence, we must inject some information about the relative or absolute position of the tokens in the sequence.  To this end, we add \"positional encodings\" to the input embeddings at the bottoms of the encoder and decoder stacks.  The positional encodings have the same dimension $d_{\\text{model}}$ as the embeddings, so that the two can be summed.   There are many choices of positional encodings, learned and fixed. \n",
        "\n",
        "In this work, we use sine and cosine functions of different frequencies:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \n",
        "$$                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \n",
        "    PE_{(pos,2i)} = sin(pos / 10000^{2i/d_{\\text{model}}}) \\\\                                                                                                                                                                                                                                                                                                                                                                                                                                      \n",
        "    PE_{(pos,2i+1)} = cos(pos / 10000^{2i/d_{\\text{model}}})                                                                                                                                                                                                                                                                                                                                                                                                                                       \n",
        "$$                                                                                                                                                                                                                                                        \n",
        "where $pos$ is the position and $i$ is the dimension.  That is, each dimension of the positional encoding corresponds to a sinusoid.  The wavelengths form a geometric progression from $2\\pi$ to $10000 \\cdot 2\\pi$.  We chose this function because we hypothesized it would allow the model to easily learn to attend by relative positions, since for any fixed offset $k$, $PE_{pos+k}$ can be represented as a linear function of $PE_{pos}$. \n",
        "\n",
        "In addition, we apply dropout to the sums of the embeddings and the positional encodings in both the encoder and decoder stacks.  For the base model, we use a rate of $P_{drop}=0.1$."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LQXpcmwcmbxv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class PositionalEncoding(nn.Module):\n",
        "    \"Implement the PE function.\"\n",
        "    def __init__(self, d_model, dropout, max_len=5000):\n",
        "        super(PositionalEncoding, self).__init__()\n",
        "        self.dropout = nn.Dropout(p=dropout)\n",
        "        \n",
        "        # Compute the positional encodings once in log space.\n",
        "        pe = torch.zeros(max_len, d_model)\n",
        "        position = torch.arange(0, max_len).unsqueeze(1)\n",
        "        div_term = torch.exp(torch.arange(0, d_model, 2) *\n",
        "                             -(math.log(10000.0) / d_model))\n",
        "        pe[:, 0::2] = torch.sin(position * div_term)\n",
        "        pe[:, 1::2] = torch.cos(position * div_term)\n",
        "        pe = pe.unsqueeze(0)\n",
        "        self.register_buffer('pe', pe)\n",
        "        \n",
        "    def forward(self, x):\n",
        "        x = x + Variable(self.pe[:, :x.size(1)], requires_grad=False)\n",
        "        return self.dropout(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UEe0y0wsmrbs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 333
        },
        "outputId": "30d5d0da-6856-425d-eead-0752222d4a5a"
      },
      "source": [
        "# The positional encoding will add in a sine wave based on position.\n",
        "# The frequency and offset of the wave is different for each dimension.\n",
        "plt.figure(figsize=(15, 5))\n",
        "pe = PositionalEncoding(20, 0)\n",
        "y = pe.forward(Variable(torch.zeros(1, 100, 20)))\n",
        "plt.plot(np.arange(100), y[0, :, 4:8].data.numpy())\n",
        "plt.legend([\"dim %d\"%p for p in [4,5,6,7]])\n",
        "None"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OiOH3sptolyB",
        "colab_type": "text"
      },
      "source": [
        "## Final Linear and Softmax Layer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kh0oJJ2uojQf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Generator(nn.Module):\n",
        "    \"Define standard linear + softmax generation step.\"\n",
        "    def __init__(self, d_model, vocab):\n",
        "        super(Generator, self).__init__()\n",
        "        self.proj = nn.Linear(d_model, vocab)\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": "x_9cn5ezpRpJ",
        "colab_type": "text"
      },
      "source": [
        "## Full Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7IkeQMOPpSDY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def make_model(src_vocab, tgt_vocab, N=6, d_model=512, d_ff=2048, h=8, dropout=0.1):\n",
        "    \"Construct a model object based on hyperparameters.\"\n",
        "    c = copy.deepcopy\n",
        "    attn = MultiHeadedAttention(h, d_model, dropout)\n",
        "    ff = PositionwiseFeedForward(d_model, d_ff, dropout)\n",
        "    position = PositionalEncoding(d_model, dropout)\n",
        "    model = EncoderDecoder(\n",
        "        Encoder(EncoderLayer(d_model, c(attn), c(ff), dropout), N),\n",
        "        Decoder(DecoderLayer(d_model, c(attn), c(attn), c(ff), dropout), N),\n",
        "        nn.Sequential(Embeddings(d_model, src_vocab), c(position)),\n",
        "        nn.Sequential(Embeddings(d_model, tgt_vocab), c(position)),\n",
        "        Generator(d_model, tgt_vocab))\n",
        "    \n",
        "    # This was important from their code. Initialize parameters with Glorot or fan_avg.\n",
        "    for p in model.parameters():\n",
        "        if p.dim() > 1:\n",
        "            nn.init.xavier_uniform(p)\n",
        "    return model"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kvOtUAuopcPu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "a0b2b4ce-5876-4d1c-e592-859dd3abb1d6"
      },
      "source": [
        "# Small example model.\n",
        "tmp_model = make_model(10, 10, 2)\n",
        "tmp_model"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "EncoderDecoder(\n",
              "  (encoder): Encoder(\n",
              "    (layers): ModuleList(\n",
              "      (0): EncoderLayer(\n",
              "        (self_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512)\n",
              "            (1): Linear(in_features=512, out_features=512)\n",
              "            (2): Linear(in_features=512, out_features=512)\n",
              "            (3): Linear(in_features=512, out_features=512)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1)\n",
              "        )\n",
              "        (feed_forward): PositionwiseFeedForward(\n",
              "          (w_1): Linear(in_features=512, out_features=2048)\n",
              "          (w_2): Linear(in_features=2048, out_features=512)\n",
              "          (dropout): Dropout(p=0.1)\n",
              "        )\n",
              "        (sublayer): ModuleList(\n",
              "          (0): SublayerConnection(\n",
              "            (norm): LayerNorm(\n",
              "            )\n",
              "            (dropout): Dropout(p=0.1)\n",
              "          )\n",
              "          (1): SublayerConnection(\n",
              "            (norm): LayerNorm(\n",
              "            )\n",
              "            (dropout): Dropout(p=0.1)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "      (1): EncoderLayer(\n",
              "        (self_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512)\n",
              "            (1): Linear(in_features=512, out_features=512)\n",
              "            (2): Linear(in_features=512, out_features=512)\n",
              "            (3): Linear(in_features=512, out_features=512)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1)\n",
              "        )\n",
              "        (feed_forward): PositionwiseFeedForward(\n",
              "          (w_1): Linear(in_features=512, out_features=2048)\n",
              "          (w_2): Linear(in_features=2048, out_features=512)\n",
              "          (dropout): Dropout(p=0.1)\n",
              "        )\n",
              "        (sublayer): ModuleList(\n",
              "          (0): SublayerConnection(\n",
              "            (norm): LayerNorm(\n",
              "            )\n",
              "            (dropout): Dropout(p=0.1)\n",
              "          )\n",
              "          (1): SublayerConnection(\n",
              "            (norm): LayerNorm(\n",
              "            )\n",
              "            (dropout): Dropout(p=0.1)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "    )\n",
              "    (norm): LayerNorm(\n",
              "    )\n",
              "  )\n",
              "  (decoder): Decoder(\n",
              "    (layers): ModuleList(\n",
              "      (0): DecoderLayer(\n",
              "        (self_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512)\n",
              "            (1): Linear(in_features=512, out_features=512)\n",
              "            (2): Linear(in_features=512, out_features=512)\n",
              "            (3): Linear(in_features=512, out_features=512)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1)\n",
              "        )\n",
              "        (src_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512)\n",
              "            (1): Linear(in_features=512, out_features=512)\n",
              "            (2): Linear(in_features=512, out_features=512)\n",
              "            (3): Linear(in_features=512, out_features=512)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1)\n",
              "        )\n",
              "        (feed_forward): PositionwiseFeedForward(\n",
              "          (w_1): Linear(in_features=512, out_features=2048)\n",
              "          (w_2): Linear(in_features=2048, out_features=512)\n",
              "          (dropout): Dropout(p=0.1)\n",
              "        )\n",
              "        (sublayer): ModuleList(\n",
              "          (0): SublayerConnection(\n",
              "            (norm): LayerNorm(\n",
              "            )\n",
              "            (dropout): Dropout(p=0.1)\n",
              "          )\n",
              "          (1): SublayerConnection(\n",
              "            (norm): LayerNorm(\n",
              "            )\n",
              "            (dropout): Dropout(p=0.1)\n",
              "          )\n",
              "          (2): SublayerConnection(\n",
              "            (norm): LayerNorm(\n",
              "            )\n",
              "            (dropout): Dropout(p=0.1)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "      (1): DecoderLayer(\n",
              "        (self_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512)\n",
              "            (1): Linear(in_features=512, out_features=512)\n",
              "            (2): Linear(in_features=512, out_features=512)\n",
              "            (3): Linear(in_features=512, out_features=512)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1)\n",
              "        )\n",
              "        (src_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512)\n",
              "            (1): Linear(in_features=512, out_features=512)\n",
              "            (2): Linear(in_features=512, out_features=512)\n",
              "            (3): Linear(in_features=512, out_features=512)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1)\n",
              "        )\n",
              "        (feed_forward): PositionwiseFeedForward(\n",
              "          (w_1): Linear(in_features=512, out_features=2048)\n",
              "          (w_2): Linear(in_features=2048, out_features=512)\n",
              "          (dropout): Dropout(p=0.1)\n",
              "        )\n",
              "        (sublayer): ModuleList(\n",
              "          (0): SublayerConnection(\n",
              "            (norm): LayerNorm(\n",
              "            )\n",
              "            (dropout): Dropout(p=0.1)\n",
              "          )\n",
              "          (1): SublayerConnection(\n",
              "            (norm): LayerNorm(\n",
              "            )\n",
              "            (dropout): Dropout(p=0.1)\n",
              "          )\n",
              "          (2): SublayerConnection(\n",
              "            (norm): LayerNorm(\n",
              "            )\n",
              "            (dropout): Dropout(p=0.1)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "    )\n",
              "    (norm): LayerNorm(\n",
              "    )\n",
              "  )\n",
              "  (src_embed): Sequential(\n",
              "    (0): Embeddings(\n",
              "      (lut): Embedding(10, 512)\n",
              "    )\n",
              "    (1): PositionalEncoding(\n",
              "      (dropout): Dropout(p=0.1)\n",
              "    )\n",
              "  )\n",
              "  (tgt_embed): Sequential(\n",
              "    (0): Embeddings(\n",
              "      (lut): Embedding(10, 512)\n",
              "    )\n",
              "    (1): PositionalEncoding(\n",
              "      (dropout): Dropout(p=0.1)\n",
              "    )\n",
              "  )\n",
              "  (generator): Generator(\n",
              "    (proj): Linear(in_features=512, out_features=10)\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E7asSV8vpii8",
        "colab_type": "text"
      },
      "source": [
        "# Training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l5aj0r-qqh0j",
        "colab_type": "text"
      },
      "source": [
        "## Optimizer"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JW7QXM7wql-u",
        "colab_type": "text"
      },
      "source": [
        "We used the Adam optimizer with $\\beta_1=0.9$, $\\beta_2=0.98$ and $\\epsilon=10^{-9}$.  We varied the learning rate over the course of training, according to the formula:                                                                                            \n",
        "$$                                                                                                                                                                                                                                                                                         \n",
        "lrate = d_{\\text{model}}^{-0.5} \\cdot                                                                                                                                                                                                                                                                                                \n",
        "  \\min({step\\_num}^{-0.5},                                                                                                                                                                                                                                                                                                  \n",
        "    {step\\_num} \\cdot {warmup\\_steps}^{-1.5})                                                                                                                                                                                                                                                                               \n",
        "$$                                                                                                                                                                                             \n",
        "This corresponds to increasing the learning rate linearly for the first $warmup\\_steps$ training steps, and decreasing it thereafter proportionally to the inverse square root of the step number.  We used $warmup\\_steps=4000$."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7CN9TpIDqKjT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Note: This part is incredibly important. \n",
        "# Need to train with this setup of the model is very unstable.\n",
        "class NoamOpt:\n",
        "    \"Optim wrapper that implements rate.\"\n",
        "    def __init__(self, model_size, factor, warmup, optimizer):\n",
        "        self.optimizer = optimizer\n",
        "        self._step = 0\n",
        "        self.warmup = warmup\n",
        "        self.factor = factor\n",
        "        self.model_size = model_size\n",
        "        self._rate = 0\n",
        "        \n",
        "    def step(self):\n",
        "        \"Update parameters and rate\"\n",
        "        self._step += 1\n",
        "        rate = self.rate()\n",
        "        for p in self.optimizer.param_groups:\n",
        "            p['lr'] = rate\n",
        "        self._rate = rate\n",
        "        self.optimizer.step()\n",
        "        \n",
        "    def rate(self, step = None):\n",
        "        \"Implement `lrate` above\"\n",
        "        if step is None:\n",
        "            step = self._step\n",
        "        return self.factor * \\\n",
        "            (self.model_size ** (-0.5) *\n",
        "            min(step ** (-0.5), step * self.warmup**(-1.5)))\n",
        "        \n",
        "def get_std_opt(model):\n",
        "    return NoamOpt(model.src_embed[0].d_model, 2, 4000,\n",
        "            torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZZMZCaDiqyGz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "outputId": "f9960a10-6294-445f-b66b-2166eeb73496"
      },
      "source": [
        "# Three settings of the lrate hyperparameters.\n",
        "opts = [NoamOpt(512, 1, 4000, None), \n",
        "        NoamOpt(512, 1, 8000, None),\n",
        "        NoamOpt(256, 1, 4000, None)]\n",
        "plt.plot(np.arange(1, 20000), [[opt.rate(i) for opt in opts] for i in range(1, 20000)])\n",
        "plt.legend([\"512:4000\", \"512:8000\", \"256:4000\"])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f55b677d4e0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa4AAAEGCAYAAAA9unEZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydeVjUVffAP3cA2RSQRQRlURQ3FEVCJRMk09JcejVb1NIsfbN6K7Ps/bWY9dbb+rZoWGpliy2SuaYtruSO5IKi4saOC7LLztzfHwMjyyADogN4P88zzzj3e875nhGYM/fcc88VUkoUCoVCoWguaEztgEKhUCgU9UEFLoVCoVA0K1TgUigUCkWzQgUuhUKhUDQrVOBSKBQKRbPC3NQONDeEEKXoAn6OqX1RKBSKZoQdoJVSXnPcEaocvn4IIbSAsLe3N7UrCoVC0WzIzs4GkFLKa870qRlX/cmxt7e3z8rKMrUfCoVC0WxwcHAgOzu7UTJVRkU+IYSlEOIdIUSqEKJACLFHCHG7kbodhBArhBBZQogcIcRqIUSnWmSnCyGOCSEKhRBxQognDMgECSHChRDRQohiIUStU0YhhEYI8YIQ4my5zcNCiPuM8VuhUCgUTRNjp2zLgGeB74CnAS2wUQgx6GpKQojWwFbgNuBNYB4QAGwTQrStJjsTWArEAE8Be4CFQojnqpkdCTxW/u/Tdfj9JvAO8Ee5zUTgRyHEhDr0FAqFQtFEqXONSwgRBOwFnpVSflQ+ZgUcAVKllEOuovsC8DbQX0p5oHyse7nuW1LKV8vHrIEkYIeUclwl/e+AMYCHlDK7fMwVyJFSFgghPgKellIKA/fuAJwFwqWUz5SPCWA74Al0llJq6/oPMmA3S6UKFQqFon6UpwqzpZQO12rLmBnXBKAE3WwIACllIfAFMFgI4VaH7p6KoFWuexzYDEysJDcUcALCq+l/CrQB7qqkf15KWWCE32MBi8o2pS5KLwK8gCAjbCgUCoWiiWFM4OoHHJdS5lUb3wcIoK8hJSGEBugD7DdweR/gK4SwqXQPDMhGo0tL9qP+9EM3M4szcO/K96xC+VpcrQ9AlRMqFAqFCTGmqtANSDEwnlb+7F6LniNgWUmuuq4ot326/LlISplRWUhKWSyEuHSVe9Tl97kG+K1QKKohpSQ9PZ3CwkK02npn2BUtGI1Gg5WVFc7OzuhWY64/xgQua6DIwHhhpeu16WGkrjVQXIudwqvc42o0yO+68q9q1lU/isuK2ZO2hwFuA7A0szS1O4oGIKUkJSWF3NxcLC0tMTMzM7VLiiZESUkJeXl5FBUV0aFDhxsSvIwJXAXoZk7Vsap0vTY9jNSt7R4VssasaRm6f0P8VjQinx78lC+PfElIxxAWhC24Yd/IFI1Heno6ubm5uLq64ujoaGp3FE2QjIwMzp8/T3p6Oi4uLtf9fsascaWhS7tVp2IstRa9DHQzntp0JVfSdmlAKyFElb8KIUQrdEUbtd3jaqQB7Wu5Nw20qagHUkq+PPIlANuTt7Px7EYTe6RoCIWFhVhaWqqgpagVR0dHLC0tKSwsrFu4ETAmcB0EupfvyarMgPLnQ4aUykvNY4BAA5cHACellPmV7oEB2cByHw9Sfw4CdkIIXwP3rnxPxXXiROaJKq/f3vc2mYWZJvJG0VC0Wq1KDyrqxMzM7IatfxoTuH5GV1b+aMWAEMISmAbslFKmlo95lu/Rqq47UAjRr5JuNyAMiKgktwXdDG1WNf3HgTygIV/V16Ar49fbLN/H9U90G5H3NsCmoh5sTdwKgJWZFa0tWpNZlMl7Ue+Z2CuFQtHcqXONS0q5VwgRAbxbvmfrNPAwur1QUyuJfgOEoKsWrCAcXZeLDUKID4BSYDa6NN6Hle5RIIR4BfhUCLECXaeL24DJwFwppX63rxDCC5hS/jKofOzl8teHpJTrym0ml29QnlO+YXo/MK7c7n0N2XysqB9bk3SBa2K3iXjbe/P67tdZd2YdIzuPZHCHwSb2TqFQNFeMbbL7EPBG+XNb4DAwUkq582pKUspcIUQouiD1CroZ3lbgGSnlpWqy4UKIEuA5dJuHk9B1xfikmtlO5b5UpuL118C6SuMvApnATHQzxDjgQSnlirresOLaSMtL41jGMQCGegwlwDWAX8/8SvT5aF7f/Tq/jPmF1q2qZ58VCoWibtSxJvVEtXwyju+Pfc9/9/0XB0sHtk7cirnGnPjseCasm0BRWRHjuozjjVurf/9QNEUSEhIA8PLyMrEniqZMXb8nN7rlk0JRbyrShEM6DsFco5vYe9t782z/ZwFYfWo1mxM2m8w/hQJg27ZtCCEMPo4fP66X++mnn5g8eTK+vr4IIQgNDTVob/PmzUybNg1fX19sbGzw8fFhxowZnDtnqBdC3cyaNQshBOPGjTN4fe3atQQEBGBlZYWnpyfz58+ntLS0hlxWVhYzZszAxcUFW1tbwsLCOHjQcH2asTZNiTqPS9Ho5Bbnsv+crnvXUI+hVa490P0BtiVtY0/aHubvno9/O3+crZ1N4aZCoeeZZ56hf//+Vcbc3a8011m0aBHR0dEEBgZy6dKl6up65s6dS0ZGBvfeey9du3blzJkzLFy4kPXr13Pw4EHatWtntE+HDx9m6dKlWFlZGby+ceNGxo0bR1hYGAsWLCAmJobXX3+d9PR0FixYoJfTarWMGjWKmJgY5syZg5OTE+Hh4YSGhhIdHY2Pj0+9bZocKaV61OMBZNnb20tF7Ww4s0H6LfOTAd8EyMvFl2tcT8tLk4O+HyT9lvnJWZtmSa1WawIvFcYSHx8v4+PjTe3GdWHr1q0SkKtWrbqqXGJioiwtLZVSSunv7y9DQkIMym3fvl2WlZXVGAPkvHnz6uVbaGionDZtmvTy8pJjx46tcb1nz54yICBA75eUUr700ktSo9HIuLg4/dhPP/1U4z1euHBBOjg4yClTpjTIpiHq+j2xt7eXQJZshM9hlSpUNDoVZfAD3QdiY2FT43p72/a8MvAVACKTI/npxE831D+FwhC5ubm1psQ8PDyM2ss2ZMgQNBpNjTFHR0eOHTtWZTwxMbFKOrIyERERREVF8eabbxq8HhsbS2xsLDNnzqzi16xZs9BqtaxcuVI/9vPPP+Pu7s7YsWP1Yy4uLkycOJHVq1dTUlJSb5umRgUuRaNSUlbCXyl/ATXThJW5q9NdjOw0EoD3ot7j2KVjtcoqFNebKVOmYGdnh7W1NcOHDycmJqbRbOfl5ZGXl4ezc9WU+EMPPUSPHj1qyBcUFDBnzhzmzp2Lm5vhU6MOHNCdFBUYWLVng7u7Ox07dtRfr5Dt379/jXZrQUFB5ObmcurUqXrbNDVqjUvRqESdjyKvJA+BINQj9Kqyrwx8hSPpR0jMTeS57c+x4u4VqkS+mVBapiUt+8a09zEGN3srzM3q/z28VatWTJgwgbvuugtnZ2cOHz7M+++/z+DBg4mKisLXt3rjnfrz0UcfUVxczMSJE+sWBt59912klMyZM6dWmbQ0Xbc8Q4HNzc2N1NTUKrJhYWEG5QBSU1Pp0aNHvWyaGhW4FI1KRZqwt0vvOosuWrdqzfsh7zN5w2SScpN4bfdrvDfkPdWItxmQll3Ibe9uNbUbev56YSgejjXT0nURHBxMcHCw/vWYMWMYPXo0gYGBzJ8/n+XLl1+TX5GRkcyfP58HHniAkJCQKte2bdtWQz4xMZF33nmHJUuWYG1d+6EYBQW6HuGWljX7iFtZWZGfn19Ftja5yrbqY9PUqFShotGQUrIteRtw9TRhZXo49WBu0FwAfo//Xa13KUyOv78/w4YNY/Pma9uucfz4ce655x78/f1ZsmSJUTrPP/88vXv35sEHH7yqXEVQKyqqeXJTYWFhlaBnbW1dq1xlW/WxaWrUjEvRaBzPOM65y7r9KsYGLoB7fe9l/7n9bIzfyLtR79LDqQf+Lv7Xy01FI+Bmb8VfLxj/M77euNkbLhlvKB4eHtcUuJKSkhg+fDgODg78+uuv2Nra1qkTHR3NihUrWL58uX4zL0BpaSn5+fnEx8fj5OREmzZt9Om8tLS0Gqm9tLS0KrNINzc3fRqwuhxcKfuvj01TowKXotGo2HTs2caTzvadjdYTQjAveB7HMo4RnxPPs1uf5ce7f6SdjfF7XhQ3FnMzTYNSc82FM2fONPhcqUuXLjF8+HCKiorYsmULrq6uRuklJSUBMGnSpBrXUlJS6NSpE4sWLeKf//wnffv2BWD//v0EBATo5VJTU0lOTtZfB+jbty+7du1CSlklDb93715at25Nly5d9HLG2jQ1KlWoaDQqAtdQj6H1XqeytbDlk7BPaG3RmosFF3lm6zMUlRk6wFqhaDwuXrxYY2zHjh1s3bqVESNG1Nve5cuXGTlyJCkpKWzYsEEfFAxRvRx+wIABrFq1qsbDxcWFoKAgVq1axZ133glAr1696N69O4sXL6asrExvY9GiRWg0GsaPH68fmzBhAqmpqaxZs0Y/lp6eTkREBGPHjsXCwqLeNk2N6lVYT1SvQsOk5qUyYqXuD33Zncvo79q/Dg3DRCZH8uTmJ5FIxviM4T+3/kcVa5iYltyrMCwsDBsbG4KDg3F2dubIkSMsXrwYe3t7oqKi8PT0BHRFFpGRkQB8+umnWFlZMX36dEBX0NGnTx8Axo0bx5o1a3jkkUcYOrRqKtXV1ZU77rhD/zo0NJTt27dT12ewt7c3ffv2ZfXq1VXG169fz5gxYwgLC+O+++7jyJEjLFy4kJkzZxIeHq6XKysrY/DgwRw9epQ5c+bg7OxMeHg4SUlJREdHVwmuxto0xI3sVWjyThTN7YHqnGGQ72K/k37L/OTgHwbL0rLSuhWuwtLDS6XfMj/pt8xPfn3k60byUNFQWnLnjI8//lgGBQVJR0dHaW5uLt3d3eW0adNkQkJCFbl58+ZJdKe213h89dVXejkvL69a5ap32wgJCZG6j+CrU1vnDCmlXLVqlezbt6+0tLSUHTt2lK+++qosKSmpIZeRkSGnT58unZycpI2NjQwNDZXR0dHXZLM6N7Jzhppx1RM14zLMY388xp60PYzxGcObgw3v9jcWKSVzI+eyMX4jAsGHQz/kds/bG8lTRX1pyTMuReOhusMrmhU5xTn6prphHjU3OtYXIQTzb51PH+c+SHRB7NDFQ9dsV6FQtAxU4FJcMzuSd1AqS7E0s2SQ+6BGsWltbs2C2xfg0caDorIintr8FIk5iY1iW6FQNG9U4FJcMxXVhAPdDDfVbSiOVo4sGrYIB0sHMosyeXzT42QWZjaafYVC0TxRgUtxTZSUlbAjZQdQv03HxuJl58WCsAVYmlmSmJvIE5uf4HLJ5Ua/j0KhaD6owKW4JqLOXWmqG+IRUrdCA+jbri9v3/Y2GqEhJj2Gp7Y8RWFp02nwqlAobiwqcCmuiYo0oTFNda+FYV7DeG3Qa4AuWD63/TlKykqu2/0UCkXTRQUuRYORDWiqey3c0/Ue5t6ia8gbmRzJv3f8mzJtWR1aCoWipaECl6LBHMs4pm+q2xhl8MYwuedknuj7BKDrJj9v1zwVvBSKmwwVuBQNpiJN6GXnRSf7TjfsvjP7zGRqr6kArDm9hld2vqKCl0JxE6ECl6LBVBwa2ZCmuteCEILZ/WczpecUANadWce/d/ybUm3pDfNBoVCYDhW4FA0iJS+FE5kngBuzvlUdIQTPBz7PNL9pAGw8u5G5kXMp0aqCDYWipaMCl6JBbEvaBkBby7YmO/RRCMGzAc/yWO/HAPgj4Q+e3/48xWXFJvFHoVDcGIwKXEIISyHEO0KIVCFEgRBijxDCqK6nQogOQogVQogsIUSOEGK1EMLggogQYroQ4pgQolAIESeEeOJabAoh7IUQ7wkhTpb7fVYI8ZkQwt0Y3xW1U7G+NaTjEMw0ZibzQwjBU/2eYpb/LAA2J27m8U2Pk1ecZzKfFM2Hbdu2IYQw+Kh8VtZPP/3E5MmT8fX1RQhBaGioQXubN29m2rRp+Pr6YmNjg4+PDzNmzODcuXNG+xQdHc2oUaNwdXWlTZs29OvXj88++wytVltDdu3atQQEBGBlZYWnpyfz58+ntLRmyjwrK4sZM2bg4uKCra0tYWFhHDx40OD9jbVpSow9AXkZMB74CDgFTAU2CiFCpJS7a1MSQrQGtgJtgDeBUuBZYJsQoq+UMrOS7EzgMyAC+B9wG7BQCGElpfygvjaFEBrgd8APCAfiAF9gFnC7EMJPSqlOKmwAOcU5RJ+LBmCop+mPbxdC8Hjfx7Eyt+J/0f9j37l9PPL7I4QPC7+ue8sULYdnnnmG/v2rniFXcaQ96A5TjI6OJjAwkEuXLtVqZ+7cuWRkZHDvvffStWtXzpw5w8KFC1m/fj0HDx6kXburn+r9999/ExwcjK+vLy+++CLW1tasX7+exx9/nJSUFN544w297MaNGxk3bhxhYWEsWLCAmJgYXn/9ddLT01mwYIFeTqvVMmrUKGJiYpgzZw5OTk6Eh4cTGhpKdHQ0Pj4+9bZpcuo69wQIQneezDOVxqzQBbDIOnRfALRAv0pj3dEFm9crjVkD6cDqavrfATmAfQNsDij3+4lqNp8sHx/akHNgUOdxyfWn10u/ZX6y/7f95eXiy6Z2pwqrTq6S/l/7S79lfnLkypEyKSfJ1C41e1ryeVxbt26VgFy1atVV5RITE2Vpqe6cOX9//xpna1Wwfft2WVZWVmMMkPPmzavTn3/+85+yVatW8tKlS/oxrVYrAwMDpaenZxXZnj17yoCAAL1fUkr50ksvSY1GI+Pi4vRjP/30U433eOHCBeng4CCnTJnSIJuGuJHncRmTKpwAlABLKwW7QuALYLAQwq0O3T1SygOVdI8Dm4GJleSGAk7oZkaV+RTdzOquBti0K38+X81mxZy94Cp+K65CRZpwkNugRm2q2xiM6zKOj4Z+pO9tOGXjFGIvxZraLUUzIDc3t9aUmIeHB2ZmdafEhwwZgkajqTHm6OjIsWPHqownJiZWSUcC5OTkYGVlhYPDlSOrhBC4urpibW2tH4uNjSU2NpaZM2dW8WvWrFlotVpWrlypH/v5559xd3dn7Nix+jEXFxcmTpzI6tWrKSkpqbdNU2NM4OoHHJdSVl802AcIoK8hpfJUXR9gv4HL+wBfIUTFp16/8ufqstGUz64aYDMayAPeEEKEla+LhQFvoEs17q3F76yrPQB7Q3o3C8VlxVea6jaBNKEhQj1CWTJ8CW1atSG9IJ2pv01lS+IWU7ulaMJMmTIFOzs7rK2tGT58ODExMY1mOy8vj7y8PJydq6atH3roIXr06FFlLCQkhJycHGbOnMnx48eJj49nwYIF/P7778ydO1cvd+CA7nt7YGBgFX13d3c6duyov14h279//xpbVoKCgsjNzeXUqVP1tmlqjFnjcgNSDIynlT/XVujgCFhWkquuK8ptny5/LpJSZlQWklIWCyEuVbqH0TallBlCiPuBJehmYxWsA+6TUh393BCizkVxueQyAsGQjkNM7U6t9GvXj2/u/IYntzxJSl4Kz2x9htn9Z/Nwr4dv6J6zFktZKeQY+lgwEXYdwMzYJfsrtGrVigkTJnDXXXfh7OzM4cOHef/99xk8eDBRUVH4+vpes2sfffQRxcXFTJw4sU7Z6dOnExMTw+eff87Spbokl4WFBYsXL2batGl6ubQ03Uegm1vNhJebmxupqalVZMPCana2qdBNTU2lR48e9bJpaoz5SVsDhooYCitdr00PI3WtgdpqmAuryRlrE+ACupnXLiAW3ezwBeBL4AFDN5N1HCt9s8+6KtKEfVz6NPnChy5tu7B85HKe3vo0hy4e4oPoDzibc5aXB7yMhZmFqd1r3uSkwMd9TO3FFZ4+DG0NHxl/NYKDgwkODta/HjNmDKNHjyYwMJD58+ezfPnya3IrMjKS+fPn88ADDxASUvX0hG3bttWQNzMzw8fHhzvvvJMJEyZgZWXFDz/8wMyZM3F2dmb06NEAFBToVjosLS1r2LCysiI/P1//uqCgoFa5yrbqY9PUGBO4CtDNcqpjVel6bXoYqVvbPSpkK8sZZVMI0RnYBjwopVxTfm2NECIeWCaE+FJK+Wct91QYQEqp379lik3HDcHJ2okvRnzBKztfYePZjfxy8heScpN4P+R9HK0cTe2eogni7+/PsGHD2Lx5c93CV+H48ePcc889+Pv7s2TJEqN03nnnHRYsWEBcXBw2NrpVj4kTJzJ06FCeeOIJRo4ciZmZmX69q6io5nf4wsLCKuth1tbWtcpVXK/8bIxNU2NM4EpDl36rTsVYbfPHDHQzo9p0JVdSfmlAKyGEY+V0oRCiFbqijYp71MfmVHQBbkM1ubXlz7cCKnDVg9iMWM7n62pdmur6liEszSx557Z36GTXifBD4USdi+K+9ffxYeiH+Dn7mdq95oldB90sp6lg16FRzXl4eFxT4EpKSmL48OE4ODjw66+/Ymtra5Tep59+yu23364PWhWMGTOG2bNnk5SUhLe3tz6dl5aWViO1l5aWVmUW6ebmpk8DVpeDK2X/9bFpaowJXAeBp4UQrasVaAwofz5kSElKqRVCxACBBi4PAE5KKSvmnhU74QKBPyrJBaIrIDnYAJuu6Na8qhegVOSI6p8Qv8mp6E3obedNZ/vOJvamflTs9ers0JlXdr7CucvneGjjQ/zfgP9jgu8EU7vX/DAzb1Bqrrlw5swZXFxcGqR76dIlhg8fTlFREVu2bMHV1dVo3fPnz1NWVrNhdEXlX0XVY9++upq4/fv3ExAQoJdLTU0lOTlZf71CdteuXUgpq6zv7t27l9atW9OlS5d62zQ1xlQV/ozuw/7RigEhhCUwDdgppUwtH/MUQnQ3oDtQCNGvkm43IAzdRuMKtqCbTc2qpv84usrAjQ2wGVf+/u6tZrNibavplMg0EyrWt5pLmtAQI7xH8P3I7/G286ZEW8L83fN5bddrFJWpveg3IxcvXqwxtmPHDrZu3cqIESPqbe/y5cuMHDmSlJQUNmzYoA8KhjBUDu/r68vvv/9OZqa+NwNlZWWsWLECBwcHOnXSNQjq1asX3bt3Z/HixVUC3aJFi9BoNIwfP14/NmHCBFJTU1mzZo1+LD09nYiICMaOHYuFhUW9bZoaYUxxnRBiBTAO+BBdFeDDwC3oNvHuLJfZBoRIKUUlvTboAoQt8AG6TcKzKS+jl1JeqiQ7C92+rQh0s67bgIeAuVLKd+trUwjhBBxBV4m4CF1xRgC6AHwUCJRS1rsjqxAiy97e3j4rK6u+qs2a5Nxk7vpFt53u6zu/JsA1oA6Npk1ucS4v73iZLUm6MvmeTj15b8h7eNp5mtizpkdCQgIAXl4tb4YVFhaGjY0NwcHBODs7c+TIERYvXoy9vT1RUVF4eup+HyIjI4mMjAR06TwrKyumT58O6NJ4ffroClXGjRvHmjVreOSRRxg6tOoXPFdXV+644w7969DQULZv307lz+Dly5czefJkunTpwowZM/TFGbt37+btt9+uUhK/fv16xowZQ1hYGPfddx9Hjhxh4cKFzJw5k/DwK1tiy8rKGDx4MEePHmXOnDk4OzsTHh5OUlIS0dHRVYKrsTYNUdfviYODA9nZ2dl1FcAZhTG7lNEVPryHbv2oEN2eqWHVZLbpzNXQ7YguGGUDuejWmDrXcp/HgOPo1rFOAf+qRc4om0AHdBulz5TbTAU+B5waumObm7Rzxnex30m/ZX5yyI9DZGlZad0KzYAybZlccniJ7PN1H+m3zE8GfRck155aa2q3mhwtuXPGxx9/LIOCgqSjo6M0NzeX7u7uctq0aTIhIaGK3Lx58yS6NfQaj6+++kov5+XlVatc9W4bISEhsvwzswq//fabDAkJkc7OzrJVq1ayT58+cvHixQb9X7Vqlezbt6+0tLSUHTt2lK+++qosKSmpIZeRkSGnT58unZycpI2NjQwNDZXR0dHXZLM6N7JzhlEzLsUVbtYZ16O/P8rec3sZ12Ucb9z6Rt0KzYioc1G8GPkiFwouADDGZwwvDXipyXUFMRUtecalaDxu5IxLHWuiqJPsomz2n9c1K2nO61u1cUv7W/h5zM+EdNTts1l7ei0T109UraIUiiaKClyKOvkr5S/KZBlWZlYMch9kaneuC22t2rIgbAEvBr2IhcaChJwEJv06ic8Pfa5OVlYomhgqcCnqpKIMfqD7QKzNm84mxMZGCMGkHpP4fpSu6rBUlrLw4EImb5jM6azTpnZPoVCUowKX4qpUaarbAtOEhuju2J2I0RFM6TkFgeDopaNMXDeRZUeWUaatucdGoVDcWFTgUlyVqHNR5JfmN/mmuo2NlbkVL9zyAl+O+JIOrTtQrC3mg+gPmPb7NM5knzG1ewrFTY0KXIqrUrHp2N/Fv8k31b0eBLYP5JcxvzDRV9fZ+8CFA0xYO4FFBxdRXFZbX2iFQnE9UYFLUStSyivdMppRb8LGxsbChlcGvcLnd3xOh9YdKNGWEH4onAnrJhB9PtrU7ikUNx0qcClqJfZSLBfydXubbpb1rasR7B7MqrGrmOY3DTNhxtnss0z9bSqv7XqN7KJsU7unUNw0qMClqJWKdkjedt50su9kYm+aBtbm1szuP5sf7/4RPyddZ/mVJ1cyZvUYVsatVMUbCsUNQAUuRa20hKa614vujt35buR3vBj0IjbmNmQUZvDa7td4cMODHLxwsG4DCoWiwajApTBIcm4yJzNPAte2vpVTWMLyvQlcymt53dfNNGZM6jGJdfes4+7OdwO69OqUjVP4v7/+j4v5NTuPKxSKa0cFLoVBKk46drRypI9zw49on782lpdWHeHez3eTcbllVuG1s2nHf2/7L9/c9Q09HHsAsO7MOu5edTdLY5ZSWFpoYg8VipaFClwKg1SkCUM6hmCmMWuQjQs5haz8OxmAMxcvM21ZFJeLWm77pH7t+vHDqB+YN2gebS3bkl+az8d/f8zdq+5m1clVav1LoWgkVOBS1CC7KFtf5n0t61vf7Umo8vpQUhaPL/+b4lLtNfnXlDHTmDHBdwLr7lnHlJ5TsNBYcD7/PK/uepUJ6yYQmRyJOpGh6RAVFcUTTzxBz549sZkE+pwAACAASURBVLW1xdPTk/vvv59Tp05VkQsNDUUIUeNx//3312p31KhRtG3bltatW+Pv78+yZcvq7d+sWbMQQjBu3DiD19euXUtAQABWVlZ4enoyf/58/SnJlcnKymLGjBm4uLhga2tLWFgYBw8aXos11qYpUcfXK2oQmRypb6o70H1gg2wUlpSxfG8iAE+FdcHdwZp//xJDZNxFnv/5EB9O7ItGI+qw0nyxt7TnhVteYFKPSSw4sIBfz/zKqaxTPLH5CQJdA5ndfza9XXqb2s2bnnfeeYedO3dy77330qdPH86dO8fChQvp168f+/bto0ePHnpZT09P3nzzzSr63t7eNWxu3LiRsWPHEhoayhtvvIGFhQVxcXEkJSXVy7fDhw+zdOlSrKysDF7fuHEj48aNIywsjAULFhATE8Prr79Oeno6CxYs0MtptVpGjRpFTEwMc+bMwcnJifDwcEJDQ4mOjsbHx6feNk1OYxzqdTM9uAkOknx267PSb5mffHLzkw228VNUovSau176/PtXeS67QEop5Seb4qTX3PXSa+56OffnQ7KsTNtYLjd5YtNj5WO/Pyb9lvnpH09sekIeST9iatfqpCUfJLlz505ZVFRUZSwuLk5aWlrKhx9+WD8WEhIi/f3967SXlZUl27VrJ//1r39ds2+hoaFy2rRp0svLS44dO7bG9Z49e8qAgABZWnrlYNeXXnpJajQaGRcXpx/76aefJCBXrVqlH7tw4YJ0cHCQU6ZMaZBNQ9zIgyRVqlBRheKyYnam7AQgzCOsQTaklHy1Mx6Au/u44Wqn+8b4ZFgXHrlVtx/sx6gkXlp9BK325kib9XDqweLhi/l82Od0d+wOwPbk7dy//n6e2vIUxy4dM7GHNyfBwcG0atWqyljXrl3p1asXx47V/JmUlpaSl5dXq73vv/+erKwsXn/9dQByc3NrTQ0nJiZy/Phxg9ciIiKIioqqMcOrIDY2ltjYWGbOnImZ2ZU16FmzZqHValm5cqV+7Oeff8bd3Z2xY8fqx1xcXJg4cSKrV6+mpKSk3jZNjUoVKqqw79y+a26qu+dMBsfScgCYduuVjctCCF65uwdlWi1f707gh32JaAT8Z5wfQrTctGFlgjsEM9B9IFsStxB+KJyTmSfZlrSNbUnbuN3zdh73f5xujt1M7WadlGpLOZ9/3tRu6HG1ccVc0zgfZ1JKzp8/j7+/f5XxY8eOYWtrS3FxMW5ubjz55JO8+OKLaDRXvv9v2rSJ7t27s2HDBl544QWSk5NxcHBg5syZvPnmm1UCwkMPPcT27dtrBLaCggLmzJnD3LlzcXNzM+jjgQMHAAgMDKwy7u7uTseOHfXXK2T79+9f428sKCiIxYsXc+rUKXr06FEvm6ZGBS5FFSrO3urbri9O1k4NsvHVzrMABHg64O9R9ZRuIQSvjemFVsK3exJYvjcRIeD1MX4tes2rMhqhYZjXMMI8w/gz4U8+O/QZp7JOsTlxM5sTNxPmEcb03tPp49LwbQjXm/P557lz5Z2mdkPPb+N/o0PrDo1ia/ny5aSkpFSZ7fj4+BAWFkbv3r3Jycnhhx9+4KWXXiIxMZHPPvtML3fq1CmSkpKYOnUqL7zwAv369WP9+vW88847FBYW8tFHH9V5/3fffRcpJXPmzKlVJi0tDcBgYHNzcyM1NbWKbFhYzexJhW5qaio9evSol01TowKXQo9WavX7txpaTZh4KZ8/j+m+iT8y2HCbKCEE88f0Qisly/cm8t2eRC4XlfHuhD5YmN082WuN0DDCewR3eN3BH/F/sOjQIs5kn2FL0ha2JG3hlva3MN1vOsHuwTfNjNTUHD9+nCeeeILBgwczZcoU/fgXX3xRRe7hhx9m4sSJLF68mGeffZZu3XSz5Ly8PDIzM3n77beZO3cuAP/4xz/Iy8sjPDycl19+GWdn3SkL27Ztq3H/xMRE3nnnHZYsWYK1de2HthYUFABgaWlZ45qVlRX5+flVZGuTq2yrPjZNjQpcCj2xl2K5UHBtTXW/3h2PlOBmb8WIXu1rldNoBG+M9cPCTMOyXfGsOpBCTkEJn04KwMqiYfvGmisaoeHOTndyh9cd/Jn4J1/GfMmxjGNEnYsi6lwU3R27M91vOnd43dHgPXWNjauNK7+N/83UbuhxtXG9Zhvnzp3Tl7BHRERUSQEa4rnnniMiIoKtW7fqA1dFsHnggQeqyE6aNImIiAj27dvHyJEja7X5/PPP07t3bx588MGr3rviPkVFNTvSFBYWVgl61tbWtcpVtlUfm6ZGBS6Fni2JV5rqett711s/r6iUFVG6kt+HBnnXOXvSaATzRvfEwcaCjzadZPPxCzz05T6WPhyInZVFve/f3DHTmHGn952M8BrB7rTdfBnzJXvP7eV4xnGej3wejzYeTOk5hbE+Y7GxsDGpr+Ya80ZLzTUFsrOzueuuu8jOzmbnzp20b1/7l64KPDw8AMjIyNCPubm5cfToUVxdqwbSiteZmZm12ouOjmbFihUsX76chIQreyBLS0vJz88nPj4eJycn2rRpo0/npaWl1UjtpaWlERwcXMWnijRgdTnQrWFVyBlr09TcPHkZRZ1c69lbP+9PIreoFCsLDQ8EeRilI4TgmWG+zBvdE4B9ZzO47/M9pGUXNMiHloAQgmD3YJaOWMr3I79nmOcwBIKk3CTe2vsWwyKG8V7UeyTnJpva1RZBYWEho0ePJi4ujvXr1+tnT3Vx5ozuJGwXFxf9WP/+/QFISUmpIpucnFxDtjoV+7wmTZpEp06d9I+UlBT+/PNPOnXqxPLlywHo27cvAPv3769iIzU1leTkZP31Ctno6OgaRSB79+6ldevWdOnSpd42TY0KXAoAknKTOJWl6xbQkDJ4rVaybFc8AP8I6IiDTaurK1Rj2q2d+N9Ef8w0gmNpOYxduJMjKeqMq94uvflw6IesHrea8V3HY2lmSW5JLt/EfsOoVaN4ZuszRJ2LUt04GkhZWRn33Xcfu3fvJiIigoEDa264z8nJqZE+Kysr46233kKj0TBs2DD9+L333gtUXROTUrJ06VJsbW2r2K9eDj9gwABWrVpV4+Hi4kJQUBCrVq3izjt1BTG9evWie/fuLF68mLKyK63EFi1ahEajYfz48fqxCRMmkJqaypo1a/Rj6enpREREMHbsWCwsLOpt0+Q0xmawm+lBC92A/M3Rb6TfMj855MchsrSstG6FamyKPaffXBx3LqfBfvwVd1H6zftNes1dL7u/vFH+fiStwbZaIhkFGXLJ4SUybEVYlc3ME9ZOkL/E/SIvF19u9Hu25A3ITz/9tATk6NGj5bffflvlUbFhd+vWrdLNzU3Onj1bhoeHy3fffVcGBgZKQM6dO7eGzYceekgKIeSjjz4qw8PD5ahRoyQg33333SpyISEhUvcRfHVq24C8bt06KYSQt99+u1y8eLH817/+JTUajXz88ceryJWWlsqBAwfKNm3ayPnz58tPP/1U9urVS9rZ2cmTJ082yKYhbuQGZJMHgub2aKmBa9pv06TfMj/56s5XG6T/4JLd0mvuejl56Z5r9iXuXI689e3N0mvueun94nq5ePtpqdXePF02jKG4rFhuPLNRTvp1UpUANnD5QPnmnjdlXMbVuxzUh5YcuCqCh6GHl5eXlFLKM2fOyAkTJkgvLy9pZWUlbWxsZFBQkFy2bJlBm0VFRfLll1+WHh4e0sLCQnbr1k1+9tlntd67LmoLXFJKuWrVKtm3b19paWkpO3bsKF999VVZUlJSQy4jI0NOnz5dOjk5SRsbGxkaGiqjo6OvyWZ1bmTgElLWnWIQQlgCrwNTgLbAIeAlKeVmI3Q7AB8Cw9GlJrcAz0opzxqQnQ7MAToBicDHUspPr9GmG/AGMBJwBFKANVLK2XW+ccPvJ8ve3t4+KyurIepNkuyibEJ+CqFMlrEgbAGhHqH10j9xLpcRH0UC8NXUWxjavd01+3Qxt4gZ3+7nQKLu/3mMvztvj++NTStVT1SdmIsxLD++nD/i/6BEW6If79euH/f63ssdXndgZW64350xVBQKeHl5XbOvipZLXb8nDg4OZGdnZ0spHQwK1ANj17iWAc8C3wFPA1pgoxBi0NWUhBCtga3AbcCbwDwgANgmhGhbTXYmsBSIAZ4C9gALhRDPXYNNLyAKCAY+AZ4AvgUMb0e/SancVHeA24B661dsOO7sbEuIb+2Lz/XBpY0lPzw2kHF9dRVPaw+lcs+nuzibfrlR7Lckerv05u3b3mbzvZuZEzgHLzvdB8eBCwf4vx3/x+0Rt/Nu1LucyjxVhyWFonlQ54xLCBEE7EU3o/mofMwKOAKkSilr7QskhHgBeBvoL6U8UD7WvVz3LSnlq+Vj1kASsENKOa6S/nfAGMBDSpldH5vl478D9sBQKWWjlKm1xBnX7G2z+TPhT4Z6DOWTsE/qpZtxuZhB/91MUamW18f24qFB3o3qm5SSr3fF859fj1GqlbSxMufDiX0Z1vPa9+20VKSU7Du3j4i4CDYnbKZUXjmSopdTL8Z2Gctd3nfhYGXcF18141IYQ1ObcU0AStDNhgCQUhYCXwCDy1NxV9PdUxFgynWPA5uBiZXkhgJOQHg1/U+BNsBd9bUphOiBLpU4X0pZIISwEUKoPFM1isqK2JGyA2jYpuMf9iVSVKqljZU54wM6NrZ7CCGYemsnfpgxEJc2luQWlvLoN/v5z/pYikrVwYyGEEIwwG0A74e8z5/3/snTAU/TsbXuZ3P00lHe2vsWYRFhzN42m+1J2ynVNq2zlhSKujAmcPUDjkspq7dE3gcIwGBxvxBCA/QB9hu4vA/wFUJU7KLsV/5cXTYaXVqyXwNsVtSoFgkh9gOXgctCiAghRK35LCFE1tUe6GZwLYZ9afsoKC1AIzSEeITUS7ekTMs3u+MBuP8WD2wtr9/3glu8Hfn1qcHc4q3LBi/dcZbxi3Zx5mLtnboV4GztzKO9H2XDPzaw7M5l/KPrP7Axt6FEW8KfCX/y5JYnGRYxjPej3udExgmMWfNWKEyNMYHLDai57frKmHsteo6A5VV0BVfWmtyAIillRmUhKWUxcKnSPepjs0v58wogDt1M7T/AaHTrc02jd46Jqdh03NelL45WjvXS3RCTxvmcIjSCRk8RGqKdnRU/PDaQf4V1QSPgSEoOdy/YQcT+JPWBWwdCCPq79md+8Hy2TtzKW4PfYoDbAASCS4WX+Dr2ayasm8DYNWNZdGgRCTkJdRtVKEyEMV+RrYGazaugsNL12vQwUtcaKK7FTmE1OWNtti5/jpJSVjT+WimEuIQuBXk3sIZq1JV/bUmzrmttqltx5tbwnu3xcLwxLYjMzTTMHt6N4C7OPPvTQdKyC3n+58Nsi7vIG2P9cLSt38bnmxEbCxtG+4xmtM9o0vLSWHdmHWtPryUhJ4Gz2WcJPxhO+MFwejr15C7vuxhgNcDkLaYUisoYM+MqQDfLqY5Vpeu16WGkbm33qJCtLFcfmwA/VJNbXv58ay33u2k4mn6UiwUXAepdAv93YiYHk3QFKrV1gb+eDOzsxManb2NEL12Rxq+H07jjf9vZGGNoMq6oDbfWbszoM4N149bx490/8nDPh/UNa2MvxfJB9Af8cvoXMvMzySjIqFJur1BUpqysrM7GxI2FMTOuNAyXj1eM1XZISwa6mVFtupIrKb80oJUQwrFyulAI0Qpd0UbFPeprE6DKaXdSymwhRBG6/Wg3NRVpwk72nerdVLdittXL3U6/7nSjcbBpxWeT+xOxP5k31sdy6XIxjy//m7v7uPG6mn3VCyEEvZx60cupF7MDZ3PgwgE2nt3IH/F/kFaURlZ+FpoLGsxszbCxsKFNqzbYtbKjlZn6P1boGg0XFRXRpk2bG3I/YwLXQeBpIUTragUaFRt+DhlSklJqhRAxQKCBywOAk1LKigNeDpY/BwJ/VJILRDcrPNgAm9Hlz1VaWAshnNHN2C4a8vtmQt9Ut55pwrTsAjaUz2weubWTSc+KEkIw8RYPBnd15t+/xLA97iLrD6ex+/Ql5o3pxeg+buosq3qiERr6u/anv2t/Xgx6kb2pe0lKTkKkC2zybCgxLyEbXR9JM2GGhZkFrTStmsyRK4obS1lZmT5oVZw1dr0xJnD9jK6bxaNAxT4uS2AasFNKmVo+5gnYlJemV9b9rxCiX6U9V92AMHR7sSrYgm42NYuqgetxIA/Y2ACb24B0YJoQYpmUUls+/lj58yYj3nuLpXJT3foGrm93J1CmlTi3tuRu/6axl9vdwZpl026pMvv61w8HWBGVxBvj/OjkbGtqF5sl5hpzbu14K7KD5PyF88RnxJOUnURqXipFZVWXmtu0akOH1h3o0LoDDpYO6gvDTYKFhYU+aN2on7mxLZ9WAOPQtVk6DTwM3IJuY+/OcpltQIiUUlTSawMcAGyBD4BSYDblZfRSykuVZGehK5qIQBe8bgMeAuZKKd9toM1H0O032wSsBnqgC4YbpZR3G/l/VP3/okVsQP7m6De8t/89nKyc2DJxCxphXG66oLiMQW9vJiu/hGeGdeWZYb7X2dP6k5ZdwLw1R/kjVpclbmWm4Z+hPswK9bnpDqm8XpRpy/j7wt9sTtzMpoRNnM+vkpHH2dqZIR2HMKTjEAa5DVLFHYpG3YBsbOCyQtfvbzK6taHDwP9JKTdVktlGtcBVPt6Rqn0FtwLPSCnPGLjPY8Bz6HoVJgGfSClrtHKop83JwFzAF11p/Q/Ayw3tpNFSAte036ax//x+xncdz2vBrxmt98O+RP79SwytzDTsfDEMlza11dSYnk2x55m39igpWboftZeTDa+N7kVoNxc1G2hEpJQcST/CpsRNbEncQnxOfJXrFhoLgtoHMaTjEEI8QlrUAZQK47nhgUtxhZYQuLIKswhZEYJWauvVVFdKyYiPIok7n8f4gI58MNH/+jraCOQXl7JgyymWRJ6hVKv7Xb+tqzMvj+pJt/Y3ZiH5ZiM+O57I5EgikyOJPh9dpeUUQBeHLgzpOITBHQbT16UvFmY332nXNyMqcJmQlhC41p5ey0s7XsLa3JrI+yKN7hy+42Q6k7/YC8D6pwbj16H5bGc7eT6X19YdZecpXSZZI+CBIE+evcMX59ZNd9bY3MktzmVX6i4ikyP5K/kvMouqHl1vbW5NUPsgBrkP4lb3W/Gy81Kz4RaKClwmpCUEroqmumEeYXwc9rHRetOXRbH5+AWCOjmyYuZVDwZokkgp2XzsAm9tOMaZ8i7zbSzNmTW0C1ODvbFupda/ridl2jJi0mP0s7ETmSdqyLjbujPIfRDB7sEMcBuAvWXz+XKkuDoqcJmQ5h64isqKuO3H2ygoLeCNW99gXJdxdSsBZ9MvM/T9bQB8NjmAO/2aRjVhQygp0/LdngQ+2nSS7ALdhtp2bSx5MqwL99/iSSvzG7OJ8mYnvSCd3am72ZW6i12pu8gorNLxDY3Q4Ofkx0D3gQS1D8Lfxf+azhVTmBYVuExIcw9ckcmRPLH5CTRCw7aJ22hrZdzm4dfWHmXZrng6trVm+/NDMdM0/3ROVn4xC7ac4ts9CRSX6nZLdHCw5ulhXflHvw6Ym6kAdqPQSi0nM0+yK3UXO1N38vf5v2t06WilaUUflz4EtQ/ilva30Melj9oA3YxQgcuENPfANX/3fH6O+5mAdgF8fdfXRunkFJYw6K3NXC4u46WRPXhsSOfr7OWNJTWrgAVbTrFifxJl5QUcnV1sefr2rozq7aYCmAkoKC0g+nw0O1N2su/cPuIy42rIWJlZ4d/On6D2QQS1D6KXcy8sNKrQo6miApcJac6BSyu13B5xO+kF6TzX/zmm+k01Sm/pX2f4z6/HsGllxu5/3469dcv8cIhPv8xHm+JYcyiVij8LLycbHg/x4Z6ADliaqzUwU5FZmMn+8/vZl7aPqHNRnM4+XUPG2tyafu36EdAugADXAPyc/bA2r60HuOJGowKXCWnOgevwxcNM2jAJgPX3rNcf8X41yrSSkPe2kpxZwEODvHh9rN/1dtPknDiXy8eb49h45Jw+gLW3s2LGkM7cH+SBTSt1HqmpSS9IZ//5/USlRbHv3L4ae8cAzIU5PZ160q9dP/q59qNfu371PrpH0XiowGVCmnPg+uTvT1gSs4TO9p1ZM67GiS4G+f3oOWZ+q2v7uOW5EDq7tK5Do+Vw6kIui7adYfXBFH0K0dG2FVODvZk0wBMnVUbfZLiQf4Goc1FEn4/mwIUD+nZm1fG28ybANUA/M/No46HK728QKnCZkOYcuO5Zcw+nsk4x3W86z/R/xiid+z7fzd6zGQzt5sJX04Kus4dNk6SMfBZHnuGn/Un6Ig5Lcw339OvAI4M74euqNjI3NbKLsjl44SB/X/ibAxcOcCT9iMEjWRytHOnt3Js+Ln3o7dwbP2c/2rRSP8/rgQpcJqS5Bq6knCRGrhoJwHcjv8Pfpe6uF0dTsxn1yQ4Avp0exG1dXa6rj02dC7mFfLkjnu/3JpBTeKUbxG1dnXlkcCdCurqgaQHVli2RorIiYi/F8vd5XSA7cOEAOcU5NeQEgs72nent0pvezr3xd/HHx8EHc41KD18rKnCZkOYauL4++jXv73+/Xk1150Qc4ufoZLq2a80fzw5RKZVyLheVsvLvZL7aGc/Z8o3MAD4utkwa4MX4gI7Y27TMApaWglZqOZ11msMXDxOTHsOhi4c4nXUaSc3PQ2tza3o69aSPcx/6uPShl1Mv2tu2V38P9UQFLhPSXAPX1N+mEn0+2uimuul5RQT/dwvFZVreuqc3Dw7wvP5ONjO0WsnWExf4YsdZdp3WH0pAB/Mcnu9wlG4DRtC932D1AddMuFxymaPpRzmcflgf0NIL0g3KOlo50sOxBz2deuofbrbq7LeroQKXCWmOgSuzMJPQFaFopZaFYQsJ8QipU+fjTSf5cFMcDjYW7H7xdtUOqQ6OpeXw7Z4Ezh7YykfiA1yF7vfjlFlnMnzvo8eI6bRxuLlTrc0NKSVpl9M4nH6YmIsxxKTHEHsptsY5ZBU4WDpUCWQ9nXribuuuglk5KnCZkOYYuNacWsPLO182uqluUWkZg9/ZysXcIh4P9WHund1vkKfNnAPfIdc/iygrpgwNZmj1l4qkBUfsQ7AMmkrPQSPRmKkvAs2REm0JZ7LOEHspVvfIiOVExolag5m9pT09HXvSw6kH3dp2o5tjN7zsvG7KNbPGDFw33//eTci2pG0ABLsHG9Xr7dfDaVzMLcJMI5gysO69Xjc9ZSXwx8uw9zMEgFNXNPd/T1xiMpk7vsAvYxO2opD+OZtg0yZSNrsS32EsnkOn4uHTy9TeK+qBhcaCbo66AHRP13sAKNWWcia7UjC7pAtmhWWFZBdlszttN7vTduttWJpZ4uPgow9kvm198W3rqxoK1wM146onzW3GVbmp7n9u/Q9ju4y9qryUktELd3AkJYe7+7ix8MGAG+RpM+XyJYh4GOL/0r3uOgLGLwGrKx9C2dmZHPvzGxxO/ED3kmNV1OPMu5Hd9R58wx7C3kUdsNhSKNWWcjb7rD6QHc84TlxmHHklebXquNm66YNYN8dudGvbDU87T6NPJ2/qqFShCWlugau+TXWj4jO49zPdt8OVjwfT38u4Jrw3JeeOwI8PQFai7vVtz8HQl0BTexowOe4AaduW4pW6kXZcKegolRpirftT2GMC3Yfej53dNf9tK5oYUkpS8lI4kXmCuMw44jLiOJF5gqTcpFp1rM2t8bH3wcfBhy4OXfTPzbGqUQUuE9LcAtdru15j5cmVRjfVnbU8mg0x5/D3cGD1rOBm98dxwzi6ClbPgpJ8sLCBsZ+C3z+MVteWlhK7ZyN5+3+gZ+ZW7ES+/lq+tORY6wHInmPpOWQ8Nm3Ul4eWzOWSy5zMPMmJjBOcyNQ9TmaepKC0oFYdWwtbfOx96NK2i+65PKi1s2nXZP9mVeAyIc0pcFVuqjsncA4P93r4qvLJmfkMeXcrWgkf39+XsX1V6qoGWi1sfRP+el/32t4T7l8Obn0abLIg/zLHIiMQMRH0yttDK3Flc3ORtOB46yDKuo+h62330sbB6VrfgaIZoJVaknOTOZF5glNZpziVeYrTWadJyEmgVJbWqtfGog0+DlVnaJ3sO+Fq42rygKYClwlpToHr0MVDTN4wGYBf7/kVT7ur78X674ZjfB55Blc7S/56IUwdqFidwhz4ZQbEbdS99hoME78GW+dGu0VeVjpxkT9hdmwtPfL3VwlixdKMWOtACrqOosut/8ClvUej3VfRPCgpKyEhJ4FT2bpAdjrrNKeyTpGYk0iZLKtVz8bcBi87LzrZd8Lb3ptO9p3oZNcJLzuvG3Y4pwpcJqQ5Ba6P//6YpTFL8bH3YfW41VeVzS8uZeBbm8kpLGXOcF+eDOt6g7xsJqSfgh8fhPTy4+aDZsCIt8Ds+nXIyM66xPFtKzA/sY5e+fuwEld67WmlIM6iO9keYbgPuAePboHQRFNEiutPcVkx8TnxnM46zcnMk7qgln2apNwktFJbq55A4N7aHW87XTDTP9t742Lt0qizNBW4TEhzClzjVo/jdPZpHu39KE8HPH1V2W/3JPDK6iNYmmvY9WKY6nxemZOb4OdHoCgbNBZw9/8g4KEb6kJebhZxO35BE7sa39w92FB131CaaEei8xCs/UbhG3QnVtY2N9Q/RdOkuKyYxJxE4nPiOZt9lrPZZ/X/vlqFI+jW0bztvPG298bLzgtvO2887TzxauNF61b1PyVCBS4T0lwCV2JOIqNWjQJg+cjl9HGpfQ1Gq5UM+3A7Zy5e5r5AD96Z0PD1mhaFlLDzY9j0GiDBth3c9x14DjCpW8WFBcTt3cjlmHV4pkfiRtW2RJelFcdt+lPcaSiegaPp0FltIFdURUrJpcJL+mB2NvssZ3POEp8dT2peqsGejZX55q5v6NeuX73u4XTIxQAAIABJREFUqTYgK+pka9JWAJytnfFzvvrhj5EnL3Lmoq5Z7LTB3tfbteZBcT6sfQqO/Kx77R6gC1r2pi9YaWVljV/IPyDkH0itlriYvaT/vRanlC10LTmh2+xcsBNid0Lsf0gWbqQ6B2PV/Q58brkTWztVpXizI4TA2doZZ2tnbml/S5VrhaWFJOQk6GdmCTkJ+te5xbkAdGzd0RRu61GBq4WyJXELACEdQ+rcwPjlzngAgn2c6N7e7nq71vTJStKtZ507rHvt/wDc/RFY3JhF7PogNBp8/Qfh6z8IgMwLycTvXoU8vYXOOftwII+OMo2OF1fCxZWURJoR26onme6Daes3nK59B2Nh0crE70LRlLAyt9J3B6mMlJKsoiwSchJwtm68gqSGoAJXCySzMJODFw8CEOYZdlXZUxdyiYy7CMAjt3a67r41eRJ2wU9TID8dhAaGvwkDH282hQ9t23Wk7dingKcoKy3lxOFdpB/cgH3aX3QrPoaFKKNnSQwkxEDCInLXW3PUpg9FHYJx6T0M714D0ZirjwVFTYQQtLVqW2cTgxuBUb+hQghL4HVgCtAWOAS8JKXcbIRuB+BDYDigAbYAz0opzxqQnQ7MAToBicDHUspPr8VmJZ0BwG5AAG2llE17keoaiEyORCu1WJtbM8Dt6usxX5XPtrycbAjr3u4GeNeEifoCNr4A2lKwcoB7l4HPUFN71WDMzM3pFjCEbgFDAMjOyuBM1EZK4jbjfmkXHbVptBEF9C3YC6f2wqkPyV1lwxkbfwo6BOPsdzudeg3ATAUyRRPD2N/IZcB44CPgFDAV2CiECJFS7q5NSQjRGtgKtAHeBEqBZ4FtQoi+UsrMSrIzgc+ACOB/wG3AQiGElZTyg4bYrKQjgE+AfMDWyPfcbKlY37rV/VYszWqvDszKL+aXv1MAmBrsffOe3ltarAtY0V/pXrv0gAe+B8fOpvWrkbF3cKTfHZPgjkkAXEw+SUL0H8izf9EhKxp3LtCGfPzzd8P/t3fm8VFW5+L/PtkTErKSPSGsBlEERFARRWu1Wmvdq1VxbW3totYu97a12k9rb7W3t61WrrVqvWqrRX9Xr1Wp1gouyFJBFhWULRCyQBaykUySmTm/P847MAwzYRJIZiZ5vp/PfCbnvOc87/OezDvPnPM+53k2L4fNv6b1f0exNW0arsKTyKqcx/hpp6nHohJxDmu4RGQ2cCV2RvNbp+5J4EPgPuD0PrrfCkwETjTGfOD0Xez0vQP4iVOXijVC/2eMucLp+0cRiQPuFpFHjTGt/ZEZwHVOn8eAbx/ummMZl9vFe7XvAXBmed+zhWf/VU1Xr4f05AQuOzGyD1sjRsceWLQAdjq/vyovgIsfhuSMyOo1BIwpncSY0knANzDGsHPbJmrW/oP4He9S3raaQhrJlH3M7FoO25fD9gfoeTWBTUmTaRszk9TxcymfPp/MvOJIX4oywghnxnUZ0As86qswxrhE5DHgXhEpMsbU9dF3hc/AOH03icg/gSs4YGTOBHKBhQH9HwKuBs4Dnu2nTABEJAP4D+Ae5xzDmpV1K+lydxEnccwrmReyndvj5cn3qgC4YlYZGSkjMNV8zRr46zXQZmedzP8hnP49iBt5EUNEhPIJUyifMAX4NhhD3Y5PqFv7Ot4dyylsWUupqSVJ3FT2fgy1H0Pt0/AuVEsxdaOn4SmdQ96UeYw7ZjoJiSPw86QMGeEYrhnAJmNM4G61VdjnRdOBQwyXM1uaBjwSROYq4LMikmaM6XTOAfB+QLvVgNc5/mw/Zfq4C2gF/hv4ccirPKD34Z59RXXSHN8y4Yz8GX0+RH3to93UtroQscuEI471i6y7u9sFSelw8R9gygWR1ip6EKGoopKiikp8ixTNu3dRtXYprm3LyGr6gIm9m0kSN2WmlrLWWmj9O3zk7CNLnkxH7gmkVMyi9LjTyCueEDMOLkr0E47hKgJqgtT7jFWodYIcIJkgRs2pE0f2Vue92xjT7N/IGNMjIk1+5+iPTERkEnAbcKkxxh3pIJODjdd49yeNPLOs72XCPy2zfixnTymgPHcEPbPweuCNu+G9B205exxc9QzkT4msXjFATkEpOedeA9j4l12d+9i4YRmtn7xDSv1qxnZuIJs2RomL43rWQ916qHsKlkMTWexKq6RrzHRSx82mdOpccscURvaClJglHMOVCgTLS+3yOx6qH2H2TQV6QshxBbQLVyZYz8O3jTEvh5B9CIfb1e3MyKJy1rWhcQNNLpvj6ayy0G7w63e18P4O68Nyw9yKoVAtOujaC8/fBFsdZ9jxZ8Jlj0NaTmT1ilFS00YxZc45MOccAIzXy+7qT6n58F16dr7P6Ob1jOvZTKr0kEsLuZ0rYMcK2PEwLIVdFFI/6hh6xhxH+tiZlB47h5wCDRysHJ5wDFcXdpYTSIrf8VD9CLNvqHP42vq3C0umiHwO+BwHliGHPUt22mXCiVkTKRsd+gvA5wJfWZjBKeOH/WM/y55NNulj8zZbPuWbcPZPIV5dvY8WEhdHwdhKCsZWAjcD0N3TzaaPV7N38wriateQ1/YhY907SBAvpdRTuq8e9r0FVcBb0EA29amT6cqbSlLpdPInz6Zo7DHICHzuqIQmnLu2Drv8FoivrjZEv2bszChUX8OBJb86IElEcvyXC0UkCetQ4TtHf2TeD7wEtItIhVPnm02Vi0hqH04lMYnv+VZfy4R72ly8vN4O541zx0U8R8+QsOkVm46kpwPik+HCB+GEL0VaqxFBclIyldNPhemn7q9zdbaz7aMVtG5ZiexeT277J5S5d5IgXsawlzFdK6F6JVQDy6HNpFGdNIHWrCnEFU0jq2I65cdMJ23U8Pf8VIITjuFaC9wmIukBDhq+na3rgnUyxnhFZAMwK8jhOcBmPyeKtc77LOB1v3azsBuM1w5AZjlwPHBxkLbrgJXAycF0j0V2tO1gW6udTcwvmx+y3dMrdtDrMeSMSuLC6cPcjdnrtQkfl9xryxnFNuljyczI6jXCSUnLYPJJn4WTPru/ztW1j60bV9O85V+Y+vXktG1ibO82UqWH0dLJ1N4N0LABGhbBevAYYWdcEU1pE+jJrSSldBr5E6ZTMPZYjfwxAgjnP/w8NprFzdgNyL5IGjcAy4wxtU5dOZBmjNkU0Pc/RGSG356rY4CzgF/6tXsTO5u6lYMN19eBDmDxAGReDQT65F4JfAn7dLk6jGuPGXzLhGNSx4QMquvq9fDnlTsBuHpOOSmJ8UOm35DT3QEvfh02vmTLZXPgiqcgoyCyeilBSUkdZSN8zDywLdTd20vV1g00bXkfd81a0vd+TJFrKzm0ES+GclNL+b5a2PeOjbPzHrhMIjUJ5TSnT6Q3dwqpJceRP3EmRaXjiIvX5cbhwmENlzFmpYg8B9wvIj6PveuAsdgIGj6eBM7Aevb5WAh8BXhVRH6NjXLxHexy3m/8ztElIncBD4nIIqzxmoc1MD8ICM8UrsxXAq9FRKY7f74y3EI++ZYJzygLHVT3pXW1NO3rITFeuObksUOp3tDSvB2evRr2fGTLM6+D838FCZpjLJZISEykonImFZUHz5D37qmh9pP3adu5nriGjWS1b6bUvYNR0k2K9DLBs5UJrVuh9TXYBrwDHSaV2oRSWtPH48mZSErxsYwZdzyFY6cQr0GGY45w59QLgJ8579nAeuB8Y8yyvjoZY9pFZD7WoNyFXfZbAtxujGkKaLtQRHqBO4EvYmdEtxljHhiozJFCs6t5f1DdUM+3jDE8/q51gf/88UUUjI6+SOdHhW1L4bnrrQdhXAKcdx/Mukn3EA0jsvNLyM4vwX5NWHrdbqq2f0Lz9g9w1XxIcvMm8vZtocRTQ4J4SZcuJns2Q+tma9C2A8ugx8RTE19Mc2oFrqwJxOdXMrpsKkUTj2e0pn+JWjSRZD+JxkSSL255kbuW3UVqQirvXPlO0PiEy7c2cdUfVwDw0jfnMq30iHO5RRfGwIr/htd/DMYDabl2abBibqQ1UyKIu7uLuu0f0lj1IT11G4lv3kJ253aK3btIlVA7cCz15LInqYx96WMx2RNILZxETtkUiioqSUoJtQtICYUmklQOwvd867SS00IG1X3c2XB84tjs4We0el3w8h2w7i+2XHg8XPkXyCqPrF5KxElITqWs8iTKKg9Oluh2u6neuYU929bhqttEfPNmRndsp6h3J9m0AVBIE4U9TdC81j6B32r7eoxQFzeGpuRSujIqMDkTSCmYRHZZJQXlx5CUPExXM6IINVwxjsvtYnmdDRAbyptwZ1Mnb2zcDQzDDcdtdfDXq6FmtS1PvQS++BAkjaBoIEq/SUhIoGx8JWXjKw851tpYR/22DXTs+ghP4xaSWreT1VVNkaeOZOklXgxFZg9Frj3gWgMNwCe2r9vEURM3hsakUjtTy6ogOX8CmUUTKRw7mYxM3ex+NFDDFeOsqFtBl7uLeInn9JLggfqfeK8KY6A4M4XPTR1GYXaqV9kguR27AYGz74a5t+vzLOWIyMwrIjOvCGafc1C91+OhdtdWGndspKPuU0zTVlLbq8hxVVPsrSdJ3CSIlxKzm5Lu3dC9GprYP1MD2MtoGhIK6UgtwT26nPjccaTmjye7dDJjiseTkKQOROGghivG8Q+qm5Vy6BJgu6uXRe9bz/9rT6kgYbi4BK95Cl75Dnh6IDkTLn0UJp9z+H6KMkDi4uMpHjuZ4rGTDznm7u2ltmYbzTs30ln/CTRtI6W9itGuWgo89fufp2XTRra7Ddo/hXYOigLrNnHUxuXRnFjEvrRSx7BVkJ4/jpziCYwpHkuiRt0H1HDFNOEE1X1+9S46ut2kJMZx1exhEAfO0wuv/QhW/cGWcyfZILl5kyKrlzKiSUhMpLjiGIorjjnkmPF6aWqooWHnJ7TXb6GnsYqElh2kddaQ21tLgWkkXgwJ4qXY7KG4Zw/0rIMW7P40h14TT53ksDepkM7UQjzpJcRnl5OWX0Fm4XhyS8aTMioqw6geddRwxTDrG9bT7LIRsoIljfR6DU84ObcumVlKVlqM71fZ1wTPXQdV79jypHPh0j9Cysi4WZXYROLiyC0oI7egDDj7kOMul4uaXVtoqd2Ca89WvM1VJLVXk9FVQ567fr+zSKJ4KKKBop4G6NlgkzUF5O1oIZ2m+HzakgvpTivCO7qMhJwyRo2pILtoHLmFZSQnxfj3AGq4YhrfMuHErImUZRw6m3pz0x52NNkIWDfEes6t+g3w7JehxfkJOu9OOPNHEDeMo38oI4KUlBTKJx5H+cTgEW+6u9pp3LWVvXXb6WyowrO3moT2XaR21ZHVs5t800iSeADIooMsTwd0boNOoBG7CdvBbeLYLVm0JIxhX1I+PaMKIaOIhOxS0seUkVlQQV5xBYnJ0e3cpIYrhjlcUN0/vWdd4OdNymNSQQwHJP3oBXjxVujthMQ06zV43CWR1kpRhoTk1AxKJk2nZNL0oMd7et3U1O2kpX47nQ3bcTftRNp2kdJZR0Z3PXmePWRiw8wmiJcCmilwN4P7E2vcGg6V2UIGe+NzaU/Kx5VagDe9mPjMYpJzy0jPL6N43HGkpEbOuKnhilGqWqvY3moNUzDDtam+jWVbbCCRG08bN6S6HTW8Xhsg953/tOXMchskt2haZPVSlCgiKTGBkvLxlJSPD9nG1dFCU10Vrbt30NW0k969tUh7Lcmdu0nv2UO2p5FcWve3z6KdLE87dFXZRFHNB8v79MKXmDzzjEG5nnBQwxWj+GZbY1LHMDVv6iHHn3Bybo3PG8UZk8YMpWpHB1erTUXy6d9tuWIeXP4EjMqLqFqKEoukpGf1OWsD6OrspLF+Jy31VXQ1V+PeW4O015K0r55R3XvIcjeQa/aSKB6yCyMb61QNV4ziM1zzy+YfElS3eV8PL3xgn9reMLeCuLgY29fUuMUmfWz81JZn3wLn3gvx6gqsKINFalpayE3ZPrweD40NNeSOKRlCzQ5FDVcM0uxqZu2e0EF1n1m1k263l4yUBC6ZWTrU6h0Zm/8Bz98E3a0QlwgX/BfMXBBprRRFwe5lyyuMfCg1NVwxyFvVb2EwpCWkMadozkHHej1enlxeBcBVs8sZlRwj/2JjYNnv4I17AAPpBfClp6FsdqQ1UxQlyoiRbzXFH98y4dySuSTFH7wn49UNdexu6yZOYMEpMZJzq6cTXvoWfPi8LRfPtE4Yo4d5hmZFUQaEGq4Yo8vdxfJaG1Q32DLh445TxrlTCynNju69GAC0VNv9WfXrbfmEL8MFv4FEjbCtKEpw1HDFGCtqV+DyuGxQ3dKDg+qu2bmXddU2T9gNc2PABb5qGSxaAJ2NIHFwzr1w8tc1SK6iKH2ihivG8C0TziyYSWbywaGOfBmOjysZzUkVUZ699V+PwuIfgNcNKVnW1X1C8I3UiqIo/qjhiiE8Xg9v7XoLOHSZsK61i8Uf1gNww6njkGidtbh7YPH3YPUTtpx/rH2elRN686SiKIo/arhiiA2NG/YH1Q1MGvnk8h14vIa89GQuOKEoAtqFQcce+Ou1UL3Clqd8AS56GJLTI6uXoigxhRquGOLN6jeBQ4PqdvV4eGaVDT57zcnlJCdEYeDZmjU26WObE876zB/BvO9C3DDJD6YoypChhiuGWLIzeFDdFz6ooaWzl6T4OK6eE4Uu8Ov+Cn/7NrhdkJQOF/8BplwQaa0URYlR1HDFCNtbt1PVVgXAWeVn7a83xvCnZdYp4wsnFDMmI4pSf3s98Mbd8N6Dtpw9ziZ9zJ8SWb0URYlp1HDFCD5vwvzUfI7NPXZ//btbGtm8x6YsuGFuRSRUC07XXnj+RthqlzeZcBZc+hik5URWL0VRYh41XDHC0uqlwKFBdf/kbDiePS6H40qiJBPwno3wzFWw184EOfVb8Jl7IF4/boqiHDn6TRIDNHU1HQiqW37g+db2xn28uWkPADdGy4bjTa/YdCQ9HRCfDBc+CCd8KdJaKYoyjFDDFQO8vevt/UF1ZxceCDr7hPNsqzQ7lc8eWxAp9SxeL7z9K1j6C1seXWKD5JbMjKxeiqIMO8LyRRaRZBG5T0RqRaRLRFaIyGfC7FsiIotEpEVE2kTkRREJOj0QkZtEZKOIuETkUxH5xkBlikiZiNwjIqtEZK+INIrIknD1jiZ8bvD+QXVbu3p5bvUuAK4/tYL4SObc6u6A5xYcMFplJ8NXlqjRUhRlUAh3E80TwB3A08BtgBdYLCKn9NVJRNKBJcA84F7gbmAmsFREsgPa3gI8CmwAvgWsAH4vIncOUOYXge8DW4AfAz8DRgNviMi1YV53xOlyd7Gi1m7Y9XeDf+79ajp7PKQlxXP5rLJQ3Qef5u3w2Gdh499seeZ1cN3fICPCM0BFUYYth10qFJHZwJXAHcaY3zp1TwIfAvcBp/fR/VZgInCiMeYDp+9ip+8dwE+culSsEfo/Y8wVTt8/ikgccLeIPGqMae2PTKxxKzfGNPpdy8PAWqwRe+pw1x4NLK9dfkhQXY/X8MR7VQBcfmIpmakRygy8dQk8f4P1IIxLgPPug1k3aZBcRVEGlXBmXJcBvdjZEADGGBfwGHCaiPQVX+gyYIXPwDh9NwH/BK7wa3cmkAssDOj/EJABnNdfmcaYj/yNllPXDbwKjHWMZdTj8yY8seDE/UF1//Hxbnbt7QLgulMrhl4pY2D5Qnj6Emu00vJgwUtw0s1qtBRFGXTCMVwzgE3GmI6A+lWAANODdXJmS9OA94McXgVMFhFfwqgZzntg29XYZckZA5AZikKgA3CF0LulrxcwZD7noYLq+jYcn1WZz/gxQxznr9cFL94Kr/07GC8UToOvLoWKuUOrh6IoI5ZwDFcRUBek3lcXKk1tDpDcR19xZPvO0W2MafZvZIzpAZr8ztEfmYcgIhOBS4DnjTEmVLtoYX3j+kOC6n5U28rK7bZuyDcct9XCE+fDur/Y8nGXwo2vQVYEn7EpijLiCMcdPhXoDlLv8jseqh9h9k0FekLIcQW0C1fmQTgzseeAfcAPQ5wLY0xWqGOOnCGbdfliE07KnkRpRilwYMPxpPx0TpuYNxRqWKpX2SC5HbsBgbPvhrm369KgoihDTjiGqws7ywkkxe94qH6E2TfUOXxt/duFK3M/IhIPPAtMAc41xgSbsUUdvjBPvmXChvZuXlpbC9gMx0OWc2vNU/DKd8DTA8mZcOmjMPmcoTm3oihKAOEYrjqCL7/56mpD9GvGzoxC9TUcWPKrA5JEJMd/uVBEkrBOG75z9EemP38EPg9cZYx5K4S+UcW21m0HguqW2aC6f1m5kx6Pl6y0RC6eUTL4Snh64bUfwqpHbDlvMlz5DORNHPxzK4qihCCcZ1xrgUpn/5Q/c5z3dcE6GWO82D1Zs4IcngNsNsZ0+p2DIG1nOTquHYBMAETkV8ANwO3GmEXBdI1GfN6E+Wk2qG6328NTK3YAcNXsclKTBjnn1r4meOriA0Zr8ufg5jfUaCmKEnHCMVzPA4nAzb4KEUnGGoNlxphap65cRCqD9D1ZRGb49T0GOAv7vMnHm9jZ1K0B/b+O9QBcPACZiMj3gO8CvzDGPBjGtUYN/rm3RIRX1tfR2NFNfJyw4JRBzrlVtx4emQ9V79jyvO/amVZKlATxVRRlRHPYpUJjzEoReQ6439mztRW4DhgLXO/X9EngDKxnn4+FwFeAV0Xk14Ab+A52Oe83fufoEpG7gIdEZBHwOjYyxjXAD4wxLf2VKSIXA/cDm4GNInJNwKW9YIzZd7jrjwSNXY2sa7AT2fll8zHG8LjjAn/ecYUUZQ7iFrSPXrDu7r2dkJgGFy2EqRcP3vkURVH6SbhBdhdgo00sALKB9cD5xphlfXUyxrSLyHysQbkLO8Nbgl22awpou1BEeoE7seGaqoHbjDEPDFDmCc77JIJHyRiH9TCMOnxBdUcljmJ24Wze37GXD2vaALjxtEGKAu/1wpKfwzu/tuXMcrjqL1B4/OCcT1EUZYCEZbicSBnfc16h2swPUb8LuDzM8/wR60hxuHaHlWmMuQe4J5zzRhu+ZcK5xTao7uPv2tnWCWVZzCzP7qvrwHC12lQkn/7dlivmweX/A6Nyj/65FEVRjhBNaxJldPZ2srxuOWBzb+3a28lrH9UDcONgbDhu3GyTPjZttuXZt8C590J8hOIfKoqiHAY1XFHG8rrldHu6iZd45pXM46F/7sBroGB0Mucf31dYyAGw+R/w/E3Q3QrxSfD5/4KZMRM4X1GUEYoarijD5wY/q2AWCYzi2VU7AVhwSgWJ8eFmoTkMxsCy38IbPwUMpBfYpI9lsw/bVVEUJdKo4YoiPF4Pb+96G7DehP+7ZhdtLjfJCXFcNbv86JykpxNe+iZ8+P9sueREa7RGhwo5qSiKEl2o4Yoi1jWs2x9U94zS+Vy3eAsAF88oIWdU0pGfoGUnPHs11K+35RO+DBf8BhJT+u6nKIoSRajhiiJ8sQknZ09mS10S2xqst/71R8Mpo+pdWLQAOptA4uGcn8PJX9cguYqixBxquKIEY8xBQXV9UeDnTsylsnD0kQiG9x+DxT8ArxtSs+HyJ2D8/CNVWVEUJSKo4YoStrduZ0ebjUU4KX0O//npHgBuOPUINhy7e+DV78Ka/7Hl/GPhyr9AziBtYlYURRkC1HBFCb7ZVn5aPm9tsFlbxuamcVZl/sAEtu+GRddC9UpbnvIFuOhhSB7ijMmKoihHGTVcUYLPcJ1adDrPvVYDwPWnVhAXN4BnUDVrrBNGu5MN5swf2UC5cUfJnV5RFCWCqOGKAhq7GlnfYD39PB1TcfV6yUhO4PJZZf0Xtu6v8NK3wNMNSelwySNQ+fmjrLGiKErkUMMVBbxV/db+oLpLPsgA3Fw+q4z05H78ezxueONuWP57W84Zb59n5U8ZFJ0VRVEihRquKMC3TDhh1CyWtboRscuEYdPZDM/fCNusHCacBZc9bj0IFUVRhhlquCJMZ28nK+pWALBnt80ufPaUAspz08ITsGejDZK710aQ59RvwWfugXj91yqKMjzRb7cI4x9Ud3NVCQA3zg3TXX3jy/DCLdDTAQkpcOGDMO2KQdRWURQl8qjhijC+3FujOYYWbxqVhRmcPD6n705eL7z9K1j6C1seXQJX/hmKZwyytoqiKJFHDVcE8Q+q61smvPG0cUhfYZi62+GFr8Gml2257GT40lOQPsD9XoqiKDGGGq4IsrZhLXu79wLQ3TqF3FFJXHhCH1Ham7fBM1+Gho22fOL1cN6vIOEoBOBVFEWJEdRwRRDfMiE9xRh3NlefXk5KYnzwxluXwHPXg6sF4hLgvPvhpJuGTFdFUZRoQQ1XhPAPqtvdOoXEeOGak8cGawgrFsLrPwbjhbQ8uOJJqJg7xBoriqJEB2q4IsT21u3sbLfZjd0dx/LFacXkjw7Ii9Xrgpdvh3XP2HLhNLupOGsAETUURVGGCWq4IsSb1W8C4O3NxOsq5obAnFtttTbeYO0aWz7uUrjw95AU5v4uRVGUYYoargjhWyZ0t09h1tgcppVmHThYvQr+eg107AYEzr4H5t6mSR8VRVFQwxURGrsa2dCwAbDLhDd8xm/D8Zon4ZU7wdMDyZlw2WMw6bMR0lRRFCX6UMMVAZZWL8VgMJ5k8hOO5dypBeDphdd+CKsesY3yJsOVz0DexMgqqyiKEmWo4YoA/6j6JwDujmO47tSJJLiarat71Tu2weTP2XQkKZmRU1JRFCVKCSuzoIgki8h9IlIrIl0iskJEPhNm3xIRWSQiLSLSJiIvikjQYHwicpOIbBQRl4h8KiLfGCqZQ0Vnbycr621WYumaytXlLfDImQeM1rzv2pmWGi1FUZSghDvjegK4FPgtsAW4HlgsImcYY5aH6iQi6cASIAO4F3ADdwBLRWS6MWavX9tbgIeB54D/AuYBvxeRFGPMrwdT5lCyrOY9PKZlBHUxAAAJ40lEQVQXY+L4fn48GX/+PLi7IDENLloIUy+OhFqKoigxgxhj+m4gMhtYCdxhjPmtU5cCfAjUGmNO76Pv94FfAicaYz5w6iqdvr8wxvzEqUsFqoF3jTEX+fV/GrgQKDPGtA6WzP4gIi2ZmZmZLS0t/e0KwI0v38m/ml6npDOdv+/+2FZmldv9WYXHD0imoihKtJOVlUVra2urMSbr8K37JpylwsuAXuBRX4UxxgU8BpwmIkWH6bvCZ2CcvpuAfwL++TfOBHKBhQH9H8LOrM4bZJlDgtvr5oPGZQBc22U3H1MxD76yVI2WoihKmIRjuGYAm4wxHQH1qwABpgfrJCJxwDTg/SCHVwGTRcS3m9aXjyOw7WrA6zs+GDKD6N3S1wsY8MOnxe8/h1v2AXBmZxfMvgWufQFG5Q5UpKIoyogjHMNVBNQFqffVhQpnngMk99FXHNm+c3QbY5r9GxljeoAmv3MMhswh4501dvJ3THcvhef/Ds6/H+ITh1oNRVGUmCYc54xUoDtIvcvveKh+hNk3FegJIccV0O5oyzyIw62/Hsms6wtn3U/mP2/DFF9C3MxrByJCURRlxBOO4erCznICSfE7HqofYfYNdQ5fW/92R1vmkDFv8inMm7xqqE+rKIoyrAhnqbCOA8tv/vjqakP0a8bOjEL1NRxY8qsDkkTkoJz1IpKEdbDwnWMwZCqKoigxRDiGay1Q6eyf8meO874uWCdjjBfYAMwKcngOsNkY0+l3DoK0neXouHawZCqKoiixRTiG63kgEbjZVyEiycANwDJjTK1TV+7spwrse7KIzPDrewxwFnZTsI83sbOpWwP6fx3oABYPskxFURQlRjjsBmQAEVkEXAT8BtgKXAecBJxpjFnmtFkKnGGMEb9+GcAHwCjg19goF9/BcaM3xjT5tb0Vu8fqOeB1bJSLBcAPjDH3D6bM/nCkG5AVRVFGIkdzA3K4IZ8WAD9z3rOB9cD5PqMVCmNMu4jMxxq8u7AzvCXA7f4Gxmm7UER6gTuBL2KjXtxmjHlgsGUqiqIosUNYMy7lADrjUhRF6T9Hc8alhqufiIgXkMxMjd6uKIoSLq2trQDGGBNWVpK+UMPVT0TEjV2ebBugCJ/F63eA3xGKjlf/0PHqHzpe/eNIxms04DXGHHEeSDVcQ4wTeeOwEToUi45X/9Dx6h86Xv0jWsbriKdsiqIoijKUqOFSFEVRYgo1XIqiKEpMoYZLURRFiSnUcCmKoigxhRouRVEUJaZQw6UoiqLEFLqPS1EURYkpdMalKIqixBRquBRFUZSYQg2XoiiKElOo4VIURVFiCjVcQ4SIJIvIfSJSKyJdIrJCRD4Tab0GAxGZLyImxKsyoO2pIvKuiHSKSL2I/E5E0oLIDHv8wpUZCUSkSER+KSJLRKTdGZP5IdpeKCJrRMQlIjtF5G4ROSSytohkicgjItIgIvtE5E0RmT5UMgebcMdMRKpCfOZ+GaTtsBwzETlJRB4SkY8dHXaKyLMiMjFI24jde0f8fWiM0dcQvIBngB7gfuCrwHtO+ZRI6zYI1zofMNgs1dcEvEb7tZsOdAHvA18Dfg64gL8NdPz6IzPCY7MZWOb8PT9Iu/MAL/AG8BXgAcADPBjQLs6R0wb8BPgG8BHQAkwYbJlRNmZVzv898DM3faSMGfA8UOfoeTPwY6AeaAemRMu9F67MkNc51B/CkfgCZjs32+1+dSnAFuDtSOs3CNfr+6K56DDtXgV2Ael+dTc7fc8ayPiFKzOCY5MB5Dp/X9THl/BHwGog3q/u586X5iS/uisCxxoYA+wFnhxsmVE2ZlXAi2HIG7ZjBpwKJAXUTXIMyBN+dRG79/ojM+R1DvWHcCS+sL8qevz/oU79v2N/zRVFWsejfL3zfTex86WTEKTNaKAX+EVAfRL21+HD/R2//siMhleoL2HgWKf+qwH1xU79v/nVLQJqcPZk+tX/AfvrP3GwZEbTmDnHqoAXgWQgrQ8ZI2rMHD1WAyudvyN674Urs6+XPuMaGmYAm4wxHQH1qwDBTrGHI09hb9ouEXldRI73O3Y8kIBdVtiPMaYHWIsdMx/hjl9/ZEYzPj0Dr6MW+4s2cGxWG+fO92MV9kfDRL92R1tmNHIOsA/YJyJbReSrQdqMqDETEQEKgEanKtL33hF/H6rhGhqKsOvOgfjqiodQl6GgB7vWfhvwReCn2OWBd0VkstOmyHkPNS7+YxLu+PVHZjQT6bGJ1c/reuBu4FLs86hG4A8i8m8B7UbamF0NlGBnhTAMPl+HeMYog0Iq0B2k3uV3fNhgjHkP+7DVx0si8jfsr7G7sTeS75pDjYv/mIQ7fv2RGc0c7jrSAtoejbEZiMyowhhzoX9ZRP4EvAvcJSL/bYxpdQ6NmDFzvHgfwo7DUwG6ROreO+Kx0hnX0NCFXXcPJMXv+LDGGLMO65nlc3n1XXOocfEfk3DHrz8yo5lIj82w+LwaYzzAb7EG5hS/QyNizESkEHgF6yByuTHGG6BLzH6+1HANDXUcmEr746urHUJdIkk1kOP87VsWCDUu/mMS7vj1R2Y0E+mxGU6f12rnPcevbtiPmYhkAouBTOBcY0y93+GY/3yp4Roa1gKVIpIeUD/HeV83xPpEivFAg/P3h4AbmOXfQESSsA9n1/pVhzt+/ZEZzfj0DLyOYqCUQ8fmROcBvD9zgA6si/FgyYwFxjvvDX51w3rMRCQF+BswGbjAGPNJQJNI33tH/n0YSRfNkfJy/iGB+xaSsRsq3420foNwvWOC1J2G3fvyuF/dYuwvYv99Hzc5Y3X2QMYvXJnR8KJv1+6N2GeC/vuHfuaM4WS/ui9x6P6hPOzy0NODLTNaxgw7o4oLqEtxvgTbAj4Pw3bMgHjg/7Cu6ef30S5i915/ZIbUP5IfwpH0wnr09AD3YXeKL3PKcyOt2yBc65vAy8APnWt9APvgdTdQ7tduplPvv9O+C3h1oOPXH5kRHJ8fO68/OzfwY075m35tLuDgiA2/c74sFwbIigeWcyBiw63YX7+twMSAtkddZrSMGXC988X3H8AtzmfvE6ft10bKmGGf6RngJQ6NIOJvVCN674UrM+R1RurmHWkv7K+/X2HXd13YPQtRNQM4itf6bWAl0IT95VcDPI6f0fJre5rzoe3CGrYHgFFHMn7hyozg+JgQr6qAdhcBHzjXW43dVhBsM3c28CjW/XsfsASYGeLcR11mNIwZcCJ2eWwX1mOtDViKXSoLJm9YjplzzeF+viJ27/VHZrCXZkBWFEVRYgp1zlAURVFiCjVciqIoSkyhhktRFEWJKdRwKYqiKDGFGi5FURQlplDDpSiKosQUargURVGUmEINl6IoihJTqOFSFEVRYgo1XIqiKEpM8f8BwEdro7d4fQAAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nbz8kqZLq2N7",
        "colab_type": "text"
      },
      "source": [
        "## Regularization"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FFVClVfQq42a",
        "colab_type": "text"
      },
      "source": [
        "### Label Smoothing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "79c5fdPYq8_H",
        "colab_type": "text"
      },
      "source": [
        "During training, we employed label smoothing of value $\\epsilon_{ls}=0.1$.  This hurts perplexity, as the model learns to be more unsure, but improves accuracy and BLEU score."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a_nElKFAq2ry",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class LabelSmoothing(nn.Module):\n",
        "    \"Implement label smoothing.\"\n",
        "    def __init__(self, size, padding_idx, smoothing=0.0):\n",
        "        super(LabelSmoothing, self).__init__()\n",
        "        self.criterion = nn.KLDivLoss(size_average=False)\n",
        "        self.padding_idx = padding_idx\n",
        "        self.confidence = 1.0 - smoothing\n",
        "        self.smoothing = smoothing\n",
        "        self.size = size\n",
        "        self.true_dist = None\n",
        "        \n",
        "    def forward(self, x, target):\n",
        "        assert x.size(1) == self.size\n",
        "        true_dist = x.data.clone()\n",
        "        true_dist.fill_(self.smoothing / (self.size - 2))\n",
        "        true_dist.scatter_(1, target.data.unsqueeze(1), self.confidence)\n",
        "        true_dist[:, self.padding_idx] = 0\n",
        "        mask = torch.nonzero(target.data == self.padding_idx)\n",
        "        if mask.dim() > 0:\n",
        "            true_dist.index_fill_(0, mask.squeeze(), 0.0)\n",
        "        self.true_dist = true_dist\n",
        "        return self.criterion(x, Variable(true_dist, requires_grad=False))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F6HHAQrzrHwK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 287
        },
        "outputId": "9dcd36e7-d8af-4dd8-8837-ccfa804ca3a5"
      },
      "source": [
        "#Example\n",
        "crit = LabelSmoothing(5, 0, 0.5)\n",
        "predict = torch.FloatTensor([[0, 0.2, 0.7, 0.1, 0],\n",
        "                             [0, 0.2, 0.7, 0.1, 0], \n",
        "                             [0, 0.2, 0.7, 0.1, 0]])\n",
        "v = crit(Variable(predict.log()), \n",
        "         Variable(torch.LongTensor([2, 1, 0])))\n",
        "\n",
        "# Show the target distributions expected by the system.\n",
        "plt.imshow(crit.true_dist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f55b673ee48>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Codt_uv_rKTJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "outputId": "a98d7d9f-90fb-411c-828f-8bd9e12847f4"
      },
      "source": [
        "# Label smoothing starts to penalize the model \n",
        "# if it gets very confident about a given choice\n",
        "crit = LabelSmoothing(5, 0, 0.1)\n",
        "def loss(x):\n",
        "    d = x + 3 * 1\n",
        "    predict = torch.FloatTensor([[0, x / d, 1 / d, 1 / d, 1 / d],\n",
        "                                 ])\n",
        "    #print(predict)\n",
        "    return crit(Variable(predict.log()),\n",
        "                 Variable(torch.LongTensor([1]))).data[0]\n",
        "plt.plot(np.arange(1, 100), [loss(x) for x in range(1, 100)])\n",
        "None"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DLe5dgJAuee0",
        "colab_type": "text"
      },
      "source": [
        "## Batches and Masking"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N2ZLz-V5uhnd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Batch:\n",
        "    def __init__(self, src, trg, src_mask, trg_mask, ntokens):\n",
        "        self.src = src\n",
        "        self.trg = trg\n",
        "        self.src_mask = src_mask\n",
        "        self.trg_mask = trg_mask\n",
        "        self.ntokens = ntokens\n",
        "    \n",
        "def make_std_mask(src, tgt, pad):\n",
        "    src_mask = (src != pad).unsqueeze(-2)\n",
        "    tgt_mask = (tgt != pad).unsqueeze(-2)\n",
        "    tgt_mask = tgt_mask & Variable(subsequent_mask(tgt.size(-1)).type_as(tgt_mask.data))\n",
        "    return src_mask, tgt_mask"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XCzQc15lVDQC",
        "colab_type": "text"
      },
      "source": [
        "## Backpropagating Loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yd3_syueVGuF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def loss_backprop(generator, criterion, out, targets, normalize, opt):\n",
        "    \"\"\"\n",
        "    Memory optmization. Compute each timestep separately and sum grads.\n",
        "    \"\"\"\n",
        "    assert out.size(1) == targets.size(1)\n",
        "    total = 0.0\n",
        "    out_grad = []\n",
        "    for i in range(out.size(1)):\n",
        "        out_column = Variable(out[:, i].data, requires_grad=True)\n",
        "        gen = generator(out_column)\n",
        "        loss = criterion(gen, targets[:, i]) / normalize\n",
        "        total += loss.data[0]\n",
        "        loss.backward()\n",
        "        out_grad.append(out_column.grad.data.clone())\n",
        "    out_grad = torch.stack(out_grad, dim=1)\n",
        "    if opt is not None:\n",
        "        out.backward(gradient=out_grad)\n",
        "    return total"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LfctgeHLJ71F",
        "colab_type": "text"
      },
      "source": [
        "## Training Loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tk-8ys4Eu10I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def train_epoch(train_iter, model, criterion, opt):\n",
        "    model.train()\n",
        "    for i, batch in enumerate(train_iter):\n",
        "        src, trg, src_mask, trg_mask = batch.src, batch.trg, batch.src_mask, batch.trg_mask\n",
        "        out = model.forward(src, trg[:, :-1], src_mask, trg_mask[:, :-1, :-1])\n",
        "        loss = loss_backprop(model.generator, criterion, out, trg[:, 1:], batch.ntokens, opt)                         \n",
        "        model_opt.step()\n",
        "        model_opt.optimizer.zero_grad()\n",
        "        if i % 100 == 0:\n",
        "            print(\"Epoch Step: %d Loss: %f\" % (i, loss / batch.ntokens, tokens / elapsed))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cZwQyIbqU-Fv",
        "colab_type": "text"
      },
      "source": [
        "## Validation Loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VMDxWCB4VAkt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def valid_epoch(valid_iter, model, criterion, opt=None):\n",
        "    model.eval()\n",
        "    total = 0\n",
        "    total_tokens = 0\n",
        "    for batch in valid_iter:\n",
        "        src, trg, src_mask, trg_mask = batch.src, batch.trg, batch.src_mask, batch.trg_mask\n",
        "        out = model.forward(src, trg[:, :-1], src_mask, trg_mask[:, :-1, :-1])\n",
        "        loss = loss_backprop(model.generator, criterion, out, trg[:, 1:], batch.ntokens, opt)\n",
        "        total_tokens += batch.ntokens\n",
        "        total += loss\n",
        "    print(\"Loss: %f\" % (total/total_tokens))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yWkMgrfIvCTq",
        "colab_type": "text"
      },
      "source": [
        "# A Real World Example"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i3ao-CrxvKDp",
        "colab_type": "text"
      },
      "source": [
        "Now we consider a real-world example using the IWSLT German-English Translation task. This task is much smaller than the WMT task considered in the paper, but it illustrates the whole system. We also show how to use multi-gpu processing to make it really fast."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1QdZKvX3vDRI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "d5fb7b82-e25f-474f-b43e-c78a4d809f28"
      },
      "source": [
        "!pip install torchtext spacy\n",
        "!python -m spacy download en\n",
        "!python -m spacy download de"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: torchtext in /usr/local/lib/python3.6/dist-packages (0.2.3)\n",
            "Requirement already satisfied: spacy in /usr/local/lib/python3.6/dist-packages (2.2.4)\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: setuptools in /usr/local/lib/python3.6/dist-packages (from spacy) (49.2.0)\n",
            "Requirement already satisfied: blis<0.5.0,>=0.4.0 in /usr/local/lib/python3.6/dist-packages (from spacy) (0.4.1)\n",
            "Requirement already satisfied: wasabi<1.1.0,>=0.4.0 in /usr/local/lib/python3.6/dist-packages (from spacy) (0.7.1)\n",
            "Requirement already satisfied: srsly<1.1.0,>=1.0.2 in /usr/local/lib/python3.6/dist-packages (from spacy) (1.0.2)\n",
            "Requirement already satisfied: numpy>=1.15.0 in /usr/local/lib/python3.6/dist-packages (from spacy) (1.18.5)\n",
            "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /usr/local/lib/python3.6/dist-packages (from spacy) (1.0.2)\n",
            "Requirement already satisfied: thinc==7.4.0 in /usr/local/lib/python3.6/dist-packages (from spacy) (7.4.0)\n",
            "Requirement already satisfied: catalogue<1.1.0,>=0.0.7 in /usr/local/lib/python3.6/dist-packages (from spacy) (1.0.0)\n",
            "Requirement already satisfied: plac<1.2.0,>=0.9.6 in /usr/local/lib/python3.6/dist-packages (from spacy) (1.1.3)\n",
            "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from spacy) (3.0.2)\n",
            "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /usr/local/lib/python3.6/dist-packages (from spacy) (2.0.3)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext) (2.10)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext) (2020.6.20)\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: chardet<4,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext) (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) (1.7.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) (3.1.0)\n",
            "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: 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.7.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: 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) (49.2.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: 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: 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: 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: 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: 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: 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: 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: 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: 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.6.20)\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.10)\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: 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.7.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 617kB/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: 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: 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: 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: 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: 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: 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: 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: 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: 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.7.1)\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) (49.2.0)\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: 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: 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.7.0)\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: 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: 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.10)\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.6.20)\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=2f7aac85fdd29ec85c4479a3c4e57c62be81a061e98f4b72f32ba1d7e7e70fcd\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-6lj5gqd9/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": "Xb1JeyCXvOxB",
        "colab_type": "text"
      },
      "source": [
        "## Data Loading"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fiA1jdmnvRaf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 381
        },
        "outputId": "6318ecf4-41d5-4b75-a8db-cd9fcd53dfde"
      },
      "source": [
        "# For data loading.\n",
        "from torchtext import data, datasets\n",
        "\n",
        "if True:\n",
        "    import spacy\n",
        "    spacy_de = spacy.load('de')\n",
        "    spacy_en = spacy.load('en')\n",
        "\n",
        "    def tokenize_de(text):\n",
        "        return [tok.text for tok in spacy_de.tokenizer(text)]\n",
        "\n",
        "    def tokenize_en(text):\n",
        "        return [tok.text for tok in spacy_en.tokenizer(text)]\n",
        "\n",
        "    BOS_WORD = '<s>'\n",
        "    EOS_WORD = '</s>'\n",
        "    BLANK_WORD = \"<blank>\"\n",
        "    SRC = data.Field(tokenize=tokenize_de, pad_token=BLANK_WORD)\n",
        "    TGT = data.Field(tokenize=tokenize_en, init_token = BOS_WORD, \n",
        "                     eos_token = EOS_WORD, pad_token=BLANK_WORD)\n",
        "\n",
        "    MAX_LEN = 100\n",
        "    train, val, test = datasets.IWSLT.splits(\n",
        "        exts=('.de', '.en'), fields=(SRC, TGT), \n",
        "        filter_pred=lambda x: len(vars(x)['src']) <= MAX_LEN and \n",
        "            len(vars(x)['trg']) <= MAX_LEN)\n",
        "    MIN_FREQ = 2\n",
        "    SRC.build_vocab(train.src, min_freq=MIN_FREQ)\n",
        "    TGT.build_vocab(train.trg, min_freq=MIN_FREQ)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "downloading de-en.tgz\n",
            ".data/iwslt/de-en/IWSLT16.TED.dev2010.de-en.en.xml\n",
            ".data/iwslt/de-en/IWSLT16.TED.tst2013.de-en.en.xml\n",
            ".data/iwslt/de-en/IWSLT16.TEDX.tst2013.de-en.de.xml\n",
            ".data/iwslt/de-en/IWSLT16.TED.dev2010.de-en.de.xml\n",
            ".data/iwslt/de-en/IWSLT16.TEDX.tst2013.de-en.en.xml\n",
            ".data/iwslt/de-en/IWSLT16.TEDX.tst2014.de-en.de.xml\n",
            ".data/iwslt/de-en/IWSLT16.TED.tst2013.de-en.de.xml\n",
            ".data/iwslt/de-en/IWSLT16.TED.tst2011.de-en.en.xml\n",
            ".data/iwslt/de-en/IWSLT16.TED.tst2014.de-en.de.xml\n",
            ".data/iwslt/de-en/IWSLT16.TEDX.dev2012.de-en.de.xml\n",
            ".data/iwslt/de-en/IWSLT16.TED.tst2011.de-en.de.xml\n",
            ".data/iwslt/de-en/IWSLT16.TED.tst2010.de-en.en.xml\n",
            ".data/iwslt/de-en/IWSLT16.TED.tst2014.de-en.en.xml\n",
            ".data/iwslt/de-en/IWSLT16.TEDX.dev2012.de-en.en.xml\n",
            ".data/iwslt/de-en/IWSLT16.TED.tst2010.de-en.de.xml\n",
            ".data/iwslt/de-en/IWSLT16.TED.tst2012.de-en.de.xml\n",
            ".data/iwslt/de-en/IWSLT16.TEDX.tst2014.de-en.en.xml\n",
            ".data/iwslt/de-en/IWSLT16.TED.tst2012.de-en.en.xml\n",
            ".data/iwslt/de-en/train.tags.de-en.en\n",
            ".data/iwslt/de-en/train.tags.de-en.de\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HLCluzBevnjY",
        "colab_type": "text"
      },
      "source": [
        "Batching matters a ton for speed. We want to have very evenly divided batches, with absolutely minimal padding."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gAquNBaGvqGk",
        "colab_type": "text"
      },
      "source": [
        "## Batches and Iterators"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N83QS_hhvn4k",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "BATCH_SIZE = 4096\n",
        "global max_src_in_batch, max_tgt_in_batch\n",
        "def batch_size_fn(new, count, sofar):\n",
        "    \"Keep augmenting batch and calculate total number of tokens + padding.\"\n",
        "    global max_src_in_batch, max_tgt_in_batch\n",
        "    if count == 1:\n",
        "        max_src_in_batch = 0\n",
        "        max_tgt_in_batch = 0\n",
        "    max_src_in_batch = max(max_src_in_batch,  len(new.src))\n",
        "    max_tgt_in_batch = max(max_tgt_in_batch,  len(new.trg) + 2)\n",
        "    src_elements = count * max_src_in_batch\n",
        "    tgt_elements = count * max_tgt_in_batch\n",
        "    return max(src_elements, tgt_elements)\n",
        "\n",
        "class MyIterator(data.Iterator):\n",
        "    def create_batches(self):\n",
        "        if self.train:\n",
        "            def pool(d, random_shuffler):\n",
        "                for p in data.batch(d, self.batch_size * 100):\n",
        "                    p_batch = data.batch(\n",
        "                        sorted(p, key=self.sort_key),\n",
        "                        self.batch_size, self.batch_size_fn)\n",
        "                    for b in random_shuffler(list(p_batch)):\n",
        "                        yield b\n",
        "            self.batches = pool(self.data(), self.random_shuffler)\n",
        "            \n",
        "        else:\n",
        "            self.batches = []\n",
        "            for b in data.batch(self.data(), self.batch_size,\n",
        "                                          self.batch_size_fn):\n",
        "                self.batches.append(sorted(b, key=self.sort_key))\n",
        "\n",
        "def rebatch(pad_idx, batch):\n",
        "    \"Fix order in torchtext to match ours\"\n",
        "    src, trg = batch.src.transpose(0, 1), batch.trg.transpose(0, 1)\n",
        "    src_mask, trg_mask = make_std_mask(src, trg, pad_idx)\n",
        "    return Batch(src, trg, src_mask, trg_mask, (trg[1:] != pad_idx).data.sum())\n",
        "\n",
        "train_iter = MyIterator(train, batch_size=BATCH_SIZE, device=0,\n",
        "                        repeat=False, sort_key=lambda x: (len(x.src), len(x.trg)),\n",
        "                        batch_size_fn=batch_size_fn, train=True)\n",
        "valid_iter = MyIterator(val, batch_size=BATCH_SIZE, device=0,\n",
        "                        repeat=False, sort_key=lambda x: (len(x.src), len(x.trg)),\n",
        "                        batch_size_fn=batch_size_fn, train=False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IVWRdftpyz99",
        "colab_type": "text"
      },
      "source": [
        "## Greedy Decoding"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GJSO93Coy94D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def greedy_decode(model, src, src_mask, max_len, start_symbol):\n",
        "    memory = model.encode(src, src_mask)\n",
        "    ys = torch.ones(1, 1).fill_(start_symbol).type_as(src.data)\n",
        "    for i in range(max_len-1):\n",
        "        out = model.decode(memory, src_mask, \n",
        "                           Variable(ys), \n",
        "                           Variable(subsequent_mask(ys.size(1))\n",
        "                                    .type_as(src.data)))\n",
        "        prob = model.generator(out[:, -1])\n",
        "        _, next_word = torch.max(prob, dim = 1)\n",
        "        next_word = next_word.data[0]\n",
        "        ys = torch.cat([ys, \n",
        "                        torch.ones(1, 1).type_as(src.data).fill_(next_word)], dim=1)\n",
        "    return ys"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KKmzWkuZx41A",
        "colab_type": "text"
      },
      "source": [
        "## Training the System"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sZNI8Lejx-MB",
        "colab_type": "text"
      },
      "source": [
        "Load pretrained model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m84U8tEBx0xx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 208
        },
        "outputId": "e1317e0e-6f0d-4110-8136-3a2073598780"
      },
      "source": [
        "!wget https://s3.amazonaws.com/opennmt-models/en-de-model.pt"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2020-08-14 09:53:14--  https://s3.amazonaws.com/opennmt-models/en-de-model.pt\n",
            "Resolving s3.amazonaws.com (s3.amazonaws.com)... 52.216.146.237\n",
            "Connecting to s3.amazonaws.com (s3.amazonaws.com)|52.216.146.237|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 393031182 (375M) [application/x-www-form-urlencoded]\n",
            "Saving to: ‘en-de-model.pt’\n",
            "\n",
            "en-de-model.pt      100%[===================>] 374.82M  35.8MB/s    in 11s     \n",
            "\n",
            "2020-08-14 09:53:26 (33.6 MB/s) - ‘en-de-model.pt’ saved [393031182/393031182]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YqTVQtlAyJOh",
        "colab_type": "text"
      },
      "source": [
        "or \n",
        "\n",
        "Train the model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sA3x7qhsyFUo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "num_epochs = 20\n",
        "train = False\n",
        "\n",
        "if train:\n",
        "    pad_idx = TGT.vocab.stoi[\"<blank>\"]\n",
        "    model = make_model(len(SRC.vocab), len(TGT.vocab), N=6)\n",
        "    model_opt = get_std_opt(model)\n",
        "    model.cuda()\n",
        "    criterion = LabelSmoothing(size=len(TGT.vocab), padding_idx=pad_idx, smoothing=0.1)\n",
        "    criterion.cuda()\n",
        "    for epoch in range(num_epochs):\n",
        "        train_epoch((rebatch(pad_idx, b) for b in train_iter), model, criterion, model_opt)\n",
        "        valid_epoch((rebatch(pad_idx, b) for b in valid_iter), model, criterion)\n",
        "else:\n",
        "    model, SRC, TGT = torch.load(\"en-de-model.pt\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-QwdvIE_zFLk",
        "colab_type": "text"
      },
      "source": [
        "Once trained we can decode the model to produce a set of translations. Here we simply translate the given sentence from the dataset. This dataset is pretty small so the translations with greedy search are reasonably accurate."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s2KWQtmMzFqB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "b4f7f417-a33a-4ef8-c05b-6f3c0a146f8d"
      },
      "source": [
        "sentence = \"▁The ▁log ▁file ▁can ▁be ▁sent ▁with ▁email ▁or ▁FTP ▁to ▁a ▁specified ▁receiver\"\n",
        "model.eval()\n",
        "sent = sentence.split()\n",
        "src = torch.LongTensor([[SRC.stoi[w] for w in sent]])\n",
        "src = Variable(src)\n",
        "src_mask = (src != SRC.stoi[\"<blank>\"]).unsqueeze(-2)\n",
        "out = greedy_decode(model, src, src_mask, \n",
        "                    max_len=60, start_symbol=TGT.stoi[\"<s>\"])\n",
        "print(\"Translation:\", end=\"\\t\")\n",
        "trans = \"<s> \"\n",
        "for i in range(1, out.size(1)):\n",
        "    sym = TGT.itos[out[0, i]]\n",
        "    if sym == \"</s>\": break\n",
        "    trans += sym + \" \"\n",
        "print(trans)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Translation:\t<s> ▁Die ▁Protokoll datei ▁kann ▁per ▁E - Mail ▁oder ▁FTP ▁an ▁einen ▁bestimmte n ▁Empfänger ▁gesendet ▁werden . \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RxKCE2GaY4Vl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}