{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "![MLU Logo](../data/MLU_Logo.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Machine Learning Accelerator - Natural Language Processing - Lecture 3\n", "\n", "## Word Vectors\n", "Word vectors refers to a family of related techniques, first gaining popularity via ```Word2Vec``` which associates an $n$-dimensional (normally $n$ is in the range of $50$ to $500$. For us it will be $300$) vector to every word in the target language.\n", "\n", "We will first load a batch of word vectors known as [ConceptNet Numberbatch](https://github.com/commonsense/conceptnet-numberbatch), which have been found to have excellent performance while reducing issues of [learning human bias](https://gist.github.com/rspeer/ef750e7e407e04894cb3b78a82d66aed). Learning how to construct these word vectors is a bit beyond the scope of what we can cover in this notebook, but [this two-part blog post provides an excellent introduction](http://mccormickml.com/2016/04/19/word2vec-tutorial-the-skip-gram-model/).\n", "\n", "We will go over these:\n", "1. How to get the most from this notebook\n", "2. Computing Distances\n", "3. Linear Structure of Word Vectors (Subtraction)\n", "4. Reverse Lookup\n", "5. Application: Analogies\n", "6. Visualization (PCA)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Note: you may need to restart the kernel to use updated packages.\n" ] } ], "source": [ "%pip install -q -r ../requirements.txt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. How to get the most from this notebook\n", "(Go to top)\n", "\n", "This builds out a solution in a step by step manner making it clear where data is being used and what tools are useful for exploration. After every code block, I encourage you to explore your own problem from beginning to end using these tools." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "--2023-01-26 00:05:14-- https://conceptnet.s3.amazonaws.com/downloads/2017/numberbatch/numberbatch-en-17.06.txt.gz\n", "Resolving conceptnet.s3.amazonaws.com (conceptnet.s3.amazonaws.com)... 52.216.29.188, 52.216.43.89, 3.5.10.142, ...\n", "Connecting to conceptnet.s3.amazonaws.com (conceptnet.s3.amazonaws.com)|52.216.29.188|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 269500348 (257M) [text/plain]\n", "Saving to: ‘numberbatch-en-17.06.txt.gz’\n", "\n", "100%[======================================>] 269,500,348 46.3MB/s in 5.6s \n", "\n", "2023-01-26 00:05:19 (45.8 MB/s) - ‘numberbatch-en-17.06.txt.gz’ saved [269500348/269500348]\n", "\n" ] } ], "source": [ "# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved\n", "# SPDX-License-Identifier: MIT-0\n", "\n", "! wget https://conceptnet.s3.amazonaws.com/downloads/2017/numberbatch/numberbatch-en-17.06.txt.gz" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "! gzip -d numberbatch-en-17.06.txt.gz" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Load our libraries\n", "import pandas as pd\n", "import numpy as np\n", "\n", "# Load word vectors\n", "words = pd.read_csv('numberbatch-en-17.06.txt',\n", " sep=\" \",\n", " index_col=0,\n", " header=None,\n", " skiprows=[0]).transpose()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The code snippet above loads our wordvectors. The Pandas table ```words``` allows us to perform lookups like ```words['house']``` to get the associated vectors. Let's just print one out for reference." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 0.0331\n", "2 0.1253\n", "3 0.0865\n", "4 0.0641\n", "5 -0.1315\n", " ... \n", "296 -0.0046\n", "297 -0.0053\n", "298 0.0449\n", "299 -0.0277\n", "300 -0.0500\n", "Name: house, Length: 300, dtype: float64\n" ] } ], "source": [ "print(words['house'])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Such a vector is not particularly informative to us since it is not organized in a humanly readable way." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Computing Distances\n", "(Go to top)\n", "\n", "As part of our \"manipulation primitives\", we often need to be able to compute distances between vectors associated to words. So we start by writing a little snippet that lets us do so. ```numpy``` makes this fairly easy to do. Remember that small distances correspond to similar words, so lets check this by going through and writing a little code that takes three words and tells you if the first word is closer to the second than the third." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# define the distance between two words\n", "def dist(w1,w2) :\n", " return np.linalg.norm(words[w1] - words[w2])\n", " \n", "# Say if w1 is closer to w2 than w3\n", "def distCompare(w1, w2, w3) :\n", " d2 = dist(w1,w2)\n", " d3 = dist(w1,w3)\n", " if d2 < d3 :\n", " print(\"{} is closer to {} than {}\".format(w1,w2,w3))\n", " else :\n", " print(\"{} is closer to {} than {}\".format(w1,w3,w2))" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "orb is closer to ball than hockey\n", "picked is closer to lifted than play\n", "pink is closer to red than blue\n" ] } ], "source": [ "distCompare('orb','ball','hockey')\n", "distCompare('picked','lifted','play')\n", "distCompare('pink','red','blue')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We see that it mostly agrees with what we anticipated. If you continued to ask more questions, you'd find some things that disagree with what you would expect (for instance, it believes that ```'maroon'``` is closer to ```'blue'``` than ```'red'```), but on the whole, you'll find it agrees with the intuition that similar words should be close to one another. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Linear Structure of Word Vectors (Subtraction)\n", "(Go to top)\n", "\n", "If word vectors only put similar words next to one another, they would have never garnered the interest that they have obtained from the community. Indeed they actually contain subtle and nuanced understanding of the meanings of words. It will take a while to explore what this means, but the mantra that we should now internalize is \"relationships = directions\" which is to say that words that share a similar relationship, will be separated from one another in the same direction.\n", "\n", "As we saw, vector subtraction lets us examine this. However, since vector subtraction is as simple as\n", "```python\n", "diff = v - w\n", "```\n", "there is not much to look at here.\n", "\n", "## 4. Reverse Lookup\n", "(Go to top)\n", "\n", "Reverse lookup will allow us to probe the finer structure of word vectors. In particular, we will now create a reverse lookup routine that finds the $k$ closest words to a given vector. As the straight-forward implementation will be too slow (looping over every element of ```words```) we will provide you with a ```numpy``` implementation which will be fast enough for our needs." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['blue' 'bluecurls' 'bluishness' 'bluer' 'unblue' 'bluest' 'blueish'\n", " 'cyanol' 'bluely' 'gridelin' 'iridovirus' 'ceruleous' 'roygbiv'\n", " 'cyanophore' 'lazuline' 'berylline' 'acyanopia' 'bluing' 'blueness'\n", " 'chromostereopsis' 'umangite' 'red' 'yellowred' 'bluet' 'bluetit'\n", " 'purple' 'yellow' 'kumst' 'cerulean' 'purpre' 'mauvette' 'bepurple'\n", " 'bluish' 'purpureal' 'pyrrh' 'deredden' 'indigoidine' 'zaffre' 'argb'\n", " 'bloncket' 'turquoisey' 'puniceous' 'luteo' 'rubiform' 'xanthous'\n", " 'xanthochromic' 'crustaceorubin' 'tetronerythrin' 'vitellorubin'\n", " 'cyanophyll']\n" ] } ], "source": [ "# drop things containing underscores (these are compound terms like \"young_man\" that our code will not use) and convert to matrix format for faster computation\n", "labels = words.columns.values.tolist()\n", "labels = np.array([w for w in labels if isinstance(w,str) and w.isalpha()])\n", "wordsMatrix = words[labels].values\n", "\n", "# snipped to find the closest word (or vector)\n", "def find_closest_word(v, k = 1):\n", " if type(v) == type('str'):\n", " v = words[v]\n", " diff = wordsMatrix - v.values.reshape(-1,1)\n", " delta = np.linalg.norm(diff, axis=0)\n", " return labels[np.argsort(delta)[:k]]\n", " \n", "# test with the 50 closest words to blue\n", "print(find_closest_word('blue', 50))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Seems to work to me! Lots of blue related words, and then words related to other colors. Many of them, like ```'tetronerythrin'``` actually relate to specific pigments." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5. Application: Analogies\n", "(Go to top)\n", "\n", "Let us suppose that we have four associated word vectors $v_{man}$, $v_{woman}$, $v_{boy}$, and $v_{girl}$. If we believe the idea that \"relationship = direction\" then, this becomes a vector relationship, where the vector that takes us from $v_{man}$ to $v_{woman}$ should be the same as the vector that takes us from $v_{boy}$ to $v_{girl}$. Recalling that vector subtraction is what gives us such a direction, this becomes\n", "$$\n", "v_{woman} - v_{man} \\approx v_{girl} - v_{boy}\n", "$$\n", "\n", "Suppose you now wanted to solve an analogy using this idea. Say we were just given ```man:woman::boy:?``` and we wanted to find the question mark. The expression above can be rearranged by adding $v_{boy}$ to both sides to yield\n", "$$\n", "v_{?} \\approx v_{woman} - v_{man} + v_{boy}\n", "$$\n", "Thus the word we are looking for should hopefully be the word whose associated vector is closest to $v_{woman} - v_{man} + v_{boy}$. Let's see how this works out in code." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# A little snippet for analogies\n", "def analogy(w1,w2,w3, k = 1) : \n", " listPoss = find_closest_word(words[w2] - words[w1] + words[w3], k)\n", " print(\"{} : {} :: {} : {}\".format(w1,w2,w3,listPoss))" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "man : woman :: boy : ['girl' 'boy']\n", "short : tall :: shortest : ['tallest' 'tall']\n", "seattle : washington :: minneapolis : ['minnesota' 'minneapolis']\n" ] } ], "source": [ "# A few examples\n", "analogy('man','woman','boy', 2)\n", "analogy('short','tall','shortest', 2)\n", "analogy('seattle','washington','minneapolis', 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "All in all, this should have worked fantastically! The first one will indeed show that ```man : woman :: boy : girl``` as the most likely choice. The second will state that ```short : tall :: shortest : tallest``` is the most likely case indicating that it understands how to turn words into superlatives (not just a simple relationship of size). The third one indicates it understands what the largest cities in Washington and Minnesota are and can retrieve that information if needed." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 6. Visualization (PCA)\n", "(Go to top)\n", "\n", "Let's implement our last little primitive: the ability to automatically visualize what a collection of vectors is doing by projecting it onto the best possible pair of directions. We will use [sklearn](http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html) to do this." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "from sklearn.decomposition import PCA\n", "\n", "def pcaPlot(word_list) :\n", " # fetch list of word vectors\n", " vecs = [words[x] for x in word_list]\n", " \n", " #reduce dimensions\n", " model = PCA(n_components = 2)\n", " reduced = model.fit_transform(vecs)\n", " xc = [v[0] for v in reduced]\n", " yc = [v[1] for v in reduced]\n", " \n", " # plot them\n", " plt.figure(figsize=(10,10))\n", " plt.scatter(xc, yc)\n", "\n", " # label the plot\n", " for i, word in enumerate(word_list) :\n", " \tplt.annotate(word, xy=(xc[i], yc[i]+0.01), fontsize=12)\n", " plt.show()\n", "\n", "pcaPlot(['fast','faster','fastest','slow','slower','slowest'])\n", "pcaPlot(['bird', 'cat', 'squirrel', 'dog', 'fish', 'helicopter', 'airplane', 'car', 'submarine', 'whale'])" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# Deleting notebook artifacts\n", "! rm -rf numberbatch-en-17.06.txt.gz\n", "! rm numberbatch-en-17.06.txt" ] } ], "metadata": { "kernelspec": { "display_name": "conda_pytorch_p39", "language": "python", "name": "conda_pytorch_p39" }, "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.13" } }, "nbformat": 4, "nbformat_minor": 2 }