transformer_code_review.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.5.2"
    },
    "colab": {
      "name": "code_review.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "2kwnw6yu2y57",
        "Y_vWK-rR2y6W"
      ]
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5T-MlJPZP1w5",
        "colab_type": "text"
      },
      "source": [
        "![alt text](https://daiwk.github.io/assets/tensor2tensor-variants.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lex7SNa4T1Zb",
        "colab_type": "text"
      },
      "source": [
        "* $d_{\\text{model}}=512$\n",
        "\n",
        "  트랜스포머의 인코더와 디코더에서의 정해진 입력과 출력의 크기를 의미합니다. 즉, 임베딩 벡터의 크기 또한 dmodel이며, 각 인코더와 디코더가 다음 층의 인코더와 디코더로 값을 보낼 때에도 이 크기를 가집니다. 논문에서는 512의 크기를 가졌습니다.\n",
        "\n",
        "* $num_{\\text{layers}} = 6$\n",
        "\n",
        "  트랜스포머에서 하나의 인코더와 디코더를 층으로 생각하였을 때, 트랜스포머 모델에서 인코더와 디코더가 총 몇 층으로 구성되었는지를 의미합니다. 논문에서는 인코더와 디코더를 각각 총 6개 쌓았습니다.\n",
        "\n",
        "* $num_{\\text{heads}} = 8$\n",
        "\n",
        "  트랜스포머에서는 어텐션을 사용할 때, 1번 하는 것 보다 여러 개로 분할해서 병렬로 어텐션을 수행하고 결과값을 다시 하나로 합치는 방식을 택했습니다. 이때 이 병렬의 개수를 의미합니다.\n",
        "\n",
        "* $d_{\\text{ff}}=2048 $\n",
        "\n",
        "  트랜스포머 내부에는 피드 포워드 신경망이 존재합니다. 이때 은닉층의 크기를 의미합니다. 피드 포워드 신경망의 입력층과 출력층의 크기는 dmodel의 크기를 가집니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1m1Lgqf_XkZS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "490e3996-ccd3-44a0-c121-7e93684b3948"
      },
      "source": [
        "\"\"\"\n",
        "src_vocab=58,790 #len(SRC.vocab)\n",
        "tgt_vocab=36,323 #len(TGT.vocab)\n",
        "N=6, \n",
        "d_model=512\n",
        "d_ff=2048\n",
        "h=8\n",
        "dropout=0.1\n",
        "\"\"\""
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'\\nsrc_vocab=58,790 #len(SRC.vocab)\\ntgt_vocab=36,323 #len(TGT.vocab)\\nN=6, \\nd_model=512\\nd_ff=2048\\nh=8\\ndropout=0.1\\n'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "89nyS8lL2y46",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#from IPython.display import Image\n",
        "#Image(filename='images/aiayn.png')"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "10ZHLkwS2y4-",
        "colab_type": "text"
      },
      "source": [
        "The Transformer from [\"Attention is All You Need\"](https://arxiv.org/abs/1706.03762) has been on a lot of people's minds over the last year. Besides producing major improvements in translation quality, it provides a new architecture for many other NLP tasks. The paper itself is very clearly written, but the conventional wisdom has been that it is quite difficult to implement correctly. \n",
        "\n",
        "In this post I present an \"annotated\" version of the paper in the form of a line-by-line implementation. I have reordered and deleted some sections from the original paper and added comments throughout. This document itself is a working notebook, and should be a completely usable implementation. In total there are 400 lines of library code which can process 27,000 tokens per second on 4 GPUs. \n",
        "\n",
        "To follow along you will first need to install [PyTorch](http://pytorch.org/). The complete notebook is also available on [github](https://github.com/harvardnlp/annotated-transformer) or on Google [Colab](https://drive.google.com/file/d/1xQXSv6mtAOLXxEMi8RvaW8TW-7bvYBDF/view?usp=sharing). \n",
        "\n",
        "Note this is merely a starting point for researchers and interested developers. The code here is based heavily on our [OpenNMT](http://opennmt.net) packages. (If helpful feel free to [cite](#conclusion).) For other full-sevice implementations of the model check-out [Tensor2Tensor](https://github.com/tensorflow/tensor2tensor) (tensorflow) and [Sockeye](https://github.com/awslabs/sockeye) (mxnet).\n",
        "\n",
        "- Alexander Rush ([@harvardnlp](https://twitter.com/harvardnlp) or srush@seas.harvard.edu)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lA9Pips32y4_",
        "colab_type": "text"
      },
      "source": [
        "# Prelims"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PWFJzW0Q2y4_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# !pip install http://download.pytorch.org/whl/cu80/torch-0.3.0.post4-cp36-cp36m-linux_x86_64.whl numpy matplotlib spacy torchtext seaborn "
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SsyzwTHC2y5C",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "f3efd461-03b6-41ed-c9af-f02390606c84"
      },
      "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": 4,
      "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": "rAVawwsT2y5F",
        "colab_type": "text"
      },
      "source": [
        "Table of Contents\n",
        "\n",
        "\n",
        "* Table of Contents                               \n",
        "{:toc}      "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gOX4IOou2y5G",
        "colab_type": "text"
      },
      "source": [
        "> My comments are blockquoted. The main text is all from the paper itself."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FFCFoOol2y5G",
        "colab_type": "text"
      },
      "source": [
        "# Background"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t9TDvaf52y5H",
        "colab_type": "text"
      },
      "source": [
        "The goal of reducing sequential computation also forms the foundation of the Extended Neural GPU, ByteNet and ConvS2S, all of which use convolutional neural networks as basic building block, computing hidden representations in parallel for all input and output positions. In these models, the number of operations required to relate signals from two arbitrary input or output positions grows in the distance between positions, linearly for ConvS2S and logarithmically for ByteNet. This makes it more difficult to learn dependencies between distant positions. In the Transformer this is reduced to a constant number of operations, albeit at the cost of reduced effective resolution due to averaging attention-weighted positions, an effect we counteract with Multi-Head Attention.\n",
        "\n",
        "Self-attention, sometimes called intra-attention is an attention mechanism relating different positions of a single sequence in order to compute a representation of the sequence. Self-attention has been used successfully in a variety of tasks including reading comprehension, abstractive summarization, textual entailment and learning task-independent sentence representations. End-to-end memory networks are based on a recurrent attention mechanism instead of sequencealigned recurrence and have been shown to perform well on simple-language question answering and\n",
        "language modeling tasks.\n",
        "\n",
        "To the best of our knowledge, however, the Transformer is the first transduction model relying entirely on self-attention to compute representations of its input and output without using sequence aligned RNNs or convolution. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "py8t1ajv2y5I",
        "colab_type": "text"
      },
      "source": [
        "# Model Architecture"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x3tfwZfI2y5I",
        "colab_type": "text"
      },
      "source": [
        "Most competitive neural sequence transduction models have an encoder-decoder structure [(cite)](https://arxiv.org/abs/1409.0473). 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 [(cite)](https://arxiv.org/abs/1308.0850), consuming the previously generated symbols as additional input when generating the next. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rjydtmNX2y5J",
        "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",
        "        output = self.decode(self.encode(src, src_mask), src_mask,\n",
        "                            tgt, tgt_mask)\n",
        "        return output\n",
        "\n",
        "    def encode(self, src, src_mask):\n",
        "        output = self.encoder(self.src_embed(src), src_mask) \n",
        "        return output\n",
        "    \n",
        "    def decode(self, memory, src_mask, tgt, tgt_mask):\n",
        "        output = self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)\n",
        "        return output"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KIWfsor12y5M",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Generator(nn.Module):\n",
        "    \"Define standard linear + softmax generation step.\"\n",
        "    \"\"\"\n",
        "    d_model=512\n",
        "    len(TGT.vocab)=36,323\n",
        "    \"\"\"\n",
        "    def __init__(self, d_model, vocab):\n",
        "        super(Generator, self).__init__()\n",
        "        self.proj = nn.Linear(d_model, vocab)\n",
        "        print(\"self.proj:\", self.proj)\n",
        "\n",
        "    def forward(self, x):\n",
        "        output = F.log_softmax(self.proj(x), dim=-1) #-1 마지막 차원\n",
        "        return output"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YE45Sb8Dtcnx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "ae19ee5f-3d58-4107-c076-4ad0e0567413"
      },
      "source": [
        "generator = Generator(512, 36323)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "self.proj: Linear(in_features=512, out_features=36323, bias=True)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-zkfb8sZ2y5P",
        "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": "code",
      "metadata": {
        "id": "v8HFmLyV2y5Q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Image(filename='images/ModalNet-21.png')"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pPV_R59q2y5S",
        "colab_type": "text"
      },
      "source": [
        "## Encoder and Decoder Stacks   "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Sy_7P8aerbi",
        "colab_type": "text"
      },
      "source": [
        "### Encoder\n",
        "\n",
        "The encoder is composed of a stack of $N=6$ identical layers. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vQtg486N2y5T",
        "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": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kAlpFT6x2y5W",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Encoder는 EncoderLayer를 6개 쌓고 + LayerNorm을 수행\n",
        "class Encoder(nn.Module):\n",
        "    \"Core encoder is a stack of N layers\"\n",
        "    \"\"\"\n",
        "    layer = EncoderLayer(d_model, c(attn), c(ff), dropout), N) #d_model=512, N=6\n",
        "    N = 6\n",
        "    \"\"\"\n",
        "    def __init__(self, layer, N):\n",
        "        super(Encoder, self).__init__()\n",
        "        self.layers = clones(layer, N)\n",
        "        print(\"Encoder layers\", self.layers)\n",
        "        self.norm = LayerNorm(layer.size)\n",
        "        print(\"Encoder norm\", self.norm)\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",
        "        output = self.norm(x)\n",
        "        return output"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "roQ1FSui2y5Z",
        "colab_type": "text"
      },
      "source": [
        "We employ a residual connection [(cite)](https://arxiv.org/abs/1512.03385) around each of the two sub-layers, followed by layer normalization [(cite)](https://arxiv.org/abs/1607.06450).  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gPXndV5tN8X-",
        "colab_type": "text"
      },
      "source": [
        "![alt text](https://yonghyuc.files.wordpress.com/2020/03/bn_vs_ln.png)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iNaECjA_2y5Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class LayerNorm(nn.Module):\n",
        "    \"Construct a layernorm module (See citation for details).\"\n",
        "    # features = d_model = 512\n",
        "    def __init__(self, features, eps=1e-6): \n",
        "        super(LayerNorm, self).__init__()\n",
        "        self.a_2 = nn.Parameter(torch.ones(features)) # features = d_model = 512\n",
        "        self.b_2 = nn.Parameter(torch.zeros(features)) # features = d_model = 512\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",
        "        norm = self.a_2 * (x - mean) / (std + self.eps) + self.b_2\n",
        "        print(\"norm:\", norm.shape)\n",
        "        return norm"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iCIPoOXn2y5c",
        "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 [(cite)](http://jmlr.org/papers/v15/srivastava14a.html) 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": "markdown",
      "metadata": {
        "id": "e3nWZPX14XWN",
        "colab_type": "text"
      },
      "source": [
        "$\\mathrm{LayerNorm}(x + \\mathrm{Sublayer}(x))$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PuZEgCn52y5d",
        "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",
        "    \"\"\"\n",
        "    1) x를 normalization한 후,\n",
        "    2) sublayer(encoder or decoder block)에 입력 후,\n",
        "    3) 출력값에 대해 dropout한 뒤,\n",
        "    4) x를 다시 더해줘서 residual 수행  \n",
        "    # d_model = 512\n",
        "    # dropout = 0.1\n",
        "    \"\"\"\n",
        "    def __init__(self, size, dropout): \n",
        "        super(SublayerConnection, self).__init__()\n",
        "        self.norm = LayerNorm(size) # size = 512\n",
        "        self.dropout = nn.Dropout(dropout) # dropout = 0.1\n",
        "\n",
        "    def forward(self, x, sublayer):\n",
        "        \"Apply residual connection to any sublayer with the same size.\"\n",
        "        output = x + self.dropout(sublayer(self.norm(x)))  \n",
        "        return output"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WIwqYF582y5g",
        "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": "b2UfFplg2y5g",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class EncoderLayer(nn.Module):\n",
        "    \"Encoder is made up of self-attn and feed forward (defined below)\"\n",
        "    \"\"\"\n",
        "    size = d_model= 512\n",
        "    self_attn = MultiHeadedAttention(h, d_model) # h=8, d_model=512\n",
        "    feed_forward = PositionwiseFeedForward(d_model, d_ff, dropout)  # d_model=512, d_ff=2048, dropout=0.1\n",
        "    dropout=0.1\n",
        "    N=6\n",
        "    \"\"\"    \n",
        "    def __init__(self, size, self_attn, feed_forward, dropout):\n",
        "        super(EncoderLayer, self).__init__()\n",
        "        self.self_attn = self_attn # MultiHeadedAttention(8, 512)\n",
        "        self.feed_forward = feed_forward # PositionwiseFeedForward(512, 2048, 0.1)\n",
        "        self.sublayer = clones(SublayerConnection(size, dropout), 2) # SublayerConnection(512, 0.1) \n",
        "        self.size = size # size = d_model= 512 ??\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)) # MultiHeadedAttention\n",
        "        output = self.sublayer[1](x, self.feed_forward) #feed-forward\n",
        "        return output"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dJfc6DPy2y5j",
        "colab_type": "text"
      },
      "source": [
        "### Decoder\n",
        "\n",
        "The decoder is also composed of a stack of $N=6$ identical layers.  \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g3_Y1iv62y5j",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Decoder(nn.Module):\n",
        "    \"Generic N layer decoder with masking.\"\n",
        "    \"\"\"\n",
        "    layer=DecoderLayer(d_model, c(attn), c(attn), c(ff), dropout), N) \n",
        "    N=6\n",
        "    \"\"\"\n",
        "    def __init__(self, layer, N):\n",
        "        super(Decoder, self).__init__()\n",
        "        self.layers = clones(layer, N)\n",
        "        self.norm = LayerNorm(layer.size) #DecoderLayer(512, c(attn), c(attn), c(ff), 0.1), 6)\n",
        "        print(\"decodeLayer size:\", 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",
        "        output = self.norm(x) \n",
        "        return output"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tykxroZO2y5m",
        "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": "vuS4cLAQ2y5n",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class DecoderLayer(nn.Module):\n",
        "    \"Decoder is made of self-attn, src-attn, and feed forward (defined below)\"\n",
        "    \"\"\"\n",
        "    self_attn = MultiHeadedAttention(h, d_model) # h=8, d_model=512\n",
        "    src_attn = MultiHeadedAttention(h, d_model) # h=8, d_model=512\n",
        "    feed_forward = PositionwiseFeedForward(d_model, d_ff, dropout)  # d_model=512, d_ff=2048, dropout=0.1\n",
        "    size = d_model = 512\n",
        "    dropout=0.1\n",
        "    \"\"\"\n",
        "    def __init__(self, size, self_attn, src_attn, feed_forward, dropout):\n",
        "        super(DecoderLayer, self).__init__()\n",
        "        self.size = size # size = d_model = 512\n",
        "        self.self_attn = self_attn # MultiHeadedAttention(8, 512)\n",
        "        self.src_attn = src_attn # MultiHeadedAttention(8, 512)\n",
        "        self.feed_forward = feed_forward #PositionwiseFeedForward(512, 2048, 0.1)\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)) # masked self-attention\n",
        "        x = self.sublayer[1](x, lambda x: self.src_attn(x, m, m, src_mask)) # encoder-decoder self-attention\n",
        "        output = self.sublayer[2](x, self.feed_forward)\n",
        "        return output"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "JZvGhxIn2y5p",
        "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": "markdown",
      "metadata": {
        "id": "wVOzGV93EdaZ",
        "colab_type": "text"
      },
      "source": [
        "![alt text](https://lh3.googleusercontent.com/proxy/wGLnY9-hrQ1SDa9jB-8mOtPl-2Q0huHN2ocBYKD2gL4T4_6chStXpDh1NlGNDisiSthYBV6sLHEFfM1ifs-uXPOct07uQM245jRNyMtgXl-681O7old8crGTIPzh6nQAj2aOR7Ti0J8Wy6NYfmnPiWRX_pl2J16WTDriMYySZdG1qNe0Ekuk2nRaQiR8OrZYYVLeoRUvNH2M)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FHFAR4Hq2y5q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 하삼각행렬\n",
        "# subsequent_mask(tgt.size(-1))\n",
        "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",
        "    output = torch.from_numpy(subsequent_mask) == 0\n",
        "    return output"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ENMtYrx8pAA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 745
        },
        "outputId": "b95dea23-c961-4167-b48c-4db5e9876936"
      },
      "source": [
        "subsequent_mask(20).shape #torch.Size([1, 20, 20])\n",
        "subsequent_mask(20)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[ True, False, False, False, False, False, False, False, False, False,\n",
              "          False, False, False, False, False, False, False, False, False, False],\n",
              "         [ True,  True, False, False, False, False, False, False, False, False,\n",
              "          False, False, False, False, False, False, False, False, False, False],\n",
              "         [ True,  True,  True, False, False, False, False, False, False, False,\n",
              "          False, False, False, False, False, False, False, False, False, False],\n",
              "         [ True,  True,  True,  True, False, False, False, False, False, False,\n",
              "          False, False, False, False, False, False, False, False, False, False],\n",
              "         [ True,  True,  True,  True,  True, False, False, False, False, False,\n",
              "          False, False, False, False, False, False, False, False, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True, False, False, False, False,\n",
              "          False, False, False, False, False, False, False, False, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True, False, False, False,\n",
              "          False, False, False, False, False, False, False, False, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True,  True, False, False,\n",
              "          False, False, False, False, False, False, False, False, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True,  True,  True, False,\n",
              "          False, False, False, False, False, False, False, False, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "          False, False, False, False, False, False, False, False, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "           True, False, False, False, False, False, False, False, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "           True,  True, False, False, False, False, False, False, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "           True,  True,  True, False, False, False, False, False, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "           True,  True,  True,  True, False, False, False, False, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "           True,  True,  True,  True,  True, False, False, False, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "           True,  True,  True,  True,  True,  True, False, False, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "           True,  True,  True,  True,  True,  True,  True, False, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "           True,  True,  True,  True,  True,  True,  True,  True, False, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "           True,  True,  True,  True,  True,  True,  True,  True,  True, False],\n",
              "         [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "           True,  True,  True,  True,  True,  True,  True,  True,  True,  True]]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Pk8me1o2y5s",
        "colab_type": "text"
      },
      "source": [
        "> Below the attention mask shows the position each tgt word (row) is allowed to look at (column). Words are blocked for attending to future words during training."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3H_OIxVn2y5t",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 333
        },
        "outputId": "178d55ca-33fb-488a-aa24-d0b663663ae3"
      },
      "source": [
        "plt.figure(figsize=(5,5))\n",
        "plt.imshow(subsequent_mask(20)[0])\n",
        "None"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "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": "UGd-Uw1F2y5v",
        "colab_type": "text"
      },
      "source": [
        "### Attention                                                                                                                                                                                                                                                                             \n",
        "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.                                                                                                                                                                                                                                  \n",
        "                                                                                                                                                                     "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zjFIRQo_2y5w",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Image(filename='images/ModalNet-19.png')"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sRV3Ssov2y5y",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "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": "LwNBI-6Y2y5y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#x, self.attn = attention(query, key, value, mask=mask, dropout=self.dropout)\n",
        "def attention(query, key, value, mask=None, dropout=None):\n",
        "    \"Compute 'Scaled Dot Product Attention'\"\n",
        "    d_k = query.size(-1)\n",
        "    print(\"attention d_k:\", d_k)\n",
        "\n",
        "    #1. score by matmuling query and the transposed key and dividing by sqrt of d_k \n",
        "    scores = torch.matmul(query, key.transpose(-2, -1)) \\\n",
        "             / math.sqrt(d_k)\n",
        "\n",
        "    #(option) fill mask\n",
        "    if mask is not None:\n",
        "        scores = scores.masked_fill(mask == 0, -1e9)\n",
        "    \n",
        "    #2. softmax\n",
        "    p_attn = F.softmax(scores, dim = -1)\n",
        "\n",
        "    #3. dropout\n",
        "    if dropout is not None:\n",
        "        p_attn = dropout(p_attn)\n",
        "\n",
        "    #4. mutiplied by value \n",
        "    output = torch.matmul(p_attn, value)\n",
        "\n",
        "    return output, p_attn"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1q7gtnv_2y51",
        "colab_type": "text"
      },
      "source": [
        "The two most commonly used attention functions are additive attention [(cite)](https://arxiv.org/abs/1409.0473), 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$ [(cite)](https://arxiv.org/abs/1703.03906). 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": "JQl2QqmqLPqD",
        "colab_type": "text"
      },
      "source": [
        "https://pretteyandnerdy.wordpress.com/2019/04/26/attention-is-all-you-need/\n",
        "![alt text](https://lh4.googleusercontent.com/v5ymE2USvWBpBG19EzqsZgf1GqRkW8Lf34YXLM3Bm2peou8DHT2fMDs2ALTWXwbA74AwPvye0c3siWol0yiPfcX3eQ4NQGL6b9qA-Efv5RQPfIj_Us0RW6Qx5uiEaQSui6RMOGSfL4o)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LZLONAiY2y51",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Image(filename='images/ModalNet-20.png')"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MLQeQHQG2y54",
        "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",
        "\\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}}}$.                                                                                                                                                                                             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": "markdown",
      "metadata": {
        "id": "IXw7vm2VSjDe",
        "colab_type": "text"
      },
      "source": [
        "![대체 텍스트](https://image.slidesharecdn.com/pytorchtutorial-2017-1103-171103060015/95/update-pytorch-tutorial-for-ntu-machine-learing-course-2017-48-638.jpg?cb=1509688980)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rx3ot9_PSMN2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "50b91c02-7334-4da6-c5db-fea717682991"
      },
      "source": [
        "d_model=512\n",
        "linear_layer = nn.Linear(d_model, d_model)#, 4) # 512*512\n",
        "linear_layer"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Linear(in_features=512, out_features=512, bias=True)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZWSlIAPq2y54",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#h=8, d_model=512\n",
        "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 #512/8 = 64\n",
        "        self.h = h\n",
        "        # 4 weights -> query, key, value, concat \n",
        "        self.linears = clones(nn.Linear(d_model, d_model), 4) # 512*512\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 = 8 x 64\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",
        "        print(\"query:\", query.shape)\n",
        "        print(\"key:\", key.shape)\n",
        "        print(\"value:\", value.shape)\n",
        "        \n",
        "        # 2) Apply attention on all the projected vectors in batch. \n",
        "        x, self.attn = attention(query, key, value, mask=mask, #attention 함수\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",
        "        \n",
        "        output = self.linears[-1](x)\n",
        "        return output"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IuQKt8vVQ4GL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 181
        },
        "outputId": "cbbf4006-8373-4364-84bb-caa47286505d"
      },
      "source": [
        "#h=8, d_model=512\n",
        "attn = MultiHeadedAttention(8, 512)\n",
        "attn"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MultiHeadedAttention(\n",
              "  (linears): ModuleList(\n",
              "    (0): Linear(in_features=512, out_features=512, bias=True)\n",
              "    (1): Linear(in_features=512, out_features=512, bias=True)\n",
              "    (2): Linear(in_features=512, out_features=512, bias=True)\n",
              "    (3): Linear(in_features=512, out_features=512, bias=True)\n",
              "  )\n",
              "  (dropout): Dropout(p=0.1, inplace=False)\n",
              ")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2kwnw6yu2y57",
        "colab_type": "text"
      },
      "source": [
        "### Applications of Attention in our Model                                                                                                                                                      \n",
        "The Transformer uses multi-head attention in three different ways:                                                        \n",
        "1) In \"encoder-decoder attention\" layers, the queries come from the previous decoder layer, and the memory keys and values come from the output of the encoder.   This allows every position in the decoder to attend over all positions in the input sequence.  This mimics the typical encoder-decoder attention mechanisms in sequence-to-sequence models such as [(cite)](https://arxiv.org/abs/1609.08144).    \n",
        "\n",
        "\n",
        "2) The encoder contains self-attention layers.  In a self-attention layer all of the keys, values and queries come from the same place, in this case, the output of the previous layer in the encoder.   Each position in the encoder can attend to all positions in the previous layer of the encoder.                                                   \n",
        "\n",
        "\n",
        "3) Similarly, self-attention layers in the decoder allow each position in the decoder to attend to all positions in the decoder up to and including that position.  We need to prevent leftward information flow in the decoder to preserve the auto-regressive property.  We implement this inside of scaled dot-product attention by masking out (setting to $-\\infty$) all values in the input of the softmax which correspond to illegal connections.                                                                                                                                                                                                                                                      "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "duY0F06u2y58",
        "colab_type": "text"
      },
      "source": [
        "## Position-wise Feed-Forward Networks                                                                                                                                                                                                                                                                                                                                                             \n",
        "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \n",
        "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": "markdown",
      "metadata": {
        "id": "6Xqu5DNIMyTN",
        "colab_type": "text"
      },
      "source": [
        "$$\\mathrm{FFN}(x)=\\max(0, xW_1 + b_1) W_2 + b_2$$                                        "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H5LSJWio2y58",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class PositionwiseFeedForward(nn.Module):\n",
        "    \"Implements FFN equation.\"\n",
        "    \"\"\"\n",
        "    d_model=512\n",
        "    d_ff=2048\n",
        "    dropout=0.1\n",
        "    \"\"\"\n",
        "    def __init__(self, d_model, d_ff, dropout=0.1):\n",
        "        super(PositionwiseFeedForward, self).__init__()\n",
        "        \n",
        "        self.w_1 = nn.Linear(d_model, d_ff) #d_model=512, d_ff=2048 -> liner layer has not shape()\n",
        "        print(\"w_1:\", self.w_1)\n",
        "        self.w_2 = nn.Linear(d_ff, d_model) #d_ff=2048, d_model=512\n",
        "        print(\"w_2:\", self.w_2)\n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "\n",
        "    def forward(self, x):\n",
        "        output = self.w_2(self.dropout(F.relu(self.w_1(x)))) #bias???\n",
        "        return output"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NH5xLJNQq_8s",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 145
        },
        "outputId": "f3bd41a0-2450-43f8-81e6-353facb2ef2f"
      },
      "source": [
        "ff = PositionwiseFeedForward(512, 2048, 0.1)\n",
        "ff"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "w_1: Linear(in_features=512, out_features=2048, bias=True)\n",
            "w_2: Linear(in_features=2048, out_features=512, bias=True)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "PositionwiseFeedForward(\n",
              "  (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
              "  (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
              "  (dropout): Dropout(p=0.1, inplace=False)\n",
              ")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UK_AI3UY2y5_",
        "colab_type": "text"
      },
      "source": [
        "## (순서1) Embeddings and Softmax                                                                                                                                                                                                                                                                                           \n",
        "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, similar to [(cite)](https://arxiv.org/abs/1608.05859). In the embedding layers, we multiply those weights by $\\sqrt{d_{\\text{model}}}$.                                                                                                                                 "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "13Dm5lwlkxOC",
        "colab_type": "text"
      },
      "source": [
        "![대체 텍스트](https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&fname=http%3A%2F%2Fcfile22.uf.tistory.com%2Fimage%2F9948BD4E5B5022961C43D7)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0SSckiwu2y5_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Embeddings(nn.Module):\n",
        "    \"\"\"\n",
        "    d_model = 512\n",
        "    vocab = 58790\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, d_model, vocab): \n",
        "        super(Embeddings, self).__init__()\n",
        "        \"\"\"\n",
        "        num_embeddings (int): size of the dictionary of embeddings  \n",
        "        embedding_dim (int): the size of each embedding vector  \n",
        "        \"\"\"\n",
        "        self.lut = nn.Embedding(vocab, d_model) #vocab = 58790, d_model = 512\n",
        "        self.d_model = d_model #d_model = 512\n",
        "\n",
        "    def forward(self, x):\n",
        "        output = self.lut(x) * math.sqrt(self.d_model)\n",
        "        return output"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TbCWVlrEXbzs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "outputId": "005f2b65-c2cb-4fc2-edc6-2b7c50600822"
      },
      "source": [
        "#src_vocab=58,790 #len(SRC.vocab)\n",
        "#tgt_vocab=36,323 #len(TGT.vocab)\n",
        "#N=6, \n",
        "#d_model=512\n",
        "#d_ff=2048\n",
        "#h=8\n",
        "#dropout=0.1\n",
        "src_embeddings = Embeddings(512, 58790)\n",
        "src_embeddings"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Embeddings(\n",
              "  (lut): Embedding(58790, 512)\n",
              ")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hEby-sId2y6B",
        "colab_type": "text"
      },
      "source": [
        "## (순서2) Positional Encoding                                                                                                                             \n",
        "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 [(cite)](https://arxiv.org/pdf/1705.03122.pdf). \n",
        "\n",
        "In this work, we use sine and cosine functions of different frequencies:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \n",
        "$$PE_{(pos,2i)} = sin(pos / 10000^{2i/d_{\\text{model}}})$$\n",
        "\n",
        "$$PE_{(pos,2i+1)} = cos(pos / 10000^{2i/d_{\\text{model}}})$$                                                                                                                                                                                                                                                        \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$. \n",
        "                                                                                                                                                                                                                                                    \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9geFjl6ndRvW",
        "colab_type": "text"
      },
      "source": [
        "![대체 텍스트](https://static.packt-cdn.com/products/9781788834131/graphics/B09475_01_20.jpg)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aJhRARZdocYQ",
        "colab_type": "text"
      },
      "source": [
        "## Positional Encoding\n",
        "\n",
        "Unlike the recurrent layer, both the multi-head attention layer and the position-wise feed-forward network compute the output of each item in the sequence independently. This feature enables us to parallelize the computation, but it fails to model the sequential information for a given sequence. To better capture the sequential information, the Transformer model uses the *positional encoding* to maintain the positional information of the input sequence.\n",
        "\n",
        "To explain, assume that $X\\in\\mathbb R^{l\\times d}$ is the embedding of an example, where $l$ is the sequence length and $d$ is the embedding size. This positional encoding layer encodes X's position $P\\in\\mathbb R^{l\\times d}$ and outputs $P+X$.\n",
        "\n",
        "The position $P$ is a 2-D matrix, where $i$ refers to the order in the sentence, and $j$ refers to the position along the embedding vector dimension. In this way, each value in the origin sequence is then maintained using the equations below:\n",
        "\n",
        "$$P_{i, 2j} = \\sin(i/10000^{2j/d}),$$\n",
        "\n",
        "$$\\quad P_{i, 2j+1} = \\cos(i/10000^{2j/d}),$$\n",
        "\n",
        "for $i=0,\\ldots, l-1$ and $j=0,\\ldots,\\lfloor(d-1)/2\\rfloor$.\n",
        "\n",
        "\n",
        ":numref:`fig_positional_encoding` illustrates the positional encoding.\n",
        "\n",
        "![Positional encoding.](http://d2l.ai/_images/positional_encoding.svg)\n",
        ":label:`fig_positional_encoding`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iTmLS3R_Nb3s",
        "colab_type": "text"
      },
      "source": [
        "$$P_{i, 2j} = \\sin(i/10000^{2j/d}),$$\n",
        "\n",
        "$$\\quad P_{i, 2j+1} = \\cos(i/10000^{2j/d}),$$\n",
        "\n",
        "for $i=0,\\ldots, l-1$ and $j=0,\\ldots,\\lfloor(d-1)/2\\rfloor$."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6QWCNuJg2y6C",
        "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) #shape: torch.Size([5000, 512])\n",
        "        \n",
        "        position = torch.arange(0, max_len).unsqueeze(1) #shape: torch.Size([5000, 1])\n",
        "        div_term = torch.exp(torch.arange(0, d_model, 2) *\n",
        "                             -(math.log(10000.0) / d_model)) #shape: torch.Size([256])\n",
        "        param = position * div_term #shape: torch.Size([5000, 256])\n",
        "        print(\"sin/cos parameter:\", param.shape)\n",
        "\n",
        "        pe[:, 0::2] = torch.sin(param)\n",
        "        pe[:, 1::2] = torch.cos(param) #shape: torch.Size([5000, 512])\n",
        "        \n",
        "        pe = pe.unsqueeze(0) #torch.Size([1, 5000, 512])\n",
        "        \n",
        "        self.register_buffer('pe', pe)\n",
        "        \n",
        "    def forward(self, x):\n",
        "        var = Variable(self.pe[:, :x.size(1)], requires_grad=False) #torch.Size([1, x.size(1), 512])\n",
        "        print(\"PE forward var:\", var.shape)\n",
        "        print(\"PE forward var:\", var)\n",
        "        x = x + var\n",
        "        output = self.dropout(x)\n",
        "        return output"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BlCHVXStZPxw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        },
        "outputId": "cbd141f7-9ba0-4277-e576-64ef95671778"
      },
      "source": [
        "#src_vocab=58,790 #len(SRC.vocab)\n",
        "#tgt_vocab=36,323 #len(TGT.vocab)\n",
        "#N=6, \n",
        "#d_model=512\n",
        "#d_ff=2048\n",
        "#h=8\n",
        "#dropout=0.1\n",
        "pe = PositionalEncoding(512, 0.1)\n",
        "pe"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "sin/cos parameter: torch.Size([5000, 256])\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "PositionalEncoding(\n",
              "  (dropout): Dropout(p=0.1, inplace=False)\n",
              ")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A76fCUlv2y6E",
        "colab_type": "text"
      },
      "source": [
        "> Below the positional encoding will add in a sine wave based on position. The frequency and offset of the wave is different for each dimension. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tuq9jgVj2y6E",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 605
        },
        "outputId": "b97a721a-2651-4517-89ad-439bc0030fd5"
      },
      "source": [
        "plt.figure(figsize=(15, 5))\n",
        "pe = PositionalEncoding(20, 0) #d_model = 20, dropout = 0\n",
        "y = pe.forward(Variable(torch.zeros(1, 100, 20))) #x =(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": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "sin/cos parameter: torch.Size([5000, 10])\n",
            "PE forward var: torch.Size([1, 100, 20])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  3.8767e-01,  ...,  1.0000e+00,\n",
            "           2.5119e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  7.1471e-01,  ...,  1.0000e+00,\n",
            "           5.0238e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 3.7961e-01, -9.2515e-01,  7.9395e-01,  ...,  9.9813e-01,\n",
            "           2.4363e-02,  9.9970e-01],\n",
            "         [-5.7338e-01, -8.1929e-01,  9.6756e-01,  ...,  9.9809e-01,\n",
            "           2.4614e-02,  9.9970e-01],\n",
            "         [-9.9921e-01,  3.9821e-02,  9.8984e-01,  ...,  9.9805e-01,\n",
            "           2.4865e-02,  9.9969e-01]]])\n"
          ],
          "name": "stdout"
        },
        {
          "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": "code",
      "metadata": {
        "id": "oCBdCR4dhp2o",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 351
        },
        "outputId": "b5d330c6-6b9a-4421-ff39-ac3deae2c6a2"
      },
      "source": [
        "plt.figure(figsize=(15, 5))\n",
        "plt.plot(np.arange(100), y[0, :, 0:4].data.numpy())\n",
        "plt.legend([\"dim %d\"%p for p in [0,1,2,3]])"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fed24e66400>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        },
        {
          "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": "code",
      "metadata": {
        "id": "QyNoB_5xiL9T",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 351
        },
        "outputId": "49f1d16d-d358-49f0-e3f3-b19915b6d90e"
      },
      "source": [
        "plt.figure(figsize=(15, 5))\n",
        "plt.plot(np.arange(100), y[0, :, 8:12].data.numpy())\n",
        "plt.legend([\"dim %d\"%p for p in [8,9,10,11]])"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fed235f2278>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        },
        {
          "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": "yMC-aBG52y6G",
        "colab_type": "text"
      },
      "source": [
        "We also experimented with using learned positional embeddings [(cite)](https://arxiv.org/pdf/1705.03122.pdf) instead, and found that the two versions produced nearly identical results.  We chose the sinusoidal version because it may allow the model to extrapolate to sequence lengths longer than the ones encountered during training.    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Ca9kXjb2y6H",
        "colab_type": "text"
      },
      "source": [
        "## Full Model\n",
        "\n",
        "> Here we define a function from hyperparameters to a full model. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8imTd2BA2y6H",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def make_model(src_vocab, tgt_vocab, N=6, \n",
        "               d_model=512, d_ff=2048, h=8, dropout=0.1):\n",
        "    \"\"\"\n",
        "    src_vocab: len(SRC.vocab)=58,790\n",
        "    tgt_vocab: len(TGT.vocab)=36,323 \n",
        "    N=6, \n",
        "    d_model=512\n",
        "    d_ff=2048\n",
        "    h=8\n",
        "    dropout=0.1\n",
        "    \"\"\"\n",
        "    \"Helper: Construct a model from hyperparameters.\"\n",
        "    c = copy.deepcopy\n",
        "   \n",
        "    attn = MultiHeadedAttention(h, d_model) # h=8, d_model=512\n",
        "    ff = PositionwiseFeedForward(d_model, d_ff, dropout)  # d_model=512, d_ff=2048, dropout=0.1\n",
        "    position = PositionalEncoding(d_model, dropout) # d_model=512, dropout=0.1\n",
        "   \n",
        "    model = EncoderDecoder(\n",
        "        # d_model=512, dropout=0.1, N=6\n",
        "        Encoder(EncoderLayer(d_model, c(attn), c(ff), dropout), N),\n",
        "        # d_model=512, dropout=0.1, N=6\n",
        "        Decoder(DecoderLayer(d_model, c(attn), c(attn), c(ff), dropout), N),\n",
        "        # d_model=512, len(SRC.vocab)=58,790\n",
        "        nn.Sequential(Embeddings(d_model, src_vocab), c(position)),\n",
        "        # d_model=512, len(TGT.vocab)=36,323\n",
        "        nn.Sequential(Embeddings(d_model, tgt_vocab), c(position)),\n",
        "        # d_model=512, len(TGT.vocab)=36,323\n",
        "        Generator(d_model, tgt_vocab))\n",
        "    \n",
        "    # This was important from their code. \n",
        "    # Initialize parameters with Glorot / fan_avg.\n",
        "    for p in model.parameters():\n",
        "        if p.dim() > 1:\n",
        "            nn.init.xavier_uniform(p)\n",
        "    return model"
      ],
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KTeyQxMn2y6K",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "461640dc-5140-467b-adb3-905d0d0dbb89"
      },
      "source": [
        "# Small example model.\n",
        "tmp_model = make_model(10, 10, 2)\n",
        "tmp_model"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "w_1: Linear(in_features=512, out_features=2048, bias=True)\n",
            "w_2: Linear(in_features=2048, out_features=512, bias=True)\n",
            "sin/cos parameter: torch.Size([5000, 256])\n",
            "Encoder layers ModuleList(\n",
            "  (0): EncoderLayer(\n",
            "    (self_attn): MultiHeadedAttention(\n",
            "      (linears): ModuleList(\n",
            "        (0): Linear(in_features=512, out_features=512, bias=True)\n",
            "        (1): Linear(in_features=512, out_features=512, bias=True)\n",
            "        (2): Linear(in_features=512, out_features=512, bias=True)\n",
            "        (3): Linear(in_features=512, out_features=512, bias=True)\n",
            "      )\n",
            "      (dropout): Dropout(p=0.1, inplace=False)\n",
            "    )\n",
            "    (feed_forward): PositionwiseFeedForward(\n",
            "      (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
            "      (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
            "      (dropout): Dropout(p=0.1, inplace=False)\n",
            "    )\n",
            "    (sublayer): ModuleList(\n",
            "      (0): SublayerConnection(\n",
            "        (norm): LayerNorm()\n",
            "        (dropout): Dropout(p=0.1, inplace=False)\n",
            "      )\n",
            "      (1): SublayerConnection(\n",
            "        (norm): LayerNorm()\n",
            "        (dropout): Dropout(p=0.1, inplace=False)\n",
            "      )\n",
            "    )\n",
            "  )\n",
            "  (1): EncoderLayer(\n",
            "    (self_attn): MultiHeadedAttention(\n",
            "      (linears): ModuleList(\n",
            "        (0): Linear(in_features=512, out_features=512, bias=True)\n",
            "        (1): Linear(in_features=512, out_features=512, bias=True)\n",
            "        (2): Linear(in_features=512, out_features=512, bias=True)\n",
            "        (3): Linear(in_features=512, out_features=512, bias=True)\n",
            "      )\n",
            "      (dropout): Dropout(p=0.1, inplace=False)\n",
            "    )\n",
            "    (feed_forward): PositionwiseFeedForward(\n",
            "      (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
            "      (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
            "      (dropout): Dropout(p=0.1, inplace=False)\n",
            "    )\n",
            "    (sublayer): ModuleList(\n",
            "      (0): SublayerConnection(\n",
            "        (norm): LayerNorm()\n",
            "        (dropout): Dropout(p=0.1, inplace=False)\n",
            "      )\n",
            "      (1): SublayerConnection(\n",
            "        (norm): LayerNorm()\n",
            "        (dropout): Dropout(p=0.1, inplace=False)\n",
            "      )\n",
            "    )\n",
            "  )\n",
            ")\n",
            "Encoder norm LayerNorm()\n",
            "decodeLayer size: 512\n",
            "self.proj: Linear(in_features=512, out_features=10, bias=True)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:35: UserWarning: nn.init.xavier_uniform is now deprecated in favor of nn.init.xavier_uniform_.\n"
          ],
          "name": "stderr"
        },
        {
          "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, bias=True)\n",
              "            (1): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (2): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (3): Linear(in_features=512, out_features=512, bias=True)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (feed_forward): PositionwiseFeedForward(\n",
              "          (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
              "          (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (sublayer): ModuleList(\n",
              "          (0): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "          (1): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "      (1): EncoderLayer(\n",
              "        (self_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (1): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (2): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (3): Linear(in_features=512, out_features=512, bias=True)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (feed_forward): PositionwiseFeedForward(\n",
              "          (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
              "          (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (sublayer): ModuleList(\n",
              "          (0): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "          (1): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "    )\n",
              "    (norm): LayerNorm()\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, bias=True)\n",
              "            (1): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (2): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (3): Linear(in_features=512, out_features=512, bias=True)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (src_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (1): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (2): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (3): Linear(in_features=512, out_features=512, bias=True)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (feed_forward): PositionwiseFeedForward(\n",
              "          (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
              "          (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (sublayer): ModuleList(\n",
              "          (0): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "          (1): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "          (2): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "      (1): DecoderLayer(\n",
              "        (self_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (1): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (2): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (3): Linear(in_features=512, out_features=512, bias=True)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (src_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (1): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (2): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (3): Linear(in_features=512, out_features=512, bias=True)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (feed_forward): PositionwiseFeedForward(\n",
              "          (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
              "          (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (sublayer): ModuleList(\n",
              "          (0): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "          (1): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "          (2): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "    )\n",
              "    (norm): LayerNorm()\n",
              "  )\n",
              "  (src_embed): Sequential(\n",
              "    (0): Embeddings(\n",
              "      (lut): Embedding(10, 512)\n",
              "    )\n",
              "    (1): PositionalEncoding(\n",
              "      (dropout): Dropout(p=0.1, inplace=False)\n",
              "    )\n",
              "  )\n",
              "  (tgt_embed): Sequential(\n",
              "    (0): Embeddings(\n",
              "      (lut): Embedding(10, 512)\n",
              "    )\n",
              "    (1): PositionalEncoding(\n",
              "      (dropout): Dropout(p=0.1, inplace=False)\n",
              "    )\n",
              "  )\n",
              "  (generator): Generator(\n",
              "    (proj): Linear(in_features=512, out_features=10, bias=True)\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2HvXw7vq2y6M",
        "colab_type": "text"
      },
      "source": [
        "# Training\n",
        "\n",
        "This section describes the training regime for our models."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hlQxKPw_2y6N",
        "colab_type": "text"
      },
      "source": [
        "> We stop for a quick interlude to introduce some of the tools \n",
        "needed to train a standard encoder decoder model. First we define a batch object that holds the src and target sentences for training, as well as constructing the masks. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tpeQbTCe2y6N",
        "colab_type": "text"
      },
      "source": [
        "## Batches and Masking"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hX7yUAZ12y6O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Batch:\n",
        "    \"Object for holding a batch of data with mask during training.\"\n",
        "    def __init__(self, src, trg=None, pad=0):\n",
        "        self.src = src\n",
        "        self.src_mask = (src != pad).unsqueeze(-2)\n",
        "        print(\"self.src_mask:\", self.src_mask.shape)\n",
        "        if trg is not None:\n",
        "            self.trg = trg[:, :-1]\n",
        "            self.trg_y = trg[:, 1:]\n",
        "            self.trg_mask = \\\n",
        "                self.make_std_mask(self.trg, pad)\n",
        "            self.ntokens = (self.trg_y != pad).data.sum()\n",
        "    \n",
        "    @staticmethod\n",
        "    def make_std_mask(tgt, pad):\n",
        "        \"Create a mask to hide padding and future words.\"\n",
        "        tgt_mask = (tgt != pad).unsqueeze(-2)\n",
        "        tgt_mask = tgt_mask & Variable(\n",
        "            subsequent_mask(tgt.size(-1)).type_as(tgt_mask.data)) # subsequent_mask\n",
        "        print(\"self.tgt_mask:\", tgt_mask)\n",
        "        return tgt_mask"
      ],
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LRSNlc1v2y6Q",
        "colab_type": "text"
      },
      "source": [
        "> Next we create a generic training and scoring function to keep track of loss. We pass in a generic loss compute function that also handles parameter updates. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oBwsIMus2y6R",
        "colab_type": "text"
      },
      "source": [
        "## Training Loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E9vMcfEj2y6R",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def run_epoch(data_iter, model, loss_compute):\n",
        "    \"Standard Training and Logging Function\"\n",
        "    start = time.time()\n",
        "    total_tokens = 0\n",
        "    total_loss = 0\n",
        "    tokens = 0\n",
        "    for i, batch in enumerate(data_iter):\n",
        "        out = model.forward(batch.src, batch.trg, \n",
        "                            batch.src_mask, batch.trg_mask)\n",
        "        loss = loss_compute(out, batch.trg_y, batch.ntokens)\n",
        "        total_loss += loss\n",
        "        total_tokens += batch.ntokens\n",
        "        tokens += batch.ntokens\n",
        "        if i % 50 == 1:\n",
        "            elapsed = time.time() - start\n",
        "            print(\"Epoch Step: %d Loss: %f Tokens per Sec: %f\" %\n",
        "                    (i, loss / batch.ntokens, tokens / elapsed))\n",
        "            start = time.time()\n",
        "            tokens = 0\n",
        "    return total_loss / total_tokens"
      ],
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cnDmrZVU2y6T",
        "colab_type": "text"
      },
      "source": [
        "## Training Data and Batching\n",
        "\n",
        "We trained on the standard WMT 2014 English-German dataset consisting of about 4.5 million sentence pairs.  Sentences were encoded using byte-pair encoding, which has a shared source-target vocabulary of about 37000 tokens. For English-French, we used the significantly larger WMT 2014 English-French dataset consisting of 36M sentences and split tokens into a 32000 word-piece vocabulary.\n",
        "\n",
        "\n",
        "Sentence pairs were batched together by approximate sequence length.  Each training batch contained a set of sentence pairs containing approximately 25000 source tokens and 25000 target tokens.     "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OUm5GF612y6U",
        "colab_type": "text"
      },
      "source": [
        "> We will use torch text for batching. This is discussed in more detail below. Here we create batches in a torchtext function that ensures our batch size padded to the maximum batchsize does not surpass a threshold (25000 if we have 8 gpus)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bjl9d9Zf2y6U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "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)"
      ],
      "execution_count": 38,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y_vWK-rR2y6W",
        "colab_type": "text"
      },
      "source": [
        "## Hardware and Schedule                                                                                                                                                                                                   \n",
        "We trained our models on one machine with 8 NVIDIA P100 GPUs.  For our base models using the hyperparameters described throughout the paper, each training step took about 0.4 seconds.  We trained the base models for a total of 100,000 steps or 12 hours. For our big models, step time was 1.0 seconds.  The big models were trained for 300,000 steps (3.5 days)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rCIZfpp_2y6X",
        "colab_type": "text"
      },
      "source": [
        "## Optimizer\n",
        "\n",
        "We used the Adam optimizer [(cite)](https://arxiv.org/abs/1412.6980) 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": "markdown",
      "metadata": {
        "id": "sStlszjD2y6X",
        "colab_type": "text"
      },
      "source": [
        "> Note: This part is very important. Need to train with this setup of the model. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hVkzqSmj2y6Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "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": 39,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N9IyocE72y6a",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "> Example of the curves of this model for different model sizes and for optimization hyperparameters. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8GT_q9EI2y6b",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "outputId": "d54aea52-c4ab-4660-c532-2b635a56f4f8"
      },
      "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\"])\n",
        "None"
      ],
      "execution_count": 40,
      "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": "GsGp1iYa2y6d",
        "colab_type": "text"
      },
      "source": [
        "## Regularization                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \n",
        "                                                                                                                                                                                                                                                                                                                      \n",
        "### Label Smoothing\n",
        "\n",
        "During training, we employed label smoothing of value $\\epsilon_{ls}=0.1$ [(cite)](https://arxiv.org/abs/1512.00567).  This hurts perplexity, as the model learns to be more unsure, but improves accuracy and BLEU score.  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mcjcpVh92y6d",
        "colab_type": "text"
      },
      "source": [
        "> We implement label smoothing using the KL div loss. Instead of using a one-hot target distribution, we create a distribution that has `confidence` of the correct word and the rest of the `smoothing` mass distributed throughout the vocabulary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T3DWiruA2y6e",
        "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": 41,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mGSaL-YT2y6i",
        "colab_type": "text"
      },
      "source": [
        "> Here we can see an example of how the mass is distributed to the words based on confidence. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1kgiJhis2y6i",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 378
        },
        "outputId": "3183d572-9177-4fa0-d49d-8d28e42cfb2b"
      },
      "source": [
        "#Example of label smoothing.\n",
        "crit = LabelSmoothing(5, 0, 0.4)\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)\n",
        "None"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/torch/nn/_reduction.py:44: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.\n",
            "  warnings.warn(warning.format(ret))\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:18: UserWarning: This overload of nonzero is deprecated:\n",
            "\tnonzero(Tensor input, *, Tensor out)\n",
            "Consider using one of the following signatures instead:\n",
            "\tnonzero(Tensor input, *, bool as_tuple) (Triggered internally at  /pytorch/torch/csrc/utils/python_arg_parser.cpp:766.)\n"
          ],
          "name": "stderr"
        },
        {
          "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": "qvg-iUtI2y6m",
        "colab_type": "text"
      },
      "source": [
        "> Label smoothing actually starts to penalize the model if it gets very confident about a given choice. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0-6rvQK52y6m",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 315
        },
        "outputId": "c76e8ed8-9d7b-4663-83b2-00820062f017"
      },
      "source": [
        "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 #data[0]\n",
        "plt.plot(np.arange(1, 100), [loss(x) for x in range(1, 100)])\n",
        "None"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/torch/nn/_reduction.py:44: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.\n",
            "  warnings.warn(warning.format(ret))\n"
          ],
          "name": "stderr"
        },
        {
          "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": "v5uPgWK42y6o",
        "colab_type": "text"
      },
      "source": [
        "# A First  Example\n",
        "\n",
        "> We can begin by trying out a simple copy-task. Given a random set of input symbols from a small vocabulary, the goal is to generate back those same symbols. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PTId1L7T2y6o",
        "colab_type": "text"
      },
      "source": [
        "## Synthetic Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eu5ffW7-2y6p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#data_gen(V, 30, 20)\n",
        "def data_gen(V, batch, nbatches):\n",
        "    \"Generate random data for a src-tgt copy task.\"\n",
        "    for i in range(nbatches):\n",
        "        data = torch.from_numpy(np.random.randint(1, V, size=(batch, 10)))\n",
        "        data[:, 0] = 1\n",
        "        src = Variable(data, requires_grad=False)\n",
        "        tgt = Variable(data, requires_grad=False)\n",
        "        yield Batch(src, tgt, 0)"
      ],
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hPs5TEFq2y6r",
        "colab_type": "text"
      },
      "source": [
        "## Loss Computation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HkqD9JJz2y6r",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class SimpleLossCompute:\n",
        "    \"A simple loss compute and train function.\"\n",
        "    def __init__(self, generator, criterion, opt=None):\n",
        "        self.generator = generator\n",
        "        self.criterion = criterion\n",
        "        self.opt = opt\n",
        "        \n",
        "    def __call__(self, x, y, norm):\n",
        "        x = self.generator(x)\n",
        "        loss = self.criterion(x.contiguous().view(-1, x.size(-1)), \n",
        "                              y.contiguous().view(-1)) / norm\n",
        "        loss.backward()\n",
        "        if self.opt is not None:\n",
        "            self.opt.step()\n",
        "            self.opt.optimizer.zero_grad()\n",
        "        return loss.data * norm # loss.data[0]"
      ],
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PGMi_XRi2y6t",
        "colab_type": "text"
      },
      "source": [
        "## Greedy Decoding"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f0K0u2L5qWhj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "9f3f0295-a7e5-48a1-fb75-108eddf81c05"
      },
      "source": [
        "# Train the simple copy task.\n",
        "V = 11\n",
        "criterion = LabelSmoothing(size=V, padding_idx=0, smoothing=0.0)\n",
        "model = make_model(V, V, N=2) #src_vocab=11, tgt_vocab=11, N=6\n",
        "model"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/torch/nn/_reduction.py:44: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.\n",
            "  warnings.warn(warning.format(ret))\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:35: UserWarning: nn.init.xavier_uniform is now deprecated in favor of nn.init.xavier_uniform_.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "w_1: Linear(in_features=512, out_features=2048, bias=True)\n",
            "w_2: Linear(in_features=2048, out_features=512, bias=True)\n",
            "sin/cos parameter: torch.Size([5000, 256])\n",
            "Encoder layers ModuleList(\n",
            "  (0): EncoderLayer(\n",
            "    (self_attn): MultiHeadedAttention(\n",
            "      (linears): ModuleList(\n",
            "        (0): Linear(in_features=512, out_features=512, bias=True)\n",
            "        (1): Linear(in_features=512, out_features=512, bias=True)\n",
            "        (2): Linear(in_features=512, out_features=512, bias=True)\n",
            "        (3): Linear(in_features=512, out_features=512, bias=True)\n",
            "      )\n",
            "      (dropout): Dropout(p=0.1, inplace=False)\n",
            "    )\n",
            "    (feed_forward): PositionwiseFeedForward(\n",
            "      (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
            "      (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
            "      (dropout): Dropout(p=0.1, inplace=False)\n",
            "    )\n",
            "    (sublayer): ModuleList(\n",
            "      (0): SublayerConnection(\n",
            "        (norm): LayerNorm()\n",
            "        (dropout): Dropout(p=0.1, inplace=False)\n",
            "      )\n",
            "      (1): SublayerConnection(\n",
            "        (norm): LayerNorm()\n",
            "        (dropout): Dropout(p=0.1, inplace=False)\n",
            "      )\n",
            "    )\n",
            "  )\n",
            "  (1): EncoderLayer(\n",
            "    (self_attn): MultiHeadedAttention(\n",
            "      (linears): ModuleList(\n",
            "        (0): Linear(in_features=512, out_features=512, bias=True)\n",
            "        (1): Linear(in_features=512, out_features=512, bias=True)\n",
            "        (2): Linear(in_features=512, out_features=512, bias=True)\n",
            "        (3): Linear(in_features=512, out_features=512, bias=True)\n",
            "      )\n",
            "      (dropout): Dropout(p=0.1, inplace=False)\n",
            "    )\n",
            "    (feed_forward): PositionwiseFeedForward(\n",
            "      (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
            "      (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
            "      (dropout): Dropout(p=0.1, inplace=False)\n",
            "    )\n",
            "    (sublayer): ModuleList(\n",
            "      (0): SublayerConnection(\n",
            "        (norm): LayerNorm()\n",
            "        (dropout): Dropout(p=0.1, inplace=False)\n",
            "      )\n",
            "      (1): SublayerConnection(\n",
            "        (norm): LayerNorm()\n",
            "        (dropout): Dropout(p=0.1, inplace=False)\n",
            "      )\n",
            "    )\n",
            "  )\n",
            ")\n",
            "Encoder norm LayerNorm()\n",
            "decodeLayer size: 512\n",
            "self.proj: Linear(in_features=512, out_features=11, bias=True)\n"
          ],
          "name": "stdout"
        },
        {
          "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, bias=True)\n",
              "            (1): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (2): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (3): Linear(in_features=512, out_features=512, bias=True)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (feed_forward): PositionwiseFeedForward(\n",
              "          (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
              "          (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (sublayer): ModuleList(\n",
              "          (0): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "          (1): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "      (1): EncoderLayer(\n",
              "        (self_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (1): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (2): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (3): Linear(in_features=512, out_features=512, bias=True)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (feed_forward): PositionwiseFeedForward(\n",
              "          (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
              "          (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (sublayer): ModuleList(\n",
              "          (0): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "          (1): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "    )\n",
              "    (norm): LayerNorm()\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, bias=True)\n",
              "            (1): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (2): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (3): Linear(in_features=512, out_features=512, bias=True)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (src_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (1): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (2): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (3): Linear(in_features=512, out_features=512, bias=True)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (feed_forward): PositionwiseFeedForward(\n",
              "          (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
              "          (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (sublayer): ModuleList(\n",
              "          (0): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "          (1): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "          (2): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "      (1): DecoderLayer(\n",
              "        (self_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (1): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (2): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (3): Linear(in_features=512, out_features=512, bias=True)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (src_attn): MultiHeadedAttention(\n",
              "          (linears): ModuleList(\n",
              "            (0): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (1): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (2): Linear(in_features=512, out_features=512, bias=True)\n",
              "            (3): Linear(in_features=512, out_features=512, bias=True)\n",
              "          )\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (feed_forward): PositionwiseFeedForward(\n",
              "          (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
              "          (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (sublayer): ModuleList(\n",
              "          (0): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "          (1): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "          (2): SublayerConnection(\n",
              "            (norm): LayerNorm()\n",
              "            (dropout): Dropout(p=0.1, inplace=False)\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "    )\n",
              "    (norm): LayerNorm()\n",
              "  )\n",
              "  (src_embed): Sequential(\n",
              "    (0): Embeddings(\n",
              "      (lut): Embedding(11, 512)\n",
              "    )\n",
              "    (1): PositionalEncoding(\n",
              "      (dropout): Dropout(p=0.1, inplace=False)\n",
              "    )\n",
              "  )\n",
              "  (tgt_embed): Sequential(\n",
              "    (0): Embeddings(\n",
              "      (lut): Embedding(11, 512)\n",
              "    )\n",
              "    (1): PositionalEncoding(\n",
              "      (dropout): Dropout(p=0.1, inplace=False)\n",
              "    )\n",
              "  )\n",
              "  (generator): Generator(\n",
              "    (proj): Linear(in_features=512, out_features=11, bias=True)\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YFK0ZeTp-LW1",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "eaf0c8e6-0b1e-406e-aa6d-9e9fe8579f96"
      },
      "source": [
        "model_opt = NoamOpt(model.src_embed[0].d_model, 1, 400,\n",
        "        torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))\n",
        "model_opt"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<__main__.NoamOpt at 0x7fed2341cac8>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6u-eNrBS2y6u",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "29af10fe-3d25-4940-87f6-2fb2bdb96e2b"
      },
      "source": [
        "for epoch in range(10):\n",
        "    model.train()\n",
        "    run_epoch(data_gen(V, 30, 20), model, \n",
        "              SimpleLossCompute(model.generator, criterion, model_opt))\n",
        "    model.eval()\n",
        "    print(run_epoch(data_gen(V, 30, 5), model, \n",
        "                    SimpleLossCompute(model.generator, criterion, None)))\n",
        "\"\"\"\n",
        "512/8 = 64\n",
        "PE forward var: torch.Size([1, 9, 512])\n",
        "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
        "           0.0000e+00,  1.0000e+00],\n",
        "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
        "           1.0366e-04,  1.0000e+00],\n",
        "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
        "           2.0733e-04,  1.0000e+00],\n",
        "         ...,\n",
        "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
        "           6.2198e-04,  1.0000e+00],\n",
        "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
        "           7.2564e-04,  1.0000e+00],\n",
        "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
        "           8.2931e-04,  1.0000e+00]]])\n",
        "norm: torch.Size([30, 9, 512])\n",
        "query: torch.Size([30, 8, 9, 64])\n",
        "key: torch.Size([30, 8, 9, 64])\n",
        "value: torch.Size([30, 8, 9, 64])\n",
        "norm: torch.Size([30, 9, 512])\n",
        "query: torch.Size([30, 8, 9, 64])\n",
        "key: torch.Size([30, 8, 10, 64])\n",
        "value: torch.Size([30, 8, 10, 64])\n",
        "norm: torch.Size([30, 9, 512])\n",
        "norm: torch.Size([30, 9, 512])\n",
        "query: torch.Size([30, 8, 9, 64])\n",
        "key: torch.Size([30, 8, 9, 64])\n",
        "value: torch.Size([30, 8, 9, 64])\n",
        "norm: torch.Size([30, 9, 512])\n",
        "query: torch.Size([30, 8, 9, 64])\n",
        "key: torch.Size([30, 8, 10, 64])\n",
        "value: torch.Size([30, 8, 10, 64])\n",
        "norm: torch.Size([30, 9, 512])\n",
        "norm: torch.Size([30, 9, 512])\n",
        "\"\"\""
      ],
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[1;30;43mStreaming output truncated to the last 5000 lines.\u001b[0m\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "Epoch Step: 1 Loss: 0.240754 Tokens per Sec: 470.987091\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "tensor(0.1995)\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "Epoch Step: 1 Loss: 0.384114 Tokens per Sec: 388.065521\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "Epoch Step: 1 Loss: 0.248092 Tokens per Sec: 468.198578\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "self.src_mask: torch.Size([30, 1, 10])\n",
            "self.tgt_mask: tensor([[[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        ...,\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]],\n",
            "\n",
            "        [[ True, False, False,  ..., False, False, False],\n",
            "         [ True,  True, False,  ..., False, False, False],\n",
            "         [ True,  True,  True,  ..., False, False, False],\n",
            "         ...,\n",
            "         [ True,  True,  True,  ...,  True, False, False],\n",
            "         [ True,  True,  True,  ...,  True,  True, False],\n",
            "         [ True,  True,  True,  ...,  True,  True,  True]]])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "query: torch.Size([30, 8, 10, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 10, 512])\n",
            "norm: torch.Size([30, 10, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 9, 64])\n",
            "value: torch.Size([30, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "query: torch.Size([30, 8, 9, 64])\n",
            "key: torch.Size([30, 8, 10, 64])\n",
            "value: torch.Size([30, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([30, 9, 512])\n",
            "norm: torch.Size([30, 9, 512])\n",
            "tensor(0.1983)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'\\n512/8 = 64\\nPE forward var: torch.Size([1, 9, 512])\\nPE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\\n           0.0000e+00,  1.0000e+00],\\n         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\\n           1.0366e-04,  1.0000e+00],\\n         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\\n           2.0733e-04,  1.0000e+00],\\n         ...,\\n         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\\n           6.2198e-04,  1.0000e+00],\\n         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\\n           7.2564e-04,  1.0000e+00],\\n         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\\n           8.2931e-04,  1.0000e+00]]])\\nnorm: torch.Size([30, 9, 512])\\nquery: torch.Size([30, 8, 9, 64])\\nkey: torch.Size([30, 8, 9, 64])\\nvalue: torch.Size([30, 8, 9, 64])\\nnorm: torch.Size([30, 9, 512])\\nquery: torch.Size([30, 8, 9, 64])\\nkey: torch.Size([30, 8, 10, 64])\\nvalue: torch.Size([30, 8, 10, 64])\\nnorm: torch.Size([30, 9, 512])\\nnorm: torch.Size([30, 9, 512])\\nquery: torch.Size([30, 8, 9, 64])\\nkey: torch.Size([30, 8, 9, 64])\\nvalue: torch.Size([30, 8, 9, 64])\\nnorm: torch.Size([30, 9, 512])\\nquery: torch.Size([30, 8, 9, 64])\\nkey: torch.Size([30, 8, 10, 64])\\nvalue: torch.Size([30, 8, 10, 64])\\nnorm: torch.Size([30, 9, 512])\\nnorm: torch.Size([30, 9, 512])\\n'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_GGZFlC42y6w",
        "colab_type": "text"
      },
      "source": [
        "> This code predicts a translation using greedy decoding for simplicity. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uRzDPLmcqrP_",
        "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": 49,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OFzqM3B92y6x",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "5a49263f-42e9-44d4-d2db-2afc86a6c42f"
      },
      "source": [
        "model.eval()\n",
        "src = Variable(torch.LongTensor([[1,2,3,4,5,6,7,8,9,10]]) )\n",
        "print(\"src:\", src.shape)\n",
        "src_mask = Variable(torch.ones(1, 1, 10))\n",
        "print(\"src_mask:\", src_mask)\n",
        "print(\"src_mask:\", src_mask.shape)\n",
        "print(greedy_decode(model, src, src_mask, max_len=10, start_symbol=1))"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "src: torch.Size([1, 10])\n",
            "src_mask: tensor([[[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]]])\n",
            "src_mask: torch.Size([1, 1, 10])\n",
            "PE forward var: torch.Size([1, 10, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00],\n",
            "         [ 4.1212e-01, -9.1113e-01,  6.7637e-01,  ...,  1.0000e+00,\n",
            "           9.3297e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([1, 10, 512])\n",
            "query: torch.Size([1, 8, 10, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 10, 512])\n",
            "norm: torch.Size([1, 10, 512])\n",
            "query: torch.Size([1, 8, 10, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 10, 512])\n",
            "norm: torch.Size([1, 10, 512])\n",
            "PE forward var: torch.Size([1, 1, 512])\n",
            "PE forward var: tensor([[[0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0.,\n",
            "          1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1.,\n",
            "          0., 1.]]])\n",
            "norm: torch.Size([1, 1, 512])\n",
            "query: torch.Size([1, 8, 1, 64])\n",
            "key: torch.Size([1, 8, 1, 64])\n",
            "value: torch.Size([1, 8, 1, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 1, 512])\n",
            "query: torch.Size([1, 8, 1, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 1, 512])\n",
            "norm: torch.Size([1, 1, 512])\n",
            "query: torch.Size([1, 8, 1, 64])\n",
            "key: torch.Size([1, 8, 1, 64])\n",
            "value: torch.Size([1, 8, 1, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 1, 512])\n",
            "query: torch.Size([1, 8, 1, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 1, 512])\n",
            "norm: torch.Size([1, 1, 512])\n",
            "PE forward var: torch.Size([1, 2, 512])\n",
            "PE forward var: tensor([[[0.0000e+00, 1.0000e+00, 0.0000e+00,  ..., 1.0000e+00,\n",
            "          0.0000e+00, 1.0000e+00],\n",
            "         [8.4147e-01, 5.4030e-01, 8.2186e-01,  ..., 1.0000e+00,\n",
            "          1.0366e-04, 1.0000e+00]]])\n",
            "norm: torch.Size([1, 2, 512])\n",
            "query: torch.Size([1, 8, 2, 64])\n",
            "key: torch.Size([1, 8, 2, 64])\n",
            "value: torch.Size([1, 8, 2, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 2, 512])\n",
            "query: torch.Size([1, 8, 2, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 2, 512])\n",
            "norm: torch.Size([1, 2, 512])\n",
            "query: torch.Size([1, 8, 2, 64])\n",
            "key: torch.Size([1, 8, 2, 64])\n",
            "value: torch.Size([1, 8, 2, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 2, 512])\n",
            "query: torch.Size([1, 8, 2, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 2, 512])\n",
            "norm: torch.Size([1, 2, 512])\n",
            "PE forward var: torch.Size([1, 3, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([1, 3, 512])\n",
            "query: torch.Size([1, 8, 3, 64])\n",
            "key: torch.Size([1, 8, 3, 64])\n",
            "value: torch.Size([1, 8, 3, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 3, 512])\n",
            "query: torch.Size([1, 8, 3, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 3, 512])\n",
            "norm: torch.Size([1, 3, 512])\n",
            "query: torch.Size([1, 8, 3, 64])\n",
            "key: torch.Size([1, 8, 3, 64])\n",
            "value: torch.Size([1, 8, 3, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 3, 512])\n",
            "query: torch.Size([1, 8, 3, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 3, 512])\n",
            "norm: torch.Size([1, 3, 512])\n",
            "PE forward var: torch.Size([1, 4, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         [ 1.4112e-01, -9.8999e-01,  2.4509e-01,  ...,  1.0000e+00,\n",
            "           3.1099e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([1, 4, 512])\n",
            "query: torch.Size([1, 8, 4, 64])\n",
            "key: torch.Size([1, 8, 4, 64])\n",
            "value: torch.Size([1, 8, 4, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 4, 512])\n",
            "query: torch.Size([1, 8, 4, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 4, 512])\n",
            "norm: torch.Size([1, 4, 512])\n",
            "query: torch.Size([1, 8, 4, 64])\n",
            "key: torch.Size([1, 8, 4, 64])\n",
            "value: torch.Size([1, 8, 4, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 4, 512])\n",
            "query: torch.Size([1, 8, 4, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 4, 512])\n",
            "norm: torch.Size([1, 4, 512])\n",
            "PE forward var: torch.Size([1, 5, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         [ 1.4112e-01, -9.8999e-01,  2.4509e-01,  ...,  1.0000e+00,\n",
            "           3.1099e-04,  1.0000e+00],\n",
            "         [-7.5680e-01, -6.5364e-01, -6.5717e-01,  ...,  1.0000e+00,\n",
            "           4.1465e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([1, 5, 512])\n",
            "query: torch.Size([1, 8, 5, 64])\n",
            "key: torch.Size([1, 8, 5, 64])\n",
            "value: torch.Size([1, 8, 5, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 5, 512])\n",
            "query: torch.Size([1, 8, 5, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 5, 512])\n",
            "norm: torch.Size([1, 5, 512])\n",
            "query: torch.Size([1, 8, 5, 64])\n",
            "key: torch.Size([1, 8, 5, 64])\n",
            "value: torch.Size([1, 8, 5, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 5, 512])\n",
            "query: torch.Size([1, 8, 5, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 5, 512])\n",
            "norm: torch.Size([1, 5, 512])\n",
            "PE forward var: torch.Size([1, 6, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         [ 1.4112e-01, -9.8999e-01,  2.4509e-01,  ...,  1.0000e+00,\n",
            "           3.1099e-04,  1.0000e+00],\n",
            "         [-7.5680e-01, -6.5364e-01, -6.5717e-01,  ...,  1.0000e+00,\n",
            "           4.1465e-04,  1.0000e+00],\n",
            "         [-9.5892e-01,  2.8366e-01, -9.9385e-01,  ...,  1.0000e+00,\n",
            "           5.1832e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([1, 6, 512])\n",
            "query: torch.Size([1, 8, 6, 64])\n",
            "key: torch.Size([1, 8, 6, 64])\n",
            "value: torch.Size([1, 8, 6, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 6, 512])\n",
            "query: torch.Size([1, 8, 6, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 6, 512])\n",
            "norm: torch.Size([1, 6, 512])\n",
            "query: torch.Size([1, 8, 6, 64])\n",
            "key: torch.Size([1, 8, 6, 64])\n",
            "value: torch.Size([1, 8, 6, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 6, 512])\n",
            "query: torch.Size([1, 8, 6, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 6, 512])\n",
            "norm: torch.Size([1, 6, 512])\n",
            "PE forward var: torch.Size([1, 7, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-7.5680e-01, -6.5364e-01, -6.5717e-01,  ...,  1.0000e+00,\n",
            "           4.1465e-04,  1.0000e+00],\n",
            "         [-9.5892e-01,  2.8366e-01, -9.9385e-01,  ...,  1.0000e+00,\n",
            "           5.1832e-04,  1.0000e+00],\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([1, 7, 512])\n",
            "query: torch.Size([1, 8, 7, 64])\n",
            "key: torch.Size([1, 8, 7, 64])\n",
            "value: torch.Size([1, 8, 7, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 7, 512])\n",
            "query: torch.Size([1, 8, 7, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 7, 512])\n",
            "norm: torch.Size([1, 7, 512])\n",
            "query: torch.Size([1, 8, 7, 64])\n",
            "key: torch.Size([1, 8, 7, 64])\n",
            "value: torch.Size([1, 8, 7, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 7, 512])\n",
            "query: torch.Size([1, 8, 7, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 7, 512])\n",
            "norm: torch.Size([1, 7, 512])\n",
            "PE forward var: torch.Size([1, 8, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-9.5892e-01,  2.8366e-01, -9.9385e-01,  ...,  1.0000e+00,\n",
            "           5.1832e-04,  1.0000e+00],\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([1, 8, 512])\n",
            "query: torch.Size([1, 8, 8, 64])\n",
            "key: torch.Size([1, 8, 8, 64])\n",
            "value: torch.Size([1, 8, 8, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 8, 512])\n",
            "query: torch.Size([1, 8, 8, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 8, 512])\n",
            "norm: torch.Size([1, 8, 512])\n",
            "query: torch.Size([1, 8, 8, 64])\n",
            "key: torch.Size([1, 8, 8, 64])\n",
            "value: torch.Size([1, 8, 8, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 8, 512])\n",
            "query: torch.Size([1, 8, 8, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 8, 512])\n",
            "norm: torch.Size([1, 8, 512])\n",
            "PE forward var: torch.Size([1, 9, 512])\n",
            "PE forward var: tensor([[[ 0.0000e+00,  1.0000e+00,  0.0000e+00,  ...,  1.0000e+00,\n",
            "           0.0000e+00,  1.0000e+00],\n",
            "         [ 8.4147e-01,  5.4030e-01,  8.2186e-01,  ...,  1.0000e+00,\n",
            "           1.0366e-04,  1.0000e+00],\n",
            "         [ 9.0930e-01, -4.1615e-01,  9.3641e-01,  ...,  1.0000e+00,\n",
            "           2.0733e-04,  1.0000e+00],\n",
            "         ...,\n",
            "         [-2.7942e-01,  9.6017e-01, -4.7522e-01,  ...,  1.0000e+00,\n",
            "           6.2198e-04,  1.0000e+00],\n",
            "         [ 6.5699e-01,  7.5390e-01,  4.5239e-01,  ...,  1.0000e+00,\n",
            "           7.2564e-04,  1.0000e+00],\n",
            "         [ 9.8936e-01, -1.4550e-01,  9.9067e-01,  ...,  1.0000e+00,\n",
            "           8.2931e-04,  1.0000e+00]]])\n",
            "norm: torch.Size([1, 9, 512])\n",
            "query: torch.Size([1, 8, 9, 64])\n",
            "key: torch.Size([1, 8, 9, 64])\n",
            "value: torch.Size([1, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 9, 512])\n",
            "query: torch.Size([1, 8, 9, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 9, 512])\n",
            "norm: torch.Size([1, 9, 512])\n",
            "query: torch.Size([1, 8, 9, 64])\n",
            "key: torch.Size([1, 8, 9, 64])\n",
            "value: torch.Size([1, 8, 9, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 9, 512])\n",
            "query: torch.Size([1, 8, 9, 64])\n",
            "key: torch.Size([1, 8, 10, 64])\n",
            "value: torch.Size([1, 8, 10, 64])\n",
            "attention d_k: 64\n",
            "norm: torch.Size([1, 9, 512])\n",
            "norm: torch.Size([1, 9, 512])\n",
            "tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 8]])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TFVWjcc02y6z",
        "colab_type": "text"
      },
      "source": [
        "# A Real World Example\n",
        "\n",
        "> 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": "6CitdjAu2y6z",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "e30c75fe-b6d6-4bf2-8bc8-6818831daa5c"
      },
      "source": [
        "!pip install torchtext spacy\n",
        "!python -m spacy download en\n",
        "!python -m spacy download de"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: torchtext in /usr/local/lib/python3.6/dist-packages (0.3.1)\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: torch in /usr/local/lib/python3.6/dist-packages (from torchtext) (1.6.0+cu101)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from torchtext) (1.18.5)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.6/dist-packages (from torchtext) (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.0.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: setuptools in /usr/local/lib/python3.6/dist-packages (from spacy) (49.2.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: thinc==7.4.0 in /usr/local/lib/python3.6/dist-packages (from spacy) (7.4.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: murmurhash<1.1.0,>=0.28.0 in /usr/local/lib/python3.6/dist-packages (from spacy) (1.0.2)\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: 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: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext) (1.24.3)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext) (2020.6.20)\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: chardet<4,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext) (3.0.4)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.6/dist-packages (from torch->torchtext) (0.16.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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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",
            "Requirement already satisfied: de_core_news_sm==2.2.5 from https://github.com/explosion/spacy-models/releases/download/de_core_news_sm-2.2.5/de_core_news_sm-2.2.5.tar.gz#egg=de_core_news_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 de_core_news_sm==2.2.5) (2.2.4)\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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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",
            "\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": "code",
      "metadata": {
        "id": "vpcv08v-qxy-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "3d876871-d0a4-4291-f7e3-e2c169cd2b50"
      },
      "source": [
        "!pwd"
      ],
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/content\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MaIUXVKe2y61",
        "colab_type": "text"
      },
      "source": [
        "## Data Loading\n",
        "> We will load the dataset using torchtext and spacy for tokenization. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z66vnvCnCl-S",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# For data loading.\n",
        "from torchtext import data, datasets\n",
        "import spacy\n",
        "spacy_de = spacy.load('de')\n",
        "spacy_en = spacy.load('en')"
      ],
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YdtU_WwqCrzD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def tokenize_de(text):\n",
        "    list_token_de = [tok.text for tok in spacy_de.tokenizer(text)]\n",
        "    return list_token_de\n",
        "\n",
        "def tokenize_en(text):\n",
        "    list_token_en = [tok.text for tok in spacy_en.tokenizer(text)]\n",
        "    return list_token_en"
      ],
      "execution_count": 67,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LFJV8aIHDBKp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "BOS_WORD = '<s>'\n",
        "EOS_WORD = '</s>'\n",
        "BLANK_WORD = \"<blank>\""
      ],
      "execution_count": 68,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eKUnGaAXDEWt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "SRC = data.Field(tokenize=tokenize_de, \n",
        "                 pad_token=BLANK_WORD)\n",
        "TGT = data.Field(tokenize=tokenize_en, \n",
        "                 init_token = BOS_WORD, #begin_of_sentence: '<s>'\n",
        "                 eos_token = EOS_WORD, #End of sentence: '</s>'\n",
        "                 pad_token=BLANK_WORD) "
      ],
      "execution_count": 69,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tAb-FjorDPAg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "MAX_LEN = 100\n",
        "set_exts = ('.de', '.en')\n",
        "set_fields = (SRC, TGT)\n",
        "# get the sentence less than MAX_LEN(100) in length\n",
        "filter_pred_funct = (lambda x: len(vars(x)['src']) <= MAX_LEN and len(vars(x)['trg']) <= MAX_LEN)"
      ],
      "execution_count": 70,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Erm2DoD2EIPh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# call tokenize function\n",
        "train, val, test = datasets.IWSLT.splits(\n",
        "    exts=set_exts, fields=set_fields, \n",
        "    filter_pred=filter_pred_funct)"
      ],
      "execution_count": 71,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DUqNipymDRi5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "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": 72,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DJpmaBraE5nw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 244
        },
        "outputId": "c2f2dcaa-6d9c-4839-963c-8b7d74094e75"
      },
      "source": [
        "from torchtext.data import Iterator\n",
        "train_loader = Iterator(train, \n",
        "\t\t\tbatch_size=3, \n",
        "\t\t\tdevice=cuda,  # gpu 사용시 \"cuda\" 입력\n",
        "\t\t\trepeat=False)\n",
        "for batch in train_loader:\n",
        "    print(batch)\n",
        "    break\n",
        "print(batch.src)\n",
        "print(batch.trg)"
      ],
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-74-aa912df00a1c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m train_loader = Iterator(train, \n\u001b[1;32m      3\u001b[0m                         \u001b[0mbatch_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m                         \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m,\u001b[0m  \u001b[0;31m# gpu 사용시 \"cuda\" 입력\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \t\t\trepeat=False)\n\u001b[1;32m      6\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbatch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtrain_loader\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'cuda' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5KIdYaZo2y62",
        "colab_type": "code",
        "colab": {}
      },
      "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",
        "        list_token_de = [tok.text for tok in spacy_de.tokenizer(text)]\n",
        "        #print(\"list_token_de:\", list_token_de)\n",
        "        return list_token_de\n",
        "\n",
        "    def tokenize_en(text):\n",
        "        list_token_en = [tok.text for tok in spacy_en.tokenizer(text)]\n",
        "        #print(\"list_token_en:\", list_token_en)\n",
        "        return list_token_en\n",
        "\n",
        "    BOS_WORD = '<s>'\n",
        "    EOS_WORD = '</s>'\n",
        "    BLANK_WORD = \"<blank>\"\n",
        "\n",
        "    SRC = data.Field(tokenize=tokenize_de, pad_token=BLANK_WORD)\n",
        "    TGT = data.Field(tokenize=tokenize_en, init_token = BOS_WORD, 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)\n",
        "\n",
        "    print(\"Data loading is done\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AhFp6DmG2y63",
        "colab_type": "text"
      },
      "source": [
        "> Batching matters a ton for speed. We want to have very evenly divided batches, with absolutely minimal padding. To do this we have to hack a bit around the default torchtext batching. This code patches their default batching to make sure we search over enough sentences to find tight batches. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fDCXIW7V2y64",
        "colab_type": "text"
      },
      "source": [
        "## Iterators"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MZ9JzmHM2y65",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "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",
        "    return Batch(src, trg, pad_idx)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "lCyOcdfB2y67",
        "colab_type": "text"
      },
      "source": [
        "## Multi-GPU Training\n",
        "\n",
        "> Finally to really target fast training, we will use multi-gpu. This code implements multi-gpu word generation. It is not specific to transformer so I won't go into too much detail. The idea is to split up word generation at training time into chunks to be processed in parallel across many different gpus. We do this using pytorch parallel primitives:\n",
        "\n",
        "* replicate - split modules onto different gpus.\n",
        "* scatter - split batches onto different gpus\n",
        "* parallel_apply - apply module to batches on different gpus\n",
        "* gather - pull scattered data back onto one gpu. \n",
        "* nn.DataParallel - a special module wrapper that calls these all before evaluating. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GTr-Yzm82y67",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Skip if not interested in multigpu.\n",
        "class MultiGPULossCompute:\n",
        "    \"A multi-gpu loss compute and train function.\"\n",
        "    def __init__(self, generator, criterion, devices, opt=None, chunk_size=5):\n",
        "        # Send out to different gpus.\n",
        "        self.generator = generator\n",
        "        self.criterion = nn.parallel.replicate(criterion, \n",
        "                                               devices=devices)\n",
        "        self.opt = opt\n",
        "        self.devices = devices\n",
        "        self.chunk_size = chunk_size\n",
        "        \n",
        "    def __call__(self, out, targets, normalize):\n",
        "        total = 0.0\n",
        "        generator = nn.parallel.replicate(self.generator, \n",
        "                                                devices=self.devices)\n",
        "        out_scatter = nn.parallel.scatter(out, \n",
        "                                          target_gpus=self.devices)\n",
        "        out_grad = [[] for _ in out_scatter]\n",
        "        targets = nn.parallel.scatter(targets, \n",
        "                                      target_gpus=self.devices)\n",
        "\n",
        "        # Divide generating into chunks.\n",
        "        chunk_size = self.chunk_size\n",
        "        for i in range(0, out_scatter[0].size(1), chunk_size):\n",
        "            # Predict distributions\n",
        "            out_column = [[Variable(o[:, i:i+chunk_size].data, \n",
        "                                    requires_grad=self.opt is not None)] \n",
        "                           for o in out_scatter]\n",
        "            gen = nn.parallel.parallel_apply(generator, out_column)\n",
        "\n",
        "            # Compute loss. \n",
        "            y = [(g.contiguous().view(-1, g.size(-1)), \n",
        "                  t[:, i:i+chunk_size].contiguous().view(-1)) \n",
        "                 for g, t in zip(gen, targets)]\n",
        "            loss = nn.parallel.parallel_apply(self.criterion, y)\n",
        "\n",
        "            # Sum and normalize loss\n",
        "            l = nn.parallel.gather(loss, \n",
        "                                   target_device=self.devices[0])\n",
        "            l = l.sum()[0] / normalize\n",
        "            total += l.data[0]\n",
        "\n",
        "            # Backprop loss to output of transformer\n",
        "            if self.opt is not None:\n",
        "                l.backward()\n",
        "                for j, l in enumerate(loss):\n",
        "                    out_grad[j].append(out_column[j][0].grad.data.clone())\n",
        "\n",
        "        # Backprop all loss through transformer.            \n",
        "        if self.opt is not None:\n",
        "            out_grad = [Variable(torch.cat(og, dim=1)) for og in out_grad]\n",
        "            o1 = out\n",
        "            o2 = nn.parallel.gather(out_grad, \n",
        "                                    target_device=self.devices[0])\n",
        "            o1.backward(gradient=o2)\n",
        "            self.opt.step()\n",
        "            self.opt.optimizer.zero_grad()\n",
        "        return total * normalize"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DsIW0_PR2y6-",
        "colab_type": "text"
      },
      "source": [
        "> Now we create our model, criterion, optimizer, data iterators, and paralelization"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MZFjh0-awDGs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%tensorflow_version 2.x\n",
        "import tensorflow as tf\n",
        "device_name = tf.test.gpu_device_name()\n",
        "print(\"device_name:\", device_name)\n",
        "if device_name != '/device:GPU:0':\n",
        "  raise SystemError('GPU device not found')\n",
        "print('Found GPU at: {}'.format(device_name))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fMYX3rCawlX3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%tensorflow_version 2.x\n",
        "import tensorflow as tf\n",
        "import timeit\n",
        "\n",
        "device_name = tf.test.gpu_device_name()\n",
        "if device_name != '/device:GPU:0':\n",
        "  print(\n",
        "      '\\n\\nThis error most likely means that this notebook is not '\n",
        "      'configured to use a GPU.  Change this in Notebook Settings via the '\n",
        "      'command palette (cmd/ctrl-shift-P) or the Edit menu.\\n\\n')\n",
        "  raise SystemError('GPU device not found')\n",
        "\n",
        "def cpu():\n",
        "  with tf.device('/cpu:0'):\n",
        "    random_image_cpu = tf.random.normal((100, 100, 100, 3))\n",
        "    net_cpu = tf.keras.layers.Conv2D(32, 7)(random_image_cpu)\n",
        "    return tf.math.reduce_sum(net_cpu)\n",
        "\n",
        "def gpu():\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    random_image_gpu = tf.random.normal((100, 100, 100, 3))\n",
        "    net_gpu = tf.keras.layers.Conv2D(32, 7)(random_image_gpu)\n",
        "    return tf.math.reduce_sum(net_gpu)\n",
        "  \n",
        "# We run each op once to warm up; see: https://stackoverflow.com/a/45067900\n",
        "cpu()\n",
        "gpu()\n",
        "\n",
        "# Run the op several times.\n",
        "print('Time (s) to convolve 32x7x7x3 filter over random 100x100x100x3 images '\n",
        "      '(batch x height x width x channel). Sum of ten runs.')\n",
        "print('CPU (s):')\n",
        "cpu_time = timeit.timeit('cpu()', number=10, setup=\"from __main__ import cpu\")\n",
        "print(cpu_time)\n",
        "print('GPU (s):')\n",
        "gpu_time = timeit.timeit('gpu()', number=10, setup=\"from __main__ import gpu\")\n",
        "print(gpu_time)\n",
        "print('GPU speedup over CPU: {}x'.format(int(cpu_time/gpu_time)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VKYbBWycNKuq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(\"len(SRC.vocab)\", len(SRC.vocab))\n",
        "print(\"len(TGT.vocab)\", len(TGT.vocab))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p8QXQTN-2y6_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# GPUs to use\n",
        "devices = [0, 1, 2, 3]\n",
        "if True:\n",
        "    pad_idx = TGT.vocab.stoi[\"<blank>\"]\n",
        "    model = make_model(len(SRC.vocab), len(TGT.vocab), N=6)\n",
        "    #model.cuda()\n",
        "    criterion = LabelSmoothing(size=len(TGT.vocab), padding_idx=pad_idx, smoothing=0.1)\n",
        "    #criterion.cuda()\n",
        "    BATCH_SIZE = 12000\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)\n",
        "    print(\"valid_iter:\", valid_iter)\n",
        "    #model_par = nn.DataParallel(model, device_ids=devices) # devices \n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_yjcpLrL2y7A",
        "colab_type": "text"
      },
      "source": [
        "> Now we train the model. I will play with the warmup steps a bit, but everything else uses the default parameters.  On an AWS p3.8xlarge with 4 Tesla V100s, this runs at ~27,000 tokens per second with a batch size of 12,000 "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "24kYYPKl2y7B",
        "colab_type": "text"
      },
      "source": [
        "## Training the System"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y5Fvsen62y7B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!wget https://s3.amazonaws.com/opennmt-models/iwslt.pt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lQaZ5I-nLV7q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "(rebatch(pad_idx, b) for b in train_iter)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9byGlwy62y7E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "if False:\n",
        "    model_opt = NoamOpt(model.src_embed[0].d_model, 1, 2000,\n",
        "            torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))\n",
        "    for epoch in range(10):\n",
        "        model_par.train()\n",
        "        run_epoch((rebatch(pad_idx, b) for b in train_iter), \n",
        "                  model_par, \n",
        "                  MultiGPULossCompute(model.generator, criterion, \n",
        "                                      devices=devices, opt=model_opt)) # GPU devices \n",
        "        model_par.eval()\n",
        "        loss = run_epoch((rebatch(pad_idx, b) for b in valid_iter), \n",
        "                          model_par, \n",
        "                          MultiGPULossCompute(model.generator, criterion, \n",
        "                          devices=devices, opt=None)) # GPU devices \n",
        "        print(loss)\n",
        "else:\n",
        "    #model = torch.load(\"iwslt.pt\")\n",
        "    model = torch.load(\"iwslt.pt\", map_location=torch.device('cpu'))\n",
        "#print(model)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QlMfgqSQ2y7F",
        "colab_type": "text"
      },
      "source": [
        "> Once trained we can decode the model to produce a set of translations. Here we simply translate the first sentence in the validation set. This dataset is pretty small so the translations with greedy search are reasonably accurate. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HjvGH-gd2y7G",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i, batch in enumerate(valid_iter):\n",
        "    src = batch.src.transpose(0, 1)[:1]\n",
        "    print(\"src:\", src)\n",
        "    src_mask = (src != SRC.vocab.stoi[\"<blank>\"]).unsqueeze(-2)\n",
        "    out = greedy_decode(model, src, src_mask, \n",
        "                        max_len=60, start_symbol=TGT.vocab.stoi[\"<s>\"])\n",
        "    print(\"Translation:\", end=\"\\t\")\n",
        "    for i in range(1, out.size(1)):\n",
        "        sym = TGT.vocab.itos[out[0, i]]\n",
        "        if sym == \"</s>\": break\n",
        "        print(sym, end =\" \")\n",
        "    print()\n",
        "    print(\"Target:\", end=\"\\t\")\n",
        "    for i in range(1, batch.trg.size(0)):\n",
        "        sym = TGT.vocab.itos[batch.trg.data[i, 0]]\n",
        "        if sym == \"</s>\": break\n",
        "        print(sym, end =\" \")\n",
        "    print()\n",
        "    break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "KfF0i3VI2y7I",
        "colab_type": "text"
      },
      "source": [
        "# Additional Components: BPE, Search, Averaging"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1zHz2sRJ2y7I",
        "colab_type": "text"
      },
      "source": [
        "> So this mostly covers the transformer model itself. There are four aspects that we didn't cover explicitly. We also have all these additional features implemented in [OpenNMT-py](https://github.com/opennmt/opennmt-py).\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cftvOIBE2y7I",
        "colab_type": "text"
      },
      "source": [
        "> 1) BPE/ Word-piece: We can use a library to first preprocess the data into subword units. See Rico Sennrich's [subword-nmt](https://github.com/rsennrich/subword-nmt) implementation. These models will transform the training data to look like this:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KGUKNjTP2y7J",
        "colab_type": "text"
      },
      "source": [
        "▁Die ▁Protokoll datei ▁kann ▁ heimlich ▁per ▁E - Mail ▁oder ▁FTP ▁an ▁einen ▁bestimmte n ▁Empfänger ▁gesendet ▁werden ."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nnb23Kjk2y7K",
        "colab_type": "text"
      },
      "source": [
        "> 2) Shared Embeddings: When using BPE with shared vocabulary we can share the same weight vectors between the source / target / generator. See the [(cite)](https://arxiv.org/abs/1608.05859) for details. To add this to the model simply do this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2CMcKyEb2y7K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "if False:\n",
        "    model.src_embed[0].lut.weight = model.tgt_embeddings[0].lut.weight\n",
        "    model.generator.lut.weight = model.tgt_embed[0].lut.weight"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8osIIGON2y7M",
        "colab_type": "text"
      },
      "source": [
        "> 3) Beam Search: This is a bit too complicated to cover here. See the [OpenNMT-py](https://github.com/OpenNMT/OpenNMT-py/blob/master/onmt/translate/Beam.py) for a pytorch implementation.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cr9tc3V02y7M",
        "colab_type": "text"
      },
      "source": [
        "> 4) Model Averaging: The paper averages the last k checkpoints to create an ensembling effect. We can do this after the fact if we have a bunch of models:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DX3hkNHB2y7N",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def average(model, models):\n",
        "    \"Average models into model\"\n",
        "    for ps in zip(*[m.params() for m in [model] + models]):\n",
        "        p[0].copy_(torch.sum(*ps[1:]) / len(ps[1:]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Awv-leVn2y7P",
        "colab_type": "text"
      },
      "source": [
        "# Results\n",
        "\n",
        "On the WMT 2014 English-to-German translation task, the big transformer model (Transformer (big)\n",
        "in Table 2) outperforms the best previously reported models (including ensembles) by more than 2.0\n",
        "BLEU, establishing a new state-of-the-art BLEU score of 28.4. The configuration of this model is\n",
        "listed in the bottom line of Table 3. Training took 3.5 days on 8 P100 GPUs. Even our base model\n",
        "surpasses all previously published models and ensembles, at a fraction of the training cost of any of\n",
        "the competitive models.\n",
        "\n",
        "On the WMT 2014 English-to-French translation task, our big model achieves a BLEU score of 41.0,\n",
        "outperforming all of the previously published single models, at less than 1/4 the training cost of the\n",
        "previous state-of-the-art model. The Transformer (big) model trained for English-to-French used\n",
        "dropout rate Pdrop = 0.1, instead of 0.3.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mNTDGbfo2y7P",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "Image(filename=\"images/results.png\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zSgMdUzP2y7R",
        "colab_type": "text"
      },
      "source": [
        "> The code we have written here is a version of the base model. There are fully trained version of this system available here  [(Example Models)](http://opennmt.net/Models-py/).\n",
        ">\n",
        "> With the addtional extensions in the last section, the OpenNMT-py replication gets to 26.9 on EN-DE WMT. Here I have loaded in those parameters to our reimplemenation. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z0u70uaq2y7R",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!wget https://s3.amazonaws.com/opennmt-models/en-de-model.pt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4uWlfb5-2y7T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model, SRC, TGT = torch.load(\"en-de-model.pt\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VFOga--f_WI2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CNlN--iAAAKZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model.eval()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Eb4ZLSC8AH02",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "sent = \"▁The ▁log ▁file ▁can ▁be ▁sent ▁secret ly ▁with ▁email ▁or ▁FTP ▁to ▁a ▁specified ▁receiver\".split()\n",
        "src = torch.LongTensor([[SRC.stoi[w] for w in sent]])\n",
        "print(\"src:\", src)\n",
        "src = Variable(src)\n",
        "src_mask = (src != SRC.stoi[\"<blank>\"]).unsqueeze(-2)\n",
        "print(\"src_mask:\", src_mask)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CgBx0camA6lc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "out = greedy_decode(model, src, src_mask, \n",
        "                    max_len=60, start_symbol=TGT.stoi[\"<s>\"])\n",
        "out"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ozyi-d-y2y7V",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "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": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "df8Hwg562y7X",
        "colab_type": "text"
      },
      "source": [
        "## Attention Visualization\n",
        "\n",
        "> Even with a greedy decoder the translation looks pretty good. We can further visualize it to see what is happening at each layer of the attention "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZXcXuS0J2y7X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "tgt_sent = trans.split()\n",
        "def draw(data, x, y, ax):\n",
        "    seaborn.heatmap(data, \n",
        "                    xticklabels=x, square=True, yticklabels=y, vmin=0.0, vmax=1.0, \n",
        "                    cbar=False, ax=ax)\n",
        "    \n",
        "for layer in range(1, 6, 2):\n",
        "    fig, axs = plt.subplots(1,4, figsize=(20, 10))\n",
        "    print(\"Encoder Layer\", layer+1)\n",
        "    for h in range(4):\n",
        "        draw(model.encoder.layers[layer].self_attn.attn[0, h].data, \n",
        "            sent, sent if h ==0 else [], ax=axs[h])\n",
        "    plt.show()\n",
        "    \n",
        "for layer in range(1, 6, 2):\n",
        "    fig, axs = plt.subplots(1,4, figsize=(20, 10))\n",
        "    print(\"Decoder Self Layer\", layer+1)\n",
        "    for h in range(4):\n",
        "        draw(model.decoder.layers[layer].self_attn.attn[0, h].data[:len(tgt_sent), :len(tgt_sent)], \n",
        "            tgt_sent, tgt_sent if h ==0 else [], ax=axs[h])\n",
        "    plt.show()\n",
        "    print(\"Decoder Src Layer\", layer+1)\n",
        "    fig, axs = plt.subplots(1,4, figsize=(20, 10))\n",
        "    for h in range(4):\n",
        "        draw(model.decoder.layers[layer].self_attn.attn[0, h].data[:len(tgt_sent), :len(sent)], \n",
        "            sent, tgt_sent if h ==0 else [], ax=axs[h])\n",
        "    plt.show()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TH5yDDb32y7Y",
        "colab_type": "text"
      },
      "source": [
        "# Conclusion\n",
        "\n",
        "> Hopefully this code is useful for future research. Please reach out if you have any issues. If you find this code helpful, also check out our other OpenNMT tools.\n",
        "\n",
        "```\n",
        "@inproceedings{opennmt,\n",
        "  author    = {Guillaume Klein and\n",
        "               Yoon Kim and\n",
        "               Yuntian Deng and\n",
        "               Jean Senellart and\n",
        "               Alexander M. Rush},\n",
        "  title     = {OpenNMT: Open-Source Toolkit for Neural Machine Translation},\n",
        "  booktitle = {Proc. ACL},\n",
        "  year      = {2017},\n",
        "  url       = {https://doi.org/10.18653/v1/P17-4012},\n",
        "  doi       = {10.18653/v1/P17-4012}\n",
        "}\n",
        "```\n",
        "\n",
        "> Cheers,\n",
        "> srush"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H7BhZcxS2y7Z",
        "colab_type": "text"
      },
      "source": [
        "{::options parse_block_html=\"true\" /}\n",
        "<div id=\"disqus_thread\"></div>\n",
        "<script>\n",
        "\n",
        "/**\n",
        "*  RECOMMENDED CONFIGURATION VARIABLES: EDIT AND UNCOMMENT THE SECTION BELOW TO INSERT DYNAMIC VALUES FROM YOUR PLATFORM OR CMS.\n",
        "*  LEARN WHY DEFINING THESE VARIABLES IS IMPORTANT: https://disqus.com/admin/universalcode/#configuration-variables*/\n",
        "/*\n",
        "var disqus_config = function () {\n",
        "this.page.url = PAGE_URL;  // Replace PAGE_URL with your page's canonical URL variable\n",
        "this.page.identifier = PAGE_IDENTIFIER; // Replace PAGE_IDENTIFIER with your page's unique identifier variable\n",
        "};\n",
        "*/\n",
        "(function() { // DON'T EDIT BELOW THIS LINE\n",
        "var d = document, s = d.createElement('script');\n",
        "s.src = 'https://harvard-nlp.disqus.com/embed.js';\n",
        "s.setAttribute('data-timestamp', +new Date());\n",
        "(d.head || d.body).appendChild(s);\n",
        "})();\n",
        "</script>\n",
        "<noscript>Please enable JavaScript to view the <a href=\"https://disqus.com/?ref_noscript\">comments powered by Disqus.</a></noscript>\n",
        "                            "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BnWMKOBb2y7Z",
        "colab_type": "text"
      },
      "source": [
        "<div id=\"disqus_thread\"></div>\n",
        "<script>\n",
        "    /**\n",
        "     *  RECOMMENDED CONFIGURATION VARIABLES: EDIT AND UNCOMMENT THE SECTION BELOW TO INSERT DYNAMIC VALUES FROM YOUR PLATFORM OR CMS.\n",
        "     *  LEARN WHY DEFINING THESE VARIABLES IS IMPORTANT: https://disqus.com/admin/universalcode/#configuration-variables\n",
        "     */\n",
        "    /*\n",
        "    var disqus_config = function () {\n",
        "        this.page.url = PAGE_URL;  // Replace PAGE_URL with your page's canonical URL variable\n",
        "        this.page.identifier = PAGE_IDENTIFIER; // Replace PAGE_IDENTIFIER with your page's unique identifier variable\n",
        "    };\n",
        "    */\n",
        "    (function() {  // REQUIRED CONFIGURATION VARIABLE: EDIT THE SHORTNAME BELOW\n",
        "        var d = document, s = d.createElement('script');\n",
        "        \n",
        "        s.src = 'https://EXAMPLE.disqus.com/embed.js';  // IMPORTANT: Replace EXAMPLE with your forum shortname!\n",
        "        \n",
        "        s.setAttribute('data-timestamp', +new Date());\n",
        "        (d.head || d.body).appendChild(s);\n",
        "    })();\n",
        "</script>\n",
        "<noscript>Please enable JavaScript to view the <a href=\"https://disqus.com/?ref_noscript\" rel=\"nofollow\">comments powered by Disqus.</a></noscript>"
      ]
    }
  ]
}