NMT_400000.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TensorFlow 2.1.0\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import pickle\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow_datasets as tfds\n",
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.keras.layers import Embedding, GRU, Dense \n",
    "print('TensorFlow',tf.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "bDHTti385NJK",
    "outputId": "0cf717e5-66b6-448f-be63-48881220a9e4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
     ]
    }
   ],
   "source": [
    "from google.colab import drive\n",
    "drive.mount('/content/drive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 102
    },
    "colab_type": "code",
    "id": "IgB04IZ_KutF",
    "outputId": "628555d7-d165-4bea-ccf4-11bf3f082771"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: gputil in /usr/local/lib/python3.6/dist-packages (1.4.0)\n",
      "Requirement already satisfied: psutil in /usr/local/lib/python3.6/dist-packages (5.4.8)\n",
      "Requirement already satisfied: humanize in /usr/local/lib/python3.6/dist-packages (0.5.1)\n",
      "Gen RAM Free: 10.6 GB  | Proc size: 376.0 MB\n",
      "GPU RAM Free: 11441MB | Used: 0MB | Util   0% | Total 11441MB\n"
     ]
    }
   ],
   "source": [
    "# memory footprint support libraries/code\n",
    "!ln -sf /opt/bin/nvidia-smi /usr/bin/nvidia-smi\n",
    "!pip install gputil\n",
    "!pip install psutil\n",
    "!pip install humanize\n",
    "import psutil\n",
    "import humanize\n",
    "import os\n",
    "import GPUtil as GPU\n",
    "GPUs = GPU.getGPUs()\n",
    "# XXX: only one GPU on Colab and isn’t guaranteed\n",
    "gpu = GPUs[0]\n",
    "def printm():\n",
    " process = psutil.Process(os.getpid())\n",
    " print(\"Gen RAM Free: \" + humanize.naturalsize( psutil.virtual_memory().available ), \" | Proc size: \" + humanize.naturalsize( process.memory_info().rss))\n",
    " print(\"GPU RAM Free: {0:.0f}MB | Used: {1:.0f}MB | Util {2:3.0f}% | Total {3:.0f}MB\".format(gpu.memoryFree, gpu.memoryUsed, gpu.memoryUtil*100, gpu.memoryTotal))\n",
    "printm()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ISDqPtzQ5HOm"
   },
   "source": [
    "## Loading the Dataset using tensorflow_datasets "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PBW0iX7_5HOn"
   },
   "outputs": [],
   "source": [
    "NUM_SAMPLES = 400000\n",
    "dataset = tfds.load(name='wmt14_translate/fr-en', as_supervised=True, download=False, data_dir=\"/content/drive/My Drive\")\n",
    "dataset['train'] = dataset['train'].take(NUM_SAMPLES)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KtqatiFD5HOp"
   },
   "source": [
    "## Adding Start and End Sequence Markers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "HtqE1WEG5HOq",
    "outputId": "87bc2155-6277-4a01-d299-ac8d207cd200"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "400000it [02:29, 2666.98it/s]\n",
      "3000it [00:02, 1427.00it/s]\n"
     ]
    }
   ],
   "source": [
    "en_sentences = []\n",
    "fr_sentences = []\n",
    "for example in tqdm(dataset['train']):\n",
    "    fr_sentences.append(example[0].numpy().decode())\n",
    "    en_sentences.append('startseq ' + example[1].numpy().decode() + ' endseq')\n",
    "for example in tqdm(dataset['validation']):\n",
    "    fr_sentences.append(example[0].numpy().decode())\n",
    "    en_sentences.append('startseq ' + example[1].numpy().decode() + ' endseq')    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mqz4bMbh5HOt"
   },
   "source": [
    "## Tokenization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GaTtOKk75HOt"
   },
   "outputs": [],
   "source": [
    "en_tk = Tokenizer(num_words=30000)\n",
    "fr_tk = Tokenizer(num_words=30000)\n",
    "    \n",
    "en_tk.fit_on_texts(en_sentences)\n",
    "fr_tk.fit_on_texts(fr_sentences)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UMKTb-O85HOy"
   },
   "source": [
    "## Visualizing Sequence Lengths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 547
    },
    "colab_type": "code",
    "id": "ADO5e5km5HOy",
    "outputId": "6b5d4472-49bc-4b5a-f5d4-e40864d1eabd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "English sentences : mean = 28.52640446650124, std = 26.045968383940934, max = 5649\n",
      "French sentences : mean = 26.91360794044665, std = 21.01531582420789, max = 1505\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "en_lens = [len(x.split()) for x in en_sentences]\n",
    "fr_lens = [len(x.split()) for x in fr_sentences]\n",
    "\n",
    "plt.figure()\n",
    "plt.hist(en_lens)\n",
    "\n",
    "plt.figure()\n",
    "plt.hist(fr_lens)\n",
    "\n",
    "en_mean = np.mean(en_lens)\n",
    "en_std = np.std(en_lens)\n",
    "fr_mean = np.mean(fr_lens)\n",
    "fr_std = np.std(fr_lens)\n",
    "en_max = np.max(en_lens)\n",
    "fr_max = np.max(fr_lens)\n",
    "\n",
    "print(f'English sentences : mean = {en_mean}, std = {en_std}, max = {en_max}')\n",
    "print(f'French sentences : mean = {fr_mean}, std = {fr_std}, max = {fr_max}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jInzPs5A5HO1"
   },
   "outputs": [],
   "source": [
    "max_sequence_len = 30\n",
    "en_vocab_size = 30000\n",
    "fr_vocab_size = 30000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lvDeHeXL5HO4"
   },
   "source": [
    "## Tokenization and Sequence Padding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QCR08fEG5HO4"
   },
   "outputs": [],
   "source": [
    "def preprocess_en(en):\n",
    "    encoded_en = en_tk.texts_to_sequences(en)\n",
    "    padded_en = pad_sequences(encoded_en, maxlen=max_sequence_len, padding='post', truncating='post')\n",
    "    return padded_en\n",
    "\n",
    "def preprocess_fr(fr):\n",
    "    encoded_fr = fr_tk.texts_to_sequences(fr)\n",
    "    padded_fr = pad_sequences(encoded_fr, maxlen=max_sequence_len, padding='post', truncating='post')\n",
    "    return padded_fr\n",
    "\n",
    "def preprocess_text(en, fr):\n",
    "    return preprocess_en(en.numpy().decode()), preprocess_fr(fr.numpy().decode())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BNZSEsni5HO6"
   },
   "source": [
    "## Preparing Training Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "2g3ofFZX5HO7",
    "outputId": "208d2722-7b9d-48cd-8517-f5d1d674c9bf"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "400000it [02:15, 2960.39it/s]\n"
     ]
    }
   ],
   "source": [
    "train_ds = dataset['train']\n",
    "train_en = []\n",
    "train_fr = []\n",
    "for example in tqdm(train_ds):\n",
    "    train_fr.append(example[0].numpy().decode())\n",
    "    train_en.append('startseq ' + example[1].numpy().decode() + ' endseq')\n",
    "train_en = preprocess_en(train_en)\n",
    "train_fr = preprocess_fr(train_fr)\n",
    "\n",
    "batch_size = 80\n",
    "train_dataset = tf.data.Dataset.from_tensor_slices((train_fr, train_en))\n",
    "train_dataset = train_dataset.cache()\n",
    "train_dataset = train_dataset.shuffle(1024)\n",
    "train_dataset = train_dataset.batch(batch_size, drop_remainder=True)\n",
    "train_dataset = train_dataset.prefetch(tf.data.experimental.AUTOTUNE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "s8SZ7G0C5HO9"
   },
   "source": [
    "## Defining Encoder, Decoder, and Attention models using tf.keras Model Subclassing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HfPAVDFa5HO9"
   },
   "outputs": [],
   "source": [
    "class Encoder(tf.keras.Model):\n",
    "    def __init__(self, hidden_size=1000, max_sequence_len=30, batch_size=batch_size, embedding_dim=620, vocab_size=30000):\n",
    "        super(Encoder, self).__init__()\n",
    "        self.embedding_dim = embedding_dim\n",
    "        self.vocab_size = vocab_size\n",
    "        self.max_sequence_len = max_sequence_len\n",
    "        self.hidden_size = hidden_size\n",
    "        self.batch_size = batch_size\n",
    "        self.initializer = tf.keras.initializers.RandomNormal(mean=0, stddev=0.001)\n",
    "        self.embedding_layer = Embedding(\n",
    "            input_dim=self.vocab_size, output_dim=self.embedding_dim)\n",
    "        self.GRU_1 = Bidirectional(GRU(units=hidden_size, return_sequences=True, return_state=True, kernel_initializer=self.initializer,\n",
    "                                       bias_initializer='zeros'))\n",
    "\n",
    "    def initial_hidden_state(self):\n",
    "        return [tf.zeros(shape=(self.batch_size, self.hidden_size),) for i in range(2)]\n",
    "\n",
    "    def call(self, x, initial_state, training=False):\n",
    "        x = self.embedding_layer(x)\n",
    "        x, hidden_state,_ = self.GRU_1(x, initial_state=initial_state)\n",
    "        return x, hidden_state\n",
    "\n",
    "\n",
    "class Attention(tf.keras.Model):\n",
    "    def __init__(self, hidden_size=256):\n",
    "        super(Attention, self).__init__()\n",
    "        self.initializer = tf.keras.initializers.RandomNormal(mean=0, stddev=0.001)\n",
    "        self.fc1 = Dense(units=hidden_size, kernel_initializer=self.initializer,\n",
    "                                       bias_initializer='zeros')\n",
    "        self.fc2 = Dense(units=hidden_size, kernel_initializer=self.initializer,\n",
    "                                       bias_initializer='zeros')\n",
    "        self.fc3 = Dense(units=1, kernel_initializer=self.initializer,\n",
    "                                       bias_initializer='zeros')\n",
    "\n",
    "    def call(self, encoder_output, hidden_state, training=False):\n",
    "        '''hidden_state : h(t-1)'''\n",
    "        y_hidden_state = tf.expand_dims(hidden_state, axis=1)\n",
    "        y_hidden_state = self.fc1(y_hidden_state)\n",
    "        y_enc_out = self.fc2(encoder_output)\n",
    "\n",
    "        y = tf.keras.backend.tanh(y_enc_out + y_hidden_state)\n",
    "        attention_score = self.fc3(y)\n",
    "        attention_weights = tf.keras.backend.softmax(attention_score, axis=1)\n",
    "\n",
    "        context_vector = tf.multiply(encoder_output, attention_weights)\n",
    "        context_vector = tf.reduce_sum(context_vector, axis=1)\n",
    "\n",
    "        return context_vector, attention_weights\n",
    "\n",
    "\n",
    "class Decoder(tf.keras.Model):\n",
    "    def __init__(self, hidden_size=1000, max_sequence_len=30, batch_size=batch_size, embedding_dim=620, vocab_size=30000):\n",
    "        super(Decoder, self).__init__()\n",
    "        self.embedding_dim = embedding_dim\n",
    "        self.vocab_size = vocab_size\n",
    "        self.max_sequence_len = max_sequence_len\n",
    "        self.hidden_size = hidden_size\n",
    "        self.batch_size = batch_size\n",
    "        self.initializer = tf.keras.initializers.RandomNormal(mean=0, stddev=0.001)\n",
    "        self.embedding_layer = Embedding(\n",
    "            input_dim=self.vocab_size, output_dim=self.embedding_dim)\n",
    "        self.GRU = GRU(units=hidden_size,\n",
    "                       return_sequences=True, return_state=True)\n",
    "        self.attention = Attention(hidden_size=self.hidden_size)\n",
    "        self.fc = Dense(units=self.vocab_size, kernel_initializer=self.initializer,\n",
    "                                       bias_initializer='zeros')\n",
    "\n",
    "    def initial_hidden_state(self):\n",
    "        return tf.zeros(shape=(self.batch_size, self.hidden_size))\n",
    "\n",
    "    def call(self, x, encoder_output, hidden_state, training=False):\n",
    "        x = self.embedding_layer(x)\n",
    "        context_vector, attention_weights = self.attention(\n",
    "            encoder_output, hidden_state, training=training)\n",
    "        contect_vector = tf.expand_dims(context_vector, axis=1)\n",
    "        x = tf.concat([x, contect_vector], axis=-1)\n",
    "        x, curr_hidden_state = self.GRU(x)\n",
    "        x = tf.reshape(x, shape=[self.batch_size, -1])\n",
    "        x = self.fc(x)\n",
    "        return x, curr_hidden_state, attention_weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oyTdyV4S5HPA"
   },
   "source": [
    "## Defining Training Loop, Loss Function and Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "IIzMKRr-5HPA"
   },
   "outputs": [],
   "source": [
    "loss_object = tf.losses.SparseCategoricalCrossentropy(from_logits=True)\n",
    "optimizer = tf.keras.optimizers.Adadelta(rho=0.95, epsilon=1e-06)\n",
    "train_accuracy = tf.metrics.SparseCategoricalAccuracy()\n",
    "\n",
    "\n",
    "def loss_function(y_true, y_pred):\n",
    "    loss = loss_object(y_true, y_pred)\n",
    "    mask = 1 - tf.cast(tf.equal(y_true, 0), 'float32')\n",
    "    return tf.reduce_mean(loss * mask)\n",
    "    \n",
    "@tf.function()\n",
    "def training_step(fr, en):    \n",
    "    with tf.GradientTape() as Tape:\n",
    "        encoder_init_state = encoder.initial_hidden_state()\n",
    "        encoder_output, encoder_hidden_state = encoder(fr, encoder_init_state, training=True)\n",
    "        decoder_hidden = encoder_hidden_state\n",
    "        loss = 0\n",
    "        acc = []\n",
    "        current_word = tf.expand_dims(en[:, 0], axis=1)\n",
    "        for word_idx in range(1, max_sequence_len):\n",
    "            next_word = en[:, word_idx]\n",
    "            logits, decoder_hidden, attention_weights = decoder(current_word, encoder_output, decoder_hidden, training=True)\n",
    "            loss += loss_function(next_word, logits)\n",
    "            acc.append(train_accuracy(next_word, logits))\n",
    "            current_word = tf.expand_dims(next_word, axis=1)\n",
    "    variables = encoder.trainable_variables + decoder.trainable_variables\n",
    "    gradients = Tape.gradient(loss, variables)\n",
    "    optimizer.apply_gradients(zip(gradients, variables))\n",
    "    return loss, tf.reduce_mean(acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vSyQ3rz45HPC"
   },
   "outputs": [],
   "source": [
    "encoder = Encoder()\n",
    "decoder = Decoder()\n",
    "checkpoint_dir = '/content/drive/My Drive/training400000'\n",
    "checkpoint_prefix = '/content/drive/My Drive/training400000/ckpt'\n",
    "checkpoint = tf.train.Checkpoint(optimizer=optimizer, encoder=encoder, decoder=decoder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "0b7bxZmrOuqT",
    "outputId": "07c72123-5253-4d6f-be8e-5fa8b8b41238"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f5ad678bb38>"
      ]
     },
     "execution_count": 15,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkpoint.restore('/content/drive/My Drive/training400000/ckpt-7')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JVfYDZlK5HPE"
   },
   "source": [
    "## Training the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 613
    },
    "colab_type": "code",
    "id": "WdMpCnQ85HPF",
    "outputId": "70897d66-fc29-4d4a-82e5-3e4ff7da84f2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10 \n",
      "6250/6250 [==============================] - 2798s 421ms/batch - curr_loss: 1.9174 - curr_accuracy: 0.5128 \n",
      "Metrics after epoch 1 : Loss => 2.756 | Accuracy => 0.491\n",
      "Epoch 2/10 \n",
      "6250/6250 [==============================] - 2730s 437ms/batch - curr_loss: 1.7174 - curr_accuracy: 0.5337 \n",
      "Metrics after epoch 2 : Loss => 2.235 | Accuracy => 0.521\n",
      "Epoch 3/10 \n",
      "6250/6250 [==============================] - 2696s 431ms/batch - curr_loss: 1.5729 - curr_accuracy: 0.552 \n",
      "9Metrics after epoch 3 : Loss => 1.933 | Accuracy => 0.544\n",
      "Epoch 4/10 \n",
      "6250/6250 [==============================] - 2685s 430ms/batch - curr_loss: 1.5869 - curr_accuracy: 0.5665 \n",
      "Metrics after epoch 4 : Loss => 1.758 | Accuracy => 0.560\n",
      "Epoch 5/10 \n",
      "6250/6250 [==============================] - 2687s 430ms/batch - curr_loss: 1.4037 - curr_accuracy: 0.5776 \n",
      "Metrics after epoch 5 : Loss => 1.626 | Accuracy => 0.572\n",
      "Epoch 6/10 \n",
      "6250/6250 [==============================] - 6956s 1s/batch - curr_loss: 1.3711 - curr_accuracy: 0.6257 \n",
      "Metrics after epoch 6 : Loss => 1.521 | Accuracy => 0.622\n",
      "Epoch 7/10 \n",
      "6250/6250 [==============================] - 6946s 1s/batch - curr_loss: 1.4287 - curr_accuracy: 0.6347 \n",
      "/content/drive/My Drive/training400000/ckpt \n",
      "Metrics after epoch 7 : Loss => 1.455 | Accuracy => 0.635\n",
      "Epoch 8/10 \n",
      "6250/6250 [==============================] - 6917s 1s/batch - curr_loss: 1.2395 - curr_accuracy: 0.6422 \n",
      "/content/drive/My Drive/training400000/ckpt \n",
      "Metrics after epoch 8 : Loss => 1.364 | Accuracy => 0.639\n",
      "Epoch 9/10 \n",
      "6250/6250 [==============================] - 6912s 1s/batch - curr_loss: 1.0843 - curr_accuracy: 0.6476 \n",
      "/content/drive/My Drive/training400000/ckpt \n",
      "Metrics after epoch 9 : Loss => 1.309 | Accuracy => 0.645\n",
      "Epoch 10/10 \n",
      "6250/6250 [==============================] - 7012 1s/batch - curr_loss: 0.9241 - curr_accuracy: 0.6511 \n",
      "/content/drive/My Drive/training400000/ckpt \n",
      "Metrics after epoch 10 : Loss => 1.272 | Accuracy => 0.650\n"
     ]
    }
   ],
   "source": [
    "epochs = 10\n",
    "num_steps = NUM_SAMPLES // batch_size\n",
    "for epoch in range(1, epochs + 1):\n",
    "    print(f'Epoch {epoch}/{epochs}')\n",
    "    ep_loss = []\n",
    "    ep_acc = []\n",
    "    progbar = tf.keras.utils.Progbar(target=num_steps, stateful_metrics=[\n",
    "                                     'curr_loss', 'curr_accuracy'], unit_name='batch')\n",
    "\n",
    "    for step, example in enumerate(train_dataset):\n",
    "        fr = example[0]\n",
    "        en = example[1]\n",
    "        loss, acc = training_step(fr, en)\n",
    "        loss /= en.shape[1]\n",
    "        for i in range(len(encoder.trainable_weights)):\n",
    "          loss += 0.001 * tf.reduce_sum(tf.square(encoder.trainable_weights[i]))\n",
    "        for i in range(len(decoder.trainable_weights)):\n",
    "          loss += 0.001 * tf.reduce_sum(tf.square(decoder.trainable_weights[i]))\n",
    "        ep_loss.append(loss)\n",
    "        ep_acc.append(acc)\n",
    "        progbar.update(\n",
    "            step + 1, values=[('curr_loss', loss), ('curr_accuracy', acc)])\n",
    "\n",
    "    checkpoint.save(file_prefix=checkpoint_prefix)\n",
    "    print(checkpoint_prefix)\n",
    "    print(f'Metrics after epoch {epoch} : Loss => {np.mean(ep_loss):.3f} | Accuracy => {np.mean(ep_acc):.3f}')\n",
    "checkpoint.save(file_prefix=checkpoint_prefix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "QXYBfGbB5HPH",
    "outputId": "d113d138-edba-4339-d928-ff2de0321950"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f1594e680f0>"
      ]
     },
     "execution_count": 15,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkpoint.restore('/content/drive/My Drive/training400000/ckpt-10')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dKBU6jem5HPI"
   },
   "source": [
    "## Inference Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vp3iStoE5HPJ"
   },
   "outputs": [],
   "source": [
    "def translate_sentence(sentence):\n",
    "    sentence = preprocess_en([sentence])\n",
    "    enc_init = tf.zeros(shape=[1, 1024])\n",
    "    enc_out, enc_hidden = encoder(sentence, enc_init)\n",
    "\n",
    "    decoder.batch_size = 1\n",
    "    fr_tk.index_word[0] = ''\n",
    "    decoded = []\n",
    "    att = []\n",
    "    current_word = tf.expand_dims([fr_tk.word_index['startseq']], axis=0) \n",
    "    decoder_hidden = enc_hidden\n",
    "    for word_idx in range(1, max_sequence_len):\n",
    "        logits, decoder_hidden, attention_weights = decoder(current_word, enc_out, decoder_hidden)\n",
    "        decoded_idx = np.argmax(logits)\n",
    "        if fr_tk.index_word[decoded_idx] == 'endseq':\n",
    "            break\n",
    "        decoded.append(fr_tk.index_word[decoded_idx])\n",
    "        att.append(attention_weights.numpy().squeeze())\n",
    "        current_word = tf.expand_dims([decoded_idx], axis=0)\n",
    "    return ' '.join(decoded), att"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gN_U9s6h5HPL"
   },
   "source": [
    "## Translating and Visualizing Attention Maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "f833wT185HPM",
    "outputId": "b8d48a70-b259-44b3-d85e-2f21e47fb521"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EN :  il y a un malentendu\n",
      "FR :  there is a misunderstanding\n",
      "------------------------------\n",
      "EN :  que veux tu\n",
      "FR :  what do you\n",
      "------------------------------\n",
      "EN :  es tu fou\n",
      "FR :  what is your view\n",
      "------------------------------\n",
      "EN :  l'état de l'art\n",
      "FR :  the art\n",
      "------------------------------\n",
      "EN :  l'examen est difficile\n",
      "FR :  the review is difficult\n",
      "------------------------------\n",
      "EN :  voulez vous jouer avec moi\n",
      "FR :  do you want to play with me\n",
      "------------------------------\n",
      "EN :  je t'aime\n",
      "FR :  i\n",
      "------------------------------\n",
      "EN :  comment allez vous\n",
      "FR :  how will you\n",
      "------------------------------\n",
      "EN :  je dois vous dire que je suis très dangereux\n",
      "FR :  i have to say that i am very dangerous\n",
      "------------------------------\n",
      "EN :  as tu une idée de comment l'utiliser\n",
      "FR :  you can you think about how to use\n",
      "------------------------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 360x288 with 0 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 216x216 with 0 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 216x288 with 0 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x384 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 216x144 with 0 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 216x288 with 0 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAARoAAAFwCAYAAABn3LSGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAARNklEQVR4nO3de/DldV3H8ecLfiv3iygXRYU0UFER5WJaMKYGNYoySoyjRKS5maFpwQwhldUQTJiTmqkIhKjTqCResMTSDEaQ+3LTccQLg8agJMIu1wXe/XHOL38su+5vf799/77nwPMxs/M79/PeM8uTz/f7Pef8UlVIUqdNhh5A0iOfoZHUztBIamdoJLUzNJLaGRpJ7QyNpHaGRlI7QyOpnaFpkuTVSb6T5PYkdyRZmeSOoeeShhA/gtAjyQ3AoVX1raFnkYbmiqbPLUZGGnFF0yTJe4FdgM8C985eXlWfGWwoaSAzQw/wCLYtcBdw8JzLCjA0etRxRSOpnftomiTZM8lXklw3Pr93khOHnksagqHp8xHgz4DVAFV1DfDaQSeSBmJo+mxZVZeucdn9g0yiR4wkWyR5+tBzbChD0+fWJE9jtAOYJIcDNw87kqZZkkOBFcCXxuf3SfL5YaeaH3cGN0nyVOA04EXAbcD3gSOr6gdDzqXpleQK4CXA16rqeePLrq2q5ww72fp5eLtJVX0PeFmSrYBNqmrl0DNp6q2uqtuTzL1sKlYKhqZJku2Bo4DdgZnZfxxV9bYBx9J0uz7J64BNk+wBvA24aOCZ5sV9NH3+jVFkrgWumPNHWqi3As9i9E7zfwHuAN4+6ETz5D6aJkmurKrnDz2HNAkMTZMk7wBWAefx0M86/XSwoTSVknyBX7AvpqpeuYTjLIj7aPrcB5wKvJOf/yMp4KmDTaRp9e6hB1gsVzRNknwPOKCqbh16Fmlormj63MDo09vSoiT5VFUdkeRaHroJFaCqau+BRps3Q9PnTmBFkv/ioftoPLytDfXH45+vGHSKRTA0fT47/iMtSlXNfnRlE+DmqroHRp97AnYebLAN4D4aaUokuRx4UVXdNz7/GODrVbX/sJOtnyuaJuN3bp4M7AVsPnt5VXnUSQs1MxsZgKq6bxybiec7g/v8M/BBRl8N8evA2cDHB51I0+4nSf7/PTNJXgVMxVFNN52aJLmiqvad++na2cuGnk3Tafy1I58AnsjoiNNNwFFVdcOgg82Dm0597k2yCfCdJMcAPwK2HngmTbGq+i7wK0m2Hp9fNfBI8+aKpkmS/YFvAdsDfwNsB/xdVX1j0ME0dZIcWVUfT/Ina7u+qt6z1DNtKFc0fa4dH4ZcBfweQJLHDzuSptSW45/bDDrFIhiaPpcledPsCibJaxgdhdpz2LE0hZ42/vnNqvr0oJMskJtOTZI8BzgT+BqjnXePA36/qn445FyTJslmVXXv+i57NBt/9GBv4Ipp/eoRVzRNquraJCcBHwNWAgcZmbW6GFjzP561XfZo9iVG3zu9dZI75lw++1mnbYcZa/4MTZMkZzBa8u7NaHPpvCTvr6oPDDvZZEiyC7ArsEWS5zH6jwZGv0p4y3Xe8dHpxKo6LsnnqupVQw+zEIamz7WMNpUK+H6SFwATf3RgCR0CHA08Cfh7fh6alcAJA800qWZXeHes74aTyn00jZLsBuxRVf85/gDcjL8N4aGSvKaq/nXoOSbZ+Ncq/y2jt0kct+b1VfWZJR9qA7miaZLkTcByYAdGm1BPAj4EvHTIuSbQk5Jsy2gl8xFG/+c+vqq+POxYE+XNwOsZvSfr0DWuK2DiQ+OKpkmSFcABwCXT9su+llKSq6vquUkOYfQf1InAx6b16EqnJG+sqjOGnmMhXNH0uXf86VoAkswwJb/sa4nN7pt5OXB2VV2fNX5D2qNdkpdU1VeB25K8es3r3XR6dPvvJCcwOqryG8BbgC8MPNMkuiLJ+Yy+tP34JNsADw4806Q5CPgqo82mYnxYe87PiQ+Nm05Nxh+ofCNwMKN/EOcDp5cv+EOMX6cTgcdW1TuSPAXYraouHHi0iZHkT3l4YBifnorPOhkaDSrJBxmtYF5SVc9M8ljgy9PwrXFLJclfjk8+Hdgf+Byj2BwKXFpVRw4123wZmo1s/GXkBfy0qg4fep5JN/sbPZNcNWen+dVV9dyhZ5s0SS4AXj77FonxZuYXq+qgYSdbP/fRbHxHj38+MOQQU2R1kk0ZbwYk2RH30azLzox+MeGs+5iSLyc3NBtZVd049AxT5n3AucBO48+GHc5on40e7mzg0iTnjs8fBpw13Djz56bTRpZkJWs/jD01H4BbakmeweiNjAG+UlXfGnikiZXk+cCB47MXVNVVQ84zX4ZGUjt/C4KkdoZGUjtDswSSLB96hmnhazU/0/Y6GZqlMVX/KAbmazU/U/U6GRpJ7R5xR51mttuyNtt5u6HHeIj7b7+Lme0m69spH7x9Mt9C9cDdd7LpFlsNPcZDLLtz8t4/uHr1nSxbNlmv0z33/oz7Vt+51k/eT+a/tkXYbOfteNb7jh56jIl39/k7DT3C1NjlYr8UcT4uue7D67zOTSdJ7QyNpHaGRlI7QyOpnaGR1M7QSGpnaCS1MzSS2hkaSe0MjaR2hkZSO0MjqZ2hkdTO0EhqZ2gktTM0ktoZGkntDI2kdoZGUjtDI6mdoZHUztBIamdoJLUzNJLaGRpJ7QyNpHaGRlI7QyOpnaGR1M7QSGpnaCS1GyQ0SbZP8pbx6RcnOW+IOSQtjaFWNNsDbxnouSUtsZmBnvcU4GlJVgCrgTuTnAM8G7gCOLKqKsm+wHuArYFbgaOr6uaBZpa0QEOtaI4HvltV+wDHAc8D3g7sBTwV+NUky4D3A4dX1b7AmcBJA80raRGGWtGs6dKq+iHAeJWzO/AzRiuc/0gCsCmw1tVMkuXAcoDH7LTtEowraUNMSmjunXP6AUZzBbi+ql64vjtX1WnAaQBb7fmEaplQ0oINtem0EthmPbf5NrBjkhcCJFmW5Fntk0na6AZZ0VTV/yb5epLrgLuBW9Zym/uSHA68L8l2jGb9B+D6pZ1W0mINtulUVa9bx+XHzDm9AjhoyYaS1MJ3BktqZ2gktTM0ktoZGkntDI2kdoZGUjtDI6mdoZHUztBIamdoJLUzNJLaGRpJ7QyNpHaGRlI7QyOpnaGR1M7QSGpnaCS1MzSS2hkaSe0MjaR2hkZSO0MjqZ2hkdTO0EhqZ2gktTM0ktoZGkntDI2kdoZGUjtDI6ndzNADbHS3zfDAOTsOPcXEO/iYi4ceYWpccuP+Q48wFR78dtZ5nSsaSe0MjaR2hkZSO0MjqZ2hkdTO0EhqZ2gktTM0ktoZGkntDI2kdoZGUjtDI6mdoZHUztBIamdoJLUzNJLaGRpJ7QyNpHaGRlI7QyOpnaGR1M7QSGpnaCS1MzSS2hkaSe0MjaR2hkZSO0MjqZ2hkdTO0EhqZ2gktTM0ktoZGkntDI2kdksemiRPTHLOUj+vpOHMLPYBkgRIVT04n9tX1f8Ahy/2eSVNjwWtaJLsnuTbSc4GrgP+PMllSa5J8lfj25yS5I/m3OddSY4d3/e68WWbJjl1zn3/YHz5B5K8cnz63CRnjk+/IclJi/srS1pqi9l02gP4J+AdwK7AAcA+wL5JDgI+CRwx5/ZHjC+b643A7VW1P7A/8KYkvwRcCBw4vs2uwF7j0wcCF6w5SJLlSS5Pcvn9d9+5iL+SpA6LCc2NVfUN4ODxn6uAK4FnAHtU1VXATuN9Ms8Fbquqm9Z4jIOBo5KsAC4BHscoYBcCBybZC/gmcEuSJwAvBC5ac5CqOq2q9quq/Wa22GoRfyVJHRazj2Z26RDg5Kr68Fpu82lG+2N24eGrmdn7vrWqzn/YFcn2wG8yWsHswGhFtKqqVi5iZkkD2BhHnc4H3pBka4AkuybZaXzdJ4HXMorNp9dx3z9Msmx83z2TzC5JvgG8nVFoLgSOHf+UNGUWfdSpqr6c5JnAxaMDUKwCjgR+XFXXJ9kG+FFV3byWu58O7A5cOT569RPgsPF1FwIHV9UNSW5ktKoxNNIUWlBoquoHwLPnnH8v8N513PY567rv+JD4CeM/a97vDOCM8enVgDtfpCnlO4MltTM0ktoZGkntDI2kdoZGUjtDI6mdoZHUztBIamdoJLUzNJLaGRpJ7QyNpHaGRlI7QyOpnaGR1M7QSGpnaCS1MzSS2hkaSe0MjaR2hkZSO0MjqZ2hkdTO0EhqZ2gktTM0ktoZGkntDI2kdoZGUjtDI6mdoZHUbmboATSMLTe9b+gRpsZdO2469AhT4cGZrPM6VzSS2hkaSe0MjaR2hkZSO0MjqZ2hkdTO0EhqZ2gktTM0ktoZGkntDI2kdoZGUjtDI6mdoZHUztBIamdoJLUzNJLaGRpJ7QyNpHaGRlI7QyOpnaGR1M7QSGpnaCS1MzSS2hkaSe0MjaR2hkZSO0MjqZ2hkdTO0EhqZ2gktTM0ktpNbGiSXDT0DJI2jokNTVW9aOgZJG0cExuaJKvGP5+Q5IIkK5Jcl+TAoWeTtGFmhh5gHl4HnF9VJyXZFNhy6IEkbZhpCM1lwJlJlgGfraoVa94gyXJgOcBjtnrsEo8naX0mdtNpVlVdABwE/Ag4K8lRa7nNaVW1X1XtN7PFVks+o6RfbOJDk2Q34Jaq+ghwOvD8gUeStIGmYdPpxcBxSVYDq4CHrWgkTbaJDU1VbT3++VHgowOPI2kRJn7TSdL0MzSS2hkaSe0MjaR2hkZSO0MjqZ2hkdTO0EhqZ2gktTM0ktoZGkntDI2kdoZGUjtDI6mdoZHUztBIamdoJLUzNJLaGRpJ7QyNpHaGRlI7QyOpnaGR1M7QSGpnaCS1MzSS2hkaSe0MjaR2hkZSO0MjqZ2hkdQuVTX0DBvVttmhXpCXDj3GxJvZ/SlDjzA1vnjR54ceYSoccMhNXH71PVnbda5oJLUzNJLaGRpJ7QyNpHaGRlI7QyOpnaGR1M7QSGpnaCS1MzSS2hkaSe0MjaR2hkZSO0MjqZ2hkdTO0EhqZ2gktTM0ktoZGkntDI2kdoZGUjtDI6mdoZHUztBIamdoJLUzNJLaGRpJ7QyNpHaGRlI7QyOpnaGR1M7QSGpnaCS12+DQJHlXkmOT/HWSl40vOzDJ9UlWJNkiyanj86cmeXOSoxYyXJKvJdlvfPqEhTyGpOHNLPSOVfUXc86+Hji5qj4OkGQ5sENVPbDI+eY6Afjbjfh4kpbIvEKT5J3A7wI/Bm4CrkhyFnAesD1wBHBIkt8CtgG2Ht/mZOCZwKqqeneSXwY+BOwIPAD8NvBk4NiqesX4uf4RuLyqzprz/KcAWyRZAVxfVa9f7F9c0tJZb2iS7Au8FthnfPsrgStmr6+q05P8GnBeVZ0zvs+qqtpnfPpdcx7uE8ApVXVuks0Zbbo9eX0zVNXxSY6ZfUxJ02U+K5oDgXOr6i6AJJ9fyBMl2QbYtarOBaiqe8aXL+Th1nzs5cBygM3ZctGPJ2njmoSjTvfz0Dk239AHqKrTqmq/qtpvGZttvMkkbRTzCc0FwGHjo0nbAIcu5ImqaiXwwySHASTZLMmWwI3AXuPz2wMvXcdDrE6ybCHPLWlY6w1NVV0JfBK4Gvh34LJFPN/vAG9Lcg1wEbBLVd0EfAq4bvzzqnXc9zTgmiSfWMTzSxpAqmroGTaqbbNDvSDrWhRp1szuTxl6hKnxxYsWtFvyUeeAQ27i8qvvWetO10nYRyPpEc7QSGpnaCS1MzSS2hkaSe0MjaR2hkZSO0MjqZ2hkdTO0EhqZ2gktTM0ktoZGkntDI2kdoZGUjtDI6mdoZHUztBIamdoJLUzNJLaGRpJ7QyNpHaGRlI7QyOpnaGR1M7QSGpnaCS1MzSS2hkaSe0MjaR2hkZSO0MjqV2qaugZNqokPwFuHHqONTweuHXoIaaEr9X8TOLrtFtV7bi2Kx5xoZlESS6vqv2GnmMa+FrNz7S9Tm46SWpnaCS1MzRL47ShB5givlbzM1Wvk/toJLVzRSOpnaGR1M7QSGpnaCS1MzSS2v0fn8kMA+TaDcEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 288x384 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 360x504 with 0 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x403.2 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 144x72 with 0 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 216x216 with 0 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQkAAAEnCAYAAAC6zrYiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAANW0lEQVR4nO3de6xldXmH8ec7F27qdBQGq0KhXtoUDZc4Jt6wXgppqGnS1ktNUdBWrBqqf6A2/cfWRptUbZNqkwoqLbZapS22GisVbBACLYECZUQjKhCxRRAQlAIDw9s/9h7mzDlnXs4ZZua3d3g+ycnstfaZzTtrDs+stfbae6eqkKRdWTN6AEmzzUhIahkJSS0jIallJCS1jISklpGQ1DISklpGYpEkF65knfRYsW70ALMiyQHAQcAhSZ4IZHrXBuBpwwaTBjMSO7wFeCfwVOBKdkTibuCjo4aSRouv3dhZktOr6iOj55BmhZFYRpIXAkeyYE+rqs4ZNpA0kIcbiyT5FPAM4Gpg23R1AUZCj0nuSSyS5BvAUeWGkQCfAl3OFuCnRw8hzQoPN5Y6BLguyeXA/dtXVtWvjhtJGsdILPWHoweQZonnJJaR5AjgWVV1QZKDgLVV9ePRc0kjeE5ikSRvBv4B+Nh01dOAz4+bSBrLSCz1duBFTK60pKquBw4dOpE0kJFY6v6q2rp9Ick6JtdJSI9JRmKpi5L8AXBgkhOAc4EvDJ5JGsYTl4skWQP8NnAikxd5nQ983Iur9FhlJCS1PNxYJMkrk1yV5I4kdyf5cZK7R88ljeKexCJJvg38OnCthxiSexLL+R6wxUBIE+5JLJLkecAfAxex82s3/mzYUNJAvnZjqfcDPwEOAPYbPIs0nJFY6qlV9ZzRQ0izwnMSS30pyYmjh5BmhZFY6q3Al5Pc61OgvSQXJjlp0bozR80zq5L8aZINSdZPt9ltSU4ePddKGYlFquoJVbWmqg6sqg3T5Q2j55pRPwu8J8l7F6zbPGqYGXZiVd0NvBK4EXgm8K6hE62C5ySWkeRolr5b9j8NG2h2/Qh4BfAXSb4AzM2/jvvY9p+jXwHOraq7knTfP1OMxCJJPgkcDXwdeGi6ugAjsVSq6kHgbUlOBS4Bnjh2pJn0xSTfBO4F3ppkE3Df4JlWzOskFklyXVUdNXqOeZDkLVX1sQXLzwXeXlVvGjjWTEryJOCuqto2fbezDVV1y+i5VsJILJLkE8CHq+q60bPMgyQvZvJWf2dP/4V8fFXdMHquWZLkDcutn5cPfPJwY6lzgMuS3MLkissAVVVHjx1r9kxPWG4Gfh44G1gP/C2Td/bSDs9bcPsAJudx/os5+cAnI7HUJ4DXA9ey45yElvdrwHFMfuCpqv9J8oSxI82eqjp94XKSjcDfDxpn1YzEUrdV1b+MHmJObK2qSlIASR43eqA5cQ+Tp4/ngpFY6qokn2bylnULX+DlsxtLfS7Jx4CN03cZfxNw1uCZZs706eHtJ//WAr8AfG7cRKvjictFkpy9zOryjP3ypu8D+vBb/VXVVwaPNHOS/OKCxQeBm6rq5lHzrJaRkPaBJE9mxwnMy6vq1pHzrIaXZS+S5LAk5yW5dfr1j0kOGz3XLNn+epZlvnydyzKSvAa4HHg18BrgP5O8auxUK+eexCJJvgJ8GvjUdNXJwG9V1QnjptI8S3INcML2vYfp9SQXVNUxYydbGU9cLrWpqhael/jrJO8cNs0Mml49uEtVdce+mmVOrFl0eHE7c7QXbySWun36Mt7PTJdfx+QvVTtcyeRs/cJXKW1fLuDpI4aaYf+a5Hx2/Ey9FvjSwHlWxcONRaafKP4R4AVMfuAvBU6vqu8NHWxGTfcqnsXkSkIAquqicRPNniRnAD8Ajp2uuqSqzhs40qq4J7HU+4BTqupOePh/gg8xuQZACyT5HeAdwGHA1cDzmUT1FSPnmkGPA34fuAP4LJNtNDfm5rhoHzp6eyDg4ePr4wbOM8veweRpvZuq6mVMttNdY0eaPVX1R1X1bCafWP8UJp83e8HgsVbMSCy1JsnD74kw3ZNwj2t591XVfQBJ9q+qbzJ5sZeWdytwC5NzXIcOnmXF/OFf6sNMXgV67nT51UzeZl9L3Tx9sdLnga8kuRO4afBMMyfJ25hcH7GJyafUv3me3orAE5fLSHIU8PLp4lfn6S90lOmlxz8FfLmqto6eZ5Yk+RPgs1V19ehZdoeRkNTynISklpGQ1DISjyDJaaNnmAdup5Wbt21lJB7ZXP2FDuR2Wrm52lZGQlJrpp7dOORJa+vIw9ePHmMnt92+jU0Hrx09xk6+9d2DR4+wxNYH7mG/9bP3Fpe574HRIyyx9aF72W/NgaPH2Mm9237M1ofuXfZjxWbqYqojD1/P5ecfPnqMmXfC6944eoS5sf6b3x89wly47Ifn7vI+DzcktYyEpJaRkNQyEpJaRkJSy0hIahkJSS0jIallJCS1jISklpGQ1DISklpGQlLLSEhqGQlJLSMhqWUkJLWMhKSWkZDUMhKSWkZCUstISGoZCUktIyGpZSQktYyEpJaRkNQyEpJaRkJSy0hIahkJSS0jIan1iJFIcmSSLftiGEmzxz0JSa2VRmJtkrOSfD3JvyU5MMmxSf4jyX8nOS/JE5McmuRKgCTHJKkkPzNd/k6Sg/ban0TSXrHSSDwL+MuqejbwI+A3gHOA91TV0cC1wHur6lbggCQbgOOBK4DjkxwB3FpV/7f4gZOcluSKJFfcdvu2PfBHkrQnrTQSN1TV1dPbVwLPADZW1UXTdX8DvGR6+1LgRdPlD0x/PR64eLkHrqozq2pzVW3edPDa3fgjSNqbVhqJ+xfc3gZsbL73a0yicATwz8AxwIvZRSQkzbbdPXF5F3BnkuOny68Htu9VXAycDFxfVQ8BdwAnAZc8mkEljbHuUfzeU4C/mp6M/C7wRoCqujFJmOxRwCQOh1XVnY9qUklDPGIkqupG4DkLlj+04O7n7+L3HL7g9geYnJuQNIe8TkJSy0hIahkJSS0jIallJCS1jISklpGQ1DISklpGQlLLSEhqGQlJLSMhqWUkJLWMhKSWkZDUMhKSWkZCUstISGoZCUktIyGpZSQktYyEpJaRkNQyEpJaRkJSy0hIahkJSS0jIallJCS1jISklpGQ1Fo3eoCFvvWdgznxVaeMHmPm/e8ZW0ePMDcOOeuI0SPMhYcu2W+X97knIallJCS1jISklpGQ1DISklpGQlLLSEhqGQlJLSMhqWUkJLWMhKSWkZDUMhKSWkZCUstISGoZCUktIyGpZSQktYyEpJaRkNQyEpJaRkJSy0hIahkJSS0jIallJCS1jISklpGQ1DISklpGQlLLSEhqGQlJLSMhqbVHI5HkS0k2Tm//ZPrrkUm27Mn/jqR9Z92efLCqOmlPPp6k8Va1J5HkXUl+b3r7z5N8dXr75Un+LsmNSQ7ZG4NKGmO1hxsXA8dPb28GHp9k/XTd1/bkYJJmw2ojcSXw3CQbgPuBy5jE4ngmAVm1JKcluSLJFQ88eM/uPISkvWhVkaiqB4AbgFOBS5mE4WXAM4Fv7M4AVXVmVW2uqs3r1z1udx5C0l60O89uXAycweTw4mLgd4Grqqr25GCSZsPuRuIpwGVV9QPgPnbzUEPS7Fv1U6BVdSGwfsHyzy24feSC24+f/noj8JxHM6SkcbziUlLLSEhqGQlJLSMhqWUkJLWMhKSWkZDUMhKSWkZCUstISGoZCUktIyGpZSQktYyEpJaRkNQyEpJaRkJSy0hIahkJSS0jIallJCS1jISklpGQ1DISklpGQlLLSEhqGQlJLSMhqWUkJLWMhKSWkZDUWjd6gJ3ccy+59JrRU8y8XPrC0SPMje+/tEaPMBe2XpNd3ueehKSWkZDUMhKSWkZCUstISGoZCUktIyGpZSQktYyEpJaRkNQyEpJaRkJSy0hIahkJSS0jIallJCS1jISklpGQ1DISklpGQlLLSEhqGQlJLSMhqWUkJLWMhKSWkZDUMhKSWkZCUstISGoZCUktIyGpZSQktYyEpJaRkNQyEpJaK45EkvcleeeC5fcneUeSDybZkuTaJK+d3vfSJF9c8L0fTXLqHp1c0j6xmj2JTwJvAEiyBvhN4GbgWOAY4JeADyZ5yp4eUtI461b6jVV1Y5LbkxwHPBm4Cngx8Jmq2gb8IMlFwPOAu1f6uElOA04DOICDVjO7pH1gteckPg6cCryRyZ7Frjy46LEP2NU3VtWZVbW5qjavZ/9VjiNpb1ttJM4DfpnJ3sL5wMXAa5OsTbIJeAlwOXATcFSS/ZNsBF6xB2eWtA+t+HADoKq2Jvl34EdVtS3JecALgGuAAt5dVbcAJPkcsAW4gcmhiaQ5tKpITE9YPh94NUBVFfCu6ddOqurdwLv3wIySBlrNU6BHAd8GLqyq6/feSJJmyWqe3bgOePpenEXSDPKKS0ktIyGpZSQktYyEpJaRkNQyEpJaRkJSy0hIahkJSS0jIallJCS1jISklpGQ1DISklpGQlLLSEhqGQlJLSMhqWUkJLWMhKSWkZDUMhKSWkZCUstISGoZCUktIyGpZSQktYyEpJaRkNQyEpJaqarRMzwsyW3ATaPnWOQQ4Iejh5gDbqeVm8VtdURVbVrujpmKxCxKckVVbR49x6xzO63cvG0rDzcktYyEpJaReGRnjh5gTridVm6utpXnJCS13JOQ1DISklpGQlLLSEhqGQlJrf8HgxsUDTB15FkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 648x648 with 0 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 504x576 with 0 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x329.143 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sentences = [\"il y a un malentendu\",\n",
    "             'que veux tu',\n",
    "             'es tu fou',\n",
    "             \"l'état de l'art\",\n",
    "             \"l'examen est difficile\", \n",
    "             'voulez vous jouer avec moi',\n",
    "             \"je t'aime\",\n",
    "             \"comment allez vous\",\n",
    "             'je dois vous dire que je suis très dangereux',\n",
    "             \"as tu une idée de comment l'utiliser\"]\n",
    "\n",
    "for inp_sentence in sentences:\n",
    "    inp_array = inp_sentence.split()\n",
    "    inp_len = len(inp_sentence.split())\n",
    "    trans_sentence, attention_weights = translate_sentence(inp_sentence)\n",
    "    trans_array = trans_sentence.split()\n",
    "    trans_len = len(trans_array)\n",
    "    attention_weights = np.array([x for x in attention_weights])\n",
    "    attention_weights = attention_weights[:trans_len,:inp_len]\n",
    "    plt.figure(figsize=(inp_len, trans_len))\n",
    "    plt.matshow(attention_weights)\n",
    "    plt.xticks(ticks=range(inp_len), labels=inp_array, rotation=90)\n",
    "    plt.yticks(ticks=range(trans_len), labels=trans_array)\n",
    "    print('FR : ', inp_sentence)\n",
    "    print('EN : ', trans_sentence)\n",
    "    print('-'*30)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "NMT_400000.ipynb",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}