notebooks/03_categorical_pipeline_ex_02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \ud83d\udcdd Exercise M1.05\n",
    "\n",
    "The goal of this exercise is to evaluate the impact of feature preprocessing\n",
    "on a pipeline that uses a decision-tree-based classifier instead of a logistic\n",
    "regression.\n",
    "\n",
    "- The first question is to empirically evaluate whether scaling numerical\n",
    "  features is helpful or not;\n",
    "- The second question is to evaluate whether it is empirically better (both\n",
    "  from a computational and a statistical perspective) to use integer coded or\n",
    "  one-hot encoded categories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "adult_census = pd.read_csv(\"../datasets/adult-census.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target_name = \"class\"\n",
    "target = adult_census[target_name]\n",
    "data = adult_census.drop(columns=[target_name, \"education-num\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As in the previous notebooks, we use the utility `make_column_selector`\n",
    "to select only columns with a specific data type. Besides, we list in\n",
    "advance all categories for the categorical columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.compose import make_column_selector as selector\n",
    "\n",
    "numerical_columns_selector = selector(dtype_exclude=object)\n",
    "categorical_columns_selector = selector(dtype_include=object)\n",
    "numerical_columns = numerical_columns_selector(data)\n",
    "categorical_columns = categorical_columns_selector(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reference pipeline (no numerical scaling and integer-coded categories)\n",
    "\n",
    "First let's time the pipeline we used in the main notebook to serve as a\n",
    "reference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "from sklearn.model_selection import cross_validate\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.preprocessing import OrdinalEncoder\n",
    "from sklearn.ensemble import HistGradientBoostingClassifier\n",
    "\n",
    "categorical_preprocessor = OrdinalEncoder(handle_unknown=\"use_encoded_value\",\n",
    "                                          unknown_value=-1)\n",
    "preprocessor = ColumnTransformer([\n",
    "    ('categorical', categorical_preprocessor, categorical_columns)],\n",
    "    remainder=\"passthrough\")\n",
    "\n",
    "model = make_pipeline(preprocessor, HistGradientBoostingClassifier())\n",
    "\n",
    "start = time.time()\n",
    "cv_results = cross_validate(model, data, target)\n",
    "elapsed_time = time.time() - start\n",
    "\n",
    "scores = cv_results[\"test_score\"]\n",
    "\n",
    "print(\"The mean cross-validation accuracy is: \"\n",
    "      f\"{scores.mean():.3f} +/- {scores.std():.3f} \"\n",
    "      f\"with a fitting time of {elapsed_time:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scaling numerical features\n",
    "\n",
    "Let's write a similar pipeline that also scales the numerical features using\n",
    "`StandardScaler` (or similar):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your code here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## One-hot encoding of categorical variables\n",
    "\n",
    "We observed that integer coding of categorical variables can be very\n",
    "detrimental for linear models. However, it does not seem to be the case for\n",
    "`HistGradientBoostingClassifier` models, as the cross-validation score\n",
    "of the reference pipeline with `OrdinalEncoder` is reasonably good.\n",
    "\n",
    "Let's see if we can get an even better accuracy with `OneHotEncoder`.\n",
    "\n",
    "Hint: `HistGradientBoostingClassifier` does not yet support sparse input\n",
    "data. You might want to use\n",
    "`OneHotEncoder(handle_unknown=\"ignore\", sparse=False)` to force the use of a\n",
    "dense representation as a workaround."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your code here."
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "encoding": "# -*- coding: utf-8 -*-",
   "main_language": "python"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}