examples/build_and_train/build_and_train_xgboost_classification_tabular_data_pokerhand.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Build and Train Decision Trees for Classification Problems\n",
    "## Purpose\n",
    "In this example we will demonstrate how to:\n",
    "   - Build a coreset tree for classification decision trees based on a real-world multiclass dataset.\n",
    "   - Perform coreset tree vs. entire train dataset vs. random selection comparison as follows:\n",
    "      - Build an XGBClassifier model using the coreset tree service method\n",
    "      - Build an XGBClassifier model on the entire train dataset.\n",
    "      - Build an XGBClassifier model on a randomly-sampled train dataset, where the sample size exactly matches coreset size.\n",
    "      - Build an XGBClassifier 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",
    "For the example dataset, we will be using the PokerHand OpenML dataset (https://www.openml.org/search?type=data&status=active&id=155).\n",
    "The data will be split into 'train' and 'test' portions using sklearn's train/test split (80% for the train portion, 20% for the test).\n",
    "The 'train' portion will consist of roughly 663K samples, and the 'test' portion will have around 166K samples.\n",
    "Our comparisons will utilize the balanced accuracy (https://scikit-learn.org/stable/modules/generated/sklearn.metrics.balanced_accuracy_score.html) as the evaluation metric.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-16T19:17:02.722151Z",
     "start_time": "2023-06-16T19:17:01.309500Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import warnings\n",
    "from time import time\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import xgboost as xgb\n",
    "from pathlib import Path\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.datasets import fetch_openml\n",
    "from sklearn.metrics import balanced_accuracy_score\n",
    "from sklearn.preprocessing import StandardScaler, LabelEncoder, OneHotEncoder\n",
    "from xgboost import XGBClassifier\n",
    "\n",
    "from dataheroes import CoresetTreeServiceDTC\n",
    "\n",
    "warnings.simplefilter('ignore', DeprecationWarning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 1. Prepare the dataset & the testing environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-16T19:17:11.144712Z",
     "start_time": "2023-06-16T19:17:02.726654Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#classes=5, train size=663,360, test size=165,841\n"
     ]
    }
   ],
   "source": [
    "# Load PokerHand dataset as X, y (data, target) from openml.\n",
    "X, y = fetch_openml(\"pokerhand\", return_X_y=True)\n",
    "\n",
    "# Label-Encode the target. We do so because, further down the road, we will use XGBoost for\n",
    "# modeling, which requires consecutive integer labels starting from 0.\n",
    "label_enc = LabelEncoder()\n",
    "y = label_enc.fit_transform(y)\n",
    "\n",
    "# Merge 3 class labels into a single label, to make the data-set have only 5 targets.\n",
    "# (Otherwise, the smaller class is made up of only 2 samples, and the last but one - with only 11.)\n",
    "y[y > 3] = 4\n",
    "\n",
    "# Apply standard scaling on the X.\n",
    "scaler = StandardScaler()\n",
    "X = scaler.fit_transform(X)\n",
    "\n",
    "# Split to train and test.\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Remember the number of classes (5) required for the upcoming training code.\n",
    "num_classes = len(np.unique(y_train))\n",
    "print(f\"#classes={num_classes}, train size={len(X_train):,}, test size={len(X_test):,}\")\n",
    "\n",
    "# Define the number of estimators for xgboost.\n",
    "# The higher the number of estimators, the better the results will be (but the longer the time will take).\n",
    "n_estimators = 300\n",
    "\n",
    "# Set the tree access level which we will be working with (default is 0=root node).\n",
    "tree_query_level = 2\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",
    "    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",
    "        'Balanced accuracy score': [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','Balanced accuracy score','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",
    "        'Balanced accuracy score': '{:.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": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-16T19:17:26.515993Z",
     "start_time": "2023-06-16T19:17:11.148350Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coreset build time (sec): 10.41\n"
     ]
    }
   ],
   "source": [
    "t = time()\n",
    "# Define all columns as categorical, so they would be one-hot encoded by the dataheroes library.\n",
    "data_params = {\n",
    "    'categorical_features': [i for i in range(X_train.shape[1])],\n",
    "    'ohe_min_frequency': 0\n",
    "}\n",
    "service_obj = CoresetTreeServiceDTC(optimized_for='training',\n",
    "                                    n_instances=n_samples_full,\n",
    "                                    data_params=data_params\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(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": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using XGBClassifier model. To use a different model, please set the model parameter. E.g.: service_obj.fit(model=LGBMClassifier(**params), **other_params) or set the model_cls during init or use the set_model_cls function\n"
     ]
    }
   ],
   "source": [
    "t = time()\n",
    "# Ignore xgboost's warning about the requirement to pass the 'sample_weight' \n",
    "# as a keyword arg and not as a positional arg.\n",
    "warnings.filterwarnings(action='ignore', category=FutureWarning)\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",
    "                objective='multi:softmax',\n",
    "                num_class=num_classes,\n",
    "                n_estimators=n_estimators\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": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# One-hot encode all columns (not only the categorical ones).\n",
    "# We may, in fact, encode only categorical columns - but we do the inclusive encoding\n",
    "# here, since even the numeric features have small number of distinct values.\n",
    "one_hot = OneHotEncoder(sparse=False, handle_unknown='ignore')\n",
    "one_hot.fit(X_train)\n",
    "X_train = one_hot.transform(X_train)\n",
    "X_train = X_train.astype(np.int8)\n",
    "# save original X_test\n",
    "X_test_original = X_test.copy()\n",
    "# same preparation for X_test\n",
    "X_test = one_hot.transform(X_test)\n",
    "X_test = X_test.astype(np.int8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-16T19:22:36.184427Z",
     "start_time": "2023-06-16T19:19:07.864996Z"
    }
   },
   "outputs": [],
   "source": [
    "t = time()\n",
    "# Train an XGBoost model on the entire data-set.\n",
    "full_model = XGBClassifier(objective='multi:softmax',\n",
    "                                         num_class=num_classes,\n",
    "                                         n_estimators=n_estimators)\n",
    "full_model.fit(X_train, y_train)\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": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-16T19:22:50.571392Z",
     "start_time": "2023-06-16T19:22:36.181478Z"
    }
   },
   "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 an XGBoost 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 = XGBClassifier(objective='multi:softmax',\n",
    "                                               num_class=num_classes,\n",
    "                                               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[rand_csize_idxs, :], y_train[rand_csize_idxs])\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": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-16T19:24:08.929487Z",
     "start_time": "2023-06-16T19:22:50.568727Z"
    }
   },
   "outputs": [],
   "source": [
    "t = time()\n",
    "# Train an XGBoost 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 = XGBClassifier(objective='multi:softmax',\n",
    "                                               num_class=num_classes,\n",
    "                                               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[rand_large_idxs, :], y_train[rand_large_idxs])\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": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "#T_4385a caption {\n",
       "  text-align: center;\n",
       "  font-size: 120%;\n",
       "  font-weight: bold;\n",
       "}\n",
       "#T_4385a_row0_col0, #T_4385a_row1_col0, #T_4385a_row2_col0 {\n",
       "  text-align: left;\n",
       "}\n",
       "#T_4385a_row0_col1, #T_4385a_row0_col2, #T_4385a_row0_col3, #T_4385a_row0_col4, #T_4385a_row1_col1, #T_4385a_row1_col2, #T_4385a_row1_col3, #T_4385a_row1_col4, #T_4385a_row2_col1, #T_4385a_row2_col2, #T_4385a_row2_col3, #T_4385a_row2_col4 {\n",
       "  text-align: right;\n",
       "}\n",
       "#T_4385a_row3_col0 {\n",
       "  text-align: left;\n",
       "  color: green;\n",
       "  font-weight: bold;\n",
       "}\n",
       "#T_4385a_row3_col1, #T_4385a_row3_col2, #T_4385a_row3_col3, #T_4385a_row3_col4 {\n",
       "  text-align: right;\n",
       "  color: green;\n",
       "  font-weight: bold;\n",
       "}\n",
       "</style>\n",
       "<table id=\"T_4385a\">\n",
       "  <caption>XGBoostClassifier Results</caption>\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th id=\"T_4385a_level0_col0\" class=\"col_heading level0 col0\" > </th>\n",
       "      <th id=\"T_4385a_level0_col1\" class=\"col_heading level0 col1\" >Training dataset size</th>\n",
       "      <th id=\"T_4385a_level0_col2\" class=\"col_heading level0 col2\" >% of full dataset</th>\n",
       "      <th id=\"T_4385a_level0_col3\" class=\"col_heading level0 col3\" >Balanced accuracy score</th>\n",
       "      <th id=\"T_4385a_level0_col4\" class=\"col_heading level0 col4\" >Training time (sec)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td id=\"T_4385a_row0_col0\" class=\"data row0 col0\" >Full dataset</td>\n",
       "      <td id=\"T_4385a_row0_col1\" class=\"data row0 col1\" >663,360</td>\n",
       "      <td id=\"T_4385a_row0_col2\" class=\"data row0 col2\" >100.00%</td>\n",
       "      <td id=\"T_4385a_row0_col3\" class=\"data row0 col3\" >0.9990</td>\n",
       "      <td id=\"T_4385a_row0_col4\" class=\"data row0 col4\" >31.39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td id=\"T_4385a_row1_col0\" class=\"data row1 col0\" >Random bigger-sized sample</td>\n",
       "      <td id=\"T_4385a_row1_col1\" class=\"data row1 col1\" >199,008</td>\n",
       "      <td id=\"T_4385a_row1_col2\" class=\"data row1 col2\" >30.00%</td>\n",
       "      <td id=\"T_4385a_row1_col3\" class=\"data row1 col3\" >0.9879</td>\n",
       "      <td id=\"T_4385a_row1_col4\" class=\"data row1 col4\" >10.09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td id=\"T_4385a_row2_col0\" class=\"data row2 col0\" >Random smaller-sized sample</td>\n",
       "      <td id=\"T_4385a_row2_col1\" class=\"data row2 col1\" >8,993</td>\n",
       "      <td id=\"T_4385a_row2_col2\" class=\"data row2 col2\" >1.36%</td>\n",
       "      <td id=\"T_4385a_row2_col3\" class=\"data row2 col3\" >0.7508</td>\n",
       "      <td id=\"T_4385a_row2_col4\" class=\"data row2 col4\" >0.94</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td id=\"T_4385a_row3_col0\" class=\"data row3 col0\" >Coreset</td>\n",
       "      <td id=\"T_4385a_row3_col1\" class=\"data row3 col1\" >8,993</td>\n",
       "      <td id=\"T_4385a_row3_col2\" class=\"data row3 col2\" >1.36%</td>\n",
       "      <td id=\"T_4385a_row3_col3\" class=\"data row3 col3\" >0.9930</td>\n",
       "      <td id=\"T_4385a_row3_col4\" class=\"data row3 col4\" >1.18</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x1eb03e29eb0>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Evaluate models. Please note the direct usage of \"service_obj.predict()\".\n",
    "full_score = balanced_accuracy_score(y_test, full_model.predict(X_test))\n",
    "rand_large_score = balanced_accuracy_score(y_test, rand_large_model.predict(X_test))\n",
    "rand_csize_score = balanced_accuracy_score(y_test, rand_csize_model.predict(X_test))\n",
    "# pass original data to predict, due to its build-in preprocessing\n",
    "coreset_score = balanced_accuracy_score(y_test, service_obj.predict(X_test_original, copy=True))\n",
    "produce_results(\"XGBoostClassifier\",\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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Tree utilities\n",
    "\n",
    "### 5.1. Save the tree for future use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "WindowsPath('output/train_coreset_tree')"
      ]
     },
     "execution_count": 10,
     "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": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "service_obj = CoresetTreeServiceDTC.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": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'training': WindowsPath('output/training_tree_20231128_080040.png')}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x960 with 1 Axes>"
      ]
     },
     "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": 13,
   "metadata": {},
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}