Facebook-Project_Jiying.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Facebook Check-Ins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pandas import DataFrame, Series\n",
    "from sklearn import neighbors, datasets\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.neighbors import KNeighborsClassifier as KNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Read data\n",
    "train = pd.read_csv('~/Documents/Kaggle/kaggle_fa16/projects/fb/train.csv')\n",
    "test = pd.read_csv('~/Documents/Kaggle/kaggle_fa16/projects/fb/test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training data size is(29118021, 6)\n",
      "Testing data size is(8607230, 5)\n",
      "count    2.911802e+07\n",
      "mean     8.284912e+01\n",
      "std      1.147518e+02\n",
      "min      1.000000e+00\n",
      "25%      2.700000e+01\n",
      "50%      6.200000e+01\n",
      "75%      7.500000e+01\n",
      "max      1.033000e+03\n",
      "Name: accuracy, dtype: float64\n",
      "   row_id       x       y  accuracy    time    place_id\n",
      "0       0  0.7941  9.0809        54  470702  8523065625\n",
      "1       1  5.9567  4.7968        13  186555  1757726713\n",
      "2       2  8.3078  7.0407        74  322648  1137537235\n",
      "   row_id       x       y  accuracy    time\n",
      "0       0  0.1675  1.3608       107  930883\n",
      "1       1  7.3909  2.5301        35  893017\n",
      "2       2  8.0978  2.3473        62  976933\n"
     ]
    }
   ],
   "source": [
    "#Take a look at the datasets\n",
    "print(\"Training data size is\" + str(train.shape))\n",
    "print(\"Testing data size is\" + str(test.shape))\n",
    "\n",
    "print(train['accuracy'].describe())\n",
    "print(train.head(3))\n",
    "print(test.head(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>row_id</th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>time</th>\n",
       "      <th>place_id</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>2.911802e+07</td>\n",
       "      <td>2.911802e+07</td>\n",
       "      <td>2.911802e+07</td>\n",
       "      <td>2.911802e+07</td>\n",
       "      <td>2.911802e+07</td>\n",
       "      <td>2.911802e+07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>1.455901e+07</td>\n",
       "      <td>4.999770e+00</td>\n",
       "      <td>5.001814e+00</td>\n",
       "      <td>8.284912e+01</td>\n",
       "      <td>4.170104e+05</td>\n",
       "      <td>5.493787e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>8.405649e+06</td>\n",
       "      <td>2.857601e+00</td>\n",
       "      <td>2.887505e+00</td>\n",
       "      <td>1.147518e+02</td>\n",
       "      <td>2.311761e+05</td>\n",
       "      <td>2.611088e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000e+00</td>\n",
       "      <td>0.000000e+00</td>\n",
       "      <td>0.000000e+00</td>\n",
       "      <td>1.000000e+00</td>\n",
       "      <td>1.000000e+00</td>\n",
       "      <td>1.000016e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>7.279505e+06</td>\n",
       "      <td>2.534700e+00</td>\n",
       "      <td>2.496700e+00</td>\n",
       "      <td>2.700000e+01</td>\n",
       "      <td>2.030570e+05</td>\n",
       "      <td>3.222911e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>1.455901e+07</td>\n",
       "      <td>5.009100e+00</td>\n",
       "      <td>4.988300e+00</td>\n",
       "      <td>6.200000e+01</td>\n",
       "      <td>4.339220e+05</td>\n",
       "      <td>5.518573e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>2.183852e+07</td>\n",
       "      <td>7.461400e+00</td>\n",
       "      <td>7.510300e+00</td>\n",
       "      <td>7.500000e+01</td>\n",
       "      <td>6.204910e+05</td>\n",
       "      <td>7.764307e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>2.911802e+07</td>\n",
       "      <td>1.000000e+01</td>\n",
       "      <td>1.000000e+01</td>\n",
       "      <td>1.033000e+03</td>\n",
       "      <td>7.862390e+05</td>\n",
       "      <td>9.999932e+09</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             row_id             x             y      accuracy          time  \\\n",
       "count  2.911802e+07  2.911802e+07  2.911802e+07  2.911802e+07  2.911802e+07   \n",
       "mean   1.455901e+07  4.999770e+00  5.001814e+00  8.284912e+01  4.170104e+05   \n",
       "std    8.405649e+06  2.857601e+00  2.887505e+00  1.147518e+02  2.311761e+05   \n",
       "min    0.000000e+00  0.000000e+00  0.000000e+00  1.000000e+00  1.000000e+00   \n",
       "25%    7.279505e+06  2.534700e+00  2.496700e+00  2.700000e+01  2.030570e+05   \n",
       "50%    1.455901e+07  5.009100e+00  4.988300e+00  6.200000e+01  4.339220e+05   \n",
       "75%    2.183852e+07  7.461400e+00  7.510300e+00  7.500000e+01  6.204910e+05   \n",
       "max    2.911802e+07  1.000000e+01  1.000000e+01  1.033000e+03  7.862390e+05   \n",
       "\n",
       "           place_id  \n",
       "count  2.911802e+07  \n",
       "mean   5.493787e+09  \n",
       "std    2.611088e+09  \n",
       "min    1.000016e+09  \n",
       "25%    3.222911e+09  \n",
       "50%    5.518573e+09  \n",
       "75%    7.764307e+09  \n",
       "max    9.999932e+09  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Weed out the data in training set where accuracy is below 10\n",
    "acc_train = train.loc[train['accuracy'] > 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25740795, 6)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "acc_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Separate spatial data into grid for computation in smaller bits\n",
    "#Code mostly taken from 'Sandro' on Kaggle Kernels\n",
    "\n",
    "def prepare_data(df, n_cell_x, n_cell_y):\n",
    "#     \"\"\"\n",
    "#     Feature engineering and computation of the grid.\n",
    "#     \"\"\"\n",
    "    #Creating the grid\n",
    "    size_x = 10. / n_cell_x #divide 10 (x values in [0,10]) by number of cells you wish to generate by x\n",
    "    size_y = 10. / n_cell_y #divide by 10 (y values in [0, 10]) by number of cells you wish to generate by y\n",
    "    eps = 0.00001 #why do eps? Just so for values less than this, just do 0 b/c too small anyways? \n",
    "    xs = np.where(df.x.values < eps, 0, df.x.values - eps)\n",
    "    ys = np.where(df.y.values < eps, 0, df.y.values - eps)\n",
    "    pos_x = (xs / size_x).astype(np.int64) #changing position for x into new grid \n",
    "    pos_y = (ys / size_y).astype(np.int64) #changing position for y into new grid\n",
    "    df['grid_cell'] = (pos_y * n_cell_x + pos_x) #the grid # (how many y's up (so # of rows), then add x (column))\n",
    "    \n",
    "    #Feature engineering\n",
    "    fw = [500, 500, 4, 3, 1./22., 2, 10] #feature weights (black magic here), to better feature engineer\n",
    "        #each fw represents x, y, hour, weekday, day, month, year changing weights\n",
    "        #Note: Changed y fw from 1000 to 750 b/c exceeds int64 and produces negative. like too big\n",
    "        #thing to keep in mind: n_cell_x can't be too big, then will have negative values due to data type overflow\n",
    "        \n",
    "    df.x = df.x.values * fw[0]\n",
    "    df.y = df.y.values * fw[1]\n",
    "    initial_date = np.datetime64('2014-01-01T01:01', dtype='datetime64[m]') #arbitrary date\n",
    "    d_times = pd.DatetimeIndex(initial_date + np.timedelta64(int(mn), 'm') \n",
    "                               for mn in df.time.values)    \n",
    "    df['hour'] = d_times.hour * fw[2]\n",
    "    df['weekday'] = d_times.weekday * fw[3]\n",
    "    df['day'] = (d_times.dayofyear * fw[4]).astype(int)\n",
    "    df['month'] = d_times.month * fw[5]\n",
    "    df['year'] = (d_times.year - 2013) * fw[6]\n",
    "\n",
    "    #f = df.drop(['time'], axis=1) #drop time b/c converted into time\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Also code adapted from 'Sandro'\n",
    "#jk most of this stuff is mine now\n",
    "\n",
    "def process_one_cell(df_train, df_test, grid_id, threshold, n_cell_x, n_cell_y):\n",
    "    \"\"\"   \n",
    "    Throw in a training dataset and it will split it into local training and testing sets, and \n",
    "    do a KNN classification inside one grid cell.\n",
    "    \"\"\"   \n",
    "    \n",
    "    #Working on df_train to train ONE CELL (from grid_cell column)\n",
    "    df_cell_train = df_train.loc[df_train.grid_cell == grid_id] #gets all the data within one grid\n",
    "    place_counts = df_cell_train.place_id.value_counts()\n",
    "        #getting counts of places in that cell\n",
    "    \n",
    "    mask = (place_counts[df_cell_train.place_id.values] >= threshold).values \n",
    "    df_cell_train = df_cell_train.loc[mask] #weeds out ID's with less than threshold# cases\n",
    "    \n",
    "    #Preparing data\n",
    "#     le = LabelEncoder()\n",
    "#     y = le.fit_transform(df_cell_train.place_id.values)\n",
    "#      X = df_cell_train.drop(['place_id', 'grid_cell'], axis=1).values.astype(int)\n",
    "#      X_test = df_cell_test.drop(['grid_cell'], axis = 1).values.astype(int)\n",
    "    \n",
    "#     #Applying the classifier\n",
    "#     clf = KNeighborsClassifier(n_neighbors=25, weights='distance', \n",
    "#                                metric='manhattan') #algorithm applied on one grid cell\n",
    "#     clf.fit(X, y)\n",
    "#     y_pred = clf.predict_proba(X_test)\n",
    "#     pred_labels = le.inverse_transform(np.argsort(y_pred, axis=1)[:,::-1][:,:3])    \n",
    "#     return pred_labels, row_ids\n",
    "\n",
    "    #Working on df_test\n",
    "    df_cell_test = df_test.loc[df_test.grid_cell == grid_id]\n",
    "    \n",
    "    #Saving row ids of test for our output later, which will be along with top 3 predictions\n",
    "    row_ids = df_cell_test.index\n",
    "    \n",
    "    \n",
    "    features = ['x','y','hour','day','weekday','month','year','accuracy']\n",
    "    \n",
    "    train_y = df_cell_train['place_id']\n",
    "    train_x = df_cell_train[features]\n",
    "\n",
    "    test_x = df_cell_test[features]\n",
    "\n",
    "    \n",
    "    # KNN algorithm and test accuracy\n",
    "    knn = KNN(15) #15 nearest neighbors\n",
    "    knn.fit(train_x, train_y) #classifying data based on 15-nearest neighbors\n",
    "    all_preds = knn.predict_proba(test_x)\n",
    "    \n",
    "    #Saving predictions into preds_per_cell\n",
    "    preds_per_cell = np.zeros((test_x.shape[0], 3), dtype=int)\n",
    "    for record in range(len(all_preds)):\n",
    "        top3_idx = all_preds[record].argsort()[-3:][::-1]\n",
    "        preds = knn.classes_[top3_idx]\n",
    "        preds_per_cell[record] = preds\n",
    "           \n",
    "    train_acc = knn.score(train_x, train_y) # score KNN on train set\n",
    "    \n",
    "    return preds_per_cell, row_ids, train_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def process_grid(df_train, df_test, threshold, n_cells, n_cell_x, n_cell_y):\n",
    "    \"\"\"\n",
    "    Iterates over all grid cells, return average training and testing accuracies\n",
    "    \"\"\" \n",
    "    preds = np.zeros((df_test.shape[0], 3), dtype=int)\n",
    "    small_train_acc_sum = 0\n",
    "    #small_test_acc_sum = 0\n",
    "    \n",
    "    for grid_id in range(n_cells):\n",
    "        if grid_id % 100 == 0:\n",
    "            print('iter: %s' %(grid_id)) #Print iteration per 100 grids\n",
    "            print(small_train_acc_sum / (grid_id - 1))\n",
    "        \n",
    "        #Applying classifier to one grid cell\n",
    "        pred_labels, row_ids, small_train_acc = process_one_cell(df_train, df_test,\n",
    "                                                                 grid_id, threshold, \n",
    "                                                                 n_cell_x, n_cell_y)\n",
    "        \n",
    "        small_train_acc_sum += small_train_acc #add up each training accuracy\n",
    "        #small_test_acc_sum += small_test_acc #add up each testing accuracy\n",
    "        \n",
    "        #Updating predictions\n",
    "        preds[row_ids] = pred_labels\n",
    "\n",
    "    train_acc_avg = small_train_acc_sum/n_cells\n",
    "    #test_acc_avg = small_test_acc_sum/n_cells\n",
    "    \n",
    "    print('Generating submission file ...')\n",
    "    \n",
    "    #Auxiliary dataframe with the 3 best predictions for each sample\n",
    "    df_aux = pd.DataFrame(preds, dtype=str, columns = ['l1', 'l2', 'l3'])  \n",
    "    \n",
    "    #Concatenating the 3 predictions for each sample\n",
    "    ds_sub = df_aux.l1.str.cat([df_aux.l2, df_aux.l3], sep=' ')\n",
    "    \n",
    "    #Writting to csv\n",
    "    ds_sub.name = 'place_id'\n",
    "    ds_sub.to_csv('sub_knn.csv', index=True, header=True, index_label='row_id') \n",
    "    \n",
    "    return train_acc_avg#, test_acc_avg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notes\n",
    "All you need to call is the process_grid() method with appropriate parameters\n",
    "\n",
    "- Inside process_grid(), the process_one_cell() method is used on each cell, and \n",
    "\n",
    "- Inside each process_one_cell() call, prepare_data() is used "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Defining the size of the grid\n",
    "# n_cell_x = 1500\n",
    "# n_cell_y = 1500\n",
    "#Take one cell\n",
    "# gridded = prepare_data(acc_train, n_cell_x, n_cell_y) #acc_train with the grid_cell column\n",
    "# subset = gridded[gridded['grid_cell'] == 125] #take some random grid cell\n",
    "# print(subset.shape)\n",
    "# print(subset.head(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# IGNORE THIS BLOCK FOR NOW\n",
    "#Extract from datasets to build mini training and testing sets\n",
    "#small_train = acc_train.sample(frac = 0.1, axis = 0, random_state = 123) #10% randomly taken from the entire train dataset\n",
    "# small_train = acc_train.loc[acc_train['x'] < 0.2, acc_train['y'] < 0.2] #take sliver of map where x < 0.1 (ranges 0-10)\n",
    "# #print(small_train.head(3))\n",
    "# small_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Run kNN on small data and test it out\n",
    "\n",
    "#Train test split on small portion of training data\n",
    "#local_train, local_test = train_test_split(subset, test_size = 0.2)\n",
    "# local_train_y = local_train['place_id']\n",
    "# local_train_x = local_train.drop('place_id', axis=1)\n",
    "\n",
    "# local_test_y = local_test['place_id']\n",
    "# local_test_x = local_test.drop('place_id', axis=1)\n",
    "\n",
    "# th = 6 #Keeping place_ids with more than th samples.   \n",
    "# process_grid(local_train, local_test, th, n_cell_x*n_cell_y)\n",
    "# #KNN and test accuracy\n",
    "# knn = KNN(4)\n",
    "# knn.fit(local_train_x, local_train_y)\n",
    "\n",
    "# train_acc = knn.score(local_train_x, local_train_y) # score KNN on train set\n",
    "# test_acc = knn.score(local_test_x, local_test_y) # score KNN on test set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#First, feature engineering + separating training data into amplified grids for both train and test\n",
    "df_train = prepare_data(train, n_cell_x, n_cell_y) \n",
    "df_test = prepare_data(test, n_cell_x, n_cell_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n_cell_x = 50\n",
    "n_cell_y = 50\n",
    "threshold = 3\n",
    "\n",
    "# #Then running classification model through process_grid\n",
    "process_grid(df_train, df_test, threshold, n_cell_x * n_cell_y, n_cell_x, n_cell_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>row_id</th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>time</th>\n",
       "      <th>grid_cell</th>\n",
       "      <th>hour</th>\n",
       "      <th>weekday</th>\n",
       "      <th>day</th>\n",
       "      <th>month</th>\n",
       "      <th>year</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>41875.0</td>\n",
       "      <td>340200.0</td>\n",
       "      <td>107</td>\n",
       "      <td>930883</td>\n",
       "      <td>6125812</td>\n",
       "      <td>44</td>\n",
       "      <td>12</td>\n",
       "      <td>12</td>\n",
       "      <td>20</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1847725.0</td>\n",
       "      <td>632525.0</td>\n",
       "      <td>35</td>\n",
       "      <td>893017</td>\n",
       "      <td>11496163</td>\n",
       "      <td>16</td>\n",
       "      <td>18</td>\n",
       "      <td>11</td>\n",
       "      <td>18</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2024450.0</td>\n",
       "      <td>586825.0</td>\n",
       "      <td>62</td>\n",
       "      <td>976933</td>\n",
       "      <td>10684166</td>\n",
       "      <td>44</td>\n",
       "      <td>3</td>\n",
       "      <td>14</td>\n",
       "      <td>22</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>249750.0</td>\n",
       "      <td>264775.0</td>\n",
       "      <td>62</td>\n",
       "      <td>907285</td>\n",
       "      <td>4780784</td>\n",
       "      <td>8</td>\n",
       "      <td>6</td>\n",
       "      <td>12</td>\n",
       "      <td>18</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>166750.0</td>\n",
       "      <td>2431350.0</td>\n",
       "      <td>40</td>\n",
       "      <td>914399</td>\n",
       "      <td>43774004</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>12</td>\n",
       "      <td>18</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   row_id          x          y  accuracy    time  grid_cell  hour  weekday  \\\n",
       "0       0    41875.0   340200.0       107  930883    6125812    44       12   \n",
       "1       1  1847725.0   632525.0        35  893017   11496163    16       18   \n",
       "2       2  2024450.0   586825.0        62  976933   10684166    44        3   \n",
       "3       3   249750.0   264775.0        62  907285    4780784     8        6   \n",
       "4       4   166750.0  2431350.0        40  914399   43774004     4        0   \n",
       "\n",
       "   day  month  year  \n",
       "0   12     20    20  \n",
       "1   11     18    20  \n",
       "2   14     22    20  \n",
       "3   12     18    20  \n",
       "4   12     18    20  "
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}