Model_Tencent.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn import linear_model\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "import statsmodels.api as sm\n",
    "import lightgbm as lgb\n",
    "from sklearn.metrics import mean_squared_error\n",
    "import xgboost as xgb\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "user = pd.read_csv('./userFeature.csv')\n",
    "adstatic = pd.read_csv('./adStaticFeature.csv',header=0) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = pd.read_csv('./data/preprocessed/newtestSample.csv')\n",
    "\n",
    "test['pricepersize'] = test['price']/test['size'] * 100000000000000000\n",
    "test['bigprice'] = test['price'] * 100000000000000000\n",
    "test.rename(columns={'auid':'uid'}, inplace= True)\n",
    "test = pd.merge(test, user, on='uid', how='left').drop_duplicates(subset=['aid','price'])\n",
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statuscut = test['status'].str.split(\" \", expand = True)\n",
    "workcut = test['work'].str.split(\" \", expand = True) \n",
    "test['status']=statuscut[0]\n",
    "test['status1']=statuscut[1]\n",
    "test['work']=workcut[0]\n",
    "test['work1']=workcut[1]\n",
    "test=test.fillna(0)\n",
    "test['status']=test['status'].astype('int64')\n",
    "test['status1']=test['status1'].astype('int64')\n",
    "test['work']=test['work'].astype('int64')\n",
    "test['work1']=test['work1'].astype('int64')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "adExposure = pd.read_csv('./adExposure.csv')\n",
    "adExposure['msrequestTime']=pd.to_datetime(adExposure['requestTime'],unit='s')\n",
    "adExposure['drequestTime'] = adExposure.msrequestTime.dt.date\n",
    "import datetime\n",
    "train = adExposure[adExposure['drequestTime'] > datetime.date(year=2019,month=3,day=14)]\n",
    "train = train[train['drequestTime'] != datetime.date(year=2019,month=3,day=19)]\n",
    "validate = adExposure[adExposure['drequestTime'] == datetime.date(year=2019,month=3,day=19)]\n",
    "train = train.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "Input= ['tid','aid','price', 'aIndustryId', 'createTime', 'pType',  'size', \n",
    "'pricepersize', 'bigprice', 'age', 'connectionType', 'consuptionAbility', \n",
    "        'device', 'education', 'gender', 'status','status1', 'work','work1','equality_ecpm', 'pctr','totalEcpm', 'basicecpm']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_model_index = ['tid', 'aid','price', 'createTime','pType', 'size', 'aIndustryId', 'age', 'connectionType', 'consuptionAbility', \n",
    "                     'equality_ecpm', 'pctr','totalEcpm','device', 'education', 'gender', 'status', 'work']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = pd.merge(train, adstatic, on='aid', how='left')\n",
    "train = pd.merge(train, user, on='uid', how='left')\n",
    "train = train.drop(['size_y','msrequestTime','drequestTime','auid'],axis = 1)\n",
    "train.rename(columns={'size_x':'size', 'adPrice':'price', 'aRequestId':'tid'}, inplace=True)\n",
    "train = train[first_model_index]\n",
    "statuscut = train['status'].str.split(\" \", expand = True)\n",
    "workcut = train['work'].str.split(\" \", expand = True) \n",
    "train['status']=statuscut[0]\n",
    "train['status1']=statuscut[1]\n",
    "train['work']=workcut[0]\n",
    "train['work1']=workcut[1]\n",
    "train=train.fillna(0)\n",
    "train['status']=train['status'].astype('int64')\n",
    "train['status1']=train['status1'].astype('int64')\n",
    "train['work']=train['work'].astype('int64')\n",
    "train['work1']=train['work1'].astype('int64')\n",
    "train['pricepersize'] = train['price']/train['size'] * 100000000000000000\n",
    "train['bigprice'] = train['price'] * 100000000000000000\n",
    "train['basicecpm']=train['pctr']*train['price']\n",
    "traininput = train.groupby(['aid','price'], as_index=False).mean()\n",
    "trainoutput = train.groupby(['aid','price'], as_index=False).count()['tid']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test1 = pd.merge(test, traininput[['aid','price', 'equality_ecpm', 'pctr','totalEcpm']], on=['aid','price'], how='left').drop_duplicates(subset=['aid','price'])\n",
    "testinput = test1.fillna(0)\n",
    "testinput = testinput.reset_index(drop = True)\n",
    "testinput['basicecpm']=testinput['pctr']*testinput['price']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "validate = validate.reset_index(drop=True)\n",
    "validate = pd.merge(validate, adstatic, on='aid', how='left')\n",
    "validate = pd.merge(validate, user, on='uid', how='left')\n",
    "validate.rename(columns={'size_x':'size', 'adPrice':'price', 'aRequestId':'tid'}, inplace=True)\n",
    "validate = validate.drop(['size_y','msrequestTime','drequestTime','auid'],axis = 1)\n",
    "validate = validate[first_model_index]\n",
    "statuscut = validate['status'].str.split(\" \", expand = True)\n",
    "workcut = validate['work'].str.split(\" \", expand = True) \n",
    "validate['status']=statuscut[0]\n",
    "validate['status1']=statuscut[1]\n",
    "validate['work']=workcut[0]\n",
    "validate['work1']=workcut[1]\n",
    "validate=validate.fillna(0)\n",
    "validate['status']=validate['status'].astype('int64')\n",
    "validate['status1']=validate['status1'].astype('int64')\n",
    "validate['work']=validate['work'].astype('int64')\n",
    "validate['work1']=validate['work1'].astype('int64')\n",
    "validate['pricepersize'] = validate['price']/train['size'] * 100000000000000000\n",
    "validate['bigprice'] = validate['price'] * 100000000000000000\n",
    "validate['basicecpm']=validate['pctr']*validate['price']\n",
    "traininput = train.groupby(['aid','price'], as_index=False).mean()\n",
    "validateinput = validate.groupby(['aid','price'], as_index=False).mean()\n",
    "validateoutput = validate.groupby(['aid','price'], as_index=False).count()['tid']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "reg = LinearRegression()\n",
    "reg.fit(traininput[Input], trainoutput)\n",
    "y_pred1 = reg.predict(validateinput[Input]) \n",
    "pred1 = reg.predict(testinput[Input]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "regtree2 = decision_tree_regression.create(traininput[Input], trainoutput)\n",
    "y_pred22 = regtree2.predict(validateinput[Input])\n",
    "results = model.evaluate(validateinput[Input])\n",
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.show(view=\"Tree\", tree_id=0)\n",
    "# Regression Tree\n",
    "regtree = DecisionTreeRegressor(random_state = 0)\n",
    "regtree.fit(traininput[Input], trainoutput)\n",
    "y_pred2 = regtree.predict(validateinput[Input]) \n",
    "# pred2 = regtree.predict(testinput[Input]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from sklearn.tree import export_graphviz\n",
    "# from IPython.display import SVG\n",
    "# from IPython.display import display\n",
    "# from graphviz import Source\n",
    "# treevisiual = export_graphviz(regtree, out_file = None,\n",
    "#                                    feature_names = Input, filled= True,\n",
    "#                                    rounded = True, special_characters = True)\n",
    "# display(SVG(graph.pipe(format='svg')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Random forsest\n",
    "RFreg = RandomForestRegressor(n_estimators = 10, criterion = 'mse', random_state = 0)\n",
    "RFreg.fit(traininput[Input], trainoutput)\n",
    "y_pred3 = RFreg.predict(validateinput) \n",
    "pred3 = RFreg.predict(testinput[Input]) \n",
    "from sklearn.externals.six import StringIO\n",
    "from IPython.display import Image\n",
    "from sklearn.tree import export_graphviz\n",
    "import pydotplus\n",
    "dot_data = StringIO()\n",
    "export_graphviz(regtree, out_file = dot_data, \n",
    "                filled = True, rounded = True, special_characters = True)\n",
    "graph = pydotplus.graph_from_dot_data(dot_data.getvalue())\n",
    "Image(graph.create_png())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dmatrix = xgb.DMatrix(data=traininput[Input],label=trainoutput)\n",
    "xg_reg = xgb.XGBRegressor(objective ='reg:linear', colsample_bytree = 0.2, learning_rate = 0.01,\n",
    "                max_depth = 10, alpha = 10, n_estimators = 10)\n",
    "xg_reg.fit(traininput[Input],trainoutput)\n",
    "\n",
    "y_pred4 = xg_reg.predict(validateinput[Input])\n",
    "pred4 = xg_reg.predict(testinput[Input]) \n",
    "xgb.plot_importance(xg_reg)\n",
    "plt.rcParams['figure.figsize'] = [5, 5]\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Light gbm\n",
    "lgb_train = lgb.Dataset(traininput[Input], trainoutput)\n",
    "lgb_eval = lgb.Dataset(validateinput[Input], validateoutput, reference = lgb_train)\n",
    "params = {\n",
    "    'boosting_type': 'gbdt',\n",
    "    'objective': 'regression',\n",
    "    'metric': {'l2', 'l1'},\n",
    "    'num_leaves': 31,\n",
    "    'learning_rate': 0.01,\n",
    "    'feature_fraction': 0.9,\n",
    "    'bagging_fraction': 0.8,\n",
    "    'bagging_freq': 5,\n",
    "    'verbose': 0\n",
    "}\n",
    "gbm = lgb.train(params,\n",
    "                lgb_train,\n",
    "                num_boost_round=10000,\n",
    "                valid_sets=lgb_eval,\n",
    "                early_stopping_rounds=5)\n",
    "y_pred5 = gbm.predict(validateinput, num_iteration=gbm.best_iteration) \n",
    "pred5 = gbm.predict(testinput[Input]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lgb.plot_importance(gbm)\n",
    "testinput"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred1 = y_pred1 + alpha * validateinput['price']\n",
    "y_pred2 = y_pred2 + alpha * validateinput['price']\n",
    "y_pred3 = y_pred3 + alpha * validateinput['price']\n",
    "y_pred4 = y_pred4 + alpha * validateinput['price']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reg SMPAE : 1.011671552009012 regtree SMPAE : 0.22874564768780326\n",
      "RF SMPAE : 0.8395390879796779 xgb SMPAE : 0.5071402324466373\n",
      "lgb SMPAE : 0.8155647199545979\n"
     ]
    }
   ],
   "source": [
    "# SMPAE\n",
    "gap1 = np.absolute(y_pred1-validateoutput.values)\n",
    "Sum1 = y_pred1+validateoutput.values\n",
    "gap2 = np.absolute(y_pred2-validateoutput.values)\n",
    "Sum2 = y_pred2+validateoutput.values\n",
    "gap3 = np.absolute(y_pred3-validateoutput.values)\n",
    "Sum3 = y_pred3+validateoutput.values\n",
    "gap4 = np.absolute(y_pred4-validateoutput.values)\n",
    "Sum4 = y_pred4+validateoutput.values\n",
    "gap5 = np.absolute(y_pred5-validateoutput.values)\n",
    "Sum5 = y_pred5+validateoutput.values\n",
    "\n",
    "smpae1=2*gap1/Sum1\n",
    "smpae2=2*gap2/Sum2\n",
    "smpae3=2*gap3/Sum3\n",
    "smpae4=2*gap4/Sum4\n",
    "smpae5=2*gap5/Sum5\n",
    "\n",
    "\n",
    "SMPAE1= smpae1.mean()\n",
    "SMPAE2= smpae2.mean()\n",
    "SMPAE3= smpae3.mean()\n",
    "SMPAE4= smpae4.mean()\n",
    "SMPAE5= smpae5.mean()\n",
    "\n",
    "print('reg SMPAE : {}'.format(SMPAE1),'regtree SMPAE : {}'.format(SMPAE2))\n",
    "print('RF SMPAE : {}'.format(SMPAE3),'xgb SMPAE : {}'.format(SMPAE4))\n",
    "print('lgb SMPAE : {}'.format(SMPAE5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reg Monoscore : 0.2903712356259061 regtree Monoscore : 0.39490247792691596\n",
      "RF Monoscore : 0.08945793788348683 xgb Monoscore : 0.302729492243552\n",
      "lgb Monoscore : 0.6145628505424909\n"
     ]
    }
   ],
   "source": [
    "validateinput['pred1']=y_pred1 #reg\n",
    "validateinput['pred2']=y_pred2 #regtree\n",
    "validateinput['pred3']=y_pred3 #rf\n",
    "validateinput['pred4']=y_pred4 #xgb\n",
    "validateinput['pred5']=y_pred5 #lgb\n",
    "out = validateinput[['aid','price','pred1','pred2','pred3','pred4','pred5']]\n",
    "aid = out['aid'].unique()\n",
    "\n",
    "S1 = []\n",
    "S2 = []\n",
    "S3 = []\n",
    "S4 = []\n",
    "S5 = []\n",
    "for a in aid :\n",
    "    s1 = []\n",
    "    s2 = []\n",
    "    s3 = []\n",
    "    s4 = []\n",
    "    s5 = []\n",
    "    each = out[out['aid']==a].reset_index(drop=True)\n",
    "    price0 = each['price'][0]\n",
    "    pred10 = each['pred1'][0]\n",
    "    pred20 = each['pred2'][0]\n",
    "    pred30 = each['pred3'][0]\n",
    "    pred40 = each['pred4'][0]\n",
    "    pred50 = each['pred5'][0]\n",
    "    \n",
    "    num = each.count()[0]\n",
    "    for n in range(num) :\n",
    "        b1 = (each['price'][n]-price0)*(each['pred1'][n]-pred10)\n",
    "        b2 = (each['price'][n]-price0)*(each['pred2'][n]-pred20)\n",
    "        b3 = (each['price'][n]-price0)*(each['pred3'][n]-pred30)\n",
    "        b4 = (each['price'][n]-price0)*(each['pred4'][n]-pred40)\n",
    "        b5 = (each['price'][n]-price0)*(each['pred5'][n]-pred40)\n",
    "        if b1 > 0.0 :\n",
    "            s1.append(1)\n",
    "        elif b1 < 0.0 :\n",
    "            s1.append(-1)\n",
    "        else :\n",
    "            s1.append(0)\n",
    "        if b2 > 0.0 :\n",
    "            s2.append(1)\n",
    "        elif b2 < 0.0 :\n",
    "            s2.append(-1)\n",
    "        else :\n",
    "            s2.append(0)\n",
    "        if b3 > 0.0 :\n",
    "            s3.append(1)\n",
    "        elif b3 < 0.0 :\n",
    "            s3.append(-1)\n",
    "        else :\n",
    "            s3.append(0)\n",
    "        if b4 > 0.0 :\n",
    "            s4.append(1)\n",
    "        elif b4 < 0.0 :\n",
    "            s4.append(-1)\n",
    "        else :\n",
    "            s4.append(0)\n",
    "        if b5 > 0.0 :\n",
    "            s5.append(1)\n",
    "        elif b5 < 0.0 :\n",
    "            s5.append(-1)\n",
    "        else :\n",
    "            s5.append(0)\n",
    "            \n",
    "    S1.append(sum(s1)/len(s1))\n",
    "    S2.append(sum(s2)/len(s2))\n",
    "    S3.append(sum(s3)/len(s3))\n",
    "    S4.append(sum(s4)/len(s4))\n",
    "    S5.append(sum(s5)/len(s5))    \n",
    "\n",
    "monoscore1 = sum(S1)/len(S1)\n",
    "monoscore2 = sum(S2)/len(S2)\n",
    "monoscore3 = sum(S3)/len(S3)\n",
    "monoscore4 = sum(S4)/len(S4)\n",
    "monoscore5 = sum(S5)/len(S5)\n",
    "\n",
    "print('reg Monoscore : {}'.format(monoscore1),'regtree Monoscore : {}'.format(monoscore2))\n",
    "print('RF Monoscore : {}'.format(monoscore3),'xgb Monoscore : {}'.format(monoscore4))\n",
    "print('lgb Monoscore : {}'.format(monoscore5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reg TotalScore : 58.47770602859694 regtree TotalScore : 77.2721613840514\n",
      "RF TotalScore : 55.892956376911044 xgb TotalScore : 68.93908011837382\n",
      "lgb TotalScore : 72.12559111718278\n"
     ]
    }
   ],
   "source": [
    "w1=40\n",
    "w2=60\n",
    "TotalScore1 = w1*(1-SMPAE1/2)+w2*(monoscore1 + 1)/2\n",
    "TotalScore2 = w1*(1-SMPAE2/2)+w2*(monoscore2 + 1)/2\n",
    "TotalScore3 = w1*(1-SMPAE3/2)+w2*(monoscore3 + 1)/2\n",
    "TotalScore4 = w1*(1-SMPAE4/2)+w2*(monoscore4 + 1)/2\n",
    "TotalScore5 = w1*(1-SMPAE5/2)+w2*(monoscore5 + 1)/2\n",
    "\n",
    "print('reg TotalScore : {}'.format(TotalScore1),'regtree TotalScore : {}'.format(TotalScore2))\n",
    "print('RF TotalScore : {}'.format(TotalScore3),'xgb TotalScore : {}'.format(TotalScore4))\n",
    "print('lgb TotalScore : {}'.format(TotalScore5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "testinput\n",
    "testinput['pred'] = pred2\n",
    "pred = testinput[['tid', 'pred']]\n",
    "pred['pred'] = pred['pred'].round(4)\n",
    "pred.pred = pred.pred.astype(float)\n",
    "pred.to_csv('submission.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}