SeqAttnMT.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "SeqAttnMT.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "JYuJKcWPsCtI"
      },
      "outputs": [],
      "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')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Load data files"
      ],
      "metadata": {
        "id": "oRL0WEYEuOGd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!wget https://download.pytorch.org/tutorial/data.zip\n",
        "!unzip data.zip"
      ],
      "metadata": {
        "id": "JsS4rTWus3kZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "SOS_token = 0\n",
        "EOS_token = 1\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\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"
      ],
      "metadata": {
        "id": "kXibPEwyten4"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Turn a Unicode string to plain ASCII, thanks to 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",
        "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"
      ],
      "metadata": {
        "id": "BZ4thUYiuMGp"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def readLangs(lang1, lang2, reverse=False):\n",
        "  print(\"Reading lines...\")\n",
        "\n",
        "  lines = open('data/%s-%s.txt' % (lang1, lang2), encoding='utf-8').\\\n",
        "    read().strip().split('\\n')\n",
        "  \n",
        "  pairs = [[normalizeString(s) for s in l.split('\\t')] for l in lines]\n",
        "\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"
      ],
      "metadata": {
        "id": "5knVIoVIumIC"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "MAX_LENGTH = 10\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",
        "def filterPair(p):\n",
        "  return len(p[0].split(' ')) < MAX_LENGTH and \\\n",
        "    len(p[1].split(' ')) < MAX_LENGTH and \\\n",
        "    p[1].startswith(eng_prefixes)\n",
        "\n",
        "def filterPairs(pairs):\n",
        "  return [pair for pair in pairs if filterPair(pair)]"
      ],
      "metadata": {
        "id": "9_Ljz62ZvWwS"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def prepareData(lang1, lang2, reverse=False):\n",
        "  input_lang, output_lang, pairs = readLangs(lang1, lang2, reverse)\n",
        "  print(f'Read {len(pairs)} sentence pairs')\n",
        "  pairs = filterPairs(pairs)\n",
        "  print(f'Trimmed to {len(pairs)} sentence 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",
        "input_lang, output_lang, pairs = prepareData('eng', 'fra', reverse=True)\n",
        "print(random.choice(pairs))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ekMJXe72waKe",
        "outputId": "712ed74b-6f48-42d3-8d9f-9fce22362d4d"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reading lines...\n",
            "Read 135842 sentence pairs\n",
            "Trimmed to 11051 sentence pairs\n",
            "Counting words...\n",
            "Counted words:\n",
            "fra 4502\n",
            "eng 2905\n",
            "['ils sont similaires .', 'they re similar .']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Seq2Seq - Encoder"
      ],
      "metadata": {
        "id": "BjGBQ1-Oxjho"
      }
    },
    {
      "cell_type": "code",
      "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 init_hidden(self):\n",
        "    return torch.zeros(1, 1, self.hidden_size).to(device)"
      ],
      "metadata": {
        "id": "z8L2-RI0xleb"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Seq2Seq - Decoder"
      ],
      "metadata": {
        "id": "1ejDPIXZyKCW"
      }
    },
    {
      "cell_type": "code",
      "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",
        "\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 = F.log_softmax(self.out(output[0]))\n",
        "    return output, hidden\n",
        "  \n",
        "  def init_hidden(self):\n",
        "    return torch.zeros(1, 1, self.hidden_size).to(device)"
      ],
      "metadata": {
        "id": "lfOEOkh9yL5b"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Seq2Seq Attention Decoder"
      ],
      "metadata": {
        "id": "UKNe5ztezB3S"
      }
    },
    {
      "cell_type": "code",
      "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(self.attn(torch.cat((embedded[0], hidden[0]), 1)), dim=1)\n",
        "    attn_applied = torch.bmm(attn_weights.unsqueeze(0), 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 init_hidden(self):\n",
        "    return torch.zeros(1, 1, self.hidden_size).to(device)"
      ],
      "metadata": {
        "id": "GZeFLYWmz34D"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Traning"
      ],
      "metadata": {
        "id": "C6nmkXpu21Hg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def indexesFromSentence(lang, sentence):\n",
        "  return [lang.word2index[word] for word in sentence.split(' ')]\n",
        "\n",
        "def tensorFromSentence(lang, sentence):\n",
        "  indexes = indexesFromSentence(lang, sentence)\n",
        "  indexes.append(EOS_token)\n",
        "  return torch.tensor(indexes, dtype=torch.long).view(-1, 1).to(device)\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)"
      ],
      "metadata": {
        "id": "hwfIsGBc8b-D"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "teacher_forcing_ratio = 0.5\n",
        "\n",
        "def train(input_tensor, target_tensor, encoder, decoder, encoder_optimizer,\n",
        "          decoder_optimizer, criterion, max_length=MAX_LENGTH):\n",
        "  encoder_hidden = encoder.init_hidden()\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).to(device)\n",
        "\n",
        "  loss = 0\n",
        "  for ei in range(input_length):\n",
        "    encoder_output, encoder_hidden = encoder(input_tensor[ei], encoder_hidden)\n",
        "    encoder_outputs[ei] = encoder_output[0, 0]\n",
        "\n",
        "  decoder_input = torch.tensor([[SOS_token]]).to(device)\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",
        "    for di in range(target_length):\n",
        "      decoder_output, decoder_hidden, decoder_attention \\\n",
        "      = decoder(decoder_input, decoder_hidden, encoder_outputs)\n",
        "      loss += criterion(decoder_output, target_tensor[di])\n",
        "      decoder_input = target_tensor[di]\n",
        "  else:\n",
        "    for di in range(target_length):\n",
        "      decoder_output, decoder_hidden, decoder_attention \\\n",
        "      = decoder(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",
        "      loss += criterion(decoder_output, target_tensor[di])\n",
        "      if decoder_input.item() == EOS_token:\n",
        "        break\n",
        "\n",
        "  loss.backward()\n",
        "  encoder_optimizer.step()\n",
        "  decoder_optimizer.step()\n",
        "\n",
        "  return loss.item() / target_length"
      ],
      "metadata": {
        "id": "tYUKpYjH9I-T"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "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))"
      ],
      "metadata": {
        "id": "oZTBkYOiAHmX"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def trainIters(encoder, decoder, n_iters, print_every=100, plot_every=100, learning_rate=0.01):\n",
        "  start = time.time()\n",
        "  plot_losses = []\n",
        "  print_loss_total = 0\n",
        "  plot_loss_total = 0\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)) 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, decoder, encoder_optimizer,\n",
        "                 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",
        "  showPlot(plot_losses)"
      ],
      "metadata": {
        "id": "zNpZhRksAJpg"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.switch_backend('agg')\n",
        "import matplotlib.ticker as ticker\n",
        "import numpy as np\n",
        "\n",
        "def showPlot(points):\n",
        "  plt.figure()\n",
        "  fig, ax = plt.subplots()\n",
        "  loc = ticker.MultipleLocator(base=0.2)\n",
        "  ax.yaxis.set_major_locator(loc)\n",
        "  plt.plot(points)"
      ],
      "metadata": {
        "id": "xgJTfD40Babf"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Evaluation"
      ],
      "metadata": {
        "id": "Kbbc8cXYy9Rd"
      }
    },
    {
      "cell_type": "code",
      "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.init_hidden()\n",
        "\n",
        "    encoder_outputs = torch.zeros(max_length, encoder.hidden_size).to(device)\n",
        "\n",
        "    for ei in range(input_length):\n",
        "      encoder_output, encoder_hidden = encoder(input_tensor[ei], encoder_hidden)\n",
        "      encoder_outputs[ei] += encoder_output[0, 0]\n",
        "\n",
        "    decoder_input = torch.tensor([[SOS_token]]).to(device)\n",
        "\n",
        "    decoder_hidden = encoder_hidden\n",
        "\n",
        "    decoder_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",
        "      )\n",
        "      decoder_attentions[di] = decoder_attention.data\n",
        "      topv, topi = decoder_output.data.topk(1)\n",
        "      if topi.item() == EOS_token:\n",
        "        decoder_words.append('<EOS>')\n",
        "        break\n",
        "      else:\n",
        "        decoder_words.append(output_lang.index2word[topi.item()])\n",
        "\n",
        "      decoder_input = topi.squeeze().detach()\n",
        "\n",
        "  return decoder_words, decoder_attentions[:di + 1]"
      ],
      "metadata": {
        "id": "0ukVKpity_LL"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def evaluateRandomly(encoder, decoder, n=10):\n",
        "  for i in range(n):\n",
        "    pair = random.choice(pairs)\n",
        "    print('>', pair[0])\n",
        "    print('=', pair[1])\n",
        "    output_words, attentions = evaluate(encoder, decoder, pair[0])\n",
        "    output_sentence = ' '.join(output_words)\n",
        "    print('<', output_sentence)\n",
        "    print('')"
      ],
      "metadata": {
        "id": "fwgA463r0Ghn"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "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",
        "trainIters(encoder1, attn_decoder1, 75000, print_every=5000)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MWqFRB5E2X79",
        "outputId": "4f8d2e9c-e9dd-4785-879a-d60541853bf5"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2m 3s (- 28m 43s) (5000 6%) 2.9316\n",
            "3m 56s (- 25m 36s) (10000 13%) 2.3512\n",
            "5m 50s (- 23m 22s) (15000 20%) 2.0521\n",
            "7m 45s (- 21m 19s) (20000 26%) 1.8102\n",
            "9m 39s (- 19m 19s) (25000 33%) 1.5973\n",
            "11m 34s (- 17m 22s) (30000 40%) 1.4450\n",
            "13m 29s (- 15m 25s) (35000 46%) 1.2829\n",
            "15m 24s (- 13m 29s) (40000 53%) 1.1723\n",
            "17m 22s (- 11m 35s) (45000 60%) 1.0473\n",
            "19m 19s (- 9m 39s) (50000 66%) 0.9619\n",
            "21m 16s (- 7m 44s) (55000 73%) 0.8711\n",
            "23m 12s (- 5m 48s) (60000 80%) 0.7861\n",
            "25m 7s (- 3m 51s) (65000 86%) 0.6966\n",
            "27m 2s (- 1m 55s) (70000 93%) 0.6597\n",
            "28m 58s (- 0m 0s) (75000 100%) 0.6017\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "evaluateRandomly(encoder1, attn_decoder1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mxLkeK6b2pDB",
        "outputId": "733fc7dc-0416-41f8-b869-631d265a11f2"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "> tu as probablement soif .\n",
            "= you re probably thirsty .\n",
            "< you re probably thirsty . <EOS>\n",
            "\n",
            "> je suis surpris d apprendre ca .\n",
            "= i am surprised to learn this .\n",
            "< i m not to to this . <EOS>\n",
            "\n",
            "> je ne suis pas decourage .\n",
            "= i m not discouraged .\n",
            "< i m not dumb . <EOS>\n",
            "\n",
            "> tu en es en partie responsable .\n",
            "= you are in part responsible for it .\n",
            "< you are in part responsible for it . <EOS>\n",
            "\n",
            "> nous sommes votre dernier espoir .\n",
            "= we re your last hope .\n",
            "< we re your last hope . <EOS>\n",
            "\n",
            "> je suis consciencieux .\n",
            "= i m thorough .\n",
            "< i m married . <EOS>\n",
            "\n",
            "> vous n etes pas tom .\n",
            "= you aren t tom .\n",
            "< you aren t tom . <EOS>\n",
            "\n",
            "> je ne suis pas une personne violente .\n",
            "= i m not a violent person .\n",
            "< i m not a violent person . <EOS>\n",
            "\n",
            "> tu es pleine de ressources .\n",
            "= you re resourceful .\n",
            "< you re very resourceful . <EOS>\n",
            "\n",
            "> j en ai marre de ce temps .\n",
            "= i m fed up with this weather .\n",
            "< i m sick of this weather . <EOS>\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Visualize attention"
      ],
      "metadata": {
        "id": "YL6tc0oN2sqh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%matplotlib inline"
      ],
      "metadata": {
        "id": "jklQloul_oBQ"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "output_words, attentions = evaluate(encoder1, attn_decoder1, 'je suis trop froid .')\n",
        "plt.matshow(attentions.numpy())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 292
        },
        "id": "4H5FrLK-2vPW",
        "outputId": "3982e92d-6a33-49cc-ad4b-3681254a2c11"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fd448625410>"
            ]
          },
          "metadata": {},
          "execution_count": 25
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 480x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def showAttention(input_sentence, output_words, attentions):\n",
        "  fig = plt.figure()\n",
        "  ax = fig.add_subplot(111)\n",
        "  cax = ax.matshow(attentions.numpy(), cmap='bone')\n",
        "  fig.colorbar(cax)\n",
        "\n",
        "  ax.set_xticklabels([''] + input_sentence.split(' ') + ['<EOS>'], rotation=90)\n",
        "  ax.set_yticklabels([''] + output_words)\n",
        "\n",
        "  ax.xaxis.set_major_locator(ticker.MultipleLocator(1))\n",
        "  ax.yaxis.set_major_locator(ticker.MultipleLocator(1))\n",
        "\n",
        "  plt.show()\n",
        "\n",
        "def evaluateAndShowAttention(input_sentence):\n",
        "  output_words, attentions = evaluate(encoder1, attn_decoder1, input_sentence)\n",
        "  print('input = ', input_sentence)\n",
        "  print('output = ', ' '.join(output_words))\n",
        "  showAttention(input_sentence, output_words, attentions)\n",
        "\n",
        "evaluateAndShowAttention(\"elle a cinq ans de moins que moi .\")\n",
        "\n",
        "evaluateAndShowAttention(\"elle est trop petit .\")\n",
        "\n",
        "evaluateAndShowAttention(\"je ne crains pas de mourir .\")\n",
        "\n",
        "evaluateAndShowAttention(\"c est un jeune directeur plein de talent .\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "P6OC8dCI25Z2",
        "outputId": "c23f2506-bf9f-432e-a2d9-137694b7b46d"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "input =  elle a cinq ans de moins que moi .\n",
            "output =  she s six years younger than me . <EOS>\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "input =  elle est trop petit .\n",
            "output =  she s too loud . <EOS>\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "input =  je ne crains pas de mourir .\n",
            "output =  i m not scared to die . <EOS>\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "input =  c est un jeune directeur plein de talent .\n",
            "output =  he s an talented young businessman . <EOS>\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}