seq2seq_translation_attention.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  },
  "colab": {
   "name": "seq2seq_translation_attention.ipynb",
   "provenance": []
  },
  "accelerator": "GPU"
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "T0CUqI56C9V9"
   },
   "source": [
    "# Machine Learning using seq2seq architecture with attention mechanism"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Ql1UG4OeC9WC",
    "outputId": "904f003e-b1c5-42af-e61e-72e533dc4758"
   },
   "source": [
    "from __future__ import unicode_literals, print_function, division\n",
    "from io import open\n",
    "import unicodedata\n",
    "import string\n",
    "import re\n",
    "import random\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch import optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "! curl https://download.pytorch.org/tutorial/data.zip --create-dirs -o .pytorch/engfr/data.zip\n",
    "! python -m zipfile -e .pytorch/engfr/data.zip .pytorch/engfr/\n",
    "! mv .pytorch/engfr/data/* .pytorch/engfr/"
   ],
   "execution_count": 18,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
      "                                 Dload  Upload   Total   Spent    Left  Speed\n",
      "\n",
      "  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0\n",
      "  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0\n",
      "  0     0    0     0    0     0      0      0 --:--:--  0:00:01 --:--:--     0\n",
      "  6 2814k    6  173k    0     0  70764      0  0:00:40  0:00:02  0:00:38 70905\n",
      " 32 2814k   32  913k    0     0   256k      0  0:00:10  0:00:03  0:00:07  256k\n",
      " 79 2814k   79 2233k    0     0   496k      0  0:00:05  0:00:04  0:00:01  496k\n",
      "100 2814k  100 2814k    0     0   558k      0  0:00:05  0:00:05 --:--:--  633k\n",
      "'mv' is not recognized as an internal or external command,\n",
      "operable program or batch file.\n"
     ]
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "uSepgT4-C9WF"
   },
   "source": [
    "## Data preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "kHQ1J4C2C9WG"
   },
   "source": [
    "SOS_token = 0\n",
    "EOS_token = 1\n",
    "\n",
    "\n",
    "class Lang:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.word2index = {}\n",
    "        self.word2count = {}\n",
    "        self.index2word = {0: \"SOS\", 1: \"EOS\"}\n",
    "        self.n_words = 2  # Count SOS and EOS\n",
    "\n",
    "    def addSentence(self, sentence):\n",
    "        for word in sentence.split(' '):\n",
    "            self.addWord(word)\n",
    "\n",
    "    def addWord(self, word):\n",
    "        if word not in self.word2index:\n",
    "            self.word2index[word] = self.n_words\n",
    "            self.word2count[word] = 1\n",
    "            self.index2word[self.n_words] = word\n",
    "            self.n_words += 1\n",
    "        else:\n",
    "            self.word2count[word] += 1"
   ],
   "execution_count": 19,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "3fkgqt4HC9WH"
   },
   "source": [
    "# Turn a Unicode string to plain ASCII, thanks to\n",
    "# https://stackoverflow.com/a/518232/2809427\n",
    "def unicodeToAscii(s):\n",
    "    return ''.join(\n",
    "        c for c in unicodedata.normalize('NFD', s)\n",
    "        if unicodedata.category(c) != 'Mn'\n",
    "    )\n",
    "\n",
    "# Lowercase, trim, and remove non-letter characters\n",
    "\n",
    "\n",
    "def normalizeString(s):\n",
    "    s = unicodeToAscii(s.lower().strip())\n",
    "    s = re.sub(r\"([.!?])\", r\" \\1\", s)\n",
    "    s = re.sub(r\"[^a-zA-Z.!?]+\", r\" \", s)\n",
    "    return s"
   ],
   "execution_count": 20,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "AIvhIi-XC9WJ"
   },
   "source": [
    "## read data"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "1kG0nTPVC9WJ"
   },
   "source": [
    "def readLangs(lang1, lang2, reverse=False):\n",
    "    print(\"Reading lines...\")\n",
    "\n",
    "    # Read the file and split into lines\n",
    "    lines = open('.pytorch/engfr/%s-%s.txt' % (lang1, lang2), encoding='utf-8').read().strip().split('\\n')\n",
    "\n",
    "    # Split every line into pairs and normalize\n",
    "    pairs = [[normalizeString(s) for s in l.split('\\t')] for l in lines]\n",
    "\n",
    "    # Reverse pairs, make Lang instances\n",
    "    if reverse:\n",
    "        pairs = [list(reversed(p)) for p in pairs]\n",
    "        input_lang = Lang(lang2)\n",
    "        output_lang = Lang(lang1)\n",
    "    else:\n",
    "        input_lang = Lang(lang1)\n",
    "        output_lang = Lang(lang2)\n",
    "\n",
    "    return input_lang, output_lang, pairs"
   ],
   "execution_count": 21,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "aH40yeGHC9WL"
   },
   "source": [
    "MAX_LENGTH = 20\n",
    "\n",
    "eng_prefixes = (\n",
    "    \"i am \", \"i m \",\n",
    "    \"he is\", \"he s \",\n",
    "    \"she is\", \"she s \",\n",
    "    \"you are\", \"you re \",\n",
    "    \"we are\", \"we re \",\n",
    "    \"they are\", \"they re \"\n",
    ")\n",
    "\n",
    "\n",
    "def filterPair(p):\n",
    "    return len(p[0].split(' ')) < MAX_LENGTH and len(p[1].split(' ')) < MAX_LENGTH and p[1].startswith(eng_prefixes)\n",
    "\n",
    "def filterPairs(pairs):\n",
    "    return [pair for pair in pairs if filterPair(pair)]"
   ],
   "execution_count": 22,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "kD2AZfrCC9WM",
    "outputId": "bf035a7b-29e6-4514-c15e-68516a30e6bf"
   },
   "source": [
    "def prepareData(lang1, lang2, reverse=False):\n",
    "    input_lang, output_lang, pairs = readLangs(lang1, lang2, reverse)\n",
    "    print(\"Read %s sentence pairs\" % len(pairs))\n",
    "    pairs = filterPairs(pairs)\n",
    "    print(\"Trimmed to %s sentence pairs\" % len(pairs))\n",
    "    print(\"Counting words...\")\n",
    "    for pair in pairs:\n",
    "        input_lang.addSentence(pair[0])\n",
    "        output_lang.addSentence(pair[1])\n",
    "    print(\"Counted words:\")\n",
    "    print(input_lang.name, input_lang.n_words)\n",
    "    print(output_lang.name, output_lang.n_words)\n",
    "    return input_lang, output_lang, pairs\n",
    "\n",
    "\n",
    "input_lang, output_lang, pairs = prepareData('eng', 'fra', True)\n",
    "print(random.choice(pairs))"
   ],
   "execution_count": 23,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading lines...\n",
      "Read 135842 sentence pairs\n",
      "Trimmed to 13033 sentence pairs\n",
      "Counting words...\n",
      "Counted words:\n",
      "fra 5143\n",
      "eng 3371\n",
      "['nous sommes tous ici .', 'we re all here .']\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "KBvyEySxC9WP"
   },
   "source": [
    "def indexesFromSentence(lang, sentence):\n",
    "    return [lang.word2index[word] for word in sentence.split(' ')]\n",
    "\n",
    "\n",
    "def tensorFromSentence(lang, sentence):\n",
    "    indexes = indexesFromSentence(lang, sentence)\n",
    "    indexes.append(EOS_token)\n",
    "    return torch.tensor(indexes, dtype=torch.long, device=device).view(-1, 1)\n",
    "\n",
    "\n",
    "def tensorsFromPair(pair):\n",
    "    input_tensor = tensorFromSentence(input_lang, pair[0])\n",
    "    target_tensor = tensorFromSentence(output_lang, pair[1])\n",
    "    return (input_tensor, target_tensor)"
   ],
   "execution_count": 24,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "IjA1nldMC9WR"
   },
   "source": [
    "## Model implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "id": "vmC9rJVlC9WR"
   },
   "source": [
    "### Encoder"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "dTKMGkYqC9WS"
   },
   "source": [
    "class EncoderRNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size):\n",
    "        super(EncoderRNN, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "\n",
    "        self.embedding = nn.Embedding(input_size, hidden_size)\n",
    "        self.gru = nn.GRU(hidden_size, hidden_size)\n",
    "\n",
    "    def forward(self, input, hidden):\n",
    "        embedded = self.embedding(input).view(1, 1, -1)\n",
    "        output = embedded\n",
    "        output, hidden = self.gru(output, hidden)\n",
    "        return output, hidden\n",
    "\n",
    "    def initHidden(self):\n",
    "        return torch.zeros(1, 1, self.hidden_size, device=device)"
   ],
   "execution_count": 25,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "drVlOWscC9WU"
   },
   "source": [
    "### Decoder"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "MBcmzJfQC9WW"
   },
   "source": [
    "class DecoderRNN(nn.Module):\n",
    "    def __init__(self, hidden_size, output_size):\n",
    "        super(DecoderRNN, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "\n",
    "        self.embedding = nn.Embedding(output_size, hidden_size)\n",
    "        self.gru = nn.GRU(hidden_size, hidden_size)\n",
    "        self.out = nn.Linear(hidden_size, output_size)\n",
    "        self.softmax = nn.LogSoftmax(dim=1)\n",
    "\n",
    "    def forward(self, input, hidden):\n",
    "        output = self.embedding(input).view(1, 1, -1)\n",
    "        output = F.relu(output)\n",
    "        output, hidden = self.gru(output, hidden)\n",
    "        output = self.softmax(self.out(output[0]))\n",
    "        return output, hidden\n",
    "\n",
    "    def initHidden(self):\n",
    "        return torch.zeros(1, 1, self.hidden_size, device=device)"
   ],
   "execution_count": 26,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "id": "gWQkYckJC9WY"
   },
   "source": [
    "### Attention Decoder"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "bxvqRU2mC9WY"
   },
   "source": [
    "class AttnDecoderRNN(nn.Module):\n",
    "    def __init__(self, hidden_size, output_size, dropout_p=0.1, max_length=MAX_LENGTH):\n",
    "        super(AttnDecoderRNN, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.output_size = output_size\n",
    "        self.dropout_p = dropout_p\n",
    "        self.max_length = max_length\n",
    "\n",
    "        self.embedding = nn.Embedding(self.output_size, self.hidden_size)\n",
    "        self.attn = nn.Linear(self.hidden_size * 2, self.max_length)\n",
    "        self.attn_combine = nn.Linear(self.hidden_size * 2, self.hidden_size)\n",
    "        self.dropout = nn.Dropout(self.dropout_p)\n",
    "        self.gru = nn.GRU(self.hidden_size, self.hidden_size)\n",
    "        self.out = nn.Linear(self.hidden_size, self.output_size)\n",
    "\n",
    "    def forward(self, input, hidden, encoder_outputs):\n",
    "        embedded = self.embedding(input).view(1, 1, -1)\n",
    "        embedded = self.dropout(embedded)\n",
    "\n",
    "        attn_weights = F.softmax(\n",
    "            self.attn(torch.cat((embedded[0], hidden[0]), 1)), dim=1)\n",
    "        attn_applied = torch.bmm(attn_weights.unsqueeze(0),\n",
    "                                 encoder_outputs.unsqueeze(0))\n",
    "\n",
    "        output = torch.cat((embedded[0], attn_applied[0]), 1)\n",
    "        output = self.attn_combine(output).unsqueeze(0)\n",
    "\n",
    "        output = F.relu(output)\n",
    "        output, hidden = self.gru(output, hidden)\n",
    "\n",
    "        output = F.log_softmax(self.out(output[0]), dim=1)\n",
    "        return output, hidden, attn_weights\n",
    "\n",
    "    def initHidden(self):\n",
    "        return torch.zeros(1, 1, self.hidden_size, device=device)"
   ],
   "execution_count": 27,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "zHKFw8dfC9Wa"
   },
   "source": [
    "## Train & Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "e54BOPbBC9Wb"
   },
   "source": [
    "### Train"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "P7a3P4vFC9Wb"
   },
   "source": [
    "teacher_forcing_ratio = 0.5\n",
    "\n",
    "\n",
    "def train(input_tensor, target_tensor, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion, max_length=MAX_LENGTH):\n",
    "    encoder_hidden = encoder.initHidden()\n",
    "\n",
    "    encoder_optimizer.zero_grad()\n",
    "    decoder_optimizer.zero_grad()\n",
    "\n",
    "    input_length = input_tensor.size(0)\n",
    "    target_length = target_tensor.size(0)\n",
    "\n",
    "    encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)\n",
    "\n",
    "    loss = 0\n",
    "\n",
    "    for ei in range(input_length):\n",
    "        encoder_output, encoder_hidden = encoder(\n",
    "            input_tensor[ei], encoder_hidden)\n",
    "        encoder_outputs[ei] = encoder_output[0, 0]\n",
    "\n",
    "    decoder_input = torch.tensor([[SOS_token]], device=device)\n",
    "\n",
    "    decoder_hidden = encoder_hidden\n",
    "\n",
    "    use_teacher_forcing = True if random.random() < teacher_forcing_ratio else False\n",
    "\n",
    "    if use_teacher_forcing:\n",
    "        # Teacher forcing: Feed the target as the next input\n",
    "        for di in range(target_length):\n",
    "            decoder_output, decoder_hidden, decoder_attention = decoder(\n",
    "                decoder_input, decoder_hidden, encoder_outputs)\n",
    "            loss += criterion(decoder_output, target_tensor[di])\n",
    "            decoder_input = target_tensor[di]  # Teacher forcing\n",
    "\n",
    "    else:\n",
    "        # Without teacher forcing: use its own predictions as the next input\n",
    "        for di in range(target_length):\n",
    "            decoder_output, decoder_hidden, decoder_attention = decoder(\n",
    "                decoder_input, decoder_hidden, encoder_outputs)\n",
    "            topv, topi = decoder_output.topk(1)\n",
    "            decoder_input = topi.squeeze().detach()  # detach from history as input\n",
    "\n",
    "            loss += criterion(decoder_output, target_tensor[di])\n",
    "            if decoder_input.item() == EOS_token:\n",
    "                break\n",
    "\n",
    "    loss.backward()\n",
    "\n",
    "    encoder_optimizer.step()\n",
    "    decoder_optimizer.step()\n",
    "\n",
    "    return loss.item() / target_length"
   ],
   "execution_count": 28,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "E0sXVrktC9Wd"
   },
   "source": [
    "import time\n",
    "import math\n",
    "\n",
    "\n",
    "def asMinutes(s):\n",
    "    m = math.floor(s / 60)\n",
    "    s -= m * 60\n",
    "    return '%dm %ds' % (m, s)\n",
    "\n",
    "\n",
    "def timeSince(since, percent):\n",
    "    now = time.time()\n",
    "    s = now - since\n",
    "    es = s / (percent)\n",
    "    rs = es - s\n",
    "    return '%s (- %s)' % (asMinutes(s), asMinutes(rs))\n",
    "\n",
    "def checkpoint_and_save(model):\n",
    "    print('saving')\n",
    "    torch.save(model[0].state_dict(),'checkpoint/eng_fr_encoder.t7')\n",
    "    torch.save(model[1].state_dict(),'checkpoint/eng_fr_decoder.t7')"
   ],
   "execution_count": 29,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "6QEhz3k6C9We"
   },
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.switch_backend('agg')\n",
    "import matplotlib.ticker as ticker\n",
    "import numpy as np\n",
    "%matplotlib inline\n",
    "\n",
    "\n",
    "def showPlot(points):\n",
    "    plt.figure()\n",
    "    fig, ax = plt.subplots()\n",
    "    # this locator puts ticks at regular intervals\n",
    "    loc = ticker.MultipleLocator(base=0.2)\n",
    "    ax.yaxis.set_major_locator(loc)\n",
    "    plt.plot(points)"
   ],
   "execution_count": 30,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "zBHIIbjNC9Wf"
   },
   "source": [
    "def trainIters(encoder, decoder, n_iters, print_every=1000, plot_every=100, learning_rate=0.01):\n",
    "    start = time.time()\n",
    "    best_loss = 999999\n",
    "    plot_losses = []\n",
    "    print_loss_total = 0  # Reset every print_every\n",
    "    plot_loss_total = 0  # Reset every plot_every\n",
    "\n",
    "    encoder_optimizer = optim.SGD(encoder.parameters(), lr=learning_rate)\n",
    "    decoder_optimizer = optim.SGD(decoder.parameters(), lr=learning_rate)\n",
    "    training_pairs = [tensorsFromPair(random.choice(pairs))\n",
    "                      for i in range(n_iters)]\n",
    "    criterion = nn.NLLLoss()\n",
    "\n",
    "    for iter in range(1, n_iters + 1):\n",
    "        training_pair = training_pairs[iter - 1]\n",
    "        input_tensor = training_pair[0]\n",
    "        target_tensor = training_pair[1]\n",
    "\n",
    "        loss = train(input_tensor, target_tensor, encoder,\n",
    "                     decoder, encoder_optimizer, decoder_optimizer, criterion)\n",
    "        print_loss_total += loss\n",
    "        plot_loss_total += loss\n",
    "\n",
    "        if iter % print_every == 0:\n",
    "            print_loss_avg = print_loss_total / print_every\n",
    "            print_loss_total = 0\n",
    "            print('%s (%d %d%%) %.4f' % (timeSince(start, iter / n_iters),\n",
    "                                         iter, iter / n_iters * 100, print_loss_avg))\n",
    "\n",
    "        if iter % plot_every == 0:\n",
    "            plot_loss_avg = plot_loss_total / plot_every\n",
    "            plot_losses.append(plot_loss_avg)\n",
    "            plot_loss_total = 0\n",
    "        \n",
    "        if loss < best_loss:\n",
    "          best_loss = loss\n",
    "          best_epoch = iter\n",
    "          checkpoint_and_save((encoder, decoder))\n",
    "\n",
    "    showPlot(plot_losses)"
   ],
   "execution_count": 31,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "id": "x4qiFndeC9Wh"
   },
   "source": [
    "### Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "DJxICkLcC9Wi"
   },
   "source": [
    "def evaluate(encoder, decoder, sentence, max_length=MAX_LENGTH):\n",
    "    with torch.no_grad():\n",
    "        input_tensor = tensorFromSentence(input_lang, sentence)\n",
    "        input_length = input_tensor.size()[0]\n",
    "        encoder_hidden = encoder.initHidden()\n",
    "\n",
    "        encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)\n",
    "\n",
    "        for ei in range(input_length):\n",
    "            encoder_output, encoder_hidden = encoder(input_tensor[ei],\n",
    "                                                     encoder_hidden)\n",
    "            encoder_outputs[ei] += encoder_output[0, 0]\n",
    "\n",
    "        decoder_input = torch.tensor([[SOS_token]], device=device)  # SOS\n",
    "\n",
    "        decoder_hidden = encoder_hidden\n",
    "\n",
    "        decoded_words = []\n",
    "        decoder_attentions = torch.zeros(max_length, max_length)\n",
    "\n",
    "        for di in range(max_length):\n",
    "            decoder_output, decoder_hidden, decoder_attention = decoder(\n",
    "                decoder_input, decoder_hidden, encoder_outputs)\n",
    "            decoder_attentions[di] = decoder_attention.data\n",
    "            topv, topi = decoder_output.data.topk(1)\n",
    "            if topi.item() == EOS_token:\n",
    "                decoded_words.append('<EOS>')\n",
    "                break\n",
    "            else:\n",
    "                decoded_words.append(output_lang.index2word[topi.item()])\n",
    "\n",
    "            decoder_input = topi.squeeze().detach()\n",
    "\n",
    "        return decoded_words, decoder_attentions[:di + 1]"
   ],
   "execution_count": 32,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "L4GdWINOC9Wj"
   },
   "source": [
    "from torchtext.data.metrics import bleu_score\n",
    "\n",
    "def evaluateRandomly(encoder, decoder, n=10):\n",
    "    targets = []\n",
    "    outputs = []\n",
    "    for i in range(n):\n",
    "        pair = random.choice(pairs)\n",
    "        targets.append([pair[1].split(' ')])\n",
    "        print('>', pair[0])\n",
    "        print('=', pair[1])\n",
    "        output_words, attentions = evaluate(encoder, decoder, pair[0])\n",
    "        output_sentence = ' '.join(output_words)\n",
    "        outputs.append(output_words[:-1])\n",
    "        print('<', output_sentence)\n",
    "        print('')\n",
    "    print(len(outputs), len(targets))\n",
    "    print(outputs)\n",
    "    print(targets)\n",
    "    print(f'Bleu Score: {bleu_score(outputs, targets)}')"
   ],
   "execution_count": 33,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "AtN567UcC9Wk"
   },
   "source": [
    "### Training Loop"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "psPBco1bC9Wk"
   },
   "source": [
    "hidden_size = 256\n",
    "encoder1 = EncoderRNN(input_lang.n_words, hidden_size).to(device)\n",
    "attn_decoder1 = AttnDecoderRNN(hidden_size, output_lang.n_words, dropout_p=0.1).to(device)\n",
    "\n",
    "import os\n",
    "if os.path.isdir('checkpoint') and os.path.isfile('./checkpoint/eng_fr_decoder.t7'):\n",
    "    encoder1.load_state_dict(torch.load('./checkpoint/eng_fr_encoder.t7', map_location=torch.device(device)))\n",
    "    attn_decoder1.load_state_dict(torch.load('./checkpoint/eng_fr_decoder.t7', map_location=torch.device(device)))\n",
    "if not os.path.isdir('checkpoint'):\n",
    "  os.mkdir('checkpoint')\n",
    "\n"
   ],
   "execution_count": 34,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "6v8PT__UUG1j",
    "outputId": "0de4a30d-8ca2-40be-d87b-c7f439d04286",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 758
    }
   },
   "source": [
    "trainIters(encoder1, attn_decoder1, 75000, print_every=5000)"
   ],
   "execution_count": 25,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "saving\n",
      "saving\n",
      "saving\n",
      "saving\n",
      "saving\n",
      "saving\n",
      "saving\n",
      "saving\n",
      "saving\n",
      "saving\n",
      "saving\n",
      "1m 23s (- 19m 35s) (5000 6%) 0.9798\n",
      "2m 42s (- 17m 37s) (10000 13%) 0.9650\n",
      "4m 0s (- 16m 3s) (15000 20%) 0.9409\n",
      "5m 18s (- 14m 35s) (20000 26%) 0.9092\n",
      "6m 37s (- 13m 14s) (25000 33%) 0.8958\n",
      "7m 56s (- 11m 54s) (30000 40%) 0.9278\n",
      "9m 15s (- 10m 34s) (35000 46%) 0.9225\n",
      "saving\n",
      "10m 34s (- 9m 15s) (40000 53%) 0.9079\n",
      "11m 53s (- 7m 55s) (45000 60%) 0.8852\n",
      "13m 12s (- 6m 36s) (50000 66%) 0.9402\n",
      "14m 31s (- 5m 16s) (55000 73%) 0.9144\n",
      "15m 49s (- 3m 57s) (60000 80%) 0.9925\n",
      "saving\n",
      "17m 7s (- 2m 38s) (65000 86%) 1.1650\n",
      "18m 26s (- 1m 19s) (70000 93%) 1.4232\n",
      "19m 44s (- 0m 0s) (75000 100%) 1.4484\n"
     ],
     "name": "stdout"
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     }
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "55bePQWrC9Wm",
    "outputId": "693b7bd5-720a-4ea4-8093-7f07fd1ba84b"
   },
   "source": [
    "evaluateRandomly(encoder1, attn_decoder1)"
   ],
   "execution_count": 35,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> je connais bien tom .\n",
      "= i m well acquainted with tom .\n",
      "< i m glad i well . <EOS>\n",
      "\n",
      "> il a peur des serpents .\n",
      "= he s afraid of snakes .\n",
      "< he s always of snakes . <EOS>\n",
      "\n",
      "> tu es excuse .\n",
      "= you re forgiven .\n",
      "< you re weird . <EOS>\n",
      "\n",
      "> c est moi qui suis si malade .\n",
      "= i am so sick .\n",
      "< i am sick . <EOS>\n",
      "\n",
      "> ils vous cherchent .\n",
      "= they re looking for you .\n",
      "< they re looking for you . <EOS>\n",
      "\n",
      "> tu es si mechant .\n",
      "= you re so mean .\n",
      "< you re pretty mean . <EOS>\n",
      "\n",
      "> tu es maline .\n",
      "= you re clever .\n",
      "< you re clever . <EOS>\n",
      "\n",
      "> je vais me laver les mains .\n",
      "= i m going to go wash my hands .\n",
      "< i m looking to my my . . . . . <EOS>\n",
      "\n",
      "> vous etes gares en double file .\n",
      "= you re double parked .\n",
      "< you re double parked . <EOS>\n",
      "\n",
      "> nous sommes dans la deuxieme semaine d une implacable vague de chaleur .\n",
      "= we re in the second week of an unrelenting heat wave .\n",
      "< we re in the we we . . in . <EOS>\n",
      "\n",
      "10 10\n",
      "[['i', 'm', 'glad', 'i', 'well', '.'], ['he', 's', 'always', 'of', 'snakes', '.'], ['you', 're', 'weird', '.'], ['i', 'am', 'sick', '.'], ['they', 're', 'looking', 'for', 'you', '.'], ['you', 're', 'pretty', 'mean', '.'], ['you', 're', 'clever', '.'], ['i', 'm', 'looking', 'to', 'my', 'my', '.', '.', '.', '.', '.'], ['you', 're', 'double', 'parked', '.'], ['we', 're', 'in', 'the', 'we', 'we', '.', '.', 'in', '.']]\n",
      "[[['i', 'm', 'well', 'acquainted', 'with', 'tom', '.']], [['he', 's', 'afraid', 'of', 'snakes', '.']], [['you', 're', 'forgiven', '.']], [['i', 'am', 'so', 'sick', '.']], [['they', 're', 'looking', 'for', 'you', '.']], [['you', 're', 'so', 'mean', '.']], [['you', 're', 'clever', '.']], [['i', 'm', 'going', 'to', 'go', 'wash', 'my', 'hands', '.']], [['you', 're', 'double', 'parked', '.']], [['we', 're', 'in', 'the', 'second', 'week', 'of', 'an', 'unrelenting', 'heat', 'wave', '.']]]\n",
      "Bleu Score: 0.38050237458849234\n"
     ]
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Visualization"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "outputs": [],
   "source": [
    "def showAttention(input_sentence, output_words, attentions):\n",
    "    # Set up figure with colorbar\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    cax = ax.matshow(attentions.numpy(), cmap='bone')\n",
    "    fig.colorbar(cax)\n",
    "\n",
    "    # Set up axes\n",
    "    ax.set_xticklabels([''] + input_sentence.split(' ') +\n",
    "                       ['<EOS>'], rotation=90)\n",
    "    ax.set_yticklabels([''] + output_words)\n",
    "\n",
    "    # Show label at every tick\n",
    "    ax.xaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "    ax.yaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def evaluateAndShowAttention(input_sentence):\n",
    "    output_words, attentions = evaluate(\n",
    "        encoder1, attn_decoder1, input_sentence)\n",
    "    print('input =', input_sentence)\n",
    "    print('output =', ' '.join(output_words))\n",
    "    showAttention(input_sentence, output_words, attentions)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = elle a cinq ans de moins que moi .\n",
      "output = she is two my than s . <EOS>\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 2 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "evaluateAndShowAttention(\"elle a cinq ans de moins que moi .\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = elle est trop petit .\n",
      "output = she is too short . <EOS>\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 2 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "evaluateAndShowAttention(\"elle est trop petit .\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = je ne crains pas de mourir .\n",
      "output = i m not dying i . <EOS>\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 2 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "evaluateAndShowAttention(\"je ne crains pas de mourir .\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = c est un jeune directeur plein de talent .\n",
      "output = he s very young young . . <EOS>\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 2 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "evaluateAndShowAttention(\"c est un jeune directeur plein de talent .\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ]
}