NLP/WordVector/GloveDemo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ J = \\sum_{i, j=1}^{V}f(X_{ij})(Wi^{T}  Wj + b_{j} + b_{i} - log(X_{ij}))^{2} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division\n",
    "from collections import defaultdict, Counter\n",
    "\n",
    "\n",
    "import os\n",
    "import tensorflow as tf\n",
    "from random import shuffle\n",
    "import jieba"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [],
   "source": [
    "corpus = \"\"\"\n",
    "我喜欢吃苹果，也喜欢跑步。\n",
    "我喜欢吃香蕉，也喜欢散步。\n",
    "他喜欢吃苹果，也喜欢跑步。\n",
    "他喜欢吃香蕉，也喜欢散步。\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NotFitToCorpusError(Exception):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Glove(object):\n",
    "    def __init__(self, window_size,max_vocab_size,min_cooccurrence, embedding_size, \n",
    "                 coocurrence_max=100, alpha=0.75, batch_size=10, learning_rate=0.1):\n",
    "        if type(window_size) == tuple:\n",
    "            self.left_size, self.right_size = window_size\n",
    "        else:\n",
    "            self.left_size = self.right_size = window_size\n",
    "        \n",
    "        self.max_vocab_size = max_vocab_size\n",
    "        self.min_cooccurrence = min_cooccurrence\n",
    "        self.embedding_size = embedding_size\n",
    "        self.coocurrence_max = coocurrence_max\n",
    "        self.alpha = alpha\n",
    "        self.batch_size = batch_size\n",
    "        self.__embedding = None\n",
    "        self.__cooccurrence_matrix = None\n",
    "        self.learning_rate = learning_rate\n",
    "        \n",
    "    def _window(self, region, start, end):\n",
    "        '''\n",
    "        return list of words from start index to end index of region\n",
    "        '''\n",
    "        last_index = len(region) + 1\n",
    "        return region[max(0, start): min(end, last_index) + 1]\n",
    "    \n",
    "    def _context_window(self, region):\n",
    "        for i, word in enumerate(region):\n",
    "            start = i - self.left_size\n",
    "            end = i + self.right_size\n",
    "            left_context = self._window(region, start, i-1)\n",
    "            right_context = self._window(region, i+1, end)\n",
    "            yield (left_context, word, right_context)\n",
    "    \n",
    "    def fit_corpus(self, corpus):\n",
    "        self._fit_corpus(corpus, self.max_vocab_size, self.min_cooccurrence)\n",
    "        self.build_model()\n",
    "    \n",
    "    def _fit_corpus(self, corpus, vocab_size, min_count):\n",
    "        words = Counter()\n",
    "        coocurrence_counts = defaultdict(float)\n",
    "        for region in corpus:\n",
    "            words.update(region)\n",
    "            for left_context, word, right_context in self._context_window(region):\n",
    "                # add 1 / distance to word pair\n",
    "                for i, c in enumerate(left_context[::-1]):\n",
    "                    coocurrence_counts[(word, c)] += 1 / (i + 1)\n",
    "                for i, c in enumerate(right_context):\n",
    "                    coocurrence_counts[(word, c)] += 1 / (i + 1)\n",
    "        \n",
    "        self.__words = [word for word, count in words.most_common(vocab_size) if count >= min_count]\n",
    "        self.__word_2_id = {w: _id for _id, w in enumerate(self.__words)}\n",
    "        self.__cooccurrence_matrix = {(self.__word_2_id[word_pair[0]], self.__word_2_id[word_pair[1]]): count\n",
    "                                     for word_pair, count in coocurrence_counts.items()\n",
    "                                     if word_pair[0] in self.__words and word_pair[1] in self.__words}\n",
    "        \n",
    "        \n",
    "    def build_model(self):\n",
    "        self.__graph = tf.Graph()\n",
    "        with self.__graph.as_default():\n",
    "            count_max = tf.constant([self.coocurrence_max], dtype=tf.float32, name='coocurrence_max')\n",
    "            alpha = tf.constant([self.alpha], dtype=tf.float32, name='alpha')\n",
    "\n",
    "            self.__focus_input = tf.placeholder(tf.int32, shape=[self.batch_size], name='focus_words')\n",
    "            self.__context_input = tf.placeholder(tf.int32, shape=[self.batch_size], name='context_words')\n",
    "            self.__cooccurrance_count = tf.placeholder(tf.float32, shape=[self.batch_size], name='cooccurrance_count')\n",
    "\n",
    "            focus_embeddings = tf.Variable(tf.random_uniform([self.vocab_size, self.embedding_size], 1.0, -1.0, name='focus_embeddings'))\n",
    "            context_embeddings = tf.Variable(tf.random_uniform([self.vocab_size, self.embedding_size], 1.0, -1.0, name='context_embeddings'))\n",
    "            focus_bias = tf.Variable(tf.random_uniform([self.vocab_size], 1.0, -1.0, name='focus_bias'))\n",
    "            context_bias = tf.Variable(tf.random_uniform([self.vocab_size], 1.0, -1.0, name='context_bias'))\n",
    "\n",
    "            focus_emb = tf.nn.embedding_lookup([focus_embeddings], self.__focus_input)\n",
    "            context_emb = tf.nn.embedding_lookup([context_embeddings], self.__context_input)\n",
    "            focus_b = tf.nn.embedding_lookup([focus_bias], self.__focus_input)\n",
    "            context_b = tf.nn.embedding_lookup([context_bias], self.__context_input)\n",
    "\n",
    "            weighting_factor = tf.minimum(1.0, tf.pow(tf.div(self.__cooccurrance_count, count_max), alpha))\n",
    "\n",
    "            embedding_product = tf.reduce_sum(tf.multiply(focus_emb, context_emb), 1)\n",
    "            log_cooccurrence = tf.log(tf.to_float(self.__cooccurrance_count))\n",
    "\n",
    "            distance_exp = tf.square(tf.add_n([embedding_product, focus_b, context_b, tf.negative(log_cooccurrence)]))\n",
    "            loss_one = tf.multiply(weighting_factor, distance_exp)\n",
    "\n",
    "            self.__total_loss = tf.reduce_sum(loss_one)\n",
    "#             tf.summary.scalar('glove_loss', self.__total_loss)\n",
    "            print(self.__total_loss)\n",
    "            self.__optimizer = tf.train.AdagradOptimizer(self.learning_rate).minimize(self.__total_loss)\n",
    "#             tf.summary = tf.summary.merge_all()\n",
    "            self.combine_embedding = tf.add(focus_embeddings, context_embeddings, name='combine_embedding')\n",
    "\n",
    "    def train(self, epochs):\n",
    "        batches = self.__prepare_batches()\n",
    "        total_step = 0\n",
    "        \n",
    "        with tf.Session(graph=self.__graph) as sess:\n",
    "            tf.global_variables_initializer().run()\n",
    "            \n",
    "            for epoch in range(epochs):\n",
    "                shuffle(batches)\n",
    "                for batch_data in batches:\n",
    "                    i_indexs, j_indexs, counts = batch_data\n",
    "                    if len(counts) != self.batch_size:\n",
    "                        continue\n",
    "                    \n",
    "                    feed_dict = {\n",
    "                        self.__focus_input: i_indexs,\n",
    "                        self.__context_input: j_indexs,\n",
    "                        self.__cooccurrance_count: counts\n",
    "                    }\n",
    "                    sess.run([self.__optimizer, self.__total_loss], feed_dict=feed_dict)\n",
    "                    total_step += 1\n",
    "                \n",
    "            self.__embedding = self.combine_embedding.eval()\n",
    "     \n",
    "    @property\n",
    "    def words(self):\n",
    "        if self.__words is None:\n",
    "            raise NotFitToCorpusError('need to fit copus before start model')\n",
    "        return self.__words\n",
    "    \n",
    "    @property\n",
    "    def vocab_size(self):\n",
    "        return len(self.words)\n",
    "    \n",
    "    @property\n",
    "    def embeddings(self):\n",
    "        if self.__embedding is None:\n",
    "            raise NotFitToCorpusError('not fit')\n",
    "        \n",
    "        return self.__embedding\n",
    "    \n",
    "    def generate_tsne(self, path=None, size=(100, 100), word_count=1000, embeddings=None):\n",
    "        if embeddings is None:\n",
    "            embeddings = self.embeddings\n",
    "        from sklearn.manifold import TSNE\n",
    "        tsne = TSNE(perplexity=30, n_components=2, init='pca', n_iter=5000)\n",
    "        low_dim_embs = tsne.fit_transform(embeddings[:word_count, :])\n",
    "        labels = self.words[:word_count]\n",
    "        return _plot_with_labels(low_dim_embs, labels, path, size)\n",
    "    \n",
    "    def __prepare_batches(self):\n",
    "        if self.__cooccurrence_matrix is None:\n",
    "            raise NotFitToCorpusError(\n",
    "                \"Need to fit model to corpus before preparing training batches.\")\n",
    "        cooccurrences = [(word_ids[0], word_ids[1], count)\n",
    "                         for word_ids, count in self.__cooccurrence_matrix.items()]\n",
    "        i_indices, j_indices, counts = zip(*cooccurrences)\n",
    "        return list(_batchify(self.batch_size, i_indices, j_indices, counts))\n",
    "    \n",
    "def _batchify(batch_size, *sequences):\n",
    "    for i in range(0, len(sequences[0]), batch_size):\n",
    "        yield tuple(sequence[i:i+batch_size] for sequence in sequences)\n",
    "\n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [],
   "source": [
    "#显示中文\n",
    "import matplotlib as mlt\n",
    "\n",
    "# [f.name for f in mlt.font_manager.fontManager.ttflist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _plot_with_labels(low_dim_embs, labels, path, size):\n",
    "    import matplotlib.pyplot as plt\n",
    "    assert low_dim_embs.shape[0] >= len(labels), \"More labels than embeddings\"\n",
    "    figure = plt.figure(figsize=size)  # in inches\n",
    "    \n",
    "    plt.rcParams['font.sans-serif'] = ['STFangsong']\n",
    "    for i, label in enumerate(labels):\n",
    "        x, y = low_dim_embs[i, :]\n",
    "        plt.scatter(x, y)\n",
    "        plt.annotate(label, xy=(x, y), xytext=(5, 2), textcoords='offset points', ha='right',\n",
    "                     va='bottom')\n",
    "    if path is not None:\n",
    "        figure.savefig(path)\n",
    "        plt.close(figure)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [],
   "source": [
    "corpus_list = corpus.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_words(cor):\n",
    "    stop_words = [',', '.', '，', '。', ':', '：', '/', '；']\n",
    "    cut_c = list(jieba.cut(cor))\n",
    "    return [c for c in cut_c if c not in stop_words]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [],
   "source": [
    "token = [split_words(cor) for cor in corpus_list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {},
   "outputs": [],
   "source": [
    "glove = Glove(window_size=5,max_vocab_size=100, min_cooccurrence = 1, embedding_size=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(\"Sum_1:0\", shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "glove.fit_corpus(token)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['喜欢', '吃', '也', '我', '苹果', '跑步', '香蕉', '散步', '他']"
      ]
     },
     "execution_count": 314,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "glove.words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [],
   "source": [
    "glove.train(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.52527547, -0.75928116,  0.61695457, -0.22688322,  0.56773937,\n",
       "         0.7498862 ,  0.9985434 , -0.754923  ,  0.3575942 , -0.6042925 ],\n",
       "       [ 0.22061568, -1.4303073 , -0.5390147 ,  0.03642514, -1.2750477 ,\n",
       "         0.45894784,  2.1594446 , -0.10673267,  1.2786946 ,  0.25862646],\n",
       "       [ 0.14628899, -0.5754013 ,  0.7087447 ,  0.5578232 , -1.4579823 ,\n",
       "         0.37938982, -0.43644118, -0.6563008 ,  0.865909  , -0.42368427],\n",
       "       [-1.4785494 , -1.0902619 , -0.35460117,  0.18694541,  0.67853826,\n",
       "         0.8275889 ,  0.99403435, -0.7602881 , -1.194007  ,  0.49118927],\n",
       "       [ 0.67107975, -1.2055147 ,  1.2255635 ,  0.04910412, -1.0699718 ,\n",
       "        -1.9251139 ,  1.8923182 ,  0.5020014 ,  0.25295788, -0.74998266],\n",
       "       [-0.899381  ,  1.3956175 ,  0.9632489 , -0.8570343 ,  0.10158437,\n",
       "        -0.941746  , -0.33938962, -0.833922  ,  1.2539747 ,  0.9579678 ],\n",
       "       [-0.51349235,  0.274795  , -0.3832942 ,  0.49712586,  0.10508215,\n",
       "         0.32138395,  0.13877425,  0.36840427,  1.7679236 ,  1.2080827 ],\n",
       "       [-1.0136735 ,  0.27664205,  0.0491707 , -0.85531354,  0.4341358 ,\n",
       "        -0.80163884,  0.15118092, -1.1873748 , -1.2554173 ,  1.2651265 ],\n",
       "       [ 0.20343946,  0.89049757, -0.5299467 ,  0.9820477 ,  1.8383219 ,\n",
       "        -0.12700343, -0.6417648 ,  0.640035  , -0.2959784 , -1.0761123 ]],\n",
       "      dtype=float32)"
      ]
     },
     "execution_count": 316,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "glove.embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlsAAAJCCAYAAAD3HAIiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XuUX3V97//XJ5nJPeRiblwSbtHgkXvHgxduKRYBi1LLQmlZak8t1R494k/52eVRcXWd4zpWq/Kr7erC8ztFLeiPY4/FVCQtEQS5ScQAtgkICRhIQsiFBEImmWT274+ZZCUkBJPMJ9+5PB5rzWLy2Xu+3/fslZl5Zu89X0rTNAEAoI5hrR4AAGAwE1sAABWJLQCAisQWAEBFYgsAoCKxBQBQkdgCAKhIbAEAVCS2AAAqamv1ALuaMmVKc8wxx7R6DACAV/Xzn/98TdM0U19tv34VW8ccc0wWLlzY6jEAAF5VKeWp32Q/lxEBACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYkthrSurq5WjwDAICe2GNLuu+++/Ou//murxwBgEBNbDEkrV65MZ2dnDj/88Awb5ssAgHr8lGFI2rhxY374wx+mra0tw4cPz7Jly/KJT3yi1WMBMAiJLYaksWPHZuLEibn//vtz66235umnn86sWbNaPRYAg1BbqweAQ23Dhg35wQ9+kKVLl+ad73xnpk+fnje/+c1ZsmRJq0cDYBByZosh5/77788ll1ySuXPnZtasWVm3bl1+/OMf58QTT0zTNK0eD4BBRmwx5Jx//vmZMGFCtm7dmnXr1mXq1Km555578sY3vjE//vGPWz0eAIOMy4gMSaNHj87KlStz8cUXZ8OGDTnrrLOSJA899FDe8pa3ZPTo0S2eEIDBQmwxJA0bNiyrVq3KxRdfvPOFTdva2jJp0qR84AMfEFsA9BmxxZB1xgfOyH0n35fVm1ZnxtgZ+ejpH807jntHq8cCYJARWwxJP1z6w3z+ns+nc3tnkmTlppX5/D2fTxLBBUCfcoM8Q9K1D167M7R26NzemWsfvLZFEwEwWIkthqRVm1bt1zoAHCixxZA0Y+yM/VoHgAMlthiSPnb6xzJq+Kjd1kYNH5WPnf6xFk0EwGDlBnmGpB03wV/74LVZtWlVZoydkY+d/jE3xwPQ58QWQ9Y7jnuHuAKgOpcRAQAqElsAABWJLQCAisQWAEBFYgsAoCKxBQBQkdgCAKhIbAEAVCS2AAAqElsAABVVia1SSnsp5fwajw0AMJAcdGyVUk4vpdza+/6wUsr/TvLXSUb1rp1ZSjm7lPL7pZSJB/t8AAADyUH9j6hLKaOTbNxlaUKS/940zaLe7SOTXNg0zX8tpYxN8udJPnswzwkAMJAcVGw1TbM5yeOllB1L45N8vJQyPcn/TPKrJFt7991USjnx5Y9RSrkyyZVJMmvWrIMZBwCg3+nTe7aapvl10zTvT/KOJH+apPS+7etjrmuapqNpmo6pU6f25TgAAC1X5Qb5pmm2J1nc+zY2SUopY5L8ssbzAQD0Vwd1GTFJSimvTzKrlHJckjOTtCdZkeSGpmm2lFLmlVLOTjIxyV8d7PMBAAwkBx1bTdMsTvIfev+4dC/b7zzY5wCgf1uxYkWefPLJvOUtb2n1KNDveFFTAPbq1ltvTWdnZ77+9a8nSa699to99lm/fn3Wrl2bKVOm5KGHHkqSNE1zSOeE/k5sAbBX69evz/bt29Pe3p4NGzaku7t7j30mTJiQb3zjGxkxYkQWL16c73znO/n2t78tuGAXYguAPTz88MN59NFHc+edd2b16tXZtGlT9vYb48OGDcuUKVPSNE1mz56dU089NdOmTcv1119/6IeGfuqg79kCYHB56aWXsnz58p0RNW3atPz4xz/OqlWrcs011+S8887L2WefnZ/+9KdZvnx5uru7c8stt+TJJ59Md3d3pk6dmnPPPbfVnwb0G85sAbCbMWPG5B3veEfa2trS3d2djRs3pqurKx/96Edz5JFH5uyzz06SnHnmmbn88suzfPnyXHTRRTnttNMyadKkzJs3L6NGjWrxZwH9hzNbAOzVpk2bMnz48MycOTPjx4/PN7/5zZx88sm77XPPPffkyiuvTJI89thj2bRpU6655ppWjAv9ljNbAOzV8OHDM27cuCTJhRdemCeeeCKnnnrqbvuccsopmTlzZubPn585c+bkQx/6UHb5X7gBEVsAvIKmaXLiiSemlJKnn346v/u7v5vvfe97u+3z1FNP5YYbbsixxx6bK664okWTQv8mtgDYq2HDhmXLli1ZvXp1Vq9enbPOOivbt2/PV77ylbzwwgu5//77097enpNOOim33HJLPv/5z+erX/1qHn744VaPDv1K6U+vhdLR0dEsXLiw1WMAkGTbtm07b5IfNmzv/zZ/+OGHM2/evHR1de1ca29vz8UXX7zH/V0w2JRSft40Tcer7efMFgB71dbW8ztUrxRaSbJgwYLdQitJurq6smDBgqqzwUAitgA4YBs2bNivdRiKxBYAB2zChAn7tQ5DkdgC4ICdd955aW9v322tvb095513Xosmgv7Hi5oCcMB23AS/YMGCbNiwIRMmTMh5553n5njYhdgC4KCcfPLJ4gr2wWVEAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgoraDfYBSyulJvtA0zQWllNckOSvJ80m2Nk1zTynllCRTkoxJ8lDTNL8+2OcEABgoDurMVilldJKNuyx9MskPm6a5I8klpZS2JO9rmmZB0zTzklx1MM8HADDQHFRsNU2zuWmax3dZmtM0TVfv+91J3pBk0i7bj335Y5RSriylLCylLHzuuecOZhwAgH6nr+/Z2tvjlX19QNM01zVN09E0TcfUqVP7eBwAgNbq69ha0ntpMemJrH9L8sIu25f28fMBAPRrfXGD/OuTzCqlHJfkS0l+t5SyIsn3m6bZVkr5+1LK7yQZnuTag30+AICB5KBjq2maxUn+wy5L//tl239xsM8BADBQeZ0tAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAAxoN954Y5LkkUceyd13393iafYktgCAAWvt2rV55pln0tXVlXHjxmXLli2tHmkPYgsAGLCuvfbaXHXVVfmbv/mblFLS1taWr3zlK3n66adbPdpOba0eAADgQNx9990ZNWpU2tvbM3ny5Nx5551ZunRphg8fnqOOOqrV4+3kzBYAMOCsW7cuRx99dGbNmpXbbrstCxcuzCmnnJK3ve1tmTFjRqvH240zWwDAgDN58uRMnjw5SXLeeefl2Wefzfjx43PTTTf1u9hyZgsAGNBKKRk2bFief/75nH/++bn44ovzwAMPtHqsnZzZAgAGrK6uriTJxo0bc+qpp2b79u1pb2/Pvffem1NOOSUjRoxo8YRiCwAYwJ577rkkyYknnpi5c+fuPMv14osv5pxzzskRRxzR4gmT0jRNq2fYqaOjo1m4cGGrxwAABoiNGzfmsMMOa8lzl1J+3jRNx6vt58wWADBgHXbYYVm56uYsfeLL6dyyMqNGHp7jjv9kDp/xrlaPtpPYAgAGrJWrbs6SJf813d2bkySdW1ZkyZL/miT9Jrj8NiIAMGAtfeLLO0Nrh+7uzVn6xJdbNNGexBYAMGB1blm5X+utILYAgAFr1MjD92u9FarEVulxYY3HBgDY4bjjP5lhw0bvtjZs2Ogcd/wnWzTRnvr8BvlSyv9IMjHJ46WUR5PMSbItycqmaX7Z188HAAxdO26CH2q/jTi/aZrbk6SU8ldN03yi9/2vJvl4hecDAIaww2e8q1/F1cvViK0/KKV8OMnSJMfusj69lDKqaZrOXXcupVyZ5MokmTVrVoVxAABap8/v2Wqa5k+aprksybgkZZdN5RX2v65pmo6maTqmTp3a1+MAALRUzRc1XZpk7C5/XvHys1oAAINdn8ZWKeU/Jnlbkp8leTzJ90sp70yyMcnf9+VzAQAMBH0aW03T/Cw9obWrZX35HAAAA4kXNQUAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2IJB6Omnn05XV1eSZP78+Xtsf/bZZ3e+393dnZUrV+bOO+88ZPMBDCU1/9+IQIssW7YsW7ZsyaxZs3Lvvfdm0qRJ6erqylvf+tYkyV133ZW1a9dmxYoVmTp1aqZNm5atW7e2eGqAwUlswSDy6U9/Orfffns6OzszcuTItLe354tf/GIOP/zwTJ48eed+RxxxRNatW5dSSrq6utLW1pZjjjmmdYMDDGJiCwaRL3zhC0mSJUuWZMOGDdm0aVO2b9+eX/3qV/nt3/7tnfuNGTMmJ598cqZPn56tW7dm8eLFmTVrVqvGBhjU3LMFg0h3d3fmz5+fe+65J4sXL86kSZOyatWqnHnmmbvtd9hhh2XRokV5+umnM3PmzHzkIx9Je3t7Hn744RZNDjB4iS0YRIYNG5a3v/3tGTVqVI466qh0dnZm48aNWbRoUW6++eZ0d3fn1ltvzQMPPJBp06bln/7pn/Ltb387P/vZzzJs2LDMnDmz1Z8CwKDjMiIMEs8880zOP//8tLW1pb29PZ2dnfnkJz+Z173udRk5cmROPvnkNE2TCy64IN3d3fm7v/u7fPjDH86sWbPyq1/9Kr/zO7/T6k8BYFASWzBIHHnkkVm4cGFGjx6dJLnjjjtyzDHH7HHj+9q1a/OjH/0o73//+/PAAw9k6tSpGTduXD7+8Y/nfe97X0444YSdjwHAwXMZEQaRXSNpy5YtKaXstn3NmjVZunRprrjiiowdOzbPPPNMhg0blhNOOCEf+chH0jTNztfnAqBvOLMFg9TmzZszbty43damTJmSKVOm7Pzzm970pp0vCXH88ccf0vkAhgqxBYPUJZdcss/tj92/KvfevCovrnsq4yaPzJvfdXxed8aMQzQdwNAhtmAIeuz+Vbn9hiXZtrU7SfLiui25/YYlSSK4APqYe7ZgCLr35id2htYO27Z2596bn2jRRACDl9iCIejFdVv2ax2AAye2YAgaN3nkfq0DcODEFgxBb37X8WkbsfuXf9uIYXnzu/xGIkBfc4M8DEE7boK/9+Yn8uK6LX4bEaAisQVD1OvOmCGuAA4BlxEBACoa0rG1ffv2Vo8AAAxyQza2Ojs787nPfU5wAQBVDbl7tl588cVcd911mTFjRqZMmZIlS5bkZz/7Wf7oj/6o1aMBAIPQkDqztWzZsixatCjjx4/PH/zBH2T8+PF5/etfn2OOOabVowEAg9SQOrPV1dWVFStW5MEHH8xNN92UBx98MCNHjsxRRx3V6tEAgEFqSMXWtGnT8s53vjMvvfRSzjjjjLS3t+dtb3tb/vqv/zpz585t9XgAwCA0pC4jjhgxIrfeemsefvjhjB07Nqeddlo+/elP533ve1+rRwMABqkhdWbr/vvvzznnnJPnn38+U6ZMyaJFi9LR0ZGjjjoqnZ2dGTVqVKtHBAAGmSF1Zmvu3Ll56qmn0tXVlUcffTRnnXVWpk+fnqeeeio/+clPWj0eADAIDanYSpIJEybksccey5w5czJy5MhccMEF+clPfpIbbrih1aMBAIPQkLqMmCTHHntsPnP22fnVb5+XbStXpu3ww/Ouj1+VN3/2s60eDQAYhIbcma0N8+Zl5Wc/l20rViRNk20rVmTlZz+XaUuWtHo0AGAQGnKxtfqrX0vT2bnbWtPZmdVf/VqLJgIABrMhF1vbVq7cr3UAgIMx5GKr7fDD92sdAOBgDLnYmvbxq1Je9npaZdSoTPv4VS2aCAAYzIbcbyNOuPjiJD33bu34bcRpH79q5zoAQF8acrGV9ASXuAIADoUhdxkRAOBQElsAABWJLQCAisQWAEBFYgsAoCKxBQBQkdgCAKhIbAEAVCS2AAAqElsAABWJLQCAisQWAEBFYgsAoCKxBQBQkdgCAKhIbAEAVCS2AAAqElsAABWJLQCAisQWAEBFYgsAoCKxBQBQUVvtJyillCTvTrIqyeSmaebVfk4AgP7iUJzZeleSZ5umuTvJjFLK6w/BcwIA9AuHIrbOSbK89/3lSc7edWMp5cpSysJSysLnnnvuEIwDAHDoHIrYKr1vOzS7bmya5rqmaTqapumYOnXqIRgHAODQORSxdUeS43rfPyrJXYfgOQEA+oVDEVs3J5lWSjkjyYqmaRYfgucEAOgXqv82YtM0TZLv1n4eAID+yOtsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEViC4A9rFy5Mtu3b3/F7StWrMg999xzCCeCgUtsAZBt27Zl6dKlWbZsWR555JHceuuteeqpp/bYb/369Vm7dm2mTJmShx56KEnSNM2hHhcGFLEFQNra2nL99dfnkUceyXPPPZfOzs6sX78+3/zmN3PXXXft3G/ChAn5xje+kREjRmTx4sX5zne+k29/+9uCC/ZBbAGQpmmydevWPPHEE+nq6sq4ceMyceLEzJkzJxMmTNi537BhwzJlypQ0TZPZs2fn1FNPzbRp03L99de3bnjo59paPQAArVdKyZ/92Z/lzjvvzNSpU3P33XfnoYceyhlnnJGLLrooSfLTn/40y5cvT3d3d2655ZY8+eST6e7uztSpU3Puuee29hOAfsyZLQDyj//4j0mSBx98MGPGjMmkSZMyY8aMbNq0KWPHjk2SnHnmmbn88suzfPnyXHTRRTnttNMyadKkzJs3L6NGjWrl+NCviS0AMm3atCTJ6aefnhNOOCFbt27NOeeck23btu223z333JMrr7wySfLYY4/lBz/4Qa655ppDPi8MJGILgIwcOTIbNmzI448/nhUrVuTII4/MYYcdlqlTp+bxxx/fud8pp5ySmTNnZv78+ZkzZ04+9KEPpZTSwsmh/3PPFsAQt3379tx+++057rjj8pnPfCZtbW1Zv3595syZkzlz5mTevHmZPXt2kuSpp57KL37xi3R0dOSCCy5o8eQwMIgtgCFu+PDh+dSnPrXb2uOPP565c+emlJL169fnjDPOyLJlyzJ58uT84R/+YYsmhYFJbAGwh2uvvXaPtR33dS2+6/bc9d1v5YW1azL+NVNy1nvfl9efNfdQjwgDhtgC4De2+K7b8y/XfT3btm5Jkryw5rn8y3VfTxLBBa/ADfIA/Mbu+u63dobWDtu2bsld3/1WiyaC/k9sAfAbe2Htmv1aB8QWAPth/Gum7Nc6ILYA2A9nvfd9aRsxcre1thEjc9Z739eiiaD/c4M8AL+xHTfB+21E+M2JLQD2y+vPmiuuYD+4jAgAUJHYAgCoSGwBAFQktgAAKhJbAAAViS0AgIrEFgBARWILAKAisQUAUJHYAgCoSGwBAFQktgAAKhJbAAAViS0AgIrEFgBARWILAKAisQUAUJHYAgCoSGwBAFQktgAAKqoSW6WUUaWU82o8NgDAQNLWlw9WSjk2yTVJOpN8u3ft/CSbkhyR5Oamabb25XMCAPRnfX1ma2KSq5qm+VDTNHeXUqYnOaVpmruTPJTkP/Xx8wEA9GsHdGarlHJqkq/tZdNnknyx9wzXf0syKcnq3m2/TnJOkr972WNdmeTKJJk1a9aBjAMA0G8dUGw1TbMoybmvsPmnpZSxSb6T5H8lKTs+rPft5Y91XZLrkqSjo2OP7QAAA1mVG+SbptmUZFmSe9Nzr1aSzEpyZ43nAwDor/r6BvmPpeey4ZYkf9s0zbOllEWllDcnmZGeM10AAENGn8ZW0zTX7mXtlr58DgCAgcSLmgIAVCS2AAAqElsAABWJLQCAisQWAEBFYgsAoCKxBQBQkdgCAKhIbAEAVCS2AAAqElsAABWJLQCAisQWAEBFYgsAoCKxBQBQkdgCAKhIbAEAVCS2AAAqElsAABWJLQCAisQWAEBFYgsAoCKxBQBQkdgCAKhIbAEAVCS2AAAqElsAABWJLQCAisQWAEBFYgsAoCKxBQBQkdgCAKhIbAEAVCS2AAAqElsAABWJLQCAisQWAEBFYgsAoCKxBQBQkdgCAKhIbAEAVCS2AAAqElsAABWJLQCAisQWAEBFYgsAoCKxBQBQkdgCAKhIbAEAVCS2AAAqElsAABWJLQCAisQWAEBFYgsAoCKxBQBQkdgCAKhIbAEAVCS2AAAqElsAABWJLQCAisQWAEBFYgsAoCKxBQBQkdhiUFi+fHnWr1+fJLnppptaPA0Ah9pTTz3V6hFekdhiQHj22Wdz/fXX58tf/vJet2/ZsiXf//73c99992XBggX51re+lYULFx7iKQFolS996UvZsmVLq8fYq7ZWDwD78uSTT2bVqlV55plncvzxx+cDH/hA1q5dm+HDh2fixIlZs2ZNbrvttpRSsmbNmmzfvj1XX311Zs+e3erRAajoiSeeyLHHHpuf/vSnOeuss/La1742I0eOzObNm7N+/focccQRrR5xJ7FFv/WjH/0onZ2dGT16dO6444689NJL2bhxY7Zv356TTjopEydOzJQpU/Le9743n/rUp/LJT34yf/u3f5sTTzwxa9asyZve9KZWfwoAVHLfffflkUceyW233ZbOzs4kyXe/+90MHz48r3vd6wZHbJVSSpKrkrQ3TfOXvWtnpufS5NQkC5qmeb6UcnGSdUkOb5rme30wM0PEhRdemCSZN29eOjo6MmLEiGzcuDGXX375bvvdfPPNGTVqVBYtWpSurq4MHz48U6ZMacXIABwi7e3tueSSS7Jhw4Zs3rw5H/7wh7Nw4cLMmDEjxx13XKvH283B3LM1O8mSHY9RShmZ5MKmae5McmuST5RSTk0yoWmau5NsLKVccLADM3Rs3bo1N910U2bNmpXf+q3fyvHHH5+jjz4611xzTVauXJmmafLAAw/kxBNPzOTJk7NmzZq89NJLSZKNGze2eHoAatq4cWNuvvnmjBkzJm94wxvy/e9/P9/97nczadKkVo+2h1c9s9UbTF97+XrTNOeWUo7cZemEJFt7t20qpZyYZE2SRb3bf53k/ekJsV0f/8okVybJrFmzDuBTYDBas2ZNHn300Vx66aX5whe+kFNOOSXbt2/P7bffnssuuywPPfRQhg8fnte+9rUZPXp0mqbJYYcdllGjRmXs2LF59NFHM2bMmJxwwgmt/lQAqOCMM87ISSedtPPPq1evztVXXz0wY6tpmkVJzv0NHqv0vu1rrdnL41+X5Lok6ejo2GM7Q9OUKVN2Xgrs7u7Otm3b8tJLL+Wkk07KW9/61t32feyxxzJ9+vSUUnLRRRfl9NNPzxNPPCG0AAaxXUOrq6srnZ2dmTlzZpLkl7/8ZU488cRWjbaHvnzph8VJxiZJKWVMkl8muSPJjgunM5Pc2YfPxxBx7LHH5vd+7/dy6aWXpml27/Hu7u78y7/8Sy6//PI8+uijmTNnTm644YY888wzWbBgQYsmBuBQmj9/fs4+++ydf77vvvtaOM2eDuYG+bYkpyd5XSllbO+lw3mllLOTTEzyV703yB9fSnlTkrFN0/xTH83NELJ48eL88z//c7Zt25bNmzfvsf3UU09Nklx66aWZOnVqLr/88owbNy6rV68+1KMCcKg9fFOG3Xx1zvvIMyltI7Nl7JF5YfuIXHHFFRk1alSrp0uSlJefKWiljo6OxgtRciA2/WJ1Ns5/Mtuf35LhE0fmsLcfk7GnTWv1WADU9PBNybz/knTt8g/x9tHJxf9PcvJl1Z++lPLzpmk6Xm0/ryDPgLfpF6vz/P/5VbY/3/PKwduf35Ln/8+vsukXzmwBDGoL/mL30Ep6/rzgL1ozzysQWwx4G+c/maare7e1pqs7G+c/2ZqBADg0Njy9f+stIrYY8Hac0fpN1wEYJCYctX/rLSK2GPCGTxy5X+sADBLnfa7nHq1dtY/uWe9HxBYD3mFvPyalffe/yqV9WA57+zGtGQiAQ+Pky3puhp8wM0np+e8hujl+f/gfUTPg7fitQ7+NCDAEnXxZv4urlxNbDApjT5smrgDol1xGBACoSGwBAFQktgAAKhJbAAAViS0AgIrEFgBARWILAKAisQUAUJHYAgCoSGwBAFQktgAAKhJbAAAViS0AgIrEFgBARWILAKAisQUAUJHYAgCoSGwBAFQktgAAKhJbAAAViS0AgIrEFgBARWILAKAisQUAUJHYAgCoSGwBAFQktgAAKhJbAAAViS0AgIrEFgBARWILAKAisQUAUJHYAgCoSGwBAFQktgAAKhJbAAAViS0AgIrEFgBARWILAKAisQUAUJHYAgCoSGwBAFQktgAAKhJbAAAViS0AgIrEFgBARWILAKAisQUAUJHYAgCoSGwBAFQktgAAKhJbAAAViS0AgIrEFgDeR3c4AAAKSklEQVRARWILAKAisQUAUJHYAgCoSGwBAFQktgAAKqoSW6WUmaWUk2o8NgDAQNJ2oB9YSilJrkrS3jTNX/auvTPJRb27fLZ3n3cnWZVkctM08w5yXgCAAeVgzmzNTrLkZY/xQtM0H+p9ey7Ju5I82zTN3UlmlFJefxDPBwAw4Lzqma1SyqlJvvby9aZpzi2lHPmy5dmllMuTHJHkT5Kcs8vHLk9ydpLFL3v8K5NcmSSzZs3a3/kBAPq1V42tpmkWJTn3N3mwpmm+keQbpZSO9FxiLL1vO3fZy8dcl+S6JOno6NhjOwDAQFbrtxGfTPJikjuSHNe7dlSSuyo9HwBAv3QwN8i3JTk9yetKKWOTbE7yxfQE1muSfCXJS0neU0o5I8mKpmkWv8LDAQAMSgccW03TbEtPUO3q6r3s+t0DfQ4AgIHOi5oCAFQktgAAKhJbAAAViS0AgIrEFgBARWILAKAisQUAUJHYAgCoSGwBAFQktgAAKhJbAAAViS0AgIrEFgBARWILAKAisQVwCN1222158sknX3W/Rx55JCtWrKg/EFBdW6sHABjsXnzxxfzwhz/MiBEjsmTJkixbtiwTJ07M2rVr8973vjcTJ07cbf+urq489thjOfzww3PEEUe0aGqgr4gtgMrGjRuXN73pTXnkkUcyffr0jB07Nt3d3Zk7d+7O0FqwYEGeeeaZrFu3Lm1tbRk2bFh+//d/P52dnXn22Wdz9NFHt/izAA6Uy4gAh8DRRx+dp59+OtOmTcuYMWPyk5/8JDNnzty5fe7cubnssssyceLEvPvd787jjz+eG2+8MZ/73Ofy8MMPt3By4GCJLYBD5Nlnn82IESOydu3adHR0ZMyYMTu3DRs2LLfffns6OzuzfPnyXHHFFSml5PLLL8/FF1/cwqmBgyW2AA6B7u7ufPCDH8yyZcuyYsWKTJ8+PX//93+fv/iLv0jTNEmSY445Jr/+9a9z9NFHZ82aNTnyyCNz2mmntXhy4GC5ZwugorVr1+YNb3hDXnrppUyYMCETJ07MhAkTcs8992TChAmZMGFCVq1alcMPPzw///nPM3LkyBx22GFZtmxZxo8f3+rxgT5QdvyLqj/o6OhoFi5c2OoxAPrU9u3b0zRNbrzxxpx++ukZOXJk5s+fn/e85z2ZOnVqkmTRokUZPXp0Zs2alWXLlmXlypVJeu71mj17divHB15BKeXnTdN0vNp+zmwBVDZ8+PAkyT/8wz/kxhtvzAsvvJBNmzblAx/4QJJk27ZtGTduXGbPnp1nn302//7v/55LL700SfLHf/zH+dM//dO88Y1vTCmlVZ8CcBDEFsAh8sEPfjAXXnhhxo0bt1s4tbW1Zfbs2ens7MyNtz+U7z05OVf/+Q9zxMTR+eP3/OeMHz8627ZtS3t7ewunBw6UG+QBDpHLLrss48ePf8UzVLcuXpvr/q07zzy/OU2SZ57fnC/dtTqPdh4mtGAAE1sA/cSX5j+azV3bd1vb3LU9X5r/aIsmAvqC2ALoJ1Y8v3m/1oGBQWwB9BNHTBy9X+vAwCC2APqJq98+J6Pbh++2Nrp9eK5++5wWTQT0Bb+NCNBPXHLakUl67t1a8fzmHDFxdK5++5yd68DAJLYA+pFLTjtSXMEg4zIiAEBFYgsAoCKxBQBQkdgCAKhIbAEAVCS2AAAqElsAABWJLQCAisQWAEBFYgsAoCKxBQBQkdgCAKhIbAEAVCS2AAAqElsAABWJLQCAisQWAEBFYgsAoCKxBQBQkdgCAKioNE3T6hl2KqU8l+SpVs9xAKYkWdPqIfopx2bfHJ99c3xemWOzb47PK3Ns9m1/js/RTdNMfbWd+lVsDVSllIVN03S0eo7+yLHZN8dn3xyfV+bY7Jvj88ocm32rcXxcRgQAqEhsAQBUJLb6xnWtHqAfc2z2zfHZN8fnlTk2++b4vDLHZt/6/Pi4ZwsAoCJntgAAKhJbfayUMrOUclKr52DgKKWMKqWc1+o5GBhKjwtbPQcDVymlvZRyfqvnGEraWj3AQFRKKUmuStLeNM1f9q69M8lFvbt8tnefdydZlWRy0zTzWjJsC7zC8TkzPXE/NcmCpmmeL6VcnGRdksObpvleywZukVLKsUmuSdKZ5Nu9a+cn2ZTkiCQ3N02ztXUTts5Q/vrZl1LK/0gyMcnjpZRHk8xJsi3JyqZpftnS4VqolHJ6ki80TXNBKeU1Sc5K8nySrU3T3FNKOSU9r500JslDTdP8uoXjHlIvOzbDkvx/SdYmuaV3+x7fm1s27CFUSpmQ5KNJJid5Kcn/ysu+nvry2DizdWBmJ1mS3Y/fC03TfKj37bkk70rybNM0dyeZUUp5fSsGbZHdjk8pZWSSC5umuTPJrUk+UUo5NcmE3uOzsZRyQcumbZ2JSa7q/TtzdyllepJTeo/JQ0n+U2vHa6mh/PWzL/N7/758Ocl/bprmR03T/GuSP271YK1SShmdZOMuS59M8sOmae5IckkppS3J+5qmWdAb7Ve1YMyW2MuxmZDkv/f+HfrB3r43t2LOFnlteo7F/5XkDUk+uuvXU18fG2e29qE3CL728vWmac4tpRz5suXZpZTL03NG4k+SnLPLxy5PcnaSxRXHPeT24/ickGRr77ZNpZQT0/PqvIt6t/86yfvT8xd60Hml45TkM0m+2HuG678lmZRkde+2X6fn79DfHZIh+59B//VzgP6glPLhJEuTHLvL+vRSyqimaTpbNFfLNE2zOT1n+nYszWmapqv3/e70/CCdtMuH7HrcBrW9HJvxST7e+w+7/5nkV9nze/OQ0DTNwiQppQxPz8+jo3fZPD17/7l1wMTWPjRNsyjJub/hvt9I8o1SSkd6/uVUet927tLnA7bYfhyflx+Lva0NuuOzw6scp5+WUsYm+U56TmPvOCZNBvEx+Q0Mmb8f+6Npmj9JklLK17P78Xn519dQtrcrNo5Pkt7Lp+/vDYxbk1wdx+byJH+envjcoSQZnT48Ni4j9r0nk7yY5I4kx/WuHZXkrhbN0x8sTjI2SUopY5L8Mrsfn5lJ7mzJZP1A0zSbkixLcm96zowmyawM4WMSXz+vZml67knaYcVQPKv1Cpb0Xj5Len5Y/luSF3bZvvTQj9S/NE2zPT3fl/f2vXnI6L1v+OamadYmeXqXTSuS/CJ9eGy8ztYB6L0H4L8kOTE9N9htTvLF9PyAeE2Sf0zPDXfvSc8P0dc0TXNLS4ZtgZcfn95TsGf3bp6Y5M7eG+R/P8kzSWY0TfNPLRq3ZUopH0vPZcMtSf6taZpHSykXJVmfZEZ67jsZyjfID8mvn1dSSvmPSd6W5GfpudH7kSQnpeeenDVD/Ab516fn++7vJtmQ5LfT8wNze9M095VSTkvPDfLDk/z7ELtBftdjc2aS9vQcm3VN09y/t+/NrZn00Cql/N/puVS4Lsm0JP9veu5p2/n11JfHRmwBAFTkMiIAQEViCwCgIrEFAFCR2AIAqEhsAQBUJLYAACoSWwAAFYktAICKxBYAQEX/P+Z7mVhI+zDAAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "glove.generate_tsne(size=(10,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}