w2v.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import timeit\n",
    "import random\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import theano\n",
    "import theano.tensor as T\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import glob\n",
    "import os.path as op\n",
    "import cPickle as pickle\n",
    "from abc import ABCMeta, abstractmethod\n",
    "\n",
    "\n",
    "# This is a bit of magic to make matplotlib figures appear inline in the notebook\n",
    "# rather than in a new window.\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# Some more magic so that the notebook will reload external python modules;\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#mostly from stanford Deep NLP course source\n",
    "\n",
    "class Corpus(object):\n",
    "    \n",
    "    __metaclass__ = ABCMeta\n",
    "    \n",
    "    def __init__(self, corpusPath):\n",
    "        self.corpusPath = corpusPath\n",
    "    \n",
    "    @abstractmethod\n",
    "    def sentences(self):\n",
    "        return None\n",
    "    \n",
    "    \n",
    "    def tokens(self):\n",
    "        if hasattr(self, \"_tokens\") and self._tokens:\n",
    "            return self._tokens\n",
    "\n",
    "        tokens = dict()\n",
    "        tokenfreq = dict()\n",
    "        wordcount = 0\n",
    "        revtokens = []\n",
    "        idx = 0\n",
    "\n",
    "        for sentence in self.sentences():\n",
    "            for w in sentence:\n",
    "                wordcount += 1\n",
    "                if not w in tokens:\n",
    "                    tokens[w] = idx\n",
    "                    revtokens += [w]\n",
    "                    tokenfreq[w] = 1\n",
    "                    idx += 1\n",
    "                else:\n",
    "                    tokenfreq[w] += 1\n",
    "\n",
    "        tokens[\"UNK\"] = idx\n",
    "        revtokens += [\"UNK\"]\n",
    "        tokenfreq[\"UNK\"] = 1\n",
    "        wordcount += 1\n",
    "\n",
    "        self._tokens = tokens\n",
    "        self._tokenfreq = tokenfreq\n",
    "        self._wordcount = wordcount\n",
    "        self._revtokens = revtokens\n",
    "        return self._tokens\n",
    "    \n",
    "    def numSentences(self):\n",
    "        if hasattr(self, \"_numSentences\") and self._numSentences:\n",
    "            return self._numSentences\n",
    "        else:\n",
    "            self._numSentences = len(self.sentences())\n",
    "            return self._numSentences\n",
    "        \n",
    "    def getRandomContext(self, C=5):\n",
    "        allsent = self.allSentences()\n",
    "        sentID = random.randint(0, len(allsent) - 1)\n",
    "        sent = allsent[sentID]\n",
    "        wordID = random.randint(0, len(sent) - 1)\n",
    "\n",
    "        context = sent[max(0, wordID - C):wordID] \n",
    "        if wordID+1 < len(sent):\n",
    "            context += sent[wordID+1:min(len(sent), wordID + C + 1)]\n",
    "\n",
    "        centerword = sent[wordID]\n",
    "        context = [w for w in context if w != centerword]\n",
    "\n",
    "        if len(context) > 0:\n",
    "            return centerword, context\n",
    "        else:\n",
    "            return self.getRandomContext(C) \n",
    "        \n",
    "\n",
    "        \n",
    "    def allSentences(self):\n",
    "        if hasattr(self, \"_allsentences\") and self._allsentences:\n",
    "            return self._allsentences\n",
    "\n",
    "        sentences = self.sentences()\n",
    "        rejectProb = self.rejectProb()\n",
    "        tokens = self.tokens()\n",
    "        allsentences = [[w for w in s \n",
    "            if 0 >= rejectProb[tokens[w]] or random.random() >= rejectProb[tokens[w]]]\n",
    "            for s in sentences * 30]\n",
    "\n",
    "        allsentences = [s for s in allsentences if len(s) > 1]\n",
    "        \n",
    "        self._allsentences = allsentences\n",
    "        \n",
    "        return self._allsentences  \n",
    "\n",
    "    \n",
    "    def rejectProb(self):\n",
    "        if hasattr(self, '_rejectProb') and self._rejectProb is not None:\n",
    "            return self._rejectProb\n",
    "\n",
    "        threshold = 1e-5 * self._wordcount\n",
    "\n",
    "        nTokens = len(self.tokens())\n",
    "        rejectProb = np.zeros((nTokens,))\n",
    "        for i in xrange(nTokens):\n",
    "            w = self._revtokens[i]\n",
    "            freq = 1.0 * self._tokenfreq[w]\n",
    "            # Reweigh\n",
    "            rejectProb[i] = max(0, 1 - np.sqrt(threshold / freq))\n",
    "\n",
    "        self._rejectProb = rejectProb\n",
    "        return self._rejectProb    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Word2VecNet(object):\n",
    "    \n",
    "    __metaclass__ = ABCMeta\n",
    "    \n",
    "    def __init__(self, vector_size, vocabs_size):\n",
    "        \n",
    "        self.W_in_values = np.asarray((np.random.rand(vocabs_size, vector_size) - 0.5) / vector_size,\n",
    "                                      dtype=theano.config.floatX)\n",
    "\n",
    "                \n",
    "        \n",
    "        self.W_out_values = np.asarray(np.zeros((vocabs_size, vector_size)),\n",
    "                                      dtype=theano.config.floatX)     \n",
    "        \n",
    "        self.W_in = theano.shared(\n",
    "            value=self.W_in_values,\n",
    "            name='W_in',\n",
    "            borrow=True\n",
    "        )\n",
    "\n",
    "        self.W_out = theano.shared(\n",
    "            value=self.W_out_values,\n",
    "            name='W_out',\n",
    "            borrow=True\n",
    "        )  \n",
    "\n",
    "    \n",
    "    @abstractmethod\n",
    "    def cost_and_grad(self, win, wout):\n",
    "        return None\n",
    "    \n",
    "    def save(slef, file_name):\n",
    "        with open(\"{}.npy\",format(file_name) , \"w\") as f:\n",
    "            pickle.dump(self.W_in_values.shape, f)\n",
    "            pickle.dump(self.W_in_values, f)       \n",
    "            pickle.dump(self.W_out_values, f)\n",
    "    \n",
    "    \n",
    "    def load(self, file_name):\n",
    "        with open(\"{}.npy\",format(file_name), \"r\") as f:\n",
    "            _ = pickle.load(f)\n",
    "            self.W_in_values[:] = pickle.load(f)\n",
    "            self.W_out_values[:] = pickle.load(f)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Word2VecTrainer(object):\n",
    "    \n",
    "    __metaclass__ = ABCMeta\n",
    "    \n",
    "    def __init__(self, w2v_net, corpus):\n",
    "        \n",
    "        self.w2v_net = w2v_net\n",
    "        self.corpus = corpus\n",
    "        self.tokens = corpus.tokens()\n",
    "        \n",
    "        context = T.dvector('context')\n",
    "        target = T.lscalar('target')\n",
    "        \n",
    "        \n",
    "        self.train_model = theano.function([context, target], \n",
    "                                           self.w2v_net.cost_and_grad(context, target))\n",
    "        \n",
    "    \n",
    "    \n",
    "    def train(self,\n",
    "              window_size=5,\n",
    "              learning_rate=0.3,\n",
    "              iterations=5000,\n",
    "              batch_size=50,\n",
    "              anneal_every=20000,\n",
    "              print_every=10):\n",
    "        \n",
    "        print 'Start Training'\n",
    "        \n",
    "        start_it = 1\n",
    "        for it in range(start_it, iterations + 1):\n",
    "            \n",
    "            cost, grad_in, grad_out = self.train_one_batch(window_size, batch_size)\n",
    "            \n",
    "            self.w2v_net.W_in_values -= learning_rate * grad_in\n",
    "            self.w2v_net.W_out_values -= learning_rate * grad_out\n",
    "            \n",
    "            if it % 10 == 0:\n",
    "                print 'Iteration:{}, Cost {}'.format(it, cost)\n",
    "                \n",
    "            if it % anneal_every == 0:\n",
    "                learning_rate *= 0.5 \n",
    "                \n",
    "        return cost, grad_in, grad_out\n",
    "    \n",
    "        \n",
    "    \n",
    "    def train_one_batch(self, window_size, batch_size):\n",
    "        cost = 0.0\n",
    "        grad_in = np.zeros_like(self.w2v_net.W_in_values)\n",
    "        grad_out = np.zeros_like(self.w2v_net.W_out_values)\n",
    "        \n",
    "        for i in range(batch_size):\n",
    "            c = random.randint(1, window_size)\n",
    "            centerword, context = self.corpus.getRandomContext(c)\n",
    "            c_cost, gin, gout = self.train_one_step(centerword, context)\n",
    "            cost += c_cost / batch_size \n",
    "            grad_in += gin / batch_size\n",
    "            grad_out += gout / batch_size\n",
    "        \n",
    "        return cost, grad_in, grad_out\n",
    "    \n",
    "    @abstractmethod\n",
    "    def train_one_step(self, centerword, context):\n",
    "        return None\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class CBOWTrainer(Word2VecTrainer):\n",
    "    \n",
    "    def train_one_step(self, centerword, context):\n",
    "        \n",
    "        cost = 0.\n",
    "        \n",
    "        grad_in = np.zeros_like(self.w2v_net.W_in_values)\n",
    "        grad_out = np.zeros_like(self.w2v_net.W_out_values)\n",
    "        \n",
    "        target_word_index = self.tokens[centerword]\n",
    "        \n",
    "        for j in context:\n",
    "            current_word_index = self.tokens[j]\n",
    "            r = self.w2v_net.W_in_values[current_word_index]\n",
    "            c_cost, c_grad_in, c_grad_out = self.train_model(r, target_word_index)\n",
    "            cost += c_cost\n",
    "            grad_out += c_grad_out \n",
    "            grad_in[current_word_index,:] += c_grad_in.flatten()      \n",
    "\n",
    "        return cost    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class SkipGramTrainer(Word2VecTrainer):\n",
    "    \n",
    "    def train_one_step(self, centerword, context):\n",
    "        \n",
    "        cost = 0.\n",
    "        \n",
    "        grad_in = np.zeros_like(self.w2v_net.W_in_values)\n",
    "        grad_out = np.zeros_like(self.w2v_net.W_out_values)\n",
    "        \n",
    "        target_word_index = self.tokens[centerword]\n",
    "        r = self.w2v_net.W_in_values[target_word_index]\n",
    "        \n",
    "        for j in context:\n",
    "            current_word_index = self.tokens[j]\n",
    "            c_cost, c_grad_in, c_grad_out = self.train_model(r, current_word_index)\n",
    "            cost += c_cost\n",
    "            grad_out += c_grad_out \n",
    "            grad_in[current_word_index,:] += c_grad_in.flatten()\n",
    "                   \n",
    "\n",
    "        return cost, grad_in, grad_out     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class ClassicalWord2VecNet(Word2VecNet):\n",
    "    \n",
    "    def cost_and_grad(self, win, wout):\n",
    "        \n",
    "        p_wout_given_win = T.nnet.softmax(T.dot(win, self.W_out.T)).dimshuffle(1, 0)\n",
    "        \n",
    "    \n",
    "        cost = -T.log(p_wout_given_win[wout])\n",
    "        \n",
    "        foo = T.zeros_like(p_wout_given_win)\n",
    "        T.set_subtensor(foo[wout], 1)\n",
    "        \n",
    "        z = p_wout_given_win - foo\n",
    "        \n",
    "        grad_in = T.dot(self.W_out.T, z)\n",
    "        grad_out = T.outer(z, win)\n",
    "        \n",
    "        return cost, grad_in, grad_out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class StanfordSentimentCorpus(Corpus):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super(StanfordSentimentCorpus, self).__init__('datasets/stanfordSentimentTreebank/datasetSentences.txt')\n",
    "    \n",
    "    def sentences(self):\n",
    "        if hasattr(self, \"_sentences\") and self._sentences:\n",
    "            return self._sentences\n",
    "\n",
    "        sentences = []\n",
    "        with open(self.corpusPath, \"r\") as f:\n",
    "            first = True\n",
    "            for line in f:\n",
    "                if first:\n",
    "                    first = False\n",
    "                    continue\n",
    "\n",
    "                splitted = line.strip().split()[1:]\n",
    "                # Deal with some peculiar encoding issues with this file\n",
    "                sentences += [[w.lower().decode(\"utf-8\").encode('latin1') for w in splitted]]\n",
    "                \n",
    "        self._sentences = sentences\n",
    "        self._sentlengths = np.array([len(s) for s in sentences])\n",
    "        self._cumsentlen = np.cumsum(self._sentlengths)\n",
    "\n",
    "        return self._sentences        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "random.seed(314)\n",
    "corpus = StanfordSentimentCorpus()\n",
    "vocabs_size = len(corpus.tokens())\n",
    "# We are going to train 10-dimensional vectors for this assignment\n",
    "vector_size = 10\n",
    "\n",
    "# Context size\n",
    "C = 5\n",
    "iterations = 1000\n",
    "step = 0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start Training\n",
      "Iteration:10, Cost [ 27.46686634]\n",
      "Iteration:20, Cost [ 23.91000595]\n",
      "Iteration:30, Cost [ 27.46686634]\n",
      "Iteration:40, Cost [ 29.44289989]\n",
      "Iteration:50, Cost [ 24.1076093]\n",
      "Iteration:60, Cost [ 26.87405627]\n",
      "Iteration:70, Cost [ 31.41893344]\n",
      "Iteration:80, Cost [ 27.66446969]\n",
      "Iteration:90, Cost [ 33.98777705]\n",
      "Iteration:100, Cost [ 26.87405627]\n",
      "Iteration:110, Cost [ 24.89802272]\n",
      "Iteration:120, Cost [ 27.66446969]\n",
      "Iteration:130, Cost [ 30.62852002]\n",
      "Iteration:140, Cost [ 30.03570995]\n",
      "Iteration:150, Cost [ 24.50281601]\n",
      "Iteration:160, Cost [ 31.81414015]\n",
      "Iteration:170, Cost [ 24.50281601]\n",
      "Iteration:180, Cost [ 29.44289989]\n",
      "Iteration:190, Cost [ 26.67645292]\n",
      "Iteration:200, Cost [ 27.26926298]\n",
      "Iteration:210, Cost [ 31.22133008]\n",
      "Iteration:220, Cost [ 30.62852002]\n",
      "Iteration:230, Cost [ 29.64050324]\n",
      "Iteration:240, Cost [ 29.24529653]\n",
      "Iteration:250, Cost [ 30.82612337]\n",
      "Iteration:260, Cost [ 26.47884956]\n",
      "Iteration:270, Cost [ 29.04769318]\n",
      "Iteration:280, Cost [ 25.8860395]\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-15-86a779b37d2a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mw2vecNet\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mClassicalWord2VecNet\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvector_size\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvocabs_size\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mtrainer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mSkipGramTrainer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mw2vecNet\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcorpus\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mcost\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtrainer\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mC\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mstep\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0miterations\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-4-5101fde4347c>\u001b[0m in \u001b[0;36mtrain\u001b[1;34m(self, window_size, learning_rate, iterations, batch_size, anneal_every, print_every)\u001b[0m\n\u001b[0;32m     31\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0mit\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mstart_it\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0miterations\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     32\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 33\u001b[1;33m             \u001b[0mcost\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrad_in\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrad_out\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtrain_one_batch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mwindow_size\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     34\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     35\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mw2v_net\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mW_in_values\u001b[0m \u001b[1;33m-=\u001b[0m \u001b[0mlearning_rate\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mgrad_in\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-4-5101fde4347c>\u001b[0m in \u001b[0;36mtrain_one_batch\u001b[1;34m(self, window_size, batch_size)\u001b[0m\n\u001b[0;32m     56\u001b[0m             \u001b[0mc_cost\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgin\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgout\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtrain_one_step\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcenterword\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcontext\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     57\u001b[0m             \u001b[0mcost\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mc_cost\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 58\u001b[1;33m             \u001b[0mgrad_in\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mgin\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     59\u001b[0m             \u001b[0mgrad_out\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mgout\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     60\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "random.seed(31415)\n",
    "np.random.seed(9265)\n",
    "\n",
    "w2vecNet = ClassicalWord2VecNet(vector_size, vocabs_size)\n",
    "trainer = SkipGramTrainer(w2vecNet, corpus)\n",
    "cost = trainer.train(C, step, iterations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.096909986803016365, 0.056175580971282488)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnMAAAHiCAYAAACDYkp1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1c229d30>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the word vectors you trained\n",
    "\n",
    "tokens = corpus.tokens()\n",
    "wordVectors = (w2vecNet.W_in_values + w2vecNet.W_out_values)\n",
    "visualizeWords = [\"the\", \"a\", \"an\", \",\", \".\", \"?\", \"!\", \"``\", \"''\", \"--\", \"good\", \"great\", \"cool\", \"brilliant\", \"wonderful\", \"well\", \"amazing\", \"worth\", \"sweet\", \"enjoyable\", \"boring\", \"bad\", \"waste\", \"dumb\", \"annoying\"]\n",
    "visualizeIdx = [tokens[word] for word in visualizeWords]\n",
    "visualizeVecs = wordVectors[visualizeIdx, :]\n",
    "temp = (visualizeVecs - np.mean(visualizeVecs, axis=0))\n",
    "covariance = 1.0 / len(visualizeIdx) * temp.T.dot(temp)\n",
    "U,S,V = np.linalg.svd(covariance)\n",
    "coord = temp.dot(U[:,0:2]) \n",
    "\n",
    "for i in xrange(len(visualizeWords)):\n",
    "    plt.text(coord[i,0], coord[i,1], visualizeWords[i], bbox=dict(facecolor='green', alpha=0.1))\n",
    "    \n",
    "plt.xlim((np.min(coord[:,0]), np.max(coord[:,0])))\n",
    "plt.ylim((np.min(coord[:,1]), np.max(coord[:,1])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}