wip_kaggle_feature-selection-model-interpretation-and-more.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## General information\n",
    "\n",
    "In this kernel I'll try various technics for models interpretability and feature selection. Also I'll compare various models.\n",
    "I use the features from my dataset: https://www.kaggle.com/artgor/lanl-features\n",
    "This dataset was created using this kernel: https://www.kaggle.com/artgor/even-more-features/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_kg_hide-input": true,
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import gc\n",
    "import eli5\n",
    "import shap\n",
    "import time\n",
    "import json\n",
    "import builtins\n",
    "import datetime\n",
    "import warnings\n",
    "import librosa, librosa.display\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import altair as alt\n",
    "import xgboost as xgb\n",
    "import seaborn as sns\n",
    "import lightgbm as lgb\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from tqdm import tqdm_notebook\n",
    "from catboost import CatBoostRegressor\n",
    "from sklearn import svm, neighbors, linear_model\n",
    "from sklearn.preprocessing import LabelEncoder, StandardScaler\n",
    "from sklearn.svm import NuSVR, SVR\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "from sklearn.model_selection import train_test_split, KFold, cross_val_score, StratifiedKFold, GridSearchCV\n",
    "from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor, AdaBoostRegressor\n",
    "from sklearn.feature_selection import GenericUnivariateSelect, SelectPercentile, SelectKBest, f_classif, mutual_info_classif, RFE\n",
    "from sklearn.kernel_ridge import KernelRidge\n",
    "from sklearn.neighbors import NearestNeighbors\n",
    "from scipy import stats\n",
    "from scipy.signal import hilbert, hann, convolve\n",
    "from altair.vega import v3\n",
    "from IPython.display import HTML\n",
    "\n",
    "from features import gpi_new, gpii_new, gpiii_new\n",
    "\n",
    "#Configure the environment\n",
    "%matplotlib inline\n",
    "pd.options.display.precision = 15\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "importing and setting up altair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "_kg_hide-input": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "requirejs.config({\n",
       "    baseUrl: 'https://cdn.jsdelivr.net/npm/',\n",
       "    paths: {\"vega\": \"https://cdn.jsdelivr.net/npm/vega@v3.3.1?noext\", \"vega-lib\": \"https://cdn.jsdelivr.net/npm/vega-lib?noext\", \"vega-lite\": \"https://cdn.jsdelivr.net/npm/vega-lite@v3.2.1?noext\", \"vega-embed\": \"https://cdn.jsdelivr.net/npm/vega-embed@3?noext\"}\n",
       "});\n",
       "</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Preparing altair. I use code from this great kernel: https://www.kaggle.com/notslush/altair-visualization-2018-stackoverflow-survey\n",
    "\n",
    "vega_url = 'https://cdn.jsdelivr.net/npm/vega@' + v3.SCHEMA_VERSION\n",
    "vega_lib_url = 'https://cdn.jsdelivr.net/npm/vega-lib'\n",
    "vega_lite_url = 'https://cdn.jsdelivr.net/npm/vega-lite@' + alt.SCHEMA_VERSION\n",
    "vega_embed_url = 'https://cdn.jsdelivr.net/npm/vega-embed@3'\n",
    "noext = \"?noext\"\n",
    "\n",
    "paths = {\n",
    "    'vega': vega_url + noext,\n",
    "    'vega-lib': vega_lib_url + noext,\n",
    "    'vega-lite': vega_lite_url + noext,\n",
    "    'vega-embed': vega_embed_url + noext\n",
    "}\n",
    "\n",
    "workaround = \"\"\"\n",
    "requirejs.config({{\n",
    "    baseUrl: 'https://cdn.jsdelivr.net/npm/',\n",
    "    paths: {}\n",
    "}});\n",
    "\"\"\"\n",
    "\n",
    "#------------------------------------------------ Defs for future rendering\n",
    "def add_autoincrement(render_func):\n",
    "    # Keep track of unique <div/> IDs\n",
    "    cache = {}\n",
    "    def wrapped(chart, id=\"vega-chart\", autoincrement=True):\n",
    "        if autoincrement:\n",
    "            if id in cache:\n",
    "                counter = 1 + cache[id]\n",
    "                cache[id] = counter\n",
    "            else:\n",
    "                cache[id] = 0\n",
    "            actual_id = id if cache[id] == 0 else id + '-' + str(cache[id])\n",
    "        else:\n",
    "            if id not in cache:\n",
    "                cache[id] = 0\n",
    "            actual_id = id\n",
    "        return render_func(chart, id=actual_id)\n",
    "    # Cache will stay outside and \n",
    "    return wrapped\n",
    "            \n",
    "@add_autoincrement\n",
    "def render(chart, id=\"vega-chart\"):\n",
    "    chart_str = \"\"\"\n",
    "    <div id=\"{id}\"></div><script>\n",
    "    require([\"vega-embed\"], function(vg_embed) {{\n",
    "        const spec = {chart};     \n",
    "        vg_embed(\"#{id}\", spec, {{defaultStyle: true}}).catch(console.warn);\n",
    "        console.log(\"anything?\");\n",
    "    }});\n",
    "    console.log(\"really...anything?\");\n",
    "    </script>\n",
    "    \"\"\"\n",
    "    return HTML(\n",
    "        chart_str.format(\n",
    "            id=id,\n",
    "            chart=json.dumps(chart) if isinstance(chart, dict) else chart.to_json(indent=None)\n",
    "        )\n",
    "    )\n",
    "\n",
    "HTML(\"\".join((\n",
    "    \"<script>\",\n",
    "    workaround.format(json.dumps(paths)),\n",
    "    \"</script>\",\n",
    ")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "['test_features_denoised.csv', 'train_features.csv', 'test_features.csv', 'submission_1.csv', 'y.csv', 'train_features_denoised.csv']"
      ],
      "text/plain": [
       "['test_features_denoised.csv',\n",
       " 'train_features.csv',\n",
       " 'test_features.csv',\n",
       " 'submission_1.csv',\n",
       " 'y.csv',\n",
       " 'train_features_denoised.csv']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir('../input/lanl-features')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 'train_features.csv' - train features generated on original data\n",
    "* 'train_features_denoised.csv' - train features generated on denoised data\n",
    "* 'test_features.csv' - test features generated on original data\n",
    "* 'test_features_denoised.csv' - test features generated on denoised data\n",
    "* 'submission_1.csv' - one of my local submissions\n",
    "* 'y.csv' - train target"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading data\n",
    "Let's load features!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_features = pd.read_csv('../input/lanl-features/train_features.csv')\n",
    "test_features = pd.read_csv('../input/lanl-features/test_features.csv')\n",
    "train_features_denoised = pd.read_csv('../input/lanl-features/train_features_denoised.csv')\n",
    "test_features_denoised = pd.read_csv('../input/lanl-features/test_features_denoised.csv')\n",
    "train_features_denoised.columns = [f'{i}_denoised' for i in train_features_denoised.columns]\n",
    "test_features_denoised.columns = [f'{i}_denoised' for i in test_features_denoised.columns]\n",
    "y = pd.read_csv('../input/lanl-features/y.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = pd.concat([train_features, train_features_denoised], axis=1).drop(['seg_id_denoised', 'target_denoised'], axis=1)\n",
    "X_test = pd.concat([test_features, test_features_denoised], axis=1).drop(['seg_id_denoised', 'target_denoised'], axis=1)\n",
    "X = X[:-1]\n",
    "y = y[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have almost 2000 features here!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_fold = 5\n",
    "folds = KFold(n_splits=n_fold, shuffle=True, random_state=11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training function\n",
    "\n",
    "Training function is in the hidden cell below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "_kg_hide-input": true
   },
   "outputs": [],
   "source": [
    "def train_model(X, X_test, y, params, folds, model_type='lgb',\n",
    "                model=None, show_scatter=False, plot_feature_importance=False):\n",
    "\n",
    "    oof = np.zeros(len(X))\n",
    "    prediction = np.zeros(len(X_test))\n",
    "    scores = []\n",
    "    feature_importance = pd.DataFrame()\n",
    "    for fold_n, (train_index, valid_index) in enumerate(folds.split(X)):\n",
    "        print('Fold', fold_n, 'started at', time.ctime())\n",
    "        if type(X) == np.ndarray:\n",
    "            X_train, X_valid = X[train_index], X[valid_index]\n",
    "            y_train, y_valid = y[train_index], y[valid_index]\n",
    "        else:\n",
    "            X_train, X_valid = X.iloc[train_index], X.iloc[valid_index]\n",
    "            y_train, y_valid = y.iloc[train_index], y.iloc[valid_index]\n",
    "            \n",
    "        if model_type == 'lgb':\n",
    "            model = lgb.LGBMRegressor(**params, n_estimators = 50000, n_jobs = -1)\n",
    "            model.fit(X_train, y_train, \n",
    "                      eval_set=[(X_train, y_train), (X_valid, y_valid)],\n",
    "                      eval_metric='mae',\n",
    "                      verbose=10000,\n",
    "                      early_stopping_rounds=200)\n",
    "            \n",
    "            y_pred_valid = model.predict(X_valid)\n",
    "            y_pred = model.predict(X_test, num_iteration=model.best_iteration_)\n",
    "            \n",
    "        if model_type == 'xgb':\n",
    "            train_data = xgb.DMatrix(data=X_train, label=y_train, feature_names=X.columns)\n",
    "            valid_data = xgb.DMatrix(data=X_valid, label=y_valid, feature_names=X.columns)\n",
    "\n",
    "            watchlist = [(train_data, 'train'), (valid_data, 'valid_data')]\n",
    "            model = xgb.train(dtrain=train_data,\n",
    "                              num_boost_round=20000,\n",
    "                              evals=watchlist,\n",
    "                              early_stopping_rounds=200,\n",
    "                              verbose_eval=500,\n",
    "                              params=params)\n",
    "            \n",
    "            y_pred_valid = model.predict(xgb.DMatrix(X_valid, feature_names=X.columns),\n",
    "                                         ntree_limit=model.best_ntree_limit)\n",
    "            y_pred = model.predict(xgb.DMatrix(X_test, feature_names=X.columns),\n",
    "                                   ntree_limit=model.best_ntree_limit)\n",
    "        \n",
    "        if model_type == 'sklearn':\n",
    "            model = model\n",
    "            model.fit(X_train, y_train)            \n",
    "            y_pred_valid = model.predict(X_valid).reshape(-1,)\n",
    "            score = mean_absolute_error(y_valid, y_pred_valid)\n",
    "            y_pred = model.predict(X_test).reshape(-1,)\n",
    "            print(f'Fold {fold_n}. MAE: {score:.4f}.')\n",
    "            print('')\n",
    "            \n",
    "        if model_type == 'cat':\n",
    "            model = CatBoostRegressor(iterations=20000,  eval_metric='MAE', task_type='GPU', loss_function='MAE', **params)\n",
    "            model.fit(X_train,\n",
    "                      y_train,\n",
    "                      eval_set=(X_valid, y_valid),\n",
    "                      cat_features=[],\n",
    "                      use_best_model=True,\n",
    "                      verbose=False)\n",
    "\n",
    "            y_pred_valid = model.predict(X_valid)\n",
    "            y_pred = model.predict(X_test)\n",
    "        \n",
    "        if model_type == 'gpi_new':\n",
    "            y_pred_valid = gpi_new(X_valid, activation=params['activation']).values\n",
    "            y_pred = gpi_new(X_test, activation=params['activation']).values\n",
    "            \n",
    "        if model_type == 'gpii_new':\n",
    "            y_pred_valid = gpii_new(X_valid, activation=params['activation']).values\n",
    "            y_pred = gpii_new(X_test, activation=params['activation']).values\n",
    "            \n",
    "        if model_type == 'gpiii_new':\n",
    "            y_pred_valid = gpiii_new(X_valid, activation=params['activation']).values\n",
    "            y_pred = gpiii_new(X_test, activation=params['activation']).values\n",
    "            \n",
    "        oof[valid_index] = y_pred_valid.reshape(-1,)\n",
    "        scores.append(mean_absolute_error(y_valid, y_pred_valid))\n",
    "\n",
    "        prediction += y_pred    \n",
    "        \n",
    "        if model_type == 'lgb' and plot_feature_importance:\n",
    "            # feature importance\n",
    "            fold_importance = pd.DataFrame()\n",
    "            fold_importance[\"feature\"] = X.columns\n",
    "            fold_importance[\"importance\"] = model.feature_importances_\n",
    "            fold_importance[\"fold\"] = fold_n + 1\n",
    "            feature_importance = pd.concat([feature_importance, fold_importance], axis=0)\n",
    "\n",
    "    prediction /= n_fold\n",
    "    \n",
    "    if show_scatter:\n",
    "        fig, axis = plt.subplots(1, 2, figsize=(12,5))\n",
    "        ax1, ax2 = axis\n",
    "        ax1.set_xlabel('actual')\n",
    "        ax1.set_ylabel('predicted')\n",
    "        ax2.set_xlabel('train index')\n",
    "        ax2.set_ylabel('time to failure')\n",
    "        \n",
    "        ax1.scatter(y, oof, color='brown')\n",
    "        ax1.plot([(0, 0), (20, 20)], [(0, 0), (20, 20)], color='blue')\n",
    "\n",
    "        ax2.plot(y, color='blue', label='y_train')\n",
    "        ax2.plot(oof, color='orange')\n",
    "\n",
    "    print('CV mean score: {0:.4f}, std: {1:.4f}.'.format(np.mean(scores), np.std(scores)))\n",
    "    \n",
    "    if model_type == 'lgb':\n",
    "        if plot_feature_importance:\n",
    "            feature_importance[\"importance\"] /= n_fold\n",
    "            cols = feature_importance[[\"feature\", \"importance\"]].groupby(\"feature\").mean().sort_values(\n",
    "                by=\"importance\", ascending=False)[:50].index\n",
    "\n",
    "            best_features = feature_importance.loc[feature_importance.feature.isin(cols)]\n",
    "\n",
    "            plt.figure(figsize=(16, 12));\n",
    "            sns.barplot(x=\"importance\", y=\"feature\", data=best_features.sort_values(by=\"importance\", ascending=False));\n",
    "            plt.title('LGB Features (avg over folds)');\n",
    "        \n",
    "            return oof, prediction, feature_importance\n",
    "        return oof, prediction, scores\n",
    "    \n",
    "    else:\n",
    "        return oof, prediction, scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold 0 started at Sun May 12 21:02:20 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[664]\ttraining's l1: 1.23868\tvalid_1's l1: 2.09886\n",
      "Fold 1 started at Sun May 12 21:02:26 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[805]\ttraining's l1: 1.13921\tvalid_1's l1: 2.00676\n",
      "Fold 2 started at Sun May 12 21:02:33 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[550]\ttraining's l1: 1.33611\tvalid_1's l1: 2.15575\n",
      "Fold 3 started at Sun May 12 21:02:39 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[451]\ttraining's l1: 1.46945\tvalid_1's l1: 1.94486\n",
      "Fold 4 started at Sun May 12 21:02:44 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[579]\ttraining's l1: 1.32006\tvalid_1's l1: 2.07496\n",
      "CV mean score: 2.0562, std: 0.0734.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "params = {'num_leaves': 128,\n",
    "          'min_child_samples': 79,\n",
    "          'objective': 'gamma',\n",
    "          'max_depth': -1,\n",
    "          'learning_rate': 0.01,\n",
    "          \"boosting_type\": \"gbdt\",\n",
    "          \"subsample_freq\": 5,\n",
    "          \"subsample\": 0.9,\n",
    "          \"bagging_seed\": 11,\n",
    "          \"metric\": 'mae',\n",
    "          \"verbosity\": -1,\n",
    "          'reg_alpha': 0.1302650970728192,\n",
    "          'reg_lambda': 0.3603427518866501,\n",
    "          'colsample_bytree': 0.1\n",
    "}\n",
    "oof_lgb, prediction_lgb, feature_importance = train_model(X,\n",
    "                                                          X_test,\n",
    "                                                          y,\n",
    "                                                          params=params,\n",
    "                                                          folds=folds,\n",
    "                                                          model_type='lgb',\n",
    "                                                          plot_feature_importance=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NN features\n",
    "Here I normalize the data and create features using NearestNeighbors. The idea is to find samples which are similar and use it to generate features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = StandardScaler()\n",
    "scaler.fit(X)\n",
    "\n",
    "#alldata = pd.concat([X,X_test])\n",
    "#scaler = StandardScaler()\n",
    "#alldata[alldata.columns] = scaler.fit_transform(alldata[alldata.columns].astype(float))\n",
    "\n",
    "X_train_scaled = pd.DataFrame(scaler.transform(X), columns=X.columns)\n",
    "X_test_scaled = pd.DataFrame(scaler.transform(X_test), columns=X_test.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 5min 15s, sys: 103 ms, total: 5min 15s\n",
      "Wall time: 10.5 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "n = 10\n",
    "neigh = NearestNeighbors(n, n_jobs=-1)\n",
    "neigh.fit(X_train_scaled)\n",
    "\n",
    "dists, _ = neigh.kneighbors(X_train_scaled, n_neighbors=n)\n",
    "mean_dist = dists.mean(axis=1)\n",
    "max_dist = dists.max(axis=1)\n",
    "min_dist = dists.min(axis=1)\n",
    "\n",
    "X_train_scaled['mean_dist'] = mean_dist\n",
    "X_train_scaled['max_dist'] = max_dist\n",
    "X_train_scaled['min_dist'] = min_dist\n",
    "\n",
    "test_dists, _ = neigh.kneighbors(X_test_scaled, n_neighbors=n)\n",
    "\n",
    "test_mean_dist = test_dists.mean(axis=1)\n",
    "test_max_dist = test_dists.max(axis=1)\n",
    "test_min_dist = test_dists.min(axis=1)\n",
    "\n",
    "X_test_scaled['mean_dist'] = test_mean_dist\n",
    "X_test_scaled['max_dist'] = test_max_dist\n",
    "X_test_scaled['min_dist'] = test_min_dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold 0 started at Sun May 12 21:03:03 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[626]\ttraining's l1: 1.33564\tvalid_1's l1: 2.09692\n",
      "Fold 1 started at Sun May 12 21:03:08 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[983]\ttraining's l1: 1.08657\tvalid_1's l1: 2.00284\n",
      "Fold 2 started at Sun May 12 21:03:14 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[408]\ttraining's l1: 1.5359\tvalid_1's l1: 2.15788\n",
      "Fold 3 started at Sun May 12 21:03:18 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[396]\ttraining's l1: 1.58713\tvalid_1's l1: 1.93662\n",
      "Fold 4 started at Sun May 12 21:03:22 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[294]\ttraining's l1: 1.67626\tvalid_1's l1: 2.07807\n",
      "CV mean score: 2.0545, std: 0.0769.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "params = {'num_leaves': 32,\n",
    "          'min_data_in_leaf': 79,\n",
    "          'objective': 'gamma',\n",
    "          'max_depth': -1,\n",
    "          'learning_rate': 0.01,\n",
    "          \"boosting\": \"gbdt\",\n",
    "          \"bagging_freq\": 5,\n",
    "          \"bagging_fraction\": 0.8126672064208567,\n",
    "          \"bagging_seed\": 11,\n",
    "          \"metric\": 'mae',\n",
    "          \"verbosity\": -1,\n",
    "          'reg_alpha': 0.1302650970728192,\n",
    "          'reg_lambda': 0.3603427518866501,\n",
    "          'feature_fraction': 0.1\n",
    "         }\n",
    "oof_lgb, prediction_lgb, feature_importance = train_model(X_train_scaled,\n",
    "                                                          X_test_scaled,\n",
    "                                                          y,\n",
    "                                                          params=params,\n",
    "                                                          folds=folds,\n",
    "                                                          model_type='lgb',\n",
    "                                                          plot_feature_importance=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model interpretation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ELI5 and permutation importance\n",
    "ELI5 is a package with provides explanations for ML models. It can do this not only for linear models, but also for tree based like Random Forest or lightgbm.\n",
    "\n",
    "**Important notice**: running eli5 on all features takes a lot of time, so I run the cell below in `version 14` and printed the top-50 features. In the following versions I'll use these 50 columns and use eli5 to find top-40 of them so that it takes less time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[952]\ttraining's l1: 1.10149\tvalid_1's l1: 1.9994\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <style>\n",
       "    table.eli5-weights tr:hover {\n",
       "        filter: brightness(85%);\n",
       "    }\n",
       "</style>\n",
       "\n",
       "\n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "        <table class=\"eli5-weights eli5-feature-importances\" style=\"border-collapse: collapse; border: none; margin-top: 0em; table-layout: auto;\">\n",
       "    <thead>\n",
       "    <tr style=\"border: none;\">\n",
       "        <th style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">Weight</th>\n",
       "        <th style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">Feature</th>\n",
       "    </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 80.00%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0323\n",
       "                \n",
       "                    &plusmn; 0.0034\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                num_peaks_10\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 84.61%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0222\n",
       "                \n",
       "                    &plusmn; 0.0018\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                iqr1_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 87.44%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0166\n",
       "                \n",
       "                    &plusmn; 0.0011\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                num_crossing_0_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 87.92%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0157\n",
       "                \n",
       "                    &plusmn; 0.0016\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                percentile_5_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 88.03%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0155\n",
       "                \n",
       "                    &plusmn; 0.0010\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                percentile_roll_std_1\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 89.94%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0121\n",
       "                \n",
       "                    &plusmn; 0.0007\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                min_roll_std_10000\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 89.96%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0121\n",
       "                \n",
       "                    &plusmn; 0.0018\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                abs_percentile_90_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 90.03%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0119\n",
       "                \n",
       "                    &plusmn; 0.0014\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                percentile_95_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 90.34%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0114\n",
       "                \n",
       "                    &plusmn; 0.0008\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                percentile_roll_std_20\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 90.40%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0113\n",
       "                \n",
       "                    &plusmn; 0.0011\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                min_roll_std_100\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 90.55%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0111\n",
       "                \n",
       "                    &plusmn; 0.0011\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                percentile_roll_std_10\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 91.58%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0094\n",
       "                \n",
       "                    &plusmn; 0.0010\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                fftr_percentile_roll_std_80\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 91.65%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0093\n",
       "                \n",
       "                    &plusmn; 0.0015\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                min_roll_std_50\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 91.66%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0093\n",
       "                \n",
       "                    &plusmn; 0.0011\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                ffti_percentile_roll_std_75_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 91.75%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0091\n",
       "                \n",
       "                    &plusmn; 0.0011\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                min_roll_std_500\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 91.89%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0089\n",
       "                \n",
       "                    &plusmn; 0.0006\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                mean_change_rate\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 92.64%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0077\n",
       "                \n",
       "                    &plusmn; 0.0009\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                min_roll_std_1000\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 92.91%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0073\n",
       "                \n",
       "                    &plusmn; 0.0006\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                fftr_percentile_roll_std_75_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 93.33%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0067\n",
       "                \n",
       "                    &plusmn; 0.0003\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                ave_roll_std_10\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 93.37%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0067\n",
       "                \n",
       "                    &plusmn; 0.0006\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                percentile_roll_std_5\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 94.21%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0055\n",
       "                \n",
       "                    &plusmn; 0.0004\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                ffti_percentile_roll_std_80\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 94.35%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0053\n",
       "                \n",
       "                    &plusmn; 0.0003\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                ave_roll_std_50\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 94.72%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0048\n",
       "                \n",
       "                    &plusmn; 0.0003\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                percentile_roll_std_25\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 95.01%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0044\n",
       "                \n",
       "                    &plusmn; 0.0009\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                classic_sta_lta6_mean_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 95.06%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0044\n",
       "                \n",
       "                    &plusmn; 0.0005\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                range_0_1000\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 95.10%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0043\n",
       "                \n",
       "                    &plusmn; 0.0006\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                range_-1000_0\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 95.16%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0043\n",
       "                \n",
       "                    &plusmn; 0.0004\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                percentile_roll_std_10_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 95.24%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0041\n",
       "                \n",
       "                    &plusmn; 0.0005\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                autocorrelation_5\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 95.55%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0038\n",
       "                \n",
       "                    &plusmn; 0.0002\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                ffti_percentile_roll_std_70_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 95.57%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0037\n",
       "                \n",
       "                    &plusmn; 0.0005\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                ratio_unique_values_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 95.64%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0037\n",
       "                \n",
       "                    &plusmn; 0.0003\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                percentile_95\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 95.80%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0035\n",
       "                \n",
       "                    &plusmn; 0.0002\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                percentile_roll_std_1_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 95.86%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0034\n",
       "                \n",
       "                    &plusmn; 0.0003\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                mean_change_rate_first_50000\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 95.92%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0033\n",
       "                \n",
       "                    &plusmn; 0.0002\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                percentile_roll_std_30\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.04%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0032\n",
       "                \n",
       "                    &plusmn; 0.0004\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                ffti_c3_500_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.04%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0032\n",
       "                \n",
       "                    &plusmn; 0.0002\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                av_change_rate_roll_std_500_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.21%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0030\n",
       "                \n",
       "                    &plusmn; 0.0004\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                ffti_percentile_roll_std_75\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.35%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0028\n",
       "                \n",
       "                    &plusmn; 0.0002\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                fftr_min_roll_std_500\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.36%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0028\n",
       "                \n",
       "                    &plusmn; 0.0005\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                abs_percentile_90\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.36%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0028\n",
       "                \n",
       "                    &plusmn; 0.0002\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                percentile_roll_std_20_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.50%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0027\n",
       "                \n",
       "                    &plusmn; 0.0002\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                fftr_percentile_roll_std_70_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.52%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0027\n",
       "                \n",
       "                    &plusmn; 0.0002\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                binned_entropy_5_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.81%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0023\n",
       "                \n",
       "                    &plusmn; 0.0002\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                binned_entropy_70_denoised\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.85%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0023\n",
       "                \n",
       "                    &plusmn; 0.0002\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                ffti_spkt_welch_density_10\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.88%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0023\n",
       "                \n",
       "                    &plusmn; 0.0001\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                binned_entropy_5\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.88%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0023\n",
       "                \n",
       "                    &plusmn; 0.0003\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                mean_change_rate_first_10000\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.90%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0022\n",
       "                \n",
       "                    &plusmn; 0.0004\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                mean_change_rate_last_50000\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.91%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0022\n",
       "                \n",
       "                    &plusmn; 0.0002\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                fftr_spkt_welch_density_10\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 96.94%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0022\n",
       "                \n",
       "                    &plusmn; 0.0001\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                num_crossing_0\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "        <tr style=\"background-color: hsl(120, 100.00%, 97.05%); border: none;\">\n",
       "            <td style=\"padding: 0 1em 0 0.5em; text-align: right; border: none;\">\n",
       "                0.0021\n",
       "                \n",
       "                    &plusmn; 0.0003\n",
       "                \n",
       "            </td>\n",
       "            <td style=\"padding: 0 0.5em 0 0.5em; text-align: left; border: none;\">\n",
       "                fftr_percentile_roll_mean_1\n",
       "            </td>\n",
       "        </tr>\n",
       "    \n",
       "    \n",
       "        \n",
       "            <tr style=\"background-color: hsl(120, 100.00%, 97.05%); border: none;\">\n",
       "                <td colspan=\"2\" style=\"padding: 0 0.5em 0 0.5em; text-align: center; border: none; white-space: nowrap;\">\n",
       "                    <i>&hellip; 1908 more &hellip;</i>\n",
       "                </td>\n",
       "            </tr>\n",
       "        \n",
       "    \n",
       "    </tbody>\n",
       "</table>\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "    \n",
       "\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.1)\n",
    "model = lgb.LGBMRegressor(**params, n_estimators = 50000, n_jobs = -1, verbose=-1)\n",
    "model.fit(X_train,\n",
    "          y_train, \n",
    "          eval_set=[(X_train, y_train), (X_valid, y_valid)],\n",
    "          eval_metric='mae',\n",
    "          verbose=10000,\n",
    "          early_stopping_rounds=200)\n",
    "\n",
    "perm = eli5.sklearn.PermutationImportance(model, random_state=1).fit(X_train, y_train)\n",
    "eli5.show_weights(perm, top=50, feature_names=X.columns.values.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#top_columns = ['iqr1_denoised', 'percentile_5_denoised', 'abs_percentile_90_denoised', 'percentile_95_denoised', 'ave_roll_std_10', 'num_peaks_10', 'percentile_roll_std_20',\n",
    "#               'ratio_unique_values_denoised', 'fftr_percentile_roll_std_75_denoised', 'num_crossing_0_denoised', 'percentile_95', 'ffti_percentile_roll_std_75_denoised',\n",
    "#               'min_roll_std_10000', 'percentile_roll_std_1', 'percentile_roll_std_10', 'fftr_percentile_roll_std_70_denoised', 'ave_roll_std_50', 'ffti_percentile_roll_std_70_denoised',\n",
    "#               'exp_Moving_std_300_mean_denoised', 'ffti_percentile_roll_std_30_denoised', 'mean_change_rate', 'percentile_roll_std_5', 'range_-1000_0', 'mad',\n",
    "#               'fftr_range_1000_2000_denoised', 'percentile_10_denoised', 'ffti_percentile_roll_std_80', 'percentile_roll_std_25', 'fftr_percentile_10_denoised',\n",
    "#               'ffti_range_-2000_-1000_denoised', 'autocorrelation_5', 'min_roll_std_100', 'fftr_percentile_roll_std_80', 'min_roll_std_500', 'min_roll_std_50', 'min_roll_std_1000',\n",
    "#               'ffti_percentile_20_denoised', 'iqr1', 'classic_sta_lta5_mean_denoised', 'classic_sta_lta6_mean_denoised', 'percentile_roll_std_10_denoised',\n",
    "#               'fftr_percentile_70_denoised', 'ffti_c3_50_denoised', 'ffti_percentile_roll_std_75', 'abs_percentile_90', 'range_0_1000', 'spkt_welch_density_50_denoised',\n",
    "#               'ffti_percentile_roll_std_40_denoised', 'ffti_range_-4000_-3000', 'mean_change_rate_last_50000']\n",
    "\n",
    "\n",
    "#X_train, X_valid, y_train, y_valid = train_test_split(X[top_columns], y, test_size=0.2)\n",
    "#model = lgb.LGBMRegressor(**params, n_estimators = 50000, n_jobs = -1, verbose=-1)\n",
    "#model.fit(X_train,\n",
    "#          y_train, \n",
    "#          eval_set=[(X_train, y_train), (X_valid, y_valid)],\n",
    "#          eval_metric='mae',\n",
    "#          verbose=10000,\n",
    "#          early_stopping_rounds=200)\n",
    "\n",
    "#perm = eli5.sklearn.PermutationImportance(model, random_state=1).fit(X_train, y_train)\n",
    "#eli5.show_weights(perm, top=50, feature_names=top_columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold 0 started at Sun May 12 21:07:42 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[671]\ttraining's l1: 1.75127\tvalid_1's l1: 2.12822\n",
      "Fold 1 started at Sun May 12 21:07:43 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[656]\ttraining's l1: 1.77016\tvalid_1's l1: 2.04146\n",
      "Fold 2 started at Sun May 12 21:07:44 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[732]\ttraining's l1: 1.72188\tvalid_1's l1: 2.15688\n",
      "Fold 3 started at Sun May 12 21:07:46 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[459]\ttraining's l1: 1.87688\tvalid_1's l1: 1.95902\n",
      "Fold 4 started at Sun May 12 21:07:46 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[335]\ttraining's l1: 1.8994\tvalid_1's l1: 2.11835\n",
      "CV mean score: 2.0808, std: 0.0719.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "top_num_features = 40\n",
    "top_features = [i for i in eli5.formatters.as_dataframe.explain_weights_df(model).feature if 'BIAS' not in i][:top_num_features]\n",
    "oof_lgb, prediction_lgb, feature_importance = train_model(X[top_features],\n",
    "                                                          X_test[top_features],\n",
    "                                                          y,\n",
    "                                                          params=params,\n",
    "                                                          folds=folds,\n",
    "                                                          model_type='lgb',\n",
    "                                                          plot_feature_importance=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature selection\n",
    "\n",
    "Here I try various approaches to feature selection.\n",
    "\n",
    "**Important notice**: running feature selection on all features takes a lot of time, so I'll run some of feature selection methods and print the result, which I'll use in the following versions of the kernel, so that I can explore more approaches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "_kg_hide-output": true
   },
   "outputs": [],
   "source": [
    "params = {'num_leaves': 32,\n",
    "          'min_child_samples': 79,\n",
    "          'objective': 'gamma',\n",
    "          'max_depth': -1,\n",
    "          'learning_rate': 0.01,\n",
    "          \"boosting_type\": \"gbdt\",\n",
    "          \"subsample_freq\": 5,\n",
    "          \"subsample\": 0.9,\n",
    "          \"bagging_seed\": 11,\n",
    "          \"metric\": 'mae',\n",
    "          \"verbosity\": -1,\n",
    "          'reg_alpha': 0.1302650970728192,\n",
    "          'reg_lambda': 0.3603427518866501,\n",
    "          'colsample_bytree': 1.0\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SelectPercentile\n",
    "\n",
    "**Important notice**:  I run the cell below in `version 14` and printed the scores_dict. In the following versions I'll use `scores_dict` and plot the results instead of running feature selection each time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "_kg_hide-output": true,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4e6279729a60417b9c995ee2c2ea75a0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=20), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "Fold 0 started at Sun May 12 21:07:58 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[397]\tvalid_0's l1: 1.65055\tvalid_1's l1: 2.10873\n",
      "Fold 1 started at Sun May 12 21:07:59 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[578]\tvalid_0's l1: 1.53578\tvalid_1's l1: 2.03791\n",
      "Fold 2 started at Sun May 12 21:08:01 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[408]\tvalid_0's l1: 1.63322\tvalid_1's l1: 2.1629\n",
      "Fold 3 started at Sun May 12 21:08:02 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "Early stopping, best iteration is:\n",
      "[311]\tvalid_0's l1: 1.7597\tvalid_1's l1: 1.94313\n",
      "Fold 4 started at Sun May 12 21:08:03 2019\n",
      "Training until validation scores don't improve for 200 rounds.\n",
      "\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-d972f435293c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     10\u001b[0m                                           \u001b[0mparams\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfolds\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfolds\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m                                           \u001b[0mmodel_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'lgb'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m                                           plot_feature_importance=False)\n\u001b[0m\u001b[1;32m     13\u001b[0m     \u001b[0mscores_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'f_classif'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-7-25e2f9663047>\u001b[0m in \u001b[0;36mtrain_model\u001b[0;34m(X, X_test, y, params, folds, model_type, model, show_scatter, plot_feature_importance)\u001b[0m\n\u001b[1;32m     21\u001b[0m                       \u001b[0meval_metric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'mae'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m                       \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10000\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m                       early_stopping_rounds=200)\n\u001b[0m\u001b[1;32m     24\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m             \u001b[0my_pred_valid\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_valid\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/local/user/toolse64/ubuntu/18.04/usr/local/tools/anaconda_2018.12/lib/python3.7/site-packages/lightgbm/sklearn.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, sample_weight, init_score, eval_set, eval_names, eval_sample_weight, eval_init_score, eval_metric, early_stopping_rounds, verbose, feature_name, categorical_feature, callbacks)\u001b[0m\n\u001b[1;32m    640\u001b[0m                                        \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mverbose\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeature_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfeature_name\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    641\u001b[0m                                        \u001b[0mcategorical_feature\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcategorical_feature\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 642\u001b[0;31m                                        callbacks=callbacks)\n\u001b[0m\u001b[1;32m    643\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    644\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/local/user/toolse64/ubuntu/18.04/usr/local/tools/anaconda_2018.12/lib/python3.7/site-packages/lightgbm/sklearn.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, sample_weight, init_score, group, eval_set, eval_names, eval_sample_weight, eval_class_weight, eval_init_score, eval_group, eval_metric, early_stopping_rounds, verbose, feature_name, categorical_feature, callbacks)\u001b[0m\n\u001b[1;32m    500\u001b[0m                               \u001b[0mverbose_eval\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mverbose\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeature_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfeature_name\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    501\u001b[0m                               \u001b[0mcategorical_feature\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcategorical_feature\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 502\u001b[0;31m                               callbacks=callbacks)\n\u001b[0m\u001b[1;32m    503\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    504\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mevals_result\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/local/user/toolse64/ubuntu/18.04/usr/local/tools/anaconda_2018.12/lib/python3.7/site-packages/lightgbm/engine.py\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(params, train_set, num_boost_round, valid_sets, valid_names, fobj, feval, init_model, feature_name, categorical_feature, early_stopping_rounds, evals_result, verbose_eval, learning_rates, keep_training_booster, callbacks)\u001b[0m\n\u001b[1;32m    218\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mis_valid_contain_train\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    219\u001b[0m                 \u001b[0mevaluation_result_list\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbooster\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 220\u001b[0;31m             \u001b[0mevaluation_result_list\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbooster\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval_valid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    221\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    222\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mcb\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mcallbacks_after_iter\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/local/user/toolse64/ubuntu/18.04/usr/local/tools/anaconda_2018.12/lib/python3.7/site-packages/lightgbm/basic.py\u001b[0m in \u001b[0;36meval_valid\u001b[0;34m(self, feval)\u001b[0m\n\u001b[1;32m   1927\u001b[0m             \u001b[0mList\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mevaluation\u001b[0m \u001b[0mresults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1928\u001b[0m         \"\"\"\n\u001b[0;32m-> 1929\u001b[0;31m         return [item for i in range_(1, self.__num_dataset)\n\u001b[0m\u001b[1;32m   1930\u001b[0m                 for item in self.__inner_eval(self.name_valid_sets[i - 1], i, feval)]\n\u001b[1;32m   1931\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/local/user/toolse64/ubuntu/18.04/usr/local/tools/anaconda_2018.12/lib/python3.7/site-packages/lightgbm/basic.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m   1928\u001b[0m         \"\"\"\n\u001b[1;32m   1929\u001b[0m         return [item for i in range_(1, self.__num_dataset)\n\u001b[0;32m-> 1930\u001b[0;31m                 for item in self.__inner_eval(self.name_valid_sets[i - 1], i, feval)]\n\u001b[0m\u001b[1;32m   1931\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1932\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0msave_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfilename\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_iteration\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart_iteration\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/local/user/toolse64/ubuntu/18.04/usr/local/tools/anaconda_2018.12/lib/python3.7/site-packages/lightgbm/basic.py\u001b[0m in \u001b[0;36m__inner_eval\u001b[0;34m(self, data_name, data_idx, feval)\u001b[0m\n\u001b[1;32m   2302\u001b[0m                 \u001b[0mctypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mc_int\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_idx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2303\u001b[0m                 \u001b[0mctypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbyref\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtmp_out_len\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2304\u001b[0;31m                 result.ctypes.data_as(ctypes.POINTER(ctypes.c_double))))\n\u001b[0m\u001b[1;32m   2305\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mtmp_out_len\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__num_inner_eval\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2306\u001b[0m                 \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Wrong length of eval results\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "scores_dict = {'f_classif': [], 'mutual_info_classif': [], 'n_features': []}\n",
    "for i in tqdm_notebook(range(5, 105, 5)):\n",
    "    print(i)\n",
    "    s1 = SelectPercentile(f_classif, percentile=i)\n",
    "    X_train1 = s1.fit_transform(X, y.values.astype(int))\n",
    "    X_test1 = s1.transform(X_test)\n",
    "    oof, prediction, scores = train_model(X_train1,\n",
    "                                          X_test1,\n",
    "                                          y.values.reshape(-1, ),\n",
    "                                          params=params, folds=folds,\n",
    "                                          model_type='lgb',\n",
    "                                          plot_feature_importance=False)\n",
    "    scores_dict['f_classif'].append(np.mean(scores))\n",
    "    \n",
    "    s2 = SelectPercentile(mutual_info_classif, percentile=i)\n",
    "    X_train1 = s2.fit_transform(X, y.values.astype(int))\n",
    "    X_test1 = s2.transform(X_test)\n",
    "    oof, prediction, scores = train_model(X_train1,\n",
    "                                          X_test1,\n",
    "                                          y.values.reshape(-1, ),\n",
    "                                          params=params,\n",
    "                                          folds=folds,\n",
    "                                          model_type='lgb',\n",
    "                                          plot_feature_importance=False)\n",
    "    scores_dict['mutual_info_classif'].append(np.mean(scores))\n",
    "    \n",
    "    scores_dict['n_features'].append(X_train1.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores_dict = {'f_classif': [2.0746468465171377, 2.0753843541953687, 2.062191535440333, 2.0654327826583034, 2.0643551320704936, 2.0617560048382675,\n",
    "                             2.061565197738015, 2.0598878198917494, 2.0654865223333143, 2.0632788555735777, 2.058002635080971, 2.051075689018734,\n",
    "                             2.0472543961304583, 2.052401474353084, 2.055924154798443, 2.0561794619762352, 2.0549680611994963, 2.057123777802326,\n",
    "                             2.0591868861136904, 2.0577745274024553],\n",
    "               'mutual_info_classif': [2.0866763775014006, 2.0745431497064324, 2.0564324832516427, 2.060125564781158, 2.067334544167612, 2.0665943783246448,\n",
    "                                       2.063891669849029, 2.070194051004794, 2.0667490707700447, 2.0681653852378354, 2.0592743636982345, 2.061260741522344,\n",
    "                                       2.05680667824411, 2.0565047875243003, 2.058252567141659, 2.0554927194831922, 2.0562776429736873, 2.0618179277444084,\n",
    "                                       2.06364125584214, 2.0577745274024553],\n",
    "               'n_features': [98, 196, 294, 392, 490, 588, 685, 783, 881, 979, 1077, 1175, 1273, 1370, 1468, 1566, 1664, 1762, 1860, 1958]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores_df = pd.DataFrame(scores_dict)\n",
    "scores_df = scores_df.melt(id_vars=['n_features'],\n",
    "                           value_vars=['mutual_info_classif', 'f_classif'],\n",
    "                           var_name='metric',\n",
    "                           value_name='mae')\n",
    "max_value = scores_df['mae'].max() * 1.05\n",
    "min_value = scores_df['mae'].min() * 0.95\n",
    "render(alt.Chart(scores_df).mark_line().encode(\n",
    "    y=alt.Y('mae:Q', scale=alt.Scale(domain=(min_value, max_value))),\n",
    "    x='n_features:O',\n",
    "    color='metric:N',\n",
    "    tooltip=['metric:N', 'n:O', 'mae:Q']\n",
    ").properties(\n",
    "    title='Top N features by SelectPercentile vs CV'\n",
    ").interactive())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SelectKBest\n",
    "\n",
    "**Important notice**:  I run the cell below in `version 14` and printed the scores_dict. In the following versions I'll use `scores_dict` and plot the results instead of running feature selection each time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_kg_hide-output": true
   },
   "outputs": [],
   "source": [
    "scores_dict = {'f_classif': [], 'mutual_info_classif': [], 'n_features': []}\n",
    "for i in tqdm_notebook(np.arange(10, 1958, 100)):\n",
    "    print(i)\n",
    "    s1 = SelectKBest(f_classif, k=i)\n",
    "    X_train1 = s1.fit_transform(X, y.values.astype(int))\n",
    "    X_test1 = s1.transform(X_test)\n",
    "    oof, prediction, scores = train_model(X_train1,\n",
    "                                          X_test1,\n",
    "                                          y.values.reshape(-1, ),\n",
    "                                          params=params,\n",
    "                                          folds=folds,\n",
    "                                          model_type='lgb',\n",
    "                                          plot_feature_importance=False)\n",
    "    scores_dict['f_classif'].append(np.mean(scores))\n",
    "    \n",
    "    s2 = SelectKBest(mutual_info_classif, k=i)\n",
    "    X_train1 = s2.fit_transform(X, y.values.astype(int))\n",
    "    X_test1 = s2.transform(X_test)\n",
    "    oof, prediction, scores = train_model(X_train1,\n",
    "                                          X_test1,\n",
    "                                          y.values.reshape(-1, ),\n",
    "                                          params=params,\n",
    "                                          folds=folds,\n",
    "                                          model_type='lgb',\n",
    "                                          plot_feature_importance=False)\n",
    "    scores_dict['mutual_info_classif'].append(np.mean(scores))\n",
    "    \n",
    "    scores_dict['n_features'].append(X_train1.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores_dict = {'f_classif': [2.1495892622081354, 2.0778182269587147, 2.0716153738740006, 2.06152950679902, 2.0645162758752553, 2.0627705797004032, 2.0610992303725157,\n",
    "                             2.057762113735462, 2.0618360883613627, 2.0603197111525984, 2.06081274633874, 2.0580767195278056, 2.0527646572747127, 2.0498353445032533,\n",
    "                             2.052442594925, 2.0564456881902133, 2.0582284644115365, 2.0558612960548635, 2.0580900016350094, 2.058218782401599],\n",
    "               'mutual_info_classif': [2.1235703196243687, 2.084958198672301, 2.0596822478390955, 2.053305869981444, 2.063468853227225, 2.0674399950434323, 2.0658618511287874,\n",
    "                                       2.063003703200445, 2.0653174905858664, 2.0644340327023656, 2.0748993062333523, 2.0587602096358113, 2.0601495560836076, 2.0559629138548603,\n",
    "                                       2.0553852701221134, 2.058022171415446, 2.060755947658241, 2.057916705462307, 2.056245795262636, 2.0580691870837056],\n",
    "               'n_features': [10, 110, 210, 310, 410, 510, 610, 710, 810, 910, 1010, 1110, 1210, 1310, 1410, 1510, 1610, 1710, 1810, 1910]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores_df = pd.DataFrame(scores_dict)\n",
    "scores_df = scores_df.melt(id_vars=['n_features'],\n",
    "                           value_vars=['mutual_info_classif', 'f_classif'],\n",
    "                           var_name='metric',\n",
    "                           value_name='mae')\n",
    "max_value = scores_df['mae'].max() * 1.05\n",
    "min_value = scores_df['mae'].min() * 0.95\n",
    "render(alt.Chart(scores_df).mark_line().encode(\n",
    "    y=alt.Y('mae:Q', scale=alt.Scale(domain=(min_value, max_value))),\n",
    "    x='n_features:O',\n",
    "    color='metric:N',\n",
    "    tooltip=['metric:N', 'n:O', 'mae:Q']\n",
    ").properties(\n",
    "    title='Top N features by SelectKBest vs CV'\n",
    ").interactive())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dropping highly correlated features\n",
    "\n",
    "Due to the huge number of features there are certainly some highly correlated features, let's try droping them!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://chrisalbon.com/machine_learning/feature_selection/drop_highly_correlated_features/\n",
    "corr_matrix = X.corr().abs()\n",
    "\n",
    "# Select upper triangle of correlation matrix\n",
    "upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(np.bool))\n",
    "\n",
    "# Find index of feature columns with correlation greater than 0.95\n",
    "to_drop = [column for column in upper.columns if any(upper[column] > 0.99)]\n",
    "X = X.drop(to_drop, axis=1)\n",
    "X_test = X_test.drop(to_drop, axis=1)\n",
    "oof_lgb, prediction_lgb, feature_importance = train_model(X,\n",
    "                                                          X_test,\n",
    "                                                          y,\n",
    "                                                          params=params,\n",
    "                                                          folds=folds,\n",
    "                                                          model_type='lgb',\n",
    "                                                          plot_feature_importance=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "submission['time_to_failure'] = prediction_lgb\n",
    "submission.to_csv('submission_no_corr.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### RFE (Feature ranking with recursive feature elimination)\n",
    "\n",
    "**Important notice**:  I run the cell below in `version 18` and printed the scores_dict. In the following versions I'll use `scores_dict` and plot the results instead of running feature selection each time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_kg_hide-output": true
   },
   "outputs": [],
   "source": [
    "# scores_dict = {'rfe_score': [], 'n_features': []}\n",
    "# for i in np.arange(10, 1958, 100)[:3]:\n",
    "#     print(i)\n",
    "#     s1 = RFE(model, i, step=100)\n",
    "#     X_train1 = s1.fit_transform(X, y.values.astype(int))\n",
    "#     X_test1 = s1.transform(X_test)\n",
    "#     oof, prediction, scores = train_model(X_train1, X_test1, y.values.reshape(-1, ), params=params, folds=folds, model_type='lgb', plot_feature_importance=False)\n",
    "#     scores_dict['rfe_score'].append(np.mean(scores))\n",
    "    \n",
    "#     scores_dict['n_features'].append(X_train1.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores_dict = {'rfe_score': [2.103586938061856, 2.052535910798748, 2.053228199447811],\n",
    "               'n_features': [10, 110, 210]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores_df = pd.DataFrame(scores_dict)\n",
    "scores_df = scores_df.melt(id_vars=['n_features'], value_vars=['rfe_score'], var_name='metric', value_name='mae')\n",
    "max_value = scores_df['mae'].max() * 1.05\n",
    "min_value = scores_df['mae'].min() * 0.95\n",
    "render(alt.Chart(scores_df).mark_line().encode(\n",
    "    y=alt.Y('mae:Q', scale=alt.Scale(domain=(min_value, max_value))),\n",
    "    x='n_features:O',\n",
    "    color='metric:N',\n",
    "    tooltip=['metric:N', 'n:O', 'mae:Q']\n",
    ").properties(\n",
    "    title='Top N features by SelectKBest vs CV'\n",
    ").interactive())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model comparison\n",
    "\n",
    "In this section I'll try variuos sklearn models and compair their score. Running GridSearchCV each time is too long, so I'll run it once for each model and use optimal parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rfr = RandomForestRegressor(n_jobs=-1)\n",
    "#parameter_grid = {'n_estimators': [20, 50, 70, 90],\n",
    "#                  'max_depth': [4, 8, 16]\n",
    "#                 }\n",
    "\n",
    "#grid_search = GridSearchCV(rfr, param_grid=parameter_grid, cv=folds, scoring='neg_mean_absolute_error', n_jobs=-1)\n",
    "#grid_search.fit(X, y)\n",
    "#print('Best score: {}'.format(grid_search.best_score_))\n",
    "#print('Best parameters: {}'.format(grid_search.best_params_))\n",
    "#rfr = RandomForestRegressor(**grid_search.best_params_)\n",
    "rfr = RandomForestRegressor(n_estimators=90, max_depth=8, n_jobs=-1)\n",
    "oof_rfr, prediction_rfr, scores_rfr = train_model(X,\n",
    "                                                  X_test,\n",
    "                                                  y,\n",
    "                                                  params=params,\n",
    "                                                  folds=folds,\n",
    "                                                  model_type='sklearn',\n",
    "                                                  model=rfr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ridge = linear_model.Ridge(normalize=True)\n",
    "\n",
    "parameter_grid = {'alpha': [0.1, 0.5, 1.0, 2, 5, 10.0]}\n",
    "\n",
    "grid_search = GridSearchCV(ridge, param_grid=parameter_grid, cv=folds, scoring='neg_mean_absolute_error', n_jobs=-1)\n",
    "grid_search.fit(X, y)\n",
    "print('Best score: {}'.format(grid_search.best_score_))\n",
    "print('Best parameters: {}'.format(grid_search.best_params_))\n",
    "ridge = linear_model.Ridge(**grid_search.best_params_, normalize=True)\n",
    "oof_ridge, prediction_ridge, scores_ridge = train_model(X,\n",
    "                                                        X_test,\n",
    "                                                        y,\n",
    "                                                        params=params,\n",
    "                                                        folds=folds,\n",
    "                                                        model_type='sklearn',\n",
    "                                                        model=ridge)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "knn = neighbors.KNeighborsRegressor()\n",
    "\n",
    "parameter_grid = {'n_neighbors': [50, 100, 200, 300, 400]}\n",
    "\n",
    "grid_search = GridSearchCV(knn, param_grid=parameter_grid, cv=folds, scoring='neg_mean_absolute_error', n_jobs=-1)\n",
    "grid_search.fit(X, y)\n",
    "print('Best score: {}'.format(grid_search.best_score_))\n",
    "print('Best parameters: {}'.format(grid_search.best_params_))\n",
    "knn = neighbors.KNeighborsRegressor(**grid_search.best_params_)\n",
    "oof_knn, prediction_knn, scores_knn = train_model(X,\n",
    "                                                  X_test,\n",
    "                                                  y,\n",
    "                                                  params=params,\n",
    "                                                  folds=folds,\n",
    "                                                  model_type='sklearn',\n",
    "                                                  model=knn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#etr = ExtraTreesRegressor(n_jobs=-1)\n",
    "\n",
    "#parameter_grid = {'n_estimators': [500, 1000],\n",
    "#                  'max_depth': [5, 10, 20]\n",
    "#                }\n",
    "\n",
    "#grid_search = GridSearchCV(rfr, param_grid=parameter_grid,\n",
    "#                           cv=folds,\n",
    "#                           scoring='neg_mean_absolute_error',\n",
    "#                           verbose=10,\n",
    "#                           n_jobs=-1)\n",
    "#grid_search.fit(X, y)\n",
    "#print('Best score: {}'.format(grid_search.best_score_))\n",
    "#print('Best parameters: {}'.format(grid_search.best_params_))\n",
    "#etr = ExtraTreesRegressor(**grid_search.best_params_, n_jobs=-1)\n",
    "etr = ExtraTreesRegressor(n_estimators=1000, max_depth=10, n_jobs=-1)\n",
    "oof_etr, prediction_etr, scores_etr = train_model(X,\n",
    "                                                  X_test,\n",
    "                                                  y,\n",
    "                                                  params=params,\n",
    "                                                  folds=folds,\n",
    "                                                  model_type='sklearn',\n",
    "                                                  model=etr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "adr = AdaBoostRegressor()\n",
    "\n",
    "parameter_grid = {'n_estimators': [2, 4, 8, 16, 32],\n",
    "                 }\n",
    "\n",
    "grid_search = GridSearchCV(adr, param_grid=parameter_grid, cv=folds, scoring='neg_mean_absolute_error', n_jobs=-1)\n",
    "grid_search.fit(X, y)\n",
    "print('Best score: {}'.format(grid_search.best_score_))\n",
    "print('Best parameters: {}'.format(grid_search.best_params_))\n",
    "adr = AdaBoostRegressor(**grid_search.best_params_)\n",
    "oof_dar, prediction_adr, scores_adr = train_model(X,\n",
    "                                                  X_test,\n",
    "                                                  y,\n",
    "                                                  params=params,\n",
    "                                                  folds=folds, \n",
    "                                                  model_type='sklearn',\n",
    "                                                  model=adr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "params_gpi = {\n",
    "    'activation':'atan'\n",
    "}\n",
    "oof_gpi, prediction_gpi, scores_gpi = train_model(X_train_scaled,\n",
    "                                                  X_test_scaled,\n",
    "                                                  y,\n",
    "                                                  params=params_gpi,\n",
    "                                                  folds=folds,\n",
    "                                                  model_type='gpi_new')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "params_gpii = {\n",
    "    'activation':'atan'\n",
    "}\n",
    "oof_gpii, prediction_gpii, scores_gpii = train_model(X_train_scaled,\n",
    "                                                     X_test_scaled,\n",
    "                                                     y,\n",
    "                                                     params=params_gpii,\n",
    "                                                     folds=folds,\n",
    "                                                     model_type='gpii_new')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "params_gpiii = {\n",
    "    'activation':'atan'\n",
    "}\n",
    "oof_gpiii, prediction_gpiii, scores_gpiii = train_model(X_train_scaled,\n",
    "                                                        X_test_scaled,\n",
    "                                                        y,\n",
    "                                                        params=params_gpiii,\n",
    "                                                        folds=folds,\n",
    "                                                        model_type='gpiii_new')\n",
    "evaluation = pd.DataFrame(dtype=np.float64)\n",
    "submission = pd.read_csv('../input/sample_submission.csv', index_col='seg_id')\n",
    "submission['time_to_failure'] = prediction_gpiii\n",
    "submission.to_csv('../output/submission_gpiii_new.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12, 8));\n",
    "scores_df = pd.DataFrame()\n",
    "scores_df['RandomForestRegressor'] = scores_adr\n",
    "scores_df['ExtraTreesRegressor'] = scores_etr\n",
    "scores_df['AdaBoostRegressor'] = scores_adr\n",
    "scores_df['KNN'] = scores_knn\n",
    "scores_df['Ridge'] = scores_ridge\n",
    "scores_df['GPI'] = scores_gpi\n",
    "scores_df['GPII'] = scores_gpii\n",
    "scores_df['GPIII'] = scores_gpii\n",
    "\n",
    "ax = sns.boxplot(data=scores_df);\n",
    "#ax.set(yscale=\"log\")\n",
    "\n",
    "plt.xticks(rotation=45);"
   ]
  },
  {
   "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": 1
}