11_nmt-with-attention.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><div style=\"direction:rtl;font-family:B Lotus, B Nazanin, Tahoma\">به نام خدا</div></center>\n",
    "<img src=\"./logo.png\" alt=\"class.vision\" style=\"width: 200px;\"/>\n",
    "<h1><center><div style=\"direction:rtl;font-family:B Lotus, B Nazanin, Tahoma\">ترجمه ماشینی با توجه و teacher forcing</div></center></h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "J0Qjg6vuaHNt"
   },
   "source": [
    "# Neural machine translation with attention"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CiwtNgENbx2g"
   },
   "source": [
    "This notebook trains a sequence to sequence (seq2seq) model for Spanish to English translation. This is an advanced example that assumes some knowledge of sequence to sequence models.\n",
    "\n",
    "After training the model in this notebook, you will be able to input a Spanish sentence, such as *\"¿todavia estan en casa?\"*, and return the English translation: *\"are you still at home?\"*\n",
    "\n",
    "The translation quality is reasonable for a toy example, but the generated attention plot is perhaps more interesting. This shows which parts of the input sentence has the model's attention while translating:\n",
    "\n",
    "<img src=\"https://tensorflow.org/images/spanish-english.png\" alt=\"spanish-english attention plot\">\n",
    "\n",
    "Note: This example takes approximately 10 mintues to run on a single P100 GPU."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tnxXKDjq3jEL"
   },
   "outputs": [],
   "source": [
    "from __future__ import absolute_import, division, print_function, unicode_literals\n",
    "\n",
    "try:\n",
    "  # %tensorflow_version only exists in Colab.\n",
    "  %tensorflow_version 2.x\n",
    "except Exception:\n",
    "  pass\n",
    "import tensorflow as tf\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "import unicodedata\n",
    "import re\n",
    "import numpy as np\n",
    "import os\n",
    "import io\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wfodePkj3jEa"
   },
   "source": [
    "## Download and prepare the dataset\n",
    "\n",
    "We'll use a language dataset provided by http://www.manythings.org/anki/. This dataset contains language translation pairs in the format:\n",
    "\n",
    "```\n",
    "May I borrow this book?\t¿Puedo tomar prestado este libro?\n",
    "```\n",
    "\n",
    "There are a variety of languages available, but we'll use the English-Spanish dataset. For convenience, we've hosted a copy of this dataset on Google Cloud, but you can also download your own copy. After downloading the dataset, here are the steps we'll take to prepare the data:\n",
    "\n",
    "1. Add a *start* and *end* token to each sentence.\n",
    "2. Clean the sentences by removing special characters.\n",
    "3. Create a word index and reverse word index (dictionaries mapping from word → id and id → word).\n",
    "4. Pad each sentence to a maximum length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kRVATYOgJs1b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from http://storage.googleapis.com/download.tensorflow.org/data/spa-eng.zip\n",
      "2646016/2638744 [==============================] - 0s 0us/step\n"
     ]
    }
   ],
   "source": [
    "# Download the file\n",
    "path_to_zip = tf.keras.utils.get_file(\n",
    "    'spa-eng.zip', origin='http://storage.googleapis.com/download.tensorflow.org/data/spa-eng.zip',\n",
    "    extract=True)\n",
    "\n",
    "path_to_file = os.path.dirname(path_to_zip)+\"/spa-eng/spa.txt\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "rd0jw-eC3jEh"
   },
   "outputs": [],
   "source": [
    "# Converts the unicode file to ascii\n",
    "def unicode_to_ascii(s):\n",
    "  return ''.join(c for c in unicodedata.normalize('NFD', s)\n",
    "      if unicodedata.category(c) != 'Mn')\n",
    "\n",
    "\n",
    "def preprocess_sentence(w):\n",
    "  w = unicode_to_ascii(w.lower().strip())\n",
    "\n",
    "  # creating a space between a word and the punctuation following it\n",
    "  # eg: \"he is a boy.\" => \"he is a boy .\"\n",
    "  # Reference:- https://stackoverflow.com/questions/3645931/python-padding-punctuation-with-white-spaces-keeping-punctuation\n",
    "  w = re.sub(r\"([?.!,¿])\", r\" \\1 \", w)\n",
    "  w = re.sub(r'[\" \"]+', \" \", w)\n",
    "\n",
    "  # replacing everything with space except (a-z, A-Z, \".\", \"?\", \"!\", \",\")\n",
    "  w = re.sub(r\"[^a-zA-Z?.!,¿]+\", \" \", w)\n",
    "\n",
    "  w = w.rstrip().strip()\n",
    "\n",
    "  # adding a start and an end token to the sentence\n",
    "  # so that the model know when to start and stop predicting.\n",
    "  w = '<start> ' + w + ' <end>'\n",
    "  return w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "opI2GzOt479E"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<start> may i borrow this book ? <end>\n",
      "b'<start> \\xc2\\xbf puedo tomar prestado este libro ? <end>'\n"
     ]
    }
   ],
   "source": [
    "en_sentence = u\"May I borrow this book?\"\n",
    "sp_sentence = u\"¿Puedo tomar prestado este libro?\"\n",
    "print(preprocess_sentence(en_sentence))\n",
    "print(preprocess_sentence(sp_sentence).encode('utf-8'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OHn4Dct23jEm"
   },
   "outputs": [],
   "source": [
    "# 1. Remove the accents\n",
    "# 2. Clean the sentences\n",
    "# 3. Return word pairs in the format: [ENGLISH, SPANISH]\n",
    "def create_dataset(path, num_examples):\n",
    "  lines = io.open(path, encoding='UTF-8').read().strip().split('\\n')\n",
    "\n",
    "  word_pairs = [[preprocess_sentence(w) for w in l.split('\\t')]  for l in lines[:num_examples]]\n",
    "\n",
    "  return zip(*word_pairs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cTbSbBz55QtF"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<start> if you want to sound like a native speaker , you must be willing to practice saying the same sentence over and over in the same way that banjo players practice the same phrase over and over until they can play it correctly and at the desired tempo . <end>\n",
      "<start> si quieres sonar como un hablante nativo , debes estar dispuesto a practicar diciendo la misma frase una y otra vez de la misma manera en que un musico de banjo practica el mismo fraseo una y otra vez hasta que lo puedan tocar correctamente y en el tiempo esperado . <end>\n"
     ]
    }
   ],
   "source": [
    "en, sp = create_dataset(path_to_file, None)\n",
    "print(en[-1])\n",
    "print(sp[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OmMZQpdO60dt"
   },
   "outputs": [],
   "source": [
    "def max_length(tensor):\n",
    "  return max(len(t) for t in tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bIOn8RCNDJXG"
   },
   "outputs": [],
   "source": [
    "def tokenize(lang):\n",
    "  lang_tokenizer = tf.keras.preprocessing.text.Tokenizer(\n",
    "      filters='')\n",
    "  lang_tokenizer.fit_on_texts(lang)\n",
    "\n",
    "  tensor = lang_tokenizer.texts_to_sequences(lang)\n",
    "\n",
    "  tensor = tf.keras.preprocessing.sequence.pad_sequences(tensor,\n",
    "                                                         padding='post')\n",
    "\n",
    "  return tensor, lang_tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "eAY9k49G3jE_"
   },
   "outputs": [],
   "source": [
    "def load_dataset(path, num_examples=None):\n",
    "  # creating cleaned input, output pairs\n",
    "  targ_lang, inp_lang = create_dataset(path, num_examples)\n",
    "\n",
    "  input_tensor, inp_lang_tokenizer = tokenize(inp_lang)\n",
    "  target_tensor, targ_lang_tokenizer = tokenize(targ_lang)\n",
    "\n",
    "  return input_tensor, target_tensor, inp_lang_tokenizer, targ_lang_tokenizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GOi42V79Ydlr"
   },
   "source": [
    "### Limit the size of the dataset to experiment faster (optional)\n",
    "\n",
    "Training on the complete dataset of >100,000 sentences will take a long time. To train faster, we can limit the size of the dataset to 30,000 sentences (of course, translation quality degrades with less data):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cnxC7q-j3jFD"
   },
   "outputs": [],
   "source": [
    "# Try experimenting with the size of that dataset\n",
    "num_examples = 30000\n",
    "input_tensor, target_tensor, inp_lang, targ_lang = load_dataset(path_to_file, num_examples)\n",
    "\n",
    "# Calculate max_length of the target tensors\n",
    "max_length_targ, max_length_inp = max_length(target_tensor), max_length(input_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4QILQkOs3jFG"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24000 24000 6000 6000\n"
     ]
    }
   ],
   "source": [
    "# Creating training and validation sets using an 80-20 split\n",
    "input_tensor_train, input_tensor_val, target_tensor_train, target_tensor_val = train_test_split(input_tensor, target_tensor, test_size=0.2)\n",
    "\n",
    "# Show length\n",
    "print(len(input_tensor_train), len(target_tensor_train), len(input_tensor_val), len(target_tensor_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lJPmLZGMeD5q"
   },
   "outputs": [],
   "source": [
    "def convert(lang, tensor):\n",
    "  for t in tensor:\n",
    "    if t!=0:\n",
    "      print (\"%d ----> %s\" % (t, lang.index_word[t]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VXukARTDd7MT"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input Language; index to word mapping\n",
      "1 ----> <start>\n",
      "265 ----> compre\n",
      "15 ----> un\n",
      "6648 ----> nopal\n",
      "3 ----> .\n",
      "2 ----> <end>\n",
      "\n",
      "Target Language; index to word mapping\n",
      "1 ----> <start>\n",
      "4 ----> i\n",
      "222 ----> bought\n",
      "9 ----> a\n",
      "2787 ----> cactus\n",
      "3 ----> .\n",
      "2 ----> <end>\n"
     ]
    }
   ],
   "source": [
    "print (\"Input Language; index to word mapping\")\n",
    "convert(inp_lang, input_tensor_train[0])\n",
    "print ()\n",
    "print (\"Target Language; index to word mapping\")\n",
    "convert(targ_lang, target_tensor_train[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rgCLkfv5uO3d"
   },
   "source": [
    "### Create a tf.data dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TqHsArVZ3jFS"
   },
   "outputs": [],
   "source": [
    "BUFFER_SIZE = len(input_tensor_train)\n",
    "BATCH_SIZE = 64\n",
    "steps_per_epoch = len(input_tensor_train)//BATCH_SIZE\n",
    "embedding_dim = 256\n",
    "units = 1024\n",
    "vocab_inp_size = len(inp_lang.word_index)+1\n",
    "vocab_tar_size = len(targ_lang.word_index)+1\n",
    "\n",
    "dataset = tf.data.Dataset.from_tensor_slices((input_tensor_train, target_tensor_train)).shuffle(BUFFER_SIZE)\n",
    "dataset = dataset.batch(BATCH_SIZE, drop_remainder=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qc6-NK1GtWQt"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(TensorShape([64, 16]), TensorShape([64, 11]))"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_input_batch, example_target_batch = next(iter(dataset))\n",
    "example_input_batch.shape, example_target_batch.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TNfHIF71ulLu"
   },
   "source": [
    "## Write the encoder and decoder model\n",
    "\n",
    "Implement an encoder-decoder model with attention which you can read about in the TensorFlow [Neural Machine Translation (seq2seq) tutorial](https://github.com/tensorflow/nmt). This example uses a more recent set of APIs. This notebook implements the [attention equations](https://github.com/tensorflow/nmt#background-on-the-attention-mechanism) from the seq2seq tutorial. The following diagram shows that each input words is assigned a weight by the attention mechanism which is then used by the decoder to predict the next word in the sentence. The below picture and formulas are an example of attention mechanism from [Luong's paper](https://arxiv.org/abs/1508.04025v5). \n",
    "\n",
    "<img src=\"https://www.tensorflow.org/images/seq2seq/attention_mechanism.jpg\" width=\"500\" alt=\"attention mechanism\">\n",
    "\n",
    "The input is put through an encoder model which gives us the encoder output of shape *(batch_size, max_length, hidden_size)* and the encoder hidden state of shape *(batch_size, hidden_size)*.\n",
    "\n",
    "Here are the equations that are implemented:\n",
    "\n",
    "<img src=\"https://www.tensorflow.org/images/seq2seq/attention_equation_0.jpg\" alt=\"attention equation 0\" width=\"800\">\n",
    "<img src=\"https://www.tensorflow.org/images/seq2seq/attention_equation_1.jpg\" alt=\"attention equation 1\" width=\"800\">\n",
    "\n",
    "This tutorial uses [Bahdanau attention](https://arxiv.org/pdf/1409.0473.pdf) for the encoder. Let's decide on notation before writing the simplified form:\n",
    "\n",
    "* FC = Fully connected (dense) layer\n",
    "* EO = Encoder output\n",
    "* H = hidden state\n",
    "* X = input to the decoder\n",
    "\n",
    "And the pseudo-code:\n",
    "\n",
    "* `score = FC(tanh(FC(EO) + FC(H)))`\n",
    "* `attention weights = softmax(score, axis = 1)`. Softmax by default is applied on the last axis but here we want to apply it on the *1st axis*, since the shape of score is *(batch_size, max_length, hidden_size)*. `Max_length` is the length of our input. Since we are trying to assign a weight to each input, softmax should be applied on that axis.\n",
    "* `context vector = sum(attention weights * EO, axis = 1)`. Same reason as above for choosing axis as 1.\n",
    "* `embedding output` = The input to the decoder X is passed through an embedding layer.\n",
    "* `merged vector = concat(embedding output, context vector)`\n",
    "* This merged vector is then given to the GRU\n",
    "\n",
    "The shapes of all the vectors at each step have been specified in the comments in the code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nZ2rI24i3jFg"
   },
   "outputs": [],
   "source": [
    "class Encoder(tf.keras.Model):\n",
    "  def __init__(self, vocab_size, embedding_dim, enc_units, batch_sz):\n",
    "    super(Encoder, self).__init__()\n",
    "    self.batch_sz = batch_sz\n",
    "    self.enc_units = enc_units\n",
    "    self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_dim)\n",
    "    self.gru = tf.keras.layers.GRU(self.enc_units,\n",
    "                                   return_sequences=True,\n",
    "                                   return_state=True,\n",
    "                                   recurrent_initializer='glorot_uniform')\n",
    "\n",
    "  def call(self, x, hidden):\n",
    "    x = self.embedding(x)\n",
    "    output, state = self.gru(x, initial_state = hidden)\n",
    "    return output, state\n",
    "\n",
    "  def initialize_hidden_state(self):\n",
    "    return tf.zeros((self.batch_sz, self.enc_units))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "60gSVh05Jl6l"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encoder output shape: (batch size, sequence length, units) (64, 16, 1024)\n",
      "Encoder Hidden state shape: (batch size, units) (64, 1024)\n"
     ]
    }
   ],
   "source": [
    "encoder = Encoder(vocab_inp_size, embedding_dim, units, BATCH_SIZE)\n",
    "\n",
    "# sample input\n",
    "sample_hidden = encoder.initialize_hidden_state()\n",
    "sample_output, sample_hidden = encoder(example_input_batch, sample_hidden)\n",
    "print ('Encoder output shape: (batch size, sequence length, units) {}'.format(sample_output.shape))\n",
    "print ('Encoder Hidden state shape: (batch size, units) {}'.format(sample_hidden.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "umohpBN2OM94"
   },
   "outputs": [],
   "source": [
    "class BahdanauAttention(tf.keras.layers.Layer):\n",
    "  def __init__(self, units):\n",
    "    super(BahdanauAttention, self).__init__()\n",
    "    self.W1 = tf.keras.layers.Dense(units)\n",
    "    self.W2 = tf.keras.layers.Dense(units)\n",
    "    self.V = tf.keras.layers.Dense(1)\n",
    "\n",
    "  def call(self, query, values):\n",
    "    # hidden shape == (batch_size, hidden size)\n",
    "    # hidden_with_time_axis shape == (batch_size, 1, hidden size)\n",
    "    # we are doing this to perform addition to calculate the score\n",
    "    hidden_with_time_axis = tf.expand_dims(query, 1)\n",
    "\n",
    "    # score shape == (batch_size, max_length, 1)\n",
    "    # we get 1 at the last axis because we are applying score to self.V\n",
    "    # the shape of the tensor before applying self.V is (batch_size, max_length, units)\n",
    "    score = self.V(tf.nn.tanh(\n",
    "        self.W1(values) + self.W2(hidden_with_time_axis)))\n",
    "\n",
    "    # attention_weights shape == (batch_size, max_length, 1)\n",
    "    attention_weights = tf.nn.softmax(score, axis=1)\n",
    "\n",
    "    # context_vector shape after sum == (batch_size, hidden_size)\n",
    "    context_vector = attention_weights * values\n",
    "    context_vector = tf.reduce_sum(context_vector, axis=1)\n",
    "\n",
    "    return context_vector, attention_weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "k534zTHiDjQU"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attention result shape: (batch size, units) (64, 1024)\n",
      "Attention weights shape: (batch_size, sequence_length, 1) (64, 16, 1)\n"
     ]
    }
   ],
   "source": [
    "attention_layer = BahdanauAttention(10)\n",
    "attention_result, attention_weights = attention_layer(sample_hidden, sample_output)\n",
    "\n",
    "print(\"Attention result shape: (batch size, units) {}\".format(attention_result.shape))\n",
    "print(\"Attention weights shape: (batch_size, sequence_length, 1) {}\".format(attention_weights.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yJ_B3mhW3jFk"
   },
   "outputs": [],
   "source": [
    "class Decoder(tf.keras.Model):\n",
    "  def __init__(self, vocab_size, embedding_dim, dec_units, batch_sz):\n",
    "    super(Decoder, self).__init__()\n",
    "    self.batch_sz = batch_sz\n",
    "    self.dec_units = dec_units\n",
    "    self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_dim)\n",
    "    self.gru = tf.keras.layers.GRU(self.dec_units,\n",
    "                                   return_sequences=True,\n",
    "                                   return_state=True,\n",
    "                                   recurrent_initializer='glorot_uniform')\n",
    "    self.fc = tf.keras.layers.Dense(vocab_size)\n",
    "\n",
    "    # used for attention\n",
    "    self.attention = BahdanauAttention(self.dec_units)\n",
    "\n",
    "  def call(self, x, hidden, enc_output):\n",
    "    # enc_output shape == (batch_size, max_length, hidden_size)\n",
    "    context_vector, attention_weights = self.attention(hidden, enc_output)\n",
    "\n",
    "    # x shape after passing through embedding == (batch_size, 1, embedding_dim)\n",
    "    x = self.embedding(x)\n",
    "\n",
    "    # x shape after concatenation == (batch_size, 1, embedding_dim + hidden_size)\n",
    "    x = tf.concat([tf.expand_dims(context_vector, 1), x], axis=-1)\n",
    "\n",
    "    # passing the concatenated vector to the GRU\n",
    "    output, state = self.gru(x)\n",
    "\n",
    "    # output shape == (batch_size * 1, hidden_size)\n",
    "    output = tf.reshape(output, (-1, output.shape[2]))\n",
    "\n",
    "    # output shape == (batch_size, vocab)\n",
    "    x = self.fc(output)\n",
    "\n",
    "    return x, state, attention_weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "P5UY8wko3jFp"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decoder output shape: (batch_size, vocab size) (64, 4935)\n"
     ]
    }
   ],
   "source": [
    "decoder = Decoder(vocab_tar_size, embedding_dim, units, BATCH_SIZE)\n",
    "\n",
    "sample_decoder_output, _, _ = decoder(tf.random.uniform((BATCH_SIZE, 1)),\n",
    "                                      sample_hidden, sample_output)\n",
    "\n",
    "print ('Decoder output shape: (batch_size, vocab size) {}'.format(sample_decoder_output.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_ch_71VbIRfK"
   },
   "source": [
    "## Define the optimizer and the loss function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WmTHr5iV3jFr"
   },
   "outputs": [],
   "source": [
    "optimizer = tf.keras.optimizers.Adam()\n",
    "loss_object = tf.keras.losses.SparseCategoricalCrossentropy(\n",
    "    from_logits=True, reduction='none')\n",
    "\n",
    "def loss_function(real, pred):\n",
    "  mask = tf.math.logical_not(tf.math.equal(real, 0))\n",
    "  loss_ = loss_object(real, pred)\n",
    "\n",
    "  mask = tf.cast(mask, dtype=loss_.dtype)\n",
    "  loss_ *= mask\n",
    "\n",
    "  return tf.reduce_mean(loss_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DMVWzzsfNl4e"
   },
   "source": [
    "## Checkpoints (Object-based saving)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Zj8bXQTgNwrF"
   },
   "outputs": [],
   "source": [
    "checkpoint_dir = './training_checkpoints'\n",
    "checkpoint_prefix = os.path.join(checkpoint_dir, \"ckpt\")\n",
    "checkpoint = tf.train.Checkpoint(optimizer=optimizer,\n",
    "                                 encoder=encoder,\n",
    "                                 decoder=decoder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hpObfY22IddU"
   },
   "source": [
    "## Training\n",
    "\n",
    "1. Pass the *input* through the *encoder* which return *encoder output* and the *encoder hidden state*.\n",
    "2. The encoder output, encoder hidden state and the decoder input (which is the *start token*) is passed to the decoder.\n",
    "3. The decoder returns the *predictions* and the *decoder hidden state*.\n",
    "4. The decoder hidden state is then passed back into the model and the predictions are used to calculate the loss.\n",
    "5. Use *teacher forcing* to decide the next input to the decoder.\n",
    "6. *Teacher forcing* is the technique where the *target word* is passed as the *next input* to the decoder.\n",
    "7. The final step is to calculate the gradients and apply it to the optimizer and backpropagate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "sC9ArXSsVfqn"
   },
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def train_step(inp, targ, enc_hidden):\n",
    "  loss = 0\n",
    "\n",
    "  with tf.GradientTape() as tape:\n",
    "    enc_output, enc_hidden = encoder(inp, enc_hidden)\n",
    "\n",
    "    dec_hidden = enc_hidden\n",
    "\n",
    "    dec_input = tf.expand_dims([targ_lang.word_index['<start>']] * BATCH_SIZE, 1)\n",
    "\n",
    "    # Teacher forcing - feeding the target as the next input\n",
    "    for t in range(1, targ.shape[1]):\n",
    "      # passing enc_output to the decoder\n",
    "      predictions, dec_hidden, _ = decoder(dec_input, dec_hidden, enc_output)\n",
    "\n",
    "      loss += loss_function(targ[:, t], predictions)\n",
    "\n",
    "      # using teacher forcing\n",
    "      dec_input = tf.expand_dims(targ[:, t], 1)\n",
    "\n",
    "  batch_loss = (loss / int(targ.shape[1]))\n",
    "\n",
    "  variables = encoder.trainable_variables + decoder.trainable_variables\n",
    "\n",
    "  gradients = tape.gradient(loss, variables)\n",
    "\n",
    "  optimizer.apply_gradients(zip(gradients, variables))\n",
    "\n",
    "  return batch_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ddefjBMa3jF0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 Batch 0 Loss 4.7473\n",
      "Epoch 1 Batch 100 Loss 2.1733\n",
      "Epoch 1 Batch 200 Loss 1.8787\n",
      "Epoch 1 Batch 300 Loss 1.7222\n",
      "Epoch 1 Loss 2.0324\n",
      "Time taken for 1 epoch 33.9479820728302 sec\n",
      "\n",
      "Epoch 2 Batch 0 Loss 1.5579\n",
      "Epoch 2 Batch 100 Loss 1.4370\n",
      "Epoch 2 Batch 200 Loss 1.4042\n",
      "Epoch 2 Batch 300 Loss 1.2848\n",
      "Epoch 2 Loss 1.3962\n",
      "Time taken for 1 epoch 17.57913875579834 sec\n",
      "\n",
      "Epoch 3 Batch 0 Loss 1.0146\n",
      "Epoch 3 Batch 100 Loss 0.9916\n",
      "Epoch 3 Batch 200 Loss 1.0946\n",
      "Epoch 3 Batch 300 Loss 0.9436\n",
      "Epoch 3 Loss 0.9849\n",
      "Time taken for 1 epoch 17.110281229019165 sec\n",
      "\n",
      "Epoch 4 Batch 0 Loss 0.6478\n",
      "Epoch 4 Batch 100 Loss 0.6424\n",
      "Epoch 4 Batch 200 Loss 0.7041\n",
      "Epoch 4 Batch 300 Loss 0.6307\n",
      "Epoch 4 Loss 0.6634\n",
      "Time taken for 1 epoch 17.549187421798706 sec\n",
      "\n",
      "Epoch 5 Batch 0 Loss 0.4491\n",
      "Epoch 5 Batch 100 Loss 0.3657\n",
      "Epoch 5 Batch 200 Loss 0.4612\n",
      "Epoch 5 Batch 300 Loss 0.4688\n",
      "Epoch 5 Loss 0.4508\n",
      "Time taken for 1 epoch 17.02736186981201 sec\n",
      "\n",
      "Epoch 6 Batch 0 Loss 0.3293\n",
      "Epoch 6 Batch 100 Loss 0.3074\n",
      "Epoch 6 Batch 200 Loss 0.3077\n",
      "Epoch 6 Batch 300 Loss 0.2849\n",
      "Epoch 6 Loss 0.3147\n",
      "Time taken for 1 epoch 17.503292560577393 sec\n",
      "\n",
      "Epoch 7 Batch 0 Loss 0.1896\n",
      "Epoch 7 Batch 100 Loss 0.2028\n",
      "Epoch 7 Batch 200 Loss 0.2070\n",
      "Epoch 7 Batch 300 Loss 0.1809\n",
      "Epoch 7 Loss 0.2236\n",
      "Time taken for 1 epoch 17.121249437332153 sec\n",
      "\n",
      "Epoch 8 Batch 0 Loss 0.1307\n",
      "Epoch 8 Batch 100 Loss 0.2151\n",
      "Epoch 8 Batch 200 Loss 0.1595\n",
      "Epoch 8 Batch 300 Loss 0.1825\n",
      "Epoch 8 Loss 0.1683\n",
      "Time taken for 1 epoch 17.56266689300537 sec\n",
      "\n",
      "Epoch 9 Batch 0 Loss 0.1091\n",
      "Epoch 9 Batch 100 Loss 0.1238\n",
      "Epoch 9 Batch 200 Loss 0.1262\n",
      "Epoch 9 Batch 300 Loss 0.1245\n",
      "Epoch 9 Loss 0.1290\n",
      "Time taken for 1 epoch 17.148908615112305 sec\n",
      "\n",
      "Epoch 10 Batch 0 Loss 0.0939\n",
      "Epoch 10 Batch 100 Loss 0.1082\n",
      "Epoch 10 Batch 200 Loss 0.1149\n",
      "Epoch 10 Batch 300 Loss 0.0957\n",
      "Epoch 10 Loss 0.1038\n",
      "Time taken for 1 epoch 17.501878261566162 sec\n",
      "\n"
     ]
    }
   ],
   "source": [
    "EPOCHS = 10\n",
    "\n",
    "for epoch in range(EPOCHS):\n",
    "  start = time.time()\n",
    "\n",
    "  enc_hidden = encoder.initialize_hidden_state()\n",
    "  total_loss = 0\n",
    "\n",
    "  for (batch, (inp, targ)) in enumerate(dataset.take(steps_per_epoch)):\n",
    "    batch_loss = train_step(inp, targ, enc_hidden)\n",
    "    total_loss += batch_loss\n",
    "\n",
    "    if batch % 100 == 0:\n",
    "      print('Epoch {} Batch {} Loss {:.4f}'.format(epoch + 1,\n",
    "                                                   batch,\n",
    "                                                   batch_loss.numpy()))\n",
    "  # saving (checkpoint) the model every 2 epochs\n",
    "  if (epoch + 1) % 2 == 0:\n",
    "    checkpoint.save(file_prefix = checkpoint_prefix)\n",
    "\n",
    "  print('Epoch {} Loss {:.4f}'.format(epoch + 1,\n",
    "                                      total_loss / steps_per_epoch))\n",
    "  print('Time taken for 1 epoch {} sec\\n'.format(time.time() - start))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mU3Ce8M6I3rz"
   },
   "source": [
    "## Translate\n",
    "\n",
    "* The evaluate function is similar to the training loop, except we don't use *teacher forcing* here. The input to the decoder at each time step is its previous predictions along with the hidden state and the encoder output.\n",
    "* Stop predicting when the model predicts the *end token*.\n",
    "* And store the *attention weights for every time step*.\n",
    "\n",
    "Note: The encoder output is calculated only once for one input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EbQpyYs13jF_"
   },
   "outputs": [],
   "source": [
    "def evaluate(sentence):\n",
    "  attention_plot = np.zeros((max_length_targ, max_length_inp))\n",
    "\n",
    "  sentence = preprocess_sentence(sentence)\n",
    "\n",
    "  inputs = [inp_lang.word_index[i] for i in sentence.split(' ')]\n",
    "  inputs = tf.keras.preprocessing.sequence.pad_sequences([inputs],\n",
    "                                                         maxlen=max_length_inp,\n",
    "                                                         padding='post')\n",
    "  inputs = tf.convert_to_tensor(inputs)\n",
    "\n",
    "  result = ''\n",
    "\n",
    "  hidden = [tf.zeros((1, units))]\n",
    "  enc_out, enc_hidden = encoder(inputs, hidden)\n",
    "\n",
    "  dec_hidden = enc_hidden\n",
    "  dec_input = tf.expand_dims([targ_lang.word_index['<start>']], 0)\n",
    "\n",
    "  for t in range(max_length_targ):\n",
    "    predictions, dec_hidden, attention_weights = decoder(dec_input,\n",
    "                                                         dec_hidden,\n",
    "                                                         enc_out)\n",
    "\n",
    "    # storing the attention weights to plot later on\n",
    "    attention_weights = tf.reshape(attention_weights, (-1, ))\n",
    "    attention_plot[t] = attention_weights.numpy()\n",
    "\n",
    "    predicted_id = tf.argmax(predictions[0]).numpy()\n",
    "\n",
    "    result += targ_lang.index_word[predicted_id] + ' '\n",
    "\n",
    "    if targ_lang.index_word[predicted_id] == '<end>':\n",
    "      return result, sentence, attention_plot\n",
    "\n",
    "    # the predicted ID is fed back into the model\n",
    "    dec_input = tf.expand_dims([predicted_id], 0)\n",
    "\n",
    "  return result, sentence, attention_plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "s5hQWlbN3jGF"
   },
   "outputs": [],
   "source": [
    "# function for plotting the attention weights\n",
    "def plot_attention(attention, sentence, predicted_sentence):\n",
    "  fig = plt.figure(figsize=(10,10))\n",
    "  ax = fig.add_subplot(1, 1, 1)\n",
    "  ax.matshow(attention, cmap='viridis')\n",
    "\n",
    "  fontdict = {'fontsize': 14}\n",
    "\n",
    "  ax.set_xticklabels([''] + sentence, fontdict=fontdict, rotation=90)\n",
    "  ax.set_yticklabels([''] + predicted_sentence, fontdict=fontdict)\n",
    "\n",
    "  ax.xaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "  ax.yaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "sl9zUHzg3jGI"
   },
   "outputs": [],
   "source": [
    "def translate(sentence):\n",
    "  result, sentence, attention_plot = evaluate(sentence)\n",
    "\n",
    "  print('Input: %s' % (sentence))\n",
    "  print('Predicted translation: {}'.format(result))\n",
    "\n",
    "  attention_plot = attention_plot[:len(result.split(' ')), :len(sentence.split(' '))]\n",
    "  plot_attention(attention_plot, sentence.split(' '), result.split(' '))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "n250XbnjOaqP"
   },
   "source": [
    "## Restore the latest checkpoint and test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UJpT9D5_OgP6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f494a9dcbe0>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# restoring the latest checkpoint in checkpoint_dir\n",
    "checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WrAM0FDomq3E"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: <start> hace mucho frio aqui . <end>\n",
      "Predicted translation: it s very cold here . <end> \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "translate(u'hace mucho frio aqui.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zSx2iM36EZQZ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: <start> esta es mi vida . <end>\n",
      "Predicted translation: this is my life . <end> \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "translate(u'esta es mi vida.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "A3LLCx3ZE0Ls"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: <start> ¿ todavia estan en casa ? <end>\n",
      "Predicted translation: are you still at home ? <end> \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "translate(u'¿todavia estan en casa?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DUQVLVqUE1YW"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: <start> trata de averiguarlo . <end>\n",
      "Predicted translation: try to figure it out . <end> \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# wrong translation\n",
    "translate(u'trata de averiguarlo.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RTe5P5ioMJwN"
   },
   "source": [
    "## Next steps\n",
    "\n",
    "* [Download a different dataset](http://www.manythings.org/anki/) to experiment with translations, for example, English to German, or English to French.\n",
    "* Experiment with training on a larger dataset, or using more epochs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<div style=\"direction:rtl;text-align:right;font-family:B Lotus, B Nazanin, Tahoma\"> دوره پیشرفته یادگیری عمیق<br>علیرضا اخوان پور<br>  آبان و آذر 1399<br>\n",
    "</div>\n",
    "<a href=\"http://class.vision\">Class.Vision</a> - <a href=\"http://AkhavanPour.ir\">AkhavanPour.ir</a> - <a href=\"https://github.com/Alireza-Akhavan/\">GitHub</a>\n",
    "\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "nmt_with_attention.ipynb",
   "private_outputs": true,
   "provenance": [],
   "toc_visible": true
  },
  "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}