Feature engineer, RFE and a stacked model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Forest cover type prediction in Roosevelt National Forest\n",
    "\n",
    "# Feature engineering, oversampling, selection and an stacked model\n",
    "\n",
    "## Problem Description\n",
    "\n",
    "In this competition you are asked to predict the forest cover type (the predominant kind of tree cover) from strictly cartographic variables (as opposed to remotely sensed data). The actual forest cover type for a given 30 x 30 meter cell was determined from US Forest Service (USFS) Region 2 Resource Information System data. Independent variables were then derived from data obtained from the US Geological Survey and USFS. The data is in raw form (not scaled) and contains binary columns of data for qualitative independent variables such as wilderness areas and soil type\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing the libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\" For Kaggle Kernels\\nimport os\\nfor dirname, _, filenames in os.walk('/kaggle/input'):\\n    for filename in filenames:\\n        print(os.path.join(dirname, filename))\\n        if filename==train_file:\\n            train_dir=dirname\\n        if filename==test_file:\\n            test_dir=dirname\\n\""
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
    "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n",
    "# For example, here's several helpful packages to load in \n",
    "\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import gc\n",
    "import seaborn as sns\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.model_selection import cross_val_predict, cross_val_score\n",
    "\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "from sklearn.experimental import enable_hist_gradient_boosting\n",
    "from sklearn.ensemble import HistGradientBoostingClassifier\n",
    "from lightgbm import LGBMClassifier, plot_importance\n",
    "from xgboost import XGBClassifier\n",
    "\n",
    "import warnings\n",
    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
    "\n",
    "# Input data files are available in the \"../input/\" directory.\n",
    "# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n",
    "already_preprocessed=False\n",
    "train_file='train.csv'\n",
    "test_file='test.csv'\n",
    "\n",
    "\"\"\" For Kaggle Kernels\n",
    "import os\n",
    "for dirname, _, filenames in os.walk('/kaggle/input'):\n",
    "    for filename in filenames:\n",
    "        print(os.path.join(dirname, filename))\n",
    "        if filename==train_file:\n",
    "            train_dir=dirname\n",
    "        if filename==test_file:\n",
    "            test_dir=dirname\n",
    "\"\"\"        \n",
    "# Any results you write to the current directory are saved as output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
    "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a",
    "collapsed": true
   },
   "source": [
    "## Loading the train and test datasets\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#root folder\n",
    "root_folder='..\\..'\n",
    "#data_folder='.'\n",
    "data_folder_name='Datasets/RooseveltForest'\n",
    "\n",
    "# Variable for data directory\n",
    "DATA_PATH = os.path.abspath(os.path.join(root_folder, data_folder_name))\n",
    "\n",
    "# Both train and test set are in the root data directory\n",
    "train_dir = DATA_PATH\n",
    "test_dir = DATA_PATH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(565892, 54) (15120, 54)\n"
     ]
    }
   ],
   "source": [
    "# Reading the csv file with the whole dataset\n",
    "data = pd.read_csv(train_dir+'/'+train_file, sep=',', header=0, index_col=0)\n",
    "# Train data, erasing label column\n",
    "X_train = data.drop('Cover_Type', axis=1)\n",
    "y_train = data['Cover_Type']\n",
    "# Read the test data\n",
    "test = pd.read_csv(test_dir+'/'+test_file, sep=',', header=0, index_col=0)\n",
    "\n",
    "n_train=len(X_train)\n",
    "print(test.shape,X_train.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature engineering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some kernels extract some new information, or new features, from the test data and then include that new information to the training dataset. A simple and effective aproach is to create a Gaussian Mixture model as is described for example in:\n",
    "https://www.kaggle.com/stevegreenau/stacking-multiple-classifiers-clustering or in https://www.kaggle.com/arateris/2-layer-k-fold-learning-forest-cover\n",
    "\n",
    "Lets include this new features: First we normalize the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "all_data=X_train.append(test)\n",
    "# Normalized  the data using a StandardScaler\n",
    "# Standardize features by removing the mean and scaling to unit variance\n",
    "scaler = StandardScaler().fit(all_data)\n",
    "# Apply the scaler to the train and test dataset\n",
    "test_scaled = scaler.transform(test)\n",
    "X_train_scaled = scaler.transform(X_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a new feature using a clustering model, a Gaussian mixture model. Gaussian mixture models can be used to cluster unlabeled data in much the same way as k-means, but with teo differences: it accounts for variance and it provides us with the probability that a given data point belongs to each of the possible clusters. For a detailed explanation see: https://towardsdatascience.com/gaussian-mixture-models-d13a5e915c8e. \n",
    "\n",
    "Our new feature will be the cluster from the Gaussian mixture assigned to that point, the closest one. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.mixture import GaussianMixture\n",
    "# Num clusters o components is a parameter to try out with \n",
    "# We apply the clustering on the test data to extrac some information from it \n",
    "# (it is like cheating but for the intereset of education is acceptable)\n",
    "gmix = GaussianMixture(n_components=10,random_state=0)\n",
    "gmix.fit(test_scaled)\n",
    "\n",
    "x_train_gmix = gmix.predict(X_train_scaled)\n",
    "test_gmix = gmix.predict(test_scaled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(565892, 64) (15120, 64)\n"
     ]
    }
   ],
   "source": [
    "# Create the new feature, including te clusters as a new feature\n",
    "X_train['Cluster_Test']=x_train_gmix\n",
    "test['Cluster_Test']=test_gmix\n",
    "\n",
    "#Convert to categorical (binaries columns)\n",
    "X_train = pd.get_dummies(X_train,columns = ['Cluster_Test'])\n",
    "test = pd.get_dummies(test,columns = ['Cluster_Test'])\n",
    "\n",
    "print(test.shape,X_train.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to extract a new feature is to apply principal component analysis (PCA) to create a set of \"new\" features. PCA is a dimension reduction technique, so we can retrive a set of variables that are a combination of the original ones and can contain non explicit information.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PCA components dimension:  (581012, 4)\n",
      "(565892, 68) (15120, 68)\n"
     ]
    }
   ],
   "source": [
    "#Apply PCA to obtain new features based in all datasets (train and test)\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "def add_PCA_features(X):\n",
    "    ''' Return the PCA components for the dataset X'''\n",
    "    pca = PCA(n_components=0.99, random_state=0).fit(X)\n",
    "    X_pca = pca.transform(X)\n",
    "    \n",
    "    return X_pca\n",
    "\n",
    "components = add_PCA_features(all_data)\n",
    "# Show the dimension of the PCA components generated\n",
    "print('PCA components dimension: ',components.shape)\n",
    "# Create a new feature for every dimension in the PCA components\n",
    "for i in range(components.shape[1]):\n",
    "    col_name= 'pca'+str(i+1)\n",
    "    X_train[col_name] = components[:n_train, i]\n",
    "    test[col_name] = components[n_train:, i]\n",
    "\n",
    "print(test.shape,X_train.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are four components in our PCA analysis and they are inserted as new features in our dataset. Later we will apply some techniques to remove features to avoid using correlated and non relevant features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Oversampling the data\n",
    "We will apply some oversampling on the training data, trying to improve the results on the confussion matrix. There are many classifications errors in samples of cover type 1 and 2, so we want to train the model with more examples of these cover types.\n",
    "\n",
    "Many ideas and tricks extracted from a great kernell: https://www.kaggle.com/phsheth/forestml-part-6-stacking-selfets-gmix-smote by https://www.kaggle.com/phsheth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n",
      "C:\\Users\\edumu\\Anaconda3\\lib\\site-packages\\imblearn\\utils\\_validation.py:253: UserWarning: After over-sampling, the number of samples (8000) in class 1 will be larger than the number of samples in the majority class (class #1 -> 2160)\n",
      "  n_samples_majority))\n",
      "C:\\Users\\edumu\\Anaconda3\\lib\\site-packages\\imblearn\\utils\\_validation.py:253: UserWarning: After over-sampling, the number of samples (8000) in class 2 will be larger than the number of samples in the majority class (class #1 -> 2160)\n",
      "  n_samples_majority))\n",
      "C:\\Users\\edumu\\Anaconda3\\lib\\site-packages\\imblearn\\utils\\_validation.py:253: UserWarning: After over-sampling, the number of samples (3000) in class 3 will be larger than the number of samples in the majority class (class #1 -> 2160)\n",
      "  n_samples_majority))\n",
      "C:\\Users\\edumu\\Anaconda3\\lib\\site-packages\\imblearn\\utils\\_validation.py:253: UserWarning: After over-sampling, the number of samples (3000) in class 4 will be larger than the number of samples in the majority class (class #1 -> 2160)\n",
      "  n_samples_majority))\n",
      "C:\\Users\\edumu\\Anaconda3\\lib\\site-packages\\imblearn\\utils\\_validation.py:253: UserWarning: After over-sampling, the number of samples (3000) in class 5 will be larger than the number of samples in the majority class (class #1 -> 2160)\n",
      "  n_samples_majority))\n",
      "C:\\Users\\edumu\\Anaconda3\\lib\\site-packages\\imblearn\\utils\\_validation.py:253: UserWarning: After over-sampling, the number of samples (3000) in class 6 will be larger than the number of samples in the majority class (class #1 -> 2160)\n",
      "  n_samples_majority))\n",
      "C:\\Users\\edumu\\Anaconda3\\lib\\site-packages\\imblearn\\utils\\_validation.py:253: UserWarning: After over-sampling, the number of samples (3000) in class 7 will be larger than the number of samples in the majority class (class #1 -> 2160)\n",
      "  n_samples_majority))\n"
     ]
    }
   ],
   "source": [
    "# Use SMOTE technique for oversampling\n",
    "from imblearn.over_sampling import SMOTE\n",
    "# Define the sampling strategy\n",
    "sm = SMOTE(sampling_strategy = {1:8000, 2:8000, 3:3000, 4:3000, 5:3000, 6:3000, 7:3000}, random_state=0)\n",
    "\n",
    "X_sm, y_sm = sm.fit_sample(X_train, y_train.ravel())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After OverSampling, the shape of train_X: (31000, 55)\n",
      "After OverSampling, the shape of train_y: (31000,)\n",
      "After OverSampling, counts of label '1': 8000\n",
      "After OverSampling, counts of label '2': 8000\n",
      "After OverSampling, counts of label '3': 3000\n",
      "After OverSampling, counts of label '4': 3000\n",
      "After OverSampling, counts of label '5': 3000\n",
      "After OverSampling, counts of label '6': 3000\n",
      "After OverSampling, counts of label '7': 3000\n"
     ]
    }
   ],
   "source": [
    "# Show the new distribution of the target variable\n",
    "print('After OverSampling, the shape of train_X: {}'.format(X_sm.shape))\n",
    "print('After OverSampling, the shape of train_y: {}'.format(y_sm.shape))\n",
    "\n",
    "print(\"After OverSampling, counts of label '1': {}\".format(sum(y_sm==1)))\n",
    "print(\"After OverSampling, counts of label '2': {}\".format(sum(y_sm==2)))\n",
    "print(\"After OverSampling, counts of label '3': {}\".format(sum(y_sm==3)))\n",
    "print(\"After OverSampling, counts of label '4': {}\".format(sum(y_sm==4)))\n",
    "print(\"After OverSampling, counts of label '5': {}\".format(sum(y_sm==5)))\n",
    "print(\"After OverSampling, counts of label '6': {}\".format(sum(y_sm==6)))\n",
    "print(\"After OverSampling, counts of label '7': {}\".format(sum(y_sm==7)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can replace the original training dataset with the new one oversampled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a dataframe with the new features\n",
    "X_train=pd.DataFrame(data=X_sm, columns=X_train.columns)\n",
    "X_train.index.name='Id'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Id\n",
       "0        5\n",
       "1        5\n",
       "2        2\n",
       "3        2\n",
       "4        5\n",
       "        ..\n",
       "30995    7\n",
       "30996    7\n",
       "30997    7\n",
       "30998    7\n",
       "30999    7\n",
       "Name: Cover_Type, Length: 31000, dtype: int64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Include the new target labels\n",
    "y_train=pd.Series(y_sm)\n",
    "y_train.index.name='Id'\n",
    "y_train.name='Cover_Type'\n",
    "y_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Selection\n",
    "\n",
    "After including a new set of features, we need to select the best combination of features that can predict the target variable. This process is called feature selection and it based on three criteria:\n",
    "- Reduce low important features: The importance of a feature can be calculated using a decision tree model, random forest or gradient boosting machine learning model (GBM). You may remove less important features because they are not important for a ml model to make predictions.\n",
    "- Single unique value features: Here we remove columns that have a single unique value throughout the entire dataset because a machine learning model can’t draw any conclusion out of these columns\n",
    "- Colinear featurs: Collinear features are the features that are highly dependent on another feature. Due to high variance and less model interpretability, collinear features lead to decreased generalized performance. The level of correlation is identified based on a specific correlation coefficient.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the feature importance determined by the classifier clf\n",
    "def feature_importances(clf, X, y):\n",
    "    clf = clf.fit(X, y)\n",
    "    \n",
    "    importances = pd.DataFrame({'Features': X.columns, \n",
    "                                'Importances': clf.feature_importances_})\n",
    "    \n",
    "    importances.sort_values(by=['Importances'], axis='index', ascending=False, inplace=True)\n",
    "\n",
    "    fig = plt.figure(figsize=(14, 4))\n",
    "    sns.barplot(x='Features', y='Importances', data=importances)\n",
    "    plt.xticks(rotation='vertical')\n",
    "    plt.show()\n",
    "    \n",
    "# Calculate the accuracy using a cross validated approach \n",
    "def cv_accuracy(clf, X, y):\n",
    "    scores = cross_val_score(clf, X, y, \n",
    "                             cv=5, \n",
    "                             scoring='accuracy',\n",
    "                             verbose=0, \n",
    "                             n_jobs=-1)\n",
    "    \n",
    "    print('Cross-validation accuracy: {:.3f} {}'.format(np.mean(scores),  \n",
    "                                                        np.around(scores, 3)))\n",
    "\n",
    "# Shows the confusion matrix using criss validated predictions\n",
    "def cv_confusion(clf, X, y):\n",
    "    prediction = cross_val_predict(clf, X, y, \n",
    "                                   cv=5, \n",
    "                                   verbose=0, \n",
    "                                   n_jobs=-1)\n",
    "    \n",
    "    classes = sorted(y.unique().tolist())\n",
    "\n",
    "    conf_mat = confusion_matrix(y, prediction)\n",
    "    norm_conf_mat = np.around(conf_mat / conf_mat.sum(axis=1), 2)\n",
    "\n",
    "    fig = plt.figure(figsize=(14, 8))\n",
    "\n",
    "    fig.add_subplot(1, 2, 1)\n",
    "    ax = sns.heatmap(norm_conf_mat, annot=True, cmap='OrRd', \n",
    "                     xticklabels=classes, yticklabels=classes)\n",
    "    ax.set(xlabel='Predicted Class', ylabel='True Class', title='Normalized')\n",
    "\n",
    "\n",
    "    fig.add_subplot(1, 2, 2)\n",
    "    ax = sns.heatmap(conf_mat, annot=True, fmt='d', cmap='OrRd', \n",
    "                     xticklabels=classes, yticklabels=classes)\n",
    "    ax.set(xlabel='Predicted Class', ylabel='True Class', title ='Counts')\n",
    "\n",
    "    #plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "# Plot correlations between numerical features\n",
    "def plot_correlations(X, annot=False):\n",
    "    numericals = [col for col in X.columns if \n",
    "                  'Soil_Type' not in col and \n",
    "                  'Wilderness_Area' not in col]\n",
    "\n",
    "    numericals = sorted(numericals)\n",
    "\n",
    "    # Place correlations in four bins\n",
    "    corr = np.around(X[numericals].corr().abs(), 1)\n",
    "    \n",
    "    corr_bin = corr.copy()\n",
    "    corr_bin = corr_bin.where(corr_bin > 0.30, 0.30)\n",
    "\n",
    "    corr_bin = corr_bin.where((corr_bin <= 0.30) | \n",
    "                              (corr_bin > 0.50), 0.50)\n",
    "\n",
    "    corr_bin = corr_bin.where((corr_bin <= 0.50) | \n",
    "                              (corr_bin > 0.70), 0.70)\n",
    "\n",
    "    corr_bin = corr_bin.where(corr_bin <= 0.70, 1.0)\n",
    "    \n",
    "    if annot:\n",
    "        annot = corr\n",
    "        \n",
    "    # Show binned correlation plot\n",
    "    fig = plt.figure(figsize=(12, 12))\n",
    "    sns.heatmap(corr_bin, annot=annot, linewidths=1, square=True, \n",
    "                cmap='BuPu', cbar_kws={'shrink':0.5})\n",
    "    plt.title('Feature Correlations')\n",
    "    plt.show()\n",
    "\n",
    "# Drop features with mode frequency > 99% of data\n",
    "# Those columns are irrelevant, they have almost just one value \n",
    "def drop_unimportant(X_):\n",
    "    X = X_.copy()\n",
    "    \n",
    "    n_rows = X.shape[0]\n",
    "    hi_freq_cols = []\n",
    "    \n",
    "    for col in X.columns:\n",
    "        mode_frequency = 100.0 * X[col].value_counts().iat[0] / n_rows \n",
    "        \n",
    "        if mode_frequency > 99.0:\n",
    "            hi_freq_cols.append(col)\n",
    "            \n",
    "    X = X.drop(hi_freq_cols, axis='columns')\n",
    "    \n",
    "    return hi_freq_cols,X\n",
    "\n",
    "def drop_correlated(X_):\n",
    "    X = X_.copy()\n",
    "    \n",
    "    drop_cols = ['Hillshade_mean', 'Hillshade_median', 'Hillshade_max', \n",
    "                 'Hillshade_min', 'Hillshade_sum', 'Hydro_Elevation_sum',\n",
    "                 'Hydro_Distance_sum', 'Hydro_Distance_diff', 'Hydro_Fire_mean', \n",
    "                 'Hydro_Fire_median', 'Hydro_Manhattan', 'Hydro_Road_Fire_mean', \n",
    "                 'Hydro_Road_Fire_median', 'Hydro_Road_mean', 'Hydro_Road_median', \n",
    "                 'Road_Fire_mean', 'Road_Fire_median']\n",
    "    \n",
    "    drop_cols = [col for col in drop_cols if col in X.columns]\n",
    "    \n",
    "    X = X.drop(drop_cols, axis='columns')\n",
    "    \n",
    "    return drop_cols,X\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other utility functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#transform binary columns of a categorical variable to an only one categorical column\n",
    "def categorify(df, col_string_search, remove_original=False):\n",
    "    cols = df.columns\n",
    "    for key_str in col_string_search:\n",
    "        new_col_name = key_str+'_cat'\n",
    "        df[new_col_name]=0\n",
    "        for col in cols:\n",
    "            if ~str(col).find(key_str):\n",
    "                binary_feat.append(col)\n",
    "                df[new_col_name]= df[new_col_name]+int(str(col).lstrip(key_str))*df[col]\n",
    "                if remove_original:\n",
    "                    df.drop(col, axis=1, inplace=True)\n",
    "        categorial_feat.append(new_col_name)\n",
    "#         df[new_col_name] = df[new_col_name].astype('category')\n",
    "        \n",
    "#keeping track of the categorial features\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use a simple RandomForest classifier to analyze the features, it will be the performance baseline to analyze the importance of features in our predictor model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This classifier is used to evaluate the performance of the features in diferent scenarios: importance, correlation and so.\n",
    "clf = RandomForestClassifier(n_estimators=125,\n",
    "                             min_samples_leaf=1,\n",
    "                             max_depth=None,\n",
    "                             verbose=0,\n",
    "                             random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Show the importance of our dataset to identify unrelevant variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cross-validation accuracy: 0.800 [0.773 0.764 0.793 0.808 0.864]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "feature_importances(clf, X_train, y_train)\n",
    "cv_accuracy(clf, X_train, y_train)\n",
    "cv_confusion(clf, X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature engineering: Feature crossing\n",
    "\n",
    "Now we will apply some feature engineering techniques to extract a more relevant group of features, especially Feature Crossing. Feature crossing combine multiple variables together, multiply or square them. Sometimes combining variables together can produce predictive performance that outperforms what they could’ve done in isolation.\n",
    "\n",
    "We are goint to generate a group of features that many others competitors have worked on and looks like they can produce a gerat result. Thanks to kwabenantim, most of the feature engineering and selection in this kernells have been extracted from his excellent kernell https://www.kaggle.com/kwabenantim/forest-cover-stacking-multiple-classifiers. I strongllly recomend to read carefully and study it, not all the steps in that kernell are included in this one. This one is simpler and very easy to understand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This new features has been extracted from the kernel previously citated:\n",
    "# https://www.kaggle.com/kwabenantim/forest-cover-stacking-multiple-classifiers\n",
    "\n",
    "def add_features(X_):\n",
    "    X = X_.copy()\n",
    "    \n",
    "    X['Hydro_Elevation_sum'] = X[['Elevation',\n",
    "                                  'Vertical_Distance_To_Hydrology']\n",
    "                                 ].sum(axis='columns')\n",
    "    \n",
    "    X['Hydro_Elevation_diff'] = X[['Elevation',\n",
    "                                   'Vertical_Distance_To_Hydrology']\n",
    "                                  ].diff(axis='columns').iloc[:, [1]]\n",
    "\n",
    "    X['Hydro_Euclidean'] = np.sqrt(X['Horizontal_Distance_To_Hydrology']**2 +\n",
    "                                   X['Vertical_Distance_To_Hydrology']**2)\n",
    "\n",
    "    X['Hydro_Manhattan'] = (X['Horizontal_Distance_To_Hydrology'] +\n",
    "                            X['Vertical_Distance_To_Hydrology'].abs())\n",
    "    \n",
    "    \n",
    "    X['Hydro_Distance_sum'] = X[['Horizontal_Distance_To_Hydrology',\n",
    "                                 'Vertical_Distance_To_Hydrology']\n",
    "                                ].sum(axis='columns')\n",
    "\n",
    "    X['Hydro_Distance_diff'] = X[['Horizontal_Distance_To_Hydrology',\n",
    "                                  'Vertical_Distance_To_Hydrology']\n",
    "                                 ].diff(axis='columns').iloc[:, [1]]\n",
    "    \n",
    "    X['Hydro_Fire_sum'] = X[['Horizontal_Distance_To_Hydrology',\n",
    "                             'Horizontal_Distance_To_Fire_Points']\n",
    "                            ].sum(axis='columns')\n",
    "\n",
    "    X['Hydro_Fire_diff'] = X[['Horizontal_Distance_To_Hydrology',\n",
    "                              'Horizontal_Distance_To_Fire_Points']\n",
    "                             ].diff(axis='columns').iloc[:, [1]].abs()\n",
    "\n",
    "    X['Hydro_Fire_mean'] = X[['Horizontal_Distance_To_Hydrology',\n",
    "                              'Horizontal_Distance_To_Fire_Points']\n",
    "                             ].mean(axis='columns')\n",
    "\n",
    "    X['Hydro_Fire_median'] = X[['Horizontal_Distance_To_Hydrology',\n",
    "                                'Horizontal_Distance_To_Fire_Points']\n",
    "                               ].median(axis='columns')\n",
    "                               \n",
    "    X['Hydro_Road_sum'] = X[['Horizontal_Distance_To_Hydrology',\n",
    "                             'Horizontal_Distance_To_Roadways']\n",
    "                            ].sum(axis='columns')\n",
    "\n",
    "    X['Hydro_Road_diff'] = X[['Horizontal_Distance_To_Hydrology',\n",
    "                              'Horizontal_Distance_To_Roadways']\n",
    "                             ].diff(axis='columns').iloc[:, [1]].abs()\n",
    "\n",
    "    X['Hydro_Road_mean'] = X[['Horizontal_Distance_To_Hydrology',\n",
    "                              'Horizontal_Distance_To_Roadways']\n",
    "                             ].mean(axis='columns')\n",
    "\n",
    "    X['Hydro_Road_median'] = X[['Horizontal_Distance_To_Hydrology',\n",
    "                                'Horizontal_Distance_To_Roadways']\n",
    "                               ].median(axis='columns')\n",
    "    \n",
    "    X['Road_Fire_sum'] = X[['Horizontal_Distance_To_Roadways',\n",
    "                            'Horizontal_Distance_To_Fire_Points']\n",
    "                           ].sum(axis='columns')\n",
    "\n",
    "    X['Road_Fire_diff'] = X[['Horizontal_Distance_To_Roadways',\n",
    "                             'Horizontal_Distance_To_Fire_Points']\n",
    "                            ].diff(axis='columns').iloc[:, [1]].abs()\n",
    "\n",
    "    X['Road_Fire_mean'] = X[['Horizontal_Distance_To_Roadways',\n",
    "                             'Horizontal_Distance_To_Fire_Points']\n",
    "                            ].mean(axis='columns')\n",
    "\n",
    "    X['Road_Fire_median'] = X[['Horizontal_Distance_To_Roadways',\n",
    "                               'Horizontal_Distance_To_Fire_Points']\n",
    "                              ].median(axis='columns')\n",
    "    \n",
    "    X['Hydro_Road_Fire_mean'] = X[['Horizontal_Distance_To_Hydrology',\n",
    "                                   'Horizontal_Distance_To_Roadways',\n",
    "                                   'Horizontal_Distance_To_Fire_Points']\n",
    "                                  ].mean(axis='columns')\n",
    "\n",
    "    X['Hydro_Road_Fire_median'] = X[['Horizontal_Distance_To_Hydrology',\n",
    "                                     'Horizontal_Distance_To_Roadways',\n",
    "                                     'Horizontal_Distance_To_Fire_Points']\n",
    "                                    ].median(axis='columns')\n",
    "\n",
    "    X['Hillshade_sum'] = X[['Hillshade_9am',\n",
    "                            'Hillshade_Noon',\n",
    "                            'Hillshade_3pm']\n",
    "                           ].sum(axis='columns')\n",
    "\n",
    "    X['Hillshade_mean'] = X[['Hillshade_9am',\n",
    "                             'Hillshade_Noon',\n",
    "                             'Hillshade_3pm']\n",
    "                            ].mean(axis='columns')\n",
    "\n",
    "    X['Hillshade_median'] = X[['Hillshade_9am',\n",
    "                               'Hillshade_Noon',\n",
    "                               'Hillshade_3pm']\n",
    "                              ].median(axis='columns')\n",
    "\n",
    "    X['Hillshade_min'] = X[['Hillshade_9am',\n",
    "                            'Hillshade_Noon',\n",
    "                            'Hillshade_3pm']\n",
    "                           ].min(axis='columns')\n",
    "\n",
    "    X['Hillshade_max'] = X[['Hillshade_9am',\n",
    "                            'Hillshade_Noon',\n",
    "                            'Hillshade_3pm']\n",
    "                           ].max(axis='columns')\n",
    "    #HILLSHADE STANDARD DEV\n",
    "    #Hillshade sum,diff in grouops of 2 values\n",
    "    #MISSING VALUES HILLSHADE3AM\n",
    "    #\n",
    "    \n",
    "    # Compute Soil_Type number from Soil_Type binary columns\n",
    "    X['Stoneyness'] = sum(i * X['Soil_Type{}'.format(i)] for i in range(1, 41))\n",
    "    \n",
    "    # For all 40 Soil_Types, 1=rubbly, 2=stony, 3=very stony, 4=extremely stony, 0=?\n",
    "    stoneyness = [4, 3, 1, 1, 1, 2, 0, 0, 3, 1, \n",
    "                  1, 2, 1, 0, 0, 0, 0, 3, 0, 0, \n",
    "                  0, 4, 0, 4, 4, 3, 4, 4, 4, 4, \n",
    "                  4, 4, 4, 4, 1, 4, 4, 4, 4, 4]\n",
    "    \n",
    "    # Replace Soil_Type number with \"stoneyness\" value\n",
    "    X['Stoneyness'] = X['Stoneyness'].replace(range(1, 41), stoneyness)\n",
    "    \n",
    "    #Drop Soil_types and categorize Stoneyness\n",
    "    return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create new features manipulating the Aspect variable\n",
    "def transform_Aspect(X_):\n",
    "    X = X_.copy()\n",
    "    \n",
    "    X['Aspect'] = X['Aspect'].astype(int) % 360\n",
    "    \n",
    "    #aspect_names = ['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW', 'N']\n",
    "    #degree = np.array([22.5, 67.5, 112.5, 157.5, 202.5, 247.5, 292.5, 337.5, 360])\n",
    "    \n",
    "    #def get_aspect_name(aspect):\n",
    "    #    d = degree - aspect\n",
    "    #    indx = np.where(d > 0, d, np.inf).argmin()\n",
    "    #    return aspect_names[indx]\n",
    "\n",
    "    #X['Aspect_Name'] = X['Aspect'].apply(get_aspect_name).astype('category')\n",
    "    #X['Aspect_Name'].cat.set_categories(aspect_names[:-1])\n",
    "    \n",
    "    X['Sin_Aspect'] = np.sin(np.radians(X['Aspect'])) # not important feature at all\n",
    "    X['Cos_Aspect'] = np.cos(np.radians(X['Aspect']))\n",
    "\n",
    "    X['Slope_hyd'] = np.arctan(X['Vertical_Distance_To_Hydrology']/(X['Horizontal_Distance_To_Hydrology']+0.001))\n",
    "    X.Slope_hyd=X.Slope_hyd.map(lambda x: 0 if np.isinf(x) else x) # remove infinite value if any\n",
    "    \n",
    "    X['Sin_Slope_hyd'] = np.sin(np.radians(X['Slope_hyd']))\n",
    "    X['Cos_Slope_hyd'] = np.cos(np.radians(X['Slope_hyd']))\n",
    "\n",
    "    X['Sin_Slope'] = np.sin(np.radians(X['Slope']))\n",
    "    X['Cos_Slope'] = np.cos(np.radians(X['Slope']))\n",
    "    \n",
    "   \n",
    "    return X\n",
    "\n",
    "#train['Slope2'] = np.sqrt(train.Horizontal_Distance_To_Hydrology**2 + train.Vertical_Distance_To_Hydrology**2)\n",
    "#test['Slope2'] = np.sqrt(test.Horizontal_Distance_To_Hydrology**2 + test.Vertical_Distance_To_Hydrology**2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will repeat the previous analyze with our new dataset, containing the new features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(565892, 94) (15120, 94)\n"
     ]
    }
   ],
   "source": [
    "# Add the new features to the dataset\n",
    "X_train = add_features(X_train)\n",
    "test = add_features(test)\n",
    "\n",
    "print(test.shape,X_train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(565892, 98) (15120, 98)\n"
     ]
    }
   ],
   "source": [
    "print(test.shape,X_train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(565892, 98) (15120, 98)\n"
     ]
    }
   ],
   "source": [
    "# Add the new features to the dataset\n",
    "# These new features based on Aspect and Slope does not improve accuracy\n",
    "#X_train = transform_Aspect(X_train)\n",
    "#test = transform_Aspect(test)\n",
    "\n",
    "print(test.shape,X_train.shape)\n",
    "\n",
    "#feature_importances(clf, X_train, y_train)\n",
    "#cv_accuracy(clf, X_train, y_train)\n",
    "#cv_confusion(clf, X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4    6546\n",
       "1    5096\n",
       "0    1854\n",
       "2     877\n",
       "3     747\n",
       "Name: Stoneyness, dtype: int64"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.Stoneyness.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Convert to categorical\n",
    "#X_train = pd.get_dummies(X_train,columns = ['Aspect_Name'])\n",
    "#test = pd.get_dummies(test,columns = ['Aspect_Name'])\n",
    "\n",
    "#X_train.drop('Aspect',axis=1,inplace=True)\n",
    "#test.drop('Aspect',axis=1,inplace=True)\n",
    "\n",
    "#print(test.shape,X_train.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Applying feature selection techniques \n",
    "Finally we will drop unimportant features, those containing just a few values. Mode frequency > 99% of data. And the last step will be to drop those correlated features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cross-validation accuracy: 0.807 [0.78  0.783 0.792 0.814 0.867]\n",
      "(565892, 81) (15120, 81)\n"
     ]
    }
   ],
   "source": [
    "# Drop umportant columns from train data\n",
    "unimportant_cols,X_train = drop_unimportant(X_train)\n",
    "\n",
    "cv_accuracy(clf, X_train, y_train)\n",
    "# Drop umportant columns from test data\n",
    "test = test.drop(unimportant_cols, axis='columns')\n",
    "print(test.shape,X_train.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drop correlated columns they usually do not provide information for a better classifier but they can overfit out model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(565892, 64) (15120, 64)\n"
     ]
    }
   ],
   "source": [
    "plot_correlations(X_train, annot=False)\n",
    "#Drop correlated columns from test data\n",
    "dropped_cols, X_train = drop_correlated(X_train)\n",
    "#Drop correlated columns from test data\n",
    "test = test.drop(dropped_cols, axis='columns')\n",
    "print(test.shape,X_train.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Apply Recursive Feature Elimination to select the features \n",
    "\n",
    "The Recursive Feature Elimination (RFE) method is a feature selection approach. It works by recursively removing attributes and building a model on those attributes that remain. It uses the model accuracy to identify which attributes (and combination of attributes) contribute the most to predicting the target attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_selection import RFE\n",
    "# Define the RFE algorithm\n",
    "rfe = RFE(clf, n_features_to_select = None, step=1)\n",
    "# Train the rfe algorithm on the train dataset\n",
    "selector= rfe.fit(X_train, y_train)\n",
    "#print(selector.n_features_,selector.ranking_)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drop the columns with a bad ranking on the RFE algorithm "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(selector.n_features_,selector.ranking_)\n",
    "#X_train = selector.transform(X_train)\n",
    "def drop_unranked(X_,cols,rank = 1):\n",
    "    X = X_.copy()\n",
    "    \n",
    "    drop_cols = [X.columns[i] for i in range(0,len(X.columns)) if cols[i]>rank]\n",
    "    \n",
    "    X = X.drop(drop_cols, axis='columns')\n",
    "    \n",
    "    return drop_cols,X\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seleccionables:  27\n"
     ]
    }
   ],
   "source": [
    "print('Select columns: ',sum(selector.ranking_<=5))\n",
    "cols,X_train=drop_unranked(X_train,selector.ranking_, 5)\n",
    "test = test.drop(cols, axis='columns')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the final dataset after removing some unrelevant features in the previous steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(565892, 68) (15120, 68)\n",
      "Cross-validation accuracy: 0.812 [0.791 0.778 0.796 0.816 0.878]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Lets evaluate our final dataset\n",
    "print(test.shape,X_train.shape)\n",
    "\n",
    "cv_accuracy(clf, X_train, y_train)\n",
    "feature_importances(clf, X_train, y_train)\n",
    "cv_confusion(clf, X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets save the final train and test dataset to be use in the classifiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = X_train.assign(Cover_Type=y_train)\n",
    "df1.to_csv('train_fe.csv', sep=',', header=True, index=True, index_label='Id')\n",
    "test.to_csv('test_fe.csv', sep=',', header=True, index=True, index_label='Id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X:  (15120, 64)\n",
      "y:  (15120,)\n",
      "test:  (565892, 64)\n"
     ]
    }
   ],
   "source": [
    "# Tranform to numpy array of float type\n",
    "X = X_train.values.astype('float64')\n",
    "y = y_train.values.ravel()\n",
    "test_ds= test.values.astype('float64')\n",
    "\n",
    "#X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.4, random_state = 0)\n",
    "\n",
    "print('X: ', X.shape)\n",
    "print('y: ', y.shape)\n",
    "print('test: ', test_ds.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ensemble Stacked Model\n",
    "Ensemble modeling is now a well-established means for improving prediction accuracy; it enables you to average out noise from diverse models and thereby enhance the generalizable signal. Basic stacked ensemble techniques combine predictions from multiple machine learning algorithms and use these predictions as inputs to second-level learning models. It involves combining the predictions from multiple machine learning models on the same dataset, like bagging and boosting.\n",
    "\n",
    "The architecture of a stacking model involves two or more base models, often referred to as level-0 models, and a meta-model that combines the predictions of the base models, referred to as a level-1 model.\n",
    "\n",
    "- Level-0 Models (Base-Models): Models fit on the training data and whose predictions are compiled.\n",
    "- Level-1 Model (Meta-Model): Model that learns how to best combine the predictions of the base models.\n",
    "\n",
    "### Classifiers in the Level 0 of the stacked model\n",
    "\n",
    "Create a dictionary with the diferents models in the Level 1 in the stacked model. There are many posibilities, I have tested some of them using GridSearchCV for some parameter tunning (but they can be improved with some other experiments). You can check some great kernels published by others members:\n",
    "\n",
    "https://www.kaggle.com/stevegreenau/stacking-multiple-classifiers-clustering\n",
    "https://www.kaggle.com/phsheth/forestml-part-6-stacking-selfets-gmix-smote\n",
    "\n",
    "Bayesian optimization for hyperparameters. ¿Try?\n",
    "https://www.kdnuggets.com/2019/07/xgboost-random-forest-bayesian-optimisation.html\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Define a ratio for every class weighted\n",
    "#ratio_weight={1:0.3, 2:0.3, 3: 0.1, 4:0.05, 5:0.1, 6:0.1, 7:0.05}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Estimators: 400, 400, 400, 125 (reduce to 100 100 100 100 for some tests)\n",
    "models = {\n",
    "    'Random Forest': RandomForestClassifier(criterion = 'entropy',n_estimators=400, max_depth=None, min_samples_split=2, min_samples_leaf=1, \n",
    "                                    max_leaf_nodes=None,random_state = 0, class_weight = None),\n",
    "    'AdaBoost': AdaBoostClassifier(base_estimator=DecisionTreeClassifier(criterion = 'entropy', max_depth=None, min_samples_split=2,\n",
    "                                                                         min_samples_leaf=1,max_leaf_nodes=None,max_features='auto',\n",
    "                                                                         random_state = 0, class_weight = None),\n",
    "                                   n_estimators=400,learning_rate=0.2,random_state=0),\n",
    "    \n",
    "    'Bagging': BaggingClassifier(base_estimator=DecisionTreeClassifier(criterion = 'entropy', max_depth=None, min_samples_split=2,\n",
    "                                                                         min_samples_leaf=1,max_leaf_nodes=None,max_features='auto',\n",
    "                                                                         random_state = 0),\n",
    "                                   n_estimators=300,max_features=0.75, max_samples=1.0, random_state=0,n_jobs=-1,verbose=0),\n",
    "    #{'max_features': 0.75, 'max_samples': 1.0, 'n_estimators': 300}\n",
    "    #'GBM': GradientBoostingClassifier(n_estimators=500, learning_rate= 0.2, max_depth=10, min_samples_leaf=1, \n",
    "    #                                  min_samples_split=2,random_state=0,verbose=1),\n",
    "    'LGBM': LGBMClassifier(n_estimators=300, learning_rate= 0.1, objective= 'multiclass', num_class=7, random_state= 0, \n",
    "                           n_jobs=-1, class_weight = None),\n",
    "    #'LGBM': LGBMClassifier(n_estimators=300, num_leaves=100, verbosity=0, random_state=0,n_jobs=-1),\n",
    "    #'KNN': KNeighborsClassifier(n_neighbors=7, n_jobs=-1),\n",
    "    # 'XGB': XGBClassifier(n_estimator= 200, learning_rate= 0.1, max_depth= 50, objective= 'binary:logistic',random_state= 0,n_jobs=-1),\n",
    "    'Extra Tree': ExtraTreesClassifier(criterion = 'entropy', n_estimators=150, max_depth=None, min_samples_split=2,min_samples_leaf=1, \n",
    "                                      max_leaf_nodes=None,oob_score=False, warm_start=True, random_state = 0, \n",
    "                                      class_weight = None)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets evaluate our level-0 classifiers using cross validation, splits = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import KFold, cross_val_score\n",
    "\n",
    "# Create the splits for cross validation\n",
    "cv = KFold(n_splits=5, shuffle=True, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating Model:  Random Forest\n",
      "Random Forest Accuracy Mean 0.8919, Std 0.0061\n",
      "Evaluating Model:  AdaBoost\n",
      "AdaBoost Accuracy Mean 0.7937, Std 0.0082\n",
      "Evaluating Model:  GBM\n",
      "      Iter       Train Loss   Remaining Time \n",
      "         1       13667.7726            5.22m\n",
      "         2        9898.4484            7.07m\n",
      "         3        7517.9394            7.55m\n",
      "         4        5743.3423            7.82m\n",
      "         5        4524.4453            8.02m\n",
      "         6        3626.1486            8.18m\n",
      "         7        2970.6414            8.29m\n",
      "         8        2425.3214            8.36m\n",
      "         9        2000.5692            8.43m\n",
      "        10        1671.6210            8.53m\n",
      "        20         448.6706            8.55m\n",
      "        30         169.9908            7.91m\n",
      "        40          69.1669            7.38m\n",
      "        50          30.9718            6.80m\n",
      "        60          15.3047            6.28m\n",
      "        70           8.3592            5.72m\n",
      "        80           5.5700            5.14m\n",
      "        90           4.3366            4.60m\n",
      "       100           3.7889            4.11m\n",
      "       200           3.4621            1.61m\n",
      "       300           3.4621           44.20s\n",
      "       400           3.4621           17.04s\n",
      "       500           3.4621            0.00s\n",
      "      Iter       Train Loss   Remaining Time \n",
      "         1       13765.8920            5.83m\n",
      "         2        9947.6859            7.08m\n",
      "         3        7563.1166            7.50m\n",
      "         4        5917.4676            7.99m\n",
      "         5        4638.6287            8.24m\n",
      "         6        3676.3965            8.39m\n",
      "         7        2987.9764            8.51m\n",
      "         8        2428.3162            8.70m\n",
      "         9        1989.5468            8.78m\n",
      "        10        1663.9253            8.82m\n",
      "        20         449.7427            8.58m\n",
      "        30         171.3001            7.92m\n",
      "        40          72.4531            7.31m\n",
      "        50          35.0744            6.78m\n",
      "        60          17.4793            6.29m\n",
      "        70           9.4732            5.85m\n",
      "        80           5.9703            5.28m\n",
      "        90           4.4610            4.74m\n",
      "       100           3.8942            4.24m\n",
      "       200           3.5233            1.66m\n",
      "       300           3.5233           45.50s\n",
      "       400           3.5233           17.53s\n",
      "       500           3.5233            0.00s\n",
      "      Iter       Train Loss   Remaining Time \n",
      "         1       13878.4736            5.65m\n",
      "         2       10096.1903            7.08m\n",
      "         3        7732.8633            7.56m\n",
      "         4        6084.0058            8.12m\n",
      "         5        4838.8930            8.33m\n",
      "         6        3881.8248            8.57m\n",
      "         7        3187.2370            8.57m\n",
      "         8        2647.2260            8.64m\n",
      "         9        2225.3935            8.79m\n",
      "        10        1867.4555            8.85m\n",
      "        20         486.0585            8.75m\n",
      "        30         196.7969            8.13m\n",
      "        40          86.5138            7.57m\n",
      "        50          37.5193            7.08m\n",
      "        60          17.3828            6.60m\n",
      "        70           9.3277            6.07m\n",
      "        80           6.2881            5.46m\n",
      "        90           4.9107            4.88m\n",
      "       100           4.0512            4.40m\n",
      "       200           3.5102            1.73m\n",
      "       300           3.5102           47.48s\n",
      "       400           3.5102           18.28s\n",
      "       500           3.5102            0.00s\n",
      "      Iter       Train Loss   Remaining Time \n",
      "         1       13960.7943            5.30m\n",
      "         2        9985.1712            7.03m\n",
      "         3        7587.3905            7.66m\n",
      "         4        5867.1460            7.97m\n",
      "         5        4645.4317            8.17m\n",
      "         6        3729.2813            8.45m\n",
      "         7        3032.7000            8.62m\n",
      "         8        2530.7934            8.85m\n",
      "         9        2104.4305            9.09m\n",
      "        10        1790.4889            9.15m\n",
      "        20         492.1876            9.03m\n",
      "        30         181.5141            8.48m\n",
      "        40          71.9755            7.91m\n",
      "        50          30.4736            7.32m\n",
      "        60          14.3278            6.77m\n",
      "        70           7.8190            6.17m\n",
      "        80           5.4486            5.51m\n",
      "        90           4.3468            4.92m\n",
      "       100           3.8522            4.39m\n",
      "       200           3.4445            1.73m\n",
      "       300           3.4445           47.34s\n",
      "       400           3.4445           18.29s\n",
      "       500           3.4445            0.00s\n",
      "      Iter       Train Loss   Remaining Time \n",
      "         1       13982.0794            6.07m\n",
      "         2       10161.7105            7.41m\n",
      "         3        7642.7425            7.99m\n",
      "         4        5939.5564            8.36m\n",
      "         5        4704.2867            8.71m\n",
      "         6        3775.5132            8.93m\n",
      "         7        3055.0408            9.18m\n",
      "         8        2517.6255            9.35m\n",
      "         9        2101.7969            9.42m\n",
      "        10        1761.6007            9.51m\n",
      "        20         449.8752            9.49m\n",
      "        30         164.7728            8.85m\n",
      "        40          69.4452            8.12m\n",
      "        50          32.1663            7.55m\n",
      "        60          14.5236            6.98m\n",
      "        70           8.0607            6.37m\n",
      "        80           5.4469            5.71m\n",
      "        90           4.2983            5.11m\n",
      "       100           3.7576            4.56m\n",
      "       200           3.4978            1.78m\n",
      "       300           3.4978           48.80s\n",
      "       400           3.4978           18.81s\n",
      "       500           3.4978            0.00s\n",
      "GBM Accuracy Mean 0.8866, Std 0.0081\n",
      "Evaluating Model:  Extra Tree\n",
      "Extra Tree Accuracy Mean 0.8978, Std 0.0056\n",
      "Best Model:  Extra Tree  Accuracy:  0.8978174603174601\n"
     ]
    }
   ],
   "source": [
    "# Evaluate the L0 classifiers. This step is only necessary when experimenting with different combination of models, \n",
    "# but when we select the final models in L0 we can skip this step for training.\n",
    "results= dict()\n",
    "for name, model in models.items():\n",
    "    print('Evaluating Model: ',name)\n",
    "    cv_results = cross_val_score(model, X, y,\n",
    "                                cv=cv, \n",
    "                                scoring='accuracy')\n",
    "    results[name] = cv_results\n",
    "    print(name, 'Accuracy Mean {0:.4f}, Std {1:.4f}'.format(\n",
    "              cv_results.mean(), cv_results.std()))\n",
    "\n",
    "accuracies= dict()\n",
    "for name, accs in results.items():\n",
    "    accuracies[name]=accs.mean()\n",
    "    \n",
    "best_model=max(accuracies, key=accuracies.get)\n",
    "print('Best Model: ',best_model,' Accuracy: ',accuracies[best_model])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classifier for Level 1 of the Stacked model\n",
    "Now we have determined the best model and its accuracy, so the next step is to create a stacked model whose L0 classifiers are the previuos models and the meta-classifier (L1 classifier) will be the best model in the Level 0 or one determined by experimentation. Finally we will test the model using prediction probabilities in L0 and adding or not the features of te datasets, we will try out both approaches.\n",
    "\n",
    "The outputs from the base models used as input to the meta-model may be real value in the case of regression, and probability values, probability like values, or class labels in the case of classification. The training data for the meta-model may also include the inputs to the base models, e.g. input elements of the training data. This can provide an additional context to the meta-model as to how to best combine the predictions from the meta-model.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "#meta_model=models[best_model]\n",
    "#meta_model=RandomForestClassifier(criterion = 'entropy',n_estimators=200, max_depth=None, min_samples_split=2, min_samples_leaf=1, \n",
    "#                                    max_leaf_nodes=None,random_state = 0)\n",
    "#meta_model=LGBMClassifier(n_estimators=20, learning_rate= 0.1, objective= 'multiclass', num_class=7, random_state= 0, \n",
    "#                           n_jobs=-1, class_weight = None)\n",
    "meta_model=XGBClassifier(n_estimator= 100, learning_rate= 0.1, max_depth= 50, objective= 'binary:logistic',random_state= 0,n_jobs=-1)\n",
    "#meta_model=LogisticRegression(max_iter=1000, n_jobs=-1, solver= 'lbfgs',multi_class = 'multinomial')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a stacked model, using the meta classifier in the cell before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mlxtend.classifier import StackingCVClassifier\n",
    "\n",
    "clfs = [m for m in models.values()]\n",
    "\n",
    "stacked_model = StackingCVClassifier(classifiers=clfs,\n",
    "                             meta_classifier=meta_model,\n",
    "                             cv=cv,\n",
    "                             use_probas=True,\n",
    "                             drop_last_proba=False,\n",
    "                             use_features_in_secondary=True,\n",
    "                             verbose=1,\n",
    "                             store_train_meta_features=True,\n",
    "                             random_state=0,\n",
    "                             n_jobs=-1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When training and experimenting with the model we apply a cross validation strategy to score and evaluate a bunch of models. When we have chosen the best approach we can skip this step and train or fit the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 classifiers...\n",
      "Fitting classifier1: randomforestclassifier (1/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   45.6s remaining:  1.1min\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   46.7s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier2: adaboostclassifier (2/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:    0.2s remaining:    0.3s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:    2.1s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier3: baggingclassifier (3/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   24.1s remaining:   36.2s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   24.6s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier4: lgbmclassifier (4/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   33.5s remaining:   50.4s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   33.7s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier5: extratreesclassifier (5/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:    6.0s remaining:    9.1s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:    6.1s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 classifiers...\n",
      "Fitting classifier1: randomforestclassifier (1/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   43.0s remaining:  1.1min\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   44.1s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier2: adaboostclassifier (2/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:    0.2s remaining:    0.3s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:    0.2s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier3: baggingclassifier (3/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   24.0s remaining:   36.0s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   24.5s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier4: lgbmclassifier (4/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   32.3s remaining:   48.4s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   33.1s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier5: extratreesclassifier (5/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:    6.0s remaining:    9.1s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:    6.3s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 classifiers...\n",
      "Fitting classifier1: randomforestclassifier (1/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   42.9s remaining:  1.1min\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   43.6s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier2: adaboostclassifier (2/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:    0.2s remaining:    0.3s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:    0.2s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier3: baggingclassifier (3/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   24.1s remaining:   36.3s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   24.6s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier4: lgbmclassifier (4/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   31.5s remaining:   47.3s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   32.0s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier5: extratreesclassifier (5/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:    5.7s remaining:    8.6s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:    6.1s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 classifiers...\n",
      "Fitting classifier1: randomforestclassifier (1/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   41.2s remaining:  1.0min\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   42.4s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier2: adaboostclassifier (2/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:    0.2s remaining:    0.3s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:    0.2s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier3: baggingclassifier (3/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   23.6s remaining:   35.4s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   24.2s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier4: lgbmclassifier (4/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   32.0s remaining:   48.0s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   32.7s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier5: extratreesclassifier (5/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:    5.9s remaining:    8.9s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:    6.2s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 classifiers...\n",
      "Fitting classifier1: randomforestclassifier (1/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   41.2s remaining:  1.0min\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   42.1s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier2: adaboostclassifier (2/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:    0.1s remaining:    0.2s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:    0.1s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier3: baggingclassifier (3/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   23.3s remaining:   35.0s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   23.8s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier4: lgbmclassifier (4/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   30.0s remaining:   45.1s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   30.5s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier5: extratreesclassifier (5/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:    6.1s remaining:    9.3s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:    6.4s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9034 (+/- 0.0079)\n"
     ]
    }
   ],
   "source": [
    "#It is time for evaluating the stacked model\n",
    "scores = cross_val_score(stacked_model, X, y, cv=cv, scoring='accuracy', verbose=0)\n",
    "\n",
    "print('Accuracy: %0.4f (+/- %0.4f)' % (scores.mean(), scores.std()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we will predict on the training and test data to get the final results "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "StackingCVClassifier(classifiers=[RandomForestClassifier(bootstrap=True,\n",
       "                                                         class_weight=None,\n",
       "                                                         criterion='entropy',\n",
       "                                                         max_depth=None,\n",
       "                                                         max_features='auto',\n",
       "                                                         max_leaf_nodes=None,\n",
       "                                                         min_impurity_decrease=0.0,\n",
       "                                                         min_impurity_split=None,\n",
       "                                                         min_samples_leaf=1,\n",
       "                                                         min_samples_split=2,\n",
       "                                                         min_weight_fraction_leaf=0.0,\n",
       "                                                         n_estimators=400,\n",
       "                                                         n_jobs=None,\n",
       "                                                         oob_score=False,\n",
       "                                                         random_state=0,\n",
       "                                                         verbose...\n",
       "                                                            min_impurity_split=None,\n",
       "                                                            min_samples_leaf=1,\n",
       "                                                            min_samples_split=2,\n",
       "                                                            min_weight_fraction_leaf=0.0,\n",
       "                                                            n_estimators=200,\n",
       "                                                            n_jobs=None,\n",
       "                                                            oob_score=False,\n",
       "                                                            random_state=0,\n",
       "                                                            verbose=0,\n",
       "                                                            warm_start=False),\n",
       "                     n_jobs=-1, pre_dispatch='2*n_jobs', random_state=0,\n",
       "                     shuffle=True, store_train_meta_features=True,\n",
       "                     stratify=True, use_clones=True,\n",
       "                     use_features_in_secondary=True, use_probas=True,\n",
       "                     verbose=1)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stacked_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we will fit or train our model and then we predict on the training and test data to get the final results "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 classifiers...\n",
      "Fitting classifier1: randomforestclassifier (1/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   56.3s remaining:  1.4min\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   56.9s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier2: adaboostclassifier (2/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:    0.2s remaining:    0.4s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:    2.1s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier3: baggingclassifier (3/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   31.0s remaining:   46.5s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   31.6s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier4: lgbmclassifier (4/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   35.7s remaining:   53.6s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   36.6s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting classifier5: extratreesclassifier (5/5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:    7.3s remaining:   11.0s\n",
      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:    7.5s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stacked Model Accuracy:  1.0\n"
     ]
    }
   ],
   "source": [
    "# Fit and predict the stacked model on both train and test data\n",
    "stacked_model.fit(X, y)\n",
    "predictions = stacked_model.predict(X)\n",
    "predictions_test = stacked_model.predict(test_ds)\n",
    "print('Stacked Model Accuracy: ',round(accuracy_score(y, predictions),4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('randomforestclassifier',\n",
       "  RandomForestClassifier(bootstrap=True, class_weight=None, criterion='entropy',\n",
       "                         max_depth=None, max_features='auto', max_leaf_nodes=None,\n",
       "                         min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                         min_samples_leaf=1, min_samples_split=2,\n",
       "                         min_weight_fraction_leaf=0.0, n_estimators=400,\n",
       "                         n_jobs=None, oob_score=False, random_state=0, verbose=0,\n",
       "                         warm_start=False)),\n",
       " ('adaboostclassifier', AdaBoostClassifier(algorithm='SAMME.R',\n",
       "                     base_estimator=DecisionTreeClassifier(class_weight=None,\n",
       "                                                           criterion='entropy',\n",
       "                                                           max_depth=None,\n",
       "                                                           max_features='auto',\n",
       "                                                           max_leaf_nodes=None,\n",
       "                                                           min_impurity_decrease=0.0,\n",
       "                                                           min_impurity_split=None,\n",
       "                                                           min_samples_leaf=1,\n",
       "                                                           min_samples_split=2,\n",
       "                                                           min_weight_fraction_leaf=0.0,\n",
       "                                                           presort=False,\n",
       "                                                           random_state=0,\n",
       "                                                           splitter='best'),\n",
       "                     learning_rate=0.2, n_estimators=400, random_state=0)),\n",
       " ('baggingclassifier',\n",
       "  BaggingClassifier(base_estimator=DecisionTreeClassifier(class_weight=None,\n",
       "                                                          criterion='entropy',\n",
       "                                                          max_depth=None,\n",
       "                                                          max_features='auto',\n",
       "                                                          max_leaf_nodes=None,\n",
       "                                                          min_impurity_decrease=0.0,\n",
       "                                                          min_impurity_split=None,\n",
       "                                                          min_samples_leaf=1,\n",
       "                                                          min_samples_split=2,\n",
       "                                                          min_weight_fraction_leaf=0.0,\n",
       "                                                          presort=False,\n",
       "                                                          random_state=0,\n",
       "                                                          splitter='best'),\n",
       "                    bootstrap=True, bootstrap_features=False, max_features=0.75,\n",
       "                    max_samples=1.0, n_estimators=300, n_jobs=-1, oob_score=False,\n",
       "                    random_state=0, verbose=0, warm_start=False)),\n",
       " ('lgbmclassifier',\n",
       "  LGBMClassifier(boosting_type='gbdt', class_weight=None, colsample_bytree=1.0,\n",
       "                 importance_type='split', learning_rate=0.1, max_depth=-1,\n",
       "                 min_child_samples=20, min_child_weight=0.001, min_split_gain=0.0,\n",
       "                 n_estimators=300, n_jobs=-1, num_class=7, num_leaves=31,\n",
       "                 objective='multiclass', random_state=0, reg_alpha=0.0,\n",
       "                 reg_lambda=0.0, silent=True, subsample=1.0,\n",
       "                 subsample_for_bin=200000, subsample_freq=0)),\n",
       " ('extratreesclassifier',\n",
       "  ExtraTreesClassifier(bootstrap=False, class_weight=None, criterion='entropy',\n",
       "                       max_depth=None, max_features='auto', max_leaf_nodes=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, n_estimators=150,\n",
       "                       n_jobs=None, oob_score=False, random_state=0, verbose=0,\n",
       "                       warm_start=True))]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stacked_model.named_classifiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save the input meta-features to L1 classifier, it can be used in another kind of model as a NN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "df= pd.DataFrame(data=stacked_model.train_meta_features_, index=X_train.index.values)\n",
    "df.to_csv(\"meta_features_L2_train.csv\", index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We need to create the meta features for the test dataset\n",
    "metaf_test = stacked_model.predict_meta_features(test_ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "#metaf.shape\n",
    "#stacked_model.meta-features\n",
    "df= pd.DataFrame(data=metaf_test, index=test.index.values)\n",
    "df.to_csv(\"meta_features_L2_test.csv\", index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate a submission file with the predictions\n",
    "\n",
    "Create the submission file with the predictions for the test dataset and then we upload the file to Kaggle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "submission = pd.DataFrame({ 'Id': test.index.values,\n",
    "                            'Cover_Type': predictions_test })\n",
    "submission.to_csv(\"submission_data.csv\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully submitted to Learn With Other Kaggle Users\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "  0%|          | 0.00/5.32M [00:00<?, ?B/s]\n",
      "  1%|1         | 80.0k/5.32M [00:00<00:07, 756kB/s]\n",
      " 42%|####2     | 2.26M/5.32M [00:00<00:03, 1.07MB/s]\n",
      " 55%|#####5    | 2.93M/5.32M [00:02<00:03, 642kB/s] \n",
      "100%|##########| 5.32M/5.32M [00:06<00:00, 924kB/s]\n"
     ]
    }
   ],
   "source": [
    "!kaggle  competitions  submit -c learn-together -f submission_data.csv -m \"FE 10-clus-dummy StoneyDummy L1:RF Ada LGBM ET BAG L2:XGB 100\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fileName                                 date                 description                                                      status    publicScore  privateScore  \n",
      "---------------------------------------  -------------------  ---------------------------------------------------------------  --------  -----------  ------------  \n",
      "submission_data.csv                      2019-10-12 18:04:49  FE 10-clus-dummy StoneyDummy L1:RF Ada LGBM ET BAG L2:XGB 100    complete  0.82377      None          \n",
      "submission_data.csv                      2019-10-12 15:48:04  FE 10-clus-dummy StoneyDummy L1:RF Ada LGBM ET BAG L2:RF 200     complete  0.82366      None          \n",
      "submission_data.csv                      2019-10-12 11:22:56  FE 10-clus-dummy with Corr L1:RF Ada LGBM ET BAG L2:RF 200       complete  0.82302      None          \n",
      "submission_data.csv                      2019-10-12 11:06:01  FE 10-clus-dummy newAspectSlope L1:RF Ada LGBM ET BAG L2:RF 200  complete  0.82302      None          \n",
      "submission_data.csv                      2019-10-12 10:47:57  FE 10-clus-dummy newAspect L1:RF Ada LGBM ET BAG L2:RF 200       complete  0.82309      None          \n",
      "submission_data.csv                      2019-10-11 11:41:07  FE 10-clus-dummy Aspect L1:RF Ada LGBM ET BAG L2:RF 200          complete  0.82126      None          \n",
      "submission_data.csv                      2019-10-10 17:52:49  FE 10-clus-dummy L1:RF Ada LGBM ET BAG L2:RF 400                 complete  0.82854      None          \n",
      "submission_data.csv                      2019-10-10 17:36:59  FE 10-clus-dummy L1:RF Ada LGBM ET BAG L2:RF                     complete  0.82862      None          \n",
      "submission_data.csv                      2019-10-09 18:18:52  FE 10-c PCA L1:RF Ada LGBM ET BAG KNN L2:RF                      complete  0.79693      None          \n",
      "Feature eng. and a simple Stacked model  2019-10-08 17:45:22  From \"Feature eng. and a simple Stacked model\" Script            complete  0.82529      None          \n",
      "Feature eng. and a simple Stacked model  2019-10-08 17:11:01  From \"Feature eng. and a simple Stacked model\" Script            complete  0.82277      None          \n",
      "Feature eng. and a simple Stacked model  2019-10-08 16:51:16  From \"Feature eng. and a simple Stacked model\" Script            complete  0.81976      None          \n",
      "Feature eng. and a simple Stacked model  2019-10-08 16:28:36  From \"Feature eng. and a simple Stacked model\" Script            complete  0.82296      None          \n",
      "Feature eng. and a simple Stacked model  2019-10-08 11:11:54  From \"Feature eng. and a simple Stacked model\" Script            complete  0.82691      None          \n",
      "Feature eng. and a simple Stacked model  2019-10-06 11:40:45  From \"Feature eng. and a simple Stacked model\" Script            complete  0.82086      None          \n",
      "Feature eng. and a simple Stacked model  2019-10-05 18:24:47  From \"Feature eng. and a simple Stacked model\" Script            complete  0.81494      None          \n",
      "Feature eng. and a simple Stacked model  2019-10-05 17:38:53  From \"Feature eng. and a simple Stacked model\" Script            complete  0.82586      None          \n",
      "roosevelt_Submit20191002105659.csv       2019-10-02 11:05:29  FE 10-c SMOTE L1:RF Ada LGBM ET BAG KNN L2:FastNN 3layers 10emb  complete  0.81332      None          \n",
      "roosevelt_Submit20190930111706.csv       2019-09-30 11:24:38  FE 10-c Meta SMOTE L1:RF Ada LGBM ET BAG KNN L2:FastNN           complete  0.81475      None          \n",
      "submission_data.csv                      2019-09-28 17:52:43  FE 10-c OSamp L1:RF Ada LGBM ET BAG KNN L2:RF                    complete  0.81675      None          \n"
     ]
    }
   ],
   "source": [
    "!kaggle competitions submissions -c learn-together -q"
   ]
  },
  {
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}