DRAGON_VPAS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initialisations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T20:04:37.770549Z",
     "start_time": "2020-01-25T20:04:28.066933Z"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd ; pd.set_option('display.max_columns', 500) # dataframes\n",
    "import numpy as np # mathsy bits\n",
    "import ipywidgets as widgets # widgets\n",
    "\n",
    "from sklearn.model_selection import train_test_split #split data into train and test sets\n",
    "\n",
    "# feature selection + gridsearch\n",
    "from sklearn.feature_selection import SelectFromModel, SelectKBest\n",
    "from sklearn.feature_selection import f_regression, mutual_info_regression\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "# models\n",
    "from sklearn.linear_model import Lars, ElasticNet, Lasso\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor\n",
    "from sklearn.ensemble import AdaBoostRegressor, GradientBoostingRegressor\n",
    "\n",
    "import joblib # saving models\n",
    "from datetime import datetime # get time for labelling saved models\n",
    "\n",
    "# visualization\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "import mpld3 # hover-over labels for plots\n",
    "mpld3.disable_notebook()\n",
    "\n",
    "train_scores = dict() ; test_scores  = dict() #to hold scores for viewing at the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T20:04:37.800926Z",
     "start_time": "2020-01-25T20:04:37.772852Z"
    }
   },
   "outputs": [],
   "source": [
    "def grid_search_return_hp_dict(model, X_train_gs, y_train_gs, param_grid):\n",
    "    \"\"\"Run GridSearchCV on given model with defined param_grid, return best params as dict.\n",
    "    Pre-assign sklearn model to variable. Pass param_grid as dict.\"\"\"\n",
    "    print(str(model).split(sep='(')[0], \"grid search.\")\n",
    "    GS = GridSearchCV(model, param_grid, n_jobs=2)\n",
    "    GS.fit(X_train_gs, y_train_gs)\n",
    "    print(GS.best_params_)\n",
    "    return(GS.best_params_)\n",
    "\n",
    "def train_model(model, feature_set, hyperparameters, \n",
    "                grid_search = False):\n",
    "    \"\"\"Wrapper for training models with optional grid search and feature selection.\n",
    "    Pass model with no brackets, ie Lars not Lars()\n",
    "    If grid_search = True, hyperparameters is the hp ranges dictionary. Outputs trained model, best_hp\n",
    "    If grid_search = False, hyperparameters is the hp dictionary. Outputs trained model\"\"\"\n",
    "    X_train, X_test = X_train_main[feature_set], X_test_main[feature_set]\n",
    "    \n",
    "    if grid_search == True:\n",
    "        best_hp = grid_search_return_hp_dict(model(),\n",
    "                                             X_train, y_train, hyperparameters)\n",
    "        print(\"Grid search complete!\\nHyperparameters:\\n\", best_hp)\n",
    "        training_model = model(**best_hp).fit(X_train, y_train)\n",
    "        return training_model, best_hp\n",
    "\n",
    "    if grid_search == False:\n",
    "        print(\"No grid search\\nHyperparameters:\\n\", hyperparameters)\n",
    "        training_model = model(**hyperparameters).fit(X_train, y_train)\n",
    "        return training_model\n",
    "\n",
    "def produce_exp_vs_pred_df(features_list, model, codename): # generalise!\n",
    "    \"\"\"Pass features_list as a string\"\"\"\n",
    "    pred_list = []\n",
    "    for i in range(0, len(dragon_features)):\n",
    "        prediction = model.predict([dragon_features[eval(features_list)].iloc[i]])\n",
    "        pred_list.append(prediction)\n",
    "    \n",
    "    exp_vs_calc = pd.DataFrame(constants_first)\n",
    "    exp_vs_calc['Predicted'] = pred_list\n",
    "    exp_vs_calc.rename({'Kh_first':'Experimental'}, inplace=True, axis=1)\n",
    "    exp_vs_calc.to_csv('models/DRAGON_VPAS/%s'%(\"expvcalc_\" + str(model).split(sep='(')[0] + \"_\" + features_list[16:] + \".csv\"))\n",
    "    now = datetime.now()\n",
    "\n",
    "    dt_string = now.strftime(\"_%d_%m_%Y_%H_%M_%S\")\n",
    "    filename = \"models/DRAGON_VPAS/\" + str(model).split(sep='(')[0] + \"_\" + features_list[16:] + dt_string + \".joblib\"\n",
    "    print(str(model).split(sep='(')[0], \"run at:\", now, \". Saving to\", filename)\n",
    "    \n",
    "    joblib.dump(model, filename)\n",
    "    return exp_vs_calc\n",
    "\n",
    "def prediction_plot_scores(model_func, pred_df):\n",
    "    \"\"\"Print train+test scores, then plot scatter of predicted vs actual HLCs. Uses {X/y}_{train/test},\n",
    "    redefining these variables will change the output.\"\"\"\n",
    "    fig = plt.figure(figsize=(10, 10))\n",
    "    scatter = plt.scatter(pred_df['Experimental'], pred_df['Predicted'])\n",
    "    plt.xlabel('Experimental')\n",
    "    plt.ylabel('Predicted')\n",
    "    plt.title('%s predictions of HLCs' %str(model_func).split(sep='(')[0])\n",
    "    labels = ['{}'.format(i) for i in species_names]\n",
    "    tooltip = mpld3.plugins.PointLabelTooltip(scatter, labels=labels)\n",
    "    mpld3.plugins.connect(fig, tooltip)\n",
    "    plt.plot([-30, 10], [-30, 10], c='red')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DRAGON descriptors\n",
    "## Bringing in data and splitting it into parts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T20:04:38.684875Z",
     "start_time": "2020-01-25T20:04:37.803937Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input Shape (2075, 1480)\n",
      "Removed NaN, new shape (2068, 1480)\n"
     ]
    }
   ],
   "source": [
    "csv = pd.read_csv('filtered_organics_desc_kh.csv') # contains VP/AS HLCs\n",
    "\n",
    "print(\"Input Shape\", csv.shape) #input shape\n",
    "\n",
    "csv.dropna(axis=0, inplace=True)\n",
    "\n",
    "print(\"Removed NaN, new shape\", csv.shape) #removed NaN shape\n",
    "\n",
    "smiles_strings = csv.pop('Unnamed: 0')\n",
    "species_names = csv.pop('0')\n",
    "constants_mean = csv.pop('Kh_mean')\n",
    "constants_first = csv.pop('Kh_first')\n",
    "\n",
    "varying_columns = csv[['Varying_1', 'Varying_2', 'Varying_3', 'Varying_4',\n",
    " 'Varying_5', 'Varying_6', 'Varying_7', 'Varying_8', 'Varying_9']] # popping one-hot encoding columns\n",
    "\n",
    "dragon_features = csv.drop(['Varying_1', 'Varying_2', 'Varying_3', 'Varying_4',\n",
    " 'Varying_5', 'Varying_6', 'Varying_7', 'Varying_8', 'Varying_9', 'Index'], axis=1) #seperating features\n",
    "\n",
    "X_train_main, X_test_main, y_train, y_test = train_test_split(dragon_features, constants_first, test_size=0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T20:04:45.038962Z",
     "start_time": "2020-01-25T20:04:38.687883Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:3: FutureWarning: The signature of `Series.to_csv` was aligned to that of `DataFrame.to_csv`, and argument 'header' will change its default value from False to True: please pass an explicit value to suppress this warning.\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    }
   ],
   "source": [
    "for i in ['X_train_main', 'X_test_main', 'y_train', 'y_test']:\n",
    "    #joblib.dump(exec('i'), \"models/DRAGON_VPAS/%s.joblib\"%i)\n",
    "    eval('%s'%i).to_csv('models/DRAGON_VPAS/%s.csv'%i)\n",
    "    #if 'X' in i:\n",
    "        #eval('%s'%i).drop('Unnamed: 0', axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Selection\n",
    "Made aware of features selection methods in scikitlearn via https://towardsdatascience.com/feature-selection-techniques-in-machine-learning-with-python-f24e7da3f36e\n",
    "\n",
    "See also [scikit-learn docs](https://scikit-learn.org/stable/modules/feature_selection.html)\n",
    "### Importances via 'dummy' GradientBoostingRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T20:05:05.563123Z",
     "start_time": "2020-01-25T20:04:45.045584Z"
    }
   },
   "outputs": [],
   "source": [
    "fs_model = GradientBoostingRegressor()\n",
    "fs_model.fit(X_train_main, y_train)\n",
    "importances = pd.Series(fs_model.feature_importances_, index = X_train_main.columns)\n",
    "top_15_features_model = list(importances.nlargest(15).index.values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importances via 'dummy' LASSO model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T20:05:30.182854Z",
     "start_time": "2020-01-25T20:05:05.566102Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\coordinate_descent.py:475: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Duality gap: 156.79907782243208, tolerance: 7.848553524875528\n",
      "  positive)\n"
     ]
    }
   ],
   "source": [
    "dummy_lasso = Lasso(max_iter=10000, alpha=0.5)\n",
    "selector = SelectFromModel(dummy_lasso).fit(X_train_main, y_train)\n",
    "coefs = selector.estimator_.coef_\n",
    "importances_lasso = pd.Series(coefs, index = X_train_main.columns)\n",
    "top_15_features_lasso = list(importances_lasso.nlargest(15).index.values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SelectKBest using f_regression scoring function\n",
    "F-test estimates degree of linear dependency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T20:05:30.335259Z",
     "start_time": "2020-01-25T20:05:30.184860Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\feature_selection\\univariate_selection.py:299: RuntimeWarning: invalid value encountered in true_divide\n",
      "  corr /= X_norms\n",
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\scipy\\stats\\_distn_infrastructure.py:901: RuntimeWarning: invalid value encountered in greater\n",
      "  return (a < x) & (x < b)\n",
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\scipy\\stats\\_distn_infrastructure.py:901: RuntimeWarning: invalid value encountered in less\n",
      "  return (a < x) & (x < b)\n",
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\scipy\\stats\\_distn_infrastructure.py:1892: RuntimeWarning: invalid value encountered in less_equal\n",
      "  cond2 = cond0 & (x <= _a)\n"
     ]
    }
   ],
   "source": [
    "fs_kbest = SelectKBest(score_func= f_regression, k=15)\n",
    "fit = fs_kbest.fit(X_train_main, y_train)\n",
    "scores_f = pd.Series(fit.scores_, index=X_train_main.columns)\n",
    "top_15_features_kbest = list(scores_f.nlargest(15).index.values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SelectKBest using mutual_info_regression\n",
    "Catch any statistical dependancy, but requires more samples than f_reg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T20:06:08.197015Z",
     "start_time": "2020-01-25T20:05:30.339271Z"
    }
   },
   "outputs": [],
   "source": [
    "fs_mut_info = SelectKBest(score_func= mutual_info_regression, k=15)\n",
    "fit = fs_mut_info.fit(X_train_main, y_train)\n",
    "scores_mutual = pd.Series(fit.scores_, index=X_train_main.columns)\n",
    "top_15_features_mutual_info = list(scores_mutual.nlargest(15).index.values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feature Selection results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T20:06:09.138532Z",
     "start_time": "2020-01-25T20:06:08.199933Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, imp_plot = plt.subplots(nrows=1, ncols=4, figsize=(15, 10))\n",
    "imp_plot[0].barh(importances.nlargest(15).index.values, importances.nlargest(15))\n",
    "imp_plot[0].set_title('Dummy Model')\n",
    "imp_plot[1].barh(scores_mutual.nlargest(15).index.values, scores_mutual.nlargest(15))\n",
    "imp_plot[1].set_title('Mutual Information')\n",
    "imp_plot[2].barh(scores_f.nlargest(15).index.values, scores_f.nlargest(15))\n",
    "imp_plot[2].set_title('F Regression')\n",
    "imp_plot[3].barh(importances_lasso.nlargest(15).index.values, importances_lasso.nlargest(15))\n",
    "imp_plot[3].set_title('LASSO')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exporting feature importances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T20:06:09.330876Z",
     "start_time": "2020-01-25T20:06:09.141542Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['models/DRAGON_VPAS/mutual_importances.joblib']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joblib.dump(importances, \"models/DRAGON_VPAS/model_importances.joblib\")\n",
    "joblib.dump(importances_lasso, \"models/DRAGON_VPAS/lasso_importances.joblib\")\n",
    "joblib.dump(scores_f, \"models/DRAGON_VPAS/freg_importances.joblib\")\n",
    "joblib.dump(scores_mutual, \"models/DRAGON_VPAS/mutual_importances.joblib\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GradientBoosting\n",
    "### Model-chosen features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T20:06:09.340902Z",
     "start_time": "2020-01-25T20:06:09.333884Z"
    }
   },
   "outputs": [],
   "source": [
    "gbr_param_grid = {\n",
    "    'n_estimators': [500, 1000, 2000],\n",
    "    'max_depth': [2, 4, 6],\n",
    "    'min_samples_leaf': [3, 5, 9, 17],\n",
    "    'learning_rate': [0.1, 0.05, 0.02],\n",
    "    'max_features': [1.0, 0.3, 0.1],\n",
    "    'loss': ['ls', 'lad', 'huber']\n",
    "} #hyperparameters for each gbr grid search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:11:03.297710Z",
     "start_time": "2020-01-25T20:06:09.344912Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GradientBoostingRegressor grid search.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_split.py:1978: FutureWarning: The default value of cv will change from 3 to 5 in version 0.22. Specify it explicitly to silence this warning.\n",
      "  warnings.warn(CV_WARNING, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'learning_rate': 0.02, 'loss': 'lad', 'max_depth': 6, 'max_features': 0.1, 'min_samples_leaf': 3, 'n_estimators': 2000}\n",
      "Grid search complete!\n",
      "Hyperparameters:\n",
      " {'learning_rate': 0.02, 'loss': 'lad', 'max_depth': 6, 'max_features': 0.1, 'min_samples_leaf': 3, 'n_estimators': 2000}\n",
      "GradientBoostingRegressor run at: 2020-01-25 21:11:03.157335 . Saving to models/DRAGON_VPAS/GradientBoostingRegressor_model_25_01_2020_21_11_03.joblib\n"
     ]
    }
   ],
   "source": [
    "gbr_model, gbr_hp = train_model(model = GradientBoostingRegressor,\n",
    "           feature_set= top_15_features_model,\n",
    "            grid_search=True,\n",
    "           hyperparameters=gbr_param_grid)\n",
    "\n",
    "exp_vs_calc_gbr_model = produce_exp_vs_pred_df('top_15_features_model', gbr_model,\n",
    "                                         \"GradBoost, model-chosen features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### F-regression features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:11:15.373820Z",
     "start_time": "2020-01-25T21:11:03.301722Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'learning_rate': 0.02, 'loss': 'lad', 'max_depth': 6, 'max_features': 0.1, 'min_samples_leaf': 3, 'n_estimators': 2000}\n",
      "GradientBoostingRegressor run at: 2020-01-25 21:11:15.237454 . Saving to models/DRAGON_VPAS/GradientBoostingRegressor_kbest_25_01_2020_21_11_15.joblib\n"
     ]
    }
   ],
   "source": [
    "gbr_freg = train_model(model = GradientBoostingRegressor,\n",
    "           feature_set= top_15_features_kbest,\n",
    "            grid_search=False,\n",
    "           hyperparameters=gbr_hp)\n",
    "\n",
    "exp_vs_calc_gbr_freg = produce_exp_vs_pred_df('top_15_features_kbest', gbr_freg,\n",
    "                                                    \"GradBoost, f_reg features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutual info features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:11:27.169988Z",
     "start_time": "2020-01-25T21:11:15.376829Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'learning_rate': 0.02, 'loss': 'lad', 'max_depth': 6, 'max_features': 0.1, 'min_samples_leaf': 3, 'n_estimators': 2000}\n",
      "GradientBoostingRegressor run at: 2020-01-25 21:11:26.993513 . Saving to models/DRAGON_VPAS/GradientBoostingRegressor_mutual_info_25_01_2020_21_11_26.joblib\n"
     ]
    }
   ],
   "source": [
    "gbr_mu = train_model(model = GradientBoostingRegressor,\n",
    "           feature_set= top_15_features_mutual_info,\n",
    "            grid_search=False,\n",
    "           hyperparameters=gbr_hp)\n",
    "\n",
    "exp_vs_calc_gbr_mu = produce_exp_vs_pred_df('top_15_features_mutual_info', gbr_mu,\n",
    "                                            \"GradBoost, Mutual Info\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LASSO features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:11:38.703755Z",
     "start_time": "2020-01-25T21:11:27.172994Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'learning_rate': 0.02, 'loss': 'lad', 'max_depth': 6, 'max_features': 0.1, 'min_samples_leaf': 3, 'n_estimators': 2000}\n",
      "GradientBoostingRegressor run at: 2020-01-25 21:11:38.564381 . Saving to models/DRAGON_VPAS/GradientBoostingRegressor_lasso_25_01_2020_21_11_38.joblib\n"
     ]
    }
   ],
   "source": [
    "gbr_lasso = train_model(model = GradientBoostingRegressor,\n",
    "           feature_set= top_15_features_lasso,\n",
    "            grid_search=False,\n",
    "           hyperparameters=gbr_hp)\n",
    "exp_vs_calc_gbr_lasso = produce_exp_vs_pred_df('top_15_features_lasso', gbr_lasso,\n",
    "                                               \"LASSO-features, GBR model\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decision Tree\n",
    "### Model-Chosen Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:11:38.712780Z",
     "start_time": "2020-01-25T21:11:38.706763Z"
    }
   },
   "outputs": [],
   "source": [
    "dtr_param_grid = {\n",
    "    'criterion': ['mse', 'friedman_mse', 'mae'], #function measuring quality of a split\n",
    "    'max_depth': [5, 10, 20] , # max depth of tree\n",
    "    'max_features': [5, 10, 15], # N features to be considered when looking for split\n",
    "    'max_leaf_nodes': [None, 10, 15, 20, 30], #grows tree with N nodes in best-first fashion\n",
    "    'min_impurity_decrease': [0.0, 0.1],\n",
    "    'min_samples_leaf': [1, 2, 3], \n",
    "    'min_samples_split': [1.0, 2, 3],\n",
    "    'min_weight_fraction_leaf': [0.0, 0.1, 0.5] , \n",
    "    'splitter': ['best', 'random']\n",
    "} #hyperparameters for dtr gridsearch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:15:34.790154Z",
     "start_time": "2020-01-25T21:11:38.714784Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DecisionTreeRegressor grid search.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_split.py:1978: FutureWarning: The default value of cv will change from 3 to 5 in version 0.22. Specify it explicitly to silence this warning.\n",
      "  warnings.warn(CV_WARNING, FutureWarning)\n",
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_search.py:814: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal.\n",
      "  DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'criterion': 'friedman_mse', 'max_depth': 20, 'max_features': 10, 'max_leaf_nodes': None, 'min_impurity_decrease': 0.0, 'min_samples_leaf': 3, 'min_samples_split': 3, 'min_weight_fraction_leaf': 0.0, 'splitter': 'random'}\n",
      "Grid search complete!\n",
      "Hyperparameters:\n",
      " {'criterion': 'friedman_mse', 'max_depth': 20, 'max_features': 10, 'max_leaf_nodes': None, 'min_impurity_decrease': 0.0, 'min_samples_leaf': 3, 'min_samples_split': 3, 'min_weight_fraction_leaf': 0.0, 'splitter': 'random'}\n",
      "DecisionTreeRegressor run at: 2020-01-25 21:15:34.782136 . Saving to models/DRAGON_VPAS/DecisionTreeRegressor_model_25_01_2020_21_15_34.joblib\n"
     ]
    }
   ],
   "source": [
    "dtr_model, dtr_hp = train_model(model = DecisionTreeRegressor,\n",
    "           feature_set= top_15_features_model,\n",
    "            grid_search=True,\n",
    "           hyperparameters=dtr_param_grid)\n",
    "\n",
    "\n",
    "exp_vs_calc_dtr_model = produce_exp_vs_pred_df('top_15_features_model', dtr_model,\n",
    "                                         \"Decision Tree, model-chosen features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### F-regression features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:15:37.935397Z",
     "start_time": "2020-01-25T21:15:34.793162Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'criterion': 'friedman_mse', 'max_depth': 20, 'max_features': 10, 'max_leaf_nodes': None, 'min_impurity_decrease': 0.0, 'min_samples_leaf': 3, 'min_samples_split': 3, 'min_weight_fraction_leaf': 0.0, 'splitter': 'random'}\n",
      "DecisionTreeRegressor run at: 2020-01-25 21:15:37.924364 . Saving to models/DRAGON_VPAS/DecisionTreeRegressor_kbest_25_01_2020_21_15_37.joblib\n"
     ]
    }
   ],
   "source": [
    "dtr_freg = train_model(model = DecisionTreeRegressor,\n",
    "           feature_set= top_15_features_kbest,\n",
    "            grid_search=False,\n",
    "           hyperparameters=dtr_hp)\n",
    "exp_vs_calc_dtr_freg = produce_exp_vs_pred_df('top_15_features_kbest', dtr_freg,\n",
    "                                         \"Decision Tree, freg features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutual info features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:15:40.970478Z",
     "start_time": "2020-01-25T21:15:37.938405Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'criterion': 'friedman_mse', 'max_depth': 20, 'max_features': 10, 'max_leaf_nodes': None, 'min_impurity_decrease': 0.0, 'min_samples_leaf': 3, 'min_samples_split': 3, 'min_weight_fraction_leaf': 0.0, 'splitter': 'random'}\n",
      "DecisionTreeRegressor run at: 2020-01-25 21:15:40.958468 . Saving to models/DRAGON_VPAS/DecisionTreeRegressor_mutual_info_25_01_2020_21_15_40.joblib\n"
     ]
    }
   ],
   "source": [
    "dtr_mu = train_model(model = DecisionTreeRegressor,\n",
    "           feature_set= top_15_features_mutual_info,\n",
    "            grid_search=False,\n",
    "           hyperparameters=dtr_hp)\n",
    "exp_vs_calc_dtr_mu = produce_exp_vs_pred_df('top_15_features_mutual_info', dtr_mu,\n",
    "                                         \"Decision Tree, mutual info features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LASSO features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:15:44.227124Z",
     "start_time": "2020-01-25T21:15:40.973474Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'criterion': 'friedman_mse', 'max_depth': 20, 'max_features': 10, 'max_leaf_nodes': None, 'min_impurity_decrease': 0.0, 'min_samples_leaf': 3, 'min_samples_split': 3, 'min_weight_fraction_leaf': 0.0, 'splitter': 'random'}\n",
      "DecisionTreeRegressor run at: 2020-01-25 21:15:44.221107 . Saving to models/DRAGON_VPAS/DecisionTreeRegressor_lasso_25_01_2020_21_15_44.joblib\n"
     ]
    }
   ],
   "source": [
    "dtr_lasso = train_model(model = DecisionTreeRegressor,\n",
    "           feature_set= top_15_features_lasso,\n",
    "            grid_search=False,\n",
    "           hyperparameters=dtr_hp)\n",
    "\n",
    "exp_vs_calc_dtr_lasso = produce_exp_vs_pred_df('top_15_features_lasso', dtr_lasso,\n",
    "                                         \"Decision Tree, lasso features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## AdaBoost Regressor\n",
    "### Model Chosen Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:15:44.241162Z",
     "start_time": "2020-01-25T21:15:44.234144Z"
    }
   },
   "outputs": [],
   "source": [
    "base_models = [ExtraTreesRegressor(n_estimators= 5,\n",
    "                                   criterion= 'mse',\n",
    "                                   max_features = 'log2'),\n",
    "               RandomForestRegressor(n_estimators= 5,\n",
    "                                     criterion= 'mse',\n",
    "                                     max_features = 'sqrt',\n",
    "                                     min_samples_split = 3),\n",
    "              GradientBoostingRegressor(),\n",
    "              DecisionTreeRegressor(),\n",
    "              Lars(),\n",
    "              ElasticNet()]\n",
    "\n",
    "ada_param_grid = {\n",
    "    'base_estimator' : base_models, \n",
    "    'learning_rate' : [0.3, 0.5, 0.8, 1], \n",
    "    'loss' : ['linear', 'square', 'exponential'], \n",
    "    'n_estimators' : [50, 100]\n",
    "} #hyperparameters for adaboost gridsearch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:22:29.961639Z",
     "start_time": "2020-01-25T21:15:44.244171Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AdaBoostRegressor grid search.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_split.py:1978: FutureWarning: The default value of cv will change from 3 to 5 in version 0.22. Specify it explicitly to silence this warning.\n",
      "  warnings.warn(CV_WARNING, FutureWarning)\n",
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_search.py:814: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal.\n",
      "  DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'base_estimator': ExtraTreesRegressor(bootstrap=False, criterion='mse', max_depth=None,\n",
      "                    max_features='log2', max_leaf_nodes=None,\n",
      "                    min_impurity_decrease=0.0, min_impurity_split=None,\n",
      "                    min_samples_leaf=1, min_samples_split=2,\n",
      "                    min_weight_fraction_leaf=0.0, n_estimators=5, n_jobs=None,\n",
      "                    oob_score=False, random_state=None, verbose=0,\n",
      "                    warm_start=False), 'learning_rate': 0.3, 'loss': 'exponential', 'n_estimators': 50}\n",
      "Grid search complete!\n",
      "Hyperparameters:\n",
      " {'base_estimator': ExtraTreesRegressor(bootstrap=False, criterion='mse', max_depth=None,\n",
      "                    max_features='log2', max_leaf_nodes=None,\n",
      "                    min_impurity_decrease=0.0, min_impurity_split=None,\n",
      "                    min_samples_leaf=1, min_samples_split=2,\n",
      "                    min_weight_fraction_leaf=0.0, n_estimators=5, n_jobs=None,\n",
      "                    oob_score=False, random_state=None, verbose=0,\n",
      "                    warm_start=False), 'learning_rate': 0.3, 'loss': 'exponential', 'n_estimators': 50}\n",
      "AdaBoostRegressor run at: 2020-01-25 21:22:29.807262 . Saving to models/DRAGON_VPAS/AdaBoostRegressor_model_25_01_2020_21_22_29.joblib\n"
     ]
    }
   ],
   "source": [
    "ada_model, ada_hp = train_model(model = AdaBoostRegressor,\n",
    "           feature_set= top_15_features_model,\n",
    "            grid_search=True,\n",
    "           hyperparameters=ada_param_grid)\n",
    "\n",
    "exp_vs_calc_ada_model = produce_exp_vs_pred_df('top_15_features_model', ada_model,\n",
    "                                               \"AdaBoost, model features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### F-regression features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:23:44.532561Z",
     "start_time": "2020-01-25T21:22:29.972667Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'base_estimator': ExtraTreesRegressor(bootstrap=False, criterion='mse', max_depth=None,\n",
      "                    max_features='log2', max_leaf_nodes=None,\n",
      "                    min_impurity_decrease=0.0, min_impurity_split=None,\n",
      "                    min_samples_leaf=1, min_samples_split=2,\n",
      "                    min_weight_fraction_leaf=0.0, n_estimators=5, n_jobs=None,\n",
      "                    oob_score=False, random_state=None, verbose=0,\n",
      "                    warm_start=False), 'learning_rate': 0.3, 'loss': 'exponential', 'n_estimators': 50}\n",
      "AdaBoostRegressor run at: 2020-01-25 21:23:44.365112 . Saving to models/DRAGON_VPAS/AdaBoostRegressor_kbest_25_01_2020_21_23_44.joblib\n"
     ]
    }
   ],
   "source": [
    "ada_freg = train_model(model = AdaBoostRegressor,\n",
    "           feature_set= top_15_features_kbest,\n",
    "            grid_search=False,\n",
    "           hyperparameters=ada_hp)\n",
    "\n",
    "exp_vs_calc_ada_freg = produce_exp_vs_pred_df('top_15_features_kbest', ada_freg,\n",
    "                                               \"AdaBoost, freg features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutual info features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:24:58.730636Z",
     "start_time": "2020-01-25T21:23:44.541586Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'base_estimator': ExtraTreesRegressor(bootstrap=False, criterion='mse', max_depth=None,\n",
      "                    max_features='log2', max_leaf_nodes=None,\n",
      "                    min_impurity_decrease=0.0, min_impurity_split=None,\n",
      "                    min_samples_leaf=1, min_samples_split=2,\n",
      "                    min_weight_fraction_leaf=0.0, n_estimators=5, n_jobs=None,\n",
      "                    oob_score=False, random_state=None, verbose=0,\n",
      "                    warm_start=False), 'learning_rate': 0.3, 'loss': 'exponential', 'n_estimators': 50}\n",
      "AdaBoostRegressor run at: 2020-01-25 21:24:58.570459 . Saving to models/DRAGON_VPAS/AdaBoostRegressor_mutual_info_25_01_2020_21_24_58.joblib\n"
     ]
    }
   ],
   "source": [
    "ada_mu = train_model(model = AdaBoostRegressor,\n",
    "           feature_set= top_15_features_mutual_info,\n",
    "            grid_search=False,\n",
    "           hyperparameters=ada_hp)\n",
    "\n",
    "exp_vs_calc_ada_mu = produce_exp_vs_pred_df('top_15_features_mutual_info', ada_mu,\n",
    "                                               \"AdaBoost, mutual info features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LASSO features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:26:14.475020Z",
     "start_time": "2020-01-25T21:24:58.733641Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'base_estimator': ExtraTreesRegressor(bootstrap=False, criterion='mse', max_depth=None,\n",
      "                    max_features='log2', max_leaf_nodes=None,\n",
      "                    min_impurity_decrease=0.0, min_impurity_split=None,\n",
      "                    min_samples_leaf=1, min_samples_split=2,\n",
      "                    min_weight_fraction_leaf=0.0, n_estimators=5, n_jobs=None,\n",
      "                    oob_score=False, random_state=None, verbose=0,\n",
      "                    warm_start=False), 'learning_rate': 0.3, 'loss': 'exponential', 'n_estimators': 50}\n",
      "AdaBoostRegressor run at: 2020-01-25 21:26:14.306601 . Saving to models/DRAGON_VPAS/AdaBoostRegressor_lasso_25_01_2020_21_26_14.joblib\n"
     ]
    }
   ],
   "source": [
    "ada_lasso = train_model(model = AdaBoostRegressor,\n",
    "           feature_set= top_15_features_lasso,\n",
    "            grid_search=False,\n",
    "           hyperparameters=ada_hp)\n",
    "\n",
    "exp_vs_calc_ada_lasso = produce_exp_vs_pred_df('top_15_features_lasso', ada_lasso,\n",
    "                                               \"AdaBoost, model features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LASSO\n",
    "### Model Chosen Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:26:14.486049Z",
     "start_time": "2020-01-25T21:26:14.481037Z"
    }
   },
   "outputs": [],
   "source": [
    "lasso_param_grid = {\n",
    "    'alpha':[0.2, 0.4, 0.6, 0.8],\n",
    "    'max_iter':[1000, 5000, 10000, 50000],\n",
    "    'selection':['cyclic', 'random']\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:26:27.698150Z",
     "start_time": "2020-01-25T21:26:14.489058Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lasso grid search.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_split.py:1978: FutureWarning: The default value of cv will change from 3 to 5 in version 0.22. Specify it explicitly to silence this warning.\n",
      "  warnings.warn(CV_WARNING, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alpha': 0.2, 'max_iter': 10000, 'selection': 'random'}\n",
      "Grid search complete!\n",
      "Hyperparameters:\n",
      " {'alpha': 0.2, 'max_iter': 10000, 'selection': 'random'}\n",
      "Lasso run at: 2020-01-25 21:26:27.687155 . Saving to models/DRAGON_VPAS/Lasso_model_25_01_2020_21_26_27.joblib\n"
     ]
    }
   ],
   "source": [
    "lasso_model, lasso_hp = train_model(model = Lasso,\n",
    "           feature_set= top_15_features_model,\n",
    "            grid_search=True,\n",
    "           hyperparameters=lasso_param_grid)\n",
    "\n",
    "\n",
    "exp_vs_calc_lasso_model = produce_exp_vs_pred_df('top_15_features_model', lasso_model,\n",
    "                                                 \"LASSO, model features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### F-regression features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:26:30.848454Z",
     "start_time": "2020-01-25T21:26:27.701158Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'alpha': 0.2, 'max_iter': 10000, 'selection': 'random'}\n",
      "Lasso run at: 2020-01-25 21:26:30.838423 . Saving to models/DRAGON_VPAS/Lasso_kbest_25_01_2020_21_26_30.joblib\n"
     ]
    }
   ],
   "source": [
    "lasso_freg = train_model(model = Lasso,\n",
    "           feature_set= top_15_features_kbest,\n",
    "            grid_search=False,\n",
    "           hyperparameters=lasso_hp)\n",
    "\n",
    "exp_vs_calc_lasso_freg = produce_exp_vs_pred_df('top_15_features_kbest', lasso_freg,\n",
    "                                                 \"LASSO, f-reg features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutual info features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:26:34.014873Z",
     "start_time": "2020-01-25T21:26:30.851461Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'alpha': 0.2, 'max_iter': 10000, 'selection': 'random'}\n",
      "Lasso run at: 2020-01-25 21:26:34.003874 . Saving to models/DRAGON_VPAS/Lasso_mutual_info_25_01_2020_21_26_34.joblib\n"
     ]
    }
   ],
   "source": [
    "lasso_mu = train_model(model = Lasso,\n",
    "           feature_set= top_15_features_mutual_info,\n",
    "            grid_search=False,\n",
    "           hyperparameters=lasso_hp)\n",
    "\n",
    "exp_vs_calc_lasso_mu = produce_exp_vs_pred_df('top_15_features_mutual_info', lasso_mu,\n",
    "                                                 \"LASSO, mutual info features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LASSO Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:26:37.181292Z",
     "start_time": "2020-01-25T21:26:34.017881Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'alpha': 0.2, 'max_iter': 10000, 'selection': 'random'}\n",
      "Lasso run at: 2020-01-25 21:26:37.172283 . Saving to models/DRAGON_VPAS/Lasso_lasso_25_01_2020_21_26_37.joblib\n"
     ]
    }
   ],
   "source": [
    "lasso_lasso = train_model(model = Lasso,\n",
    "           feature_set= top_15_features_lasso,\n",
    "            grid_search=False,\n",
    "           hyperparameters=lasso_hp)\n",
    "\n",
    "exp_vs_calc_lasso_lasso = produce_exp_vs_pred_df('top_15_features_lasso', lasso_lasso,\n",
    "                                                 \"LASSO, lasso features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Forest Regressor\n",
    "### Model Chosen Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T21:26:37.193322Z",
     "start_time": "2020-01-25T21:26:37.184300Z"
    }
   },
   "outputs": [],
   "source": [
    "random_forest_param_grid = {\n",
    "    'max_depth': [10, 20, 30, 40, 50, 60, 70, 80, 90, None],\n",
    "    'max_features': ['auto', 'sqrt'],\n",
    "    'min_samples_leaf': [1, 2, 4],\n",
    "    'min_samples_split': [2, 5, 10],\n",
    "    'n_estimators': [200, 400, 600, 800, 1000, 1200, 1400, 1600]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:31:36.312167Z",
     "start_time": "2020-01-25T21:26:37.197333Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RandomForestRegressor grid search.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_split.py:1978: FutureWarning: The default value of cv will change from 3 to 5 in version 0.22. Specify it explicitly to silence this warning.\n",
      "  warnings.warn(CV_WARNING, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'max_depth': 20, 'max_features': 'sqrt', 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}\n",
      "Grid search complete!\n",
      "Hyperparameters:\n",
      " {'max_depth': 20, 'max_features': 'sqrt', 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}\n",
      "RandomForestRegressor run at: 2020-01-25 23:31:36.194850 . Saving to models/DRAGON_VPAS/RandomForestRegressor_model_25_01_2020_23_31_36.joblib\n"
     ]
    }
   ],
   "source": [
    "random_forest_model, rfr_hp = train_model(model = RandomForestRegressor,\n",
    "           feature_set= top_15_features_model,\n",
    "            grid_search=True,\n",
    "           hyperparameters=random_forest_param_grid)\n",
    "exp_vs_calc_random_forest_model = produce_exp_vs_pred_df('top_15_features_model', random_forest_model,\n",
    "                                                         \"RandomForest, model features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### F-regression features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:32:09.965643Z",
     "start_time": "2020-01-25T23:31:36.318181Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'max_depth': 20, 'max_features': 'sqrt', 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}\n",
      "RandomForestRegressor run at: 2020-01-25 23:32:09.853344 . Saving to models/DRAGON_VPAS/RandomForestRegressor_kbest_25_01_2020_23_32_09.joblib\n"
     ]
    }
   ],
   "source": [
    "random_forest_freg = train_model(model = RandomForestRegressor,\n",
    "           feature_set= top_15_features_kbest,\n",
    "            grid_search=False,\n",
    "           hyperparameters=rfr_hp)\n",
    "exp_vs_calc_random_forest_freg = produce_exp_vs_pred_df('top_15_features_kbest', random_forest_freg,\n",
    "                                                         \"RandomForest, freg features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutual info features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:32:43.924932Z",
     "start_time": "2020-01-25T23:32:09.968650Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'max_depth': 20, 'max_features': 'sqrt', 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}\n",
      "RandomForestRegressor run at: 2020-01-25 23:32:43.811659 . Saving to models/DRAGON_VPAS/RandomForestRegressor_mutual_info_25_01_2020_23_32_43.joblib\n"
     ]
    }
   ],
   "source": [
    "random_forest_mu = train_model(model = RandomForestRegressor,\n",
    "           feature_set= top_15_features_mutual_info,\n",
    "            grid_search=False,\n",
    "           hyperparameters=rfr_hp)\n",
    "exp_vs_calc_random_forest_mu = produce_exp_vs_pred_df('top_15_features_mutual_info', random_forest_mu,\n",
    "                                                         \"RandomForest, mutual info features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LASSO features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:33:17.913299Z",
     "start_time": "2020-01-25T23:32:43.927939Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'max_depth': 20, 'max_features': 'sqrt', 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}\n",
      "RandomForestRegressor run at: 2020-01-25 23:33:17.790972 . Saving to models/DRAGON_VPAS/RandomForestRegressor_lasso_25_01_2020_23_33_17.joblib\n"
     ]
    }
   ],
   "source": [
    "random_forest_lasso = train_model(model = RandomForestRegressor,\n",
    "           feature_set= top_15_features_lasso,\n",
    "            grid_search=False,\n",
    "           hyperparameters=rfr_hp)\n",
    "exp_vs_calc_random_forest_lasso = produce_exp_vs_pred_df('top_15_features_lasso', random_forest_lasso,\n",
    "                                                         \"RandomForest, lasso features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LARS - Least angle regression\n",
    "### Model chosen features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:33:17.923324Z",
     "start_time": "2020-01-25T23:33:17.919314Z"
    }
   },
   "outputs": [],
   "source": [
    "lars_param_grid = {'n_nonzero_coefs': [0, 5, 10, 15]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:33:30.505360Z",
     "start_time": "2020-01-25T23:33:17.927335Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lars grid search.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_split.py:1978: FutureWarning: The default value of cv will change from 3 to 5 in version 0.22. Specify it explicitly to silence this warning.\n",
      "  warnings.warn(CV_WARNING, FutureWarning)\n",
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_search.py:814: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal.\n",
      "  DeprecationWarning)\n",
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:578: ConvergenceWarning: Regressors in active set degenerate. Dropping a regressor, after 5 iterations, i.e. alpha=3.438e-02, with an active set of 5 regressors, and the smallest cholesky pivot element being 1.054e-08. Reduce max_iter or increase eps parameters.\n",
      "  ConvergenceWarning)\n",
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:578: ConvergenceWarning: Regressors in active set degenerate. Dropping a regressor, after 6 iterations, i.e. alpha=3.311e-02, with an active set of 6 regressors, and the smallest cholesky pivot element being 1.054e-08. Reduce max_iter or increase eps parameters.\n",
      "  ConvergenceWarning)\n",
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:578: ConvergenceWarning: Regressors in active set degenerate. Dropping a regressor, after 8 iterations, i.e. alpha=1.694e-02, with an active set of 8 regressors, and the smallest cholesky pivot element being 1.054e-08. Reduce max_iter or increase eps parameters.\n",
      "  ConvergenceWarning)\n",
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:578: ConvergenceWarning: Regressors in active set degenerate. Dropping a regressor, after 5 iterations, i.e. alpha=3.438e-02, with an active set of 5 regressors, and the smallest cholesky pivot element being 1.054e-08. Reduce max_iter or increase eps parameters.\n",
      "  ConvergenceWarning)\n",
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:578: ConvergenceWarning: Regressors in active set degenerate. Dropping a regressor, after 6 iterations, i.e. alpha=3.311e-02, with an active set of 6 regressors, and the smallest cholesky pivot element being 1.054e-08. Reduce max_iter or increase eps parameters.\n",
      "  ConvergenceWarning)\n",
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:578: ConvergenceWarning: Regressors in active set degenerate. Dropping a regressor, after 8 iterations, i.e. alpha=1.694e-02, with an active set of 8 regressors, and the smallest cholesky pivot element being 1.054e-08. Reduce max_iter or increase eps parameters.\n",
      "  ConvergenceWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'n_nonzero_coefs': 10}\n",
      "Grid search complete!\n",
      "Hyperparameters:\n",
      " {'n_nonzero_coefs': 10}\n",
      "Lars run at: 2020-01-25 23:33:30.499378 . Saving to models/DRAGON_VPAS/Lars_model_25_01_2020_23_33_30.joblib\n"
     ]
    }
   ],
   "source": [
    "lars_model, lars_hp = train_model(model = Lars,\n",
    "           feature_set= top_15_features_model,\n",
    "            grid_search=True,\n",
    "           hyperparameters= lars_param_grid)\n",
    "exp_vs_calc_lars_model = produce_exp_vs_pred_df('top_15_features_model', lars_model, \"LARS model features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### F-regression features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:33:33.611626Z",
     "start_time": "2020-01-25T23:33:30.507364Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'n_nonzero_coefs': 10}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:578: ConvergenceWarning: Regressors in active set degenerate. Dropping a regressor, after 6 iterations, i.e. alpha=4.507e-03, with an active set of 6 regressors, and the smallest cholesky pivot element being 2.220e-16. Reduce max_iter or increase eps parameters.\n",
      "  ConvergenceWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lars run at: 2020-01-25 23:33:33.604632 . Saving to models/DRAGON_VPAS/Lars_kbest_25_01_2020_23_33_33.joblib\n"
     ]
    }
   ],
   "source": [
    "lars_freg = train_model(model = Lars,\n",
    "           feature_set= top_15_features_kbest,\n",
    "            grid_search=False,\n",
    "           hyperparameters= lars_hp)\n",
    "exp_vs_calc_lars_freg = produce_exp_vs_pred_df('top_15_features_kbest', lars_freg, \"LARS freg features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutual info features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:33:36.632651Z",
     "start_time": "2020-01-25T23:33:33.617633Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'n_nonzero_coefs': 10}\n",
      "Lars run at: 2020-01-25 23:33:36.621620 . Saving to models/DRAGON_VPAS/Lars_mutual_info_25_01_2020_23_33_36.joblib\n"
     ]
    }
   ],
   "source": [
    "lars_mu = train_model(model = Lars,\n",
    "           feature_set= top_15_features_mutual_info,\n",
    "            grid_search=False,\n",
    "           hyperparameters= lars_hp)\n",
    "\n",
    "exp_vs_calc_lars_mu = produce_exp_vs_pred_df('top_15_features_mutual_info', lars_mu, \"LARS mutual info features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LASSO features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:33:39.688762Z",
     "start_time": "2020-01-25T23:33:36.635657Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'n_nonzero_coefs': 10}\n",
      "Lars run at: 2020-01-25 23:33:39.682743 . Saving to models/DRAGON_VPAS/Lars_lasso_25_01_2020_23_33_39.joblib\n"
     ]
    }
   ],
   "source": [
    "lars_lasso = train_model(model = Lars,\n",
    "           feature_set= top_15_features_lasso,\n",
    "            grid_search=False,\n",
    "           hyperparameters= lars_hp)\n",
    "exp_vs_calc_lars_lasso = produce_exp_vs_pred_df('top_15_features_lasso', lars_lasso, \"LARS lasso features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Elastic Net (linear regression l1 l2 norm regularization)\n",
    "### Model chosen features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:33:39.700795Z",
     "start_time": "2020-01-25T23:33:39.691770Z"
    }
   },
   "outputs": [],
   "source": [
    "net_param_grid = {\n",
    "    'alpha':[0.1, 0.3, 0.5, 0.8, 1.0],\n",
    "    'l1_ratio':[0.0, 0.2, 0.4, 0.6, 0.8, 1.0],\n",
    "    'fit_intercept':[True, False],\n",
    "    'max_iter': [1000, 3000, 5000],\n",
    "    'tol':[0.0001, 0.001, 0.01],\n",
    "    'selection':['cyclic', 'random']\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:34:22.569135Z",
     "start_time": "2020-01-25T23:33:39.703802Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ElasticNet grid search.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_split.py:1978: FutureWarning: The default value of cv will change from 3 to 5 in version 0.22. Specify it explicitly to silence this warning.\n",
      "  warnings.warn(CV_WARNING, FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alpha': 0.1, 'fit_intercept': True, 'l1_ratio': 1.0, 'max_iter': 5000, 'selection': 'random', 'tol': 0.001}\n",
      "Grid search complete!\n",
      "Hyperparameters:\n",
      " {'alpha': 0.1, 'fit_intercept': True, 'l1_ratio': 1.0, 'max_iter': 5000, 'selection': 'random', 'tol': 0.001}\n",
      "ElasticNet run at: 2020-01-25 23:34:22.562148 . Saving to models/DRAGON_VPAS/ElasticNet_model_25_01_2020_23_34_22.joblib\n"
     ]
    }
   ],
   "source": [
    "net_model, net_hp = train_model(model = ElasticNet,\n",
    "           feature_set= top_15_features_model,\n",
    "            grid_search=True,\n",
    "           hyperparameters= net_param_grid)\n",
    "exp_vs_calc_net_model = produce_exp_vs_pred_df('top_15_features_model', net_model, \"ElasticNet model features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### F regression features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:34:25.834819Z",
     "start_time": "2020-01-25T23:34:22.575152Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'alpha': 0.1, 'fit_intercept': True, 'l1_ratio': 1.0, 'max_iter': 5000, 'selection': 'random', 'tol': 0.001}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\coordinate_descent.py:475: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Duality gap: 454.6366127367655, tolerance: 78.48553524875527\n",
      "  positive)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ElasticNet run at: 2020-01-25 23:34:25.828801 . Saving to models/DRAGON_VPAS/ElasticNet_kbest_25_01_2020_23_34_25.joblib\n"
     ]
    }
   ],
   "source": [
    "net_freg = train_model(model = ElasticNet,\n",
    "           feature_set= top_15_features_kbest,\n",
    "            grid_search=False,\n",
    "           hyperparameters= net_hp)\n",
    "exp_vs_calc_net_freg = produce_exp_vs_pred_df('top_15_features_kbest', net_freg, \"ElasticNet freg features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutual info features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:34:29.016277Z",
     "start_time": "2020-01-25T23:34:25.841838Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'alpha': 0.1, 'fit_intercept': True, 'l1_ratio': 1.0, 'max_iter': 5000, 'selection': 'random', 'tol': 0.001}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jtd1g16\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\coordinate_descent.py:475: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Duality gap: 264.93895034046, tolerance: 78.48553524875527\n",
      "  positive)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ElasticNet run at: 2020-01-25 23:34:29.010295 . Saving to models/DRAGON_VPAS/ElasticNet_mutual_info_25_01_2020_23_34_29.joblib\n"
     ]
    }
   ],
   "source": [
    "net_mu = train_model(model = ElasticNet,\n",
    "           feature_set= top_15_features_mutual_info,\n",
    "            grid_search=False,\n",
    "           hyperparameters= net_hp)\n",
    "exp_vs_calc_net_mu = produce_exp_vs_pred_df('top_15_features_mutual_info', net_mu, \"ElasticNet mutual info features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LASSO features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-25T23:34:32.156997Z",
     "start_time": "2020-01-25T23:34:29.020288Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No grid search\n",
      "Hyperparameters:\n",
      " {'alpha': 0.1, 'fit_intercept': True, 'l1_ratio': 1.0, 'max_iter': 5000, 'selection': 'random', 'tol': 0.001}\n",
      "ElasticNet run at: 2020-01-25 23:34:32.146968 . Saving to models/DRAGON_VPAS/ElasticNet_lasso_25_01_2020_23_34_32.joblib\n"
     ]
    }
   ],
   "source": [
    "net_lasso = train_model(model = ElasticNet,\n",
    "           feature_set= top_15_features_lasso,\n",
    "            grid_search=False,\n",
    "           hyperparameters= net_hp)\n",
    "exp_vs_calc_net_lasso = produce_exp_vs_pred_df('top_15_features_lasso', net_lasso, \"ElasticNet lasso features\")"
   ]
  }
 ],
 "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"
  },
  "notify_time": "30",
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "303.516px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}