Chapter 7 - Putting Everything Together - Predicting Room Bookings.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lightgbm import LGBMRegressor,LGBMClassifier\n",
    "from sklearn.linear_model import LinearRegression,LogisticRegression,Lasso,Ridge,ElasticNet\n",
    "from xgboost import XGBRegressor,XGBClassifier\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.metrics import mean_squared_error,f1_score,precision_score,recall_score\n",
    "\n",
    "from sklearnex import patch_sklearn,unpatch_sklearn\n",
    "\n",
    "from mlxtend.feature_selection import SequentialFeatureSelector as sfs\n",
    "from sklearn.feature_selection import RFE\n",
    "\n",
    "from copy import deepcopy\n",
    "from boruta import BorutaPy\n",
    "\n",
    "from scipy.stats import f_oneway\n",
    "\n",
    "import gc\n",
    "import pickle\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "from Interaction_effect_features import get_data\n",
    "\n",
    "from MetaHeuristics import FeatureSelection\n",
    "\n",
    "# from EvolutionaryFS import GeneticAlgorithmFS\n",
    "# from SimmulatedAnnealingFS import SimulatedAnnealingFS\n",
    "# from ACO import AntColonyOptimizationFS\n",
    "# from PSOFinal import ParticleSwarmOptimizationFS\n",
    "\n",
    "import shap\n",
    "\n",
    "np.seterr(divide = 'ignore')\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\n",
    "import warnings\n",
    "# suppress warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_plot(metric,test_cost,external_cost):\n",
    "    sns.set(rc={'figure.figsize':(16,8)})\n",
    "    sns.set_context('paper', font_scale = 1.3)\n",
    "    if metric=='RMSE':\n",
    "        fig, ax = plt.subplots(1, 2)\n",
    "    else:\n",
    "        fig, ax = plt.subplots(1, 2, sharey=True)\n",
    "        \n",
    "    validation_name = [' External_Test','External_Test ',' External_Test ',' External_Test  ','  External_Test']\n",
    "\n",
    "    ax[0].bar(list(test_cost.keys()),list(test_cost.values()))\n",
    "    ax[0].set_title(metric + ' for test data and validation data')\n",
    "\n",
    "    ax[1].bar(validation_name,external_cost)\n",
    "    ax[1].set_title(metric + ' for external test data')\n",
    "    plt.show()\n",
    "\n",
    "def get_data_for_FS(data_dict,dependent_variable,features_all):\n",
    "    \n",
    "    data_dict_for_SA = {}\n",
    "    \n",
    "    x_validation = data_dict['data_validation_test'][features_all]\n",
    "    y_validation = data_dict['data_validation_test'][dependent_variable]\n",
    "\n",
    "    #for each training data\n",
    "    for data_fold_index in data_dict['fold_dict'].keys():\n",
    "        \n",
    "        for feature in features_all:\n",
    "            if feature not in data_dict['fold_dict'][data_fold_index]['fold_training'].columns:\n",
    "                print(feature,'not present')\n",
    "\n",
    "        data_dict_for_SA[data_fold_index]={'x_train':data_dict['fold_dict'][data_fold_index]['fold_training'][features_all],\n",
    "                                           'y_train':data_dict['fold_dict'][data_fold_index]['fold_training'][dependent_variable],\n",
    "                                           'x_test':data_dict['fold_dict'][data_fold_index]['fold_test'][features_all],\n",
    "                                           'y_test':data_dict['fold_dict'][data_fold_index]['fold_test'][dependent_variable]}\n",
    "    \n",
    "    \n",
    "    return data_dict_for_SA,x_validation,y_validation,features_all\n",
    "\n",
    "def last_preprocessing(data_dict,problem):\n",
    "    \n",
    "    #'HotelCancellations', 'CouponRecommendation', 'PredictRoomBooking','CarSales'\n",
    "    \n",
    "    if problem == 'PredictRoomBooking':\n",
    "        columns = ['AdjustedLeadTime_Quartile_countRankEncoded', 'CumulativeNumberOfRooms_Quartile_percentEncoded', 'CumulativeNumberOfRooms_Quartile_countRankEncoded', 'CumulativeNumberOfRooms_Quartile_MeanEncoded', 'CumulativeNumberOfRoomsSubstract_Quartile_percentEncoded', 'CumulativeNumberOfRoomsSubstract_Quartile_countRankEncoded', 'CumulativeNumberOfRoomsSubstract_Quartile_MeanEncoded', 'CumulativeNumberOfRoomsNet_Quartile_countEncoded', 'CumulativeNumberOfRoomsNet_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeNumberOfRooms_Quartile_countEncoded', 'AdjustedLeadTimeCumulativeNumberOfRooms_Quartile_percentEncoded', 'AdjustedLeadTimeCumulativeNumberOfRooms_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeNumberOfRooms_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsSubstract_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsSubstract_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsNet_Quartile_percentEncoded', 'CumulativeRevenue_Quartile_countEncoded', 'CumulativeRevenue_Quartile_percentEncoded', 'CumulativeRevenue_Quartile_countRankEncoded', 'CumulativeRevenue_Quartile_MeanEncoded', 'CumulativeRevenueSubstract_Quartile_percentEncoded', 'CumulativeRevenueSubstract_Quartile_countRankEncoded', 'CumulativeRevenueNet_Quartile_percentEncoded', 'CumulativeRevenueNet_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeRevenue_Quartile_percentEncoded', 'AdjustedLeadTimeCumulativeRevenue_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeRevenueSubstract_Quartile_countEncoded', 'AdjustedLeadTimeCumulativeRevenueSubstract_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeRevenueSubstract_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeRevenueNet_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeRevenueNet_Quartile_MeanEncoded','AdjustedLeadTime_Quartile_percentEncoded', 'CumulativeNumberOfRoomsSubstract_Quartile_countEncoded', 'CumulativeNumberOfRoomsNet_Quartile_percentEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsSubstract_Quartile_countEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsNet_Quartile_countEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsNet_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsNet_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeRevenue_Quartile_MeanEncoded', 'AdjustedLeadTimeCumulativeRevenueSubstract_Quartile_percentEncoded','AdjustedLeadTime_Quartile_countEncoded', 'CumulativeNumberOfRoomsNet_Quartile_countRankEncoded', 'AdjustedLeadTimeCumulativeNumberOfRoomsSubstract_Quartile_percentEncoded', 'CumulativeRevenueSubstract_Quartile_countEncoded', 'CumulativeRevenueSubstract_Quartile_MeanEncoded', 'CumulativeRevenueNet_Quartile_countEncoded', 'AdjustedLeadTimeCumulativeRevenueNet_Quartile_countEncoded','AdjustedLeadTime_Quartile_MeanEncoded', 'CumulativeNumberOfRooms_Quartile_countEncoded', 'CumulativeRevenueNet_Quartile_countRankEncoded','AdjustedLeadTimeCumulativeRevenue_Quartile_countEncoded', 'AdjustedLeadTimeCumulativeRevenueNet_Quartile_percentEncoded']\n",
    "    elif problem == 'HotelCancellations':\n",
    "        columns = ['LeadTime_Quartile_countEncoded','LeadTime_Quartile_percentEncoded','LeadTime_Quartile_countRankEncoded','LeadTime_Quartile_MeanEncoded','ADR_Quartile_countEncoded','ADR_Quartile_percentEncoded','ADR_Quartile_countRankEncoded','ADR_Quartile_MeanEncoded']\n",
    "    elif problem == 'CouponRecommendation':\n",
    "        columns = []\n",
    "    elif problem == 'CarSales':\n",
    "        columns = ['ownercountEncodedandkmdrivenQuartileMeanEncoded','sellertypecountEncodedandownercountEncoded','fuelcountEncodedandownerMeanEncoded','ownercountEncodedandmaxpowerQuartileMeanEncoded','ownercountEncodedandkmdrivenQuartilecountEncoded','ownercountEncodedandmileageQuartileMeanEncoded','ownercountEncodedandmileageQuartilecountEncoded','fuelcountEncodedandkmdrivenQuartileMeanEncoded','sellertypecountEncodedandmaxpowerQuartileMeanEncoded','fuelcountEncodedandmaxpowerQuartilecountEncoded','ownercountEncodedandmaxpowerQuartilecountEncoded','sellertypecountEncodedandownerMeanEncoded','fuelcountEncodedandkmdrivenQuartilecountEncoded','sellertypecountEncodedandmileageQuartileMeanEncoded','fuelcountEncodedandownercountEncoded','sellertypecountEncodedandmileageQuartilecountEncoded','sellertypecountEncodedandmaxpowerQuartilecountEncoded','fuelcountEncodedandsellertypecountEncoded','fuelcountEncodedandmileageQuartileMeanEncoded','fuelcountEncodedandmileageQuartilecountEncoded','sellertypecountEncodedandkmdrivenQuartileMeanEncoded','sellertypecountEncodedandkmdrivenQuartilecountEncoded','mileageQuartilecountEncodedandmaxpowerQuartilecountEncoded','kmdrivenQuartilecountEncodedandmileageQuartilecountEncoded','kmdrivenQuartilecountEncodedandmaxpowerQuartilecountEncoded','kmdriven_Quartile_percentEncoded','maxpower_Quartile_percentEncoded','mileage_Quartile_percentEncoded']\n",
    "    \n",
    "    if columns:\n",
    "        for feature in columns:\n",
    "            if feature in data_dict['data_external_test'].columns:\n",
    "                data_dict['data_external_test'][feature] = data_dict['data_external_test'][feature].astype(int)\n",
    "                data_dict['data_validation_test'][feature] = data_dict['data_validation_test'][feature].astype(int)\n",
    "\n",
    "                for index in data_dict['fold_dict'].keys():\n",
    "                    data_dict['fold_dict'][index]['fold_training'][feature] = data_dict['fold_dict'][index]['fold_training'][feature].astype(int)\n",
    "                    data_dict['fold_dict'][index]['fold_test'][feature] = data_dict['fold_dict'][index]['fold_test'][feature].astype(int)\n",
    "        \n",
    "    return data_dict\n",
    "\n",
    "def get_external(data_dict,features,dependent_variable):\n",
    "    x_external = data_dict['data_external_test'][features]\n",
    "    y_external = data_dict['data_external_test'][dependent_variable]\n",
    "    return x_external,y_external\n",
    "\n",
    "def cost_funct(y_true,y_pred):\n",
    "    return np.sqrt(mean_squared_error(y_true,y_pred))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_cost(current_at_feature_subset,problem_type,cost_function,data_dict,model,x_validation,y_validation,x_external,y_external,sequence):\n",
    "\n",
    "    test_cost = {}\n",
    "    external_cost = []\n",
    "    selected_features = {}\n",
    "    common_features = []\n",
    "    \n",
    "    precision_test = []\n",
    "    recall_test = []\n",
    "    precision_external = []\n",
    "    recall_external = []\n",
    "    \n",
    "    #for each fold\n",
    "    for i in data_dict.keys():\n",
    "        \n",
    "        ### - for the set of + features + dataset + model        \n",
    "        x_train=data_dict[i]['x_train'][current_at_feature_subset]\n",
    "        y_train=data_dict[i]['y_train']\n",
    "\n",
    "        x_test=data_dict[i]['x_test'][current_at_feature_subset]\n",
    "        y_test=data_dict[i]['y_test']\n",
    "\n",
    "        ### do the feature selection process\n",
    "        if sequence in ['lasso','ridge','elasticnet']:\n",
    "            output_list = deepcopy(current_at_feature_subset)\n",
    "        elif sequence in ['feature_importance']:\n",
    "            output_list = tree_importance(model,current_at_feature_subset,x_train,y_train,dependent_variable,sequence,problem_type)\n",
    "        elif sequence in ['boruta']:\n",
    "            output_list = boruta_importance(model,current_at_feature_subset,x_train,y_train,dependent_variable,sequence,problem_type)        \n",
    "        elif sequence in ['borutaLGBM']:\n",
    "            output_list = borutaLGBM_importance(model,current_at_feature_subset,x_train,y_train,dependent_variable,sequence,problem_type)        \n",
    "        elif sequence in ['beta']:            \n",
    "            output_list = filter_features_reg(model,current_at_feature_subset,x_train,y_train,dependent_variable,sequence,problem_type)\n",
    "        \n",
    "        #fit model\n",
    "        model.fit(x_train[output_list],y_train)\n",
    "        \n",
    "        ### - obtain + filtered features + cost for test + cost for validation\n",
    "        \n",
    "        #filtered features\n",
    "        selected_features[i] = output_list\n",
    "        \n",
    "        #predict for test and validation\n",
    "        y_test_predict=model.predict(x_test[output_list])\n",
    "        y_validation_predict=model.predict(x_validation[output_list])\n",
    "        \n",
    "        #predict for external test\n",
    "        y_external_predict=model.predict(x_external[output_list])\n",
    "        \n",
    "        cost1 = cost_function(y_test,y_test_predict)\n",
    "        cost2 = cost_function(y_validation,y_validation_predict)\n",
    "        cost3 = cost_function(y_external,y_external_predict)\n",
    "                \n",
    "        if problem_type != 'regression':\n",
    "                        \n",
    "            precision_test.append(np.mean([precision_score(y_test,y_test_predict),precision_score(y_validation,y_validation_predict)]))\n",
    "            recall_test.append(np.mean([recall_score(y_test,y_test_predict),recall_score(y_validation,y_validation_predict)]))\n",
    "            \n",
    "            precision_external.append(precision_score(y_external,y_external_predict))#\n",
    "            recall_external.append(recall_score(y_external,y_external_predict))\n",
    "\n",
    "        #cost for validation and external\n",
    "        #predict for test and calculate cost function\n",
    "        test_cost['CV Sample-'+str(i)] = np.mean([cost1,cost2])\n",
    "        external_cost.append(cost3)\n",
    "    #also obtain common set of features\n",
    "    common_features = list(set(selected_features[0]).intersection(set(selected_features[1])).intersection(set(selected_features[2])).intersection(set(selected_features[3])).intersection(set(selected_features[4])))\n",
    "\n",
    "    print('Total number of input features:',len(current_at_feature_subset),', total number of selected features:',len(common_features))\n",
    "    \n",
    "    if problem_type != 'regression':\n",
    "        print('Combined precision on test and validation data is',np.mean(precision_test),'combined recall on test and validation data is',np.mean(recall_test))\n",
    "        print('Precision on external test data is',np.mean(precision_external),'recall on external test data is',np.mean(recall_external))\n",
    "    else:\n",
    "        print('Combined cost on test and validation data is',np.mean(list(test_cost.values())))\n",
    "        print('Cost on external test data is',np.mean(external_cost))\n",
    "    \n",
    "    return test_cost,external_cost,selected_features,common_features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_features_reg(model,features_input,x_train,y_train,dependent_variable,sequence,problem_type):\n",
    "\n",
    "    output_list = []\n",
    "    importance_cutoff = 95\n",
    "    \n",
    "    #fit linear model\n",
    "    model.fit(x_train,y_train)\n",
    "\n",
    "    #get beta of each feature, and create df of feature and beta\n",
    "    coefficients = pd.DataFrame({\"Feature\":features_input,\"Coefficients\":np.abs(np.transpose(model.coef_).ravel())})\n",
    "\n",
    "    #cumsum of beta\n",
    "    coefficients.sort_values(by='Coefficients',inplace=True,ascending=False)\n",
    "    coefficients.reset_index(inplace=True,drop=True)\n",
    "\n",
    "    coefficients['cum_sum'] = coefficients['Coefficients'].cumsum()\n",
    "    coefficients['cum_perc'] = 100*coefficients['cum_sum']/coefficients['Coefficients'].sum()\n",
    "\n",
    "    #filter at cutoff cumsum, use for feature selection\n",
    "    output_list = list(coefficients[coefficients['cum_perc']<=importance_cutoff].Feature.values)\n",
    "    \n",
    "    return output_list\n",
    "\n",
    "def tree_importance(model,features_input,x_train,y_train,dependent_variable,sequence,problem_type):\n",
    "        \n",
    "    output_list = []\n",
    "    importance_cutoff = 90\n",
    "    model.fit(x_train[features_input],y_train)\n",
    "    feature_imp = pd.DataFrame({'Importance':model.feature_importances_,'Feature':features_input})\n",
    "    \n",
    "    feature_imp.sort_values(by='Importance',inplace=True,ascending=False)\n",
    "    feature_imp.reset_index(inplace=True,drop=True)\n",
    "    feature_imp['cum_sum'] = feature_imp['Importance'].cumsum()\n",
    "    feature_imp['cum_perc'] = 100*feature_imp['cum_sum']/feature_imp['Importance'].sum()\n",
    "    output_list = list(feature_imp[feature_imp['cum_perc'] <= importance_cutoff]['Feature'].values)\n",
    "    return output_list\n",
    "\n",
    "def boruta_importance(model,features_input,x_train,y_train,dependent_variable,sequence,problem_type):\n",
    "    \n",
    "    output_list = []    \n",
    "    boruta_fit = BorutaPy(model, n_estimators='auto', verbose=0, random_state=1)\n",
    "    boruta_fit.fit(np.array(x_train[features_input]), np.array(y_train))\n",
    "    \n",
    "    for feature,possible in zip(features_input,boruta_fit.support_):\n",
    "        if possible:\n",
    "            output_list.append(feature)\n",
    "    \n",
    "    return output_list\n",
    "\n",
    "def borutaLGBM_importance(model,features_input,x_train,y_train,dependent_variable,sequence,problem_type):\n",
    "    \n",
    "    output_list = []    \n",
    "    boruta_fit = BorutaPyForLGB(model, n_estimators='auto', verbose=0, random_state=1)\n",
    "    boruta_fit.fit(np.array(x_train[features_input]), np.array(y_train))\n",
    "    \n",
    "    for feature,possible in zip(features_input,boruta_fit.support_):\n",
    "        if possible:\n",
    "            output_list.append(feature)\n",
    "    \n",
    "    return output_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predict Room Booking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#'HotelCancellations', 'CouponRecommendation', 'PredictRoomBooking','CarSales'\n",
    "problem = 'PredictRoomBooking'\n",
    "data_dict,dependent_variable,categorical_linear,categorical_tree,categorical_features,numerical_features_linear,numerical_features_tree,ordinal_features,ordinal_features_engineered = get_data(problem)\n",
    "\n",
    "data_dict = last_preprocessing(data_dict,problem)\n",
    "\n",
    "linear_features_all = categorical_linear+numerical_features_linear+ordinal_features_engineered\n",
    "tree_features_all = categorical_tree+numerical_features_tree+ordinal_features_engineered\n",
    "\n",
    "x_external_tree,y_external_tree = get_external(data_dict,tree_features_all,dependent_variable)\n",
    "x_external_linear,y_external_linear = get_external(data_dict,linear_features_all,dependent_variable)\n",
    "\n",
    "data_dict_for_tree,x_validation_tree,y_validation_tree,features_all = get_data_for_FS(data_dict,dependent_variable,features_all=tree_features_all)\n",
    "data_dict_for_linear,x_validation_linear,y_validation_linear,features_all_linear = get_data_for_FS(data_dict,dependent_variable,features_all=linear_features_all)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lasso"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 314 , total number of selected features: 314\n",
      "Combined cost on test and validation data is 59.9985212478604\n",
      "Cost on external test data is 27.571017364482817\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#initialize model\n",
    "model_use = Lasso(random_state=1)\n",
    "\n",
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = linear_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_linear,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_linear,\n",
    "                                                                           y_validation = y_validation_linear,\n",
    "                                                                           x_external = x_external_linear,\n",
    "                                                                           y_external = y_external_linear,\n",
    "                                                                           sequence = 'lasso')\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ridge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 314 , total number of selected features: 314\n",
      "Combined cost on test and validation data is 30.149637609399782\n",
      "Cost on external test data is 25.951608163578573\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#initialize model\n",
    "model_use = Ridge(random_state=1)\n",
    "\n",
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = linear_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_linear,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_linear,\n",
    "                                                                           y_validation = y_validation_linear,\n",
    "                                                                           x_external = x_external_linear,\n",
    "                                                                           y_external = y_external_linear,\n",
    "                                                                           sequence = 'ridge')\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ElasticNet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 314 , total number of selected features: 314\n",
      "Combined cost on test and validation data is 60.14067877088409\n",
      "Cost on external test data is 27.56659885051197\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#initialize model\n",
    "model_use = ElasticNet(random_state=1)\n",
    "\n",
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = linear_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_linear,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_linear,\n",
    "                                                                           y_validation = y_validation_linear,\n",
    "                                                                           x_external = x_external_linear,\n",
    "                                                                           y_external = y_external_linear,\n",
    "                                                                           sequence = 'elasticnet')\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Regression Weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 314 , total number of selected features: 17\n",
      "Combined cost on test and validation data is 3453903703182.71\n",
      "Cost on external test data is 2928233442328.2017\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#initialize model\n",
    "model_use = LinearRegression(n_jobs=-1)\n",
    "\n",
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = linear_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_linear,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_linear,\n",
    "                                                                           y_validation = y_validation_linear,\n",
    "                                                                           x_external = x_external_linear,\n",
    "                                                                           y_external = y_external_linear,\n",
    "                                                                           sequence = 'beta')\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tree Feature Importance - LightGBM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 100 , total number of selected features: 22\n",
      "Combined cost on test and validation data is 17.294388521132202\n",
      "Cost on external test data is 12.325217421969429\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#initialize model\n",
    "model_use = LGBMRegressor(random_state=1,n_jobs=-1,n_estimators=200)\n",
    "\n",
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           sequence = 'feature_importance')\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tree Feature Importance - XGboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 100 , total number of selected features: 6\n",
      "Combined cost on test and validation data is 19.253476282857722\n",
      "Cost on external test data is 14.569420191083484\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#initialize model\n",
    "model_use = XGBRegressor(n_estimators=200,random_state=1,n_jobs=-1,tree_method = 'gpu_hist')\n",
    "\n",
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           sequence = 'feature_importance')\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boruta - RandomForest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 100 , total number of selected features: 88\n",
      "Combined cost on test and validation data is 30.338116123055602\n",
      "Cost on external test data is 10.95441916048139\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#initialize model\n",
    "model_use = RandomForestRegressor(random_state=1,n_jobs=-1,n_estimators=200)\n",
    "\n",
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           sequence = 'boruta')\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boruta - Xgboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 100 , total number of selected features: 41\n",
      "Combined cost on test and validation data is 17.29825329559428\n",
      "Cost on external test data is 13.375030365406838\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#initialize model\n",
    "model_use = XGBRegressor(n_estimators=200,random_state=1,n_jobs=-1,tree_method = 'gpu_hist')\n",
    "\n",
    "#calculate cost\n",
    "test_cost,external_cost,selected_features,common_features = calculate_cost(current_at_feature_subset = tree_features_all,\n",
    "                                                                           problem_type = 'regression',\n",
    "                                                                           cost_function = cost_funct,\n",
    "                                                                           data_dict = data_dict_for_tree,\n",
    "                                                                           model = model_use,\n",
    "                                                                           x_validation = x_validation_tree,\n",
    "                                                                           y_validation = y_validation_tree,\n",
    "                                                                           x_external = x_external_tree,\n",
    "                                                                           y_external = y_external_tree,\n",
    "                                                                           sequence = 'boruta')\n",
    "#make plot\n",
    "make_plot(metric = 'RMSE',\n",
    "          test_cost = test_cost,\n",
    "          external_cost = external_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}