Case1modeling.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: xgboost in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (1.3.3)\n",
      "Requirement already satisfied: scipy in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from xgboost) (1.6.0)\n",
      "Requirement already satisfied: numpy in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from xgboost) (1.20.0)\n",
      "Requirement already satisfied: lightgbm in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (3.1.1)\n",
      "Requirement already satisfied: wheel in /snap/jupyter/6/lib/python3.7/site-packages (from lightgbm) (0.33.4)\n",
      "Requirement already satisfied: numpy in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from lightgbm) (1.20.0)\n",
      "Requirement already satisfied: scikit-learn!=0.22.0 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from lightgbm) (0.24.1)\n",
      "Requirement already satisfied: scipy in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from lightgbm) (1.6.0)\n",
      "Requirement already satisfied: threadpoolctl>=2.0.0 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from scikit-learn!=0.22.0->lightgbm) (2.1.0)\n",
      "Requirement already satisfied: joblib>=0.11 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from scikit-learn!=0.22.0->lightgbm) (1.0.0)\n",
      "Requirement already satisfied: mlxtend in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (0.18.0)\n",
      "Requirement already satisfied: numpy>=1.16.2 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from mlxtend) (1.20.0)\n",
      "Requirement already satisfied: setuptools in /snap/jupyter/6/lib/python3.7/site-packages (from mlxtend) (41.0.1)\n",
      "Requirement already satisfied: scipy>=1.2.1 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from mlxtend) (1.6.0)\n",
      "Requirement already satisfied: pandas>=0.24.2 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from mlxtend) (1.2.1)\n",
      "Requirement already satisfied: matplotlib>=3.0.0 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from mlxtend) (3.3.4)\n",
      "Requirement already satisfied: scikit-learn>=0.20.3 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from mlxtend) (0.24.1)\n",
      "Requirement already satisfied: joblib>=0.13.2 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from mlxtend) (1.0.0)\n",
      "Requirement already satisfied: pytz>=2017.3 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from pandas>=0.24.2->mlxtend) (2021.1)\n",
      "Requirement already satisfied: python-dateutil>=2.7.3 in /snap/jupyter/6/lib/python3.7/site-packages (from pandas>=0.24.2->mlxtend) (2.8.0)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from matplotlib>=3.0.0->mlxtend) (1.3.1)\n",
      "Requirement already satisfied: cycler>=0.10 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from matplotlib>=3.0.0->mlxtend) (0.10.0)\n",
      "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.3 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from matplotlib>=3.0.0->mlxtend) (2.4.7)\n",
      "Requirement already satisfied: pillow>=6.2.0 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from matplotlib>=3.0.0->mlxtend) (8.1.0)\n",
      "Requirement already satisfied: threadpoolctl>=2.0.0 in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (from scikit-learn>=0.20.3->mlxtend) (2.1.0)\n",
      "Requirement already satisfied: six>=1.5 in /snap/jupyter/6/lib/python3.7/site-packages (from python-dateutil>=2.7.3->pandas>=0.24.2->mlxtend) (1.12.0)\n",
      "Requirement already satisfied: graphviz in /home/jonah/snap/jupyter/common/lib/python3.7/site-packages (0.16)\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "pip install xgboost\n",
    "pip install lightgbm\n",
    "pip install mlxtend\n",
    "pip install graphviz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "from sklearn.linear_model import LinearRegression, ElasticNet, Lasso, Ridge\n",
    "from sklearn.svm import SVR\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.ensemble import RandomForestRegressor, BaggingRegressor, AdaBoostRegressor, GradientBoostingRegressor\n",
    "from sklearn.metrics import explained_variance_score\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.metrics import max_error\n",
    "from sklearn.metrics import r2_score\n",
    "from sklearn.decomposition import PCA\n",
    "from mlxtend.regressor import StackingCVRegressor\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import uniform, randint\n",
    "import xgboost\n",
    "from xgboost import XGBRegressor\n",
    "from lightgbm import LGBMRegressor\n",
    "import graphviz\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "%store -r x_train_prepared\n",
    "%store -r x_test_prepared\n",
    "%store -r y_train\n",
    "%store -r y_test\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "80\n"
     ]
    }
   ],
   "source": [
    "pca = PCA()\n",
    "pca.fit(x_train_prepared)\n",
    "cumsum = np.cumsum(pca.explained_variance_ratio_)\n",
    "d = np.argmax(cumsum >= 0.95) + 1\n",
    "print(pca.n_components_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6,4))\n",
    "plt.plot(cumsum, linewidth=3)\n",
    "plt.axis([0, 80, 0, 1.05])\n",
    "plt.xlabel(\"Dimensions\")\n",
    "plt.ylabel(\"Explained Variance\")\n",
    "plt.plot([d, d], [0, 0.95], \"k:\")\n",
    "plt.plot([0, d], [0.95, 0.95], \"k:\")\n",
    "plt.plot(d, 0.95, \"ko\")\n",
    "plt.annotate(\"Elbow\", xy=(65, 0.85), xytext=(70, 0.7),\n",
    "             arrowprops=dict(arrowstyle=\"->\"), fontsize=16)\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "pca = PCA(n_components=0.95)\n",
    "x_reduced = pca.fit_transform(x_train_prepared)\n",
    "x_test_reduced = pca.transform(x_test_prepared)\n",
    "print(len(x_test_prepared))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52.26443584151022\n",
      "102.17809485110261\n",
      "0.45316127813696494\n"
     ]
    }
   ],
   "source": [
    "lin_reg = LinearRegression()\n",
    "lin_reg.fit(x_reduced, y_train)\n",
    "y_pred = lin_reg.predict(x_test_reduced)\n",
    "print(np.sqrt(mean_squared_error(y_test,y_pred)))\n",
    "print(max_error(y_test,y_pred))\n",
    "print(r2_score(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "62.515120744298805\n",
      "145.70092899003188\n",
      "0.21762155925158966\n"
     ]
    }
   ],
   "source": [
    "ridge_reg = Ridge()\n",
    "ridge_reg.fit(x_train_prepared, y_train)\n",
    "y_pred = ridge_reg.predict(x_test_prepared)\n",
    "print(np.sqrt(mean_squared_error(y_test,y_pred)))\n",
    "print(max_error(y_test,y_pred))\n",
    "print(r2_score(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "38.70818975466528\n",
      "96.95906876368696\n",
      "0.7000475258192909\n"
     ]
    }
   ],
   "source": [
    "lasso_reg = Lasso()\n",
    "lasso_reg.fit(x_train_prepared, y_train)\n",
    "y_pred = lasso_reg.predict(x_test_prepared)\n",
    "print(np.sqrt(mean_squared_error(y_test,y_pred)))\n",
    "print(max_error(y_test,y_pred))\n",
    "print(r2_score(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48.64319666820108\n",
      "100.7999949922011\n",
      "0.5263135725915586\n"
     ]
    }
   ],
   "source": [
    "enet_reg = ElasticNet()\n",
    "enet_reg.fit(x_train_prepared, y_train)\n",
    "y_pred = enet_reg.predict(x_test_prepared)\n",
    "print(np.sqrt(mean_squared_error(y_test,y_pred)))\n",
    "print(max_error(y_test,y_pred))\n",
    "print(r2_score(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "54.49809443329604\n",
      "104.89634899999999\n",
      "0.405421282268844\n"
     ]
    }
   ],
   "source": [
    "tree_reg = DecisionTreeRegressor()\n",
    "tree_reg.fit(x_train_prepared, y_train)\n",
    "y_pred = tree_reg.predict(x_test_prepared)\n",
    "print(np.sqrt(mean_squared_error(y_test,y_pred)))\n",
    "print(max_error(y_test,y_pred))\n",
    "print(r2_score(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37.64909141322404\n",
      "79.28249871999995\n",
      "0.7162370270814428\n"
     ]
    }
   ],
   "source": [
    "forest_reg = RandomForestRegressor()\n",
    "forest_reg.fit(x_train_prepared, y_train)\n",
    "y_pred = forest_reg.predict(x_test_prepared)\n",
    "\n",
    "print(np.sqrt(mean_squared_error(y_test,y_pred)))\n",
    "print(max_error(y_test,y_pred))\n",
    "print(r2_score(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37.78554927666947\n",
      "82.22732210000001\n",
      "0.7141763206855156\n"
     ]
    }
   ],
   "source": [
    "bag_reg = BaggingRegressor()\n",
    "bag_reg.fit(x_train_prepared, y_train)\n",
    "y_pred = bag_reg.predict(x_test_prepared)\n",
    "\n",
    "print(np.sqrt(mean_squared_error(y_test,y_pred)))\n",
    "print(max_error(y_test,y_pred))\n",
    "print(r2_score(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40.54155138872962\n",
      "98.65243725\n",
      "0.670960941994577\n"
     ]
    }
   ],
   "source": [
    "ada_reg = AdaBoostRegressor()\n",
    "ada_reg.fit(x_train_prepared, y_train)\n",
    "y_pred = ada_reg.predict(x_test_prepared)\n",
    "\n",
    "print(np.sqrt(mean_squared_error(y_test,y_pred)))\n",
    "print(max_error(y_test,y_pred))\n",
    "print(r2_score(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52.10778490832393\n",
      "118.89938835502983\n",
      "0.45643441855027234\n"
     ]
    }
   ],
   "source": [
    "gbr_reg = GradientBoostingRegressor(n_estimators=3000,\n",
    "                                    learning_rate=0.05, max_depth=4, max_features='sqrt',\n",
    "                                    min_samples_leaf=15, min_samples_split=10, loss='huber', random_state =42)\n",
    "gbr_reg.fit(x_train_prepared, y_train)\n",
    "y_pred = gbr_reg.predict(x_test_prepared)\n",
    "\n",
    "print(np.sqrt(mean_squared_error(y_test,y_pred)))\n",
    "print(max_error(y_test,y_pred))\n",
    "print(r2_score(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LightGBM] [Warning] feature_fraction is set=0.2, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.2\n",
      "[LightGBM] [Warning] bagging_freq is set=5, subsample_freq=0 will be ignored. Current value: bagging_freq=5\n",
      "[LightGBM] [Warning] bagging_fraction is set=0.75, subsample=1.0 will be ignored. Current value: bagging_fraction=0.75\n",
      "58.77364112867641\n",
      "111.12899426500013\n",
      "0.30846857633683933\n"
     ]
    }
   ],
   "source": [
    "lgbm_reg = LGBMRegressor(objective='regression', \n",
    "                                       num_leaves=4,\n",
    "                                       learning_rate=0.01, \n",
    "                                       n_estimators=5000,\n",
    "                                       max_bin=200, \n",
    "                                       bagging_fraction=0.75,\n",
    "                                       bagging_freq=5, \n",
    "                                       bagging_seed=7,\n",
    "                                       feature_fraction=0.2,\n",
    "                                       feature_fraction_seed=7,\n",
    "                                       verbose=-1,\n",
    "                                       )\n",
    "lgbm_reg.fit(x_train_prepared, y_train)\n",
    "y_pred = lgbm_reg.predict(x_test_prepared)\n",
    "\n",
    "print(np.sqrt(mean_squared_error(y_test,y_pred)))\n",
    "print(max_error(y_test,y_pred))\n",
    "print(r2_score(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15:21:41] WARNING: ../src/objective/regression_obj.cu:170: reg:linear is now deprecated in favor of reg:squarederror.\n",
      "35.041868259991624\n",
      "79.56207328222655\n",
      "0.7541777264910765\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Feature importance'}, xlabel='F score', ylabel='Features'>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1440x432 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xgb_reg = XGBRegressor(learning_rate=0.01,n_estimators=3460,\n",
    "                                     max_depth=3, min_child_weight=0,\n",
    "                                     gamma=0, subsample=0.7,\n",
    "                                     colsample_bytree=0.7,\n",
    "                                     objective='reg:linear', nthread=-1,\n",
    "                                     scale_pos_weight=1, seed=27,\n",
    "                                     reg_alpha=0.00006)\n",
    "xgb_reg.fit(x_train_prepared, y_train)\n",
    "y_pred = xgb_reg.predict(x_test_prepared)\n",
    "\n",
    "print(np.sqrt(mean_squared_error(y_test,y_pred)))\n",
    "print(max_error(y_test,y_pred))\n",
    "print(r2_score(y_test,y_pred))\n",
    "plt.figure(figsize=(20, 6))\n",
    "xgboost.plot_importance(xgb_reg)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LightGBM] [Warning] feature_fraction is set=0.2, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.2\n",
      "[LightGBM] [Warning] bagging_freq is set=5, subsample_freq=0 will be ignored. Current value: bagging_freq=5\n",
      "[LightGBM] [Warning] bagging_fraction is set=0.75, subsample=1.0 will be ignored. Current value: bagging_fraction=0.75\n",
      "[LightGBM] [Warning] feature_fraction is set=0.2, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.2\n",
      "[LightGBM] [Warning] bagging_freq is set=5, subsample_freq=0 will be ignored. Current value: bagging_freq=5\n",
      "[LightGBM] [Warning] bagging_fraction is set=0.75, subsample=1.0 will be ignored. Current value: bagging_fraction=0.75\n",
      "[LightGBM] [Warning] feature_fraction is set=0.2, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.2\n",
      "[LightGBM] [Warning] bagging_freq is set=5, subsample_freq=0 will be ignored. Current value: bagging_freq=5\n",
      "[LightGBM] [Warning] bagging_fraction is set=0.75, subsample=1.0 will be ignored. Current value: bagging_fraction=0.75\n",
      "[LightGBM] [Warning] feature_fraction is set=0.2, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.2\n",
      "[LightGBM] [Warning] bagging_freq is set=5, subsample_freq=0 will be ignored. Current value: bagging_freq=5\n",
      "[LightGBM] [Warning] bagging_fraction is set=0.75, subsample=1.0 will be ignored. Current value: bagging_fraction=0.75\n",
      "[LightGBM] [Warning] feature_fraction is set=0.2, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.2\n",
      "[LightGBM] [Warning] bagging_freq is set=5, subsample_freq=0 will be ignored. Current value: bagging_freq=5\n",
      "[LightGBM] [Warning] bagging_fraction is set=0.75, subsample=1.0 will be ignored. Current value: bagging_fraction=0.75\n",
      "[LightGBM] [Warning] feature_fraction is set=0.2, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.2\n",
      "[LightGBM] [Warning] bagging_freq is set=5, subsample_freq=0 will be ignored. Current value: bagging_freq=5\n",
      "[LightGBM] [Warning] bagging_fraction is set=0.75, subsample=1.0 will be ignored. Current value: bagging_fraction=0.75\n",
      "37.13173822204522\n",
      "62.21243670825195\n",
      "0.7239820755003297\n"
     ]
    }
   ],
   "source": [
    "regressors=(gbr_reg, forest_reg, ada_reg,bag_reg, xgb_reg, lgbm_reg,lasso_reg,enet_reg,ridge_reg)\n",
    "stack_reg = StackingCVRegressor(regressors=regressors,\n",
    "                                meta_regressor=xgb_reg,\n",
    "                                use_features_in_secondary=True)\n",
    "stack_reg.fit(x_train_prepared, y_train)\n",
    "y_pred = stack_reg.predict(x_test_prepared)\n",
    "\n",
    "print(np.sqrt(mean_squared_error(y_test,y_pred)))\n",
    "print(max_error(y_test,y_pred))\n",
    "print(r2_score(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 200 candidates, totalling 1000 fits\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "xgb_reg = XGBRegressor(n_estimators=3460)\n",
    "params = {\n",
    "    \"colsample_bytree\": uniform(0.7, 0.3),\n",
    "    \"learning_rate\": uniform(0.01, 0.1), # default 0.1 \n",
    "    \"max_depth\": randint(2, 6), # default 3\n",
    "    \"subsample\": uniform(0.6, 0.4)\n",
    "}\n",
    "rand_search = RandomizedSearchCV(xgb_reg, params,  random_state=42, n_iter=200, cv=5, verbose=1, n_jobs=-1, return_train_score=True)\n",
    "rand_search.fit(x_train_prepared, y_train)\n",
    "print(rand_search.best_estimator_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35.324069212725874\n",
      "82.53609519384764\n",
      "0.750202446895416\n"
     ]
    }
   ],
   "source": [
    "final_model = rand_search.best_estimator_\n",
    "final_predictions = final_model.predict(x_test_prepared)\n",
    "print(np.sqrt(mean_squared_error(y_test,final_predictions)))\n",
    "print(max_error(y_test,final_predictions))\n",
    "print(r2_score(y_test,final_predictions))"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}