Emoji_v3a.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5bgPpghocFIa"
   },
   "source": [
    "# Emojify! \n",
    "\n",
    "Welcome to the second assignment of Week 2! You're going to use word vector representations to build an Emojifier. \n",
    "🤩 💫 🔥\n",
    "\n",
    "Have you ever wanted to make your text messages more expressive? Your emojifier app will help you do that. \n",
    "Rather than writing:\n",
    ">\"Congratulations on the promotion! Let's get coffee and talk. Love you!\"   \n",
    "\n",
    "The emojifier can automatically turn this into:\n",
    ">\"Congratulations on the promotion! 👍  Let's get coffee and talk. ☕️ Love you! ❤️\"\n",
    "\n",
    "You'll implement a model which inputs a sentence (such as \"Let's go see the baseball game tonight!\") and finds the most appropriate emoji to be used with this sentence (⚾️).\n",
    "\n",
    "### Using Word Vectors to Improve Emoji Lookups\n",
    "* In many emoji interfaces, you need to remember that ❤️  is the \"heart\" symbol rather than the \"love\" symbol. \n",
    "    * In other words, you'll have to remember to type \"heart\" to find the desired emoji, and typing \"love\" won't bring up that symbol.\n",
    "* You can make a more flexible emoji interface by using word vectors!\n",
    "* When using word vectors, you'll see that even if your training set explicitly relates only a few words to a particular emoji, your algorithm will be able to generalize and associate additional words in the test set to the same emoji.\n",
    "    * This works even if those additional words don't even appear in the training set. \n",
    "    * This allows you to build an accurate classifier mapping from sentences to emojis, even using a small training set. \n",
    "\n",
    "### What you'll build:\n",
    "1. In this exercise, you'll start with a baseline model (Emojifier-V1) using word embeddings.\n",
    "2. Then you will build a more sophisticated model (Emojifier-V2) that further incorporates an LSTM. \n",
    "\n",
    "By the end of this notebook, you'll be able to:\n",
    "\n",
    "* Create an embedding layer in Keras with pre-trained word vectors\n",
    "* Explain the advantages and disadvantages of the GloVe algorithm\n",
    "* Build a sentiment classifier using word embeddings\n",
    "* Build and train a more sophisticated classifier using an LSTM\n",
    "\n",
    "🏀 👑\n",
    "\n",
    "👆 😎\n",
    "\n",
    "(^^^ Emoji for \"skills\") \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": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "- [Packages](#0)\n",
    "- [1 - Baseline Model: Emojifier-V1](#1)\n",
    "    - [1.1 - Dataset EMOJISET](#1-1)\n",
    "    - [1.2 - Overview of the Emojifier-V1](#1-2)\n",
    "    - [1.3 - Implementing Emojifier-V1](#1-3)\n",
    "        - [Exercise 1 - sentence_to_avg](#ex-1)\n",
    "    - [1.4 - Implement the Model](#1-4)\n",
    "        - [Exercise 2 - model](#ex-2)\n",
    "    - [1.5 - Examining Test Set Performance](#1-5)\n",
    "- [2 - Emojifier-V2: Using LSTMs in Keras](#2)\n",
    "    - [2.1 - Model Overview](#2-1)\n",
    "    - [2.2 Keras and Mini-batching](#2-2)\n",
    "    - [2.3 - The Embedding Layer](#2-3)\n",
    "        - [Exercise 3 - sentences_to_indices](#ex-3)\n",
    "        - [Exercise 4 - pretrained_embedding_layer](#ex-4)\n",
    "    - [2.4 - Building the Emojifier-V2](#2-4)\n",
    "        - [Exercise 5 - Emojify_V2](#ex-5)\n",
    "    - [2.5 - Train the Model](#2-5)\n",
    "- [3 - Acknowledgments](#3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HsztVBA8cFIg"
   },
   "source": [
    "<a name='0'></a>\n",
    "## Packages\n",
    "\n",
    "Let's get started! Run the following cell to load the packages you're going to use. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "### v1.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "lMZ9xg8MFHZU"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from emo_utils import *\n",
    "import emoji\n",
    "import matplotlib.pyplot as plt\n",
    "from test_utils import *\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Av0PwZYscFIh"
   },
   "source": [
    "<a name='1'></a>\n",
    "## 1 - Baseline Model: Emojifier-V1\n",
    "\n",
    "<a name='1-1'></a>\n",
    "### 1.1 - Dataset EMOJISET\n",
    "\n",
    "Let's start by building a simple baseline classifier. \n",
    "\n",
    "You have a tiny dataset (X, Y) where:\n",
    "- X contains 127 sentences (strings).\n",
    "- Y contains an integer label between 0 and 4 corresponding to an emoji for each sentence.\n",
    "\n",
    "<img src=\"images/data_set.png\" style=\"width:700px;height:300px;\">\n",
    "<caption><center><font color='purple'><b>Figure 1</b>: EMOJISET - a classification problem with 5 classes. A few examples of sentences are given here. </center></caption>\n",
    "\n",
    "Load the dataset using the code below. The dataset is split between training (127 examples) and testing (56 examples)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "executionInfo": {
     "elapsed": 2671,
     "status": "ok",
     "timestamp": 1611738624467,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "OvuoZ8pWcFIi"
   },
   "outputs": [],
   "source": [
    "X_train, Y_train = read_csv('data/train_emoji.csv')\n",
    "X_test, Y_test = read_csv('data/tesss.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the below code cell, you will find out the sentence with the maximum number of words, and will store it's length in `maxLen` (*i.e., the number of words in the longest sentence, which will be used further*). Let's break down this code for a better understanding.\n",
    "\n",
    "- The first point to note here is that `split()` breaks a string into a list of it's words. So, if `x` is a string, then `len(x.split())` returns the number of words in that string. You can read more about `split` [here](https://docs.python.org/3/library/stdtypes.html?highlight=split#str.split).\n",
    "\n",
    "- The second point to note here is the way in which `max` function has been used. As can be read [here](https://docs.python.org/3/library/functions.html#max), apart from an iterable (*which in your case is `X_train`, a list of strings*), this function also has a `key` argument, that can be used to modify the basis on which the largest element in the iterable is chosen.\n",
    "\n",
    "In this case, `key` has been chosen as the number of words in a string. So the `max` function will return the string with the largest number of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "executionInfo": {
     "elapsed": 2046,
     "status": "ok",
     "timestamp": 1611738634135,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "DjAuDbxrcFIi"
   },
   "outputs": [],
   "source": [
    "maxLen = len(max(X_train, key=lambda x: len(x.split())).split())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EpbQIx7dcFIi"
   },
   "source": [
    "Run the following cell to print sentences from X_train and corresponding labels from Y_train. \n",
    "* Change `idx` to see different examples. \n",
    "* Note that due to the font used by iPython notebook, the heart emoji may be colored black rather than red."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 2058,
     "status": "ok",
     "timestamp": 1611738637381,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "vE1Zd2SMcFIj",
    "outputId": "49f45ed1-8f2f-4ea8-da44-4acb41731287"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "never talk to me again 😞\n",
      "I am proud of your achievements 😄\n",
      "It is the worst day in my life 😞\n",
      "Miss you so much ❤️\n",
      "food is life 🍴\n",
      "I love you mum ❤️\n",
      "Stop saying bullshit 😞\n",
      "congratulations on your acceptance 😄\n",
      "The assignment is too long  😞\n",
      "I want to go play ⚾\n"
     ]
    }
   ],
   "source": [
    "for idx in range(10):\n",
    "    print(X_train[idx], label_to_emoji(Y_train[idx]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tS_N2pMpcFIk"
   },
   "source": [
    "<a name='1-2'></a>\n",
    "### 1.2 - Overview of the Emojifier-V1\n",
    "\n",
    "In this section, you'll implement a baseline model called \"Emojifier-v1\".  \n",
    "\n",
    "<center>\n",
    "<img src=\"images/image_1.png\" style=\"width:900px;height:300px;\">\n",
    "    <caption><center><font color='purple'><b>Figure 2</b>: Baseline model (Emojifier-V1).</center></caption>\n",
    "</center></font>\n",
    "\n",
    "\n",
    "#### Inputs and Outputs\n",
    "* The input of the model is a string corresponding to a sentence (e.g. \"I love you\"). \n",
    "* The output will be a probability vector of shape (1,5), (indicating that there are 5 emojis to choose from).\n",
    "* The (1,5) probability vector is passed to an argmax layer, which extracts the index of the emoji with the highest probability."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Y6nloeF5cFIl"
   },
   "source": [
    "#### One-hot Encoding\n",
    "* To get your labels into a format suitable for training a softmax classifier, convert $Y$ from its current shape  $(m, 1)$ into a \"one-hot representation\" $(m, 5)$, \n",
    "    * Each row is a one-hot vector giving the label of one example.\n",
    "    * Here, `Y_oh` stands for \"Y-one-hot\" in the variable names `Y_oh_train` and `Y_oh_test`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "executionInfo": {
     "elapsed": 2619,
     "status": "ok",
     "timestamp": 1611738660835,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "RhRTRwVncFIm"
   },
   "outputs": [],
   "source": [
    "Y_oh_train = convert_to_one_hot(Y_train, C = 5)\n",
    "Y_oh_test = convert_to_one_hot(Y_test, C = 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2w3GRkw2cFIo"
   },
   "source": [
    "Now, see what `convert_to_one_hot()` did. Feel free to change `index` to print out different values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 2838,
     "status": "ok",
     "timestamp": 1611738667164,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "GlHYeuBIcFIo",
    "outputId": "c2b73f6a-9a15-4728-a8b4-7ba38b5372ed"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sentence 'I missed you' has label index 0, which is emoji ❤️\n",
      "Label index 0 in one-hot encoding format is [1. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "idx = 50\n",
    "print(f\"Sentence '{X_train[idx]}' has label index {Y_train[idx]}, which is emoji {label_to_emoji(Y_train[idx])}\", )\n",
    "print(f\"Label index {Y_train[idx]} in one-hot encoding format is {Y_oh_train[idx]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gbFECkqAcFIp"
   },
   "source": [
    "All the data is now ready to be fed into the Emojify-V1 model. You're ready to implement the model!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KI8mJoafcFIp"
   },
   "source": [
    "<a name='1-3'></a>\n",
    "### 1.3 - Implementing Emojifier-V1\n",
    "\n",
    "As shown in Figure 2 (above), the first step is to:\n",
    "* Convert each word in the input sentence into their word vector representations.\n",
    "* Take an average of the word vectors. \n",
    "\n",
    "Similar to this week's previous assignment, you'll use pre-trained 50-dimensional GloVe embeddings. \n",
    "\n",
    "Run the following cell to load the `word_to_vec_map`, which contains all the vector representations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "executionInfo": {
     "elapsed": 8474,
     "status": "ok",
     "timestamp": 1611738705912,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "QXI3avt7cFIq"
   },
   "outputs": [],
   "source": [
    "word_to_index, index_to_word, word_to_vec_map = read_glove_vecs('data/glove.6B.50d.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9JM-0zg6cFIr"
   },
   "source": [
    "You've loaded:\n",
    "- `word_to_index`: dictionary mapping from words to their indices in the vocabulary \n",
    "    - (400,001 words, with the valid indices ranging from 0 to 400,000)\n",
    "- `index_to_word`: dictionary mapping from indices to their corresponding words in the vocabulary\n",
    "- `word_to_vec_map`: dictionary mapping words to their GloVe vector representation.\n",
    "\n",
    "Run the following cell to check if it works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 1164,
     "status": "ok",
     "timestamp": 1611738710682,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "RB2ZN6ajcFIr",
    "outputId": "3c733016-edf8-417d-f589-828c2a9d8a09"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the index of cucumber in the vocabulary is 113317\n",
      "the 289846th word in the vocabulary is potatos\n"
     ]
    }
   ],
   "source": [
    "word = \"cucumber\"\n",
    "idx = 289846\n",
    "print(\"the index of\", word, \"in the vocabulary is\", word_to_index[word])\n",
    "print(\"the\", str(idx) + \"th word in the vocabulary is\", index_to_word[idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wg9QpkR5cFIs"
   },
   "source": [
    "<a name='ex-1'></a>\n",
    "### Exercise 1 - sentence_to_avg\n",
    "\n",
    "Implement `sentence_to_avg()` \n",
    "\n",
    "You'll need to carry out two steps:\n",
    "\n",
    "1. Convert every sentence to lower-case, then split the sentence into a list of words. \n",
    "    * `X.lower()` and `X.split()` might be useful. 😉\n",
    "2. For each word in the sentence, access its GloVe representation.\n",
    "    * Then take the average of all of these word vectors.\n",
    "    * You might use `numpy.zeros()`, which you can read more about [here]('https://numpy.org/doc/stable/reference/generated/numpy.zeros.html').\n",
    "    \n",
    "    \n",
    "#### Additional Hints\n",
    "* When creating the `avg` array of zeros, you'll want it to be a vector of the same shape as the other word vectors in the `word_to_vec_map`.  \n",
    "    * You can choose a word that exists in the `word_to_vec_map` and access its `.shape` field.\n",
    "    * Be careful not to hard-code the word that you access.  In other words, don't assume that if you see the word 'the' in the `word_to_vec_map` within this notebook, that this word will be in the `word_to_vec_map` when the function is being called by the automatic grader.\n",
    "\n",
    "**Hint**: you can use any one of the word vectors that you retrieved from the input `sentence` to find the shape of a word vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "executionInfo": {
     "elapsed": 1943,
     "status": "ok",
     "timestamp": 1611738728468,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "buYjsIBecFIs"
   },
   "outputs": [],
   "source": [
    "# UNQ_C1 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED FUNCTION: sentence_to_avg\n",
    "\n",
    "def sentence_to_avg(sentence, word_to_vec_map):\n",
    "    \"\"\"\n",
    "    Converts a sentence (string) into a list of words (strings). Extracts the GloVe representation of each word\n",
    "    and averages its value into a single vector encoding the meaning of the sentence.\n",
    "    \n",
    "    Arguments:\n",
    "    sentence -- string, one training example from X\n",
    "    word_to_vec_map -- dictionary mapping every word in a vocabulary into its 50-dimensional vector representation\n",
    "    \n",
    "    Returns:\n",
    "    avg -- average vector encoding information about the sentence, numpy-array of shape (J,), where J can be any number\n",
    "    \"\"\"\n",
    "    # Get a valid word contained in the word_to_vec_map. \n",
    "    any_word = list(word_to_vec_map.keys())[0]\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    # Step 1: Split sentence into list of lower case words (≈ 1 line)\n",
    "    words = sentence.lower().split()\n",
    "\n",
    "    # Initialize the average word vector, should have the same shape as your word vectors.\n",
    "    # Use `np.zeros` and pass in the argument of any word's word 2 vec's shape\n",
    "    avg =  np.zeros(word_to_vec_map[any_word].shape)\n",
    "    \n",
    "    # Initialize count to 0\n",
    "    count = 0\n",
    "    \n",
    "    # Step 2: average the word vectors. You can loop over the words in the list \"words\".\n",
    "    for w in words:\n",
    "        # Check that word exists in word_to_vec_map\n",
    "        if w in word_to_vec_map:\n",
    "            avg += word_to_vec_map[w]\n",
    "            # Increment count\n",
    "            count +=1\n",
    "          \n",
    "    if count > 0:\n",
    "        # Get the average. But only if count > 0\n",
    "        avg = avg / count\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return avg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "deletable": false,
    "editable": false,
    "executionInfo": {
     "elapsed": 1861,
     "status": "ok",
     "timestamp": 1611738734359,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "7OwW-r6ecFIt",
    "outputId": "7ed0ff55-10f4-4072-fdff-2edc216373fc",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avg = \n",
      " [-0.008005    0.56370833 -0.50427333  0.258865    0.55131103  0.03104983\n",
      " -0.21013718  0.16893933 -0.09590267  0.141784   -0.15708967  0.18525867\n",
      "  0.6495785   0.38371117  0.21102167  0.11301667  0.02613967  0.26037767\n",
      "  0.05820667 -0.01578167 -0.12078833 -0.02471267  0.4128455   0.5152061\n",
      "  0.38756167 -0.898661   -0.535145    0.33501167  0.68806933 -0.2156265\n",
      "  1.797155    0.10476933 -0.36775333  0.750785    0.10282583  0.348925\n",
      " -0.27262833  0.66768    -0.10706167 -0.283635    0.59580117  0.28747333\n",
      " -0.3366635   0.23393817  0.34349183  0.178405    0.1166155  -0.076433\n",
      "  0.1445417   0.09808667]\n",
      "\u001b[92mAll tests passed!\n"
     ]
    }
   ],
   "source": [
    "### YOU CANNOT EDIT THIS CELL\n",
    "\n",
    "# BEGIN UNIT TEST\n",
    "avg = sentence_to_avg(\"Morrocan couscous is my favorite dish\", word_to_vec_map)\n",
    "print(\"avg = \\n\", avg)\n",
    "\n",
    "def sentence_to_avg_test(target):\n",
    "    # Create a controlled word to vec map\n",
    "    word_to_vec_map = {'a': [3, 3], 'synonym_of_a': [3, 3], 'a_nw': [2, 4], 'a_s': [3, 2], \n",
    "                       'c': [-2, 1], 'c_n': [-2, 2],'c_ne': [-1, 2], 'c_e': [-1, 1], 'c_se': [-1, 0], \n",
    "                       'c_s': [-2, 0], 'c_sw': [-3, 0], 'c_w': [-3, 1], 'c_nw': [-3, 2]\n",
    "                      }\n",
    "    # Convert lists to np.arrays\n",
    "    for key in word_to_vec_map.keys():\n",
    "        word_to_vec_map[key] = np.array(word_to_vec_map[key])\n",
    "        \n",
    "    avg = target(\"a a_nw c_w a_s\", word_to_vec_map)\n",
    "    assert tuple(avg.shape) == tuple(word_to_vec_map['a'].shape),  \"Check the shape of your avg array\"  \n",
    "    assert np.allclose(avg, [1.25, 2.5]),  \"Check that you are finding the 4 words\"\n",
    "    avg = target(\"love a a_nw c_w a_s\", word_to_vec_map)\n",
    "    assert np.allclose(avg, [1.25, 2.5]), \"Divide by count, not len(words)\"\n",
    "    avg = target(\"love\", word_to_vec_map)\n",
    "    assert np.array_equal(avg, [0, 0]), \"Average of no words must give an array of zeros\"\n",
    "    avg = target(\"c_se foo a a_nw c_w a_s deeplearning c_nw\", word_to_vec_map)\n",
    "    assert np.allclose(avg, [0.1666667, 2.0]), \"Debug the last example\"\n",
    "    \n",
    "    print(\"\\033[92mAll tests passed!\")\n",
    "    \n",
    "sentence_to_avg_test(sentence_to_avg)\n",
    "\n",
    "# END UNIT TEST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NPPv5gmucFIv"
   },
   "source": [
    "<a name='1-4'></a>\n",
    "### 1.4 - Implement the Model\n",
    "\n",
    "You now have all the pieces to finish implementing the `model()` function! \n",
    "After using `sentence_to_avg()` you need to:\n",
    "* Pass the average through forward propagation\n",
    "* Compute the cost\n",
    "* Backpropagate to update the softmax parameters\n",
    "\n",
    "<a name='ex-2'></a>\n",
    "### Exercise 2 - model\n",
    "\n",
    "Implement the `model()` function described in Figure (2). \n",
    "\n",
    "* The equations you need to implement in the forward pass and to compute the cross-entropy cost are below:\n",
    "* The variable $Y_{oh}$ (\"Y one hot\") is the one-hot encoding of the output labels. \n",
    "\n",
    "$$ z^{(i)} = Wavg^{(i)} + b$$\n",
    "\n",
    "$$ a^{(i)} = softmax(z^{(i)})$$\n",
    "\n",
    "$$ \\mathcal{L}^{(i)} = - \\sum_{k = 0}^{n_y - 1} Y_{oh,k}^{(i)} * log(a^{(i)}_k)$$\n",
    "\n",
    "**Note**: It is possible to come up with a more efficient vectorized implementation. For now, just use nested for loops to better understand the algorithm, and for easier debugging.\n",
    "\n",
    "The function `softmax()` is provided, and has already been imported."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "executionInfo": {
     "elapsed": 2322,
     "status": "ok",
     "timestamp": 1611738741724,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "O_BzrO-TcFIv"
   },
   "outputs": [],
   "source": [
    "# UNQ_C2 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED FUNCTION: model\n",
    "\n",
    "def model(X, Y, word_to_vec_map, learning_rate=0.01, num_iterations=400):\n",
    "    \"\"\"\n",
    "    Model to train word vector representations in numpy.\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input data, numpy array of sentences as strings, of shape (m,)\n",
    "    Y -- labels, numpy array of integers between 0 and 7, numpy-array of shape (m, 1)\n",
    "    word_to_vec_map -- dictionary mapping every word in a vocabulary into its 50-dimensional vector representation\n",
    "    learning_rate -- learning_rate for the stochastic gradient descent algorithm\n",
    "    num_iterations -- number of iterations\n",
    "    \n",
    "    Returns:\n",
    "    pred -- vector of predictions, numpy-array of shape (m, 1)\n",
    "    W -- weight matrix of the softmax layer, of shape (n_y, n_h)\n",
    "    b -- bias of the softmax layer, of shape (n_y,)\n",
    "    \"\"\"\n",
    "    \n",
    "    # Get a valid word contained in the word_to_vec_map\n",
    "    any_word = list(word_to_vec_map.keys())[0]\n",
    "        \n",
    "    # Define number of training examples\n",
    "    m = Y.shape[0]                             # number of training examples\n",
    "    n_y = len(np.unique(Y))                    # number of classes\n",
    "    n_h = word_to_vec_map[any_word].shape[0]   # dimensions of the GloVe vectors\n",
    "    \n",
    "    # Initialize parameters using Xavier initialization\n",
    "    W = np.random.randn(n_y, n_h) / np.sqrt(n_h)\n",
    "    b = np.zeros((n_y,))\n",
    "    \n",
    "    # Convert Y to Y_onehot with n_y classes\n",
    "    Y_oh = convert_to_one_hot(Y, C=n_y)\n",
    "    \n",
    "    # Optimization loop\n",
    "    for t in range(num_iterations): # Loop over the number of iterations\n",
    "        \n",
    "        cost = 0\n",
    "        dW = 0\n",
    "        db = 0\n",
    "        \n",
    "        for i in range(m):          # Loop over the training examples\n",
    "            \n",
    "            ### START CODE HERE ### (≈ 4 lines of code)\n",
    "            # Average the word vectors of the words from the i'th training example\n",
    "            avg = sentence_to_avg(X[i], word_to_vec_map)\n",
    "\n",
    "            # Forward propagate the avg through the softmax layer.\n",
    "            # You can use np.dot() to perform the multiplication.\n",
    "            z = np.dot(W, avg) + b\n",
    "            a = softmax(z)\n",
    "\n",
    "            # Add the cost using the i'th training label's one hot representation and \"A\" (the output of the softmax)\n",
    "            cost += -np.sum(Y_oh[i] * np.log(a))\n",
    "            ### END CODE HERE ###\n",
    "            \n",
    "            # Compute gradients\n",
    "            dz = a - Y_oh[i]\n",
    "            dW += np.dot(dz.reshape(n_y, 1), avg.reshape(1, n_h))\n",
    "            db += dz\n",
    "\n",
    "        # Update parameters with Stochastic Gradient Descent\n",
    "        W = W - learning_rate * dW\n",
    "        b = b - learning_rate * db\n",
    "\n",
    "        assert type(cost) == np.float64, \"Incorrect implementation of cost\"\n",
    "        assert cost.shape == (), \"Incorrect implementation of cost\"\n",
    "        \n",
    "        if t % 100 == 0:\n",
    "            print(\"Epoch: \" + str(t) + \" --- cost = \" + str(cost))\n",
    "            pred = predict(X, Y, W, b, word_to_vec_map)  # predict is defined in emo_utils.py\n",
    "\n",
    "    return pred, W, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 --- cost = 2.6440537448584243\n",
      "Accuracy: 0.9166666666666666\n",
      "Epoch: 100 --- cost = 0.9513004527285976\n",
      "Accuracy: 1.0\n",
      "\u001b[92mAll tests passed!\n"
     ]
    }
   ],
   "source": [
    "### YOU CANNOT EDIT THIS CELL\n",
    "\n",
    "# UNIT TEST\n",
    "def model_test(target):\n",
    "    # Create a controlled word to vec map\n",
    "    word_to_vec_map = {'a': [3, 3], 'synonym_of_a': [3, 3], 'a_nw': [2, 4], 'a_s': [3, 2], 'a_n': [3, 4], \n",
    "                       'c': [-2, 1], 'c_n': [-2, 2],'c_ne': [-1, 2], 'c_e': [-1, 1], 'c_se': [-1, 0], \n",
    "                       'c_s': [-2, 0], 'c_sw': [-3, 0], 'c_w': [-3, 1], 'c_nw': [-3, 2]\n",
    "                      }\n",
    "    # Convert lists to np.arrays\n",
    "    for key in word_to_vec_map.keys():\n",
    "        word_to_vec_map[key] = np.array(word_to_vec_map[key])\n",
    "        \n",
    "    # Training set. Sentences composed of a_* words will be of class 0 and sentences composed of c_* words will be of class 1\n",
    "    X = np.asarray(['a a_s synonym_of_a a_n c_sw', 'a a_s a_n c_sw', 'a_s  a a_n', 'synonym_of_a a a_s a_n c_sw', \" a_s a_n\",\n",
    "                    \" a a_s a_n c \", \" a_n  a c c c_e\",\n",
    "                   'c c_nw c_n c c_ne', 'c_e c c_se c_s', 'c_nw c a_s c_e c_e', 'c_e a_nw c_sw', 'c_sw c c_ne c_ne'])\n",
    "    \n",
    "    Y = np.asarray([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1])\n",
    "    \n",
    "    np.random.seed(10)\n",
    "    pred, W, b = model(X, Y, word_to_vec_map, 0.0025, 110)\n",
    "    \n",
    "    assert W.shape == (2, 2), \"W must be of shape 2 x 2\"\n",
    "    assert np.allclose(pred.transpose(), Y), \"Model must give a perfect accuracy\"\n",
    "    assert np.allclose(b[0], -1 * b[1]), \"b should be symmetric in this example\"\n",
    "    \n",
    "    print(\"\\033[92mAll tests passed!\")\n",
    "    \n",
    "model_test(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KvdG05pgcFIw"
   },
   "source": [
    "Run the next cell to train your model and learn the softmax parameters (W, b). **The training process will take about 5 minutes**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 3817,
     "status": "ok",
     "timestamp": 1611738757775,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "umWTqRcpcFIw",
    "outputId": "7b74cb94-e98c-4936-98bc-693a3bb5f34e",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 --- cost = 247.9500402470817\n",
      "Accuracy: 0.30303030303030304\n",
      "Epoch: 100 --- cost = 108.39718728483135\n",
      "Accuracy: 0.7575757575757576\n",
      "Epoch: 200 --- cost = 38.31279044664706\n",
      "Accuracy: 0.9166666666666666\n",
      "Epoch: 300 --- cost = 28.085812850591257\n",
      "Accuracy: 0.9696969696969697\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(1)\n",
    "pred, W, b = model(X_train, Y_train, word_to_vec_map)\n",
    "# print(pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ygumNDIUcFIx"
   },
   "source": [
    "Great! Now see how it does on the test set:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O862gcUicFIx"
   },
   "source": [
    "<a name='1-5'></a>\n",
    "### 1.5 - Examining Test Set Performance \n",
    "\n",
    "Note that the `predict` function used here is defined in `emo_util.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 3704,
     "status": "ok",
     "timestamp": 1611738776291,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "yhb6CzhrcFIx",
    "outputId": "08d07fd0-55c2-4eff-d570-2562deb0570b",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set:\n",
      "Accuracy: 0.9696969696969697\n",
      "Test set:\n",
      "Accuracy: 0.875\n"
     ]
    }
   ],
   "source": [
    "print(\"Training set:\")\n",
    "pred_train = predict(X_train, Y_train, W, b, word_to_vec_map)\n",
    "print('Test set:')\n",
    "pred_test = predict(X_test, Y_test, W, b, word_to_vec_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hwmrm-aDcFIy"
   },
   "source": [
    "**Note**:\n",
    "* Random guessing would have had 20% accuracy, given that there are 5 classes. (1/5 = 20%).\n",
    "* This is pretty good performance after training on only 127 examples. \n",
    "\n",
    "\n",
    "#### The Model Matches Emojis to Relevant Words\n",
    "In the training set, the algorithm saw the sentence \n",
    ">\"I love you.\" \n",
    "\n",
    "with the label ❤️. \n",
    "* You can check that the word \"treasure\" does not appear in the training set. \n",
    "* Nonetheless, let's see what happens if you write \"I treasure you.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 1909,
     "status": "ok",
     "timestamp": 1611738785398,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "tvCl7fUvcFIz",
    "outputId": "a3913da3-85df-466d-dd8f-520245d495fc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.8333333333333334\n",
      "\n",
      "i treasure you ❤️\n",
      "i love you ❤️\n",
      "funny lol 😄\n",
      "lets play with a ball ⚾\n",
      "food is ready 🍴\n",
      "today is not good 😄\n"
     ]
    }
   ],
   "source": [
    "X_my_sentences = np.array([\"i treasure you\", \"i love you\", \"funny lol\", \"lets play with a ball\", \"food is ready\", \"today is not good\"])\n",
    "Y_my_labels = np.array([[0], [0], [2], [1], [4],[3]])\n",
    "\n",
    "pred = predict(X_my_sentences, Y_my_labels , W, b, word_to_vec_map)\n",
    "print_predictions(X_my_sentences, pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZyC-BGqKcFI0"
   },
   "source": [
    "Amazing! \n",
    "* Because *treasure* has a similar embedding as *love*, the algorithm has generalized correctly even to a word it has never seen before. \n",
    "* Words such as *heart*, *dear*, *beloved* or *adore* have embedding vectors similar to *love*. \n",
    "    * Feel free to modify the inputs above and try out a variety of input sentences. \n",
    "    * How well does it work?\n",
    "\n",
    "#### Word Ordering isn't Considered in this Model\n",
    "* Note that the model doesn't get the following sentence correct:\n",
    ">\"today is not good\" \n",
    "\n",
    "* This algorithm ignores word ordering, so is not good at understanding phrases like \"not good.\" \n",
    "\n",
    "#### Confusion Matrix\n",
    "* Printing the confusion matrix can also help understand which classes are more difficult for your model. \n",
    "* A confusion matrix shows how often an example whose label is one class (\"actual\" class) is mislabeled by the algorithm with a different class (\"predicted\" class).\n",
    "\n",
    "Print the confusion matrix below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 433
    },
    "executionInfo": {
     "elapsed": 2061,
     "status": "ok",
     "timestamp": 1611738816883,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "Ab9aH9IQcFI1",
    "outputId": "d8cfc4cc-bbdc-487b-8efc-3d9a3cdbdd06"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(56,)\n",
      "           ❤️    ⚾    😄    😞   🍴\n",
      "Predicted  0.0  1.0  2.0  3.0  4.0  All\n",
      "Actual                                 \n",
      "0            6    0    0    1    0    7\n",
      "1            0    8    0    0    0    8\n",
      "2            1    0   17    0    0   18\n",
      "3            1    0    2   13    0   16\n",
      "4            0    0    2    0    5    7\n",
      "All          8    8   21   14    5   56\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# START SKIP FOR GRADING\n",
    "print(Y_test.shape)\n",
    "print('           '+ label_to_emoji(0)+ '    ' + label_to_emoji(1) + '    ' +  label_to_emoji(2)+ '    ' + label_to_emoji(3)+'   ' + label_to_emoji(4))\n",
    "print(pd.crosstab(Y_test, pred_test.reshape(56,), rownames=['Actual'], colnames=['Predicted'], margins=True))\n",
    "plot_confusion_matrix(Y_test, pred_test)\n",
    "# END SKIP FOR GRADING"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Zm2o8SQIcFI1"
   },
   "source": [
    "<font color='blue'><b>What you should remember:</b>\n",
    "- Even with a mere 127 training examples, you can get a reasonably good model for Emojifying. \n",
    "    - This is due to the generalization power word vectors gives you. \n",
    "- Emojify-V1 will perform poorly on sentences such as *\"This movie is not good and not enjoyable\"* \n",
    "    - It doesn't understand combinations of words.\n",
    "    - It just averages all the words' embedding vectors together, without considering the ordering of words. \n",
    "</font>\n",
    "    \n",
    "**Not to worry! You will build a better algorithm in the next section!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BEeTqpjlcFI2"
   },
   "source": [
    "<a name='2'></a>\n",
    "## 2 - Emojifier-V2: Using LSTMs in Keras \n",
    "\n",
    "You're going to build an LSTM model that takes word **sequences** as input! This model will be able to account for word ordering. \n",
    "\n",
    "Emojifier-V2 will continue to use pre-trained word embeddings to represent words. You'll feed word embeddings into an LSTM, and the LSTM will learn to predict the most appropriate emoji. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CPIihtFVFEbz"
   },
   "source": [
    "### Packages\n",
    "\n",
    "Run the following cell to load the Keras packages you'll need:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "executionInfo": {
     "elapsed": 2501,
     "status": "ok",
     "timestamp": 1611738953388,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "uZ-fy9fYcFI3"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow\n",
    "np.random.seed(0)\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Dense, Input, Dropout, LSTM, Activation\n",
    "from tensorflow.keras.layers import Embedding\n",
    "from tensorflow.keras.preprocessing import sequence\n",
    "from tensorflow.keras.initializers import glorot_uniform\n",
    "np.random.seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "P7LJvriXcFI3"
   },
   "source": [
    "<a name='2-1'></a>\n",
    "### 2.1 - Model Overview\n",
    "\n",
    "Here is the Emojifier-v2 you will implement:\n",
    "\n",
    "<img src=\"images/emojifier-v2.png\" style=\"width:700px;height:400px;\"> <br>\n",
    "<caption><center><font color='purple'><b>Figure 3</b>: Emojifier-V2. A 2-layer LSTM sequence classifier. </center></caption>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-3W3WTbpcFI3"
   },
   "source": [
    "<a name='2-2'></a>\n",
    "### 2.2 Keras and Mini-batching \n",
    "\n",
    "In this exercise, you want to train Keras using mini-batches. However, most deep learning frameworks require that all sequences in the same mini-batch have the **same length**. \n",
    "\n",
    "This is what allows vectorization to work: If you had a 3-word sentence and a 4-word sentence, then the computations needed for them are different (one takes 3 steps of an LSTM, one takes 4 steps) so it's just not possible to do them both at the same time.\n",
    "    \n",
    "#### Padding Handles Sequences of Varying Length\n",
    "* The common solution to handling sequences of **different length** is to use padding.  Specifically:\n",
    "    * Set a maximum sequence length\n",
    "    * Pad all sequences to have the same length. \n",
    "    \n",
    "#### Example of Padding:\n",
    "* Given a maximum sequence length of 20, you could pad every sentence with \"0\"s so that each input sentence is of length 20. \n",
    "* Thus, the sentence \"I love you\" would be represented as $(e_{I}, e_{love}, e_{you}, \\vec{0}, \\vec{0}, \\ldots, \\vec{0})$. \n",
    "* In this example, any sentences longer than 20 words would have to be truncated. \n",
    "* One way to choose the maximum sequence length is to just pick the length of the longest sentence in the training set. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QuwbNWS0cFI4"
   },
   "source": [
    "<a name='2-3'></a>\n",
    "### 2.3 - The Embedding Layer\n",
    "\n",
    "In Keras, the embedding matrix is represented as a \"layer.\"\n",
    "\n",
    "* The embedding matrix maps word indices to embedding vectors.\n",
    "    * The word indices are positive integers.\n",
    "    * The embedding vectors are dense vectors of fixed size.\n",
    "    * A \"dense\" vector is the opposite of a sparse vector. It means that most of its values are non-zero.  As a counter-example, a one-hot encoded vector is not \"dense.\"\n",
    "* The embedding matrix can be derived in two ways:\n",
    "    * Training a model to derive the embeddings from scratch. \n",
    "    * Using a pretrained embedding.\n",
    "    \n",
    "#### Using and Updating Pre-trained Embeddings\n",
    "In this section, you'll create an [Embedding()](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Embedding) layer in Keras\n",
    "\n",
    "* You will initialize the Embedding layer with GloVe 50-dimensional vectors. \n",
    "* In the code below, you'll observe how Keras allows you to either train or leave this layer fixed.  \n",
    "    * Because your training set is quite small, you'll leave the GloVe embeddings fixed instead of updating them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zhyVzuThcFI4"
   },
   "source": [
    "#### Inputs and Outputs to the Embedding Layer\n",
    "\n",
    "* The `Embedding()` layer's input is an integer matrix of size **(batch size, max input length)**. \n",
    "    * This input corresponds to sentences converted into lists of indices (integers).\n",
    "    * The largest integer (the highest word index) in the input should be no larger than the vocabulary size.\n",
    "* The embedding layer outputs an array of shape (batch size, max input length, dimension of word vectors).\n",
    "\n",
    "* The figure shows the propagation of two example sentences through the embedding layer. \n",
    "    * Both examples have been zero-padded to a length of `max_len=5`.\n",
    "    * The word embeddings are 50 units in length.\n",
    "    * The final dimension of the representation is  `(2,max_len,50)`. \n",
    "\n",
    "<img src=\"images/embedding1.png\" style=\"width:700px;height:250px;\">\n",
    "<caption><center><font color='purple'><b>Figure 4</b>: Embedding layer</center></caption>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KnoTtNWBcFI5"
   },
   "source": [
    "#### Prepare the Input Sentences\n",
    "\n",
    "<a name='ex-3'></a>\n",
    "### Exercise 3 - sentences_to_indices\n",
    "\n",
    "Implement `sentences_to_indices`\n",
    "\n",
    "This function processes an array of sentences X and returns inputs to the embedding layer:\n",
    "\n",
    "* Convert each training sentences into a list of indices (the indices correspond to each word in the sentence)\n",
    "* Zero-pad all these lists so that their length is the length of the longest sentence.\n",
    "    \n",
    "#### Additional Hints:\n",
    "* Note that you may have considered using the `enumerate()` function in the for loop, but for the purposes of passing the autograder, please follow the starter code by initializing and incrementing `j` explicitly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 2291,
     "status": "ok",
     "timestamp": 1611738965576,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "8cMm64iWcFI5",
    "outputId": "f82cb8b2-991c-44ae-9c81-7a5235edeea2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 I\n",
      "1 like\n",
      "2 learning\n"
     ]
    }
   ],
   "source": [
    "for idx, val in enumerate([\"I\", \"like\", \"learning\"]):\n",
    "    print(idx, val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "executionInfo": {
     "elapsed": 2881,
     "status": "ok",
     "timestamp": 1611738972334,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "Z0SixlIwcFI5"
   },
   "outputs": [],
   "source": [
    "# UNQ_C3 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED FUNCTION: sentences_to_indices\n",
    "def sentences_to_indices(X, word_to_index, max_len):\n",
    "    \"\"\"\n",
    "    Converts an array of sentences (strings) into an array of indices corresponding to words in the sentences.\n",
    "    The output shape should be such that it can be given to `Embedding()` (described in Figure 4). \n",
    "    \n",
    "    Arguments:\n",
    "    X -- array of sentences (strings), of shape (m,)\n",
    "    word_to_index -- a dictionary containing each word mapped to its index\n",
    "    max_len -- maximum number of words in a sentence. You can assume every sentence in X is no longer than this. \n",
    "    \n",
    "    Returns:\n",
    "    X_indices -- array of indices corresponding to words in the sentences from X, of shape (m, max_len)\n",
    "    \"\"\"\n",
    "    \n",
    "    m = X.shape[0]                                   # number of training examples\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    # Initialize X_indices as a numpy matrix of zeros and the correct shape (≈ 1 line)\n",
    "    X_indices = np.zeros((m, max_len))\n",
    "    \n",
    "    for i in range(m):                               # loop over training examples\n",
    "        \n",
    "        # Convert the ith training sentence in lower case and split it into words. You should get a list of words.\n",
    "        sentence_words = X[i].lower().split()\n",
    "        \n",
    "        # Initialize j to 0\n",
    "        j = 0\n",
    "        \n",
    "        # Loop over the words of sentence_words\n",
    "        for w in sentence_words:\n",
    "            # if w exists in the word_to_index dictionary\n",
    "            if w in word_to_index:\n",
    "                # Set the (i,j)th entry of X_indices to the index of the correct word.\n",
    "                X_indices[i, j] = word_to_index[w]\n",
    "                # Increment j to j + 1\n",
    "                j += 1\n",
    "            \n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return X_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2. 4. 3.]\n",
      " [4. 8. 6. 5.]\n",
      " [5. 3. 7. 0.]\n",
      " [0. 0. 0. 0.]]\n",
      "\u001b[92mAll tests passed!\n"
     ]
    }
   ],
   "source": [
    "### YOU CANNOT EDIT THIS CELL\n",
    "\n",
    "# UNIT TEST\n",
    "def sentences_to_indices_test(target):\n",
    "    \n",
    "    # Create a word_to_index dictionary\n",
    "    word_to_index = {}\n",
    "    for idx, val in enumerate([\"i\", \"like\", \"learning\", \"deep\", \"machine\", \"love\", \"smile\", '´0.=']):\n",
    "        word_to_index[val] = idx + 1;\n",
    "       \n",
    "    max_len = 4\n",
    "    sentences = np.array([\"I like deep learning\", \"deep ´0.= love machine\", \"machine learning smile\", \"$\"]);\n",
    "    indexes = target(sentences, word_to_index, max_len)\n",
    "    print(indexes)\n",
    "    \n",
    "    assert type(indexes) == np.ndarray, \"Wrong type. Use np arrays in the function\"\n",
    "    assert indexes.shape == (sentences.shape[0], max_len), \"Wrong shape of ouput matrix\"\n",
    "    assert np.allclose(indexes, [[1, 2, 4, 3],\n",
    "                                 [4, 8, 6, 5],\n",
    "                                 [5, 3, 7, 0],\n",
    "                                 [0, 0, 0, 0]]), \"Wrong values. Debug with the given examples\"\n",
    "    \n",
    "    print(\"\\033[92mAll tests passed!\")\n",
    "    \n",
    "sentences_to_indices_test(sentences_to_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected value**\n",
    "\n",
    "```\n",
    "[[1. 2. 4. 3.]\n",
    " [4. 8. 6. 5.]\n",
    " [5. 3. 7. 0.]\n",
    " [0. 0. 0. 0.]]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "reyHmseecFI6"
   },
   "source": [
    "Run the following cell to check what `sentences_to_indices()` does, and take a look at your results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 1992,
     "status": "ok",
     "timestamp": 1611738982161,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "oBL1PMOCcFI6",
    "outputId": "6781359c-bafd-4ab5-a477-f8a5a86ea219"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X1 = ['funny lol' 'lets play baseball' 'food is ready for you']\n",
      "X1_indices =\n",
      " [[155345. 225122.      0.      0.      0.]\n",
      " [220930. 286375.  69714.      0.      0.]\n",
      " [151204. 192973. 302254. 151349. 394475.]]\n"
     ]
    }
   ],
   "source": [
    "X1 = np.array([\"funny lol\", \"lets play baseball\", \"food is ready for you\"])\n",
    "X1_indices = sentences_to_indices(X1, word_to_index, max_len=5)\n",
    "print(\"X1 =\", X1)\n",
    "print(\"X1_indices =\\n\", X1_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0OJPAEM5cFI6"
   },
   "source": [
    "#### Build Embedding Layer\n",
    "\n",
    "Now you'll build the `Embedding()` layer in Keras, using pre-trained word vectors. \n",
    "\n",
    "* The embedding layer takes as input a list of word indices.\n",
    "    * `sentences_to_indices()` creates these word indices.\n",
    "* The embedding layer will return the word embeddings for a sentence. \n",
    "\n",
    "<a name='ex-4'></a>\n",
    "### Exercise 4 - pretrained_embedding_layer\n",
    "\n",
    "Implement `pretrained_embedding_layer()` with these steps:\n",
    "\n",
    "1. Initialize the embedding matrix as a numpy array of zeros.\n",
    "    * The embedding matrix has a row for each unique word in the vocabulary.\n",
    "        * There is one additional row to handle \"unknown\" words.\n",
    "        * So vocab_size is the number of unique words plus one.\n",
    "    * Each row will store the vector representation of one word. \n",
    "        * For example, one row may be 50 positions long if using GloVe word vectors.\n",
    "    * In the code below, `emb_dim` represents the length of a word embedding.\n",
    "2. Fill in each row of the embedding matrix with the vector representation of a word\n",
    "    * Each word in `word_to_index` is a string.\n",
    "    * word_to_vec_map is a dictionary where the keys are strings and the values are the word vectors.\n",
    "3. Define the Keras embedding layer. \n",
    "    * Use [Embedding()](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Embedding). \n",
    "    * The input dimension is equal to the vocabulary length (number of unique words plus one).\n",
    "    * The output dimension is equal to the number of positions in a word embedding.\n",
    "    * Make this layer's embeddings fixed.\n",
    "        * If you were to set `trainable = True`, then it will allow the optimization algorithm to modify the values of the word embeddings.\n",
    "        * In this case, you don't want the model to modify the word embeddings.\n",
    "4. Set the embedding weights to be equal to the embedding matrix.\n",
    "    * Note that this is part of the code is already completed for you and does not need to be modified! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "executionInfo": {
     "elapsed": 2160,
     "status": "ok",
     "timestamp": 1611738992486,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "XBlEpiVkcFI7"
   },
   "outputs": [],
   "source": [
    "# UNQ_C4 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED FUNCTION: pretrained_embedding_layer\n",
    "def pretrained_embedding_layer(word_to_vec_map, word_to_index):\n",
    "    \"\"\"\n",
    "    Creates a Keras Embedding() layer and loads in pre-trained GloVe 50-dimensional vectors.\n",
    "    \n",
    "    Arguments:\n",
    "    word_to_vec_map -- dictionary mapping words to their GloVe vector representation.\n",
    "    word_to_index -- dictionary mapping from words to their indices in the vocabulary (400,001 words)\n",
    "\n",
    "    Returns:\n",
    "    embedding_layer -- pretrained layer Keras instance\n",
    "    \"\"\"\n",
    "    \n",
    "    vocab_size = len(word_to_index) + 1              # adding 1 to fit Keras embedding (requirement)\n",
    "    any_word = list(word_to_vec_map.keys())[0]\n",
    "    emb_dim = word_to_vec_map[any_word].shape[0]    # define dimensionality of your GloVe word vectors (= 50)\n",
    "      \n",
    "    ### START CODE HERE ###\n",
    "    # Step 1\n",
    "    # Initialize the embedding matrix as a numpy array of zeros.\n",
    "    # See instructions above to choose the correct shape.\n",
    "    emb_matrix = np.zeros((vocab_size, emb_dim))\n",
    "    \n",
    "    # Step 2\n",
    "    # Set each row \"idx\" of the embedding matrix to be \n",
    "    # the word vector representation of the idx'th word of the vocabulary\n",
    "    for word, idx in word_to_index.items():\n",
    "        emb_matrix[idx, :] = word_to_vec_map[word]\n",
    "\n",
    "    # Step 3\n",
    "    # Define Keras embedding layer with the correct input and output sizes\n",
    "    # Make it non-trainable.\n",
    "    embedding_layer = Embedding(input_dim=vocab_size, output_dim=emb_dim, trainable=False)\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # Step 4 (already done for you; please do not modify)\n",
    "    # Build the embedding layer, it is required before setting the weights of the embedding layer. \n",
    "    embedding_layer.build((None,)) # Do not modify the \"None\".  This line of code is complete as-is.\n",
    "    \n",
    "    # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\n",
    "    embedding_layer.set_weights([emb_matrix])\n",
    "    \n",
    "    return embedding_layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[92mAll tests passed!\n"
     ]
    }
   ],
   "source": [
    "### YOU CANNOT EDIT THIS CELL\n",
    "\n",
    "# UNIT TEST\n",
    "def pretrained_embedding_layer_test(target):\n",
    "    # Create a controlled word to vec map\n",
    "    word_to_vec_map = {'a': [3, 3], 'synonym_of_a': [3, 3], 'a_nw': [2, 4], 'a_s': [3, 2], 'a_n': [3, 4], \n",
    "                       'c': [-2, 1], 'c_n': [-2, 2],'c_ne': [-1, 2], 'c_e': [-1, 1], 'c_se': [-1, 0], \n",
    "                       'c_s': [-2, 0], 'c_sw': [-3, 0], 'c_w': [-3, 1], 'c_nw': [-3, 2]\n",
    "                      }\n",
    "    # Convert lists to np.arrays\n",
    "    for key in word_to_vec_map.keys():\n",
    "        word_to_vec_map[key] = np.array(word_to_vec_map[key])\n",
    "        \n",
    "    # Create a word_to_index dictionary\n",
    "    word_to_index = {}\n",
    "    for idx, val in enumerate(list(word_to_vec_map.keys())):\n",
    "        word_to_index[val] = idx;\n",
    "        \n",
    "    np.random.seed(1)\n",
    "    embedding_layer = target(word_to_vec_map, word_to_index)\n",
    "    \n",
    "    assert type(embedding_layer) == Embedding, \"Wrong type\"\n",
    "    assert embedding_layer.input_dim == len(list(word_to_vec_map.keys())) + 1, \"Wrong input shape\"\n",
    "    assert embedding_layer.output_dim == len(word_to_vec_map['a']), \"Wrong output shape\"\n",
    "    assert np.allclose(embedding_layer.get_weights(), \n",
    "                       [[[ 3, 3], [ 3, 3], [ 2, 4], [ 3, 2], [ 3, 4],\n",
    "                       [-2, 1], [-2, 2], [-1, 2], [-1, 1], [-1, 0],\n",
    "                       [-2, 0], [-3, 0], [-3, 1], [-3, 2], [ 0, 0]]]), \"Wrong vaulues\"\n",
    "    print(\"\\033[92mAll tests passed!\")\n",
    "       \n",
    "    \n",
    "pretrained_embedding_layer_test(pretrained_embedding_layer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6068,
     "status": "ok",
     "timestamp": 1611739002394,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "Gn4iGb0AcFI7",
    "outputId": "5bab44b5-bf23-4c6e-f891-429e8be34981"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weights[0][1][1] = 0.39031\n",
      "Input_dim 400001\n",
      "Output_dim 50\n"
     ]
    }
   ],
   "source": [
    "embedding_layer = pretrained_embedding_layer(word_to_vec_map, word_to_index)\n",
    "print(\"weights[0][1][1] =\", embedding_layer.get_weights()[0][1][1])\n",
    "print(\"Input_dim\", embedding_layer.input_dim)\n",
    "print(\"Output_dim\",embedding_layer.output_dim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uEsWnZ_2cFI7"
   },
   "source": [
    "<a name='2-4'></a>\n",
    "### 2.4 - Building the Emojifier-V2\n",
    "\n",
    "Now you're ready to build the Emojifier-V2 model, in which you feed the embedding layer's output to an LSTM network!\n",
    "\n",
    "<img src=\"images/emojifier-v2.png\" style=\"width:700px;height:400px;\"> <br>\n",
    "<caption><center><font color='purple'><b>Figure 3</b>: Emojifier-v2. A 2-layer LSTM sequence classifier. </center></caption></font> \n",
    "\n",
    "\n",
    "<a name='ex-5'></a>\n",
    "### Exercise 5 - Emojify_V2\n",
    "\n",
    "Implement `Emojify_V2()`\n",
    "\n",
    "This function builds a Keras graph of the architecture shown in Figure (3). \n",
    "\n",
    "* The model takes as input an array of sentences of shape (`m`, `max_len`, ) defined by `input_shape`. \n",
    "* The model outputs a softmax probability vector of shape (`m`, `C = 5`). \n",
    "\n",
    "* You may need to use the following Keras layers:\n",
    "    * [Input()](https://www.tensorflow.org/api_docs/python/tf/keras/Input)\n",
    "        * Set the `shape` and `dtype` parameters.\n",
    "        * The inputs are integers, so you can specify the data type as a string, 'int32'.\n",
    "    * [LSTM()](https://www.tensorflow.org/api_docs/python/tf/keras/layers/LSTM)\n",
    "        * Set the `units` and `return_sequences` parameters.\n",
    "    * [Dropout()](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dropout)\n",
    "        * Set the `rate` parameter.\n",
    "    * [Dense()](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dense)\n",
    "        * Set the `units`, \n",
    "        * Note that `Dense()` has an `activation` parameter.  For the purposes of passing the autograder, please do not set the activation within `Dense()`.  Use the separate `Activation` layer to do so.\n",
    "    * [Activation()](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Activation)\n",
    "        * You can pass in the activation of your choice as a lowercase string.\n",
    "    * [Model()](https://www.tensorflow.org/api_docs/python/tf/keras/Model)\n",
    "        * Set `inputs` and `outputs`.\n",
    "\n",
    "\n",
    "#### Additional Hints\n",
    "* Remember that these Keras layers return an object, and you will feed in the outputs of the previous layer as the input arguments to that object.  The returned object can be created and called in the same line.\n",
    "\n",
    "```Python\n",
    "# How to use Keras layers in two lines of code\n",
    "dense_object = Dense(units = ...)\n",
    "X = dense_object(inputs)\n",
    "\n",
    "# How to use Keras layers in one line of code\n",
    "X = Dense(units = ...)(inputs)\n",
    "```\n",
    "\n",
    "* The `embedding_layer` that is returned by `pretrained_embedding_layer` is a layer object that can be called as a function, passing in a single argument (sentence indices).\n",
    "\n",
    "* Here is some sample code in case you're stuck: 😊\n",
    "```Python\n",
    "raw_inputs = Input(shape=(maxLen,), dtype='int32')\n",
    "preprocessed_inputs = ... # some pre-processing\n",
    "X = LSTM(units = ..., return_sequences= ...)(processed_inputs)\n",
    "X = Dropout(rate = ..., )(X)\n",
    "...\n",
    "X = Dense(units = ...)(X)\n",
    "X = Activation(...)(X)\n",
    "model = Model(inputs=..., outputs=...)\n",
    "...\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "executionInfo": {
     "elapsed": 3214,
     "status": "ok",
     "timestamp": 1611739012958,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "Pb2ugsSUcFI7"
   },
   "outputs": [],
   "source": [
    "# UNQ_C5 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED FUNCTION: Emojify_V2\n",
    "def Emojify_V2(input_shape, word_to_vec_map, word_to_index):\n",
    "    \"\"\"\n",
    "    Function creating the Emojify-v2 model's graph.\n",
    "    \n",
    "    Arguments:\n",
    "    input_shape -- shape of the input, usually (max_len,)\n",
    "    word_to_vec_map -- dictionary mapping every word in a vocabulary into its 50-dimensional vector representation\n",
    "    word_to_index -- dictionary mapping from words to their indices in the vocabulary (400,001 words)\n",
    "\n",
    "    Returns:\n",
    "    model -- a model instance in Keras\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    # Define sentence_indices as the input of the graph.\n",
    "    # It should be of shape input_shape and dtype 'int32' (as it contains indices, which are integers).\n",
    "    sentence_indices = Input(shape=input_shape, dtype='int32')\n",
    "    \n",
    "    # Create the embedding layer pretrained with GloVe Vectors (≈1 line)\n",
    "    embedding_layer = pretrained_embedding_layer(word_to_vec_map, word_to_index)\n",
    "    \n",
    "    # Propagate sentence_indices through your embedding layer\n",
    "    # (See additional hints in the instructions).\n",
    "    embeddings = embedding_layer(sentence_indices)\n",
    "    \n",
    "    # Propagate the embeddings through an LSTM layer with 128-dimensional hidden state\n",
    "    # The returned output should be a batch of sequences.\n",
    "    X = LSTM(128, return_sequences=True)(embeddings)\n",
    "    # Add dropout with a probability of 0.5\n",
    "    X = Dropout(0.5)(X)\n",
    "    # Propagate X through another LSTM layer with 128-dimensional hidden state\n",
    "    # The returned output should be a single hidden state, not a batch of sequences.\n",
    "    X = LSTM(128, return_sequences=False)(X)\n",
    "    # Add dropout with a probability of 0.5\n",
    "    X = Dropout(0.5)(X)\n",
    "    # Propagate X through a Dense layer with 5 units\n",
    "    X = Dense(5)(X)\n",
    "    # Add a softmax activation\n",
    "    X = Activation('softmax')(X)\n",
    "    \n",
    "    # Create Model instance which converts sentence_indices into X.\n",
    "    model = Model(inputs=sentence_indices, outputs=X)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[32mAll tests passed!\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "### YOU CANNOT EDIT THIS CELL\n",
    "\n",
    "# UNIT TEST\n",
    "from tensorflow.python.keras.engine.functional import Functional\n",
    "\n",
    "def Emojify_V2_test(target):\n",
    "    # Create a controlled word to vec map\n",
    "    word_to_vec_map = {'a': [3, 3], 'synonym_of_a': [3, 3], 'a_nw': [2, 4], 'a_s': [3, 2], 'a_n': [3, 4], \n",
    "                       'c': [-2, 1], 'c_n': [-2, 2],'c_ne': [-1, 2], 'c_e': [-1, 1], 'c_se': [-1, 0], \n",
    "                       'c_s': [-2, 0], 'c_sw': [-3, 0], 'c_w': [-3, 1], 'c_nw': [-3, 2]\n",
    "                      }\n",
    "    # Convert lists to np.arrays\n",
    "    for key in word_to_vec_map.keys():\n",
    "        word_to_vec_map[key] = np.array(word_to_vec_map[key])\n",
    "        \n",
    "    # Create a word_to_index dictionary\n",
    "    word_to_index = {}\n",
    "    for idx, val in enumerate(list(word_to_vec_map.keys())):\n",
    "        word_to_index[val] = idx;\n",
    "        \n",
    "    maxLen = 4\n",
    "    model = target((maxLen,), word_to_vec_map, word_to_index)\n",
    "    \n",
    "    assert type(model) == Functional, \"Make sure you have correctly created Model instance which converts \\\"sentence_indices\\\" into \\\"X\\\"\"\n",
    "    \n",
    "    expectedModel = [['InputLayer', [(None, 4)], 0], ['Embedding', (None, 4, 2), 30], ['LSTM', (None, 4, 128), 67072, (None, 4, 2), 'tanh', True], ['Dropout', (None, 4, 128), 0, 0.5], ['LSTM', (None, 128), 131584, (None, 4, 128), 'tanh', False], ['Dropout', (None, 128), 0, 0.5], ['Dense', (None, 5), 645, 'linear'], ['Activation', (None, 5), 0]]\n",
    "    comparator(summary(model), expectedModel)\n",
    "    \n",
    "    \n",
    "Emojify_V2_test(Emojify_V2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-VamRAKtcFI8"
   },
   "source": [
    "Run the following cell to create your model and check its summary. \n",
    "\n",
    "* Because all sentences in the dataset are less than 10 words, `max_len = 10` was chosen.  \n",
    "* You should see that your architecture uses 20,223,927 parameters, of which 20,000,050 (the word embeddings) are non-trainable, with the remaining 223,877 being trainable. \n",
    "* Because your vocabulary size has 400,001 words (with valid indices from 0 to 400,000) there are 400,001\\*50 = 20,000,050 non-trainable parameters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 3127,
     "status": "ok",
     "timestamp": 1611739019596,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "8fLhXJ9ucFI8",
    "outputId": "02d98359-a43b-4780-bb17-3d36e060aa86",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"functional_3\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_2 (InputLayer)         [(None, 10)]              0         \n",
      "_________________________________________________________________\n",
      "embedding_3 (Embedding)      (None, 10, 50)            20000050  \n",
      "_________________________________________________________________\n",
      "lstm_2 (LSTM)                (None, 10, 128)           91648     \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 10, 128)           0         \n",
      "_________________________________________________________________\n",
      "lstm_3 (LSTM)                (None, 128)               131584    \n",
      "_________________________________________________________________\n",
      "dropout_3 (Dropout)          (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 5)                 645       \n",
      "_________________________________________________________________\n",
      "activation_1 (Activation)    (None, 5)                 0         \n",
      "=================================================================\n",
      "Total params: 20,223,927\n",
      "Trainable params: 223,877\n",
      "Non-trainable params: 20,000,050\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = Emojify_V2((maxLen,), word_to_vec_map, word_to_index)\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mKIsZqqicFI8"
   },
   "source": [
    "#### Compile the Model \n",
    "\n",
    "As usual, after creating your model in Keras, you need to compile it and define what loss, optimizer and metrics you want to use. Compile your model using `categorical_crossentropy` loss, `adam` optimizer and `['accuracy']` metrics:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "executionInfo": {
     "elapsed": 2041,
     "status": "ok",
     "timestamp": 1611739024847,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "aMf79f45cFI9"
   },
   "outputs": [],
   "source": [
    "model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mX6NORy7cFI9"
   },
   "source": [
    "<a name='2-5'></a>\n",
    "### 2.5 - Train the Model \n",
    "\n",
    "It's time to train your model! Your Emojifier-V2 `model` takes as input an array of shape (`m`, `max_len`) and outputs probability vectors of shape (`m`, `number of classes`). Thus, you have to convert X_train (array of sentences as strings) to X_train_indices (array of sentences as list of word indices), and Y_train (labels as indices) to Y_train_oh (labels as one-hot vectors)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "executionInfo": {
     "elapsed": 2284,
     "status": "ok",
     "timestamp": 1611739029525,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "UgsBnWQqcFI-"
   },
   "outputs": [],
   "source": [
    "X_train_indices = sentences_to_indices(X_train, word_to_index, maxLen)\n",
    "Y_train_oh = convert_to_one_hot(Y_train, C = 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9fMyo0vqcFI_"
   },
   "source": [
    "Fit the Keras model on `X_train_indices` and `Y_train_oh`, using `epochs = 50` and `batch_size = 32`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "id": "LtFpvyJicFI_",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/50\n",
      "5/5 [==============================] - 0s 37ms/step - loss: 1.5881 - accuracy: 0.2803\n",
      "Epoch 2/50\n",
      "5/5 [==============================] - 0s 40ms/step - loss: 1.4972 - accuracy: 0.3258\n",
      "Epoch 3/50\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 1.4407 - accuracy: 0.4773\n",
      "Epoch 4/50\n",
      "5/5 [==============================] - 0s 35ms/step - loss: 1.3325 - accuracy: 0.6061\n",
      "Epoch 5/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 1.2262 - accuracy: 0.5909\n",
      "Epoch 6/50\n",
      "5/5 [==============================] - 0s 24ms/step - loss: 1.0534 - accuracy: 0.5985\n",
      "Epoch 7/50\n",
      "5/5 [==============================] - 0s 34ms/step - loss: 0.9777 - accuracy: 0.5682\n",
      "Epoch 8/50\n",
      "5/5 [==============================] - 0s 33ms/step - loss: 1.0100 - accuracy: 0.5682\n",
      "Epoch 9/50\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 0.8852 - accuracy: 0.6515\n",
      "Epoch 10/50\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 0.8435 - accuracy: 0.6818\n",
      "Epoch 11/50\n",
      "5/5 [==============================] - 0s 35ms/step - loss: 0.7129 - accuracy: 0.6894\n",
      "Epoch 12/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 0.6949 - accuracy: 0.7727\n",
      "Epoch 13/50\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 0.6641 - accuracy: 0.7576\n",
      "Epoch 14/50\n",
      "5/5 [==============================] - 0s 35ms/step - loss: 0.6141 - accuracy: 0.7348\n",
      "Epoch 15/50\n",
      "5/5 [==============================] - 0s 21ms/step - loss: 0.4889 - accuracy: 0.8182\n",
      "Epoch 16/50\n",
      "5/5 [==============================] - 0s 25ms/step - loss: 0.4893 - accuracy: 0.8182\n",
      "Epoch 17/50\n",
      "5/5 [==============================] - 0s 34ms/step - loss: 0.4020 - accuracy: 0.8712\n",
      "Epoch 18/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 0.4400 - accuracy: 0.8333\n",
      "Epoch 19/50\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 0.3167 - accuracy: 0.9015\n",
      "Epoch 20/50\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 0.2664 - accuracy: 0.9015\n",
      "Epoch 21/50\n",
      "5/5 [==============================] - 0s 35ms/step - loss: 0.2436 - accuracy: 0.9318\n",
      "Epoch 22/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 0.2478 - accuracy: 0.9242\n",
      "Epoch 23/50\n",
      "5/5 [==============================] - 0s 24ms/step - loss: 0.2441 - accuracy: 0.9318\n",
      "Epoch 24/50\n",
      "5/5 [==============================] - 0s 34ms/step - loss: 0.2264 - accuracy: 0.9242\n",
      "Epoch 25/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 0.2439 - accuracy: 0.9470\n",
      "Epoch 26/50\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 0.2983 - accuracy: 0.9091\n",
      "Epoch 27/50\n",
      "5/5 [==============================] - 0s 34ms/step - loss: 0.7626 - accuracy: 0.8030\n",
      "Epoch 28/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 0.3761 - accuracy: 0.8864\n",
      "Epoch 29/50\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 0.3780 - accuracy: 0.8561\n",
      "Epoch 30/50\n",
      "5/5 [==============================] - 0s 35ms/step - loss: 0.3347 - accuracy: 0.8864\n",
      "Epoch 31/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 0.2951 - accuracy: 0.9167\n",
      "Epoch 32/50\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 0.2761 - accuracy: 0.9242\n",
      "Epoch 33/50\n",
      "5/5 [==============================] - 0s 35ms/step - loss: 0.2051 - accuracy: 0.9470\n",
      "Epoch 34/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 0.1764 - accuracy: 0.9545\n",
      "Epoch 35/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 0.1677 - accuracy: 0.9470\n",
      "Epoch 36/50\n",
      "5/5 [==============================] - 0s 34ms/step - loss: 0.1531 - accuracy: 0.9545\n",
      "Epoch 37/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 0.1596 - accuracy: 0.9470\n",
      "Epoch 38/50\n",
      "5/5 [==============================] - 0s 24ms/step - loss: 0.1144 - accuracy: 0.9773\n",
      "Epoch 39/50\n",
      "5/5 [==============================] - 0s 34ms/step - loss: 0.0892 - accuracy: 0.9848\n",
      "Epoch 40/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 0.0739 - accuracy: 0.9773\n",
      "Epoch 41/50\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 0.0702 - accuracy: 0.9697\n",
      "Epoch 42/50\n",
      "5/5 [==============================] - 0s 34ms/step - loss: 0.0530 - accuracy: 0.9924\n",
      "Epoch 43/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 0.0621 - accuracy: 0.9848\n",
      "Epoch 44/50\n",
      "5/5 [==============================] - 0s 24ms/step - loss: 0.0468 - accuracy: 0.9924\n",
      "Epoch 45/50\n",
      "5/5 [==============================] - 0s 34ms/step - loss: 0.0424 - accuracy: 0.9924\n",
      "Epoch 46/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 0.0418 - accuracy: 0.9924\n",
      "Epoch 47/50\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 0.0262 - accuracy: 0.9924\n",
      "Epoch 48/50\n",
      "5/5 [==============================] - 0s 34ms/step - loss: 0.0176 - accuracy: 0.9924\n",
      "Epoch 49/50\n",
      "5/5 [==============================] - 0s 22ms/step - loss: 0.0197 - accuracy: 0.9924\n",
      "Epoch 50/50\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 0.0194 - accuracy: 0.9924\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f0e6199b950>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_train_indices, Y_train_oh, epochs = 50, batch_size = 32, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gR2QJZAkcFJA"
   },
   "source": [
    "Your model should perform around **90% to 100% accuracy** on the training set. Exact model accuracy may vary! \n",
    "\n",
    "Run the following cell to evaluate your model on the test set: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 2962,
     "status": "ok",
     "timestamp": 1611739058762,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "sIbcdVibcFJA",
    "outputId": "65b06e6c-415e-4038-c6fd-3839b3fd39f1",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/2 [==============================] - 0s 3ms/step - loss: 0.5480 - accuracy: 0.8214\n",
      "\n",
      "Test accuracy =  0.8214285969734192\n"
     ]
    }
   ],
   "source": [
    "X_test_indices = sentences_to_indices(X_test, word_to_index, max_len = maxLen)\n",
    "Y_test_oh = convert_to_one_hot(Y_test, C = 5)\n",
    "loss, acc = model.evaluate(X_test_indices, Y_test_oh)\n",
    "print()\n",
    "print(\"Test accuracy = \", acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2d6y4sJbcFJA"
   },
   "source": [
    "You should get a test accuracy between 80% and 95%. Run the cell below to see the mislabelled examples: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 1779,
     "status": "ok",
     "timestamp": 1611739122633,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "mjMyEGmYcFJC",
    "outputId": "0e87d217-d501-40d1-a6c7-71d567643d52"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expected emoji:😄 prediction: she got me a nice present\t❤️\n",
      "Expected emoji:😞 prediction: work is hard\t😄\n",
      "Expected emoji:😞 prediction: This girl is messing with me\t❤️\n",
      "Expected emoji:😞 prediction: work is horrible\t😄\n",
      "Expected emoji:🍴 prediction: any suggestions for dinner\t😄\n",
      "Expected emoji:😄 prediction: you brighten my day\t❤️\n",
      "Expected emoji:😞 prediction: she is a bully\t❤️\n",
      "Expected emoji:😄 prediction: will you be my valentine\t❤️\n",
      "Expected emoji:😞 prediction: go away\t⚾\n",
      "Expected emoji:🍴 prediction: I did not have breakfast ❤️\n"
     ]
    }
   ],
   "source": [
    "# This code allows you to see the mislabelled examples\n",
    "C = 5\n",
    "y_test_oh = np.eye(C)[Y_test.reshape(-1)]\n",
    "X_test_indices = sentences_to_indices(X_test, word_to_index, maxLen)\n",
    "pred = model.predict(X_test_indices)\n",
    "for i in range(len(X_test)):\n",
    "    x = X_test_indices\n",
    "    num = np.argmax(pred[i])\n",
    "    if(num != Y_test[i]):\n",
    "        print('Expected emoji:'+ label_to_emoji(Y_test[i]) + ' prediction: '+ X_test[i] + label_to_emoji(num).strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UGg00oBRcFJD"
   },
   "source": [
    "Now you can try it on your own example! Write your own sentence below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 1780,
     "status": "ok",
     "timestamp": 1611739204630,
     "user": {
      "displayName": "Mubsi K",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gip7OjOkdNkKxKDyWEQAq1o8ccGN_HrBTGdqjgQ=s64",
      "userId": "08094225471505108399"
     },
     "user_tz": -300
    },
    "id": "wEgCsIE7cFJE",
    "outputId": "28d6942b-ad6b-461e-9904-191430145d85"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I cannot play ⚾\n"
     ]
    }
   ],
   "source": [
    "# Change the sentence below to see your prediction. Make sure all the words are in the Glove embeddings.  \n",
    "x_test = np.array(['I cannot play'])\n",
    "X_test_indices = sentences_to_indices(x_test, word_to_index, maxLen)\n",
    "print(x_test[0] +' '+  label_to_emoji(np.argmax(model.predict(X_test_indices))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tT53ibgFcFJE"
   },
   "source": [
    "#### LSTM Version Accounts for Word Order\n",
    "* The Emojify-V1 model did not \"not feeling happy\" correctly, but your implementation of Emojify-V2 got it right! \n",
    "    * If it didn't, be aware that Keras' outputs are slightly random each time, so this is probably why. \n",
    "* The current model still isn't very robust at understanding negation (such as \"not happy\")\n",
    "    * This is because the training set is small and doesn't have a lot of examples of negation. \n",
    "    * If the training set were larger, the LSTM model would be much better than the Emojify-V1 model at understanding more complex sentences. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0ysWCkrcFEb7"
   },
   "source": [
    "### Congratulations!\n",
    " \n",
    "You've completed this notebook, and harnessed the power of LSTMs to make your words more emotive! ❤️❤️❤️\n",
    "\n",
    "By now, you've: \n",
    "\n",
    "* Created an embedding matrix\n",
    "* Observed how negative sampling learns word vectors more efficiently than other methods\n",
    "* Experienced the advantages and disadvantages of the GloVe algorithm\n",
    "* And built a sentiment classifier using word embeddings! \n",
    "\n",
    "Cool! (or Emojified: 😎😎😎 ) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GgoBXYn3cFJE"
   },
   "source": [
    "<font color='blue'><b>What you should remember</b>:\n",
    "- If you have an NLP task where the training set is small, using word embeddings can help your algorithm significantly. \n",
    "- Word embeddings allow your model to work on words in the test set that may not even appear in the training set. \n",
    "- Training sequence models in Keras (and in most other deep learning frameworks) requires a few important details:\n",
    "    - To use mini-batches, the sequences need to be **padded** so that all the examples in a mini-batch have the **same length**. \n",
    "    - An `Embedding()` layer can be initialized with pretrained values. \n",
    "        - These values can be either fixed or trained further on your dataset. \n",
    "        - If however your labeled dataset is small, it's usually not worth trying to train a large pre-trained set of embeddings.   \n",
    "    - `LSTM()` has a flag called `return_sequences` to decide if you would like to return every hidden states or only the last one. \n",
    "    - You can use `Dropout()` right after `LSTM()` to regularize your network. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LUSzrFkYcFJF"
   },
   "source": [
    "\n",
    "### Input sentences:\n",
    "```Python\n",
    "\"Congratulations on finishing this assignment and building an Emojifier.\"\n",
    "\"We hope you're happy with what you've accomplished in this notebook!\"\n",
    "```\n",
    "### Output emojis:\n",
    "# 😀😀😀😀😀😀\n",
    "\n",
    "☁ 👋🚀 ☁☁\n",
    "\n",
    "      ✨ BYE-BYE!\n",
    "      \n",
    "☁ ✨  🎈\n",
    "\n",
    "      ✨  ☁\n",
    "  \n",
    "         ✨\n",
    " \n",
    "     ✨\n",
    " \n",
    "🌾✨💨 🏃 🏠🏢                    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vYoEQMCVcFJG"
   },
   "source": [
    "<a name='3'></a>\n",
    "## 3 - Acknowledgments\n",
    "\n",
    "Thanks to Alison Darcy and the Woebot team for their advice on the creation of this assignment. \n",
    "* Woebot is a chatbot friend that is ready to speak with you 24/7. \n",
    "* Part of Woebot's technology uses word embeddings to understand the emotions of what you say. \n",
    "* You can chat with Woebot by going to http://woebot.io\n",
    "\n",
    "<img src=\"images/woebot.png\" style=\"width:600px;height:300px;\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [
    "zhyVzuThcFI4",
    "LUSzrFkYcFJF"
   ],
   "name": "Solution_Emojify_v2a.ipynb",
   "provenance": []
  },
  "coursera": {
   "schema_names": [
    "DLSC5W2-A2"
   ]
  },
  "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
}