S4D_seq2seq_translation_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"3\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NLP From Scratch: Translation with a Sequence to Sequence Network and Attention\n",
    "===============================================================================\n",
    "\n",
    "**Author**: [Sean Robertson](https://github.com/spro)\n",
    "\n",
    "This is the third and final tutorial on doing \\\"NLP From Scratch\\\",\n",
    "where we write our own classes and functions to preprocess the data to\n",
    "do our NLP modeling tasks. We hope after you complete this tutorial that\n",
    "you\\'ll proceed to learn how [torchtext]{.title-ref} can handle much of\n",
    "this preprocessing for you in the three tutorials immediately following\n",
    "this one.\n",
    "\n",
    "In this project we will be teaching a neural network to translate from\n",
    "French to English.\n",
    "\n",
    "``` {.sourceCode .sh}\n",
    "[KEY: > input, = target, < output]\n",
    "\n",
    "> il est en train de peindre un tableau .\n",
    "= he is painting a picture .\n",
    "< he is painting a picture .\n",
    "\n",
    "> pourquoi ne pas essayer ce vin delicieux ?\n",
    "= why not try that delicious wine ?\n",
    "< why not try that delicious wine ?\n",
    "\n",
    "> elle n est pas poete mais romanciere .\n",
    "= she is not a poet but a novelist .\n",
    "< she not not a poet but a novelist .\n",
    "\n",
    "> vous etes trop maigre .\n",
    "= you re too skinny .\n",
    "< you re all alone .\n",
    "```\n",
    "\n",
    "\\... to varying degrees of success.\n",
    "\n",
    "This is made possible by the simple but powerful idea of the [sequence\n",
    "to sequence network](https://arxiv.org/abs/1409.3215), in which two\n",
    "recurrent neural networks work together to transform one sequence to\n",
    "another. An encoder network condenses an input sequence into a vector,\n",
    "and a decoder network unfolds that vector into a new sequence.\n",
    "\n",
    "![](https://pytorch.org/tutorials/_static/img/seq-seq-images/seq2seq.png)\n",
    "\n",
    "To improve upon this model we\\'ll use an [attention\n",
    "mechanism](https://arxiv.org/abs/1409.0473), which lets the decoder\n",
    "learn to focus over a specific range of the input sequence.\n",
    "\n",
    "**Recommended Reading:**\n",
    "\n",
    "I assume you have at least installed PyTorch, know Python, and\n",
    "understand Tensors:\n",
    "\n",
    "-   <https://pytorch.org/> For installation instructions\n",
    "-   `/beginner/deep_learning_60min_blitz`{.interpreted-text role=\"doc\"}\n",
    "    to get started with PyTorch in general\n",
    "-   `/beginner/pytorch_with_examples`{.interpreted-text role=\"doc\"} for\n",
    "    a wide and deep overview\n",
    "-   `/beginner/former_torchies_tutorial`{.interpreted-text role=\"doc\"}\n",
    "    if you are former Lua Torch user\n",
    "\n",
    "It would also be useful to know about Sequence to Sequence networks and\n",
    "how they work:\n",
    "\n",
    "-   [Learning Phrase Representations using RNN Encoder-Decoder for\n",
    "    Statistical Machine Translation](https://arxiv.org/abs/1406.1078)\n",
    "-   [Sequence to Sequence Learning with Neural\n",
    "    Networks](https://arxiv.org/abs/1409.3215)\n",
    "-   [Neural Machine Translation by Jointly Learning to Align and\n",
    "    Translate](https://arxiv.org/abs/1409.0473)\n",
    "-   [A Neural Conversational Model](https://arxiv.org/abs/1506.05869)\n",
    "\n",
    "You will also find the previous tutorials on\n",
    "`/intermediate/char_rnn_classification_tutorial`{.interpreted-text\n",
    "role=\"doc\"} and\n",
    "`/intermediate/char_rnn_generation_tutorial`{.interpreted-text\n",
    "role=\"doc\"} helpful as those concepts are very similar to the Encoder\n",
    "and Decoder models, respectively.\n",
    "\n",
    "**Requirements**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from __future__ import unicode_literals, print_function, division\n",
    "from io import open\n",
    "import unicodedata\n",
    "import re\n",
    "import random\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import numpy as np\n",
    "from torch.utils.data import TensorDataset, DataLoader, RandomSampler\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "# load_ckpt = True\n",
    "load_ckpt = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loading data files\n",
    "==================\n",
    "\n",
    "The data for this project is a set of many thousands of English to\n",
    "French translation pairs.\n",
    "\n",
    "[This question on Open Data Stack\n",
    "Exchange](https://opendata.stackexchange.com/questions/3888/dataset-of-sentences-translated-into-many-languages)\n",
    "pointed me to the open translation site <https://tatoeba.org/> which has\n",
    "downloads available at <https://tatoeba.org/eng/downloads> - and better\n",
    "yet, someone did the extra work of splitting language pairs into\n",
    "individual text files here: <https://www.manythings.org/anki/>\n",
    "\n",
    "The English to French pairs are too big to include in the repository, so\n",
    "download to `data/eng-fra.txt` before continuing. The file is a tab\n",
    "separated list of translation pairs:\n",
    "\n",
    "``` {.sourceCode .sh}\n",
    "I am cold.    J'ai froid.\n",
    "```\n",
    "\n",
    "<div style=\"background-color: #54c7ec; color: #fff; font-weight: 700; padding-left: 10px; padding-top: 5px; padding-bottom: 5px\"><strong>NOTE:</strong></div>\n",
    "<div style=\"background-color: #f3f4f7; padding-left: 10px; padding-top: 10px; padding-bottom: 10px; padding-right: 10px\">\n",
    "<p>Download the data from<a href=\"https://download.pytorch.org/tutorial/data.zip\">here</a>and extract it to the current directory.</p>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to the character encoding used in the character-level RNN\n",
    "tutorials, we will be representing each word in a language as a one-hot\n",
    "vector, or giant vector of zeros except for a single one (at the index\n",
    "of the word). Compared to the dozens of characters that might exist in a\n",
    "language, there are many many more words, so the encoding vector is much\n",
    "larger. We will however cheat a bit and trim the data to only use a few\n",
    "thousand words per language.\n",
    "\n",
    "![](https://pytorch.org/tutorials/_static/img/seq-seq-images/word-encoding.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We\\'ll need a unique index per word to use as the inputs and targets of\n",
    "the networks later. To keep track of all this we will use a helper class\n",
    "called `Lang` which has word → index (`word2index`) and index → word\n",
    "(`index2word`) dictionaries, as well as a count of each word\n",
    "`word2count` which will be used to replace rare words later.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "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  # 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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The files are all in Unicode, to simplify we will turn Unicode\n",
    "characters to ASCII, make everything lowercase, and trim most\n",
    "punctuation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "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",
    "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.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To read the data file we will split the file into lines, and then split\n",
    "lines into pairs. The files are all English → Other Language, so if we\n",
    "want to translate from Other Language → English I added the `reverse`\n",
    "flag to reverse the pairs.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since there are a *lot* of example sentences and we want to train\n",
    "something quickly, we\\'ll trim the data set to only relatively short and\n",
    "simple sentences. Here the maximum length is 10 words (that includes\n",
    "ending punctuation) and we\\'re filtering to sentences that translate to\n",
    "the form \\\"I am\\\" or \\\"He is\\\" etc. (accounting for apostrophes replaced\n",
    "earlier).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "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",
    "\n",
    "def filterPairs(pairs):\n",
    "    return [pair for pair in pairs if filterPair(pair)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading lines...\n",
      "Read 135842 sentence pairs\n",
      "Trimmed to 11445 sentence pairs\n",
      "Counting words...\n",
      "Counted words:\n",
      "fra 4601\n",
      "eng 2991\n",
      "['nous sommes toutes en train d etre manipulees', 'we re all being manipulated']\n"
     ]
    }
   ],
   "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",
    "input_lang, output_lang, pairs = prepareData('eng', 'fra', True)\n",
    "print(random.choice(pairs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Seq2Seq Model\n",
    "=================\n",
    "\n",
    "A Recurrent Neural Network, or RNN, is a network that operates on a\n",
    "sequence and uses its own output as input for subsequent steps.\n",
    "\n",
    "A [Sequence to Sequence network](https://arxiv.org/abs/1409.3215), or\n",
    "seq2seq network, or [Encoder Decoder\n",
    "network](https://arxiv.org/pdf/1406.1078v3.pdf), is a model consisting\n",
    "of two RNNs called the encoder and decoder. The encoder reads an input\n",
    "sequence and outputs a single vector, and the decoder reads that vector\n",
    "to produce an output sequence.\n",
    "\n",
    "![](https://pytorch.org/tutorials/_static/img/seq-seq-images/seq2seq.png)\n",
    "\n",
    "Unlike sequence prediction with a single RNN, where every input\n",
    "corresponds to an output, the seq2seq model frees us from sequence\n",
    "length and order, which makes it ideal for translation between two\n",
    "languages.\n",
    "\n",
    "Consider the sentence `Je ne suis pas le chat noir` →\n",
    "`I am not the black cat`. Most of the words in the input sentence have a\n",
    "direct translation in the output sentence, but are in slightly different\n",
    "orders, e.g. `chat noir` and `black cat`. Because of the `ne/pas`\n",
    "construction there is also one more word in the input sentence. It would\n",
    "be difficult to produce a correct translation directly from the sequence\n",
    "of input words.\n",
    "\n",
    "With a seq2seq model the encoder creates a single vector which, in the\n",
    "ideal case, encodes the \\\"meaning\\\" of the input sequence into a single\n",
    "vector --- a single point in some N dimensional space of sentences.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Encoder\n",
    "===========\n",
    "\n",
    "The encoder of a seq2seq network is a RNN that outputs some value for\n",
    "every word from the input sentence. For every input word the encoder\n",
    "outputs a vector and a hidden state, and uses the hidden state for the\n",
    "next input word.\n",
    "\n",
    "![](https://pytorch.org/tutorials/_static/img/seq-seq-images/encoder-network.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from s4d import S4D \n",
    "\n",
    "class EncoderRNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, dropout_p=0.1):\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, batch_first=True)\n",
    "        self.s4d = S4D(hidden_size, transposed=False, d_state=64, lr=0.001)\n",
    "        self.dropout = nn.Dropout(dropout_p)\n",
    "\n",
    "    def forward(self, input):\n",
    "        embedded = self.dropout(self.embedding(input))\n",
    "        # output, hidden = self.gru(embedded)\n",
    "        output, hidden = self.s4d(embedded)\n",
    "        return output, hidden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Decoder\n",
    "===========\n",
    "\n",
    "The decoder is another RNN that takes the encoder output vector(s) and\n",
    "outputs a sequence of words to create the translation.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simple Decoder\n",
    "==============\n",
    "\n",
    "In the simplest seq2seq decoder we use only last output of the encoder.\n",
    "This last output is sometimes called the *context vector* as it encodes\n",
    "context from the entire sequence. This context vector is used as the\n",
    "initial hidden state of the decoder.\n",
    "\n",
    "At every step of decoding, the decoder is given an input token and\n",
    "hidden state. The initial input token is the start-of-string `<SOS>`\n",
    "token, and the first hidden state is the context vector (the encoder\\'s\n",
    "last hidden state).\n",
    "\n",
    "![](https://pytorch.org/tutorials/_static/img/seq-seq-images/decoder-network.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class DecoderRNN(nn.Module):\n",
    "    def __init__(self, hidden_size, output_size):\n",
    "        super(DecoderRNN, self).__init__()\n",
    "        self.embedding = nn.Embedding(output_size, hidden_size)\n",
    "        # self.gru = nn.GRU(hidden_size, hidden_size, batch_first=True)\n",
    "        self.s4d = S4D(hidden_size, transposed=False, d_state=64, lr=0.001)\n",
    "        self.out = nn.Linear(hidden_size, output_size)\n",
    "\n",
    "    def forward(self, encoder_outputs, encoder_hidden, target_tensor=None):\n",
    "        batch_size = encoder_outputs.size(0)\n",
    "        decoder_input = torch.empty(batch_size, 1, dtype=torch.long, device=device).fill_(SOS_token)\n",
    "        decoder_hidden = encoder_hidden\n",
    "        decoder_outputs = []\n",
    "\n",
    "        for i in range(MAX_LENGTH):\n",
    "            decoder_output, decoder_hidden  = self.forward_step(decoder_input, decoder_hidden)\n",
    "            decoder_outputs.append(decoder_output)\n",
    "\n",
    "            if target_tensor is not None:\n",
    "                # Teacher forcing: Feed the target as the next input\n",
    "                decoder_input = target_tensor[:, i].unsqueeze(1) # Teacher forcing\n",
    "            else:\n",
    "                # Without teacher forcing: use its own predictions as the next input\n",
    "                _, topi = decoder_output.topk(1)\n",
    "                decoder_input = topi.squeeze(-1).detach()  # detach from history as input\n",
    "\n",
    "        decoder_outputs = torch.cat(decoder_outputs, dim=1)\n",
    "        decoder_outputs = F.log_softmax(decoder_outputs, dim=-1)\n",
    "        return decoder_outputs, decoder_hidden, None # We return `None` for consistency in the training loop\n",
    "\n",
    "    def forward_step(self, input, hidden):\n",
    "        output = self.embedding(input)\n",
    "        output = F.relu(output)\n",
    "        # output, hidden = self.gru(output, hidden)\n",
    "        output, hidden = self.s4d(output, hidden)\n",
    "        output = self.out(output)\n",
    "        return output, hidden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I encourage you to train and observe the results of this model, but to\n",
    "save space we\\'ll be going straight for the gold and introducing the\n",
    "Attention Mechanism.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention Decoder\n",
    "=================\n",
    "\n",
    "If only the context vector is passed between the encoder and decoder,\n",
    "that single vector carries the burden of encoding the entire sentence.\n",
    "\n",
    "Attention allows the decoder network to \\\"focus\\\" on a different part of\n",
    "the encoder\\'s outputs for every step of the decoder\\'s own outputs.\n",
    "First we calculate a set of *attention weights*. These will be\n",
    "multiplied by the encoder output vectors to create a weighted\n",
    "combination. The result (called `attn_applied` in the code) should\n",
    "contain information about that specific part of the input sequence, and\n",
    "thus help the decoder choose the right output words.\n",
    "\n",
    "![](https://i.imgur.com/1152PYf.png)\n",
    "\n",
    "Calculating the attention weights is done with another feed-forward\n",
    "layer `attn`, using the decoder\\'s input and hidden state as inputs.\n",
    "Because there are sentences of all sizes in the training data, to\n",
    "actually create and train this layer we have to choose a maximum\n",
    "sentence length (input length, for encoder outputs) that it can apply\n",
    "to. Sentences of the maximum length will use all the attention weights,\n",
    "while shorter sentences will only use the first few.\n",
    "\n",
    "![](https://pytorch.org/tutorials/_static/img/seq-seq-images/attention-decoder-network.png)\n",
    "\n",
    "Bahdanau attention, also known as additive attention, is a commonly used\n",
    "attention mechanism in sequence-to-sequence models, particularly in\n",
    "neural machine translation tasks. It was introduced by Bahdanau et al.\n",
    "in their paper titled [Neural Machine Translation by Jointly Learning to\n",
    "Align and Translate](https://arxiv.org/pdf/1409.0473.pdf). This\n",
    "attention mechanism employs a learned alignment model to compute\n",
    "attention scores between the encoder and decoder hidden states. It\n",
    "utilizes a feed-forward neural network to calculate alignment scores.\n",
    "\n",
    "However, there are alternative attention mechanisms available, such as\n",
    "Luong attention, which computes attention scores by taking the dot\n",
    "product between the decoder hidden state and the encoder hidden states.\n",
    "It does not involve the non-linear transformation used in Bahdanau\n",
    "attention.\n",
    "\n",
    "In this tutorial, we will be using Bahdanau attention. However, it would\n",
    "be a valuable exercise to explore modifying the attention mechanism to\n",
    "use Luong attention.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class BahdanauAttention(nn.Module):\n",
    "    def __init__(self, hidden_size):\n",
    "        super(BahdanauAttention, self).__init__()\n",
    "        self.Wa = nn.Linear(hidden_size, hidden_size)\n",
    "        self.Ua = nn.Linear(hidden_size, hidden_size)\n",
    "        self.Va = nn.Linear(hidden_size, 1)\n",
    "\n",
    "    def forward(self, query, keys):\n",
    "        scores = self.Va(torch.tanh(self.Wa(query) + self.Ua(keys)))\n",
    "        scores = scores.squeeze(2).unsqueeze(1)\n",
    "\n",
    "        weights = F.softmax(scores, dim=-1)\n",
    "        context = torch.bmm(weights, keys)\n",
    "\n",
    "        return context, weights\n",
    "\n",
    "class AttnDecoderRNN(nn.Module):\n",
    "    def __init__(self, hidden_size, output_size, dropout_p=0.1):\n",
    "        super(AttnDecoderRNN, self).__init__()\n",
    "        self.embedding = nn.Embedding(output_size, hidden_size)\n",
    "        self.attention = BahdanauAttention(hidden_size)\n",
    "        # self.gru = nn.GRU(2 * hidden_size, hidden_size, batch_first=True)\n",
    "        self.before_s4d = nn.Linear(2 * hidden_size, hidden_size)\n",
    "        self.s4d = S4D(hidden_size, transposed=False, d_state=64, lr=0.001)\n",
    "        self.out = nn.Linear(hidden_size, output_size)\n",
    "        self.dropout = nn.Dropout(dropout_p)\n",
    "\n",
    "    def forward(self, encoder_outputs, encoder_hidden, target_tensor=None):\n",
    "        batch_size = encoder_outputs.size(0)\n",
    "        decoder_input = torch.empty(batch_size, 1, dtype=torch.long, device=device).fill_(SOS_token)\n",
    "        decoder_hidden = encoder_hidden\n",
    "        decoder_outputs = []\n",
    "        attentions = []\n",
    "\n",
    "        for i in range(MAX_LENGTH):\n",
    "            decoder_output, decoder_hidden, attn_weights = self.forward_step(\n",
    "                decoder_input, decoder_hidden, encoder_outputs\n",
    "            )\n",
    "            decoder_outputs.append(decoder_output)\n",
    "            attentions.append(attn_weights)\n",
    "\n",
    "            if target_tensor is not None:\n",
    "                # Teacher forcing: Feed the target as the next input\n",
    "                decoder_input = target_tensor[:, i].unsqueeze(1) # Teacher forcing\n",
    "            else:\n",
    "                # Without teacher forcing: use its own predictions as the next input\n",
    "                _, topi = decoder_output.topk(1)\n",
    "                decoder_input = topi.squeeze(-1).detach()  # detach from history as input\n",
    "\n",
    "        decoder_outputs = torch.cat(decoder_outputs, dim=1)\n",
    "        decoder_outputs = F.log_softmax(decoder_outputs, dim=-1)\n",
    "        attentions = torch.cat(attentions, dim=1)\n",
    "\n",
    "        return decoder_outputs, decoder_hidden, attentions\n",
    "\n",
    "\n",
    "    def forward_step(self, input, hidden, encoder_outputs):\n",
    "        embedded =  self.dropout(self.embedding(input))\n",
    "\n",
    "        query = hidden.permute(1, 0, 2)\n",
    "        context, attn_weights = self.attention(query, encoder_outputs)\n",
    "        input_gru = torch.cat((embedded, context), dim=2)\n",
    "\n",
    "        # output, hidden = self.gru(input_gru, hidden)\n",
    "        input_gru = self.before_s4d(input_gru)\n",
    "        output, hidden = self.s4d(input_gru, hidden)\n",
    "        output = self.out(output)\n",
    "\n",
    "        return output, hidden, attn_weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: #54c7ec; color: #fff; font-weight: 700; padding-left: 10px; padding-top: 5px; padding-bottom: 5px\"><strong>NOTE:</strong></div>\n",
    "<div style=\"background-color: #f3f4f7; padding-left: 10px; padding-top: 10px; padding-bottom: 10px; padding-right: 10px\">\n",
    "<p>There are other forms of attention that work around the lengthlimitation by using a relative position approach. Read about \"localattention\" in <a href=\"https://arxiv.org/abs/1508.04025\">Effective Approaches to Attention-based Neural MachineTranslation</a>.</p>\n",
    "</div>\n",
    "\n",
    "Training\n",
    "========\n",
    "\n",
    "Preparing Training Data\n",
    "-----------------------\n",
    "\n",
    "To train, for each pair we will need an input tensor (indexes of the\n",
    "words in the input sentence) and target tensor (indexes of the words in\n",
    "the target sentence). While creating these vectors we will append the\n",
    "EOS token to both sequences.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "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, 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)\n",
    "\n",
    "def get_dataloader(batch_size):\n",
    "    input_lang, output_lang, pairs = prepareData('eng', 'fra', True)\n",
    "\n",
    "    n = len(pairs)\n",
    "    input_ids = np.zeros((n, MAX_LENGTH), dtype=np.int32)\n",
    "    target_ids = np.zeros((n, MAX_LENGTH), dtype=np.int32)\n",
    "\n",
    "    for idx, (inp, tgt) in enumerate(pairs):\n",
    "        inp_ids = indexesFromSentence(input_lang, inp)\n",
    "        tgt_ids = indexesFromSentence(output_lang, tgt)\n",
    "        inp_ids.append(EOS_token)\n",
    "        tgt_ids.append(EOS_token)\n",
    "        input_ids[idx, :len(inp_ids)] = inp_ids\n",
    "        target_ids[idx, :len(tgt_ids)] = tgt_ids\n",
    "\n",
    "    train_data = TensorDataset(torch.LongTensor(input_ids).to(device),\n",
    "                               torch.LongTensor(target_ids).to(device))\n",
    "\n",
    "    train_sampler = RandomSampler(train_data)\n",
    "    train_dataloader = DataLoader(train_data, sampler=train_sampler, batch_size=batch_size)\n",
    "    return input_lang, output_lang, train_dataloader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training the Model\n",
    "==================\n",
    "\n",
    "To train we run the input sentence through the encoder, and keep track\n",
    "of every output and the latest hidden state. Then the decoder is given\n",
    "the `<SOS>` token as its first input, and the last hidden state of the\n",
    "encoder as its first hidden state.\n",
    "\n",
    "\\\"Teacher forcing\\\" is the concept of using the real target outputs as\n",
    "each next input, instead of using the decoder\\'s guess as the next\n",
    "input. Using teacher forcing causes it to converge faster but [when the\n",
    "trained network is exploited, it may exhibit\n",
    "instability](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.378.4095&rep=rep1&type=pdf).\n",
    "\n",
    "You can observe outputs of teacher-forced networks that read with\n",
    "coherent grammar but wander far from the correct translation\n",
    "-intuitively it has learned to represent the output grammar and can\n",
    "\\\"pick up\\\" the meaning once the teacher tells it the first few words,\n",
    "but it has not properly learned how to create the sentence from the\n",
    "translation in the first place.\n",
    "\n",
    "Because of the freedom PyTorch\\'s autograd gives us, we can randomly\n",
    "choose to use teacher forcing or not with a simple if statement. Turn\n",
    "`teacher_forcing_ratio` up to use more of it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def train_epoch(dataloader, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion):\n",
    "\n",
    "    total_loss = 0\n",
    "    for data in dataloader:\n",
    "        input_tensor, target_tensor = data\n",
    "\n",
    "        encoder_optimizer.zero_grad()\n",
    "        decoder_optimizer.zero_grad()\n",
    "\n",
    "        encoder_outputs, encoder_hidden = encoder(input_tensor)\n",
    "        decoder_outputs, _, _ = decoder(encoder_outputs, encoder_hidden, target_tensor)\n",
    "\n",
    "        loss = criterion(\n",
    "            decoder_outputs.view(-1, decoder_outputs.size(-1)),\n",
    "            target_tensor.view(-1)\n",
    "        )\n",
    "        loss.backward()\n",
    "\n",
    "        encoder_optimizer.step()\n",
    "        decoder_optimizer.step()\n",
    "\n",
    "        total_loss += loss.item()\n",
    "\n",
    "    return total_loss / len(dataloader)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a helper function to print time elapsed and estimated time\n",
    "remaining given the current time and progress %.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import time\n",
    "import math\n",
    "\n",
    "def asMinutes(s):\n",
    "    m = math.floor(s / 60)\n",
    "    s -= m * 60\n",
    "    return '%dm %ds' % (m, s)\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))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The whole training process looks like this:\n",
    "\n",
    "-   Start a timer\n",
    "-   Initialize optimizers and criterion\n",
    "-   Create set of training pairs\n",
    "-   Start empty losses array for plotting\n",
    "\n",
    "Then we call `train` many times and occasionally print the progress (%\n",
    "of examples, time so far, estimated time) and average loss.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from set_opt import setup_optimizer\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "\n",
    "def train(train_dataloader, encoder, decoder, n_epochs, learning_rate=0.01, print_every=100, load_ckpt=False):\n",
    "    start = time.time()\n",
    "    losses = []\n",
    "\n",
    "    encoder_optimizer, encoder_scheduler = setup_optimizer(encoder, lr=learning_rate, weight_decay=0.05, epochs=n_epochs)\n",
    "    decoder_optimizer, decoder_scheduler = setup_optimizer(decoder, lr=learning_rate, weight_decay=0.05, epochs=n_epochs)\n",
    "    criterion = nn.NLLLoss()\n",
    "\n",
    "    if not load_ckpt:\n",
    "        for epoch in range(1, n_epochs + 1):\n",
    "            loss = train_epoch(train_dataloader, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion)\n",
    "            losses.append(loss)\n",
    "\n",
    "            if epoch % print_every == 0:\n",
    "                print('%s (%d %d%%) %.4f' % (timeSince(start, epoch / n_epochs), epoch, epoch / n_epochs * 100, loss))\n",
    "\n",
    "            encoder_scheduler.step()    \n",
    "            decoder_scheduler.step()\n",
    "        state = {\n",
    "            'epoch': epoch,\n",
    "            'loss': losses,\n",
    "            'encoder_state_dict': encoder.state_dict(),\n",
    "            'decoder_state_dict': decoder.state_dict(),\n",
    "        }\n",
    "        if not os.path.isdir('checkpoint'):\n",
    "            os.mkdir('checkpoint')\n",
    "        torch.save(state, './checkpoint/s4d_ckpt.pth')\n",
    "    \n",
    "    if load_ckpt:\n",
    "        checkpoint = torch.load('./checkpoint/s4d_ckpt.pth')\n",
    "        losses = checkpoint['loss']\n",
    "        epoch = checkpoint['epoch']\n",
    "        \n",
    "        xaxis = np.arange(1, n_epochs + 1)\n",
    "        plt.plot(xaxis, losses, label='Training Loss')\n",
    "        plt.xlabel('Epoch')\n",
    "        plt.ylabel('Loss')\n",
    "        plt.yscale('log')\n",
    "        plt.title('S4D on WMT2014 English-French')\n",
    "        plt.legend()\n",
    "        plt.tight_layout()\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluation\n",
    "==========\n",
    "\n",
    "Evaluation is mostly the same as training, but there are no targets so\n",
    "we simply feed the decoder\\'s predictions back to itself for each step.\n",
    "Every time it predicts a word we add it to the output string, and if it\n",
    "predicts the EOS token we stop there. We also store the decoder\\'s\n",
    "attention outputs for display later.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def evaluate(encoder, decoder, sentence, input_lang, output_lang):\n",
    "    with torch.no_grad():\n",
    "        input_tensor = tensorFromSentence(input_lang, sentence)\n",
    "\n",
    "        encoder_outputs, encoder_hidden = encoder(input_tensor)\n",
    "        decoder_outputs, decoder_hidden, decoder_attn = decoder(encoder_outputs, encoder_hidden)\n",
    "\n",
    "        _, topi = decoder_outputs.topk(1)\n",
    "        decoded_ids = topi.squeeze()\n",
    "\n",
    "        decoded_words = []\n",
    "        for idx in decoded_ids:\n",
    "            if idx.item() == EOS_token:\n",
    "                decoded_words.append('<EOS>')\n",
    "                break\n",
    "            decoded_words.append(output_lang.index2word[idx.item()])\n",
    "    return decoded_words, decoder_attn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can evaluate random sentences from the training set and print out the\n",
    "input, target, and output to make some subjective quality judgements:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "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, _ = evaluate(encoder, decoder, pair[0], input_lang, output_lang)\n",
    "        output_sentence = ' '.join(output_words)\n",
    "        print('<', output_sentence)\n",
    "        print('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training and Evaluating\n",
    "=======================\n",
    "\n",
    "With all these helper functions in place (it looks like extra work, but\n",
    "it makes it easier to run multiple experiments) we can actually\n",
    "initialize a network and start training.\n",
    "\n",
    "Remember that the input sentences were heavily filtered. For this small\n",
    "dataset we can use relatively small networks of 256 hidden nodes and a\n",
    "single GRU layer. After about 40 minutes on a MacBook CPU we\\'ll get\n",
    "some reasonable results.\n",
    "\n",
    "<div style=\"background-color: #54c7ec; color: #fff; font-weight: 700; padding-left: 10px; padding-top: 5px; padding-bottom: 5px\"><strong>NOTE:</strong></div>\n",
    "<div style=\"background-color: #f3f4f7; padding-left: 10px; padding-top: 10px; padding-bottom: 10px; padding-right: 10px\">\n",
    "<p>If you run this notebook you can train, interrupt the kernel,evaluate, and continue training later. Comment out the lines where theencoder and decoder are initialized and run <code>trainIters</code> again.</p>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading lines...\n",
      "Read 135842 sentence pairs\n",
      "Trimmed to 11445 sentence pairs\n",
      "Counting words...\n",
      "Counted words:\n",
      "fra 4601\n",
      "eng 2991\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/shida/anaconda3/envs/ssm_examples/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimizer group 0 | 5 tensors | lr 0.002 | weight_decay 0.05\n",
      "Optimizer group 1 | 3 tensors | lr 0.001 | weight_decay 0.0\n",
      "Optimizer group 0 | 15 tensors | lr 0.002 | weight_decay 0.05\n",
      "Optimizer group 1 | 3 tensors | lr 0.001 | weight_decay 0.0\n",
      "1m 23s (- 20m 49s) (5 6%) 0.6355\n",
      "2m 41s (- 18m 53s) (10 12%) 0.2352\n",
      "4m 0s (- 17m 21s) (15 18%) 0.1451\n",
      "5m 19s (- 15m 57s) (20 25%) 0.1039\n",
      "6m 37s (- 14m 34s) (25 31%) 0.0791\n",
      "7m 56s (- 13m 14s) (30 37%) 0.0639\n",
      "9m 15s (- 11m 54s) (35 43%) 0.0495\n",
      "10m 33s (- 10m 33s) (40 50%) 0.0397\n",
      "11m 52s (- 9m 14s) (45 56%) 0.0326\n",
      "13m 10s (- 7m 54s) (50 62%) 0.0255\n",
      "14m 25s (- 6m 33s) (55 68%) 0.0215\n",
      "15m 40s (- 5m 13s) (60 75%) 0.0179\n",
      "16m 53s (- 3m 53s) (65 81%) 0.0153\n",
      "18m 7s (- 2m 35s) (70 87%) 0.0136\n",
      "19m 20s (- 1m 17s) (75 93%) 0.0123\n",
      "20m 33s (- 0m 0s) (80 100%) 0.0118\n"
     ]
    }
   ],
   "source": [
    "hidden_size = 256\n",
    "batch_size = 32\n",
    "\n",
    "input_lang, output_lang, train_dataloader = get_dataloader(batch_size)\n",
    "\n",
    "encoder = EncoderRNN(input_lang.n_words, hidden_size).to(device)\n",
    "decoder = AttnDecoderRNN(hidden_size, output_lang.n_words).to(device)\n",
    "\n",
    "train(train_dataloader, encoder, decoder, n_epochs=80, print_every=5, learning_rate=0.002, load_ckpt=load_ckpt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set dropout layers to `eval` mode\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> je suis desolee je ne voulais pas dire ca\n",
      "= i m sorry i didn t mean that\n",
      "< i m sorry i didn t mean that <EOS>\n",
      "\n",
      "> ca me plait beaucoup\n",
      "= i am very happy with it\n",
      "< i m very happy with it to miss you at\n",
      "\n",
      "> elle est toujours gentille avec tout le monde\n",
      "= she is always kind to everyone\n",
      "< she is always kind to everyone <EOS>\n",
      "\n",
      "> elle est mon premier amour\n",
      "= she s my first love\n",
      "< she love my first love this love my love my\n",
      "\n",
      "> je ne suis personne de particulier\n",
      "= i m no one special\n",
      "< i m no one special such such such such such\n",
      "\n",
      "> vous etes tres observateur\n",
      "= you re very observant\n",
      "< you very very observant <EOS>\n",
      "\n",
      "> nous ne sommes que des enfants\n",
      "= we re just children\n",
      "< we are nothing children <EOS>\n",
      "\n",
      "> tu es vilain\n",
      "= you re bad\n",
      "< you are naughty <EOS>\n",
      "\n",
      "> je ne suis pas si occupee que ca\n",
      "= i m not all that busy\n",
      "< i m not all that busy <EOS>\n",
      "\n",
      "> on ne rajeunit pas\n",
      "= we re not getting any younger\n",
      "< we are not getting involved <EOS>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "encoder.eval()\n",
    "decoder.eval()\n",
    "evaluateRandomly(encoder, decoder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualizing Attention\n",
    "=====================\n",
    "\n",
    "A useful property of the attention mechanism is its highly interpretable\n",
    "outputs. Because it is used to weight specific encoder outputs of the\n",
    "input sequence, we can imagine looking where the network is focused most\n",
    "at each time step.\n",
    "\n",
    "You could simply run `plt.matshow(attentions)` to see attention output\n",
    "displayed as a matrix. For a better viewing experience we will do the\n",
    "extra work of adding axes and labels:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = il n est pas aussi grand que son pere\n",
      "output = he is not as tall as his father <EOS>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1635685/1690937169.py:8: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n",
      "  ax.set_xticklabels([''] + input_sentence.split(' ') +\n",
      "/tmp/ipykernel_1635685/1690937169.py:10: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n",
      "  ax.set_yticklabels([''] + output_words)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1635685/1690937169.py:8: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n",
      "  ax.set_xticklabels([''] + input_sentence.split(' ') +\n",
      "/tmp/ipykernel_1635685/1690937169.py:10: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n",
      "  ax.set_yticklabels([''] + output_words)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = je suis trop fatigue pour conduire\n",
      "output = i am too tired to drive <EOS>\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = je suis desole si c est une question idiote\n",
      "output = i m sorry if this is a stupid question <EOS>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1635685/1690937169.py:8: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n",
      "  ax.set_xticklabels([''] + input_sentence.split(' ') +\n",
      "/tmp/ipykernel_1635685/1690937169.py:10: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n",
      "  ax.set_yticklabels([''] + output_words)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = je suis reellement fiere de vous\n",
      "output = i really proud of you <EOS>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1635685/1690937169.py:8: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n",
      "  ax.set_xticklabels([''] + input_sentence.split(' ') +\n",
      "/tmp/ipykernel_1635685/1690937169.py:10: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n",
      "  ax.set_yticklabels([''] + output_words)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def showAttention(input_sentence, output_words, attentions):\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    cax = ax.matshow(attentions.cpu().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(encoder, decoder, input_sentence, input_lang, output_lang)\n",
    "    print('input =', input_sentence)\n",
    "    print('output =', ' '.join(output_words))\n",
    "    showAttention(input_sentence, output_words, attentions[0, :len(output_words), :])\n",
    "\n",
    "\n",
    "evaluateAndShowAttention('il n est pas aussi grand que son pere')\n",
    "\n",
    "evaluateAndShowAttention('je suis trop fatigue pour conduire')\n",
    "\n",
    "evaluateAndShowAttention('je suis desole si c est une question idiote')\n",
    "\n",
    "evaluateAndShowAttention('je suis reellement fiere de vous')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercises\n",
    "=========\n",
    "\n",
    "-   Try with a different dataset\n",
    "    -   Another language pair\n",
    "    -   Human → Machine (e.g. IOT commands)\n",
    "    -   Chat → Response\n",
    "    -   Question → Answer\n",
    "-   Replace the embeddings with pretrained word embeddings such as\n",
    "    `word2vec` or `GloVe`\n",
    "-   Try with more layers, more hidden units, and more sentences. Compare\n",
    "    the training time and results.\n",
    "-   If you use a translation file where pairs have two of the same\n",
    "    phrase (`I am test \\t I am test`), you can use this as an\n",
    "    autoencoder. Try this:\n",
    "    -   Train as an autoencoder\n",
    "    -   Save only the Encoder network\n",
    "    -   Train a new Decoder for translation from there\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}