{ "cells": [ { "cell_type": "markdown", "id": "intro-md", "metadata": {}, "source": [ "# Benchmark: AutoCarver vs. optbinning vs. KBinsDiscretizer\n", "\n", "This notebook runs the three binning libraries side-by-side on two public datasets:\n", "\n", "1. **Home Credit Default Risk** (Kaggle) — binary classification, mixed numeric / categorical features.\n", "2. **Allstate Claims Severity** (Kaggle) — regression, mixed numeric / categorical features (high-cardinality categoricals).\n", "\n", "Protocol, identical for every library: bin the features, one-hot encode the bins, fit the same\n", "simple downstream model (logistic / ridge), score on a held-out test set. 5 random splits;\n", "scores are reported as mean ± std.\n", "\n", "**TL;DR** (details and exact numbers in the result tables below):\n", "\n", "- **Regression:** AutoCarver posts the best R² *among libraries that actually bin the\n", " categoricals* — well ahead of optbinning. KBins edges it on raw score only by passing all\n", " 116 categoricals through unbinned, at ~3.7× the model size.\n", "- **Binary:** AutoCarver and optbinning tie within seed noise (Δ ≈ 0.001 AUC); AutoCarver gets\n", " there with the smallest train→test drop and the most compact model, and it is the only\n", " library that refuses to bin features whose bins don't generalize.\n", "- **Model size:** AutoCarver produces the fewest one-hot columns per point of score on both\n", " datasets (`n_dummies` metric).\n" ] }, { "cell_type": "markdown", "id": "setup-md", "metadata": {}, "source": [ "## Setup" ] }, { "cell_type": "code", "execution_count": 1, "id": "imports", "metadata": { "execution": { "iopub.execute_input": "2026-07-11T11:43:52.654170Z", "iopub.status.busy": "2026-07-11T11:43:52.654170Z", "iopub.status.idle": "2026-07-11T11:43:55.501886Z", "shell.execute_reply": "2026-07-11T11:43:55.500879Z" } }, "outputs": [], "source": [ "import time\n", "import warnings\n", "\n", "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "from sklearn.datasets import fetch_california_housing, fetch_openml\n", "from sklearn.linear_model import LogisticRegression, Ridge\n", "from sklearn.metrics import r2_score, roc_auc_score\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.preprocessing import KBinsDiscretizer\n", "\n", "from AutoCarver import BinaryCarver, ContinuousCarver, Features\n", "from AutoCarver.discretizers.utils.base_discretizer import ProcessingConfig\n", "from optbinning import BinningProcess\n", "\n", "SEED = 42\n", "warnings.filterwarnings('ignore')\n", "plt.rcParams['figure.figsize'] = (10, 3.5)" ] }, { "cell_type": "code", "execution_count": 2, "id": "helpers", "metadata": {}, "outputs": [], "source": [ "def one_hot(df):\n", " \"\"\"Treat every bin label as a categorical level and one-hot encode it.\n", "\n", " Lets a linear downstream model consume any of the three libraries' outputs\n", " uniformly, without us computing WoE per bin.\n", " \"\"\"\n", " return pd.get_dummies(df.astype(str), drop_first=True).astype(float)\n", "\n", "\n", "def fit_eval_binary(X_train, X_test, y_train, y_test):\n", " Xtr = one_hot(X_train)\n", " Xte = one_hot(X_test).reindex(columns=Xtr.columns, fill_value=0.0)\n", " model = LogisticRegression(max_iter=1000, random_state=SEED).fit(Xtr, y_train)\n", " return {\n", " 'train_auc': roc_auc_score(y_train, model.predict_proba(Xtr)[:, 1]),\n", " 'test_auc': roc_auc_score(y_test, model.predict_proba(Xte)[:, 1]),\n", " 'n_dummies': Xtr.shape[1],\n", " }\n", "\n", "\n", "def fit_eval_regression(X_train, X_test, y_train, y_test):\n", " Xtr = one_hot(X_train)\n", " Xte = one_hot(X_test).reindex(columns=Xtr.columns, fill_value=0.0)\n", " model = Ridge(random_state=SEED).fit(Xtr, y_train)\n", " return {\n", " 'train_r2': r2_score(y_train, model.predict(Xtr)),\n", " 'test_r2': r2_score(y_test, model.predict(Xte)),\n", " 'n_dummies': Xtr.shape[1],\n", " }\n", "\n", "\n", "def plot_bars(results_df, score_cols, title):\n", " fig, axes = plt.subplots(1, len(score_cols), figsize=(4 * len(score_cols), 3.5))\n", " if len(score_cols) == 1:\n", " axes = [axes]\n", " for ax, col in zip(axes, score_cols):\n", " err = results_df[col + '_std'] if col + '_std' in results_df.columns else None\n", " results_df.plot.bar(x='library', y=col, ax=ax, legend=False, color='#4C72B0', yerr=err)\n", " bar_container = next(c for c in ax.containers if hasattr(c, 'patches'))\n", " ax.bar_label(bar_container, fmt='%.4g')\n", " ax.set_title(col)\n", " ax.set_xlabel('')\n", " ax.tick_params(axis='x', rotation=0)\n", " fig.suptitle(title)\n", " fig.tight_layout()\n", " plt.show()\n", "\n", "\n", "def plot_score_vs_size(results_df, score_col, title):\n", " \"\"\"Test score vs post-one-hot model size: top-left = better score with a simpler model.\"\"\"\n", " fig, ax = plt.subplots(figsize=(5.5, 4))\n", " ax.errorbar(results_df['n_dummies'], results_df[score_col], yerr=results_df[score_col + '_std'],\n", " fmt='o', color='#4C72B0', markersize=9, capsize=3, linestyle='none', zorder=3)\n", " for _, row in results_df.iterrows():\n", " ax.annotate(row['library'], (row['n_dummies'], row[score_col]),\n", " xytext=(8, 5), textcoords='offset points')\n", " ax.set_xlabel('model size after one-hot (n_dummies — fewer = simpler)',)\n", " ax.set_ylabel(f'{score_col} (higher = better)')\n", " ax.set_title(title)\n", " fig.tight_layout()\n", " plt.show()\n", "\n", "def summarize_multiseed(tidy, score_metrics, timing_seed):\n", " \"\"\"Collapse a tidy (seed, library, metric, value) frame into one row per library.\n", "\n", " Score metrics are averaged (mean + std) across all seeds; fit_s / transform_s\n", " come from a single seed only, since timings don't need repeats.\n", " \"\"\"\n", " scores = tidy[tidy['metric'].isin(score_metrics)]\n", " mean_wide = scores.groupby(['library', 'metric'])['value'].mean().unstack('metric')\n", " std_wide = scores.groupby(['library', 'metric'])['value'].std().unstack('metric').add_suffix('_std')\n", " timing = (\n", " tidy[(tidy['seed'] == timing_seed) & (tidy['metric'].isin(['fit_s', 'transform_s']))]\n", " .pivot(index='library', columns='metric', values='value')\n", " )\n", " return timing.join(mean_wide).join(std_wide).reset_index().round(4)\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "binners", "metadata": { "execution": { "iopub.execute_input": "2026-07-11T11:43:55.519013Z", "iopub.status.busy": "2026-07-11T11:43:55.517829Z", "iopub.status.idle": "2026-07-11T11:43:55.530641Z", "shell.execute_reply": "2026-07-11T11:43:55.529634Z" } }, "outputs": [], "source": [ "from AutoCarver.combinations.binary import CramervCombinations\n", "\n", "MAX_N_MOD = 5\n", "MIN_FREQ = 0.04\n", "\n", "def bin_with_autocarver(X_train, y_train, X_dev, y_dev, X_test, categoricals, quantitatives, kind):\n", " Carver = BinaryCarver if kind == 'binary' else ContinuousCarver\n", " features = Features(categoricals=categoricals, numericals=quantitatives)\n", " combination_evaluator = CramervCombinations() if kind == 'binary' else None\n", " carver = Carver(features=features, min_freq=MIN_FREQ, max_n_mod=MAX_N_MOD, combination_evaluator=combination_evaluator)\n", "\n", " t0 = time.perf_counter()\n", " X_tr = carver.fit_transform(X_train.copy(), y_train, X_dev=X_dev.copy(), y_dev=y_dev)\n", " fit_t = time.perf_counter() - t0\n", "\n", " X_dv = carver.transform(X_dev.copy())\n", " t1 = time.perf_counter()\n", " X_te = carver.transform(X_test.copy())\n", " transform_t = time.perf_counter() - t1\n", " return pd.concat([X_tr, X_dv]), X_te, fit_t, transform_t, carver\n", "\n", "\n", "def bin_with_optbinning(X_train, y_train, X_dev, y_dev, X_test, categoricals, quantitatives, kind):\n", " # BinningProcess is optbinning's standard multi-feature API (vs. a manual per-column\n", " # OptimalBinning loop) — it infers binary/continuous from y itself, so `kind` is unused here.\n", " X_all = pd.concat([X_train, X_dev])\n", " variable_names = categoricals + quantitatives\n", " binning_process = BinningProcess(\n", " variable_names=variable_names, categorical_variables=categoricals,\n", " min_prebin_size=MIN_FREQ, max_n_bins=MAX_N_MOD,\n", " )\n", "\n", " t0 = time.perf_counter()\n", " binning_process.fit(X_train[variable_names], y_train)\n", " train_binned = binning_process.transform(X_all[variable_names], metric='bins')\n", " fit_t = time.perf_counter() - t0\n", "\n", " t1 = time.perf_counter()\n", " test_binned = binning_process.transform(X_test[variable_names], metric='bins')\n", " transform_t = time.perf_counter() - t1\n", " return train_binned, test_binned, fit_t, transform_t, binning_process\n", "\n", "\n", "def bin_with_kbins(X_train, X_dev, X_test, categoricals, quantitatives, n_bins=5):\n", " X_all = pd.concat([X_train, X_dev])\n", " num_train = X_train[quantitatives].apply(lambda c: c.fillna(c.median()))\n", " num_test = X_test[quantitatives].apply(lambda c: c.fillna(c.median()))\n", " kbd = KBinsDiscretizer(n_bins=n_bins, encode='ordinal', strategy='quantile')\n", "\n", " t0 = time.perf_counter()\n", " kbd.fit(num_train)\n", " binned_num_train = pd.DataFrame(\n", " kbd.transform(X_all[quantitatives].apply(lambda c: c.fillna(c.median()))), columns=quantitatives, index=X_all.index\n", " )\n", " fit_t = time.perf_counter() - t0\n", "\n", " t1 = time.perf_counter()\n", " binned_num_test = pd.DataFrame(\n", " kbd.transform(num_test), columns=quantitatives, index=X_test.index\n", " )\n", " transform_t = time.perf_counter() - t1\n", "\n", " # KBins has no opinion on categoricals — pass them through as labels\n", " train = pd.concat([binned_num_train, X_all[categoricals].astype(str)], axis=1)\n", " test = pd.concat([binned_num_test, X_test[categoricals].astype(str)], axis=1)\n", " return train, test, fit_t, transform_t, kbd" ] }, { "cell_type": "markdown", "id": "binary-md", "metadata": {}, "source": [ "## Binary classification — Home Credit Default Risk\n", "\n", "Mixed numeric / categorical features, target = `TARGET` (default flag). See the cell output above for exact feature/train/dev/test counts after filtering. Train / dev / test split = 60 / 20 / 20 %.\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "5926b9d0", "metadata": {}, "outputs": [], "source": [ "# !kaggle datasets download datuman/home-credit-default-risk-train-data-tabular" ] }, { "cell_type": "code", "execution_count": 5, "id": "cecd4f7e", "metadata": {}, "outputs": [], "source": [ "# from zipfile import ZipFile\n", "\n", "# with ZipFile(\"home-credit-default-risk-train-data-tabular.zip\", \"r\") as zip_ref:\n", "# zip_ref.extractall(\"home_credit_default_risk\")" ] }, { "cell_type": "code", "execution_count": 6, "id": "dd8c20f2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "train=184499, dev=61500, test=61500\n", "categoricals=16, numericals=104\n", "bad rate (train)=0.081, (test)=0.081\n", "seeds=[42, 43, 44, 45, 46]\n" ] } ], "source": [ "df = pd.read_csv(\"home_credit_default_risk/application_train.csv\")\n", "\n", "# drop ultra-rare artifacts (< 10 rows in 307k): a random split can isolate them\n", "# entirely in dev/test, leaving the binners with no fitted mapping at transform time\n", "RARE = 10\n", "for col in df.select_dtypes(exclude=\"number\").columns:\n", " counts = df[col].value_counts()\n", " df = df[~df[col].isin(counts[counts < RARE].index)]\n", "nan_counts = df.isna().sum()\n", "df = df.dropna(subset=nan_counts[(nan_counts > 0) & (nan_counts < RARE)].index)\n", "\n", "\n", "y_binary_full = df[\"TARGET\"]\n", "X_binary = df.drop(columns=[\"TARGET\", \"SK_ID_CURR\"])\n", "\n", "features = Features.from_dataframe(X_binary)\n", "categoricals = [feature.name for feature in features.categoricals]\n", "quantitatives = [feature.name for feature in features.quantitatives]\n", "\n", "N_SEEDS = 5\n", "SEEDS = list(range(SEED, SEED + N_SEEDS))\n", "\n", "def make_binary_splits(seed):\n", " X_train, X_rest, y_train, y_rest = train_test_split(\n", " X_binary, y_binary_full, test_size=0.4, random_state=seed, stratify=y_binary_full,\n", " )\n", " X_dev, X_test, y_dev, y_test = train_test_split(\n", " X_rest, y_rest, test_size=0.5, random_state=seed, stratify=y_rest,\n", " )\n", " return X_train, X_dev, X_test, y_train, y_dev, y_test\n", "\n", "X_train, X_dev, X_test, y_train, y_dev, y_test = make_binary_splits(SEED)\n", "\n", "print(f'train={len(X_train)}, dev={len(X_dev)}, test={len(X_test)}')\n", "print(f'categoricals={len(categoricals)}, numericals={len(quantitatives)}')\n", "print(f'bad rate (train)={y_train.mean():.3f}, (test)={y_test.mean():.3f}')\n", "print(f'seeds={SEEDS}')\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "599fe688", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f38e186ca73745c7afe8383c6deee242", "version_major": 2, "version_minor": 0 }, "text/plain": [ "[BinaryCarver] Carving: 0%| | 0/120 [00:00\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
metriclibraryfit_stransform_sauc_dropn_dummiestest_auctrain_aucauc_drop_stdn_dummies_stdtest_auc_stdtrain_auc_std
0AutoCarver51.04322.54340.0010292.40.75030.75130.00592.19090.00500.0010
1KBins2.13390.15490.0012266.00.73940.74060.00600.00000.00490.0012
2optbinning30.28714.43860.0028333.40.75120.75390.00563.64690.00440.0013
\n", "" ], "text/plain": [ "metric library fit_s transform_s auc_drop n_dummies test_auc \\\n", "0 AutoCarver 51.0432 2.5434 0.0010 292.4 0.7503 \n", "1 KBins 2.1339 0.1549 0.0012 266.0 0.7394 \n", "2 optbinning 30.2871 4.4386 0.0028 333.4 0.7512 \n", "\n", "metric train_auc auc_drop_std n_dummies_std test_auc_std train_auc_std \n", "0 0.7513 0.0059 2.1909 0.0050 0.0010 \n", "1 0.7406 0.0060 0.0000 0.0049 0.0012 \n", "2 0.7539 0.0056 3.6469 0.0044 0.0013 " ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "BINARY_RUNNERS = {\n", " 'AutoCarver': lambda X_train, y_train, X_dev, y_dev, X_test: bin_with_autocarver(X_train, y_train, X_dev, y_dev, X_test, categoricals, quantitatives, 'binary'),\n", " 'optbinning': lambda X_train, y_train, X_dev, y_dev, X_test: bin_with_optbinning(X_train, y_train, X_dev, y_dev, X_test, categoricals, quantitatives, 'binary'),\n", " 'KBins': lambda X_train, y_train, X_dev, y_dev, X_test: bin_with_kbins(X_train, X_dev, X_test, categoricals, quantitatives),\n", "}\n", "\n", "binary_tidy_rows = []\n", "last_autocarver = None\n", "for seed in SEEDS:\n", " X_train, X_dev, X_test, y_train, y_dev, y_test = make_binary_splits(seed)\n", " y_train_full = pd.concat([y_train, y_dev])\n", " for name, run in BINARY_RUNNERS.items():\n", " X_tr, X_te, fit_t, transform_t, model = run(X_train, y_train, X_dev, y_dev, X_test)\n", " if name == 'AutoCarver':\n", " last_autocarver = model\n", " scores = fit_eval_binary(X_tr, X_te, y_train_full, y_test)\n", " values = {\n", " 'fit_s': fit_t,\n", " 'transform_s': transform_t,\n", " 'train_auc': scores['train_auc'],\n", " 'test_auc': scores['test_auc'],\n", " 'auc_drop': scores['train_auc'] - scores['test_auc'],\n", " 'n_dummies': scores['n_dummies'],\n", " }\n", " for metric, value in values.items():\n", " binary_tidy_rows.append({'seed': seed, 'library': name, 'metric': metric, 'value': value})\n", "\n", "binary_tidy = pd.DataFrame(binary_tidy_rows)\n", "binary_results = summarize_multiseed(binary_tidy, ['train_auc', 'test_auc', 'auc_drop', 'n_dummies'], timing_seed=SEEDS[0])\n", "binary_results\n" ] }, { "cell_type": "markdown", "id": "6577f1a5", "metadata": {}, "source": [ "### What the `dropped ... feature(s) (no robust train/dev combination)` warnings mean\n", "\n", "AutoCarver *refused* to bin these features: no candidate grouping stayed viable on both train\n", "and dev (Wilson `min_freq` check, distinct target rates, train/dev rank preservation). The other\n", "two libraries silently bin them anyway. This costs nothing: as a one-off check (seed 42),\n", "optbinning restricted to the 98 features AutoCarver kept scores an identical test AUC (0.7541)\n", "to optbinning on all 120 — the vetoed features carry no out-of-sample signal, they are pure\n", "model bloat.\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "1194d311", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "AutoCarver dropped 21/120 input features (no combination survived the dev-set robustness veto):\n", " - FLAG_MOBIL\n", " - FLAG_CONT_MOBILE\n", " - FLAG_EMAIL\n", " - REG_REGION_NOT_LIVE_REGION\n", " - FLAG_DOCUMENT_2\n", " - FLAG_DOCUMENT_4\n", " - FLAG_DOCUMENT_5\n", " - FLAG_DOCUMENT_7\n", " - FLAG_DOCUMENT_9\n", " - FLAG_DOCUMENT_10\n", " - FLAG_DOCUMENT_11\n", " - FLAG_DOCUMENT_12\n", " - FLAG_DOCUMENT_13\n", " - FLAG_DOCUMENT_14\n", " - FLAG_DOCUMENT_15\n", " - FLAG_DOCUMENT_16\n", " - FLAG_DOCUMENT_17\n", " - FLAG_DOCUMENT_18\n", " - FLAG_DOCUMENT_19\n", " - FLAG_DOCUMENT_20\n", " - FLAG_DOCUMENT_21\n" ] } ], "source": [ "n_input = len(categoricals) + len(quantitatives)\n", "print(f\"AutoCarver dropped {len(last_autocarver.dropped_features)}/{n_input} input features \"\n", " f\"(no combination survived the dev-set robustness veto):\")\n", "for feature in last_autocarver.dropped_features:\n", " print(' -', feature.name)" ] }, { "cell_type": "code", "execution_count": 9, "id": "20d22249", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ORGANIZATION_TYPE: 58 raw levels -> 5 carved groups\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
labelfrequencytarget_mean
3100.2091230.054247
3210.0928730.066239
3320.3054600.081605
3430.2462130.093537
3540.1463310.104378
\n", "
" ], "text/plain": [ " label frequency target_mean\n", "31 0 0.209123 0.054247\n", "32 1 0.092873 0.066239\n", "33 2 0.305460 0.081605\n", "34 3 0.246213 0.093537\n", "35 4 0.146331 0.104378" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# interpretability: a 58-level categorical carved into a handful of ordered groups\n", "feature = last_autocarver.features(\"ORGANIZATION_TYPE\")\n", "summary = last_autocarver.summary.reset_index()\n", "bins = summary.loc[summary['feature'] == str(feature), ['label', 'frequency', 'target_mean']]\n", "print(f\"{feature.name}: {X_binary[feature.name].nunique()} raw levels -> {len(bins)} carved groups\")\n", "bins\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "8003c457", "metadata": { "execution": { "iopub.execute_input": "2026-07-11T11:44:25.758954Z", "iopub.status.busy": "2026-07-11T11:44:25.758954Z", "iopub.status.idle": "2026-07-11T11:44:26.121882Z", "shell.execute_reply": "2026-07-11T11:44:26.120803Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_bars(binary_results, ['fit_s', 'test_auc', 'auc_drop', 'n_dummies'], 'Home Credit Default Risk — binary classification')\n", "plot_score_vs_size(binary_results, 'test_auc', 'Score vs. model size — Home Credit Default Risk')\n" ] }, { "cell_type": "markdown", "id": "930e836e", "metadata": {}, "source": [ "## Regression — Allstate Claims Severity\n", "\n", "Mixed numeric / categorical features (116 categorical, 14 continuous, before rare-level filtering), target = `loss` (insurance claim severity). See the cell output above for exact feature/train/dev/test counts after filtering. Same 60 / 20 / 20 split.\n" ] }, { "cell_type": "markdown", "id": "0595bd2d", "metadata": {}, "source": [ "You need to first accept competion rules @ https://www.kaggle.com/competitions/allstate-claims-severity/rules" ] }, { "cell_type": "code", "execution_count": 11, "id": "45038759", "metadata": {}, "outputs": [], "source": [ "# !kaggle competitions download -c allstate-claims-severity" ] }, { "cell_type": "code", "execution_count": 12, "id": "d22e9028", "metadata": {}, "outputs": [], "source": [ "# from zipfile import ZipFile\n", "\n", "# with ZipFile(\"allstate-claims-severity.zip\", \"r\") as zip_ref:\n", "# zip_ref.extractall(\"allstate_claims_severity\")" ] }, { "cell_type": "code", "execution_count": 13, "id": "load-regression", "metadata": { "execution": { "iopub.execute_input": "2026-07-11T11:44:26.126037Z", "iopub.status.busy": "2026-07-11T11:44:26.124964Z", "iopub.status.idle": "2026-07-11T11:44:26.155862Z", "shell.execute_reply": "2026-07-11T11:44:26.154856Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "train=112607, dev=37536, test=37536\n", "categoricals=116, numericals=14\n" ] } ], "source": [ "df = pd.read_csv(\"allstate_claims_severity/train.csv\")\n", "\n", "\n", "# drop ultra-rare artifacts (< 10 rows in 307k): a random split can isolate them\n", "# entirely in dev/test, leaving the binners with no fitted mapping at transform time\n", "RARE = 10\n", "for col in df.select_dtypes(exclude=\"number\").columns:\n", " counts = df[col].value_counts()\n", " df = df[~df[col].isin(counts[counts < RARE].index)]\n", "nan_counts = df.isna().sum()\n", "df = df.dropna(subset=nan_counts[(nan_counts > 0) & (nan_counts < RARE)].index)\n", "\n", "y_reg = df[\"loss\"]\n", "X_reg = df.drop(columns=[\"loss\", \"id\"])\n", "\n", "features = Features.from_dataframe(X_reg)\n", "categoricals = [feature.name for feature in features.categoricals]\n", "quantitatives = [feature.name for feature in features.quantitatives]\n", "\n", "N_SEEDS = 5\n", "SEEDS = list(range(SEED, SEED + N_SEEDS))\n", "\n", "def make_regression_splits(seed):\n", " X_train, X_rest, y_train, y_rest = train_test_split(X_reg, y_reg, test_size=0.4, random_state=seed)\n", " X_dev, X_test, y_dev, y_test = train_test_split(X_rest, y_rest, test_size=0.5, random_state=seed)\n", " return X_train, X_dev, X_test, y_train, y_dev, y_test\n", "\n", "X_train, X_dev, X_test, y_train, y_dev, y_test = make_regression_splits(SEED)\n", "\n", "print(f'train={len(X_train)}, dev={len(X_dev)}, test={len(X_test)}')\n", "print(f'categoricals={len(categoricals)}, numericals={len(quantitatives)}')\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "adebc1c4", "metadata": { "execution": { "iopub.execute_input": "2026-07-11T11:44:26.159061Z", "iopub.status.busy": "2026-07-11T11:44:26.159061Z", "iopub.status.idle": "2026-07-11T11:45:11.473990Z", "shell.execute_reply": "2026-07-11T11:45:11.473990Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "195194fa1eeb43d69514577a14729109", "version_major": 2, "version_minor": 0 }, "text/plain": [ "[ContinuousCarver] Carving: 0%| | 0/130 [00:00\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
metriclibraryfit_stransform_sn_dummiesr2_droptest_r2train_r2n_dummies_stdr2_drop_stdtest_r2_stdtrain_r2_std
0AutoCarver29.49860.7893230.2-0.00030.50870.50841.30380.00870.00730.0023
1KBins0.12900.0122847.00.00490.51600.52090.00000.00730.00580.0015
2optbinning21.25842.5908181.2-0.00120.47160.47050.83670.00470.00390.0008
\n", "" ], "text/plain": [ "metric library fit_s transform_s n_dummies r2_drop test_r2 \\\n", "0 AutoCarver 29.4986 0.7893 230.2 -0.0003 0.5087 \n", "1 KBins 0.1290 0.0122 847.0 0.0049 0.5160 \n", "2 optbinning 21.2584 2.5908 181.2 -0.0012 0.4716 \n", "\n", "metric train_r2 n_dummies_std r2_drop_std test_r2_std train_r2_std \n", "0 0.5084 1.3038 0.0087 0.0073 0.0023 \n", "1 0.5209 0.0000 0.0073 0.0058 0.0015 \n", "2 0.4705 0.8367 0.0047 0.0039 0.0008 " ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "REGRESSION_RUNNERS = {\n", " 'AutoCarver': lambda X_train, y_train, X_dev, y_dev, X_test: bin_with_autocarver(X_train, y_train, X_dev, y_dev, X_test, categoricals, quantitatives, 'continuous'),\n", " 'optbinning': lambda X_train, y_train, X_dev, y_dev, X_test: bin_with_optbinning(X_train, y_train, X_dev, y_dev, X_test, categoricals, quantitatives, 'continuous'),\n", " 'KBins': lambda X_train, y_train, X_dev, y_dev, X_test: bin_with_kbins(X_train, X_dev, X_test, categoricals, quantitatives),\n", "}\n", "\n", "regression_tidy_rows = []\n", "last_autocarver_reg = None\n", "for seed in SEEDS:\n", " X_train, X_dev, X_test, y_train, y_dev, y_test = make_regression_splits(seed)\n", " y_train_full = pd.concat([y_train, y_dev])\n", " for name, run in REGRESSION_RUNNERS.items():\n", " X_tr, X_te, fit_t, transform_t, model = run(X_train, y_train, X_dev, y_dev, X_test)\n", " if name == 'AutoCarver':\n", " last_autocarver_reg = model\n", " scores = fit_eval_regression(X_tr, X_te, y_train_full, y_test)\n", " values = {\n", " 'fit_s': fit_t,\n", " 'transform_s': transform_t,\n", " 'train_r2': scores['train_r2'],\n", " 'test_r2': scores['test_r2'],\n", " 'r2_drop': scores['train_r2'] - scores['test_r2'],\n", " 'n_dummies': scores['n_dummies'],\n", " }\n", " for metric, value in values.items():\n", " regression_tidy_rows.append({'seed': seed, 'library': name, 'metric': metric, 'value': value})\n", "\n", "regression_tidy = pd.DataFrame(regression_tidy_rows)\n", "regression_results = summarize_multiseed(regression_tidy, ['train_r2', 'test_r2', 'r2_drop', 'n_dummies'], timing_seed=SEEDS[0])\n", "regression_results\n" ] }, { "cell_type": "markdown", "id": "5e8fb1d1", "metadata": {}, "source": [ "### Dropped features — same robustness veto as above\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "12e653ab", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "AutoCarver dropped 2/130 input features (no combination survived the dev-set robustness veto):\n", " - cat22\n", " - cat70\n" ] } ], "source": [ "n_input_reg = len(categoricals) + len(quantitatives)\n", "print(f\"AutoCarver dropped {len(last_autocarver_reg.dropped_features)}/{n_input_reg} input features \"\n", " f\"(no combination survived the dev-set robustness veto):\")\n", "for feature in last_autocarver_reg.dropped_features:\n", " print(' -', feature.name)" ] }, { "cell_type": "code", "execution_count": 16, "id": "b7da7c9b", "metadata": { "execution": { "iopub.execute_input": "2026-07-11T11:45:11.476450Z", "iopub.status.busy": "2026-07-11T11:45:11.476450Z", "iopub.status.idle": "2026-07-11T11:45:11.739624Z", "shell.execute_reply": "2026-07-11T11:45:11.739624Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_bars(regression_results, ['fit_s', 'test_r2', 'r2_drop', 'n_dummies'], 'Allstate Claims Severity — regression')\n", "plot_score_vs_size(regression_results, 'test_r2', 'Score vs. model size — Allstate Claims Severity')" ] }, { "cell_type": "markdown", "id": "notes-md", "metadata": {}, "source": [ "## How to read these numbers\n", "\n", "- **`fit_s` / `transform_s`** measure only `.fit` / `.transform` wall-clock — not data loading, not one-hot encoding, not the downstream model.\n", "- **`test_auc` / `test_r2`** are the headline metric (mean ± std over 5 random splits). They reflect how well a *simple* downstream model performs on each library's binned output.\n", "- **`auc_drop` / `r2_drop`** are `train − test` and measure how much each library's bins overfit. Lower is more robust. AutoCarver's dev-set veto is designed to keep this small.\n", "- **`n_dummies`** is the number of one-hot columns the downstream model consumes — the model's size. Binning is compression: a library that scores well *with few dummies* is doing the actual job. KBins does not bin categoricals at all (it passes them through raw), which is why its `n_dummies` explodes on Allstate — its R² edge there is bought by skipping the compression entirely.\n", "- **Same data, same seeds, same downstream model** across libraries — but one machine, one set of hyper-parameters. Treat as illustrative.\n", "\n", "## When the result will move\n", "\n", "- **Bigger `max_n_mod` / smaller `min_freq`** will improve AutoCarver's and optbinning's in-sample scores at the cost of `*_drop`. KBins doesn't have a target, so it's mostly insensitive.\n", "- **Different downstream model.** Gradient-boosted trees on the raw features beat any binning + linear pipeline. The point of binning is interpretability and robustness, not raw accuracy.\n", "- **Different dataset.** Both datasets here are already sizeable (hundreds of thousands of rows); at 10M+ rows, `fit_s` differences dominate the comparison.\n", "\n", "See [comparison.rst](../../comparison.html) for the qualitative scope and algorithmic comparison.\n" ] } ], "metadata": { "kernelspec": { "display_name": "AutoCarver", "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.11.15" } }, "nbformat": 4, "nbformat_minor": 5 }