HistGradientBoostingClassifier

sklearn's HistGradientBoostingClassifier & HistGradientBoostingRegressor

"LightGBM's ideas. sklearn's API. Production-ready out of the box."

1. What Is HistGradientBoosting?

HistGradientBoostingClassifier (HGBC) and HistGradientBoostingRegressor (HGBR) are sklearn's modern, fast gradient boosting estimators, introduced experimentally in sklearn 0.21 (2019) and made stable in sklearn 1.0 (2021).

They implement the histogram-based gradient boosting algorithm — the same core idea as LightGBM — but exposed through sklearn's standard fit/predict/Pipeline API with zero external dependencies.

The key innovations over sklearn's older GradientBoostingClassifier:

2. Motivation: Why a New sklearn GBM?

GradientBoostingClassifier (GBC) was sklearn's original gradient boosting implementation — a faithful implementation of Friedman (2001) with exact split finding: for each candidate feature, every unique value in the dataset is evaluated as a potential split threshold.

This is O(m · p · log m) per tree — prohibitive for datasets beyond ~50,000 rows. In an era where XGBoost (2016) and LightGBM (2017) were training in minutes on millions of rows, sklearn's implementation was a serious practical limitation.

HGBC was the response: adopt LightGBM's histogram-based approach within the sklearn ecosystem, preserving:

• The familiar fit/predict/Pipeline/GridSearchCV API
• No extra dependencies beyond sklearn itself
• Proper sklearn behavior for clone, get_params, set_params, cross-validation

The result is an estimator that:

• Trains 10–100× faster than GBC on large datasets
• Handles NaN values and categoricals natively
• Achieves accuracy comparable to XGBoost and LightGBM on medium-scale data
• Requires zero preprocessing for most tabular datasets

3. Core Algorithm — Histogram-Based Gradient Boosting

3.1 Gradient Boosting Foundation

HGBC implements the standard gradient boosting framework. The model at round t:

F_t(x) = F_{t-1}(x) + α · h_t(x)

Where h_t is a new regression tree fitted to the negative gradients (pseudo-residuals) of the loss function:

r_i = −∂L(y_i, F_{t-1}(x_i)) / ∂F_{t-1}(x_i)

For binary log-loss:

r_i = y_i − sigmoid(F_{t-1}(x_i))    (prediction error in probability space)

Leaf values are computed using a Newton step (second-order approximation) — same as XGBoost's optimal leaf formula:

γ_j = −(Σ_{i ∈ leaf_j} g_i) / (Σ_{i ∈ leaf_j} h_i + λ)

This is the key difference from GradientBoostingClassifier, which uses only the first-order gradient to set leaf values.

3.2 Histogram Construction

At the start of training, HGBC bins each feature into at most max_bins integer buckets:

Step 1: For each feature f, find max_bins−1 quantile boundaries
Step 2: Map each continuous value x_if to its bin index b_if ∈ {0, ..., max_bins−1}
Step 3: Store the binned integer matrix X_binned (dtype uint8 for max_bins ≤ 255)

This binning is done once before training and reused for all trees. Memory impact:

Original X:    m × p floats (8 bytes each) = m·p·8 bytes
X_binned:      m × p uint8  (1 byte each)  = m·p·1 byte   → 8× memory reduction

For each node during tree building, HGBC builds a gradient histogram over the bins:

For feature f, bin b:
    hist[f][b].sum_gradients = Σ_{i: b_if = b} g_i
    hist[f][b].sum_hessians  = Σ_{i: b_if = b} h_i
    hist[f][b].count         = |{i: b_if = b}|

3.3 Split Finding over Histograms

For each candidate split on feature f at bin boundary b (left bins ≤ b, right bins > b):

G_L = Σ_{b'≤b} hist[f][b'].sum_gradients
H_L = Σ_{b'≤b} hist[f][b'].sum_hessians
G_R = G_total - G_L
H_R = H_total - H_L

Gain(f, b) = ½ · [G_L²/(H_L + λ) + G_R²/(H_R + λ) − G²/(H + λ)] − γ

This is identical to XGBoost's split gain formula. The maximum gain over all (f, b) pairs determines the best split.

Complexity per node: O(max_bins · p) — independent of m. For 100 features and 255 bins: 25,500 evaluations regardless of whether m is 10,000 or 10,000,000.

3.4 The Histogram Subtraction Trick

For a node split into left and right children:

Build smaller child's histogram:    O(min(n_left, n_right) · p)
Compute larger child's histogram:   parent_hist − smaller_child_hist = O(max_bins · p)

Always build the smaller child from scratch (faster) and subtract to get the larger child (O(max_bins) arithmetic). This asymptotic trick halves the average histogram construction cost.

3.5 Second-Order Leaf Values

Unlike GradientBoostingClassifier, HGBC uses the Newton step for leaf values:

γ_j* = −G_j / (H_j + λ)

Where G_j = Σ_{i∈leaf_j} g_i (sum of gradients) and H_j = Σ_{i∈leaf_j} h_i (sum of Hessians).

For log-loss: h_i = p_i(1 − p_i) — the variance of the Bernoulli prediction. Samples near the decision boundary (p ≈ 0.5) have high Hessian; very confident predictions have low Hessian. The Newton step naturally scales the leaf value by the inverse curvature — more aggressive updates where the loss is locally flatter.

4. Differences from GradientBoostingClassifier

Critical API difference: HGBC's primary tree complexity control is max_leaf_nodes, not max_depth. The default of 31 leaves allows trees up to depth 5 (since a balanced depth-5 tree has 32 leaves). Setting only max_depth without max_leaf_nodes may not have the expected effect.

5. Native Missing Value Handling

HGBC handles NaN values without any user-supplied imputation, using the same learned default direction approach as XGBoost and LightGBM.

During training: When building a histogram, NaN values are excluded from all bin counts. When evaluating a split at node t for feature f at threshold b:

Case A: Route all NaN samples to LEFT child → compute gain
Case B: Route all NaN samples to RIGHT child → compute gain
Choose the direction that gives higher gain — store as default_direction[t, f]

During prediction: At each node, if the feature value is NaN, follow default_direction for that node's feature.

Practical result:

import numpy as np
from sklearn.ensemble import HistGradientBoostingClassifier

X = np.array([[1.0, np.nan], [2.0, 3.0], [np.nan, 1.0]])
y = np.array([0, 1, 0])

clf = HistGradientBoostingClassifier()
clf.fit(X, y)    # Works — no imputation step needed

This is one of HGBC's most practical advantages: many real-world tabular datasets have NaN values, and handling them requires a preprocessing step with every other sklearn estimator. HGBC eliminates this completely.

6. Native Categorical Feature Support

6.1 How It Works Internally

HGBC can handle integer-encoded categorical features directly — no one-hot or ordinal encoding by the user. The approach is one-hot split finding within the histogram framework:

For a categorical feature with c unique values, HGBC considers all 2^(c−1)−1 possible binary partitions of the categories — but approximates this by trying one-hot splits (one category vs. all others) and the best of a heuristic set of partition orderings.

The split is of the form: "Is category in set S? → left : right" — a proper multi-way category partition reduced to a binary split.

Setup:

import numpy as np
from sklearn.ensemble import HistGradientBoostingClassifier

# Categorical columns must be integer-encoded first
from sklearn.preprocessing import OrdinalEncoder

enc = OrdinalEncoder()
X_encoded = enc.fit_transform(X_raw)   # All columns → integers

# Tell HGBC which columns are categorical
categorical_mask = np.zeros(X_encoded.shape[1], dtype=bool)
categorical_mask[[2, 5, 7]] = True    # columns 2, 5, 7 are categorical

clf = HistGradientBoostingClassifier(categorical_features=categorical_mask)
clf.fit(X_encoded, y)

Or with a pandas DataFrame:

import pandas as pd
from sklearn.ensemble import HistGradientBoostingClassifier

# Convert string categoricals to pandas Categorical dtype
for col in ['city', 'device', 'country']:
    df[col] = df[col].astype('category')

clf = HistGradientBoostingClassifier(categorical_features='from_dtype')
clf.fit(df, y)   # Detects Categorical columns automatically

6.2 Limitations

• Categories must be non-negative integers (0, 1, 2, ..., c−1)
• Maximum categories per feature: max_bins (default 255) — features with > 255 unique values cannot use native categorical handling
• The split finding is less sophisticated than CatBoost's ordered encoding — no target encoding, no leakage prevention. For high-cardinality categoricals with target leakage concerns, CatBoost is better.
• Missing categories at test time are treated as NaN → handled by default direction

7. Monotonic Constraints

HGBC supports monotonic constraints — forcing the model's output to be non-decreasing or non-increasing with respect to specific features:

# Syntax 1: dict (feature name → constraint)
clf = HistGradientBoostingClassifier(
    monotonic_cst={'income': 1, 'age': 0, 'debt_ratio': -1}
    #  1 = monotone increasing
    #  0 = no constraint
    # -1 = monotone decreasing
)

# Syntax 2: array (one value per feature)
clf = HistGradientBoostingClassifier(
    monotonic_cst=np.array([1, 0, -1, 0, 1])
)

Implementation: During tree growing, after selecting the best split, HGBC checks if all leaf values in the left subtree are ≤ all leaf values in the right subtree (for a monotone-increasing constraint). If not, the split is skipped and the next best is tried.

This guarantee propagates recursively — HGBC ensures the constraint holds for the entire subtree, not just adjacent leaves.

Use cases:

• Credit risk: higher income → lower default probability (monotone decreasing risk)
• Pricing: higher quantity → lower unit price (monotone decreasing)
• Medical: higher dose → higher biomarker level (monotone increasing)
• Fairness: enforce sensible monotone relationships for regulatory compliance

8. Interaction Constraints

HGBC can restrict which features are allowed to interact within a single tree:

# Group 0: features {0, 1, 2} can interact with each other
# Group 1: features {3, 4} can interact with each other
# Features from different groups cannot appear in the same tree path
clf = HistGradientBoostingClassifier(
    interaction_cst=[[0, 1, 2], [3, 4]]
)

At each node, only features within the same group as the features already used in the path from the root are considered for splitting.

Use cases:

• When domain knowledge dictates that certain feature groups are independent
• For interpretability: isolate which feature groups drive which predictions
• For fairness: prevent sensitive features from interacting with outcome-relevant features

9. Early Stopping

HGBC has built-in early stopping with three modes:

# Mode 1: Auto (uses validation split if n_samples >= 10 * n_classes)
clf = HistGradientBoostingClassifier(early_stopping='auto')

# Mode 2: Always use early stopping
clf = HistGradientBoostingClassifier(
    early_stopping=True,
    validation_fraction=0.1,    # 10% held out for validation
    n_iter_no_change=10,        # Stop if no improvement for 10 rounds
    tol=1e-7,                   # Minimum improvement threshold
    scoring='loss'              # 'loss' or any sklearn scorer string
)

# Mode 3: Disable (use all n_estimators rounds)
clf = HistGradientBoostingClassifier(early_stopping=False)

After fitting:

clf.fit(X_train, y_train)
print(f"Actual rounds used: {clf.n_iter_}")           # Where training stopped
print(f"Train score history: {clf.train_score_}")     # Per-round train scores
print(f"Val score history:   {clf.validation_score_}")# Per-round val scores

Note: Early stopping in HGBC does not have the staged_predict granularity of GBC — you only see the final model, not intermediate ones. Plot train_score_ and validation_score_ to analyze the learning curve.

10. Multi-Class Classification

HGBC handles multi-class classification natively using the softmax loss (multinomial log-loss):

L = −Σᵢ Σₖ 𝟙[yᵢ=k] · log(softmax(F(xᵢ))ₖ)

Training: at each round, one tree is trained per class, fitting that class's gradient (the difference between the true indicator and the current softmax probability). For K classes and T rounds, total trees = K × T.

clf = HistGradientBoostingClassifier(
    max_iter=200,
    # For 5-class problem: builds 200 × 5 = 1000 trees total
)

Multi-class scaling: For large K (many classes), HGBC can be slow. LightGBM and XGBoost offer more optimized multi-class training through GOSS and column subsampling. For K > 50, consider HGBC with max_leaf_nodes reduced or use LightGBM.

11. Quantile Regression (Regressor only)

HistGradientBoostingRegressor supports quantile regression — predicting a specific quantile of the target distribution rather than the mean:

from sklearn.ensemble import HistGradientBoostingRegressor

# Predict the 90th percentile
clf_p90 = HistGradientBoostingRegressor(loss='quantile', quantile=0.9)
clf_p90.fit(X_train, y_train)

# Predict the 10th percentile
clf_p10 = HistGradientBoostingRegressor(loss='quantile', quantile=0.1)
clf_p10.fit(X_train, y_train)

# Prediction interval [p10, p90]
lower = clf_p10.predict(X_test)
upper = clf_p90.predict(X_test)

Implementation: Uses the pinball loss (also called quantile loss or check function):

L_q(y, ŷ) = q · max(y − ŷ, 0) + (1−q) · max(ŷ − y, 0)

The gradient of the pinball loss:

g = −q     if y > ŷ  (under-predicted: push up)
g = (1−q)  if y ≤ ŷ  (over-predicted: push down)

At quantile q, the gradient asymmetrically penalizes under-prediction (by q) and over-prediction (by 1−q), shifting the model's predictions to the desired quantile.

This makes HGBC the only major sklearn estimator with built-in prediction intervals via quantile regression.

12. Hyperparameters — Complete Reference

Classification

from sklearn.ensemble import HistGradientBoostingClassifier

HistGradientBoostingClassifier(
    loss='log_loss',          # Only option for classification
    learning_rate=0.1,        # Shrinkage — most important parameter
    max_iter=100,             # n_estimators (use early stopping instead)
    max_leaf_nodes=31,        # PRIMARY complexity control (not max_depth!)
    max_depth=None,           # Optional depth cap
    min_samples_leaf=20,      # Min samples per leaf — key regularizer
    l2_regularization=0.0,   # L2 on leaf values (λ in Newton step)
    max_bins=255,             # Histogram bins per feature
    categorical_features=None,# List/array/mask of categorical columns
    monotonic_cst=None,       # Dict or array of {1,0,-1}
    interaction_cst=None,     # List of feature groups
    warm_start=False,         # Add trees to existing model
    early_stopping='auto',    # True/False/'auto'
    scoring='loss',           # Metric for early stopping
    validation_fraction=0.1,  # Fraction for early stopping validation
    n_iter_no_change=10,      # Early stopping patience
    tol=1e-7,                 # Minimum improvement
    verbose=0,
    random_state=None,
    class_weight=None         # 'balanced' or dict
)

Regression (additional losses)

from sklearn.ensemble import HistGradientBoostingRegressor

HistGradientBoostingRegressor(
    loss='squared_error',     # or 'absolute_error', 'gamma', 'poisson', 'quantile'
    quantile=None,            # Required if loss='quantile' (float in (0,1))
    # ... all other params same as classifier
)

Hyperparameter Priority

1. learning_rate + max_iter   (find via early stopping)
2. max_leaf_nodes             (primary complexity — NOT max_depth)
3. min_samples_leaf           (primary regularization for noise)
4. l2_regularization          (Newton step regularization)
5. max_bins                   (usually leave at 255)

13. The Bias-Variance Profile

Key insight: HGBC's default min_samples_leaf=20 (vs. GBC's default of 1) means HGBC is more conservative out of the box — a deliberate choice for large datasets where individual samples shouldn't determine leaf values.

14. Feature Importance & Interpretability

# Impurity-based importance (MDI) — built-in
importances = clf.feature_importances_   # Available after fit

# Permutation importance — more reliable
from sklearn.inspection import permutation_importance
result = permutation_importance(clf, X_val, y_val,
                                 n_repeats=20, n_jobs=-1)

# Partial Dependence Plots
from sklearn.inspection import PartialDependenceDisplay
PartialDependenceDisplay.from_estimator(
    clf, X_train, features=[0, 1, (0, 1)],
    kind='both'   # 'average' or 'individual' or 'both'
)

# SHAP — fully supported
import shap
explainer = shap.TreeExplainer(clf)
shap_values = explainer.shap_values(X_val)
shap.summary_plot(shap_values, X_val)

Note: SHAP's TreeExplainer for HGBC may be slower than for LightGBM/XGBoost due to less optimized integration. For production SHAP pipelines at scale, LightGBM or XGBoost are preferable. For exploratory analysis within sklearn, HGBC + TreeExplainer works well.

15. Assumptions

16. Advantages

✅ No External Dependencies

Pure sklearn — no pip install xgboost, no C++ library compilation issues, no version conflicts. In constrained environments (Docker, cloud functions, enterprise approval processes), this matters enormously.

✅ Full sklearn API Compatibility

Works in Pipeline, GridSearchCV, cross_val_score, clone, set_params — the entire sklearn ecosystem without any wrapper classes.

✅ Native NaN Support

The most practically important feature — no SimpleImputer or IterativeImputer step needed. Pass the raw data.

✅ Native Categorical Features

Mark columns as categorical and pass integer-encoded values — no OneHotEncoder or OrdinalEncoder overhead.

✅ Monotonic Constraints

Essential for regulated domains. No other sklearn estimator offers this with this level of integration.

✅ Quantile Regression (Regressor)

Built-in prediction intervals — unique among sklearn regressors.

✅ Competitive Accuracy

On datasets up to ~500k rows, HGBC accuracy is within a few percent of XGBoost and LightGBM — often indistinguishable in practice.

✅ Second-Order Leaf Values

Newton step for leaf computation is more accurate than GBC's first-order line search.

✅ 8× Memory Reduction (Binning)

uint8 binned data vs float64 raw data — critical for large datasets approaching RAM limits.

17. Drawbacks & Limitations

❌ No GPU Support

CPU only. For datasets where GPU training is needed (> 1M rows, time-constrained), use XGBoost or LightGBM.

❌ Slower Than LightGBM/XGBoost at Scale

For very large datasets (> 1M rows), LightGBM's GOSS and EFB provide additional speedups beyond histogram binning. HGBC uses only the histogram trick; LightGBM stacks GOSS + EFB on top.

❌ No staged_predict

The key diagnostic tool of GradientBoostingClassifier is missing. Use train_score_ / validation_score_ attributes or refit with early stopping to find optimal rounds.

❌ Categorical Handling Less Sophisticated Than CatBoost

No ordered target encoding, no feature combinations, no leakage prevention. High-cardinality categoricals with strong target association will be handled worse than CatBoost.

❌ Limited Custom Loss Functions

No user-supplied gradient/hessian interface (unlike XGBoost/LightGBM). Only the built-in loss functions are available.

❌ Level-Wise Tree Growth

Unlike LightGBM's leaf-wise growth, HGBC uses level-wise (depth-wise) tree growing — less efficient for the same number of leaves. The same number of leaves requires more tree splits than LightGBM's leaf-wise approach.

❌ Class Weight Handling Limited

class_weight='balanced' is supported, but the implementation multiplies sample gradients by class weights — less sophisticated than XGBoost's scale_pos_weight or LightGBM's is_unbalance for severe imbalance.

18. HistGBM vs. GBC vs. XGBoost vs. LightGBM

19. Practical Tips & Gotchas

Canonical Setup

from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.model_selection import train_test_split
import numpy as np

X_tr, X_val, y_tr, y_val = train_test_split(X, y, test_size=0.2, random_state=42)

clf = HistGradientBoostingClassifier(
    max_iter=1000,              # High — early stopping handles this
    learning_rate=0.05,
    max_leaf_nodes=63,          # Primary complexity control
    min_samples_leaf=20,        # Primary regularizer
    l2_regularization=0.1,
    early_stopping=True,
    validation_fraction=0.15,
    n_iter_no_change=20,
    scoring='loss',
    verbose=1,
    random_state=42
)
clf.fit(X_tr, y_tr)
print(f"Stopped at: {clf.n_iter_} rounds")

Never Use max_depth as the Only Control

# WRONG — max_depth alone doesn't constrain well for HGBC
clf = HistGradientBoostingClassifier(max_depth=6)

# RIGHT — use max_leaf_nodes as primary, max_depth as secondary guard
clf = HistGradientBoostingClassifier(
    max_leaf_nodes=63,    # Primary
    max_depth=10,         # Safety cap
    min_samples_leaf=20   # Key regularizer
)

Plot Learning Curves

import matplotlib.pyplot as plt

clf = HistGradientBoostingClassifier(
    max_iter=500,
    early_stopping=True,
    validation_fraction=0.15,
    n_iter_no_change=30,
    verbose=0
)
clf.fit(X_train, y_train)

plt.figure(figsize=(10, 4))
plt.plot(clf.train_score_,      label='Train')
plt.plot(clf.validation_score_, label='Validation')
plt.xlabel('Boosting Iteration')
plt.ylabel('Score (higher is better)')
plt.axvline(clf.n_iter_ - 1, color='red', linestyle='--', label='Early stop')
plt.legend()
plt.title('HGBC Learning Curve')

Categorical Features from pandas

import pandas as pd
from sklearn.ensemble import HistGradientBoostingClassifier

# Method 1: Mark dtypes as 'category'
df_train = df_train.copy()
for col in ['city', 'device', 'country']:
    df_train[col] = df_train[col].astype('category')

clf = HistGradientBoostingClassifier(categorical_features='from_dtype')
clf.fit(df_train, y_train)

# Method 2: Specify column indices
from sklearn.preprocessing import OrdinalEncoder
enc = OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=-1)
X_enc = enc.fit_transform(X_raw)
categorical_mask = np.array([True, False, True, True, False])   # which cols are cat

clf = HistGradientBoostingClassifier(categorical_features=categorical_mask)
clf.fit(X_enc, y_train)

GridSearchCV / RandomizedSearchCV

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import loguniform, randint

param_dist = {
    'learning_rate':    loguniform(0.01, 0.2),
    'max_leaf_nodes':   randint(15, 255),
    'min_samples_leaf': randint(5, 100),
    'l2_regularization': loguniform(1e-3, 10.0),
    'max_bins':         [63, 127, 255],
}

search = RandomizedSearchCV(
    HistGradientBoostingClassifier(max_iter=500, early_stopping=True,
                                    n_iter_no_change=15),
    param_dist, n_iter=50, cv=5, scoring='roc_auc', n_jobs=-1
)
search.fit(X_train, y_train)
print(f"Best params: {search.best_params_}")

Pipeline with Preprocessing

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OrdinalEncoder, StandardScaler
from sklearn.ensemble import HistGradientBoostingClassifier
import numpy as np

num_cols = ['age', 'income', 'score']
cat_cols = ['city', 'device']

preprocessor = ColumnTransformer([
    ('num', 'passthrough', num_cols),          # No scaling needed for HGBC!
    ('cat', OrdinalEncoder(handle_unknown='use_encoded_value',
                            unknown_value=-1), cat_cols)
])

pipe = Pipeline([
    ('prep', preprocessor),
    ('clf',  HistGradientBoostingClassifier(
        categorical_features=[False, False, False, True, True],  # match output columns
        max_leaf_nodes=63,
        min_samples_leaf=20,
        early_stopping=True
    ))
])

pipe.fit(X_train, y_train)

20. When to Use It

Use HistGradientBoostingClassifier when:

• You are already in the sklearn ecosystem and don't want extra dependencies
• Dataset is medium-sized (10k–1M rows) where its speed is competitive
• Missing values are present — no imputation step needed
• Categorical features are present — basic native handling
• You need monotonic constraints for regulated or domain-constrained predictions
• You need quantile regression (via the regressor variant) for prediction intervals
• You need full sklearn Pipeline integration (GridSearchCV, ColumnTransformer)
• You want competitive accuracy without tuning (second-order leaves + sensible defaults)

Use GradientBoostingClassifier instead when:

• Dataset is small (< 10k rows) where speed difference is negligible
• You need staged_predict for detailed learning curve diagnostics

Use XGBoost or LightGBM instead when:

• Dataset is very large (> 1M rows) and speed or GPU training are needed
• You need custom loss functions
• You need the most aggressive hyperparameter tuning for maximum accuracy
• Distributed training across multiple machines is required

Summary

┌──────────────────────────────────────────────────────────────────────┐
│          HISTGRADIENTBOOSTING AT A GLANCE                           │
├──────────────────────────────────────────────────────────────────────┤
│  CORE IDEA    Histogram bins (once) → O(max_bins·p) split finding   │
│  LEAF VALUES  Newton step: γ* = −G/(H+λ)  [2nd order]              │
│  PRIMARY CTRL max_leaf_nodes (not max_depth) + min_samples_leaf     │
│  KEY FEATURES Native NaN, native categoricals, monotonic cst.       │
│  BONUS        Quantile regression (regressor) + interaction cst.    │
│  STRENGTH     sklearn API, zero deps, NaN/cat native, fast          │
│  WEAKNESS     No GPU, no custom loss, no staged_predict             │
│  vs LightGBM  Same core algo; LGB faster at scale, more features   │
│  vs GBC       10–100× faster; better leaf values; more features     │
│  BEST FOR     sklearn users, medium data, constrained environments  │
└──────────────────────────────────────────────────────────────────────┘

HistGradientBoosting represents sklearn's mature answer to the era of fast gradient boosting. It is not a clone of LightGBM — it is an adaptation of LightGBM's core ideas (histogram bins, second-order leaf values) into a library where API consistency, reproducibility, and ecosystem integration take precedence over raw throughput. For the practitioner who lives in scikit-learn — who relies on Pipeline, GridSearchCV, and ColumnTransformer — HGBC is the right gradient boosting tool, because it brings the algorithm's modern capabilities without ever requiring them to leave the ecosystem they already know.