CatBoost

Overview

CatBoost is a gradient-boosting library that is built to handle categorical columns well. Instead of asking you to one-hot encode or hand-craft target encodings, it converts categories into numbers internally using ordered target statistics, a method designed to avoid leaking the label into the features. It also uses ordered boosting to reduce a subtle bias called prediction shift, and it builds symmetric (oblivious) decision trees, which are fast to evaluate and act as a mild regularizer.

For tables rich in categories such as product codes, city names, device types or customer segments, CatBoost often gives strong accuracy with very little tuning. Its default settings are known to be good, which makes it a popular first choice for teams that want a reliable model quickly. In the context of tabular foundation models like TabPFN and TabICL, a CatBoost model is one of the standard baselines they are compared against. See /model/benchmarks for how those comparisons are framed.

What it is

CatBoost is an open-source implementation of gradient-boosted decision trees (GBDT). The name joins "category" and "boosting".

Core identity

• A gradient-boosting library that adds trees one after another, each correcting the current ensemble.
• A library with first-class categorical feature support.
• A user of ordered boosting and ordered target statistics to fight target leakage.
• A builder of symmetric trees, where every node on the same level uses the same split condition.
• Available for Python, R, the command line, and other languages, with a scikit-learn style API.

Features in practice

• Classification (binary and multiclass), regression, ranking, and several specialized objectives.
• Native handling of numeric, categorical, text and embedding features.
• Native handling of missing values.
• Automatic feature combinations (for example, pairs of categorical columns).
• Built-in cross-validation, early stopping, and overfitting detection.
• CPU and GPU training, with distributed options.
• Model analysis tools: feature importance, interaction strength and SHAP values.
• Export of fast applier models for production serving.

The kind of data it suits

Structured tables where at least some columns are categories, especially when those categories have many levels. It also performs well on mixed tables and small to medium datasets where careful tuning is not available.

Where it came from

Gradient boosting background

• Boosting methods developed in the 1990s showed that many weak learners could combine into a strong one.
• The 2001 paper "Greedy Function Approximation: A Gradient Boosting Machine" framed boosting as gradient descent over functions, and that framing underlies all modern GBDT libraries.
• XGBoost (the 2016 paper "XGBoost: A Scalable Tree Boosting System") and LightGBM (the 2017 paper "LightGBM: A Highly Efficient Gradient Boosting Decision Tree") pushed speed, scale and regularization.

The CatBoost contribution

The paper "CatBoost: unbiased boosting with categorical features" (2018) targeted two issues:

1. Target leakage in categorical encoding. If you replace a category with the average label for that category, computed on the same rows you train on, the feature secretly contains the answer for those rows. The model looks good in training and fails in use.
2. Prediction shift in boosting. Standard boosting computes gradients using a model that was trained on the very same rows. That makes the gradient estimates biased relative to what the model will see on new data.

The proposed remedy for both was an ordering principle: for each row, only use information from rows that came earlier in a random permutation. This is the idea behind ordered target statistics and ordered boosting.

Since then

• CatBoost expanded to text and embedding features, richer ranking losses, and better GPU support.
• Neural tabular models such as TabNet, SAINT and FT-Transformer were compared with CatBoost in benchmark studies, where it often placed near the top among tree models.
• Pre-trained tabular models appeared in the 2020s, and CatBoost remained a common baseline. See /model/research.

How it works

The analogy: grading a quiz without peeking

Imagine you want to estimate how well students from each school do on a test, to use as a feature. If you include the student's own score in the school average, you are letting the answer leak into the feature. A fairer approach is to compute each student's school average using only the students who took the test before them. No one's own result affects their own feature. CatBoost does the same for categories, using a random ordering of rows.

Step by step

1. Shuffle the rows into one or more random permutations.
2. Encode categories with ordered target statistics. For each row, the category value is replaced by a smoothed average of the labels of earlier rows that share the same category.
3. Build features combinations. The algorithm greedily combines categorical columns (and binned numeric columns) into pairs or triples, and encodes those too, so that interactions are available.
4. Quantize numeric features into borders (a histogram-style binning), as in other modern boosting libraries.
5. Start with a base prediction.
6. Compute gradients using ordered boosting. Instead of using a single model trained on all rows, use models that only saw earlier rows in the permutation to compute each row's gradient.
7. Grow a symmetric tree. Pick one split condition per level and apply it to every node on that level.
8. Compute leaf values and add the tree to the ensemble, scaled by the learning rate.
9. Repeat until the iteration count is reached or overfitting detection stops training.

Ordered target statistics in detail

A basic target statistic for a category is the average label among rows with that category. The ordered version computes, for row i, the average over earlier rows only. A prior is added to stabilize rare categories:

encoded(i) = (sum of labels of earlier rows with same category + prior * a) / (count of earlier rows with same category + a)

• The prior is usually the overall label mean.
• The weight a controls how strongly rare categories are pulled toward the prior.
• Early rows in a permutation have little history, so their statistics lean on the prior.
• Using several permutations reduces the noise that this causes.

Ordered boosting

In standard boosting, the gradient for row i is computed with a model trained including row i. That model has partly memorized row i, so its error on row i is optimistic. Ordered boosting maintains models that are trained only on rows before i in the permutation. The gradient for row i then comes from a model that has not seen it, which mimics what happens at prediction time. This reduces prediction shift and tends to help most on small datasets.

CatBoost offers two boosting modes. The ordered mode is more careful and slower, while the plain mode is closer to classic boosting and is used by default on larger data.

Symmetric (oblivious) trees

In an ordinary tree, each node picks its own best split. In a symmetric tree, all nodes on one level share the same split. A tree of depth 6 is therefore defined by just 6 conditions, and it has exactly 64 leaves.

Think of a tournament bracket where every match in a round uses the same rule. It is rigid, but quick to evaluate and hard to overfit.

CatBoost also supports other growth policies, such as depth-wise and loss-guided, for cases where more flexibility helps.

Categorical feature combinations

Many real effects live in combinations: a certain device type in a certain city, a product category for a certain age group. CatBoost builds combinations of categorical columns during tree construction and encodes them with the same ordered statistics. Because this happens automatically, you rarely need to craft cross features by hand.

Text and embedding features

Newer versions can handle text columns by tokenizing them and building bag-of-words or similar numeric features internally, and can accept embedding vectors as inputs. This is convenient when a table has a short free-text field.

Missing values

Missing numeric values can be treated as the smallest value, the largest value, or as a separate category, controlled by the nan_mode setting. Missing categories are treated as their own level.

Overfitting detector

CatBoost can watch a validation metric and stop training when it fails to improve for a number of iterations (od_type, od_wait, or early_stopping_rounds). It can then keep the best model found (use_best_model).

Key concepts and terms

A worked example

A numeric walk-through of an ordered statistic

Take six rows with a category "city" and a binary label. The prior is 0.5 (the overall mean) and the smoothing weight a is 1.

Notice that no row's own label appears in its own encoding. That is the key property. A naive encoding of city A would include every A label, including the row's own, and so would leak.

A realistic Python example

import pandas as pd
from catboost import CatBoostClassifier, Pool
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score

df = pd.read_csv("orders.csv")
y = df.pop("returned")

cat_cols = list(df.select_dtypes(["object", "category"]).columns)
df[cat_cols] = df[cat_cols].fillna("missing")

X_train, X_valid, y_train, y_valid = train_test_split(
    df, y, test_size=0.2, stratify=y, random_state=7
)

train_pool = Pool(X_train, y_train, cat_features=cat_cols)
valid_pool = Pool(X_valid, y_valid, cat_features=cat_cols)

model = CatBoostClassifier(
    iterations=3000,
    learning_rate=0.05,
    depth=6,
    l2_leaf_reg=3,
    eval_metric="AUC",
    random_seed=7,
    early_stopping_rounds=150,
    verbose=200,
)

model.fit(train_pool, eval_set=valid_pool, use_best_model=True)

pred = model.predict_proba(X_valid)[:, 1]
print("AUC:", roc_auc_score(y_valid, pred))
print("Trees used:", model.get_best_iteration() + 1)

Why this needs so little code

• No one-hot encoding step.
• No target encoding step and no worries about leakage inside it.
• No imputation step for missing numeric values.
• Early stopping picks the number of trees.

Inspecting what the model learned

imp = model.get_feature_importance(prettified=True)
print(imp.head(10))

# Pairs of features that interact strongly
inter = model.get_feature_importance(type="Interaction", prettified=True)
print(inter.head(5))

# Per-row explanations
shap_vals = model.get_feature_importance(valid_pool, type="ShapValues")

The last column of the SHAP matrix is the expected value, and the rest are per-feature contributions for each row.

Cross-validation inside the library

from catboost import cv

params = {"loss_function": "Logloss", "depth": 6, "learning_rate": 0.05,
          "iterations": 2000, "eval_metric": "AUC"}
results = cv(train_pool, params, fold_count=5, stratified=True,
             early_stopping_rounds=100, verbose=False)
print(results.tail(1))

Strengths and limitations

Strengths

• Excellent categorical handling. Ordered target statistics and automatic combinations are built in.
• Strong defaults. Often competitive with minimal tuning, which saves time.
• Resists overfitting. Symmetric trees and ordered boosting add regularization.
• Good on small and medium data. Ordered boosting helps most when data is limited.
• Fast prediction. Symmetric trees are quick to evaluate in production.
• Handles missing values natively.
• Text and embedding support inside the same model.
• Rich analysis tools. Interaction strength, SHAP and feature statistics.
• GPU training is mature.

Limitations

• Slower training in some settings. Ordered mode and category combinations add cost, especially with many high-cardinality columns.
• Memory use can be high with many category combinations.
• Less flexible trees. Symmetric trees may need more depth or more iterations to capture some patterns.
• Smaller ecosystem than the most widespread boosting library, though it integrates well with common tools.
• Per-table training. Like all boosting libraries, it learns each table from scratch.
• No extrapolation. Predictions are piecewise constant.
• Probabilities may need calibration.
• Unusual parameters. Some options, such as bootstrap_type and grow_policy, interact in ways that need care.

How it compares with alternatives

If your table is dominated by high-cardinality categories, try CatBoost early. If it is huge and mostly numeric, LightGBM is a natural first choice. In practice, run two or three and compare on your own validation split.

Role in tabular foundation models

What the comparison is really about

A tabular foundation model is pre-trained on many tables so it can handle a new table quickly, often without updating its weights. CatBoost is the opposite style: a model trained from scratch on one table. The two meet in benchmarks, where the key questions are whether the pre-trained model reaches the accuracy of a tuned CatBoost model, at what cost, and on which kinds of tables. Read /model/benchmarks and /model/research for the framing.

Categories are a special case in raw tables

Raw tables come with mixed types, missing cells, and columns whose names may be unhelpful or missing. Categories are the hardest of these for classic models, because they have no natural order or scale.

Why the ordered idea still matters for foundation models

CatBoost's central insight is that a feature must not carry information about its own label. The same principle appears in in-context learning. When a pre-trained model sees labeled rows as context and predicts a query row, the query's label must not appear in the context. Evaluation protocols for tabular foundation models also depend on strict separation between context and query rows, which echoes the permutation-based logic in ordered statistics.

In-context learning versus categorical statistics

• CatBoost summarizes a category by a smoothed label average computed from earlier rows.
• An in-context model sees the labeled rows directly and can learn, inside its attention layers, a similar smoothing for each category, plus more complex relations.
• For a category with only a handful of rows, both approaches rely on shrinkage toward a prior. In the foundation model that shrinkage is learned from pre-training on many tables.

Synthetic pre-training

Models such as TabPFN are pre-trained on synthetic tables, which include categorical columns created by discretizing latent variables. This teaches the model what categories typically do: they split rows into groups with different label behavior. A boosting library infers that from scratch on every dataset, using statistics. A pre-trained model brings a prior that is helpful when data is scarce, and that is the regime in which CatBoost's ordered boosting also shines. See /model/architecture for how such priors can be organized.

Imputation

CatBoost can serve as the per-column learner inside an iterative imputer, especially for categorical columns with gaps, since it can predict a category directly. A foundation model handles missing cells by predicting masked cells during pre-training, so imputation of both numbers and categories is a native task. See Imputation networks and Masked cell modeling. For a fair test, mask a known fraction of cells, impute with both, and compare error for numbers and accuracy for categories.

Anomaly detection

CatBoost needs labels to detect anomalies, such as fraud. It can also help in a different way: train a model to predict a column from the others, then flag rows with a large residual. Unsupervised detectors such as Isolation forest need no labels, and foundation models can score the surprise of a cell given the rest of the row. See Anomaly detection.

Semantic and sector classification

When a column holds a category with meaning, such as an industry or product class, the label text carries information that a pure statistic ignores. CatBoost treats categories as opaque labels, apart from text features if you provide them. Foundation models that embed column names and values can use meaning directly, which helps classify records or columns into sectors with little labeled data. See Semantic sector heads.

Continual learning

CatBoost supports training from an existing model (init_model), which adds trees to a prior model. That is a simple way to refresh a model, but the ordered statistics for categories are recomputed with the new data, so earlier behavior may shift. Neural foundation models handle new tasks with approaches such as EWC and experience replay.

A practical pairing

• Run a CatBoost baseline with default settings and early stopping.
• Run a tabular foundation model on the same split.
• Compare accuracy, calibration, training time and prediction time.
• Consider averaging the two, which often helps because the error patterns differ.

Practical guidance and best practices

A reliable workflow

1. Mark categorical columns explicitly with cat_features. Fill missing categories with a placeholder string.
2. Choose a split that mirrors production. Use time-based splits for time-dependent data.
3. Train with defaults and early stopping, and note the validation score.
4. Check feature importance and SHAP for leakage.
5. Tune depth, learning rate and regularization.
6. Fix the iteration count from early stopping and refit if you want to use all data.
7. Evaluate once on a held-out test set.
8. Track runs with a tool such as MLflow.

Parameters to tune

Handling high-cardinality categories

• Leave them as categories and let CatBoost encode them.
• Reduce max_ctr_complexity if training is slow or memory-heavy.
• Group very rare levels into an "other" bucket if they add noise.
• Do not use IDs that are unique per row, because they carry no general pattern and invite overfitting.

Class imbalance

• Use auto_class_weights or scale_pos_weight.
• Monitor AUC-PR or log loss.
• Choose the decision threshold on validation data.

Speed

• Use the GPU for large data.
• Reduce border_count and max_ctr_complexity.
• Use the plain boosting type on large data, and the ordered type on small data.
• Prefer a larger learning rate during exploration.

Choosing a loss function

Feature engineering that still helps

• Date parts such as month, weekday and hour.
• Ratios and differences between numeric columns.
• Counts and frequencies of categories, computed on training data only.
• Aggregates over groups, computed carefully to avoid leakage.
• Text length or token counts for short text fields.

Reproducibility

• Set random_seed and keep thread_count fixed.
• On GPU, results can differ slightly between runs even with a fixed seed.
• Save the model in the native format, which keeps categorical handling intact.

Diagnosing problems

Common mistakes

• Forgetting to declare categorical columns. Integer-coded categories then get treated as numbers.
• Passing missing categories as NaN in some versions. Fill them with a placeholder string so they form a clear level.
• Adding row IDs as categories. Unique values lead to memorization.
• Doing your own target encoding before CatBoost. This double-encodes and may leak labels.
• Ignoring row order assumptions. Ordered statistics use random permutations, but if the data has a meaningful time order, keep a time-based validation split.
• Setting depth too high. Symmetric trees grow exponentially in leaf count, so depth 10 means 1,024 leaves per tree.
• Using accuracy on imbalanced data. Use AUC-PR, log loss or recall at a fixed precision.
• Tuning on the test set. Keep it untouched until the end.
• Comparing against a foundation model with default settings only on one side. Tune both fairly.
• Reading importance as cause. Importance reflects model use, not causation.
• Mixing library versions. Defaults for boosting type and growth policy can change.
• Skipping a simple baseline. A basic linear model shows whether boosting adds real value.

Frequently asked questions

What is CatBoost used for?

CatBoost is used to predict outcomes from tables, especially tables with many categorical columns. Common uses include churn, fraud and risk scoring, product return prediction, click-through modeling, pricing and ranking. It supports classification, regression and ranking, and it is popular for good accuracy without heavy tuning.

Why does CatBoost handle categorical features better than other libraries?

It converts categories using ordered target statistics, where each row's encoding uses only earlier rows in a random permutation, so a row's own label never leaks into its feature. It also builds combinations of categories automatically. Together this gives accurate, leak-resistant encodings without manual work.

What is ordered boosting?

Ordered boosting is a variant of gradient boosting that reduces prediction shift. For each row, the gradient is computed with a model that has not seen that row, using the order given by a random permutation. This gives a more honest error estimate during training and tends to help most when data is limited.

What are symmetric trees and why does CatBoost use them?

In a symmetric tree every node on the same level uses the same split condition, so the tree is balanced and defined by one split per level. This acts as regularization and makes predictions very fast, because a row's leaf can be found by evaluating a few conditions and looking up an index.

Do I need to encode categorical variables before using CatBoost?

No. You list the categorical columns with the cat_features option, and CatBoost encodes them internally. You should fill missing categories with a placeholder string and avoid applying your own target encoding first, as that can duplicate or leak information.

Is CatBoost better than XGBoost or LightGBM?

Not universally. CatBoost often wins on tables dominated by categorical features and on small to medium data, and it needs less tuning. LightGBM can be faster on very large data, and XGBoost is very mature and flexible. After tuning, results are usually close, so test on your own data.

How does CatBoost handle missing values?

Missing numeric values are handled by a setting that can treat them as the lowest value, the highest value, or a separate category. Missing categorical values should be filled with a placeholder so they form their own level. No separate imputation step is required.

What depth should I use?

Depth between 4 and 8 works for most problems, with 6 as a common default. Because symmetric trees have two to the power of depth leaves, higher values grow expensive and can overfit. Raise depth only if validation performance keeps improving.

How does CatBoost relate to tabular foundation models?

CatBoost is a per-table learner with a strong method for categories, while tabular foundation models are pre-trained across many tables and predict in context. CatBoost is a standard baseline for those models. The two are complementary: boosting is dependable on larger tables, and foundation models are strong on small tables and fast to apply.

Can CatBoost be used on GPUs?

Yes. CatBoost supports GPU training, which can greatly speed up large datasets. Small datasets may not benefit because of setup overhead, and results on GPU can differ slightly between runs even with a fixed seed.

Glossary

• Categorical feature: a column holding labels with no natural order.
• Target statistic: a category summarized by label values for that category.
• Ordered target statistic: a target statistic using only rows earlier in a permutation.
• Target leakage: information about the label sneaking into a feature.
• Prediction shift: bias that arises when gradients come from a model trained on the same rows.
• Ordered boosting: boosting that avoids prediction shift using permutations.
• Symmetric tree: a tree with one shared split per level.
• Oblivious tree: another name for a symmetric tree.
• Prior: a default value used to stabilize rare categories.
• Learning rate: a factor scaling each tree's contribution.
• Regularization: a penalty that discourages complexity.
• Early stopping: stopping when validation performance stops improving.
• SHAP value: a per-feature contribution to a prediction.
• In-context learning: predicting from labeled examples placed in the model input.
• Tabular foundation model: a network pre-trained on many tables.

Summary

CatBoost is a gradient-boosting library designed around categorical data. Ordered target statistics prevent label leakage when categories are encoded, ordered boosting reduces prediction shift, and symmetric trees give regularization and fast prediction. The result is a model with strong defaults that does well on tables with many categories and on small to medium datasets.

Its trade-offs are slower training in some settings, higher memory use with many category combinations, and the usual limits of per-table boosting: no transfer between datasets and no extrapolation. Within tabular foundation models, CatBoost is a key baseline, and its central lesson, that a feature must never carry its own label, also guides how pre-trained models are evaluated. Compare it with TabPFN or TabICL on identical splits, tune both fairly, and use whichever, or a blend, serves your accuracy, latency and cost needs. Related reading: XGBoost, LightGBM, Random forest, /model/architecture and /model/benchmarks.

Related

It belongs to Classical ML in my stack, under Foundation models and applied ML. Others in the same group: