NMT.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "NMT.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMI0RmSVl0rlopHpgtAtJS8",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ahsanabbas123/Neural-Machine-Translation/blob/master/NMT.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOIoT6KE08uK",
        "colab_type": "text"
      },
      "source": [
        "## Loading and Preparing data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Tp7Hjwe-hSo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Requirements\n",
        "\n",
        "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\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qCI2Xencg1i6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Lang helper class\n",
        "\n",
        "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 addWord(self, word):\n",
        "    if word in self.word2index:\n",
        "      self.word2count[word] += 1\n",
        "    else:\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",
        "\n",
        "  def addSentence(self, sentence):\n",
        "    for word in sentence.split(' '):\n",
        "      self.addWord(word)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wKzhplLdo6y3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Turn a Unicode string to plain ASCII, thanks to\n",
        "# https://stackoverflow.com/a/518232/2809427\n",
        "\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",
        "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": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TdBHfpbjpHq2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def readLangs(lang1, lang2, reverse=False):\n",
        "    print(\"Reading lines...\")\n",
        "\n",
        "    # Read the file and split into lines\n",
        "    lines = open('data/%s-%s.txt' % (lang1, lang2), encoding='utf-8').\\\n",
        "        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": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AYFG5jCyq0Es",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''Since there are a lot of example sentences and we want to train something quickly, we’ll trim the data set to only relatively short and simple sentences.\n",
        "Here the maximum length is 10 words (that includes ending punctuation) \n",
        "and we’re filtering to sentences that translate to the form “I am” or “He is” etc. (accounting for apostrophes replaced earlier). '''\n",
        "\n",
        "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",
        "\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",
        "\n",
        "def filterPairs(pairs):\n",
        "    return [pair for pair in pairs if filterPair(pair)]\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BfZnjOfntC8t",
        "colab_type": "code",
        "outputId": "81c06fb4-07ae-489e-ca69-7ccdd289cbf1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 151
        }
      },
      "source": [
        "'''\n",
        "The full process for preparing the data is:\n",
        "\n",
        "Read text file and split into lines, split lines into pairs\n",
        "Normalize text, filter by length and content\n",
        "Make word lists from sentences in pairs\n",
        "\n",
        "'''\n",
        "\n",
        "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",
        "  \n",
        "  return input_lang, output_lang, pairs\n",
        "\n",
        "\n",
        "input_lang, output_lang, pairs = prepareData('eng', 'fra', True)\n",
        "print(random.choice(pairs))\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Reading lines...\n",
            "Read 135842 sentence pairs\n",
            "Trimmed to 10599 sentence pairs\n",
            "Counting words...\n",
            "Counted words:\n",
            "fra 4345\n",
            "eng 2803\n",
            "['c est un esprit independant .', 'he s an independent thinker .']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1rwSVe4i02G1",
        "colab_type": "text"
      },
      "source": [
        "## Seq2Seq Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WDV4TqU6u4Sf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Encoder \n",
        "\n",
        "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, self.hidden_size)\n",
        "    self.gru = nn.GRU(self.hidden_size, self.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": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iXXaFjD40AMb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Decoder With Attention\n",
        "\n",
        "class AttnDecoderRNN(nn.Module):\n",
        "  def __init__(self, hidden_size, output_size, n_layers=1, max_length = MAX_LENGTH, p_dropout=0.1):\n",
        "    super(AttnDecoderRNN, self).__init__()\n",
        "    # params\n",
        "    self.output_size = output_size\n",
        "    self.hidden_size = hidden_size\n",
        "    self.n_layers = n_layers\n",
        "    self.p_dropout = p_dropout\n",
        "    self.max_length = max_length\n",
        "\n",
        "    # layers\n",
        "    self.embedding = nn.Embedding(self.output_size, self.hidden_size)\n",
        "    self.dropout = nn.Dropout(self.p_dropout)\n",
        "    self.attn = nn.Linear(self.hidden_size * 2, self.max_length)\n",
        "    self.attn_combine = nn.Linear(2 * self.hidden_size, self.hidden_size)\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_ouputs):\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_ouputs.unsqueeze(0))\n",
        "\n",
        "    output = self.attn_combine(torch.cat((embedded[0],attn_applied[0]),1)).unsqueeze(0)\n",
        "\n",
        "    output = F.relu(output)\n",
        "    output, hidden = self.gru(output, hidden)\n",
        "\n",
        "    output = self.out(output)\n",
        "    output = F.log_softmax(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": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fzlRcYjyrBBt",
        "colab_type": "text"
      },
      "source": [
        "# Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GAIKZiYcWuUn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Preparing training data \n",
        "\n",
        "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, device=device).view(-1, 1) \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": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SuNxc1jCXNKB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#  for one iteration i.e one input-output pair\n",
        "# adding teacher forcing for quicker convergence\n",
        "\n",
        "teacher_force_ratio = 0.5\n",
        "\n",
        "def train(input_tensor, target_tensor, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion, max_length = MAX_LENGTH):\n",
        "\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(input_tensor[ei], encoder_hidden)\n",
        "    encoder_outputs[ei] = encoder_output[0, 0]\n",
        "\n",
        "  decoder_hidden = encoder_hidden\n",
        "  decoder_input = torch.tensor([[SOS_token]], device=device)\n",
        "\n",
        "  use_teacher_forcing =  True if random.random() < teacher_force_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(decoder_input, decoder_hidden, encoder_outputs)\n",
        "        loss += criterion(decoder_output, target_tensor[di])\n",
        "        decoder_input = target_tensor[di]  # Teacher forcing\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_weights = decoder(decoder_input, decoder_hidden, encoder_outputs)\n",
        "      topv, topi = decoder_output.topk(1)\n",
        "      decoder_input = topi.squeeze().detach() # detach history from input :: why? DOUBT!!!!\n",
        "      \n",
        "      loss += criterion(decoder_output, target_tensor[di])\n",
        "\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\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mBKaOdm9lara",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import math\n",
        "import time\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))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bp6cgKDTq9L_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def trainIters(encoder, decoder, n_iters, print_every = 1000, plot_every=100, learning_rate=0.01):\n",
        "\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",
        "\n",
        "  training_pairs = [tensorsFromPair(random.choice(pairs)) for i in range(n_iters)]\n",
        "\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, 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), iter, iter / n_iters * 100, print_loss_avg))\n",
        "    \n",
        "    if iter % plot_every == 0: \n",
        "      plot_losses.append(plot_loss_total / plot_every)\n",
        "      plot_loss_total = 0\n",
        "  \n",
        "  showPlot(plot_losses)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ylh1-d31uF2A",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.switch_backend('agg')\n",
        "import matplotlib.ticker as ticker\n",
        "import numpy as np\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": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lICniHTAuKIu",
        "colab_type": "code",
        "colab": {}
      },
      "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": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jMBRwBRlv2cE",
        "colab_type": "code",
        "colab": {}
      },
      "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('')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B6jFdLAYv4gb",
        "colab_type": "code",
        "outputId": "db69a0a8-28fb-40c4-aa01-d0cd90e24899",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        }
      },
      "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).to(device)\n",
        "\n",
        "trainIters(encoder1, attn_decoder1, 75000, print_every=5000)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "6m 45s (- 94m 40s) (5000 6%) 2.8522\n",
            "13m 35s (- 88m 20s) (10000 13%) 2.2614\n",
            "20m 22s (- 81m 29s) (15000 20%) 1.9970\n",
            "26m 56s (- 74m 5s) (20000 26%) 1.7066\n",
            "33m 19s (- 66m 39s) (25000 33%) 1.5281\n",
            "40m 25s (- 60m 38s) (30000 40%) 1.3736\n",
            "47m 2s (- 53m 45s) (35000 46%) 1.2194\n",
            "53m 35s (- 46m 53s) (40000 53%) 1.0862\n",
            "60m 18s (- 40m 12s) (45000 60%) 0.9934\n",
            "66m 51s (- 33m 25s) (50000 66%) 0.9064\n",
            "73m 37s (- 26m 46s) (55000 73%) 0.8201\n",
            "80m 14s (- 20m 3s) (60000 80%) 0.7228\n",
            "86m 36s (- 13m 19s) (65000 86%) 0.7060\n",
            "92m 52s (- 6m 38s) (70000 93%) 0.6306\n",
            "99m 18s (- 0m 0s) (75000 100%) 0.5861\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_Jri4kGOv6f1",
        "colab_type": "code",
        "outputId": "0da212dc-70dc-49f0-bbe3-a18a9a0f46ae",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 964
        }
      },
      "source": [
        "%matplotlib inline\n",
        "evaluateRandomly(encoder1, attn_decoder1)\n",
        "\n",
        "output_words, attentions = evaluate(\n",
        "    encoder1, attn_decoder1, \"je suis trop froid .\")\n",
        "plt.matshow(attentions.numpy())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "> nous sommes un peu occupes ici .\n",
            "= we re a little busy here .\n",
            "< we re a little busy here . <EOS>\n",
            "\n",
            "> nous sur pechons dans les oceans du monde .\n",
            "= we are overfishing the world s oceans .\n",
            "< we are on the the library world . <EOS>\n",
            "\n",
            "> il est dans la mouise .\n",
            "= he s in hot water .\n",
            "< he s in in library . <EOS>\n",
            "\n",
            "> j ai peur d y aller .\n",
            "= i am afraid to go .\n",
            "< i am afraid to go . <EOS>\n",
            "\n",
            "> j ai peur des ours .\n",
            "= i am afraid of bears .\n",
            "< i m afraid of spiders . <EOS>\n",
            "\n",
            "> il te regarde .\n",
            "= he s looking at you .\n",
            "< he s being watched . <EOS>\n",
            "\n",
            "> je suis toujours marie .\n",
            "= i m still married .\n",
            "< i m still married . <EOS>\n",
            "\n",
            "> vous cooperez .\n",
            "= you re cooperating .\n",
            "< you re overreacting . <EOS>\n",
            "\n",
            "> vous etes charmants .\n",
            "= you re charming .\n",
            "< you re powerful . <EOS>\n",
            "\n",
            "> tu es ma fille .\n",
            "= you are my daughter .\n",
            "< you are my daughter . <EOS>\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7faeb5843908>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAECCAYAAAAGtFvhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0\ndHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAALQElEQVR4nO3dXYilh13H8d/f3c1ukxYrGMVkg8lF\nrYRiExliNSKYqEltaW8TaC9E2BurqRRK6533UupFEZY0KjQ2SJpCCbHbSFNKQWPzsta8VUJMmzdJ\ngtamCnlp/17sBNNszJx/O2fOM9nPB5bMnD0cfjy7k+8+zzkzp7o7ADDxE5seAMD+Ix4AjIkHAGPi\nAcCYeAAwJh4AjC02HlV1dVV9s6oerqqPbXrPElXVBVV1R1U9UFX3V9V1m960ZFV1oKrurapbN71l\nyarqrVV1c1U9VFUPVtWvbnrTElXVH29/3d1XVZ+tqiOb3rSXFhmPqjqQ5FNJ3p3k4iTXVtXFm121\nSC8l+Uh3X5zkXUn+wHF6XdcleXDTI/aBP0/yxe7+xSTvjGN2mqo6P8kfJdnq7nckOZDkms2u2luL\njEeSy5I83N2PdPcLSW5K8v4Nb1qc7n6qu+/Z/vi5nPoiP3+zq5apqo4meU+S6ze9Zcmq6ieT/EaS\nTydJd7/Q3d/Z7KrFOpjkTVV1MMnZSZ7c8J49tdR4nJ/ksVd8/nj8T/F1VdWFSS5NcudmlyzWJ5N8\nNMkPNj1k4S5K8kySv9y+xHd9VZ2z6VFL091PJPmzJN9O8lSS/+ruL2121d5aajwYqKo3J/lckg93\n93c3vWdpquq9SZ7u7rs3vWUfOJjkl5P8RXdfmuS/k3jO8VWq6qdy6mrIRUnOS3JOVX1gs6v21lLj\n8USSC17x+dHt23iVqjqUU+G4sbtv2fSehbo8yfuq6tGcugR6RVV9ZrOTFuvxJI9398tnsDfnVEz4\nYb+V5N+6+5nufjHJLUl+bcOb9tRS4/H1JG+rqouq6qyceiLqCxvetDhVVTl1bfrB7v7EpvcsVXd/\nvLuPdveFOfV36cvdfUb9K3FV3f3vSR6rqrdv33Rlkgc2OGmpvp3kXVV19vbX4ZU5w15YcHDTA15L\nd79UVR9KciKnXsVwQ3ffv+FZS3R5kg8m+ZeqOrl92590920b3MT+94dJbtz+h9sjSX5vw3sWp7vv\nrKqbk9yTU696vDfJ8c2u2lvlR7IDMLXUy1YALJh4ADAmHgCMiQcAY+IBwNii41FVxza9Yb9wrFbj\nOK3GcVrdmXqsFh2PJGfkH8qPyLFajeO0GsdpdWfksVp6PABYoLV8k+BZdbiP5Mf/QZwv5vkcyuFd\nWJT8wi/9z648zm7612+cvWuPtZvH6o3McVqN47S6N/qxei7/+Wx3n/vq29fy40mO5Jz8Sl25jof+\nkZ04cXLnO+2xq867ZNMTAF7X3/fN33qt2122AmBMPAAYEw8AxsQDgDHxAGBMPAAYEw8AxsQDgDHx\nAGBMPAAYEw8AxsQDgDHxAGBspXhU1dVV9c2qeriqPrbuUQAs247xqKoDST6V5N1JLk5ybVVdvO5h\nACzXKmcelyV5uLsf6e4XktyU5P3rnQXAkq0Sj/OTPPaKzx/fvg2AM9SuvZNgVR3L9hvBH8nuvb0q\nAMuzypnHE0kueMXnR7dv+yHdfby7t7p76438fr4ArBaPryd5W1VdVFVnJbkmyRfWOwuAJdvxslV3\nv1RVH0pyIsmBJDd09/1rXwbAYq30nEd335bktjVvAWCf8B3mAIyJBwBj4gHAmHgAMCYeAIyJBwBj\n4gHAmHgAMCYeAIyJBwBj4gHAmHgAMLZrbwa1dFedd8mmJ+wbJ548uekJp/HnB8vizAOAMfEAYEw8\nABgTDwDGxAOAMfEAYEw8ABgTDwDGxAOAMfEAYEw8ABgTDwDGxAOAMfEAYEw8ABjbMR5VdUNVPV1V\n9+3FIACWb5Uzj79KcvWadwCwj+wYj+7+apL/2IMtAOwTnvMAYGzX3sO8qo4lOZYkR3L2bj0sAAu0\na2ce3X28u7e6e+tQDu/WwwKwQC5bATC2ykt1P5vkH5K8vaoer6rfX/8sAJZsx+c8uvvavRgCwP7h\nshUAY+IBwJh4ADAmHgCMiQcAY+IBwJh4ADAmHgCMiQcAY+IBwJh4ADAmHgCMiQcAY+IBwJh4ADAm\nHgCMiQcAY+IBwJh4ADAmHgCMiQcAY+IBwJh4ADAmHgCMiQcAY+IBwJh4ADAmHgCM7RiPqrqgqu6o\nqgeq6v6qum4vhgGwXAdXuM9LST7S3fdU1VuS3F1Vt3f3A2veBsBC7Xjm0d1Pdfc92x8/l+TBJOev\nexgAyzV6zqOqLkxyaZI71zEGgP1hlctWSZKqenOSzyX5cHd/9zV+/1iSY0lyJGfv2kAAlmelM4+q\nOpRT4bixu295rft09/Hu3ururUM5vJsbAViYVV5tVUk+neTB7v7E+icBsHSrnHlcnuSDSa6oqpPb\nv353zbsAWLAdn/Po7q8lqT3YAsA+4TvMARgTDwDGxAOAMfEAYEw8ABgTDwDGxAOAMfEAYEw8ABgT\nDwDGxAOAMfEAYEw8ABhb+Z0EOXNcdd4lm55wmhNPntz0hNMs8TjBXnHmAcCYeAAwJh4AjIkHAGPi\nAcCYeAAwJh4AjIkHAGPiAcCYeAAwJh4AjIkHAGPiAcCYeAAwtmM8qupIVf1TVf1zVd1fVX+6F8MA\nWK5V3s/j+SRXdPf3qupQkq9V1d919z+ueRsAC7VjPLq7k3xv+9ND2796naMAWLaVnvOoqgNVdTLJ\n00lu7+471zsLgCVbKR7d/f3uviTJ0SSXVdU7Xn2fqjpWVXdV1V0v5vnd3gnAgoxebdXd30lyR5Kr\nX+P3jnf3VndvHcrh3doHwAKt8mqrc6vqrdsfvynJbyd5aN3DAFiuVV5t9XNJ/rqqDuRUbP62u29d\n7ywAlmyVV1t9I8mle7AFgH3Cd5gDMCYeAIyJBwBj4gHAmHgAMCYeAIyJBwBj4gHAmHgAMCYeAIyJ\nBwBj4gHAmHgAMLbKj2SHjbvqvEs2PeE0J548uekJp1niceKNyZkHAGPiAcCYeAAwJh4AjIkHAGPi\nAcCYeAAwJh4AjIkHAGPiAcCYeAAwJh4AjIkHAGPiAcCYeAAwtnI8qupAVd1bVbeucxAAyzc587gu\nyYPrGgLA/rFSPKrqaJL3JLl+vXMA2A9WPfP4ZJKPJvnB/3eHqjpWVXdV1V0v5vldGQfAMu0Yj6p6\nb5Knu/vu17tfdx/v7q3u3jqUw7s2EIDlWeXM4/Ik76uqR5PclOSKqvrMWlcBsGg7xqO7P97dR7v7\nwiTXJPlyd39g7csAWCzf5wHA2MHJnbv7K0m+spYlAOwbzjwAGBMPAMbEA4Ax8QBgTDwAGBMPAMbE\nA4Ax8QBgTDwAGBMPAMbEA4Ax8QBgTDwAGBv9VF3g/1x13iWbnsCP4cSTJzc94TT76e+UMw8AxsQD\ngDHxAGBMPAAYEw8AxsQDgDHxAGBMPAAYEw8AxsQDgDHxAGBMPAAYEw8AxsQDgLGVfiR7VT2a5Lkk\n30/yUndvrXMUAMs2eT+P3+zuZ9e2BIB9w2UrAMZWjUcn+VJV3V1Vx9Y5CIDlW/Wy1a939xNV9TNJ\nbq+qh7r7q6+8w3ZUjiXJkZy9yzMBWJKVzjy6+4nt/z6d5PNJLnuN+xzv7q3u3jqUw7u7EoBF2TEe\nVXVOVb3l5Y+T/E6S+9Y9DIDlWuWy1c8m+XxVvXz/v+nuL651FQCLtmM8uvuRJO/cgy0A7BNeqgvA\nmHgAMCYeAIyJBwBj4gHAmHgAMCYeAIyJBwBj4gHAmHgAMCYeAIyJBwBj4gHAWHX37j9o1TNJvrUL\nD/XTSZ7dhcc5EzhWq3GcVuM4re6Nfqx+vrvPffWNa4nHbqmqu7p7a9M79gPHajWO02ocp9WdqcfK\nZSsAxsQDgLGlx+P4pgfsI47Vahyn1ThOqzsjj9Win/MAYJmWfuYBwAKJBwBj4gHAmHgAMCYeAIz9\nL5MjPLfgr4LsAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 480x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QiyN1SoqjQvY",
        "colab_type": "code",
        "outputId": "2ff06a4d-6ade-4079-8883-04e056e4a05b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "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)\n",
        "\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 .\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "input = elle a cinq ans de moins que moi .\n",
            "output = she is three years younger than me . <EOS>\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWIAAAEZCAYAAACtuS94AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0\ndHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3debgdVZ3u8e+bgKBAiwoOzRRQHAIy\nJURsUFGRG2iEbkUBRRtR41VRbBUuKhcU9bkq7YAtKlHBeaARlYtpURAaRZQkJAQSjUSGJghiEBFQ\nhpzz9h9VBzaHM+yTVO3aw/vhqefUrqq91qrDzu+svWoNsk1ERDRnWtMFiIgYdAnEERENSyCOiGhY\nAnFERMMSiCMiGpZAHBHRsATiiIiGJRBHRDQsgTgiomEJxBHRESp8X9Kzmi5Lt0kgjohO2R/YE3hD\n0wXpNgnEEdEpr6cIwi+VtEHThekmCcQRUTtJWwA72f5P4ELgnxouUldJII6ITngN8K1y/yzSPPEw\nCcQR0QlHUwRgbC8EniJpm2aL1D0SiKPvSdpb0ibl/pGSPiFpu6bLNSgkbQ58xvbNLYffDWzRUJG6\njjIxfPQ7ScuAXYFdgC8DXwReafsFTZYrYkRqxDEI1rqocRxCUTM7Hdis4TINBElvlLRjuS9JZ0n6\ni6RlknZvunzdIoE4BsFdkt4DHAn8UNI0YMOGyzQojgVuKPePoPhWsj3wTuDTDZWp6yQQxyA4DLgP\neL3tW4GtgVObLdLAWGv7gXL/IOCrtm+3fSGwSYPl6ippI46I2ki6EvhH4A7gRuBFtpeX535tO8Od\nSY04BoCkl0m6VtKdZfvkXZL+0nS5BsRJwCKK5onzWoLwC4DrGixXV0mNOPqepFXAS23/uumyDKJy\nOPNmtu9oObYJRfy5u7mSdY+M945B8IcE4UY9HnirpJ3K18uBz9r+Q4Nl6iqpEfc4SXtMdN72lZ0q\nS7eSdBrwZOD7FA/tALB9bmOFGhCS9ga+SdF/e3F5eBbwL8CrbV/WUNG6SgJxj5P0S2APYBkg4NkU\nH/h7Adt+UYPF6wqSzhrjsG0f3fHCDJjy8/lm20tGHd8NOMP2c5opWXdJ00Tv+z3wRttXA0jaGXi/\n7UObLVb3sP26uvMoh0zvaPtCSY8GNrB9V9359oC/Gx2EAWwvlZRBNaUEYkDSPhT/iM6StCWwqe3r\nmy5Xm54xEoQBbF9T5woIkh4HbGN7WV15VEXS8bY/JunfgUd89bP99oryeSMwj6It9KkU/ZQ/D7y4\ngrQ7cg81kqTHtT6oKw8+nvTaetDAB2JJJwOzgWdQzA61IfB1YO8myzUFyyR9kaLMAK+maKaojKRL\ngIMpPi+LgdskXWb7nVXmU4ORB3SLas7nrcAc4FcAtq+V9MSK0u7UPdTlk8CPJb0bGHleMQv4aHku\nSBsxkpYCuwNX2t69PLbM9i7Nlqw9kjYG3gw8vzx0KfA52/dWmMcS27tLegNFbfjkXvodjZC0KUDV\nXaYk/cr2c1p+TxtQfJ4q//3UdQ91knQQcDywE0WtfgVwqu3/32jBusjA14iB+21bkuHB/o09owy4\nn6Te2sUGkp4CvBJ4X4351KJsN/8aRdOBJP0ReO3I4IIK/Jek9wKPlvQS4C1ApUGmA/dQG9vnA+c3\nXY5uljYaOFvSGcDmZVvfhcAXGi5T28q5dn8i6beSrhvZKs7mFOACYJXthZJ2AK6tOI86zQfeaXs7\n29sC76La/8cnAH8ErgbeBCwATqwwfaj/Hmoh6eyW/Y+OOvfjzpeoOw180wRAWYvZn6L71wW2f9Jw\nkdom6TfAv1K03Q6NHLd9e2OF6jKSrrK962THulmv3sNIc025f6XtPcY6N+jSNAGUgbdngu8od5YL\nMtam7EnyRmAGLZ+ZqvrhSno68DngSbZ3lrQLcLDtD1WRPnCdpP9L8dUeiukwK/vWIOl6xu7RsENV\neVDzPdRooppeaoGlgQ3Eku5i7A+CKDr7/12Hi7SuLpZ0KnAuDx81VuWIuh8AP6Nothma5Np18QXg\nOOAMANvLJH0TqCoQHw18APhu+fpnQJV9i2e37G8MvIKiLbdKdd9DXR5TTgA/jaINfXeKf2MCHt1o\nybpImiZ6nKSLxzhc6Yg6SUtt71ZVemOkv9D2nqO+xlaWp6TZFA8ZZ/BQ5cN19vqQtNj2rArT6/g9\nVGGcz+eDbL+wU2XpZoNcI56wxmL7T50qy/ro0Af5fEkH2l5QU/prJD2V8huKpEOBWypM/xsUi1Ve\nAwxXmC7wiPk+plHUkKv+t1XrPdQlgbY9A1sjbmnXEw81Uaj86Yrb9yon6UjbX5c05qAK25+oMK+7\nKFZTuA94gIqbb8peGPOBf6CYQPx6iglhbqwo/Z/b3qeKtMZJ/2Ie+gytpZh7999s/7bCPGq9hzqV\nQ76fbvuqlmPbAkOjVnYeWANbI7a9PUC5ftmrge1tn1J+QJ5SZV7lsOAdKdoPR/K/dD2THenvPNZ4\n/Ur/utrerPwG8bB7WF+j/ogsAC6mqFHeA7wcqOqPycnl6MOLqGf2tfN56I865f5BkkbyqeI+6r6H\nOq0FzpW0i+17ymNfBN4LJBAzwIG4xekUX/VeRNFf9i6KByJ7VpF4ORrtWIr5B5YCewGXl/mtM9tn\nlLs7AMfa/nOZ3+OAj69P2qONcw+/YP3nUhj5I/IMit/3DyiC2WuAK9Yz7VavA55JMXx95Gu9KR5w\nVmEWDy//SynKX2Vf67rvoTa2H5D0PYoBQWeVlZ0tbffqsO3q2R7ojWIoKsCSlmNXVZj+1RS1yKXl\n62cC51aY/pJ2jnX5PVxKsYLDyOvNgEsrTH9lzZ+hWsvfiXuoeys/M5eW+ycCb2+6TN20ZWQdPCBp\nOg89KNqSah+G3Oty3gdJG9n+DUUNsCrTylowZR6Pp/pvOnXfw5OA+1te318eq8ovJM2sML3R6i4/\n1H8PtSo/Myr7jB/OQ/2hgzRNAHwa+B7wREkfBg6l2uGpqyVtTrE6xE8kjaxmW5WPA5dL+o/y9SuA\nD1eYPtR/D18Frii/vgL8E8WKDlXZC1haPqC9j4ceNlbV9avu8kP99/AIkp5s+9YKk/wSRdvw1R41\nLeagG9heE60kPZOivVPARa5pfTMVK9c+FviR7fsnu34K6c7koTbnn9peUVXaY+RV1z3sATyvfHmp\nx5hMfD3S3m6s466oV0aZR23lL9Ov/R7GyPOHtv+xwvQeQ9Et8eW2L6wq3X6QQBwR0bC0EUdENCyB\neBRJ85J+0u/W9DuRR6+nXzdJZ0q6TdI145yXpE9LWiVpmSZZaR0SiMdS94ck6Sf9bs+j19Ov25eB\nuROcP4Bi8NOOFPf6uckSTCCOiJgCF6NiJ5qL5hDgqy78kmLRiQlH6/Z19zWVyx/V9b5Zs6Y+uda2\n227L7Nmz20p/8eLFU04f1v2+k35vpN+JPLos/TW2t1yf/ObOnes1a9a0de3ixYuXA61rPs63PX8K\n2W0F3NTyenV5bNyJrPo6ENftioULa01/+rROfGHR5Jesl/TKifW23l301qxZw6JF7Y2olnSv7dmT\nX1mdBOKIGAgd7Kp7M7BNy+utmWRyo7QRR0TfMzA0PNzWVoHzgNeWvSf2oljObML5tVMjjogBYFxR\nM5mkbwH7AltIWg2cTDErHrY/TzGl64HAKuCvtLGkVQJxRPQ/w3BFLRO2j5jkvIG3TiXNBOKIGAjd\nPJ1DAnFE9D0DwwnEERHNSo14CiTdAMy23V7v64iISdiuqkdELbouEEdE1KGba8SN9iOWtImkH0q6\nStI1kg4rT71N0pWSri4nbR+59kxJV0haIumQBoseET3Gbf7XhKYHdMwFfm97V9s7Az8qj6+xvQfF\nrEXvLo+9j2L1iTnAC4FTJW0yOkFJ8yQtkpQVYiMCGHlY197WhKYD8dXASyR9VNLzbN9ZHh9ZInwx\nMKPc3x84QdJS4BKKVYW3HZ2g7fm2Z3d6rHhEdLd2V1RuQqNtxLZ/W06afCDwIUkXlafuK38O8VAZ\nRbHW1coOFzMiel2XP6xruo3474G/2v46cCow0Uz2F1C0Hat87+4dKGJE9AGTGvFEnk3R1jsMPAC8\nGThnnGs/CHwKWCZpGnA9cFBHShkRPS8DOsZh+wKKmm6rGS3nF1FMroHtvwFv6lTZIqK/dHP3taZr\nxBERHdBc17R2JBBHRN9zg13T2pFAHBEDYbiLe00kEEdE38vsaxERXSAP6yIimmSnRtyvOrPcfb3s\netvNyvE3EY1LjTgiokEGhhKIIyKalRpxRETDEogjIhrkPKyLiGheasQREQ1LII6IaFDRayJDnCMi\nGtXNk/70xIgESb9ougwR0cPaXJ1jUFfoaIvtf2i6DBHRu0aWSupWvVIjvrv8+RRJl0paKukaSc9r\numwR0RuGyy5sk21N6IkacYtXARfY/rCk6cBjmi5QRPSGbq4R91ogXgicKWlD4Pu2l46+QNI8YF7H\nSxYRXcs2Q108MXxPNE2MsH0p8HzgZuDLkl47xjXzbc+2PbvjBYyIruU2/2tCT9WIJW0HrLb9BUkb\nAXsAX224WBHRA9J9rTr7AldJWgIcBpzWbHEioheM9JqoovuapLmSVkpaJemEMc5vK+liSUskLZN0\n4GRp9kSN2Pam5c+vAF9puDgR0YOqeFhXdhI4HXgJsBpYKOk82ytaLjsRONv25yTNBBYAMyZKtycC\ncUTEeqnuYd0cYJXt6wAkfRs4BGgNxAb+rtx/LPD7yRJNII6IvlfhgI6tgJtaXq8GnjPqmvcDP5b0\nNmATYL/JEu21NuKIiHUyhQEdW0ha1LJNtTvsEcCXbW8NHAh8TdKEsTY14ogYCFPomrZmgu6vNwPb\ntLzeujzW6vXAXADbl0vaGNgCuG28DFMjjoiBYLe3TWIhsKOk7SU9CjgcOG/UNf8NvBhA0rOAjYE/\nTpRoasQR0fcMlcwjYXutpGOAC4DpwJm2l0s6BVhk+zzgXcAXJP1rmfVRnqSBOoE4IvpfhUOcbS+g\n6JLWeuyklv0VwN5TSTOBOCL6XrdPg5lAHBEDIYE4IqJhTc013I4E4ogYAM3NrNaOBOKI6Httdk1r\nTAJxRAyEbp4YPoE4IvpeVf2I65JAHBEDoZt7TdQ2xFnS5pLeUu7vK+n8uvKKiJhQm5PCNxWs65xr\nYnPgLVN5QznpckRE9SqabKIOdTZNfAR4qqSlwAPAPZLOAXYGFgNH2rakG4DvUMx4/zFJfwI+AGwE\n/A54ne27Jc0CPgFsCqyhGL99S43lj4g+Mjw0gE0TwAnA72zvBhwH7A68A5gJ7MDDx2LfbnsP4EKK\nZUb2K18vAt4paUPg34FDbc8CzgQ+XGPZI6KPFJXd7m2a6OTDuitsrwYoa8kzgJ+X575T/tyLIlBf\nJgngUcDlwDMoatI/KY9PB8asDZeTOE91IueI6HPd/LCuk4H4vpb9oVF531P+FPAT20e0vlHSs4Hl\ntp87WSa25wPzy/d1728+IjqoudpuO+psmrgL2GyK7/klsLekpwFI2kTS04GVwJaSnlse31DSTpWW\nNiL6mofd1taE2mrEtm+XdJmka4C/AX9o4z1/lHQU8C1JG5WHT7T9W0mHAp+W9Niy3J8CltdU/Ijo\nIyNtxN2q1qYJ268a5/gxLfszRp37KbDnGO9ZCjy/4iJGxIBwhjhHRDSriyvECcQRMQDcXPtvOxKI\nI2IgDGwbcUREN8iadRERXSCBOCKiSTYeSq+JiIhGpUYcXaucu6M2t/z5z7Wm/4xtn1Zr+n/5y5pa\n04/O6eI4nEAcEf0vD+siIpo2yEOcIyK6gxnOw7qIiGalRhwR0aCBnn0tIqJrJBBHRDTL3dtEnEAc\nEYMhTRMREU2yGc7E8OtP0nTbQ02XIyJ6T7cP6Khl8VBJp0h6R8vrD0s6VtJxkhZKWibpAy3nvy9p\nsaTlkua1HL9b0sclXQU8V9JHJK0o3/9vdZQ9IvqQq1s8VNJcSSslrZJ0wjjXvLKMVcslfXOyNOta\nxflM4LVlgaYBhwO3AjsCc4DdgFmSRtagO9r2LGA28HZJTyiPbwL8yvauwK+BfwZ2sr0L8KGxMpY0\nT9IiSYvqubWI6ElFH7bJtwlImg6cDhwAzASOkDRz1DU7Au8B9ra9E/CORyQ0Si2B2PYNwO2Sdgf2\nB5ZQLAg6sn8l8EyKwAxF8L0K+CWwTcvxIeC75f6dwL3AlyS9DPjrOHnPtz3b9uyq7ysiepWx29sm\nMQdYZfs62/cD3wYOGXXNG4HTbd8BYPu2yRKts434i8BRwJMpasgvBv6f7TNaL5K0L7Af8Fzbf5V0\nCbBxefrekXZh22slzSnTORQ4BnhRjeWPiD4y3P6adVuM+kY93/b8cn8r4KaWc6uB54x6/9MBJF0G\nTAfeb/tHE2VYZyD+HnAKsCHwKmAt8EFJ37B9t6StgAeAxwJ3lEH4mcBeYyUmaVPgMbYXlDd4XY1l\nj4g+4rKNuE1r1vMb9QYU3+r3BbYGLpX0bNvjzglbWyC2fb+ki4E/l7XaH0t6FnB5OQfu3cCRwI+A\n/y3p18BKiuaJsWwG/EDSxoCAd9ZV9ojoPxX1mriZovl0xNblsVarKZ5tPQBcL+m3FIF54XiJ1haI\ny4d0ewGvGDlm+zTgtDEuP2CsNGxv2rJ/C0X7TETElFUUiBcCO0raniIAH07xjb/V94EjgLMkbUHR\nVDHhN/i6uq/NBFYBF9m+to48IiLaV83DOttrKZ5PXUDRk+ts28vLLrsHl5ddQNFZYQVwMXCc7dsn\nSreWGrHtFcAOdaQdETFlFc6+ZnsBsGDUsZNa9k3RdNp282nPjKyLiFhXBjzUvSPrEogjYiB08xDn\nBOKI6H/tDdZoTAJxRAyEKfQj7rgE4qjVUzbfvNb0667llH3eow+kRhwR0aBunwYzgTgi+p+NMzF8\nRESzsmZdRETD0jQREdGkCkfW1SGBOCL6Xh7WRUQ0zgwPdW8jcQJxRPS/NE1ERHSBBOJ6SJo+sqZd\nRMREujgOTzwxfDnZ8TtaXn9Y0rGSTpV0jaSrJR1WnttX0vkt135G0lHl/g2SPiDpyvI9zyyPbynp\nJ5KWS/qipBvLGe2RdKSkKyQtlXRGuYw1ku6W9PFy1efnVv0LiYj+M/KwroJVnGsx2QodZwKvhQeX\nPjqcYj2m3YBdKVZfPlXSU9rIa43tPYDPAe8uj50M/NT2TsA5wLZlXs8CDgP2tr0bMAS8unzPJhTr\nQe1q++ejM5E0T9KiUauwRsQgKxcPbWdrwoRNE7ZvkHS7pN2BJwFLgH2Ab5VNAn+Q9F/AnsBfJsnr\n3PLnYuBl5f4+wD+Xef1I0h3l8RcDs4CF5aQrjwZuK88NAd+doMzzgfkAkrr4y0hEdI4Z7vEhzl8E\njgKeTFFDfsk4163l4TXsjUedv6/8OdRGvgK+Yvs9Y5y7N+3CETFV3dxrop3FQ78HzKWo9V4A/Aw4\nTNJ0SVsCzweuAG4EZkraSNLmFLXayVwGvBJA0v7A48rjFwGHSnpiee7xkrZr/7YiIkax29saMGmN\n2Pb9ki4G/mx7SNL3KB6SXUXRBn687VsBJJ0NXANcT9GMMZkPAN+S9BrgcuBW4C7baySdCPy4bJt+\nAHgrRbCPiJgSu8cnhi8D4V7AK+DBFUqPK7eHsX08cPwYx2e07C8C9i1f3gn8L9trJT0X2NP2feV1\n3wG+M0Zam05W5oiI0bq4ZWLiQCxpJnA+8D3b19aQ/7bA2WWwvx94Yw15RMTA6+E162yvAHaoK/My\nuO9eV/oREQCYnu81ERHR00yPtxFHRPSDnm2aiIjoD811TWtHAnFE9L9MgxlRn6LDTe9aO1T/INEN\npk+vPY9eMDyUQBwR0ZgslRQR0bQ0TURENK2HB3RERPSLBOKIiIZ184CO3n7kHBHRhpHZ16pYoUPS\nXEkrJa2SdMIE171ckiXNnizNBOKIGAhVrFlXrp15OnAAMBM4opwcbfR1mwHHAr9qp2wJxBExANoL\nwm20I88BVtm+zvb9wLeBQ8a47oPAR4F72yldxwKxpM0lvaXcf9iKzxERtaquaWIr4KaW16vLYw+S\ntAewje0ftlu8TtaINwfe0sH8IiIeNIUa8RYjK8GX27x28yjnVv8E8K6plK2TvSY+AjxV0lKKpY/u\nkXQOsDPFys5H2rakk4CXUqzc/AvgTeXxSyjaW15IEdRfb/tnHSx/RPSoKY6sW2N7vAdsNwPbtLze\nujw2YjOKmHZJuQL9k4HzJB1crk40pk7WiE8Afmd7N4pllnYH3kHR4L0DsHd53Wds72l7Z4pgfFBL\nGhvYnlO+7+SxMpE0b+QvWU33ERE9x3h4uK1tEguBHSVtL+lRwOHAeQ/mYt9pewvbM8ol4n4JTBiE\nodmHdVfYXm17GFgKzCiPv1DSryRdDbwI2KnlPeeWPxe3XP8wtufbnj3BX7SIGDQGD7e3TZiMvRY4\nhmJF+18DZ9teLukUSQeva/GaHNBxX8v+ELCBpI2BzwKzbd8k6f3AxmO8Z4gMRomIKahqZJ3tBcCC\nUcdOGufafdtJs5M14rso2k8mMhJ010jaFDi03iJFxKCoqPtaLTpWq7R9u6TLJF0D/A34wxjX/FnS\nF4BrgFsp2mMiItZLpsFsYftV4xw/pmX/RODEMa7Zt2V/DeO0EUdEPILN8FBWcY6IaFZqxBERzTIJ\nxBERjXFW6IiIaJrxZJ2EG5RAHBEDITXiiIiGDU8+fLkxCcTR47q3ltOO6dMyJXgnFIM1EogjIpqV\npomIiGal+1pERMPysC4iolFmeHio6UKMK4E4IvpeBnRERHSBBOKIiIYlEEdENMrpvhYR0TSTAR0R\nEY2xu3uIc9eMr5Q0Q9JvJH1Z0m8lfUPSfuXyStdKmiNpE0lnSrpC0hJJhzRd7ojoBe2tV9f3a9a1\n6WnAK4CjKdarexWwD3Aw8F5gBfBT20dL2hy4QtKFtu8ZSUDSPGBex0seEV0tc02073rbVwNIWg5c\nZNuSrqZYo25r4GBJ7y6v3xjYFvj1SAK25wPzyzS6t3U+IjoqvSbad1/L/nDL62GKsg4BL7e9stMF\ni4je1s2BuGvaiNt0AfA2SQKQtHvD5YmIXmC3vzWg22rEk/kg8ClgmaRpwPXAQc0WKSK6nYFhZ66J\nSdm+Adi55fVR45x7UyfLFRH9oLkeEe3omkAcEVGnBOKIiIYlEEdENKh4Dpd+xBERDTLu4iHOCcQR\nMRCyZl1ERMPSRhwR0SinjTgiokndvmZdrw1xjohYJ1VNgylprqSVklZJOmGM8++UtELSMkkXSdpu\nsjQTiCNiIAwPD7e1TUTSdOB04ABgJnCEpJmjLlsCzLa9C3AO8LHJypZAHBEDwODh9raJzQFW2b7O\n9v3At4GHLVBh+2Lbfy1f/pJi+t4JJRBHxEBwm/8BW0ha1LK1LjSxFXBTy+vV5bHxvB74z8nKlod1\nEdH3pviwbo3t2eubp6QjgdnACya7NoE4IgZCRb0mbga2aXm9dXnsYSTtB7wPeIHt+0afHy2BOCIG\nQGX9iBcCO0raniIAH06xtuaDygUrzgDm2r6tnUQTiCNiIEzWI6IdttdKOoZitaDpwJm2l0s6BVhk\n+zzgVGBT4D/KxYT+2/bBE6WbQBwRfa/KAR22FwALRh07qWV/v6mmmUAcEQOgufXo2pFAHBEDwWSu\niY4p+/zNm/TCiBgo3TzXRN8FYtvzgfkAkrr3Nx8RHeRKHtbVpe8CcUTEaN2+VFLPDnGWtEDS3zdd\njojoDVXNvlaHnq0R2z6w6TJERO9IG3FERKPSfS0ionFZPDQiokE2DA8PNV2McSUQR8QAaO5BXDsS\niCNiICQQR0Q0LIE4IqJh3TygI4E4Ivqf030tIqJRBoZTI46IaFaaJiIiGpXuaxERjUsgjohoUJVr\n1tUhgTgiBoBxhjhHRDSrmyf9qWVieEmXSFopaWm5ndNybp6k35TbFZL2aTl3kKQlkq6StELSm+oo\nX0QMnoGYGF7So4ANbd9THnq17UWjrjkIeBOwj+01kvYAvi9pDnA7xVpzc2yvlrQRMKN83+Ns31FV\nWSNi8HRzG/F614glPUvSx4GVwNMnufz/AMfZXgNg+0rgK8Bbgc0o/jDcXp67z/bK8n2HSbpG0rsk\nbbm+ZY6IwVLUdofb2pqwToFY0iaSXifp58AXgBXALraXtFz2jZamiVPLYzsBi0cltwjYyfafgPOA\nGyV9S9KrJU0DsP154ADgMcClks6RNHfkfETEZPqxaeIWYBnwBtu/GeeaRzRNTMb2GyQ9G9gPeDfw\nEuCo8txNwAclfYgiKJ9JEcQPbk1D0jxg3lTyjYj+NzzcvSPr1rVGeShwM3CupJMkbdfm+1YAs0Yd\nmwUsH3lh+2rbn6QIwi9vvbBsS/4s8GngbOA9ozOwPd/2bNuz272ZiBgAIxP/TLY1YJ0Cse0f2z4M\neB5wJ/ADSRdKmjHJWz8GfFTSEwAk7UZR4/2spE0l7dty7W7AjeV1+0taBnwIuBiYafsdtpcTETEp\nY4bb2pqwXr0mbN8OnAacVtZWW3tMf0PS38r9Nbb3s32epK2AX0gycBdwpO1bJG0GHC/pDOBvwD2U\nzRIUD/BeavvG9SlvRAymbh9Zp24u3Poqg31E1+rEvz9JtedRs8Xr29Q4bdp0b7TRo9u69t5771nv\n/KYqI+siYiB0c6UzgTgiBoAZzlwTERHN6fY24gyIiIjBUFH3tXIw2UpJqySdMMb5jSR9pzz/qzZ6\nkyUQR8QgcNv/TUTSdOB0ikFlM4EjJM0cddnrgTtsPw34JPDRyUqXQBwRA6GiuSbmAKtsX2f7fuDb\nwCGjrjmEYg4dgHOAF2uSritpI46IgVDREOetgJtaXq8GnjPeNbbXSroTeAKwZrxE+z0Qr6EcnTcF\nWzDBL6wCST/pP2gd+/h21T10IP12p1CYyAVlvu3YWFLrPDnzbc+voAzj6utAbHvKU2ZKWlRnZ+6k\nn/S7PY9eT38studWlNTNwDYtr7cuj411zWpJGwCPpZzedzxpI46IaN9CYEdJ25eLYRxOMX1vq/OA\nfyn3DwV+6kn6zvV1jTgiokplm+8xFE0d04EzbS+XdAqwyPZ5wJeAr0laBfyJIlhPKIH4kWptC0r6\nSb8H8uj19GtlewGwYNSxkxDxvY0AAAA7SURBVFr27wVeMZU0+3rSn4iIXpA24oiIhiUQR0Q0LIE4\nIqJhCcQREQ1LII6IaFgCcUREwxKIIyIa9j87QoVruCsN4gAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "input = elle est trop petit .\n",
            "output = she is too short . <EOS>\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAD9CAYAAAC2l2x5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "input = je ne crains pas de mourir .\n",
            "output = i m not scared of dying . <EOS>\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEYCAYAAABWae38AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nGur/A89J33cX1/WBAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "input = c est un jeune directeur plein de talent .\n",
            "output = he s a talented young . <EOS>\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAETCAYAAADah9Z7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIyIaJEE/IqJB/j+HLc2ULI2dDgAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hyc26Cv5jods",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}