5. Nearest Neighbor Methods.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Agenda \n",
    "* Working with Nearest Neighbors\n",
    "* Test-Based Distances\n",
    "* Computing Mixed Distance Functions\n",
    "* Nearest for Image Recognition\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# import required libraries\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import requests\n",
    "from tensorflow.python.framework import ops\n",
    "ops.reset_default_graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sess = tf.Session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "housing_url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/housing/housing.data'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "housing_header = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* CRIM : per capita crime rate by town\n",
    "* ZN : prop. of res. land zones\n",
    "* INDUS : prop. of non-retail business acres\n",
    "* CHAS : Charles river dummy variable\n",
    "* NOX : nitrix oxides concentration / 10 M\n",
    "* RM : Avg. # of rooms per building\n",
    "* AGE : prop. of buildings built prior to 1940\n",
    "* DIS : Weighted distances to employment centers\n",
    "* RAD : Index of radian highway access\n",
    "* TAX : Full tax rate value per $10k\n",
    "* PTRATIO: Pupil/Teacher ratio by town\n",
    "* B : 1000*(Bk-0.63)^2, Bk=prop. of blacks\n",
    "* LSTAT : % lower status of pop\n",
    "\n",
    "----y-data----\n",
    "* MEDV : Median Value of homes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cols_used = ['CRIM', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'TAX', 'PTRATIO', 'B', 'LSTAT']\n",
    "num_features = len(cols_used)\n",
    "housing_file = requests.get(housing_url)\n",
    "\n",
    "housing_data = [[float(x) for x in y.split(' ') if len(x)>=1] for y in housing_file.text.split('\\n') if len(y)>=1]\n",
    "\n",
    "y_vals = np.transpose([np.array([y[13] for y in housing_data])])\n",
    "x_vals = np.array([[x for i,x in enumerate(y) if housing_header[i] in cols_used] for y in housing_data])\n",
    "\n",
    "## Min-Max Scaling\n",
    "x_vals = (x_vals - x_vals.min(0)) / x_vals.ptp(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0.00000000e+00,   6.78152493e-02,   3.14814815e-01, ...,\n",
       "          2.87234043e-01,   1.00000000e+00,   8.96799117e-02],\n",
       "       [  2.35922539e-04,   2.42302053e-01,   1.72839506e-01, ...,\n",
       "          5.53191489e-01,   1.00000000e+00,   2.04470199e-01],\n",
       "       [  2.35697744e-04,   2.42302053e-01,   1.72839506e-01, ...,\n",
       "          5.53191489e-01,   9.89737254e-01,   6.34657837e-02],\n",
       "       ..., \n",
       "       [  6.11892474e-04,   4.20454545e-01,   3.86831276e-01, ...,\n",
       "          8.93617021e-01,   1.00000000e+00,   1.07891832e-01],\n",
       "       [  1.16072990e-03,   4.20454545e-01,   3.86831276e-01, ...,\n",
       "          8.93617021e-01,   9.91300620e-01,   1.31070640e-01],\n",
       "       [  4.61841693e-04,   4.20454545e-01,   3.86831276e-01, ...,\n",
       "          8.93617021e-01,   1.00000000e+00,   1.69701987e-01]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_vals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_vals.ptp(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function ptp:\n",
      "\n",
      "ptp(...) method of numpy.ndarray instance\n",
      "    a.ptp(axis=None, out=None)\n",
      "    \n",
      "    Peak to peak (maximum - minimum) value along a given axis.\n",
      "    \n",
      "    Refer to `numpy.ptp` for full documentation.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    numpy.ptp : equivalent function\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(x_vals.ptp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "506"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy\n",
    "len(x_vals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_indices = np.random.choice(len(x_vals), round(len(x_vals)*0.8), replace=False)\n",
    "\n",
    "test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices)))\n",
    "\n",
    "x_vals_train = x_vals[train_indices]\n",
    "x_vals_test = x_vals[test_indices]\n",
    "y_vals_train = y_vals[train_indices]\n",
    "y_vals_test = y_vals[test_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "k = 4\n",
    "batch_size=len(x_vals_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x_data_train = tf.placeholder(shape=[None, num_features], dtype=tf.float32)\n",
    "x_data_test = tf.placeholder(shape=[None, num_features], dtype=tf.float32)\n",
    "y_target_train = tf.placeholder(shape=[None, 1], dtype=tf.float32)\n",
    "y_target_test = tf.placeholder(shape=[None, 1], dtype=tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "distance = tf.reduce_sum(tf.abs(tf.sub(x_data_train, tf.expand_dims(x_data_test,1))), reduction_indices=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'ExpandDims_1:0' shape=(?, 1, 10) dtype=float32>"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.expand_dims(x_data_test,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function top_k in module tensorflow.python.ops.nn_ops:\n",
      "\n",
      "top_k(input, k=1, sorted=True, name=None)\n",
      "    Finds values and indices of the `k` largest entries for the last dimension.\n",
      "    \n",
      "    If the input is a vector (rank-1), finds the `k` largest entries in the vector\n",
      "    and outputs their values and indices as vectors.  Thus `values[j]` is the\n",
      "    `j`-th largest entry in `input`, and its index is `indices[j]`.\n",
      "    \n",
      "    For matrices (resp. higher rank input), computes the top `k` entries in each\n",
      "    row (resp. vector along the last dimension).  Thus,\n",
      "    \n",
      "        values.shape = indices.shape = input.shape[:-1] + [k]\n",
      "    \n",
      "    If two elements are equal, the lower-index element appears first.\n",
      "    \n",
      "    Args:\n",
      "      input: 1-D or higher `Tensor` with last dimension at least `k`.\n",
      "      k: 0-D `int32` `Tensor`.  Number of top elements to look for along the last\n",
      "        dimension (along each row for matrices).\n",
      "      sorted: If true the resulting `k` elements will be sorted by the values in\n",
      "        descending order.\n",
      "      name: Optional name for the operation.\n",
      "    \n",
      "    Returns:\n",
      "      values: The `k` largest elements along each last dimensional slice.\n",
      "      indices: The indices of `values` within the last dimension of `input`.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(tf.nn.top_k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "top_k_xvals, top_k_indices = tf.nn.top_k(tf.neg(distance), k=k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'TopKV2:0' shape=(?, 4) dtype=float32>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top_k_xvals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x_sums = tf.expand_dims(tf.reduce_sum(top_k_xvals, 1),1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'ExpandDims_2:0' shape=(?, 1) dtype=float32>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_sums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_sums = tf.expand_dims(tf.reduce_sum(top_k_xvals, 1),1)\n",
    "\n",
    "x_sums_repeated = tf.matmul(x_sums,tf.ones([1, k], tf.float32))\n",
    "\n",
    "x_val_weights = tf.expand_dims(tf.div(top_k_xvals,x_sums_repeated), 1)\n",
    "\n",
    "top_k_yvals = tf.gather(y_target_train, top_k_indices)\n",
    "\n",
    "prediction = tf.squeeze(tf.batch_matmul(x_val_weights,top_k_yvals), squeeze_dims=[1])\n",
    "\n",
    "mse = tf.div(tf.reduce_sum(tf.square(tf.sub(prediction, y_target_test))), batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "Batch # 1 MSE: 14.058\n",
      "Batch # 2 MSE: 0.0\n",
      "Batch # 3 MSE: 0.0\n",
      "Batch # 4 MSE: 0.0\n",
      "Batch # 5 MSE: 0.0\n",
      "Batch # 6 MSE: 0.0\n",
      "Batch # 7 MSE: 0.0\n",
      "Batch # 8 MSE: 0.0\n",
      "Batch # 9 MSE: 0.0\n",
      "Batch # 10 MSE: 0.0\n"
     ]
    }
   ],
   "source": [
    "num_loops = int(np.ceil(len(x_vals_test)/batch_size))\n",
    "\n",
    "print (num_loops)\n",
    "for i in range(10):\n",
    "    min_index = i*batch_size\n",
    "    max_index = min((i+1)*batch_size,len(x_vals_train))\n",
    "    x_batch = x_vals_test[min_index:max_index]\n",
    "    y_batch = y_vals_test[min_index:max_index]\n",
    "    predictions = sess.run(prediction, feed_dict={x_data_train: x_vals_train, x_data_test: x_batch, y_target_train: y_vals_train, y_target_test: y_batch})\n",
    "    batch_mse = sess.run(mse, feed_dict={x_data_train: x_vals_train, x_data_test: x_batch, y_target_train: y_vals_train, y_target_test: y_batch})\n",
    "\n",
    "    print('Batch # '+ str(i+1) + ' MSE: ' + str(np.round(batch_mse,3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1a0948267f0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bins = np.linspace(5, 50, 45)\n",
    "\n",
    "plt.hist(predictions, bins, alpha=0.5, label='Prediction')\n",
    "plt.hist(y_batch, bins, alpha=0.5, label='Actual')\n",
    "plt.title('Histogram of Predicted and Actual Values')\n",
    "plt.xlabel('Med Home Value in $1,000s')\n",
    "plt.ylabel('Frequency')\n",
    "plt.legend(loc='upper right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "101"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(x_vals_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "101"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function squeeze in module tensorflow.python.ops.array_ops:\n",
      "\n",
      "squeeze(input, axis=None, name=None, squeeze_dims=None)\n",
      "    Removes dimensions of size 1 from the shape of a tensor.\n",
      "    \n",
      "    Given a tensor `input`, this operation returns a tensor of the same type with\n",
      "    all dimensions of size 1 removed. If you don't want to remove all size 1\n",
      "    dimensions, you can remove specific size 1 dimensions by specifying\n",
      "    `axis`.\n",
      "    \n",
      "    For example:\n",
      "    \n",
      "    ```prettyprint\n",
      "    # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]\n",
      "    shape(squeeze(t)) ==> [2, 3]\n",
      "              ```\n",
      "    \n",
      "    Or, to remove specific size 1 dimensions:\n",
      "    \n",
      "    ```prettyprint\n",
      "    # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]\n",
      "    shape(squeeze(t, [2, 4])) ==> [1, 2, 3, 1]\n",
      "    ```\n",
      "    \n",
      "    Args:\n",
      "      input: A `Tensor`. The `input` to squeeze.\n",
      "      axis: An optional list of `ints`. Defaults to `[]`.\n",
      "        If specified, only squeezes the dimensions listed. The dimension\n",
      "        index starts at 0. It is an error to squeeze a dimension that is not 1.\n",
      "      name: A name for the operation (optional).\n",
      "      squeeze_dims: Deprecated keyword argument that is now axis.\n",
      "    \n",
      "    Returns:\n",
      "      A `Tensor`. Has the same type as `input`.\n",
      "      Contains the same data as `input`, but has one or more dimensions of\n",
      "      size 1 removed.\n",
      "    \n",
      "    Raises:\n",
      "      ValueError: When both `squeeze_dims` and `axis` are specified.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(tf.squeeze)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "from tensorflow.examples.tutorials.mnist import input_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.\n",
      "Extracting MNIST_data/train-images-idx3-ubyte.gz\n",
      "Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.\n",
      "Extracting MNIST_data/train-labels-idx1-ubyte.gz\n",
      "Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.\n",
      "Extracting MNIST_data/t10k-images-idx3-ubyte.gz\n",
      "Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.\n",
      "Extracting MNIST_data/t10k-labels-idx1-ubyte.gz\n"
     ]
    }
   ],
   "source": [
    "sess = tf.Session()\n",
    "mnist = input_data.read_data_sets(\"MNIST_data/\", one_hot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_size = 1000\n",
    "test_size = 102\n",
    "rand_train_indices = np.random.choice(len(mnist.train.images), train_size, replace=False)\n",
    "rand_test_indices = np.random.choice(len(mnist.test.images), test_size, replace=False)\n",
    "x_vals_train = mnist.train.images[rand_train_indices]\n",
    "x_vals_test = mnist.test.images[rand_test_indices]\n",
    "y_vals_train = mnist.train.labels[rand_train_indices]\n",
    "y_vals_test = mnist.test.labels[rand_test_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "k = 4\n",
    "batch_size=6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x_data_train = tf.placeholder(shape=[None, 784], dtype=tf.float32)\n",
    "x_data_test = tf.placeholder(shape=[None, 784], dtype=tf.float32)\n",
    "y_target_train = tf.placeholder(shape=[None, 10], dtype=tf.float32)\n",
    "y_target_test = tf.placeholder(shape=[None, 10], dtype=tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "distance = tf.reduce_sum(tf.abs(tf.sub(x_data_train, tf.expand_dims(x_data_test,1))), reduction_indices=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "top_k_xvals, top_k_indices = tf.nn.top_k(tf.neg(distance), k=k)\n",
    "\n",
    "prediction_indices = tf.gather(y_target_train, top_k_indices)\n",
    "count_of_predictions = tf.reduce_sum(prediction_indices, reduction_indices=1)\n",
    "\n",
    "prediction = tf.argmax(count_of_predictions, dimension=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "num_loops = int(np.ceil(len(x_vals_test)/batch_size))\n",
    "test_output = []\n",
    "actual_vals = []\n",
    "for i in range(num_loops):\n",
    "    min_index = i*batch_size\n",
    "    max_index = min((i+1)*batch_size,len(x_vals_train))\n",
    "    x_batch = x_vals_test[min_index:max_index]\n",
    "    y_batch = y_vals_test[min_index:max_index]\n",
    "    predictions = sess.run(prediction, feed_dict={x_data_train: x_vals_train, x_data_test: x_batch,\n",
    "                                         y_target_train: y_vals_train, y_target_test: y_batch})\n",
    "    test_output.extend(predictions)\n",
    "    actual_vals.extend(np.argmax(y_batch, axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test set: 0.9019607843137244\n"
     ]
    }
   ],
   "source": [
    "accuracy = sum([1./test_size for i in range(test_size) if test_output[i]==actual_vals[i]])\n",
    "print('Accuracy on test set: ' + str(accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWQAAAD4CAYAAADbyJysAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nd4tsHVpqmwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1a09714c1d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "actuals = np.argmax(y_batch, axis=1)\n",
    "Nrows = 2\n",
    "Ncols = 3\n",
    "for i in range(len(actuals)):\n",
    "    plt.subplot(Nrows, Ncols, i+1)\n",
    "    plt.imshow(np.reshape(x_batch[i], [28,28]), cmap='Greys_r')\n",
    "    plt.title('Actual: ' + str(actuals[i]) + ' Pred: ' + str(predictions[i]), fontsize=10)\n",
    "    frame = plt.gca()\n",
    "    frame.axes.get_xaxis().set_visible(False)\n",
    "    frame.axes.get_yaxis().set_visible(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}