grutoatttogrupad__bleu.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.7.1"
    },
    "colab": {
      "name": "grutoatttogrupad__bleu.ipynb",
      "provenance": []
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HunniL9qoZjm",
        "outputId": "e218b0ff-98f4-4aaf-bd0a-220d5020d600"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qpzMxahioZjt"
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "\n",
        "from torchtext.data import Field, BucketIterator\n",
        "import string\n",
        "import spacy\n",
        "from torchtext import data\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "import pandas\n",
        "import random\n",
        "import math\n",
        "import time"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ibSOTfqX85Qa",
        "outputId": "bafca6ef-9195-49a4-d888-8247c70c5610",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "import torchtext\r\n",
        "torchtext.__version__"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'0.6.0'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l0GA8u9OoZjw"
      },
      "source": [
        "SEED = 1234\n",
        "\n",
        "random.seed(SEED)\n",
        "np.random.seed(SEED)\n",
        "torch.manual_seed(SEED)\n",
        "torch.cuda.manual_seed(SEED)\n",
        "torch.backends.cudnn.deterministic = True"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "epFWpY6ooZjx"
      },
      "source": [
        "spacy_en = spacy.load('en')"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HUto2KrSoZjz"
      },
      "source": [
        "def tokenize_en(text):\n",
        "    \"\"\"\n",
        "    Tokenizes English text from a string into a list of strings (tokens)\n",
        "    \"\"\"\n",
        "    return [tok.text for tok in spacy_en.tokenizer(text)]\n",
        "tokenize_yr = lambda x: str(x).translate(str.maketrans('', '', string.punctuation)).strip().split()"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QUZKEShloZj0"
      },
      "source": [
        "ID = Field()\n",
        "SRC = Field(tokenize = tokenize_en, \n",
        "            init_token = '<sos>', \n",
        "            eos_token = '<eos>', \n",
        "            lower = True,\n",
        "            include_lengths = True)\n",
        "\n",
        "TRG = Field(tokenize = tokenize_en, \n",
        "            init_token = '<sos>', \n",
        "            eos_token = '<eos>', \n",
        "            lower = True)"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yZ58b6OmoZj2"
      },
      "source": [
        "from torchtext import data\n",
        "tv_datafields = [('ID', None),(\"Yoruba\", SRC), (\"English\", TRG)]\n",
        "train_data = data.TabularDataset(path='drive/MyDrive/yorubatoEN/Train.csv',format=\"csv\",\n",
        "                                                skip_header=True, fields =tv_datafields)\n",
        "test_data = data.TabularDataset(path='drive/MyDrive/yorubatoEN/Test.csv', format=\"csv\",\n",
        "                                                skip_header=True, fields =[('ID', None),(\"Yoruba\", SRC)])"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8R79vCCdoZj3",
        "outputId": "dedf9709-e5f3-480b-f292-d7edeec9cfaa"
      },
      "source": [
        "print(f\"Number of training examples: {len(train_data.examples)}\")\n",
        "print(f\"Number of testing examples: {len(test_data.examples)}\")"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number of training examples: 10054\n",
            "Number of testing examples: 6816\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gg4VStPfoZj4",
        "outputId": "e40c9fe6-84d4-412c-bb9a-ca37bc30eed2"
      },
      "source": [
        "print(vars(train_data.examples[0]))"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'Yoruba': ['a', 'ṣètò', 'ìgbìmọ̀', 'tó', 'ń', 'ṣètò', 'ìrànwọ́', 'nígbà', 'àjálù', 'láti', 'wá', 'bí', 'àwọn', 'ará', 'wa', 'níbẹ̀', 'ṣe', 'máa', 'rí', 'àwọn', 'nǹkan', 'tí', 'wọ́n', 'máa', 'nílò', 'lọ́jọ́', 'iwájú', '.'], 'English': ['a', 'disaster', 'relief', 'committee', 'was', 'formed', 'to', 'organize', 'the', 'long', '-', 'term', 'relief', 'efforts', '.']}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1SLTykrAoZj6"
      },
      "source": [
        "import random\n",
        "\n",
        "train_data, valid_data = train_data.split(split_ratio=0.9,random_state = random.seed(SEED))"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0KVL8_jgoZj7"
      },
      "source": [
        "SRC.build_vocab(train_data, min_freq = 2)\n",
        "TRG.build_vocab(train_data, min_freq = 2)"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MinI2NRToZj8",
        "outputId": "d4d48aef-d35a-4f4a-fefd-3bb7f80dc14d"
      },
      "source": [
        "print(f\"Unique tokens in source (yr) vocabulary: {len(SRC.vocab)}\")\n",
        "print(f\"Unique tokens in target (en) vocabulary: {len(TRG.vocab)}\")"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Unique tokens in source (yr) vocabulary: 6616\n",
            "Unique tokens in target (en) vocabulary: 7989\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hn6mvZzXoZj9"
      },
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o-MBzbikoZj-"
      },
      "source": [
        "train_iter , valid_iter = data.BucketIterator.splits((train_data,valid_data), device=device, \n",
        "                                 batch_sizes=(16,16),\n",
        "                                 sort_key = lambda x: data.interleave_keys(len(x.Yoruba),len(x.English)),\n",
        "                                 sort_within_batch=True, repeat=False)\n",
        "test_iter = data.Iterator(test_data,batch_size=16,device=device,train=False,sort=False,sort_within_batch=False)"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tOOVBkvNoZj_"
      },
      "source": [
        "class Encoder(nn.Module):\n",
        "    def __init__(self, input_dim, emb_dim, enc_hid_dim, dec_hid_dim, dropout):\n",
        "        super().__init__()\n",
        "        \n",
        "        self.embedding = nn.Embedding(input_dim, emb_dim)\n",
        "        \n",
        "        self.rnn = nn.GRU(emb_dim, enc_hid_dim, bidirectional = True)\n",
        "        \n",
        "        self.fc = nn.Linear(enc_hid_dim * 2, dec_hid_dim)\n",
        "        \n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "        \n",
        "    def forward(self, src, src_len):\n",
        "        \n",
        "        #src = [src len, batch size]\n",
        "        #src_len = [batch size]\n",
        "        \n",
        "        embedded = self.dropout(self.embedding(src))\n",
        "        \n",
        "        #embedded = [src len, batch size, emb dim]\n",
        "                \n",
        "        packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, src_len,enforce_sorted=False)\n",
        "                \n",
        "        packed_outputs, hidden = self.rnn(packed_embedded)\n",
        "                                 \n",
        "        #packed_outputs is a packed sequence containing all hidden states\n",
        "        #hidden is now from the final non-padded element in the batch\n",
        "            \n",
        "        outputs, _ = nn.utils.rnn.pad_packed_sequence(packed_outputs) \n",
        "            \n",
        "        #outputs is now a non-packed sequence, all hidden states obtained\n",
        "        #  when the input is a pad token are all zeros\n",
        "            \n",
        "        #outputs = [src len, batch size, hid dim * num directions]\n",
        "        #hidden = [n layers * num directions, batch size, hid dim]\n",
        "        \n",
        "        #hidden is stacked [forward_1, backward_1, forward_2, backward_2, ...]\n",
        "        #outputs are always from the last layer\n",
        "        \n",
        "        #hidden [-2, :, : ] is the last of the forwards RNN \n",
        "        #hidden [-1, :, : ] is the last of the backwards RNN\n",
        "        \n",
        "        #initial decoder hidden is final hidden state of the forwards and backwards \n",
        "        #  encoder RNNs fed through a linear layer\n",
        "        hidden = torch.tanh(self.fc(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim = 1)))\n",
        "        \n",
        "        #outputs = [src len, batch size, enc hid dim * 2]\n",
        "        #hidden = [batch size, dec hid dim]\n",
        "        \n",
        "        return outputs, hidden"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yB2KW8tLuiCr"
      },
      "source": [
        "class Attention(nn.Module):\r\n",
        "    def __init__(self, enc_hid_dim, dec_hid_dim):\r\n",
        "        super().__init__()\r\n",
        "        \r\n",
        "        self.attn = nn.Linear((enc_hid_dim * 2) + dec_hid_dim, dec_hid_dim)\r\n",
        "        self.v = nn.Linear(dec_hid_dim, 1, bias = False)\r\n",
        "        \r\n",
        "    def forward(self, hidden, encoder_outputs, mask):\r\n",
        "        \r\n",
        "        #hidden = [batch size, dec hid dim]\r\n",
        "        #encoder_outputs = [src len, batch size, enc hid dim * 2]\r\n",
        "        \r\n",
        "        batch_size = encoder_outputs.shape[1]\r\n",
        "        src_len = encoder_outputs.shape[0]\r\n",
        "        \r\n",
        "        #repeat decoder hidden state src_len times\r\n",
        "        hidden = hidden.unsqueeze(1).repeat(1, src_len, 1)\r\n",
        "  \r\n",
        "        encoder_outputs = encoder_outputs.permute(1, 0, 2)\r\n",
        "        \r\n",
        "        #hidden = [batch size, src len, dec hid dim]\r\n",
        "        #encoder_outputs = [batch size, src len, enc hid dim * 2]\r\n",
        "        \r\n",
        "        energy = torch.tanh(self.attn(torch.cat((hidden, encoder_outputs), dim = 2))) \r\n",
        "        \r\n",
        "        #energy = [batch size, src len, dec hid dim]\r\n",
        "\r\n",
        "        attention = self.v(energy).squeeze(2)\r\n",
        "        \r\n",
        "        #attention = [batch size, src len]\r\n",
        "        \r\n",
        "        attention = attention.masked_fill(mask == 0, -1e10)\r\n",
        "        \r\n",
        "        return F.softmax(attention, dim = 1)"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YgFz42mOoZkA"
      },
      "source": [
        "class Decoder(nn.Module):\n",
        "    def __init__(self, output_dim, emb_dim, enc_hid_dim, dec_hid_dim, dropout, attention):\n",
        "        super().__init__()\n",
        "\n",
        "        self.output_dim = output_dim\n",
        "        self.attention = attention\n",
        "        \n",
        "        self.embedding = nn.Embedding(output_dim, emb_dim)\n",
        "        \n",
        "        self.rnn = nn.GRU((enc_hid_dim * 2) + emb_dim, dec_hid_dim)\n",
        "        \n",
        "        self.fc_out = nn.Linear((enc_hid_dim * 2) + dec_hid_dim + emb_dim, output_dim)\n",
        "        \n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "        \n",
        "    def forward(self, input, hidden, encoder_outputs, mask):\n",
        "             \n",
        "        #input = [batch size]\n",
        "        #hidden = [batch size, dec hid dim]\n",
        "        #encoder_outputs = [src len, batch size, enc hid dim * 2]\n",
        "        #mask = [batch size, src len]\n",
        "        \n",
        "        input = input.unsqueeze(0)\n",
        "        \n",
        "        #input = [1, batch size]\n",
        "        \n",
        "        embedded = self.dropout(self.embedding(input))\n",
        "        \n",
        "        #embedded = [1, batch size, emb dim]\n",
        "        \n",
        "        a = self.attention(hidden, encoder_outputs, mask)\n",
        "                \n",
        "        #a = [batch size, src len]\n",
        "        \n",
        "        a = a.unsqueeze(1)\n",
        "        \n",
        "        #a = [batch size, 1, src len]\n",
        "        \n",
        "        encoder_outputs = encoder_outputs.permute(1, 0, 2)\n",
        "        \n",
        "        #encoder_outputs = [batch size, src len, enc hid dim * 2]\n",
        "        \n",
        "        weighted = torch.bmm(a, encoder_outputs)\n",
        "        \n",
        "        #weighted = [batch size, 1, enc hid dim * 2]\n",
        "        \n",
        "        weighted = weighted.permute(1, 0, 2)\n",
        "        \n",
        "        #weighted = [1, batch size, enc hid dim * 2]\n",
        "        \n",
        "        rnn_input = torch.cat((embedded, weighted), dim = 2)\n",
        "        \n",
        "        #rnn_input = [1, batch size, (enc hid dim * 2) + emb dim]\n",
        "            \n",
        "        output, hidden = self.rnn(rnn_input, hidden.unsqueeze(0))\n",
        "        \n",
        "        #output = [seq len, batch size, dec hid dim * n directions]\n",
        "        #hidden = [n layers * n directions, batch size, dec hid dim]\n",
        "        \n",
        "        #seq len, n layers and n directions will always be 1 in this decoder, therefore:\n",
        "        #output = [1, batch size, dec hid dim]\n",
        "        #hidden = [1, batch size, dec hid dim]\n",
        "        #this also means that output == hidden\n",
        "        assert (output == hidden).all()\n",
        "        \n",
        "        embedded = embedded.squeeze(0)\n",
        "        output = output.squeeze(0)\n",
        "        weighted = weighted.squeeze(0)\n",
        "        \n",
        "        prediction = self.fc_out(torch.cat((output, weighted, embedded), dim = 1))\n",
        "        \n",
        "        #prediction = [batch size, output dim]\n",
        "        \n",
        "        return prediction, hidden.squeeze(0), a.squeeze(1)"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l9fQBu_IoZkC"
      },
      "source": [
        "class Seq2Seq(nn.Module):\n",
        "    def __init__(self, encoder, decoder, src_pad_idx, device):\n",
        "        super().__init__()\n",
        "        \n",
        "        self.encoder = encoder\n",
        "        self.decoder = decoder\n",
        "        self.src_pad_idx = src_pad_idx\n",
        "        self.device = device\n",
        "        \n",
        "    def create_mask(self, src):\n",
        "        mask = (src != self.src_pad_idx).permute(1, 0)\n",
        "        return mask\n",
        "        \n",
        "    def forward(self, src, src_len, trg, teacher_forcing_ratio = 0.5):\n",
        "        \n",
        "        #src = [src len, batch size]\n",
        "        #src_len = [batch size]\n",
        "        #trg = [trg len, batch size]\n",
        "        #teacher_forcing_ratio is probability to use teacher forcing\n",
        "        #e.g. if teacher_forcing_ratio is 0.75 we use teacher forcing 75% of the time\n",
        "                    \n",
        "        batch_size = src.shape[1]\n",
        "        trg_len = trg.shape[0]\n",
        "        trg_vocab_size = self.decoder.output_dim\n",
        "        \n",
        "        #tensor to store decoder outputs\n",
        "        outputs = torch.zeros(trg_len, batch_size, trg_vocab_size).to(self.device)\n",
        "        \n",
        "        #encoder_outputs is all hidden states of the input sequence, back and forwards\n",
        "        #hidden is the final forward and backward hidden states, passed through a linear layer\n",
        "        encoder_outputs, hidden = self.encoder(src, src_len.cpu())\n",
        "                \n",
        "        #first input to the decoder is the <sos> tokens\n",
        "        input = trg[0,:]\n",
        "        \n",
        "        mask = self.create_mask(src)\n",
        "\n",
        "        #mask = [batch size, src len]\n",
        "                \n",
        "        for t in range(1, trg_len):\n",
        "            \n",
        "            #insert input token embedding, previous hidden state, all encoder hidden states \n",
        "            #  and mask\n",
        "            #receive output tensor (predictions) and new hidden state\n",
        "            output, hidden, _ = self.decoder(input, hidden, encoder_outputs, mask)\n",
        "            \n",
        "            #place predictions in a tensor holding predictions for each token\n",
        "            outputs[t] = output\n",
        "            \n",
        "            #decide if we are going to use teacher forcing or not\n",
        "            teacher_force = random.random() < teacher_forcing_ratio\n",
        "            \n",
        "            #get the highest predicted token from our predictions\n",
        "            top1 = output.argmax(1) \n",
        "            \n",
        "            #if teacher forcing, use actual next token as next input\n",
        "            #if not, use predicted token\n",
        "            input = trg[t] if teacher_force else top1\n",
        "            \n",
        "        return outputs"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tv7WBloaoZkP"
      },
      "source": [
        "INPUT_DIM = len(SRC.vocab)\n",
        "OUTPUT_DIM = len(TRG.vocab)\n",
        "ENC_EMB_DIM = 256\n",
        "DEC_EMB_DIM = 256\n",
        "ENC_HID_DIM = 512\n",
        "DEC_HID_DIM = 512\n",
        "ENC_DROPOUT = 0.5\n",
        "DEC_DROPOUT = 0.5\n",
        "SRC_PAD_IDX = SRC.vocab.stoi[SRC.pad_token]\n",
        "\n",
        "attn = Attention(ENC_HID_DIM, DEC_HID_DIM)\n",
        "enc = Encoder(INPUT_DIM, ENC_EMB_DIM, ENC_HID_DIM, DEC_HID_DIM, ENC_DROPOUT)\n",
        "dec = Decoder(OUTPUT_DIM, DEC_EMB_DIM, ENC_HID_DIM, DEC_HID_DIM, DEC_DROPOUT, attn)\n",
        "\n",
        "model = Seq2Seq(enc, dec, SRC_PAD_IDX, device).to(device)"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gt9ilNyWoZkc",
        "outputId": "3bf7e99f-97b2-4e89-d686-1ac5867363a2"
      },
      "source": [
        "def init_weights(m):\n",
        "    for name, param in m.named_parameters():\n",
        "        if 'weight' in name:\n",
        "            nn.init.normal_(param.data, mean=0, std=0.01)\n",
        "        else:\n",
        "            nn.init.constant_(param.data, 0)\n",
        "            \n",
        "model.apply(init_weights)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Seq2Seq(\n",
              "  (encoder): Encoder(\n",
              "    (embedding): Embedding(6616, 256)\n",
              "    (rnn): GRU(256, 512, bidirectional=True)\n",
              "    (fc): Linear(in_features=1024, out_features=512, bias=True)\n",
              "    (dropout): Dropout(p=0.5, inplace=False)\n",
              "  )\n",
              "  (decoder): Decoder(\n",
              "    (attention): Attention(\n",
              "      (attn): Linear(in_features=1536, out_features=512, bias=True)\n",
              "      (v): Linear(in_features=512, out_features=1, bias=False)\n",
              "    )\n",
              "    (embedding): Embedding(7989, 256)\n",
              "    (rnn): GRU(1280, 512)\n",
              "    (fc_out): Linear(in_features=1792, out_features=7989, bias=True)\n",
              "    (dropout): Dropout(p=0.5, inplace=False)\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0Gbgw4NpoZkd",
        "outputId": "9c5101cb-a4f7-43fc-f4f4-b7da1f4941cb"
      },
      "source": [
        "def count_parameters(model):\n",
        "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
        "\n",
        "print(f'The model has {count_parameters(model):,} trainable parameters')"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The model has 24,496,437 trainable parameters\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9YYqEP4loZke"
      },
      "source": [
        "optimizer = optim.Adam(model.parameters())\n",
        "TRG_PAD_IDX = TRG.vocab.stoi[TRG.pad_token]\n",
        "\n",
        "criterion = nn.CrossEntropyLoss(ignore_index = TRG_PAD_IDX)"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-eMOx0ChoZkf"
      },
      "source": [
        "def train(model, iterator, optimizer, criterion, clip):\n",
        "    \n",
        "    model.train()\n",
        "    \n",
        "    epoch_loss = 0\n",
        "    \n",
        "    for i, batch in enumerate(iterator):\n",
        "        \n",
        "        src, src_len = batch.Yoruba\n",
        "        trg = batch.English\n",
        "        \n",
        "        optimizer.zero_grad()\n",
        "        \n",
        "        output = model(src, src_len, trg)\n",
        "        \n",
        "        #trg = [trg len, batch size]\n",
        "        #output = [trg len, batch size, output dim]\n",
        "        \n",
        "        output_dim = output.shape[-1]\n",
        "        \n",
        "        output = output[1:].view(-1, output_dim)\n",
        "        trg = trg[1:].view(-1)\n",
        "        \n",
        "        #trg = [(trg len - 1) * batch size]\n",
        "        #output = [(trg len - 1) * batch size, output dim]\n",
        "        \n",
        "        loss = criterion(output, trg)\n",
        "        \n",
        "        loss.backward()\n",
        "        \n",
        "        torch.nn.utils.clip_grad_norm_(model.parameters(), clip)\n",
        "        \n",
        "        optimizer.step()\n",
        "        \n",
        "        epoch_loss += loss.item()\n",
        "        \n",
        "    return epoch_loss / len(iterator)"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yNaznJJ7oZkg"
      },
      "source": [
        "def evaluate(model, iterator, criterion):\n",
        "    \n",
        "    model.eval()\n",
        "    \n",
        "    epoch_loss = 0\n",
        "    \n",
        "    with torch.no_grad():\n",
        "    \n",
        "        for i, batch in enumerate(iterator):\n",
        "\n",
        "            src, src_len = batch.Yoruba\n",
        "            trg = batch.English\n",
        "\n",
        "            output = model(src, src_len, trg, 0) #turn off teacher forcing\n",
        "            \n",
        "            #trg = [trg len, batch size]\n",
        "            #output = [trg len, batch size, output dim]\n",
        "\n",
        "            output_dim = output.shape[-1]\n",
        "            \n",
        "            output = output[1:].view(-1, output_dim)\n",
        "            trg = trg[1:].view(-1)\n",
        "\n",
        "            #trg = [(trg len - 1) * batch size]\n",
        "            #output = [(trg len - 1) * batch size, output dim]\n",
        "\n",
        "            loss = criterion(output, trg)\n",
        "\n",
        "            epoch_loss += loss.item()\n",
        "        \n",
        "    return epoch_loss / len(iterator)"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zj0rBWbJoZki"
      },
      "source": [
        "def epoch_time(start_time, end_time):\n",
        "    elapsed_time = end_time - start_time\n",
        "    elapsed_mins = int(elapsed_time / 60)\n",
        "    elapsed_secs = int(elapsed_time - (elapsed_mins * 60))\n",
        "    return elapsed_mins, elapsed_secs"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 666
        },
        "id": "lu7mvejDoZkj",
        "outputId": "7277a3b2-50a0-42c7-9e46-98df2c8bc09b"
      },
      "source": [
        "N_EPOCHS = 10\n",
        "CLIP = 1\n",
        "from torch.nn import functional as F\n",
        "best_valid_loss = float('inf')\n",
        "\n",
        "for epoch in range(N_EPOCHS):\n",
        "    \n",
        "    start_time = time.time()\n",
        "    \n",
        "    train_loss = train(model, train_iter, optimizer, criterion, CLIP)\n",
        "    valid_loss = evaluate(model, valid_iter, criterion)\n",
        "    \n",
        "    end_time = time.time()\n",
        "    \n",
        "    epoch_mins, epoch_secs = epoch_time(start_time, end_time)\n",
        "    \n",
        "    if valid_loss < best_valid_loss:\n",
        "        best_valid_loss = valid_loss\n",
        "        torch.save(model.state_dict(), 'tut1-model.pt')\n",
        "    \n",
        "    print(f'Epoch: {epoch+1:02} | Time: {epoch_mins}m {epoch_secs}s')\n",
        "    print(f'\\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}')\n",
        "    print(f'\\t Val. Loss: {valid_loss:.3f} |  Val. PPL: {math.exp(valid_loss):7.3f}')"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch: 01 | Time: 1m 17s\n",
            "\tTrain Loss: 6.215 | Train PPL: 500.209\n",
            "\t Val. Loss: 5.757 |  Val. PPL: 316.378\n",
            "Epoch: 02 | Time: 1m 18s\n",
            "\tTrain Loss: 5.334 | Train PPL: 207.290\n",
            "\t Val. Loss: 5.450 |  Val. PPL: 232.867\n",
            "Epoch: 03 | Time: 1m 17s\n",
            "\tTrain Loss: 4.791 | Train PPL: 120.427\n",
            "\t Val. Loss: 5.324 |  Val. PPL: 205.254\n",
            "Epoch: 04 | Time: 1m 18s\n",
            "\tTrain Loss: 4.273 | Train PPL:  71.710\n",
            "\t Val. Loss: 5.275 |  Val. PPL: 195.385\n",
            "Epoch: 05 | Time: 1m 17s\n",
            "\tTrain Loss: 3.744 | Train PPL:  42.251\n",
            "\t Val. Loss: 5.310 |  Val. PPL: 202.412\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-27-05bb84e19348>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0mstart_time\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m     \u001b[0mtrain_loss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain_iter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCLIP\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m     \u001b[0mvalid_loss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mevaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalid_iter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-23-5ddfd8ce7069>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(model, iterator, optimizer, criterion, clip)\u001b[0m\n\u001b[1;32m     27\u001b[0m         \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 29\u001b[0;31m         \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     31\u001b[0m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclip_grad_norm_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparameters\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclip\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[1;32m    219\u001b[0m                 \u001b[0mretain_graph\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    220\u001b[0m                 create_graph=create_graph)\n\u001b[0;32m--> 221\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    222\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    223\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[1;32m    130\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[1;32m    131\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 132\u001b[0;31m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[1;32m    133\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    134\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5JsCkYuG39_r",
        "outputId": "c1006c80-37c7-4655-b28e-1b56b9e36fd1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "model.load_state_dict(torch.load('tut1-model.pt'))\r\n",
        "\r\n",
        "test_loss = evaluate(model, valid_iter, criterion)\r\n",
        "\r\n",
        "print(f'| Test Loss: {test_loss:.3f} | Test PPL: {math.exp(test_loss):7.3f} |')"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "| Test Loss: 5.275 | Test PPL: 195.385 |\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EnHfkfepsUbp"
      },
      "source": [
        "def translate_sentence(sentence, src_field, trg_field, model, device, max_len = 50):\r\n",
        "\r\n",
        "    model.eval()\r\n",
        "        \r\n",
        "    if isinstance(sentence, str):\r\n",
        "        nlp = spacy.load('en')\r\n",
        "        tokens = [token.text.lower() for token in nlp(sentence)]\r\n",
        "    else:\r\n",
        "        tokens = [token.lower() for token in sentence]\r\n",
        "\r\n",
        "    tokens = [src_field.init_token] + tokens + [src_field.eos_token]\r\n",
        "        \r\n",
        "    src_indexes = [src_field.vocab.stoi[token] for token in tokens]\r\n",
        "    \r\n",
        "    src_tensor = torch.LongTensor(src_indexes).unsqueeze(1).to(device)\r\n",
        "\r\n",
        "    src_len = torch.LongTensor([len(src_indexes)]).to(device)\r\n",
        "    \r\n",
        "    with torch.no_grad():\r\n",
        "        encoder_outputs, hidden = model.encoder(src_tensor, src_len.cpu())\r\n",
        "\r\n",
        "    mask = model.create_mask(src_tensor)\r\n",
        "        \r\n",
        "    trg_indexes = [trg_field.vocab.stoi[trg_field.init_token]]\r\n",
        "\r\n",
        "    attentions = torch.zeros(max_len, 1, len(src_indexes)).to(device)\r\n",
        "    \r\n",
        "    for i in range(max_len):\r\n",
        "\r\n",
        "        trg_tensor = torch.LongTensor([trg_indexes[-1]]).to(device)\r\n",
        "                \r\n",
        "        with torch.no_grad():\r\n",
        "            output, hidden, attention = model.decoder(trg_tensor, hidden, encoder_outputs, mask)\r\n",
        "\r\n",
        "        attentions[i] = attention\r\n",
        "            \r\n",
        "        pred_token = output.argmax(1).item()\r\n",
        "        \r\n",
        "        trg_indexes.append(pred_token)\r\n",
        "\r\n",
        "        if pred_token == trg_field.vocab.stoi[trg_field.eos_token]:\r\n",
        "            break\r\n",
        "    \r\n",
        "    trg_tokens = [trg_field.vocab.itos[i] for i in trg_indexes]\r\n",
        "    \r\n",
        "    return trg_tokens[1:], attentions[:len(trg_tokens)-1]"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JPe8qFBw1cj5"
      },
      "source": [
        "def display_attention(sentence, translation, attention):\r\n",
        "    \r\n",
        "    fig = plt.figure(figsize=(10,10))\r\n",
        "    ax = fig.add_subplot(111)\r\n",
        "    \r\n",
        "    attention = attention.squeeze(1).cpu().detach().numpy()\r\n",
        "    \r\n",
        "    cax = ax.matshow(attention, cmap='bone')\r\n",
        "   \r\n",
        "    ax.tick_params(labelsize=15)\r\n",
        "    ax.set_xticklabels(['']+['<sos>']+[t.lower() for t in sentence]+['<eos>'], \r\n",
        "                       rotation=45)\r\n",
        "    ax.set_yticklabels(['']+translation)\r\n",
        "\r\n",
        "    ax.xaxis.set_major_locator(ticker.MultipleLocator(1))\r\n",
        "    ax.yaxis.set_major_locator(ticker.MultipleLocator(1))\r\n",
        "\r\n",
        "    plt.show()\r\n",
        "    plt.close()"
      ],
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cE44RybY1dqb",
        "outputId": "b4e554e8-59ca-4a74-a80e-7407941d7124",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "example_idx = 5\r\n",
        "\r\n",
        "src = vars(train_data.examples[example_idx])['Yoruba']\r\n",
        "trg = vars(train_data.examples[example_idx])['English']\r\n",
        "\r\n",
        "print(f'Yoruba = {src}')\r\n",
        "print(f'English = {trg}')"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Yoruba = ['àwọn', 'afẹ̀hónúhàn', 'kóra', 'jọ', 'láti', 'fi', 'òpin', 'sí', 'ikọ̀', 'sars', 'ní', 'ọjọ́', '13', ',', 'oṣù', 'òwàrà', ',', 'ọdún', '2020', ',', 'ní', 'ikeja', ',', 'èkó', '.']\n",
            "English = ['protesters', 'gather', 'to', 'end', 'sars', 'on', 'october', '13', ',', '2020', ',', 'in', 'ikeja', ',', 'lagos', '.']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VnTsQZsg1g0h",
        "outputId": "2e1949a5-431c-442e-8d6f-6549b364692b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "translation, attention = translate_sentence(src, SRC, TRG, model, device)\r\n",
        "\r\n",
        "print(f'predicted English = {translation}')"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "predicted English = ['protesters', 'gather', 'sars', 'sars', 'sars', 'sars', 'sars', 'sars', 'sars', ',', '2020', ',', '2020', ',', '2020', ',', '2020', ',', '2020', ',', '2020', ',', '2020', ',', '2020', ',', '2020', ',', '2020', '.', '<eos>']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t-EGp-vn1jK9",
        "outputId": "a1e164b4-7dcd-494d-cd6a-747d91e3930f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 660
        }
      },
      "source": [
        "import matplotlib.pyplot as plt\r\n",
        "import matplotlib.ticker as ticker\r\n",
        "\r\n",
        "display_attention(src, translation, attention)"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q0gGQPi64Obu"
      },
      "source": [
        "from torchtext.data.metrics import bleu_score\r\n",
        "\r\n",
        "def calculate_bleu(data, src_field, trg_field, model, device, max_len = 50):\r\n",
        "    \r\n",
        "    trgs = []\r\n",
        "    pred_trgs = []\r\n",
        "    \r\n",
        "    for datum in data:\r\n",
        "        \r\n",
        "        src = vars(datum)['Yoruba']\r\n",
        "        trg = vars(datum)['English']\r\n",
        "        \r\n",
        "        pred_trg, _ = translate_sentence(src, src_field, trg_field, model, device, max_len)\r\n",
        "        \r\n",
        "        #cut off <eos> token\r\n",
        "        pred_trg = pred_trg[:-1]\r\n",
        "        \r\n",
        "        pred_trgs.append(pred_trg)\r\n",
        "        trgs.append([trg])\r\n",
        "        \r\n",
        "    return bleu_score(pred_trgs, trgs)"
      ],
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DC7qufb34TID",
        "outputId": "33827527-3f79-41f4-a0e3-8c4231baa462",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "bleu_score = calculate_bleu(valid_data, SRC, TRG, model, device)\r\n",
        "\r\n",
        "print(f'BLEU score = {bleu_score*100:.2f}')"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "BLEU score = 3.52\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2BDQwA7F6fhs"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}