examples/build_and_train/build_and_train_catboost_regression_tabular_data_bar_crawl.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Build and Train Decision Trees for Regression Problems\n",
    "## Purpose\n",
    "In this example we will demonstrate how to:\n",
    "   - Build a coreset tree for regression decision trees based on a real-world dataset.\n",
    "   - Perform coreset tree vs. entire train dataset vs. random selection comparison as follows:\n",
    "      - Build a CatBoostRegressor model using the coreset tree service method.\n",
    "      - Build a CatBoostRegressor model on the entire train dataset.\n",
    "      - Build a CatBoostRegressor model on a randomly-sampled train dataset, where the sample size exactly matches coreset size.\n",
    "      - Build a CatBoostRegressor model on a randomly-sampled train dataset, where the sample size is large-enough to strive to match the quality of using the coreset from the coreset tree.\n",
    "      - Compare the quality of all four models built.\n",
    "   - Employ coreset tree's utility functions for saving, loading and plotting the coreset tree.\n",
    "\n",
    "In this example we'll be using the Bar Crawl dataset (https://archive.ics.uci.edu/ml/datasets/Bar+Crawl%3A+Detecting+Heavy+Drinking) after we’ve performed some feature engineering on the data.\n",
    "We have about 252K instances in the train set and about 28K in the test set.\n",
    "Our comparisons will utilize the mean squared error (https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html) as the evaluation metric.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T01:54:05.281939700Z",
     "start_time": "2023-12-05T01:54:05.219916200Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import warnings\n",
    "from time import time\n",
    "import pathlib\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pathlib import Path\n",
    "\n",
    "from sklearn.metrics import  mean_squared_error\n",
    "from catboost import CatBoostRegressor\n",
    "import gdown\n",
    "\n",
    "from dataheroes import CoresetTreeServiceDTR\n",
    "\n",
    "warnings.simplefilter('ignore', DeprecationWarning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T01:54:05.333956300Z",
     "start_time": "2023-12-05T01:54:05.233940Z"
    }
   },
   "outputs": [],
   "source": [
    "# Public folder on Google Drive with data.\n",
    "url = \"https://drive.google.com/drive/folders/1c49gInO2rTqerxXggEVd58EcstN304zD\"\n",
    "# create local data folder.\n",
    "data_path = pathlib.Path('data/BarCrawl')\n",
    "data_path.mkdir(parents=True, exist_ok=True)\n",
    "# Download files.\n",
    "if not os.path.exists(str(data_path / \"x_train.npy\")):\n",
    "    gdown.download_folder(url, quiet=True, use_cookies=False, output=str(data_path))\n",
    "# Load data into memory.\n",
    "x_train = np.load(str(data_path / \"x_train.npy\"), allow_pickle=True)\n",
    "x_test = np.load(str(data_path / \"x_test.npy\"), allow_pickle=True)\n",
    "y_train = np.load(str(data_path / \"y_train.npy\"))\n",
    "y_test = np.load(str(data_path / \"y_test.npy\"))\n",
    "\n",
    "# Convert to pandas dataframe.\n",
    "x_train = pd.DataFrame(x_train)\n",
    "x_test = pd.DataFrame(x_test)\n",
    "y_train = pd.DataFrame(y_train)\n",
    "y_test = pd.DataFrame(y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 1. Prepare the dataset & the testing environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T01:54:05.333956300Z",
     "start_time": "2023-12-05T01:54:05.281939700Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train size=251,707, test size=27,968\n"
     ]
    }
   ],
   "source": [
    "print(f\"train size={len(x_train):,}, test size={len(x_test):,}\")\n",
    "\n",
    "# Define the number of estimators for Catboost.\n",
    "# The higher the number of estimators, the better the results will be (but the longer the time will take).\n",
    "n_estimators = 1000  # Catboost's default.\n",
    "\n",
    "# Set the tree access level which we will be working with (default is 0=root node).\n",
    "tree_query_level = 0\n",
    "\n",
    "# Remember the number of samples for the full dataset.\n",
    "n_samples_full = len(y_train)\n",
    "\n",
    "# Define the number of samples for the comparison flavour in which a randomly-selected dataset is striving to resemble coreset dataset's quality.\n",
    "n_samples_rand_large = int(n_samples_full * 0.3)\n",
    "\n",
    "# Define method for summarizing every flavour's experimental results in one neat table.\n",
    "def produce_results(experiment_group : str,\n",
    "                    n_samp_full : int, n_samp_rand_large : int, n_samp_coreset : int,\n",
    "                    full_score : float, rand_large_score : float, rand_csize_score : float, coreset_score : float, \n",
    "                    full_secs : float, rand_large_secs : float, rand_csize_secs : float, coreset_secs : float, \n",
    "                    ):\n",
    "\n",
    "    df = pd.DataFrame(data={\n",
    "        ' ': ['Full dataset', 'Random bigger-sized sample', 'Random smaller-sized sample', 'Coreset'],\n",
    "        'Training dataset size': [n_samp_full, n_samp_rand_large, n_samp_coreset, n_samp_coreset],\n",
    "        '% of full dataset': [n_samp_full / n_samp_full, n_samp_rand_large / n_samp_full, n_samp_coreset / n_samp_full, n_samp_coreset / n_samp_full],\n",
    "        'Mean Square Error': [full_score, rand_large_score, rand_csize_score, coreset_score],\n",
    "        'Training time (sec)': [full_secs, rand_large_secs, rand_csize_secs, coreset_secs],\n",
    "    })\n",
    "    last_row = pd.IndexSlice[df.index[-1], :]\n",
    "    styles = [dict(selector=\"caption\", props=[(\"text-align\", \"center\"), (\"font-size\", \"120%\"), (\"font-weight\", \"bold\")])]\n",
    "    s  = df.style \\\n",
    "        .set_properties(subset=[' '],**{'text-align':'left'}) \\\n",
    "        .set_properties(subset=['Training dataset size','% of full dataset','Mean Square Error','Training time (sec)'],**{'text-align':'right'}) \\\n",
    "        .set_properties(subset=last_row, **{'color':'green', 'font-weight':'bold'}) \\\n",
    "        .set_caption(f\"{experiment_group} Results\") \\\n",
    "        .format({\n",
    "        'Training dataset size': '{:,}',\n",
    "        '% of full dataset': '{:.2%}',\n",
    "        'Mean Square Error': '{:.4f}',\n",
    "        'Training time (sec)': '{:.2f}'}) \\\n",
    "        .hide(axis='index') \\\n",
    "        .set_table_styles(styles)\n",
    "    return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Build and train the coreset tree\n",
    "Create a new service object and run `build` directly on the X, y train data.\n",
    "We pass `n_instances` to initialize the coreset tree.\n",
    "\n",
    "### 2.1. Build the coreset\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T01:54:10.384178600Z",
     "start_time": "2023-12-05T01:54:05.293952700Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coreset build time (sec): 5.09\n"
     ]
    }
   ],
   "source": [
    "t = time()\n",
    "service_obj = CoresetTreeServiceDTR(optimized_for='training',\n",
    "                                    n_instances=n_samples_full,\n",
    "                                    model_cls=CatBoostRegressor,\n",
    "                                    )\n",
    "# We pass copy=True so the build function won’t change X_train and y_train\n",
    "# as they’re used later on to train the model on the entire dataset and random samples.\n",
    "service_obj.build_from_df(x_train, y_train, copy=True)\n",
    "coreset_build_secs = time() - t\n",
    "print(f\"Coreset build time (sec): {coreset_build_secs:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Train a model directly on the coreset tree service object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T01:54:13.935717500Z",
     "start_time": "2023-12-05T01:54:10.388180Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using CatBoostRegressor model.\n"
     ]
    }
   ],
   "source": [
    "t = time()\n",
    "\n",
    "# Please note the direct usage of \"service_obj.fit()\".\n",
    "# Provide the same parameters to the fit method as you'd provide for the model generation and \n",
    "# for tree access (required tree level).\n",
    "service_obj.fit(level=tree_query_level,\n",
    "                n_estimators=n_estimators,\n",
    "                verbose=False,\n",
    "               )\n",
    "coreset_secs = time() - t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Train the models using traditional sampling methods\n",
    "### 3.1. Train a model on the entire dataset (for comparison)\n",
    "We use the same (entire) training part of the dataset that was used for building the coreset tree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T01:54:33.772228Z",
     "start_time": "2023-12-05T01:54:13.947717900Z"
    }
   },
   "outputs": [],
   "source": [
    "t = time()\n",
    "# Train a Catboost model on the entire data-set.\n",
    "full_model = CatBoostRegressor(n_estimators=n_estimators)\n",
    "full_model.fit(x_train, y_train, verbose=False)\n",
    "full_secs = time() - t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2. Train models on samples selected randomly from the training set\n",
    "\n",
    "### 3.2.1. Produce a randomly-selected sample matching the coreset's size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T01:54:37.140560800Z",
     "start_time": "2023-12-05T01:54:33.774226500Z"
    }
   },
   "outputs": [],
   "source": [
    "# We get the number of samples in the coreset, so we can randomly sample the same number of samples from the full dataset.\n",
    "n_samples_coreset = service_obj.get_coreset_size(tree_query_level)\n",
    "t = time()\n",
    "# Train a Catboost model on the random data-set -\n",
    "# (1) Create the model, (2) randomly sample the exact size as the coreset size, and (3) train the model.\n",
    "rand_csize_model = CatBoostRegressor(n_estimators=n_estimators)\n",
    "rand_csize_idxs = np.random.choice(n_samples_full, n_samples_coreset, replace=False)\n",
    "rand_csize_model.fit(x_train.iloc[rand_csize_idxs, :], y_train.iloc[rand_csize_idxs,:], verbose=False)\n",
    "rand_csize_secs = time() - t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.2. Produce a randomly-selected sample striving to match coreset's quality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T01:54:47.070473Z",
     "start_time": "2023-12-05T01:54:37.142560700Z"
    }
   },
   "outputs": [],
   "source": [
    "t = time()\n",
    "# Train a Catboost model on the random data-set -\n",
    "# (1) Create the model, (2) randomly sample size larger than the coreset size, and (3) train the model.\n",
    "rand_large_model = CatBoostRegressor(n_estimators=n_estimators)\n",
    "rand_large_idxs = np.random.choice(n_samples_full, n_samples_rand_large, replace=False)\n",
    "rand_large_model.fit(x_train.iloc[rand_large_idxs, :], y_train.iloc[rand_large_idxs,:], verbose=False)\n",
    "rand_large_secs = time() - t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Tree-based coreset performance comparison: coreset tree's default fit modeling approach\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1. Compare models quality\n",
    "Test coreset, random samples and full models on a test dataset, and compare their evaluation scores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T01:54:47.324468800Z",
     "start_time": "2023-12-05T01:54:47.071473900Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<pandas.io.formats.style.Styler at 0x1f32c7fc400>",
      "text/html": "<style type=\"text/css\">\n#T_69e6e caption {\n  text-align: center;\n  font-size: 120%;\n  font-weight: bold;\n}\n#T_69e6e_row0_col0, #T_69e6e_row1_col0, #T_69e6e_row2_col0 {\n  text-align: left;\n}\n#T_69e6e_row0_col1, #T_69e6e_row0_col2, #T_69e6e_row0_col3, #T_69e6e_row0_col4, #T_69e6e_row1_col1, #T_69e6e_row1_col2, #T_69e6e_row1_col3, #T_69e6e_row1_col4, #T_69e6e_row2_col1, #T_69e6e_row2_col2, #T_69e6e_row2_col3, #T_69e6e_row2_col4 {\n  text-align: right;\n}\n#T_69e6e_row3_col0 {\n  text-align: left;\n  color: green;\n  font-weight: bold;\n}\n#T_69e6e_row3_col1, #T_69e6e_row3_col2, #T_69e6e_row3_col3, #T_69e6e_row3_col4 {\n  text-align: right;\n  color: green;\n  font-weight: bold;\n}\n</style>\n<table id=\"T_69e6e\">\n  <caption>CatBoostRegressor Results</caption>\n  <thead>\n    <tr>\n      <th id=\"T_69e6e_level0_col0\" class=\"col_heading level0 col0\" > </th>\n      <th id=\"T_69e6e_level0_col1\" class=\"col_heading level0 col1\" >Training dataset size</th>\n      <th id=\"T_69e6e_level0_col2\" class=\"col_heading level0 col2\" >% of full dataset</th>\n      <th id=\"T_69e6e_level0_col3\" class=\"col_heading level0 col3\" >Mean Square Error</th>\n      <th id=\"T_69e6e_level0_col4\" class=\"col_heading level0 col4\" >Training time (sec)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td id=\"T_69e6e_row0_col0\" class=\"data row0 col0\" >Full dataset</td>\n      <td id=\"T_69e6e_row0_col1\" class=\"data row0 col1\" >251,707</td>\n      <td id=\"T_69e6e_row0_col2\" class=\"data row0 col2\" >100.00%</td>\n      <td id=\"T_69e6e_row0_col3\" class=\"data row0 col3\" >0.8727</td>\n      <td id=\"T_69e6e_row0_col4\" class=\"data row0 col4\" >19.82</td>\n    </tr>\n    <tr>\n      <td id=\"T_69e6e_row1_col0\" class=\"data row1 col0\" >Random bigger-sized sample</td>\n      <td id=\"T_69e6e_row1_col1\" class=\"data row1 col1\" >75,512</td>\n      <td id=\"T_69e6e_row1_col2\" class=\"data row1 col2\" >30.00%</td>\n      <td id=\"T_69e6e_row1_col3\" class=\"data row1 col3\" >0.8974</td>\n      <td id=\"T_69e6e_row1_col4\" class=\"data row1 col4\" >9.92</td>\n    </tr>\n    <tr>\n      <td id=\"T_69e6e_row2_col0\" class=\"data row2 col0\" >Random smaller-sized sample</td>\n      <td id=\"T_69e6e_row2_col1\" class=\"data row2 col1\" >1,196</td>\n      <td id=\"T_69e6e_row2_col2\" class=\"data row2 col2\" >0.48%</td>\n      <td id=\"T_69e6e_row2_col3\" class=\"data row2 col3\" >0.9376</td>\n      <td id=\"T_69e6e_row2_col4\" class=\"data row2 col4\" >3.26</td>\n    </tr>\n    <tr>\n      <td id=\"T_69e6e_row3_col0\" class=\"data row3 col0\" >Coreset</td>\n      <td id=\"T_69e6e_row3_col1\" class=\"data row3 col1\" >1,196</td>\n      <td id=\"T_69e6e_row3_col2\" class=\"data row3 col2\" >0.48%</td>\n      <td id=\"T_69e6e_row3_col3\" class=\"data row3 col3\" >0.5686</td>\n      <td id=\"T_69e6e_row3_col4\" class=\"data row3 col4\" >3.55</td>\n    </tr>\n  </tbody>\n</table>\n"
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Evaluate models. Please note the direct usage of \"service_obj.predict()\".\n",
    "full_score = mean_squared_error(y_test, full_model.predict(x_test))\n",
    "rand_large_score = mean_squared_error(y_test, rand_large_model.predict(x_test))\n",
    "rand_csize_score = mean_squared_error(y_test, rand_csize_model.predict(x_test))\n",
    "# Pass original data to predict, due to its built-in preprocessing.\n",
    "coreset_score = mean_squared_error(y_test, service_obj.predict(x_test, copy=True))\n",
    "produce_results(\"CatBoostRegressor\",\n",
    "                n_samples_full, n_samples_rand_large, n_samples_coreset,\n",
    "                full_score, rand_large_score, rand_csize_score, coreset_score, \n",
    "                full_secs, rand_large_secs, rand_csize_secs, coreset_secs, \n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Tree utilities\n",
    "\n",
    "### 5.1. Save the tree for future use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T01:54:47.482016200Z",
     "start_time": "2023-12-05T01:54:47.326468500Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "WindowsPath('output/train_coreset_tree')"
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out_dir = Path('output')\n",
    "out_dir.mkdir(exist_ok=True)\n",
    "save_tree_name = 'train_coreset_tree'\n",
    "service_obj.save(out_dir, save_tree_name, override=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2. Load the saved tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T01:54:47.625018600Z",
     "start_time": "2023-12-05T01:54:47.483017200Z"
    }
   },
   "outputs": [],
   "source": [
    "service_obj = CoresetTreeServiceDTR.load(out_dir, save_tree_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.3. Plot the tree\n",
    "Plot the tree to show the loading from files was properly done and to visualize the way the data is structured inside it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T01:54:48.873631400Z",
     "start_time": "2023-12-05T01:54:47.626017200Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "{'training': WindowsPath('output/training_tree_20231205_015447.png')}"
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 1600x960 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "output_dir = Path('output')\n",
    "output_dir.mkdir(exist_ok=True)\n",
    "service_obj.plot(output_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.4. Save coreset for future use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T01:54:49.409317Z",
     "start_time": "2023-12-05T01:54:48.876534600Z"
    }
   },
   "outputs": [],
   "source": [
    "final_coreset_path = os.path.join(output_dir, \"final_coreset\")\n",
    "service_obj.save_coreset(final_coreset_path)"
   ]
  }
 ],
 "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}