Upload 15 files

.gitattributes

@@ -72,3 +72,7 @@ Word_Representation/many_to_one_prediction_for_emoji/home/jovyan/work/W2A2/image
 Word_Representation/many_to_one_prediction_for_emoji/home/jovyan/work/W2A2/images/emojiss.png filter=lfs diff=lfs merge=lfs -text
 Word_Representation/many_to_one_prediction_for_emoji/home/jovyan/work/W2A2/images/image_1.png filter=lfs diff=lfs merge=lfs -text
 Word_Representation/many_to_one_prediction_for_emoji/home/jovyan/work/W2A2/images/woebot.png filter=lfs diff=lfs merge=lfs -text
+Seq2Seq/Neural_MT_without_Teacher_Forcing/home/jovyan/work/W3A1/images/attn_mechanism.png filter=lfs diff=lfs merge=lfs -text
+Seq2Seq/Neural_MT_without_Teacher_Forcing/home/jovyan/work/W3A1/images/attn_model.png filter=lfs diff=lfs merge=lfs -text
+Seq2Seq/Neural_MT_without_Teacher_Forcing/home/jovyan/work/W3A1/images/date_attention.png filter=lfs diff=lfs merge=lfs -text
+Seq2Seq/Neural_MT_without_Teacher_Forcing/home/jovyan/work/W3A1/images/date_attention2.png filter=lfs diff=lfs merge=lfs -text

Seq2Seq/Neural_MT_without_Teacher_Forcing/home/jovyan/work/W3A1/.ipynb_checkpoints/Neural_machine_translation_with_attention_v4a-checkpoint.ipynb

@@ -0,0 +1,1390 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "adTDe2CTh3MU"
+   },
+   "source": [
+    "# Neural Machine Translation\n",
+    "\n",
+    "Welcome to your first programming assignment for this week! \n",
+    "\n",
+    "* You will build a Neural Machine Translation (NMT) model to translate human-readable dates (\"25th of June, 2009\") into machine-readable dates (\"2009-06-25\"). \n",
+    "* You will do this using an attention model, one of the most sophisticated sequence-to-sequence models. \n",
+    "\n",
+    "This notebook was produced together with NVIDIA's Deep Learning Institute. \n",
+    "\n",
+    "## Important Note on Submission to the AutoGrader\n",
+    "\n",
+    "Before submitting your assignment to the AutoGrader, please make sure you are not doing the following:\n",
+    "\n",
+    "1. You have not added any _extra_ `print` statement(s) in the assignment.\n",
+    "2. You have not added any _extra_ code cell(s) in the assignment.\n",
+    "3. You have not changed any of the function parameters.\n",
+    "4. You are not using any global variables inside your graded exercises. Unless specifically instructed to do so, please refrain from it and use the local variables instead.\n",
+    "5. You are not changing the assignment code where it is not required, like creating _extra_ variables.\n",
+    "\n",
+    "If you do any of the following, you will get something like, `Grader Error: Grader feedback not found` (or similarly unexpected) error upon submitting your assignment. Before asking for help/debugging the errors in your assignment, check for these first. If this is the case, and you don't remember the changes you have made, you can get a fresh copy of the assignment by following these [instructions](https://www.coursera.org/learn/nlp-sequence-models/supplement/qHIve/h-ow-to-refresh-your-workspace)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "0LCkjDBFh3Md"
+   },
+   "source": [
+    "## Table of Contents\n",
+    "\n",
+    "- [Packages](#0)\n",
+    "- [1 - Translating Human Readable Dates Into Machine Readable Dates](#1)\n",
+    "    - [1.1 - Dataset](#1-1)\n",
+    "- [2 - Neural Machine Translation with Attention](#2)\n",
+    "    - [2.1 - Attention Mechanism](#2-1)\n",
+    "        - [Exercise 1 - one_step_attention](#ex-1)\n",
+    "        - [Exercise 2 - modelf](#ex-2)\n",
+    "        - [Exercise 3 - Compile the Model](#ex-3)\n",
+    "- [3 - Visualizing Attention (Optional / Ungraded)](#3)\n",
+    "    - [3.1 - Getting the Attention Weights From the Network](#3-1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name='0'></a>\n",
+    "## Packages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false,
+    "editable": false
+   },
+   "outputs": [],
+   "source": [
+    "### v3.1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 14508,
+     "status": "ok",
+     "timestamp": 1612468511651,
+     "user": {
+      "displayName": "Mubsi K",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
+      "userId": "08094225471505108399"
+     },
+     "user_tz": -300
+    },
+    "id": "RcBRMzPiiMmp",
+    "outputId": "17e9a429-5bb6-4401-a23a-f8f756d6113d"
+   },
+   "outputs": [],
+   "source": [
+    "from tensorflow.keras.layers import Bidirectional, Concatenate, Permute, Dot, Input, LSTM, Multiply\n",
+    "from tensorflow.keras.layers import RepeatVector, Dense, Activation, Lambda\n",
+    "from tensorflow.keras.optimizers import Adam\n",
+    "from tensorflow.keras.utils import to_categorical\n",
+    "from tensorflow.keras.models import load_model, Model\n",
+    "import tensorflow.keras.backend as K\n",
+    "import tensorflow as tf\n",
+    "import numpy as np\n",
+    "\n",
+    "from faker import Faker\n",
+    "import random\n",
+    "from tqdm import tqdm\n",
+    "from babel.dates import format_date\n",
+    "from nmt_utils import *\n",
+    "import matplotlib.pyplot as plt\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "J0pkH-k0h3Mf"
+   },
+   "source": [
+    "<a name='1'></a>\n",
+    "## 1 - Translating Human Readable Dates Into Machine Readable Dates\n",
+    "\n",
+    "* The model you will build here could be used to translate from one language to another, such as translating from English to Hindi. \n",
+    "* However, language translation requires massive datasets and usually takes days of training on GPUs. \n",
+    "* To give you a place to experiment with these models without using massive datasets, we will perform a simpler \"date translation\" task. \n",
+    "* The network will input a date written in a variety of possible formats (*e.g. \"the 29th of August 1958\", \"03/30/1968\", \"24 JUNE 1987\"*) \n",
+    "* The network will translate them into standardized, machine readable dates (*e.g. \"1958-08-29\", \"1968-03-30\", \"1987-06-24\"*). \n",
+    "* We will have the network learn to output dates in the common machine-readable format YYYY-MM-DD. \n",
+    "\n",
+    "<!-- \n",
+    "Take a look at [nmt_utils.py](./nmt_utils.py) to see all the formatting. Count and figure out how the formats work, you will need this knowledge later. !--> "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "8BhEaJvph3Mf"
+   },
+   "source": [
+    "<a name='1-1'></a>\n",
+    "### 1.1 - Dataset\n",
+    "\n",
+    "We will train the model on a dataset of 10,000 human readable dates and their equivalent, standardized, machine readable dates. Let's run the following cells to load the dataset and print some examples. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 16981,
+     "status": "ok",
+     "timestamp": 1612468514155,
+     "user": {
+      "displayName": "Mubsi K",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
+      "userId": "08094225471505108399"
+     },
+     "user_tz": -300
+    },
+    "id": "gwIf5l17h3Mg",
+    "outputId": "1fca5fb8-3a9b-4a78-f726-7aef8e14ee41"
+   },
+   "outputs": [],
+   "source": [
+    "m = 10000\n",
+    "dataset, human_vocab, machine_vocab, inv_machine_vocab = load_dataset(m)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 16972,
+     "status": "ok",
+     "timestamp": 1612468514156,
+     "user": {
+      "displayName": "Mubsi K",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
+      "userId": "08094225471505108399"
+     },
+     "user_tz": -300
+    },
+    "id": "zCTqMyPch3Mg",
+    "outputId": "42c9d8aa-d07b-4618-ab8a-4db4e1b971e2"
+   },
+   "outputs": [],
+   "source": [
+    "dataset[:10]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ao4Ffrkxh3Mg"
+   },
+   "source": [
+    "You've loaded:\n",
+    "- `dataset`: a list of tuples of (human readable date, machine readable date).\n",
+    "- `human_vocab`: a python dictionary mapping all characters used in the human readable dates to an integer-valued index.\n",
+    "- `machine_vocab`: a python dictionary mapping all characters used in machine readable dates to an integer-valued index. \n",
+    "    - **Note**: These indices are not necessarily consistent with `human_vocab`. \n",
+    "- `inv_machine_vocab`: the inverse dictionary of `machine_vocab`, mapping from indices back to characters. \n",
+    "\n",
+    "Let's preprocess the data and map the raw text data into the index values. \n",
+    "- We will set Tx=30 \n",
+    "    - We assume Tx is the maximum length of the human readable date.\n",
+    "    - If we get a longer input, we would have to truncate it.\n",
+    "- We will set Ty=10\n",
+    "    - \"YYYY-MM-DD\" is 10 characters long."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 16962,
+     "status": "ok",
+     "timestamp": 1612468514157,
+     "user": {
+      "displayName": "Mubsi K",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
+      "userId": "08094225471505108399"
+     },
+     "user_tz": -300
+    },
+    "id": "Qdso90EBh3Mg",
+    "outputId": "0a364ad8-8b25-4de3-f036-d5d8e40bdf8c"
+   },
+   "outputs": [],
+   "source": [
+    "Tx = 30\n",
+    "Ty = 10\n",
+    "X, Y, Xoh, Yoh = preprocess_data(dataset, human_vocab, machine_vocab, Tx, Ty)\n",
+    "\n",
+    "print(\"X.shape:\", X.shape)\n",
+    "print(\"Y.shape:\", Y.shape)\n",
+    "print(\"Xoh.shape:\", Xoh.shape)\n",
+    "print(\"Yoh.shape:\", Yoh.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "q9C0UY25h3Mh"
+   },
+   "source": [
+    "You now have:\n",
+    "- `X`: a processed version of the human readable dates in the training set.\n",
+    "    - Each character in X is replaced by an index (integer) mapped to the character using `human_vocab`. \n",
+    "    - Each date is padded to ensure a length of $T_x$ using a special character (< pad >). \n",
+    "    - `X.shape = (m, Tx)` where m is the number of training examples in a batch.\n",
+    "- `Y`: a processed version of the machine readable dates in the training set.\n",
+    "    - Each character is replaced by the index (integer) it is mapped to in `machine_vocab`. \n",
+    "    - `Y.shape = (m, Ty)`. \n",
+    "- `Xoh`: one-hot version of `X`\n",
+    "    - Each index in `X` is converted to the one-hot representation (if the index is 2, the one-hot version has the index position 2 set to 1, and the remaining positions are 0.\n",
+    "    - `Xoh.shape = (m, Tx, len(human_vocab))`\n",
+    "- `Yoh`: one-hot version of `Y`\n",
+    "    - Each index in `Y` is converted to the one-hot representation. \n",
+    "    - `Yoh.shape = (m, Ty, len(machine_vocab))`. \n",
+    "    - `len(machine_vocab) = 11` since there are 10 numeric digits (0 to 9) and the `-` symbol."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "N7qKvWrTh3Mh"
+   },
+   "source": [
+    "* Let's also look at some examples of preprocessed training examples. \n",
+    "* Feel free to play with `index` in the cell below to navigate the dataset and see how source/target dates are preprocessed. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 16952,
+     "status": "ok",
+     "timestamp": 1612468514158,
+     "user": {
+      "displayName": "Mubsi K",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
+      "userId": "08094225471505108399"
+     },
+     "user_tz": -300
+    },
+    "id": "kUOayR4gh3Mh",
+    "outputId": "d20994de-bbea-4cc7-ffaf-38a05974c9db"
+   },
+   "outputs": [],
+   "source": [
+    "index = 0\n",
+    "print(\"Source date:\", dataset[index][0])\n",
+    "print(\"Target date:\", dataset[index][1])\n",
+    "print()\n",
+    "print(\"Source after preprocessing (indices):\", X[index])\n",
+    "print(\"Target after preprocessing (indices):\", Y[index])\n",
+    "print()\n",
+    "print(\"Source after preprocessing (one-hot):\", Xoh[index])\n",
+    "print(\"Target after preprocessing (one-hot):\", Yoh[index])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "94o4RYbOh3Mi"
+   },
+   "source": [
+    "<a name='2'></a>\n",
+    "## 2 - Neural Machine Translation with Attention\n",
+    "\n",
+    "* If you had to translate a book's paragraph from French to English, you would not read the whole paragraph, then close the book and translate. \n",
+    "* Even during the translation process, you would read/re-read and focus on the parts of the French paragraph corresponding to the parts of the English you are writing down. \n",
+    "* The attention mechanism tells a Neural Machine Translation model where it should pay attention to at any step. \n",
+    "\n",
+    "<a name='2-1'></a>\n",
+    "### 2.1 - Attention Mechanism\n",
+    "\n",
+    "In this part, you will implement the attention mechanism presented in the lecture videos. \n",
+    "* Here is a figure to remind you how the model works. \n",
+    "    * The diagram on the left shows the attention model. \n",
+    "    * The diagram on the right shows what one \"attention\" step does to calculate the attention variables $\\alpha^{\\langle t, t' \\rangle}$.\n",
+    "    * The attention variables $\\alpha^{\\langle t, t' \\rangle}$ are used to compute the context variable $context^{\\langle t \\rangle}$ for each timestep in the output ($t=1, \\ldots, T_y$). \n",
+    "\n",
+    "<table>\n",
+    "<td> \n",
+    "<img src=\"images/attn_model.png\" style=\"width:500;height:500px;\"> <br>\n",
+    "</td> \n",
+    "<td> \n",
+    "<img src=\"images/attn_mechanism.png\" style=\"width:500;height:500px;\"> <br>\n",
+    "</td> \n",
+    "</table>\n",
+    "<caption><center> **Figure 1**: Neural machine translation with attention</center></caption>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "b2TkQnykh3Mi"
+   },
+   "source": [
+    "Here are some properties of the model that you may notice: \n",
+    "\n",
+    "#### Pre-attention and Post-attention LSTMs on both sides of the attention mechanism\n",
+    "- There are two separate LSTMs in this model (see diagram on the left): pre-attention and post-attention LSTMs.\n",
+    "- *Pre-attention* Bi-LSTM is the one at the bottom of the picture is a Bi-directional LSTM and comes *before* the attention mechanism.\n",
+    "    - The attention mechanism is shown in the middle of the left-hand diagram.\n",
+    "    - The pre-attention Bi-LSTM goes through $T_x$ time steps\n",
+    "- *Post-attention* LSTM: at the top of the diagram comes *after* the attention mechanism. \n",
+    "    - The post-attention LSTM goes through $T_y$ time steps. \n",
+    "\n",
+    "- The post-attention LSTM passes the hidden state $s^{\\langle t \\rangle}$ and cell state $c^{\\langle t \\rangle}$ from one time step to the next. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "JpznWuWqh3Mi"
+   },
+   "source": [
+    "#### An LSTM has both a hidden state and cell state\n",
+    "* In the lecture videos, we were using only a basic RNN for the post-attention sequence model\n",
+    "    * This means that the state captured by the RNN was outputting only the hidden state $s^{\\langle t\\rangle}$. \n",
+    "* In this assignment, we are using an LSTM instead of a basic RNN.\n",
+    "    * So the LSTM has both the hidden state $s^{\\langle t\\rangle}$ and the cell state $c^{\\langle t\\rangle}$. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "85btUzl4h3Mj"
+   },
+   "source": [
+    "#### Each time step does not use predictions from the previous time step\n",
+    "* Unlike previous text generation examples earlier in the course, in this model, the post-attention LSTM at time $t$ does not take the previous time step's prediction $y^{\\langle t-1 \\rangle}$ as input.\n",
+    "* The post-attention LSTM at time 't' only takes the hidden state $s^{\\langle t\\rangle}$ and cell state $c^{\\langle t\\rangle}$ as input. \n",
+    "* We have designed the model this way because unlike language generation (where adjacent characters are highly correlated) there isn't as strong a dependency between the previous character and the next character in a YYYY-MM-DD date."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NYT3v7rUh3Mk"
+   },
+   "source": [
+    "#### Concatenation of hidden states from the forward and backward pre-attention LSTMs\n",
+    "- $\\overrightarrow{a}^{\\langle t \\rangle}$: hidden state of the forward-direction, pre-attention LSTM.\n",
+    "- $\\overleftarrow{a}^{\\langle t \\rangle}$: hidden state of the backward-direction, pre-attention LSTM.\n",
+    "- $a^{\\langle t \\rangle} = [\\overrightarrow{a}^{\\langle t \\rangle}, \\overleftarrow{a}^{\\langle t \\rangle}]$: the concatenation of the activations of both the forward-direction $\\overrightarrow{a}^{\\langle t \\rangle}$ and backward-directions $\\overleftarrow{a}^{\\langle t \\rangle}$ of the pre-attention Bi-LSTM. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "97GUKCqwh3Mk"
+   },
+   "source": [
+    "#### Computing \"energies\" $e^{\\langle t, t' \\rangle}$ as a function of $s^{\\langle t-1 \\rangle}$ and $a^{\\langle t' \\rangle}$\n",
+    "- Recall in the lesson videos \"Attention Model\", at time 6:45 to 8:16, the definition of \"e\" as a function of $s^{\\langle t-1 \\rangle}$ and $a^{\\langle t \\rangle}$.\n",
+    "    - \"e\" is called the \"energies\" variable.\n",
+    "    - $s^{\\langle t-1 \\rangle}$ is the hidden state of the post-attention LSTM\n",
+    "    - $a^{\\langle t' \\rangle}$ is the hidden state of the pre-attention LSTM.\n",
+    "    - $s^{\\langle t-1 \\rangle}$ and $a^{\\langle t \\rangle}$ are fed into a simple neural network, which learns the function to output $e^{\\langle t, t' \\rangle}$.\n",
+    "    - $e^{\\langle t, t' \\rangle}$ is then used when computing the attention $\\alpha^{\\langle t, t' \\rangle}$ that $y^{\\langle t \\rangle}$ should pay to $a^{\\langle t' \\rangle}$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "scu_HnPNh3Mk"
+   },
+   "source": [
+    "- The diagram on the right of figure 1 uses a `RepeatVector` node to copy $s^{\\langle t-1 \\rangle}$'s value $T_x$ times.\n",
+    "- Then it uses `Concatenation` to concatenate $s^{\\langle t-1 \\rangle}$ and $a^{\\langle t \\rangle}$.\n",
+    "- The concatenation of $s^{\\langle t-1 \\rangle}$ and $a^{\\langle t \\rangle}$ is fed into a \"Dense\" layer, which computes $e^{\\langle t, t' \\rangle}$. \n",
+    "- $e^{\\langle t, t' \\rangle}$ is then passed through a softmax to compute $\\alpha^{\\langle t, t' \\rangle}$.\n",
+    "- Note that the diagram doesn't explicitly show variable $e^{\\langle t, t' \\rangle}$, but $e^{\\langle t, t' \\rangle}$ is above the Dense layer and below the Softmax layer in the diagram in the right half of figure 1.\n",
+    "- We'll explain how to use `RepeatVector` and `Concatenation` in Keras below. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_ukmqe_Yh3Ml"
+   },
+   "source": [
+    "#### Implementation Details\n",
+    "   \n",
+    "Let's implement this neural translator. You will start by implementing two functions: `one_step_attention()` and `model()`.\n",
+    "\n",
+    "#### one_step_attention\n",
+    "* The inputs to the one_step_attention at time step $t$ are:\n",
+    "    - $[a^{<1>},a^{<2>}, ..., a^{<T_x>}]$: all hidden states of the pre-attention Bi-LSTM.\n",
+    "    - $s^{<t-1>}$: the previous hidden state of the post-attention LSTM \n",
+    "* one_step_attention computes:\n",
+    "    - $[\\alpha^{<t,1>},\\alpha^{<t,2>}, ..., \\alpha^{<t,T_x>}]$: the attention weights\n",
+    "    - $context^{ \\langle t \\rangle }$: the context vector:\n",
+    "    \n",
+    "$$context^{<t>} = \\sum_{t' = 1}^{T_x} \\alpha^{<t,t'>}a^{<t'>}\\tag{1}$$ \n",
+    "\n",
+    "##### Clarifying 'context' and 'c'\n",
+    "- In the lecture videos, the context was denoted $c^{\\langle t \\rangle}$\n",
+    "- In the assignment, we are calling the context $context^{\\langle t \\rangle}$.\n",
+    "    - This is to avoid confusion with the post-attention LSTM's internal memory cell variable, which is also denoted $c^{\\langle t \\rangle}$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "LIfLKkwoh3Ml"
+   },
+   "source": [
+    "<a name='ex-1'></a>\n",
+    "### Exercise 1 - one_step_attention \n",
+    "\n",
+    "Implement `one_step_attention()`. \n",
+    "\n",
+    "* The function `model()` will call the layers in `one_step_attention()` $T_y$ times using a for-loop.\n",
+    "* It is important that all $T_y$ copies have the same weights. \n",
+    "    * It should not reinitialize the weights every time. \n",
+    "    * In other words, all $T_y$ steps should have shared weights. \n",
+    "* Here's how you can implement layers with shareable weights in Keras:\n",
+    "    1. Define the layer objects in a variable scope that is outside of the `one_step_attention` function.  For example, defining the objects as global variables would work.\n",
+    "        - Note that defining these variables inside the scope of the function `model` would technically work, since `model` will then call the `one_step_attention` function.  For the purposes of making grading and troubleshooting easier, we are defining these as global variables.  Note that the automatic grader will expect these to be global variables as well.\n",
+    "    2. Call these objects when propagating the input.\n",
+    "* We have defined the layers you need as global variables. \n",
+    "    * Please run the following cells to create them. \n",
+    "    * Please note that the automatic grader expects these global variables with the given variable names.  For grading purposes, please do not rename the global variables.\n",
+    "* Please check the Keras documentation to learn more about these layers.  The layers are functions.  Below are examples of how to call these functions.\n",
+    "    * [RepeatVector()](https://www.tensorflow.org/api_docs/python/tf/keras/layers/RepeatVector)\n",
+    "```Python\n",
+    "var_repeated = repeat_layer(var1)\n",
+    "```\n",
+    "    * [Concatenate()](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Concatenate)   \n",
+    "```Python\n",
+    "concatenated_vars = concatenate_layer([var1,var2,var3])\n",
+    "```\n",
+    "    * [Dense()](https://keras.io/layers/core/#dense)  \n",
+    "```Python\n",
+    "var_out = dense_layer(var_in)\n",
+    "```\n",
+    "    * [Activation()](https://keras.io/layers/core/#activation)  \n",
+    "```Python\n",
+    "activation = activation_layer(var_in)  \n",
+    "```\n",
+    "    * [Dot()](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dot)  \n",
+    "```Python\n",
+    "dot_product = dot_layer([var1,var2])\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false,
+    "editable": false
+   },
+   "outputs": [],
+   "source": [
+    "# You cannot edit this cell\n",
+    "\n",
+    "# Defined shared layers as global variables\n",
+    "repeator = RepeatVector(Tx)\n",
+    "concatenator = Concatenate(axis=-1)\n",
+    "densor1 = Dense(10, activation = \"tanh\")\n",
+    "densor2 = Dense(1, activation = \"relu\")\n",
+    "activator = Activation(softmax, name='attention_weights') # We are using a custom softmax(axis = 1) loaded in this notebook\n",
+    "dotor = Dot(axes = 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 16950,
+     "status": "ok",
+     "timestamp": 1612468514159,
+     "user": {
+      "displayName": "Mubsi K",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
+      "userId": "08094225471505108399"
+     },
+     "user_tz": -300
+    },
+    "id": "mZuMOnTDh3Mn"
+   },
+   "outputs": [],
+   "source": [
+    "# UNQ_C1 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
+    "# GRADED FUNCTION: one_step_attention\n",
+    "\n",
+    "def one_step_attention(a, s_prev):\n",
+    "    \"\"\"\n",
+    "    Performs one step of attention: Outputs a context vector computed as a dot product of the attention weights\n",
+    "    \"alphas\" and the hidden states \"a\" of the Bi-LSTM.\n",
+    "    \n",
+    "    Arguments:\n",
+    "    a -- hidden state output of the Bi-LSTM, numpy-array of shape (m, Tx, 2*n_a)\n",
+    "    s_prev -- previous hidden state of the (post-attention) LSTM, numpy-array of shape (m, n_s)\n",
+    "    \n",
+    "    Returns:\n",
+    "    context -- context vector, input of the next (post-attention) LSTM cell\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    ### START CODE HERE ###\n",
+    "    # Use repeator to repeat s_prev to be of shape (m, Tx, n_s) so that you can concatenate it with all hidden states \"a\" (≈ 1 line)\n",
+    "    s_prev = None\n",
+    "    # Use concatenator to concatenate a and s_prev on the last axis (≈ 1 line)\n",
+    "    # For grading purposes, please list 'a' first and 's_prev' second, in this order.\n",
+    "    concat = None\n",
+    "    # Use densor1 to propagate concat through a small fully-connected neural network to compute the \"intermediate energies\" variable e. (≈1 lines)\n",
+    "    e = None\n",
+    "    # Use densor2 to propagate e through a small fully-connected neural network to compute the \"energies\" variable energies. (≈1 lines)\n",
+    "    energies = None\n",
+    "    # Use \"activator\" on \"energies\" to compute the attention weights \"alphas\" (≈ 1 line)\n",
+    "    alphas = None\n",
+    "    # Use dotor together with \"alphas\" and \"a\", in this order, to compute the context vector to be given to the next (post-attention) LSTM-cell (≈ 1 line)\n",
+    "    context = None\n",
+    "    ### END CODE HERE ###\n",
+    "    \n",
+    "    return context"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false,
+    "editable": false
+   },
+   "outputs": [],
+   "source": [
+    "### You cannot edit this cell\n",
+    "\n",
+    "# UNIT TEST\n",
+    "def one_step_attention_test(target):\n",
+    "    np.random.seed(10)\n",
+    "    tf.random.set_seed(10)\n",
+    "\n",
+    "    m = 10\n",
+    "    Tx = 30\n",
+    "    n_a = 32\n",
+    "    n_s = 64\n",
+    "    \n",
+    "    a = np.random.uniform(1, 0, (m, Tx, 2 * n_a)).astype(np.float32)\n",
+    "    s_prev =np.random.uniform(1, 0, (m, n_s)).astype(np.float32) * 1\n",
+    "    context = target(a, s_prev)\n",
+    "    \n",
+    "    expected_output = np.load('expected_output_ex1.npy')\n",
+    "    \n",
+    "    assert type(context) == tf.python.framework.ops.EagerTensor, \"Unexpected type. It should be a Tensor\"\n",
+    "    assert tuple(context.shape) == (m, 1, n_s), \"Unexpected output shape\"\n",
+    "    assert np.all(context.numpy() == expected_output), \"Unexpected values in the result\"\n",
+    "    \n",
+    "    print(\"\\033[92mAll tests passed!\")\n",
+    "    \n",
+    "one_step_attention_test(one_step_attention)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vcmC3WcQh3Mn"
+   },
+   "source": [
+    "<a name='ex-2'></a>\n",
+    "### Exercise 2 - modelf\n",
+    "\n",
+    "Implement `modelf()` as explained in figure 1 and the instructions:\n",
+    "\n",
+    "* `modelf` first runs the input through a Bi-LSTM to get $[a^{<1>},a^{<2>}, ..., a^{<T_x>}]$. \n",
+    "* Then, `modelf` calls `one_step_attention()` $T_y$ times using a `for` loop.  At each iteration of this loop:\n",
+    "    - It gives the computed context vector $context^{<t>}$ to the post-attention LSTM.\n",
+    "    - It runs the output of the post-attention LSTM through a dense layer with softmax activation.\n",
+    "    - The softmax generates a prediction $\\hat{y}^{<t>}$.\n",
+    "    \n",
+    "Again, we have defined global layers that will share weights to be used in `modelf()`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deletable": false,
+    "editable": false
+   },
+   "outputs": [],
+   "source": [
+    "### You cannot edit this cell\n",
+    "\n",
+    "n_a = 32 # number of units for the pre-attention, bi-directional LSTM's hidden state 'a'\n",
+    "n_s = 64 # number of units for the post-attention LSTM's hidden state \"s\"\n",
+    "\n",
+    "# Please note, this is the post attention LSTM cell.  \n",
+    "post_activation_LSTM_cell = LSTM(n_s, return_state = True) # Please do not modify this global variable.\n",
+    "output_layer = Dense(len(machine_vocab), activation=softmax)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "lGkKpb1Nh3Mo"
+   },
+   "source": [
+    "Now you can use these layers $T_y$ times in a `for` loop to generate the outputs, and their parameters will not be reinitialized. You will have to carry out the following steps: \n",
+    "\n",
+    "1. Propagate the input `X` into a bi-directional LSTM.\n",
+    "    * [Bidirectional](https://keras.io/layers/wrappers/#bidirectional) \n",
+    "    * [LSTM](https://keras.io/layers/recurrent/#lstm)\n",
+    "    * Remember that we want the LSTM to return a full sequence instead of just the last hidden state.  \n",
+    "    \n",
+    "Sample code:\n",
+    "\n",
+    "```Python\n",
+    "sequence_of_hidden_states = Bidirectional(LSTM(units=..., return_sequences=...))(the_input_X)\n",
+    "```\n",
+    "    \n",
+    "2. Iterate for $t = 0, \\cdots, T_y-1$: \n",
+    "    1. Call `one_step_attention()`, passing in the sequence of hidden states $[a^{\\langle 1 \\rangle},a^{\\langle 2 \\rangle}, ..., a^{ \\langle T_x \\rangle}]$ from the pre-attention bi-directional LSTM, and the previous hidden state $s^{<t-1>}$ from the post-attention LSTM to calculate the context vector $context^{<t>}$.\n",
+    "    2. Give $context^{<t>}$ to the post-attention LSTM cell. \n",
+    "        - Remember to pass in the previous hidden-state $s^{\\langle t-1\\rangle}$ and cell-states $c^{\\langle t-1\\rangle}$ of this LSTM \n",
+    "        * This outputs the new hidden state $s^{<t>}$ and the new cell state $c^{<t>}$.  \n",
+    "\n",
+    "        Sample code:\n",
+    "        ```Python\n",
+    "        _, next_hidden_state, next_cell_state = \n",
+    "            post_activation_LSTM_cell(inputs=..., initial_state=[prev_hidden_state, prev_cell_state])\n",
+    "        ```   \n",
+    "        Please note that the layer is actually the \"post attention LSTM cell\".  For the purposes of passing the automatic grader, please do not modify the naming of this global variable.  This will be fixed when we deploy updates to the automatic grader.\n",
+    "    3. Apply a dense, softmax layer to $s^{<t>}$, get the output.  \n",
+    "        Sample code:\n",
+    "        ```Python\n",
+    "        output = output_layer(inputs=...)\n",
+    "        ```\n",
+    "    4. Save the output by adding it to the list of outputs.\n",
+    "\n",
+    "3. Create your Keras model instance.\n",
+    "    * It should have three inputs:\n",
+    "        * `X`, the one-hot encoded inputs to the model, of shape ($T_{x}, humanVocabSize)$\n",
+    "        * $s^{\\langle 0 \\rangle}$, the initial hidden state of the post-attention LSTM\n",
+    "        * $c^{\\langle 0 \\rangle}$, the initial cell state of the post-attention LSTM\n",
+    "    * The output is the list of outputs.  \n",
+    "    Sample code\n",
+    "    ```Python\n",
+    "    model = Model(inputs=[...,...,...], outputs=...)\n",
+    "    ```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 16948,
+     "status": "ok",
+     "timestamp": 1612468514160,
+     "user": {
+      "displayName": "Mubsi K",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
+      "userId": "08094225471505108399"
+     },
+     "user_tz": -300
+    },
+    "id": "qeKbeDOvh3Mo"
+   },
+   "outputs": [],
+   "source": [
+    "# UNQ_C2 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
+    "# GRADED FUNCTION: model\n",
+    "\n",
+    "def modelf(Tx, Ty, n_a, n_s, human_vocab_size, machine_vocab_size=None):\n",
+    "    \"\"\"\n",
+    "    Arguments:\n",
+    "    Tx -- length of the input sequence\n",
+    "    Ty -- length of the output sequence\n",
+    "    n_a -- hidden state size of the Bi-LSTM\n",
+    "    n_s -- hidden state size of the post-attention LSTM\n",
+    "    human_vocab_size -- size of the python dictionary \"human_vocab\"\n",
+    "    machine_vocab_size -- integer, optional, size of the python dictionary \"machine_vocab\"\n",
+    "                          This is not being used\n",
+    "\n",
+    "    Returns:\n",
+    "    model -- Keras model instance\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # Define the inputs of your model with a shape (Tx, human_vocab_size)\n",
+    "    # Define s0 (initial hidden state) and c0 (initial cell state)\n",
+    "    # for the decoder LSTM with shape (n_s,)\n",
+    "    X = Input(shape=(Tx, human_vocab_size))\n",
+    "    # initial hidden state\n",
+    "    s0 = Input(shape=(n_s,), name='s0')\n",
+    "    # initial cell state\n",
+    "    c0 = Input(shape=(n_s,), name='c0')\n",
+    "    # hidden state\n",
+    "    s = s0\n",
+    "    # cell state\n",
+    "    c = c0\n",
+    "    \n",
+    "    # Initialize empty list of outputs\n",
+    "    outputs = []\n",
+    "    \n",
+    "    ### START CODE HERE ###\n",
+    "    \n",
+    "    # Step 1: Define your pre-attention Bi-LSTM. (≈ 1 line)\n",
+    "    a = None\n",
+    "    \n",
+    "    # Step 2: Iterate for Ty steps\n",
+    "    for t in range(None):\n",
+    "    \n",
+    "        # Step 2.A: Perform one step of the attention mechanism to get back the context vector at step t (≈ 1 line)\n",
+    "        context = None\n",
+    "        \n",
+    "        # Step 2.B: Apply the post-attention LSTM cell to the \"context\" vector. (≈ 1 line)\n",
+    "        # Don't forget to pass: initial_state = [hidden state, cell state] \n",
+    "        # Remember: s = hidden state, c = cell state\n",
+    "        _, s, c = None\n",
+    "        \n",
+    "        # Step 2.C: Apply Dense layer to the hidden state output of the post-attention LSTM (≈ 1 line)\n",
+    "        out = None\n",
+    "        \n",
+    "        # Step 2.D: Append \"out\" to the \"outputs\" list (≈ 1 line)\n",
+    "        None\n",
+    "    \n",
+    "    # Step 3: Create model instance taking three inputs and returning the list of outputs. (≈ 1 line)\n",
+    "    model = None\n",
+    "    \n",
+    "    ### END CODE HERE ###\n",
+    "    \n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deleteable": false,
+    "editable": false
+   },
+   "outputs": [],
+   "source": [
+    "### You cannot edit this cell\n",
+    "\n",
+    "# UNIT TEST 1\n",
+    "from test_utils import *\n",
+    "\n",
+    "def modelf_test(target):\n",
+    "    Tx = 30\n",
+    "    n_a = 32\n",
+    "    n_s = 64\n",
+    "    len_human_vocab = 37\n",
+    "    \n",
+    "    \n",
+    "    model = target(Tx, Ty, n_a, n_s, len_human_vocab)\n",
+    "    \n",
+    "    print(summary(model))\n",
+    "\n",
+    "    \n",
+    "    expected_summary = [['InputLayer', [(None, 30, 37)], 0],\n",
+    "                         ['InputLayer', [(None, 64)], 0],\n",
+    "                         ['Bidirectional', (None, 30, 64), 17920],\n",
+    "                         ['RepeatVector', (None, 30, 64), 0, 30],\n",
+    "                         ['Concatenate', (None, 30, 128), 0],\n",
+    "                         ['Dense', (None, 30, 10), 1290, 'tanh'],\n",
+    "                         ['Dense', (None, 30, 1), 11, 'relu'],\n",
+    "                         ['Activation', (None, 30, 1), 0],\n",
+    "                         ['Dot', (None, 1, 64), 0],\n",
+    "                         ['InputLayer', [(None, 64)], 0],\n",
+    "                         ['LSTM',[(None, 64), (None, 64), (None, 64)], 33024,[(None, 1, 64), (None, 64), (None, 64)],'tanh'],\n",
+    "                         ['Dense', (None, 11), 715, 'softmax']]\n",
+    "\n",
+    "    assert len(model.outputs) == 10, f\"Wrong output shape. Expected 10 != {len(model.outputs)}\"\n",
+    "\n",
+    "    comparator(summary(model), expected_summary)\n",
+    "    \n",
+    "\n",
+    "modelf_test(modelf)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Run the test in the next cell to check if your `modelf` function is correctly updating the (next) `hidden state` and `cell state`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deleteable": false,
+    "editable": false
+   },
+   "outputs": [],
+   "source": [
+    "### You cannot edit this cell\n",
+    "\n",
+    "# UNIT TEST 2\n",
+    "\n",
+    "def modelf_states_test(target):\n",
+    "    Tx = 30\n",
+    "    n_a = 32\n",
+    "    n_s = 64\n",
+    "    len_human_vocab = 37\n",
+    "\n",
+    "    model = target(Tx, Ty, n_a, n_s, len_human_vocab)\n",
+    "\n",
+    "    # Create test inputs\n",
+    "    X_test = np.random.rand(1, Tx, len_human_vocab)\n",
+    "    s0_test = np.zeros((1, n_s))\n",
+    "    c0_test = np.zeros((1, n_s))\n",
+    "\n",
+    "    @tf.function(input_signature=[\n",
+    "        tf.TensorSpec(shape=[None, Tx, len_human_vocab], dtype=tf.float32),\n",
+    "        tf.TensorSpec(shape=[None, n_s], dtype=tf.float32),\n",
+    "        tf.TensorSpec(shape=[None, n_s], dtype=tf.float32)\n",
+    "    ])\n",
+    "    def predict_function(X, s0, c0):\n",
+    "        # Call the model directly with input tensors\n",
+    "        return model([X, s0, c0])  \n",
+    "\n",
+    "    # Get the outputs of the model for the first five time steps\n",
+    "    outputs = predict_function(X_test, s0_test, c0_test)\n",
+    "\n",
+    "    # Extract the hidden states (s) from the LSTM outputs for each time step\n",
+    "    hidden_states = [np.array(output) for output in outputs]\n",
+    "\n",
+    "    # Check if consecutive hidden states are different\n",
+    "    for i in range(len(hidden_states) - 1):\n",
+    "        assert not np.allclose(hidden_states[i], hidden_states[i + 1]), (\n",
+    "            \"Consecutive hidden states should be different.\\n\"\n",
+    "            \"Check if the LSTM cell is using the correct previous states.\\n\"\n",
+    "            \"Make sure you are using s and c, and NOT using s0 and c0 in Step 2.B.\"\n",
+    "        )\n",
+    "\n",
+    "    print(\"\\033[32mAll tests passed!\\033[0m\")\n",
+    "\n",
+    "modelf_states_test(modelf)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "--RX7hSsh3Mo"
+   },
+   "source": [
+    "Run the following cell to create your model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deleteable": false,
+    "editable": false
+   },
+   "outputs": [],
+   "source": [
+    "## You cannot edit this cell\n",
+    "model = modelf(Tx, Ty, n_a, n_s, len(human_vocab))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "nUJw7Xohh3Mp"
+   },
+   "source": [
+    "#### Troubleshooting Note\n",
+    "* If you are getting repeated errors after an initially incorrect implementation of \"model\", but believe that you have corrected the error, you may still see error messages when building your model.  \n",
+    "* A solution is to save and restart your kernel (or shutdown then restart your notebook), and re-run the cells."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "VgeU_I9_h3Mp"
+   },
+   "source": [
+    "Let's get a summary of the model to check if it matches the expected output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 20835,
+     "status": "ok",
+     "timestamp": 1612468518050,
+     "user": {
+      "displayName": "Mubsi K",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
+      "userId": "08094225471505108399"
+     },
+     "user_tz": -300
+    },
+    "id": "tX0vaYmPh3Mq",
+    "outputId": "336b9248-70b0-4379-be95-95366874c02a"
+   },
+   "outputs": [],
+   "source": [
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uiqCePt5h3Mr"
+   },
+   "source": [
+    "**Expected Output**:\n",
+    "\n",
+    "Here is the summary you should see\n",
+    "<table>\n",
+    "    <tr>\n",
+    "        <td>\n",
+    "            **Total params:**\n",
+    "        </td>\n",
+    "        <td>\n",
+    "         52,960\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "        <tr>\n",
+    "        <td>\n",
+    "            **Trainable params:**\n",
+    "        </td>\n",
+    "        <td>\n",
+    "         52,960\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "            <tr>\n",
+    "        <td>\n",
+    "            **Non-trainable params:**\n",
+    "        </td>\n",
+    "        <td>\n",
+    "         0\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "                    <tr>\n",
+    "        <td>\n",
+    "            **bidirectional_1's output shape **\n",
+    "        </td>\n",
+    "        <td>\n",
+    "         (None, 30, 64)  \n",
+    "        </td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "        <td>\n",
+    "            **repeat_vector_1's output shape **\n",
+    "        </td>\n",
+    "        <td>\n",
+    "         (None, 30, 64) \n",
+    "        </td>\n",
+    "    </tr>\n",
+    "                <tr>\n",
+    "        <td>\n",
+    "            **concatenate_1's output shape **\n",
+    "        </td>\n",
+    "        <td>\n",
+    "         (None, 30, 128) \n",
+    "        </td>\n",
+    "    </tr>\n",
+    "            <tr>\n",
+    "        <td>\n",
+    "            **attention_weights's output shape **\n",
+    "        </td>\n",
+    "        <td>\n",
+    "         (None, 30, 1)  \n",
+    "        </td>\n",
+    "    </tr>\n",
+    "        <tr>\n",
+    "        <td>\n",
+    "            **dot_1's output shape **\n",
+    "        </td>\n",
+    "        <td>\n",
+    "         (None, 1, 64)\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "           <tr>\n",
+    "        <td>\n",
+    "            **dense_3's output shape **\n",
+    "        </td>\n",
+    "        <td>\n",
+    "         (None, 11) \n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "8u3D9Odhh3Ms"
+   },
+   "source": [
+    "<a name='ex-3'></a>\n",
+    "### Exercise 3 - Compile the Model\n",
+    "\n",
+    "* After creating your model in Keras, you need to compile it and define the loss function, optimizer and metrics you want to use. \n",
+    "    * Loss function: 'categorical_crossentropy'.\n",
+    "    * Optimizer: [Adam](https://keras.io/optimizers/#adam) [optimizer](https://keras.io/optimizers/#usage-of-optimizers)\n",
+    "        - learning rate = 0.005 \n",
+    "        - $\\beta_1 = 0.9$\n",
+    "        - $\\beta_2 = 0.999$\n",
+    "        - decay = 0.01  \n",
+    "    * metric: 'accuracy'\n",
+    "    \n",
+    "Sample code\n",
+    "```Python\n",
+    "optimizer = Adam(lr=..., beta_1=..., beta_2=..., decay=...)\n",
+    "model.compile(optimizer=..., loss=..., metrics=[...])\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 20835,
+     "status": "ok",
+     "timestamp": 1612468518051,
+     "user": {
+      "displayName": "Mubsi K",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
+      "userId": "08094225471505108399"
+     },
+     "user_tz": -300
+    },
+    "id": "sBFRJ49rh3Ms"
+   },
+   "outputs": [],
+   "source": [
+    "### START CODE HERE ### (≈2 lines)\n",
+    "opt = None # Adam(...) \n",
+    "model.compile(loss = None, optimizer = None, metrics = None)\n",
+    "### END CODE HERE ###"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deleteable": false,
+    "editable": false
+   },
+   "outputs": [],
+   "source": [
+    "### You cannot edit this cell\n",
+    "\n",
+    "# UNIT TESTS\n",
+    "assert opt.lr == 0.005, \"Set the lr parameter to 0.005\"\n",
+    "assert opt.beta_1 == 0.9, \"Set the beta_1 parameter to 0.9\"\n",
+    "assert opt.beta_2 == 0.999, \"Set the beta_2 parameter to 0.999\"\n",
+    "assert opt.decay == 0.01, \"Set the decay parameter to 0.01\"\n",
+    "assert model.loss == \"categorical_crossentropy\", \"Wrong loss. Use 'categorical_crossentropy'\"\n",
+    "assert model.optimizer == opt, \"Use the optimizer that you have instantiated\"\n",
+    "assert model.compiled_metrics._user_metrics[0] == 'accuracy', \"set metrics to ['accuracy']\"\n",
+    "\n",
+    "print(\"\\033[92mAll tests passed!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Qz71nM3oh3Ms"
+   },
+   "source": [
+    "#### Define inputs and outputs, and fit the model\n",
+    "The last step is to define all your inputs and outputs to fit the model:\n",
+    "- You have input `Xoh` of shape $(m = 10000, T_x = 30, human\\_vocab=37)$ containing the training examples.\n",
+    "- You need to create `s0` and `c0` to initialize your `post_attention_LSTM_cell` with zeros.\n",
+    "- Given the `model()` you coded, you need the \"outputs\" to be a list of 10 elements of shape (m, T_y). \n",
+    "    - The list `outputs[i][0], ..., outputs[i][Ty]` represents the true labels (characters) corresponding to the $i^{th}$ training example (`Xoh[i]`). \n",
+    "    - `outputs[i][j]` is the true label of the $j^{th}$ character in the $i^{th}$ training example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deleteable": false,
+    "editable": false
+   },
+   "outputs": [],
+   "source": [
+    "### You cannot edit this cell\n",
+    "s0 = np.zeros((m, n_s))\n",
+    "c0 = np.zeros((m, n_s))\n",
+    "outputs = list(Yoh.swapaxes(0,1))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FVkITGi3h3Mt"
+   },
+   "source": [
+    "Let's now fit the model and run it for one epoch."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deleteable": false,
+    "editable": false
+   },
+   "outputs": [],
+   "source": [
+    "### You cannot edit this cell\n",
+    "model.fit([Xoh, s0, c0], outputs, epochs=1, batch_size=100)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "SUikskCoh3Mt"
+   },
+   "source": [
+    "While training you can see the loss as well as the accuracy on each of the 10 positions of the output. The table below gives you an example of what the accuracies could be if the batch had 2 examples: \n",
+    "\n",
+    "<img src=\"images/table.png\" style=\"width:700;height:200px;\"> <br>\n",
+    "<caption><center>Thus, <mark> dense_2_8_accuracy: 0.89 </mark> means that you are predicting the 9th character of the output correctly 89% of the time in the current batch of data. </center></caption>\n",
+    "\n",
+    "\n",
+    "We have run this model for longer, and saved the weights. Run the next cell to load our weights. (By training a model for several minutes, you should be able to obtain a model of similar accuracy, but loading our model will save you time.) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deleteable": false,
+    "editable": false
+   },
+   "outputs": [],
+   "source": [
+    "### You cannot edit this cell\n",
+    "model.load_weights('models/model.h5')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "yUUD9yXxh3Mu"
+   },
+   "source": [
+    "You can now see the results on new examples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "deleteable": false,
+    "editable": false
+   },
+   "outputs": [],
+   "source": [
+    "### You cannot edit this cell\n",
+    "\n",
+    "EXAMPLES = ['3 May 1979', '5 April 09', '21th of August 2016', 'Tue 10 Jul 2007', 'Saturday May 9 2018', 'March 3 2001', 'March 3rd 2001', '1 March 2001']\n",
+    "s00 = np.zeros((1, n_s))\n",
+    "c00 = np.zeros((1, n_s))\n",
+    "for example in EXAMPLES:\n",
+    "    source = string_to_int(example, Tx, human_vocab)\n",
+    "    #print(source)\n",
+    "    source = np.array(list(map(lambda x: to_categorical(x, num_classes=len(human_vocab)), source))).swapaxes(0,1)\n",
+    "    source = np.swapaxes(source, 0, 1)\n",
+    "    source = np.expand_dims(source, axis=0)\n",
+    "    prediction = model.predict([source, s00, c00])\n",
+    "    prediction = np.argmax(prediction, axis = -1)\n",
+    "    output = [inv_machine_vocab[int(i)] for i in prediction]\n",
+    "    print(\"source:\", example)\n",
+    "    print(\"output:\", ''.join(output),\"\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vjdEQiIDh3Mv"
+   },
+   "source": [
+    "You can also change these examples to test with your own examples. The next part will give you a better sense of what the attention mechanism is doing--i.e., what part of the input the network is paying attention to when generating a particular output character. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1XIxtN4xh3Mv"
+   },
+   "source": [
+    "<a name='3'></a>\n",
+    "## 3 - Visualizing Attention (Optional / Ungraded)\n",
+    "\n",
+    "Since the problem has a fixed output length of 10, it is also possible to carry out this task using 10 different softmax units to generate the 10 characters of the output. But one advantage of the attention model is that each part of the output (such as the month) knows it needs to depend only on a small part of the input (the characters in the input giving the month). We can  visualize what each part of the output is looking at which part of the input.\n",
+    "\n",
+    "Consider the task of translating \"Saturday 9 May 2018\" to \"2018-05-09\". If we visualize the computed $\\alpha^{\\langle t, t' \\rangle}$ we get this: \n",
+    "\n",
+    "<img src=\"images/date_attention.png\" style=\"width:600;height:300px;\"> <br>\n",
+    "<caption><center> **Figure 8**: Full Attention Map</center></caption>\n",
+    "\n",
+    "Notice how the output ignores the \"Saturday\" portion of the input. None of the output timesteps are paying much attention to that portion of the input. We also see that 9 has been translated as 09 and May has been correctly translated into 05, with the output paying attention to the parts of the input it needs to make the translation. The year mostly requires it to pay attention to the input's \"18\" in order to generate \"2018.\" "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FrP893IFh3Mv"
+   },
+   "source": [
+    "<a name='3-1'></a>\n",
+    "### 3.1 - Getting the Attention Weights From the Network\n",
+    "\n",
+    "Lets now visualize the attention values in your network. We'll propagate an example through the network, then visualize the values of $\\alpha^{\\langle t, t' \\rangle}$. \n",
+    "\n",
+    "To figure out where the attention values are located, let's start by printing a summary of the model ."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 53826,
+     "status": "ok",
+     "timestamp": 1612468551078,
+     "user": {
+      "displayName": "Mubsi K",
+      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
+      "userId": "08094225471505108399"
+     },
+     "user_tz": -300
+    },
+    "id": "RfiLrfKIh3Mv",
+    "outputId": "b6690603-209c-40d7-f352-235a689d1aea"
+   },
+   "outputs": [],
+   "source": [
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "zbcprBCPh3Mv"
+   },
+   "source": [
+    "Navigate through the output of `model.summary()` above. You can see that the layer named `attention_weights` outputs the `alphas` of shape (m, 30, 1) before `dot_2` computes the context vector for every time step $t = 0, \\ldots, T_y-1$. Let's get the attention weights from this layer.\n",
+    "\n",
+    "The function `plot_attention_map()` pulls out the attention values from your model and plots them.\n",
+    "\n",
+    "**Note**: We are aware that you might run into an error running the cell below despite a valid implementation for Exercise 2 - `modelf` above. If  you have passed all implementations of the exercises above, don’t worry about the error, it will not affect the grading for this assignment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attention_map = plot_attention_map(model, human_vocab, inv_machine_vocab, \"Tuesday 09 Oct 1993\", num = 7, n_s = 64);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "pQ3qbIjqh3Mx"
+   },
+   "source": [
+    "On the generated plot you can observe the values of the attention weights for each character of the predicted output. Examine this plot and check that the places where the network is paying attention makes sense to you.\n",
+    "\n",
+    "In the date translation application, you will observe that most of the time attention helps predict the year, and doesn't have much impact on predicting the day or month."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "IkpGu1Jkh3Mx"
+   },
+   "source": [
+    "### Congratulations!\n",
+    "\n",
+    "\n",
+    "You have come to the end of this assignment \n",
+    "\n",
+    "#### Here's what you should remember\n",
+    "\n",
+    "- Machine translation models can be used to map from one sequence to another. They are useful not just for translating human languages (like French->English) but also for tasks like date format translation. \n",
+    "- An attention mechanism allows a network to focus on the most relevant parts of the input when producing a specific part of the output. \n",
+    "- A network using an attention mechanism can translate from inputs of length $T_x$ to outputs of length $T_y$, where $T_x$ and $T_y$ can be different. \n",
+    "- You can visualize attention weights $\\alpha^{\\langle t,t' \\rangle}$ to see what the network is paying attention to while generating each output."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ZaKA2u4uh3My"
+   },
+   "source": [
+    "Congratulations on finishing this assignment! You are now able to implement an attention model and use it to learn complex mappings from one sequence to another. "
+   ]
+  }
+ ],
+ "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.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

Seq2Seq/Neural_MT_without_Teacher_Forcing/home/jovyan/work/W3A1/expected_output_ex1.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a07c969d1cc85d193c3078b618bde6a2dde392b441676d1e066baf9d905de24
+size 2688

Seq2Seq/Neural_MT_without_Teacher_Forcing/home/jovyan/work/W3A1/generateTestCases.py

@@ -0,0 +1,97 @@
+# New Generate Test Cases 
+import numpy as np 
+import math 
+import os,sys
+from testCase import get_testCase
+# import copy 
+# from keras.callbacks import History 
+# import tensorflow as tf
+sys.path.append('../')
+sys.path.append('../../')
+
+from grader_support import stdout_redirector
+from grader_support import util
+
+os.environ['TF_CPP_MIN_LOG_LEVEL']='3'
+
+# This grader is for the Emojify assignment
+
+mFiles = [
+    "one_step_attention.py",
+    "model.py"
+]
+class suppress_stdout_stderr(object):
+    '''
+    A context manager for doing a "deep suppression" of stdout and stderr in 
+    Python, i.e. will suppress all print, even if the print originates in a 
+    compiled C/Fortran sub-function.
+       This will not suppress raised exceptions, since exceptions are printed
+    to stderr just before a script exits, and after the context manager has
+    exited (at least, I think that is why it lets exceptions through).      
+
+    '''
+    def __init__(self):
+        # Open a pair of null files
+        self.null_fds =  [os.open(os.devnull,os.O_RDWR) for x in range(2)]
+        # Save the actual stdout (1) and stderr (2) file descriptors.
+        self.save_fds = [os.dup(1), os.dup(2)]
+
+    def __enter__(self):
+        # Assign the null pointers to stdout and stderr.
+        os.dup2(self.null_fds[0],1)
+        os.dup2(self.null_fds[1],2)
+
+    def __exit__(self, *_):
+        # Re-assign the real stdout/stderr back to (1) and (2)
+        os.dup2(self.save_fds[0],1)
+        os.dup2(self.save_fds[1],2)
+        # Close all file descriptors
+        for fd in self.null_fds + self.save_fds:
+            os.close(fd)
+np.random.seed(3)
+with suppress_stdout_stderr():
+    from solutions import *
+    from testCase import get_testCase
+    n_a = 64
+    n_s = 128
+    m = 10
+    dataset, human_vocab, machine_vocab, inv_machine_vocab = load_dataset(m)
+
+    human_vocab_size = len(human_vocab)
+    machine_vocab_size = len(machine_vocab)
+
+    im = model(Tx, Ty, n_a, n_s, human_vocab_size, machine_vocab_size)
+    cp1 = im.count_params()
+    mi1 = len(im.inputs)
+    mo1 = len(im.outputs)
+    ml1 = len(im.layers)
+    m_out1 = np.asarray((cp1, mi1, mo1, ml1))
+
+
+    # GRADED FUNCTION: one_step_attention
+
+    m_out2 = get_testCase()
+
+def generateTestCases():
+	testCases = {
+	    'one_step_attention': {
+	        'partId': 'zcQIs',
+	        'testCases': [
+	            {
+	                'testInput': 0,
+	                'testOutput': m_out2
+	            }
+	        ]
+	    },
+	    'model': { 
+	        'partId': 'PTKef',
+	        'testCases': [
+	            {
+	                'testInput': (Tx, Ty, n_a, n_s, human_vocab_size, machine_vocab_size),
+	                'testOutput': m_out1
+	            }
+	        ]
+	    }
+       }
+	return testCases
+

Seq2Seq/Neural_MT_without_Teacher_Forcing/home/jovyan/work/W3A1/models/model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:908b9a19d6528c5efcf0374b2eb7de6c79443269b8f53c1440268e6e3399e80a
+size 698400

Seq2Seq/Neural_MT_without_Teacher_Forcing/home/jovyan/work/W3A1/nmt_utils.py

@@ -0,0 +1,289 @@
+import numpy as np
+from faker import Faker
+import random
+from tqdm import tqdm
+from babel.dates import format_date
+from tensorflow.keras.utils import to_categorical
+import tensorflow.keras.backend as K
+from tensorflow.keras.models import Model
+import matplotlib.pyplot as plt
+
+fake = Faker()
+Faker.seed(12345)
+random.seed(12345)
+
+# Define format of the data we would like to generate
+FORMATS = ['short',
+           'medium',
+           'long',
+           'full',
+           'full',
+           'full',
+           'full',
+           'full',
+           'full',
+           'full',
+           'full',
+           'full',
+           'full',
+           'd MMM YYY', 
+           'd MMMM YYY',
+           'dd MMM YYY',
+           'd MMM, YYY',
+           'd MMMM, YYY',
+           'dd, MMM YYY',
+           'd MM YY',
+           'd MMMM YYY',
+           'MMMM d YYY',
+           'MMMM d, YYY',
+           'dd.MM.YY']
+
+# change this if you want it to work with another language
+LOCALES = ['en_US']
+
+def load_date():
+    """
+        Loads some fake dates 
+        :returns: tuple containing human readable string, machine readable string, and date object
+    """
+    dt = fake.date_object()
+
+    try:
+        human_readable = format_date(dt, format=random.choice(FORMATS),  locale='en_US') # locale=random.choice(LOCALES))
+        human_readable = human_readable.lower()
+        human_readable = human_readable.replace(',','')
+        machine_readable = dt.isoformat()
+        
+    except AttributeError as e:
+        return None, None, None
+
+    return human_readable, machine_readable, dt
+
+def load_dataset(m):
+    """
+        Loads a dataset with m examples and vocabularies
+        :m: the number of examples to generate
+    """
+    
+    human_vocab = set()
+    machine_vocab = set()
+    dataset = []
+    Tx = 30
+    
+
+    for i in tqdm(range(m)):
+        h, m, _ = load_date()
+        if h is not None:
+            dataset.append((h, m))
+            human_vocab.update(tuple(h))
+            machine_vocab.update(tuple(m))
+    
+    human = dict(zip(sorted(human_vocab) + ['<unk>', '<pad>'], 
+                     list(range(len(human_vocab) + 2))))
+    inv_machine = dict(enumerate(sorted(machine_vocab)))
+    machine = {v:k for k,v in inv_machine.items()}
+ 
+    return dataset, human, machine, inv_machine
+
+def preprocess_data(dataset, human_vocab, machine_vocab, Tx, Ty):
+    
+    X, Y = zip(*dataset)
+    
+    X = np.array([string_to_int(i, Tx, human_vocab) for i in X])
+    Y = [string_to_int(t, Ty, machine_vocab) for t in Y]
+    
+    Xoh = np.array(list(map(lambda x: to_categorical(x, num_classes=len(human_vocab)), X)))
+    Yoh = np.array(list(map(lambda x: to_categorical(x, num_classes=len(machine_vocab)), Y)))
+
+
+
+    return X, np.array(Y), Xoh, Yoh
+
+def string_to_int(string, length, vocab):
+    """
+    Converts all strings in the vocabulary into a list of integers representing the positions of the
+    input string's characters in the "vocab"
+    
+    Arguments:
+    string -- input string, e.g. 'Wed 10 Jul 2007'
+    length -- the number of time steps you'd like, determines if the output will be padded or cut
+    vocab -- vocabulary, dictionary used to index every character of your "string"
+    
+    Returns:
+    rep -- list of integers (or '<unk>') (size = length) representing the position of the string's character in the vocabulary
+    """
+    
+    #make lower to standardize
+    string = string.lower()
+    string = string.replace(',','')
+    
+    if len(string) > length:
+        string = string[:length]
+        
+    rep = list(map(lambda x: vocab.get(x, '<unk>'), string))
+    
+    if len(string) < length:
+        rep += [vocab['<pad>']] * (length - len(string))
+    
+    #print (rep)
+    return rep
+
+
+def int_to_string(ints, inv_vocab):
+    """
+    Output a machine readable list of characters based on a list of indexes in the machine's vocabulary
+    
+    Arguments:
+    ints -- list of integers representing indexes in the machine's vocabulary
+    inv_vocab -- dictionary mapping machine readable indexes to machine readable characters 
+    
+    Returns:
+    l -- list of characters corresponding to the indexes of ints thanks to the inv_vocab mapping
+    """
+    
+    l = [inv_vocab[i] for i in ints]
+    return l
+
+
+EXAMPLES = ['3 May 1979', '5 Apr 09', '20th February 2016', 'Wed 10 Jul 2007']
+
+def run_example(model, input_vocabulary, inv_output_vocabulary, text):
+    encoded = string_to_int(text, TIME_STEPS, input_vocabulary)
+    prediction = model.predict(np.array([encoded]))
+    prediction = np.argmax(prediction[0], axis=-1)
+    return int_to_string(prediction, inv_output_vocabulary)
+
+def run_examples(model, input_vocabulary, inv_output_vocabulary, examples=EXAMPLES):
+    predicted = []
+    for example in examples:
+        predicted.append(''.join(run_example(model, input_vocabulary, inv_output_vocabulary, example)))
+        print('input:', example)
+        print('output:', predicted[-1])
+    return predicted
+
+
+def softmax(x, axis=1):
+    """Softmax activation function.
+    # Arguments
+        x : Tensor.
+        axis: Integer, axis along which the softmax normalization is applied.
+    # Returns
+        Tensor, output of softmax transformation.
+    # Raises
+        ValueError: In case `dim(x) == 1`.
+    """
+    ndim = K.ndim(x)
+    if ndim == 2:
+        return K.softmax(x)
+    elif ndim > 2:
+        e = K.exp(x - K.max(x, axis=axis, keepdims=True))
+        s = K.sum(e, axis=axis, keepdims=True)
+        return e / s
+    else:
+        raise ValueError('Cannot apply softmax to a tensor that is 1D')
+        
+
+def plot_attention_map(modelx, input_vocabulary, inv_output_vocabulary, text, n_s = 128, num = 7):
+    """
+    Plot the attention map.
+  
+    """
+    attention_map = np.zeros((10, 30))
+    layer = modelx.get_layer('attention_weights')
+
+    Ty, Tx = attention_map.shape
+    
+    human_vocab_size = 37
+    
+    # Well, this is cumbersome but this version of tensorflow-keras has a bug that affects the 
+    # reuse of layers in a model with the functional API. 
+    # So, I have to recreate the model based on the functional 
+    # components and connect then one by one.
+    # ideally it can be done simply like this:
+    # layer = modelx.layers[num]
+    # f = Model(modelx.inputs, [layer.get_output_at(t) for t in range(Ty)])
+    #
+    
+    X = modelx.inputs[0] 
+    s0 = modelx.inputs[1] 
+    c0 = modelx.inputs[2] 
+    s = s0
+    c = s0
+    
+    a = modelx.layers[2](X)  
+    outputs = []
+
+    for t in range(Ty):
+        s_prev = s
+        s_prev = modelx.layers[3](s_prev)
+        concat = modelx.layers[4]([a, s_prev]) 
+        e = modelx.layers[5](concat) 
+        energies = modelx.layers[6](e) 
+        alphas = modelx.layers[7](energies) 
+        context = modelx.layers[8]([alphas, a])
+        # Don't forget to pass: initial_state = [hidden state, cell state] (≈ 1 line)
+        s, _, c = modelx.layers[10](context, initial_state = [s, c]) 
+        outputs.append(energies)
+
+    f = Model(inputs=[X, s0, c0], outputs = outputs)
+    
+
+    s0 = np.zeros((1, n_s))
+    c0 = np.zeros((1, n_s))
+    encoded = np.array(string_to_int(text, Tx, input_vocabulary)).reshape((1, 30))
+    encoded = np.array(list(map(lambda x: to_categorical(x, num_classes=len(input_vocabulary)), encoded)))
+
+    
+    r = f([encoded, s0, c0])
+        
+    for t in range(Ty):
+        for t_prime in range(Tx):
+            attention_map[t][t_prime] = r[t][0, t_prime]
+
+    # Normalize attention map
+    row_max = attention_map.max(axis=1)
+    attention_map = attention_map / row_max[:, None]
+
+    prediction = modelx.predict([encoded, s0, c0])
+    
+    predicted_text = []
+    for i in range(len(prediction)):
+        predicted_text.append(int(np.argmax(prediction[i], axis=1)))
+        
+    predicted_text = list(predicted_text)
+    predicted_text = int_to_string(predicted_text, inv_output_vocabulary)
+    text_ = list(text)
+    
+    # get the lengths of the string
+    input_length = len(text)
+    output_length = Ty
+    
+    # Plot the attention_map
+    plt.clf()
+    f = plt.figure(figsize=(8, 8.5))
+    ax = f.add_subplot(1, 1, 1)
+
+    # add image
+    i = ax.imshow(attention_map, interpolation='nearest', cmap='Blues')
+
+    # add colorbar
+    cbaxes = f.add_axes([0.2, 0, 0.6, 0.03])
+    cbar = f.colorbar(i, cax=cbaxes, orientation='horizontal')
+    cbar.ax.set_xlabel('Alpha value (Probability output of the "softmax")', labelpad=2)
+
+    # add labels
+    ax.set_yticks(range(output_length))
+    ax.set_yticklabels(predicted_text[:output_length])
+
+    ax.set_xticks(range(input_length))
+    ax.set_xticklabels(text_[:input_length], rotation=45)
+
+    ax.set_xlabel('Input Sequence')
+    ax.set_ylabel('Output Sequence')
+
+    # add grid and legend
+    ax.grid()
+
+    #f.show()
+    
+    return attention_map

Seq2Seq/Neural_MT_without_Teacher_Forcing/home/jovyan/work/W3A1/test_utils.py

@@ -0,0 +1,57 @@
+from termcolor import colored
+
+from tensorflow.keras.layers import Input
+from tensorflow.keras.layers import Conv2D
+from tensorflow.keras.layers import MaxPooling2D
+from tensorflow.keras.layers import Dropout 
+from tensorflow.keras.layers import Conv2DTranspose
+from tensorflow.keras.layers import concatenate
+from tensorflow.keras.layers import ZeroPadding2D
+from tensorflow.keras.layers import Dense
+from tensorflow.keras.layers import LSTM
+from tensorflow.keras.layers import RepeatVector
+
+
+# Compare the two inputs
+def comparator(learner, instructor):
+    if len(learner) != len(instructor):
+        raise AssertionError("Error in test. The lists contain a different number of elements") 
+    for index, a in enumerate(instructor):
+        b = learner[index]
+        if tuple(a) != tuple(b):
+            print(colored(f"Test failed at index {index}", attrs=['bold']),
+                  "\n Expected value \n\n", colored(f"{a}", "green"), 
+                  "\n\n does not match the input value: \n\n", 
+                  colored(f"{b}", "red"))
+            raise AssertionError("Error in test") 
+    print(colored("All tests passed!", "green"))
+
+# extracts the description of a given model
+def summary(model):
+    model.compile(optimizer='adam',
+                  loss='categorical_crossentropy',
+                  metrics=['accuracy'])
+    result = []
+    for layer in model.layers:
+        descriptors = [layer.__class__.__name__, layer.output_shape, layer.count_params()]
+        if (type(layer) == Conv2D):
+            descriptors.append(layer.padding)
+            descriptors.append(layer.activation.__name__)
+            descriptors.append(layer.kernel_initializer.__class__.__name__)
+        if (type(layer) == MaxPooling2D):
+            descriptors.append(layer.pool_size)
+            descriptors.append(layer.strides)
+            descriptors.append(layer.padding)
+        if (type(layer) == Dropout):
+            descriptors.append(layer.rate)
+        if (type(layer) == ZeroPadding2D):
+            descriptors.append(layer.padding)
+        if (type(layer) == Dense):
+            descriptors.append(layer.activation.__name__)
+        if (type(layer) == LSTM):
+            descriptors.append(layer.input_shape)
+            descriptors.append(layer.activation.__name__)
+        if (type(layer) == RepeatVector):
+            descriptors.append(layer.n)
+        result.append(descriptors)
+    return result