C1-natural-language-processing-with-classification-and-vector-spaces/Week3/C1_W3_lecture_nb_02_manipulating_word_embeddings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manipulating word embeddings \n",
    "\n",
    "In this week's assignment, you are going to use a pre-trained word embedding for finding word analogies and equivalence. This exercise can be used as an Intrinsic Evaluation for the word embedding performance. In this notebook, you will apply linear algebra operations using NumPy to find analogies between words manually. This will help you to prepare for this week's assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd # Library for Dataframes \n",
    "import numpy as np # Library for math functions\n",
    "import pickle # Python object serialization library. Not secure\n",
    "\n",
    "word_embeddings = pickle.load( open( \"./data/word_embeddings_subset.p\", \"rb\" ) )\n",
    "len(word_embeddings) # there should be 243 words that will be used in this assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that the model is loaded, we can take a look at the word representations. First, note that **word_embeddings** is a dictionary. Each word is the key to the entry, and the value is its corresponding vector presentation. Remember that square brackets allow access to any entry if the key exists. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "countryVector = word_embeddings['country'] # Get the vector representation for the word 'country'\n",
    "print(type(countryVector)) # Print the type of the vector. Note it is a numpy array\n",
    "print(countryVector) # Print the values of the vector.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to note that we store each vector as a NumPy array. It allows us to use the linear algebra operations on it. \n",
    "\n",
    "The vectors have a size of 300, while the vocabulary size of Google News is around 3 million words! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Get the vector for a given word:\n",
    "def vec(w):\n",
    "    return word_embeddings[w]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operating on word embeddings\n",
    "\n",
    "Remember that understanding the data is one of the most critical steps in Data Science. Word embeddings are the result of machine learning processes and will be part of the input for further processes. These word embedding needs to be validated or at least understood because the performance of the derived model will strongly depend on its quality.\n",
    "\n",
    "Word embeddings are multidimensional arrays, usually with hundreds of attributes that pose a challenge for its interpretation. \n",
    "\n",
    "In this notebook, we will visually inspect the word embedding of some words using a pair of attributes. Raw attributes are not the best option for the creation of such charts but will allow us to illustrate the mechanical part in Python. \n",
    "\n",
    "In the next cell, we make a beautiful plot for the word embeddings of some words. Even if plotting the dots gives an idea of the words, the arrow representations help to visualize the vector's alignment as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt # Import matplotlib\n",
    "%matplotlib inline\n",
    "\n",
    "words = ['oil', 'gas', 'happy', 'sad', 'city', 'town', 'village', 'country', 'continent', 'petroleum', 'joyful']\n",
    "\n",
    "bag2d = np.array([vec(word) for word in words]) # Convert each word to its vector representation\n",
    "\n",
    "fig, ax = plt.subplots(figsize = (10, 10)) # Create custom size image\n",
    "\n",
    "col1 = 3 # Select the column for the x axis\n",
    "col2 = 2 # Select the column for the y axis\n",
    "\n",
    "# Print an arrow for each word\n",
    "for word in bag2d:\n",
    "    ax.arrow(0, 0, word[col1], word[col2], head_width=0.005, head_length=0.005, fc='r', ec='r', width = 1e-5)\n",
    "\n",
    "    \n",
    "ax.scatter(bag2d[:, col1], bag2d[:, col2]); # Plot a dot for each word\n",
    "\n",
    "# Add the word label over each dot in the scatter plot\n",
    "for i in range(0, len(words)):\n",
    "    ax.annotate(words[i], (bag2d[i, col1], bag2d[i, col2]))\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that similar words like 'village' and 'town' or 'petroleum', 'oil', and 'gas' tend to point in the same direction. Also, note that 'sad' and 'happy' looks close to each other; however, the vectors point in opposite directions.\n",
    "\n",
    "In this chart, one can figure out the angles and distances between the words. Some words are close in both kinds of distance metrics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Word distance\n",
    "\n",
    "Now plot the words 'sad', 'happy', 'town', and 'village'. In this same chart, display the vector from 'village' to 'town' and the vector from 'sad' to 'happy'. Let us use NumPy for these linear algebra operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = ['sad', 'happy', 'town', 'village']\n",
    "\n",
    "bag2d = np.array([vec(word) for word in words]) # Convert each word to its vector representation\n",
    "\n",
    "fig, ax = plt.subplots(figsize = (10, 10)) # Create custom size image\n",
    "\n",
    "col1 = 3 # Select the column for the x axe\n",
    "col2 = 2 # Select the column for the y axe\n",
    "\n",
    "# Print an arrow for each word\n",
    "for word in bag2d:\n",
    "    ax.arrow(0, 0, word[col1], word[col2], head_width=0.0005, head_length=0.0005, fc='r', ec='r', width = 1e-5)\n",
    "    \n",
    "# print the vector difference between village and town\n",
    "village = vec('village')\n",
    "town = vec('town')\n",
    "diff = town - village\n",
    "ax.arrow(village[col1], village[col2], diff[col1], diff[col2], fc='b', ec='b', width = 1e-5)\n",
    "\n",
    "# print the vector difference between village and town\n",
    "sad = vec('sad')\n",
    "happy = vec('happy')\n",
    "diff = happy - sad\n",
    "ax.arrow(sad[col1], sad[col2], diff[col1], diff[col2], fc='b', ec='b', width = 1e-5)\n",
    "\n",
    "\n",
    "ax.scatter(bag2d[:, col1], bag2d[:, col2]); # Plot a dot for each word\n",
    "\n",
    "# Add the word label over each dot in the scatter plot\n",
    "for i in range(0, len(words)):\n",
    "    ax.annotate(words[i], (bag2d[i, col1], bag2d[i, col2]))\n",
    "\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear algebra on word embeddings\n",
    "\n",
    "In the lectures, we saw the analogies between words using algebra on word embeddings. Let us see how to do it in Python with Numpy.\n",
    "\n",
    "To start, get the **norm** of a word in the word embedding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.linalg.norm(vec('town'))) # Print the norm of the word town\n",
    "print(np.linalg.norm(vec('sad'))) # Print the norm of the word sad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predicting capitals\n",
    "\n",
    "Now, applying vector difference and addition, one can create a vector representation for a new word. For example, we can say that the vector difference between 'France' and 'Paris' represents the concept of Capital.\n",
    "\n",
    "One can move from the city of Madrid in the direction of the concept of Capital, and obtain something close to the corresponding country to which Madrid is the Capital."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capital = vec('France') - vec('Paris')\n",
    "country = vec('Madrid') + capital\n",
    "\n",
    "print(country[0:5]) # Print the first 5 values of the vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can observe that the vector 'country' that we expected to be the same as the vector for Spain is not exactly it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diff = country - vec('Spain')\n",
    "print(diff[0:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, we have to look for the closest words in the embedding that matches the candidate country. If the word embedding works as expected, the most similar word must be 'Spain'. Let us define a function that helps us to do it. We will store our word embedding as a DataFrame, which facilitate the lookup operations based on the numerical vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a dataframe out of the dictionary embedding. This facilitate the algebraic operations\n",
    "keys = word_embeddings.keys()\n",
    "data = []\n",
    "for key in keys:\n",
    "    data.append(word_embeddings[key])\n",
    "\n",
    "embedding = pd.DataFrame(data=data, index=keys)\n",
    "# Define a function to find the closest word to a vector:\n",
    "def find_closest_word(v, k = 1):\n",
    "    # Calculate the vector difference from each word to the input vector\n",
    "    diff = embedding.values - v \n",
    "    # Get the norm of each difference vector. \n",
    "    # It means the squared euclidean distance from each word to the input vector\n",
    "    delta = np.sum(diff * diff, axis=1)\n",
    "    # Find the index of the minimun distance in the array\n",
    "    i = np.argmin(delta)\n",
    "    # Return the row name for this item\n",
    "    return embedding.iloc[i].name\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print some rows of the embedding as a Dataframe\n",
    "embedding.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let us find the name that corresponds to our numerical country:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_closest_word(country)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predicting other Countries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_closest_word(vec('Italy') - vec('Rome') + vec('Madrid'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(find_closest_word(vec('Berlin') + capital))\n",
    "print(find_closest_word(vec('Beijing') + capital))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, it does not always work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(find_closest_word(vec('Lisbon') + capital))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Represent a sentence as a vector\n",
    "\n",
    "A whole sentence can be represented as a vector by summing all the word vectors that conform to the sentence. Let us see. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "doc = \"Spain petroleum city king\"\n",
    "vdoc = [vec(x) for x in doc.split(\" \")]\n",
    "doc2vec = np.sum(vdoc, axis = 0)\n",
    "doc2vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_closest_word(doc2vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Congratulations! You have finished the introduction to word embeddings manipulation!**"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}