C2-natural-language-processing-with-probabilistic-models/Week4/C2_W4_Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment 4: Word Embeddings \n",
    "\n",
    "Welcome to the fourth (and last) programming assignment of Course 2! \n",
    "\n",
    "In this assignment, you will practice how to compute word embeddings and use them for sentiment analysis.\n",
    "- To implement sentiment analysis, you can go beyond counting the number of positive words and negative words. \n",
    "- You can find a way to represent each word numerically, by a vector. \n",
    "- The vector could then represent syntactic (i.e. parts of speech) and semantic (i.e. meaning) structures. \n",
    "\n",
    "In this assignment, you will explore a classic way of generating word embeddings or representations.\n",
    "- You will implement a famous model called the continuous bag of words (CBOW) model. \n",
    "\n",
    "By completing this assignment you will:\n",
    "\n",
    "- Train word vectors from scratch.\n",
    "- Learn how to create batches of data.\n",
    "- Understand how backpropagation works.\n",
    "- Plot and visualize your learned word vectors.\n",
    "\n",
    "Knowing how to train these models will give you a better understanding of word vectors, which are building blocks to many applications in natural language processing.\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 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/probabilistic-models-in-nlp/supplement/saGQf/how-to-refresh-your-workspace)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "- [1 - The Continuous Bag of Words Model](#1)\n",
    "- [2 - Training the Model](#2)\n",
    "    - [2.1 - Initializing the Model](#2.1)\n",
    "        - [Exercise 1 - initialize_model (UNQ_C1)](#ex-1)\n",
    "    - [2.2 - Softmax](#2.2)\n",
    "        - [Exercise 2 - softmax (UNQ_C2)](#ex-2)\n",
    "    - [2.3 - Forward Propagation](#2.3)\n",
    "        - [Exercise 3 - forward_prop (UNQ_C3)](#ex-3)\n",
    "    - [2.4 - Cost Function](#2.4)\n",
    "    - [2.5 - Training the Model - Backpropagation](#2.5)\n",
    "        - [Exercise 4 - back_prop (UNQ_C4)](#ex-4)\n",
    "    - [2.6 - Gradient Descent](#2.6)\n",
    "        - [Exercise 5 - gradient_descent (UNQ_C5)](#ex-5)\n",
    "- [3 - Visualizing the Word Vectors](#3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='1'></a>\n",
    "## 1 - The Continuous Bag of Words Model\n",
    "\n",
    "Let's take a look at the following sentence: \n",
    ">**'I am happy because I am learning'**. \n",
    "\n",
    "- In continuous bag of words (CBOW) modeling, we try to predict the center word given a few context words (the words around the center word).\n",
    "- For example, if you were to choose a context half-size of say $C = 2$, then you would try to predict the word **happy** given the context that includes 2 words before and 2 words after the center word:\n",
    "\n",
    "> $C$ words before: [I, am] \n",
    "\n",
    "> $C$ words after: [because, I] \n",
    "\n",
    "- In other words:\n",
    "\n",
    "$$context = [I,am, because, I]$$\n",
    "$$target = happy$$\n",
    "\n",
    "The structure of your model will look like this:\n",
    "\n",
    "<div style=\"width:image width px; font-size:100%; text-align:center;\"><img src='images/word2.png' alt=\"alternate text\" width=\"width\" height=\"height\" style=\"width:600px;height:250px;\" /> Figure 1 </div>\n",
    "\n",
    "Where $\\bar x$ is the average of all the one hot vectors of the context words. \n",
    "\n",
    "<div style=\"width:image width px; font-size:100%; text-align:center;\"><img src='images/mean_vec2.png' alt=\"alternate text\" width=\"width\" height=\"height\" style=\"width:600px;height:250px;\" /> Figure 2 </div>\n",
    "\n",
    "Once you have encoded all the context words, you can use $\\bar x$ as the input to your model. \n",
    "\n",
    "The architecture you will be implementing is as follows:\n",
    "\n",
    "\\begin{align}\n",
    " h &= W_1 \\  X + b_1  \\tag{1} \\\\\n",
    " a &= ReLU(h)  \\tag{2} \\\\\n",
    " z &= W_2 \\  a + b_2   \\tag{3} \\\\\n",
    " \\hat y &= softmax(z)   \\tag{4} \\\\\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to /Users/johnmoses/nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Import Python libraries and helper functions (in utils2) \n",
    "import nltk\n",
    "from nltk.tokenize import word_tokenize\n",
    "import numpy as np\n",
    "from collections import Counter\n",
    "from utils2 import sigmoid, get_batches, compute_pca, get_dict\n",
    "import w4_unittest\n",
    "\n",
    "nltk.download('punkt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Download sentence tokenizer\n",
    "nltk.data.path.append('.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of tokens: 60976 \n",
      " ['o', 'for', 'a', 'muse', 'of', 'fire', '.', 'that', 'would', 'ascend', 'the', 'brightest', 'heaven', 'of', 'invention']\n"
     ]
    }
   ],
   "source": [
    "# Load, tokenize and process the data\n",
    "import re                                                           #  Load the Regex-modul\n",
    "with open('./data/shakespeare.txt') as f:\n",
    "    data = f.read()                                                 #  Read in the data\n",
    "data = re.sub(r'[,!?;-]', '.',data)                                 #  Punktuations are replaced by .\n",
    "data = nltk.word_tokenize(data)                                     #  Tokenize string to words\n",
    "data = [ ch.lower() for ch in data if ch.isalpha() or ch == '.']    #  Lower case and drop non-alphabetical tokens\n",
    "print(\"Number of tokens:\", len(data),'\\n', data[:15])               #  print data sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of vocabulary:  5775\n",
      "Most frequent tokens:  [('.', 9630), ('the', 1521), ('and', 1394), ('i', 1257), ('to', 1159), ('of', 1093), ('my', 857), ('that', 781), ('in', 770), ('a', 752), ('you', 748), ('is', 630), ('not', 559), ('for', 467), ('it', 460), ('with', 441), ('his', 434), ('but', 417), ('me', 417), ('your', 397)]\n"
     ]
    }
   ],
   "source": [
    "# Compute the frequency distribution of the words in the dataset (vocabulary)\n",
    "fdist = nltk.FreqDist(word for word in data)\n",
    "print(\"Size of vocabulary: \",len(fdist) )\n",
    "print(\"Most frequent tokens: \",fdist.most_common(20) ) # print the 20 most frequent words and their freq."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Mapping words to indices and indices to words\n",
    "We provide a helper function to create a dictionary that maps words to indices and indices to words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of vocabulary:  5775\n"
     ]
    }
   ],
   "source": [
    "# get_dict creates two dictionaries, converting words to indices and viceversa.\n",
    "word2Ind, Ind2word = get_dict(data)\n",
    "V = len(word2Ind)\n",
    "print(\"Size of vocabulary: \", V)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index of the word 'king' :   2744\n",
      "Word which has index 2743:   kinds\n"
     ]
    }
   ],
   "source": [
    "# example of word to index mapping\n",
    "print(\"Index of the word 'king' :  \",word2Ind['king'] )\n",
    "print(\"Word which has index 2743:  \",Ind2word[2743] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='2'></a>\n",
    "## 2 - Training the Model\n",
    "\n",
    "<a name='2.1'></a>\n",
    "### 2.1 - Initializing the Model\n",
    "\n",
    "You will now initialize two matrices and two vectors. \n",
    "- The first matrix ($W_1$) is of dimension $N \\times V$, where $V$ is the number of words in your vocabulary and $N$ is the dimension of your word vector.\n",
    "- The second matrix ($W_2$) is of dimension $V \\times N$. \n",
    "- Vector $b_1$ has dimensions $N\\times 1$\n",
    "- Vector $b_2$ has dimensions  $V\\times 1$. \n",
    "- $b_1$ and $b_2$ are the bias vectors of the linear layers from matrices $W_1$ and $W_2$.\n",
    "\n",
    "The overall structure of the model will look as in Figure 1, but at this stage we are just initializing the parameters. \n",
    "\n",
    "<a name='ex-1'></a>\n",
    "### Exercise 1 - initialize_model\n",
    "Please use [numpy.random.rand](https://numpy.org/doc/stable/reference/random/generated/numpy.random.rand.html) to generate matrices that are initialized with random values from a uniform distribution, ranging between 0 and 1.\n",
    "\n",
    "**Note:** In the next cell you will encounter a random seed. Please **DO NOT** modify this seed so your solution can be tested correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# UNIT TEST COMMENT: Candidate for Table Driven Tests\n",
    "# UNQ_C1 GRADED FUNCTION: initialize_model\n",
    "def initialize_model(N,V, random_seed=1):\n",
    "    '''\n",
    "    Inputs: \n",
    "        N:  dimension of hidden vector \n",
    "        V:  dimension of vocabulary\n",
    "        random_seed: random seed for consistent results in the unit tests\n",
    "     Outputs: \n",
    "        W1, W2, b1, b2: initialized weights and biases\n",
    "    '''\n",
    "    \n",
    "    ### START CODE HERE (Replace instances of 'None' with your code) ###\n",
    "    np.random.seed(random_seed)\n",
    "    # W1 has shape (N,V)\n",
    "    W1 = np.random.uniform(0,1,(N,V))\n",
    "    \n",
    "    # W2 has shape (V,N)\n",
    "    W2 = np.random.uniform(0,1,(V,N))\n",
    "    \n",
    "    # b1 has shape (N,1)\n",
    "    b1 = np.random.uniform(0,1,(N,1))\n",
    "    \n",
    "    # b2 has shape (V,1)\n",
    "    b2 = np.random.uniform(0,1,(V,1))\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "    return W1, W2, b1, b2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tmp_W1.shape: (4, 10)\n",
      "tmp_W2.shape: (10, 4)\n",
      "tmp_b1.shape: (4, 1)\n",
      "tmp_b2.shape: (10, 1)\n"
     ]
    }
   ],
   "source": [
    "# Test your function example.\n",
    "tmp_N = 4\n",
    "tmp_V = 10\n",
    "tmp_W1, tmp_W2, tmp_b1, tmp_b2 = initialize_model(tmp_N,tmp_V)\n",
    "assert tmp_W1.shape == ((tmp_N,tmp_V))\n",
    "assert tmp_W2.shape == ((tmp_V,tmp_N))\n",
    "print(f\"tmp_W1.shape: {tmp_W1.shape}\")\n",
    "print(f\"tmp_W2.shape: {tmp_W2.shape}\")\n",
    "print(f\"tmp_b1.shape: {tmp_b1.shape}\")\n",
    "print(f\"tmp_b2.shape: {tmp_b2.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Expected Output \n",
    "\n",
    "```CPP\n",
    "tmp_W1.shape: (4, 10)\n",
    "tmp_W2.shape: (10, 4)\n",
    "tmp_b1.shape: (4, 1)\n",
    "tmp_b2.shape: (10, 1)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[92m All tests passed\n"
     ]
    }
   ],
   "source": [
    "# Test your function\n",
    "w4_unittest.test_initialize_model(initialize_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='2.2'></a>\n",
    "### 2.2 - Softmax\n",
    "Before we can start training the model, we need to implement the softmax function as defined in equation 5:  \n",
    "\n",
    "<br>\n",
    "$$ \\text{softmax}(z_i) = \\frac{e^{z_i} }{\\sum_{i=0}^{V-1} e^{z_i} }  \\tag{5} $$\n",
    "\n",
    "- Array indexing in code starts at 0.\n",
    "- $V$ is the number of words in the vocabulary (which is also the number of rows of $z$).\n",
    "- $i$ goes from 0 to |V| - 1.\n",
    "\n",
    "\n",
    "<a name='ex-2'></a>\n",
    "### Exercise 2 - softmax\n",
    "**Instructions**: Implement the softmax function below. \n",
    "\n",
    "- Assume that the input $z$ to `softmax` is a 2D array\n",
    "- Each training example is represented by a vector of shape (V, 1) in this 2D array.\n",
    "- There may be more than one column, in the 2D array, because you can put in a batch of examples to increase efficiency.  Let's call the batch size lowercase $m$, so the $z$ array has shape (V, m)\n",
    "- When taking the sum from $i=1 \\cdots V-1$, take the sum for each column (each example) separately.\n",
    "\n",
    "Please use\n",
    "- numpy.exp\n",
    "- numpy.sum (set the axis so that you take the sum of each column in z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# UNIT TEST COMMENT: Candidate for Table Driven Tests\n",
    "# UNQ_C2 GRADED FUNCTION: softmax\n",
    "def softmax(z):\n",
    "    '''\n",
    "    Inputs: \n",
    "        z: output scores from the hidden layer\n",
    "    Outputs: \n",
    "        yhat: prediction (estimate of y)\n",
    "    '''\n",
    "    ### START CODE HERE (Replace instances of 'None' with your own code) ###\n",
    "    # Calculate yhat (softmax)\n",
    "    yhat = np.exp(z)/np.sum(np.exp(z),axis=0)\n",
    "    ### END CODE HERE ###\n",
    "    return yhat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5       , 0.73105858, 0.88079708],\n",
       "       [0.5       , 0.26894142, 0.11920292]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the function\n",
    "tmp = np.array([[1,2,3],\n",
    "                [1,1,1]\n",
    "               ])\n",
    "tmp_sm = softmax(tmp)\n",
    "display(tmp_sm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Expected Ouput\n",
    "\n",
    "```CPP\n",
    "array([[0.5       , 0.73105858, 0.88079708],\n",
    "       [0.5       , 0.26894142, 0.11920292]])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[92m All tests passed\n"
     ]
    }
   ],
   "source": [
    "# Test your function\n",
    "w4_unittest.test_softmax(softmax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='2.3'></a>\n",
    "### 2.3 - Forward Propagation\n",
    "\n",
    "<a name='ex-3'></a>\n",
    "### Exercise 3 - forward_prop\n",
    "Implement the forward propagation $z$ according to equations (1) to (3). <br>\n",
    "\n",
    "\\begin{align}\n",
    " h &= W_1 \\  X + b_1  \\tag{1} \\\\\n",
    " h &= ReLU(h)  \\tag{2} \\\\\n",
    " z &= W_2 \\  h + b_2   \\tag{3} \\\\\n",
    "\\end{align}\n",
    "\n",
    "For that, you will use as activation the Rectified Linear Unit (ReLU) given by:\n",
    "\n",
    "$$f(h)=\\max (0,h) \\tag{6}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>    \n",
    "<summary>\n",
    "    <font size=\"3\" color=\"darkgreen\"><b>Hints</b></font>\n",
    "</summary>\n",
    "<p>\n",
    "<ul>\n",
    "    <li>You can use numpy.maximum(x1,x2) to get the maximum of two values</li>\n",
    "    <li>Use numpy.dot(A,B) to matrix multiply A and B</li>\n",
    "</ul>\n",
    "</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# UNIT TEST COMMENT: Candidate for Table Driven Tests\n",
    "# UNQ_C3 GRADED FUNCTION: forward_prop\n",
    "def forward_prop(x, W1, W2, b1, b2):\n",
    "    '''\n",
    "    Inputs: \n",
    "        x:  average one hot vector for the context \n",
    "        W1, W2, b1, b2:  matrices and biases to be learned\n",
    "     Outputs: \n",
    "        z:  output score vector\n",
    "    '''\n",
    "    \n",
    "    ### START CODE HERE (Replace instances of 'None' with your own code) ###\n",
    "    # Calculate h\n",
    "    h = np.dot(W1,x) + b1\n",
    "  \n",
    "    # Apply the relu on h, \n",
    "    # store the relu in h\n",
    "    h[h < 0] = 0\n",
    "\n",
    "    # Calculate z\n",
    "    z = np.dot(W2,h) + b2\n",
    "\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    return z, h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x has shape (3, 1)\n",
      "N is 2 and vocabulary size V is 3\n",
      "call forward_prop\n",
      "\n",
      "z has shape (3, 1)\n",
      "z has values:\n",
      "[[0.55379268]\n",
      " [1.58960774]\n",
      " [1.50722933]]\n",
      "\n",
      "h has shape (2, 1)\n",
      "h has values:\n",
      "[[0.92477674]\n",
      " [1.02487333]]\n"
     ]
    }
   ],
   "source": [
    "# Test the function\n",
    "\n",
    "# Create some inputs\n",
    "tmp_N = 2\n",
    "tmp_V = 3\n",
    "tmp_x = np.array([[0,1,0]]).T\n",
    "#print(tmp_x)\n",
    "tmp_W1, tmp_W2, tmp_b1, tmp_b2 = initialize_model(N=tmp_N,V=tmp_V, random_seed=1)\n",
    "\n",
    "print(f\"x has shape {tmp_x.shape}\")\n",
    "print(f\"N is {tmp_N} and vocabulary size V is {tmp_V}\")\n",
    "\n",
    "# call function\n",
    "tmp_z, tmp_h = forward_prop(tmp_x, tmp_W1, tmp_W2, tmp_b1, tmp_b2)\n",
    "print(\"call forward_prop\")\n",
    "print()\n",
    "# Look at output\n",
    "print(f\"z has shape {tmp_z.shape}\")\n",
    "print(\"z has values:\")\n",
    "print(tmp_z)\n",
    "\n",
    "print()\n",
    "\n",
    "print(f\"h has shape {tmp_h.shape}\")\n",
    "print(\"h has values:\")\n",
    "print(tmp_h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Expected output\n",
    "```CPP\n",
    "x has shape (3, 1)\n",
    "N is 2 and vocabulary size V is 3\n",
    "call forward_prop\n",
    "\n",
    "z has shape (3, 1)\n",
    "z has values:\n",
    "[[0.55379268]\n",
    " [1.58960774]\n",
    " [1.50722933]]\n",
    "\n",
    "h has shape (2, 1)\n",
    "h has values:\n",
    "[[0.92477674]\n",
    " [1.02487333]]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[92m All tests passed\n"
     ]
    }
   ],
   "source": [
    "# Test your function\n",
    "w4_unittest.test_forward_prop(forward_prop)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='2.4'></a>\n",
    "### 2.4 - Cost Function\n",
    "\n",
    "- We have implemented the *cross-entropy* cost function for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute_cost: cross-entropy cost function\n",
    "def compute_cost(y, yhat, batch_size):\n",
    "\n",
    "    # cost function \n",
    "    logprobs = np.multiply(np.log(yhat),y)\n",
    "    cost = - 1/batch_size * np.sum(logprobs)\n",
    "    cost = np.squeeze(cost)\n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tmp_x.shape (5775, 4)\n",
      "tmp_y.shape (5775, 4)\n",
      "tmp_W1.shape (50, 5775)\n",
      "tmp_W2.shape (5775, 50)\n",
      "tmp_b1.shape (50, 1)\n",
      "tmp_b2.shape (5775, 1)\n",
      "tmp_z.shape: (5775, 4)\n",
      "tmp_h.shape: (50, 4)\n",
      "tmp_yhat.shape: (5775, 4)\n",
      "call compute_cost\n",
      "tmp_cost 10.4074\n"
     ]
    }
   ],
   "source": [
    "# Test the function\n",
    "tmp_C = 2\n",
    "tmp_N = 50\n",
    "tmp_batch_size = 4\n",
    "tmp_word2Ind, tmp_Ind2word = get_dict(data)\n",
    "tmp_V = len(word2Ind)\n",
    "\n",
    "tmp_x, tmp_y = next(get_batches(data, tmp_word2Ind, tmp_V,tmp_C, tmp_batch_size))\n",
    "        \n",
    "print(f\"tmp_x.shape {tmp_x.shape}\")\n",
    "print(f\"tmp_y.shape {tmp_y.shape}\")\n",
    "\n",
    "tmp_W1, tmp_W2, tmp_b1, tmp_b2 = initialize_model(tmp_N,tmp_V)\n",
    "\n",
    "print(f\"tmp_W1.shape {tmp_W1.shape}\")\n",
    "print(f\"tmp_W2.shape {tmp_W2.shape}\")\n",
    "print(f\"tmp_b1.shape {tmp_b1.shape}\")\n",
    "print(f\"tmp_b2.shape {tmp_b2.shape}\")\n",
    "\n",
    "tmp_z, tmp_h = forward_prop(tmp_x, tmp_W1, tmp_W2, tmp_b1, tmp_b2)\n",
    "print(f\"tmp_z.shape: {tmp_z.shape}\")\n",
    "print(f\"tmp_h.shape: {tmp_h.shape}\")\n",
    "\n",
    "tmp_yhat = softmax(tmp_z)\n",
    "print(f\"tmp_yhat.shape: {tmp_yhat.shape}\")\n",
    "\n",
    "tmp_cost = compute_cost(tmp_y, tmp_yhat, tmp_batch_size)\n",
    "print(\"call compute_cost\")\n",
    "print(f\"tmp_cost {tmp_cost:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Expected output\n",
    "\n",
    "```CPP\n",
    "tmp_x.shape (5778, 4)\n",
    "tmp_y.shape (5778, 4)\n",
    "tmp_W1.shape (50, 5778)\n",
    "tmp_W2.shape (5778, 50)\n",
    "tmp_b1.shape (50, 1)\n",
    "tmp_b2.shape (5778, 1)\n",
    "tmp_z.shape: (5778, 4)\n",
    "tmp_h.shape: (50, 4)\n",
    "tmp_yhat.shape: (5778, 4)\n",
    "call compute_cost\n",
    "tmp_cost 8.9542\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='2.5'></a>\n",
    "### 2.5 - Training the Model - Backpropagation\n",
    "\n",
    "<a name='ex-4'></a>\n",
    "### Exercise 4 - back_prop\n",
    "Now that you have understood how the CBOW model works, you will train it. <br>\n",
    "You created a function for the forward propagation. Now you will implement a function that computes the gradients to backpropagate the errors.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# UNIT TEST COMMENT: Candidate for Table Driven Tests\n",
    "# UNQ_C4 GRADED FUNCTION: back_prop\n",
    "def back_prop(x, yhat, y, h, W1, W2, b1, b2, batch_size):\n",
    "    '''\n",
    "    Inputs: \n",
    "        x:  average one hot vector for the context \n",
    "        yhat: prediction (estimate of y)\n",
    "        y:  target vector\n",
    "        h:  hidden vector (see eq. 1)\n",
    "        W1, W2, b1, b2:  matrices and biases  \n",
    "        batch_size: batch size \n",
    "     Outputs: \n",
    "        grad_W1, grad_W2, grad_b1, grad_b2:  gradients of matrices and biases   \n",
    "    '''\n",
    "    ### START CODE HERE (Replace instanes of 'None' with your code) ###\n",
    "    # Compute l1 as W2^T (Yhat - Y)\n",
    "    # and re-use it whenever you see W2^T (Yhat - Y) used to compute a gradient\n",
    "    l1 = np.dot(W2.T,yhat-y)\n",
    "\n",
    "    # Apply relu to l1\n",
    "    l1[l1 < 0] = 0\n",
    "\n",
    "    # compute the gradient for W1\n",
    "    grad_W1 = 1/batch_size * np.dot(l1,x.T)\n",
    "\n",
    "    # Compute gradient of W2\n",
    "    grad_W2 = 1/batch_size * np.dot(yhat-y,h.T)\n",
    "    \n",
    "    # compute gradient for b1\n",
    "    grad_b1 = 1/batch_size * np.dot(l1,np.ones((batch_size,1)))\n",
    "\n",
    "    # compute gradient for b2\n",
    "    grad_b2 = 1/batch_size * np.dot(yhat-y,np.ones((batch_size,1)))\n",
    "    ### END CODE HERE ####\n",
    "    \n",
    "    return grad_W1, grad_W2, grad_b1, grad_b2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "get a batch of data\n",
      "tmp_x.shape (5775, 4)\n",
      "tmp_y.shape (5775, 4)\n",
      "\n",
      "Initialize weights and biases\n",
      "tmp_W1.shape (50, 5775)\n",
      "tmp_W2.shape (5775, 50)\n",
      "tmp_b1.shape (50, 1)\n",
      "tmp_b2.shape (5775, 1)\n",
      "\n",
      "Forwad prop to get z and h\n",
      "tmp_z.shape: (5775, 4)\n",
      "tmp_h.shape: (50, 4)\n",
      "\n",
      "Get yhat by calling softmax\n",
      "tmp_yhat.shape: (5775, 4)\n",
      "\n",
      "call back_prop\n",
      "tmp_grad_W1.shape (50, 5775)\n",
      "tmp_grad_W2.shape (5775, 50)\n",
      "tmp_grad_b1.shape (50, 1)\n",
      "tmp_grad_b2.shape (5775, 1)\n"
     ]
    }
   ],
   "source": [
    "# Test the function\n",
    "tmp_C = 2\n",
    "tmp_N = 50\n",
    "tmp_batch_size = 4\n",
    "tmp_word2Ind, tmp_Ind2word = get_dict(data)\n",
    "tmp_V = len(word2Ind)\n",
    "\n",
    "\n",
    "# get a batch of data\n",
    "tmp_x, tmp_y = next(get_batches(data, tmp_word2Ind, tmp_V,tmp_C, tmp_batch_size))\n",
    "\n",
    "print(\"get a batch of data\")\n",
    "print(f\"tmp_x.shape {tmp_x.shape}\")\n",
    "print(f\"tmp_y.shape {tmp_y.shape}\")\n",
    "\n",
    "print()\n",
    "print(\"Initialize weights and biases\")\n",
    "tmp_W1, tmp_W2, tmp_b1, tmp_b2 = initialize_model(tmp_N,tmp_V)\n",
    "\n",
    "print(f\"tmp_W1.shape {tmp_W1.shape}\")\n",
    "print(f\"tmp_W2.shape {tmp_W2.shape}\")\n",
    "print(f\"tmp_b1.shape {tmp_b1.shape}\")\n",
    "print(f\"tmp_b2.shape {tmp_b2.shape}\")\n",
    "\n",
    "print()\n",
    "print(\"Forwad prop to get z and h\")\n",
    "tmp_z, tmp_h = forward_prop(tmp_x, tmp_W1, tmp_W2, tmp_b1, tmp_b2)\n",
    "print(f\"tmp_z.shape: {tmp_z.shape}\")\n",
    "print(f\"tmp_h.shape: {tmp_h.shape}\")\n",
    "\n",
    "print()\n",
    "print(\"Get yhat by calling softmax\")\n",
    "tmp_yhat = softmax(tmp_z)\n",
    "print(f\"tmp_yhat.shape: {tmp_yhat.shape}\")\n",
    "\n",
    "tmp_m = (2*tmp_C)\n",
    "tmp_grad_W1, tmp_grad_W2, tmp_grad_b1, tmp_grad_b2 = back_prop(tmp_x, tmp_yhat, tmp_y, tmp_h, tmp_W1, tmp_W2, tmp_b1, tmp_b2, tmp_batch_size)\n",
    "\n",
    "print()\n",
    "print(\"call back_prop\")\n",
    "print(f\"tmp_grad_W1.shape {tmp_grad_W1.shape}\")\n",
    "print(f\"tmp_grad_W2.shape {tmp_grad_W2.shape}\")\n",
    "print(f\"tmp_grad_b1.shape {tmp_grad_b1.shape}\")\n",
    "print(f\"tmp_grad_b2.shape {tmp_grad_b2.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Expected output\n",
    "\n",
    "```CPP\n",
    "get a batch of data\n",
    "tmp_x.shape (5778, 4)\n",
    "tmp_y.shape (5778, 4)\n",
    "\n",
    "Initialize weights and biases\n",
    "tmp_W1.shape (50, 5778)\n",
    "tmp_W2.shape (5778, 50)\n",
    "tmp_b1.shape (50, 1)\n",
    "tmp_b2.shape (5778, 1)\n",
    "\n",
    "Forwad prop to get z and h\n",
    "tmp_z.shape: (5778, 4)\n",
    "tmp_h.shape: (50, 4)\n",
    "\n",
    "Get yhat by calling softmax\n",
    "tmp_yhat.shape: (5778, 4)\n",
    "\n",
    "call back_prop\n",
    "tmp_grad_W1.shape (50, 5778)\n",
    "tmp_grad_W2.shape (5778, 50)\n",
    "tmp_grad_b1.shape (50, 1)\n",
    "tmp_grad_b2.shape (5778, 1)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[92m All tests passed\n"
     ]
    }
   ],
   "source": [
    "# Test your function\n",
    "w4_unittest.test_back_prop(back_prop)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='2.6'></a>\n",
    "### 2.6 - Gradient Descent\n",
    "\n",
    "<a name='ex-5'></a>\n",
    "### Exercise 5 - gradient_descent\n",
    "Now that you have implemented a function to compute the gradients, you will implement batch gradient descent over your training set. \n",
    "\n",
    "**Hint:** For that, you will use `initialize_model` and the `back_prop` functions which you just created (and the `compute_cost` function). You can also use the provided `get_batches` helper function:\n",
    "\n",
    "```for x, y in get_batches(data, word2Ind, V, C, batch_size):```\n",
    "\n",
    "```...```\n",
    "\n",
    "Also: print the cost after each batch is processed (use batch size = 128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# UNIT TEST COMMENT: Candidate for Table Driven Tests\n",
    "# UNQ_C5 GRADED FUNCTION: gradient_descent\n",
    "def gradient_descent(data, word2Ind, N, V, num_iters, alpha=0.03, \n",
    "                     random_seed=282, initialize_model=initialize_model, \n",
    "                     get_batches=get_batches, forward_prop=forward_prop, \n",
    "                     softmax=softmax, compute_cost=compute_cost, \n",
    "                     back_prop=back_prop):\n",
    "    \n",
    "    '''\n",
    "    This is the gradient_descent function\n",
    "    \n",
    "      Inputs: \n",
    "        data:      text\n",
    "        word2Ind:  words to Indices\n",
    "        N:         dimension of hidden vector  \n",
    "        V:         dimension of vocabulary \n",
    "        num_iters: number of iterations  \n",
    "        random_seed: random seed to initialize the model's matrices and vectors\n",
    "        initialize_model: your implementation of the function to initialize the model\n",
    "        get_batches: function to get the data in batches\n",
    "        forward_prop: your implementation of the function to perform forward propagation\n",
    "        softmax: your implementation of the softmax function\n",
    "        compute_cost: cost function (Cross entropy)\n",
    "        back_prop: your implementation of the function to perform backward propagation\n",
    "     Outputs: \n",
    "        W1, W2, b1, b2:  updated matrices and biases after num_iters iterations\n",
    "\n",
    "    '''\n",
    "    W1, W2, b1, b2 = initialize_model(N,V, random_seed=random_seed) #W1=(N,V) and W2=(V,N)\n",
    "\n",
    "    batch_size = 128\n",
    "#    batch_size = 512\n",
    "    iters = 0\n",
    "    C = 2 \n",
    "    \n",
    "    for x, y in get_batches(data, word2Ind, V, C, batch_size):\n",
    "        ### START CODE HERE (Replace instances of 'None' with your own code) ###                \n",
    "        # get z and h\n",
    "        z, h = forward_prop(x,W1,W2,b1,b2)\n",
    "                \n",
    "        # get yhat\n",
    "        yhat = softmax(z)\n",
    "        \n",
    "        # get cost\n",
    "        cost = compute_cost(y,yhat,batch_size)\n",
    "        if ( (iters+1) % 10 == 0):\n",
    "            print(f\"iters: {iters + 1} cost: {cost:.6f}\")\n",
    "            \n",
    "        # get gradients\n",
    "        grad_W1, grad_W2, grad_b1, grad_b2 = back_prop(x,yhat,y,h,W1,W2,b1,b2,batch_size)\n",
    "        \n",
    "        # update weights and biases\n",
    "        W1 = W1 - (alpha * grad_W1)\n",
    "        W2 = W2 - (alpha * grad_W2)\n",
    "        b1 = b1 - (alpha * grad_b1)\n",
    "        b2 = b2 - (alpha * grad_b2)\n",
    "\n",
    "        ### END CODE HERE ###\n",
    "        iters +=1 \n",
    "        if iters == num_iters: \n",
    "            break\n",
    "        if iters % 100 == 0:\n",
    "            alpha *= 0.66\n",
    "            \n",
    "    return W1, W2, b1, b2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Call gradient_descent\n",
      "iters: 10 cost: 8.538367\n",
      "iters: 20 cost: 4.449100\n",
      "iters: 30 cost: 16.154438\n",
      "iters: 40 cost: 2.372795\n",
      "iters: 50 cost: 10.508012\n",
      "iters: 60 cost: 7.730859\n",
      "iters: 70 cost: 5.893077\n",
      "iters: 80 cost: 9.354901\n",
      "iters: 90 cost: 10.002799\n",
      "iters: 100 cost: 11.484674\n",
      "iters: 110 cost: 4.625150\n",
      "iters: 120 cost: 4.428295\n",
      "iters: 130 cost: 10.306100\n",
      "iters: 140 cost: 6.705970\n",
      "iters: 150 cost: 3.189159\n"
     ]
    }
   ],
   "source": [
    "# test your function\n",
    "# UNIT TEST COMMENT: Each time this cell is run the cost for each iteration changes slightly (the change is less dramatic after some iterations)\n",
    "# to have this into account let's accept an answer as correct if the cost of iter 15 = 41.6 (without caring about decimal points beyond the first decimal)\n",
    "# 41.66, 41.69778, 41.63, etc should all be valid answers.\n",
    "C = 2\n",
    "N = 50\n",
    "word2Ind, Ind2word = get_dict(data)\n",
    "V = len(word2Ind)\n",
    "num_iters = 150\n",
    "print(\"Call gradient_descent\")\n",
    "W1, W2, b1, b2 = gradient_descent(data, word2Ind, N, V, num_iters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Expected Output\n",
    "\n",
    "```python\n",
    "iters: 10 cost: 11.714748\n",
    "iters: 20 cost: 3.788280\n",
    "iters: 30 cost: 9.179923\n",
    "iters: 40 cost: 1.747809\n",
    "iters: 50 cost: 8.706968\n",
    "iters: 60 cost: 10.182652\n",
    "iters: 70 cost: 7.258762\n",
    "iters: 80 cost: 10.214489\n",
    "iters: 90 cost: 9.311061\n",
    "iters: 100 cost: 10.103939\n",
    "iters: 110 cost: 5.582018\n",
    "iters: 120 cost: 4.330974\n",
    "iters: 130 cost: 9.436612\n",
    "iters: 140 cost: 6.875775\n",
    "iters: 150 cost: 2.874090\n",
    "```        \n",
    "        \n",
    "Your numbers may differ a bit depending on which version of Python you're using."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name default_check\n",
      "iters: 10 cost: 9.701559\n",
      "Wrong output shape for W1 matrix.\n",
      "\t Expected: (10, 5778) \n",
      "\tGot: (10, 5775).\n",
      "Wrong output shape for W2 matrix.\n",
      "\t Expected: (5778, 10) \n",
      "\tGot: (5775, 10).\n",
      "Wrong output shape for b2 vector.\n",
      "\t Expected: (5778, 1) \n",
      "\tGot: (5775, 1).\n",
      "Wrong output values for W1 matrix.\n",
      "\t Expected: [[0.36409955 0.38892563 0.12117024 ... 0.21485169 0.8417732  0.4013149 ]\n",
      " [0.13575098 0.54877358 0.39651013 ... 0.64207701 0.6203919  0.97065011]\n",
      " [0.03939965 0.3807733  0.41687347 ... 0.18933903 0.40646899 0.71397686]\n",
      " ...\n",
      " [0.21540556 0.19491621 0.18807501 ... 0.39607305 0.78038406 0.6061392 ]\n",
      " [0.46906148 0.14242556 0.21027327 ... 0.87438456 0.75839127 0.97442377]\n",
      " [0.1400866  0.23955149 0.05433805 ... 0.71292201 0.93679829 0.72879085]] \n",
      "\tGot: [[0.35801618 0.38403625 0.12117024 ... 0.17186261 0.25644932 0.30847224]\n",
      " [0.21243742 0.84039803 0.4013149  ... 0.39430508 0.87354257 0.9487626 ]\n",
      " [0.04710886 0.73883011 0.71178276 ... 0.4011204  0.7963532  0.95414673]\n",
      " ...\n",
      " [0.50396525 0.29371189 0.51560631 ... 0.15122536 0.36083922 0.67154991]\n",
      " [0.95257741 0.14621986 0.71631176 ... 0.89558407 0.78072534 0.51184918]\n",
      " [0.27589409 0.03278513 0.16997816 ... 0.81155232 0.81384866 0.02833803]].\n",
      "Wrong output values for W2 matrix.\n",
      "\t Expected: [[1.04159784 0.26177388 0.848308   ... 0.74728741 0.94018686 0.13539754]\n",
      " [0.97860239 0.65316393 0.10570866 ... 1.07529556 0.88030501 0.13926188]\n",
      " [0.74306976 0.69342278 0.77137102 ... 0.46450767 0.16699697 0.19468542]\n",
      " ...\n",
      " [0.61898739 0.52199188 0.44596942 ... 0.91220257 0.84879163 0.93975761]\n",
      " [0.46573742 0.27582959 0.85770989 ... 0.55741427 0.76747582 0.59149174]\n",
      " [0.88165063 0.52037371 0.49309416 ... 0.17477049 0.81721038 0.49459065]] \n",
      "\tGot: [[0.47645144 0.88494448 0.92185354 ... 0.27766707 0.99304464 1.02656216]\n",
      " [0.62915744 0.745617   0.1880254  ... 0.74694568 0.45843666 0.60019522]\n",
      " [0.18539095 0.40095796 0.56763318 ... 0.71285492 0.93666004 0.72865204]\n",
      " ...\n",
      " [0.78054244 0.82034091 0.08668523 ... 0.12371276 0.03258136 0.32830463]\n",
      " [0.27987872 0.96589011 0.37420643 ... 0.57979563 0.32915841 0.83956452]\n",
      " [0.82904337 0.55661354 0.86177935 ... 0.68258725 0.69042625 0.77770358]].\n",
      "Wrong output values for b1 vector.\n",
      "\t Expected: [[0.27581438]\n",
      " [0.33807755]\n",
      " [0.59087163]\n",
      " [0.45787607]\n",
      " [0.31688845]\n",
      " [0.5186393 ]\n",
      " [0.00596877]\n",
      " [0.7707525 ]\n",
      " [0.20032616]\n",
      " [0.15449703]] \n",
      "\tGot: [[ 0.6279002 ]\n",
      " [ 0.13092078]\n",
      " [ 0.04552323]\n",
      " [-0.03916117]\n",
      " [ 0.8325815 ]\n",
      " [ 0.72378233]\n",
      " [ 0.38506879]\n",
      " [ 0.08189845]\n",
      " [ 0.53399369]\n",
      " [ 0.62530561]].\n",
      "Wrong output values for gradient of b2 vector.\n",
      "\t Expected: [[0.85118393]\n",
      " [0.0772051 ]\n",
      " [0.77574519]\n",
      " ...\n",
      " [0.26061528]\n",
      " [0.67110752]\n",
      " [0.83251038]] \n",
      "\tGot: [[0.64755019]\n",
      " [0.85850704]\n",
      " [0.78235059]\n",
      " ...\n",
      " [0.36202761]\n",
      " [0.18994367]\n",
      " [0.52721988]].\n",
      "name small_check\n",
      "iters: 10 cost: 7.774701\n",
      "Wrong output shape for W1 matrix.\n",
      "\t Expected: (5, 5778) \n",
      "\tGot: (5, 5775).\n",
      "Wrong output shape for W2 matrix.\n",
      "\t Expected: (5778, 5) \n",
      "\tGot: (5775, 5).\n",
      "Wrong output shape for b2 vector.\n",
      "\t Expected: (5778, 1) \n",
      "\tGot: (5775, 1).\n",
      "Wrong output values for W1 matrix.\n",
      "\t Expected: [[0.21955121 0.87004448 0.20671916 ... 0.07752275 0.77457191 0.67174422]\n",
      " [0.27577893 0.532172   0.30534023 ... 0.38543118 0.28671259 0.13483498]\n",
      " [0.987288   0.46881859 0.28648156 ... 0.8206767  0.03792429 0.60534254]\n",
      " [0.34221277 0.59118683 0.27437007 ... 0.24937364 0.37304776 0.02650941]\n",
      " [0.86029217 0.86354    0.9106285  ... 0.30000818 0.2322273  0.7837576 ]] \n",
      "\tGot: [[0.21852853 0.8692063  0.20671916 ... 0.94856911 0.43857341 0.76175763]\n",
      " [0.07228757 0.7706973  0.67174422 ... 0.66479061 0.12487353 0.78392502]\n",
      " [0.90476319 0.28276752 0.90278781 ... 0.78956051 0.39281928 0.42028964]\n",
      " [0.58152805 0.43041766 0.28586166 ... 0.36018539 0.35759206 0.54584511]\n",
      " [0.96694236 0.89642635 0.89907326 ... 0.21473647 0.09405947 0.95583177]].\n",
      "Wrong output values for W2 matrix.\n",
      "\t Expected: [[0.76320106 0.54504084 0.93378556 0.73599188 1.01550456]\n",
      " [0.12166387 1.00536763 0.93126515 0.05322734 0.83143197]\n",
      " [0.10183734 0.04003451 0.99304244 0.70575225 0.27900097]\n",
      " ...\n",
      " [0.44888249 0.68064226 0.25140446 0.82963476 0.9178071 ]\n",
      " [0.02947705 0.82557035 0.36649501 0.4966427  0.4188333 ]\n",
      " [0.64371739 0.51447761 0.43217087 0.32061607 0.31237681]] \n",
      "\tGot: [[0.23534933 0.44061855 0.63354448 0.70314275 0.73152675]\n",
      " [0.93421365 0.1199763  1.01004624 0.61503994 0.5704206 ]\n",
      " [0.49261531 0.16878108 0.29998427 0.23221722 0.78373806]\n",
      " ...\n",
      " [0.92256748 0.11709173 0.40440236 0.39238508 0.79189848]\n",
      " [0.72018994 0.97810695 0.64524461 0.20964472 0.78705389]\n",
      " [0.02895223 0.70038558 0.68308869 0.57766008 0.89048879]].\n",
      "Wrong output values for b1 vector.\n",
      "\t Expected: [[0.25442659]\n",
      " [0.66697987]\n",
      " [0.28046412]\n",
      " [0.01315516]\n",
      " [0.28675058]] \n",
      "\tGot: [[0.38632968]\n",
      " [0.61602159]\n",
      " [0.79186628]\n",
      " [0.01612798]\n",
      " [0.62738999]].\n",
      "Wrong output values for gradient of b2 vector.\n",
      "\t Expected: [[0.18226354]\n",
      " [0.46436747]\n",
      " [0.61834337]\n",
      " ...\n",
      " [0.75831577]\n",
      " [0.6020428 ]\n",
      " [0.90920931]] \n",
      "\tGot: [[0.86942006]\n",
      " [0.07340987]\n",
      " [0.81009339]\n",
      " ...\n",
      " [0.11864383]\n",
      " [0.65426484]\n",
      " [0.7139223 ]].\n",
      "\u001b[92m 2  Tests passed\n",
      "\u001b[91m 14  Tests failed\n"
     ]
    }
   ],
   "source": [
    "# Test your function\n",
    "w4_unittest.test_gradient_descent(gradient_descent, data, word2Ind, N=10, V=len(word2Ind), num_iters=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='3'></a>\n",
    "## 3 - Visualizing the Word Vectors\n",
    "\n",
    "In this part you will visualize the word vectors trained using the function you just coded above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# visualizing the word vectors here\n",
    "from matplotlib import pyplot\n",
    "%config InlineBackend.figure_format = 'svg'\n",
    "words = ['king', 'queen','lord','man', 'woman','dog','wolf',\n",
    "         'rich','happy','sad']\n",
    "\n",
    "embs = (W1.T + W2)/2.0\n",
    " \n",
    "# given a list of words and the embeddings, it returns a matrix with all the embeddings\n",
    "idx = [word2Ind[word] for word in words]\n",
    "X = embs[idx, :]\n",
    "print(X.shape, idx)  # X.shape:  Number of words of dimension N each "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result= compute_pca(X, 2)\n",
    "pyplot.scatter(result[:, 0], result[:, 1])\n",
    "for i, word in enumerate(words):\n",
    "    pyplot.annotate(word, xy=(result[i, 0], result[i, 1]))\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that man and king are next to each other. However, we have to be careful with the interpretation of this projected word vectors, since the PCA depends on the projection -- as shown in the following illustration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result= compute_pca(X, 4)\n",
    "pyplot.scatter(result[:, 3], result[:, 1])\n",
    "for i, word in enumerate(words):\n",
    "    pyplot.annotate(word, xy=(result[i, 3], result[i, 1]))\n",
    "pyplot.show()"
   ]
  }
 ],
 "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.9.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}