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

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lightgbm import LGBMRegressor,LGBMClassifier\n",
    "from sklearn.linear_model import LinearRegression,LogisticRegression\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 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": 36,
   "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": 49,
   "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):\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",
    "        model.fit(x_train,y_train)\n",
    "        \n",
    "        ### - obtain + filtered features + cost for test + cost for validation\n",
    "        \n",
    "        #filtered features\n",
    "        selected_features[i] = current_at_feature_subset\n",
    "        \n",
    "        #predict for test and validation\n",
    "        y_test_predict=model.predict(x_test)\n",
    "        y_validation_predict=model.predict(x_validation[current_at_feature_subset])\n",
    "        \n",
    "        #predict for external test\n",
    "        y_external_predict=model.predict(x_external[current_at_feature_subset])\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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predicting Room Bookings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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": [
    "## Lightgbm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 100 , total number of selected features: 100\n",
      "Combined cost on test and validation data is 16.415305206358177\n",
      "Cost on external test data is 12.942362919015256\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",
    "\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": [
    "## Xgboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of input features: 100 , total number of selected features: 100\n",
      "Combined cost on test and validation data is 16.88360885733757\n",
      "Cost on external test data is 13.5994203178715\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",
    "\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "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 384636660.2258599\n",
      "Cost on external test data is 395991357.99182576\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",
    "\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
}