CTBoost

CTBoost is a gradient boosting library built around Conditional Inference Trees, with a native C++17 core, pybind11 bindings, optional CUDA support, and optional scikit-learn compatible estimators.

CTBoost is focused on making conditional-inference-tree boosting practical for real datasets and production workflows. Development is centered on data ingestion, preprocessing, metrics, orchestration, serialization, and deployment around the existing learner.

What CTBoost Supports

Regression, classification, grouped ranking, and survival training
Low-level ctboost.train(...) plus CTBoostClassifier, CTBoostRegressor, and CTBoostRanker
NumPy, pandas, and SciPy sparse input without dense conversion
Native categorical, text, and embedding preprocessing through FeaturePipeline
Row weights, class imbalance controls, missing-value handling, quantization controls, and generic regularization or growth settings
Validation watchlists, callable objectives, multiple or callable eval metrics, early stopping, per-iteration callbacks, and learning-rate schedules or callback-driven learning-rate changes
Stable JSON and pickle persistence, warm start via init_model, snapshot-path resume with config and schema validation, staged prediction, and standalone Python or JSON predictor export
Richer Pool schema metadata via feature_names, column_roles, feature_metadata, and categorical_schema
Ranking metadata in Pool: group_id, group_weight, subgroup_id, pairs, pairs_weight, and baseline
External-memory pool staging plus optional TCP-based distributed training
Feature importance/statistics, leaf indices, approximate shared-leaf object influence, prediction/tree plots, fast path contributions, and exact background-based TreeSHAP values or interactions

See BACKLOG.md for the remaining generic feature roadmap and deferred items.

Demos

The repository ships local Kaggle-oriented demos in demo/ instead of remote kernel automation:

demo/kaggle_titanic.py for binary classification on Titanic
demo/kaggle_house_prices.py for regression on House Prices

See demo/README.md for expected data layouts and run commands.

Installation

Install the current release from PyPI:

python -m pip install --upgrade ctboost

Starting with CTBoost 0.1.54, that ordinary pip command installs a CUDA-enabled wheel on manylinux-compatible x86-64 systems and Windows AMD64 when using CPython 3.10 through 3.14. The same wheel continues to work for CPU training on a machine without an NVIDIA GPU. It bundles the CUDA 12.8 runtime library, so GPU use requires an NVIDIA driver compatible with CUDA 12.x (525.60.13 or newer on Linux; 528.33 or newer on Windows), but does not require a locally installed CUDA toolkit. The bundled NVIDIA runtime remains subject to the NVIDIA CUDA Toolkit license included in each CUDA-enabled wheel.

Released CUDA wheels target NVIDIA compute capability 6.0 or newer, with native code for Pascal through Blackwell and forward-compatible PTX for future architectures. macOS, Linux aarch64, and the CPython 3.8/3.9 wheels remain CPU-only. Inspect the installed build before selecting task_type="GPU":

python -c "import ctboost; print(ctboost.build_info())"

GPU-capable builds report cuda_enabled: True; a driver or device error is reported only when GPU work is requested. The legacy ctboost-install-gpu command is retained for CTBoost 0.1.52 and earlier GitHub Release assets. It is deprecated and is not needed for 0.1.54 or later.

Install from a source checkout:

python -m pip install .

Install development dependencies from a checkout:

python -m pip install -e ".[dev]"

Install the optional scikit-learn wrappers and ctboost.cv(...) support:

python -m pip install -e ".[sklearn]"

To force a CPU-only native source build:

CMAKE_ARGS="-DCTBOOST_ENABLE_CUDA=OFF" python -m pip install .

On PowerShell:

$env:CMAKE_ARGS="-DCTBOOST_ENABLE_CUDA=OFF"
python -m pip install .

Quick Start

scikit-learn API

import pandas as pd
from sklearn.datasets import make_classification

from ctboost import CTBoostClassifier

X, y = make_classification(
    n_samples=256,
    n_features=8,
    n_informative=5,
    n_redundant=0,
    random_state=13,
)

frame = pd.DataFrame(X.astype("float32"), columns=[f"f{i}" for i in range(X.shape[1])])
frame["segment"] = pd.Categorical(["a" if i % 2 == 0 else "b" for i in range(len(frame))])

model = CTBoostClassifier(
    iterations=256,
    learning_rate=0.1,
    max_depth=3,
    alpha=1.0,
    lambda_l2=1.0,
    eval_metric="AUC",
)

model.fit(
    frame.iloc[:200],
    y[:200].astype("float32"),
    eval_set=[(frame.iloc[200:], y[200:].astype("float32"))],
    early_stopping_rounds=20,
)

proba = model.predict_proba(frame)
pred = model.predict(frame)
importance = model.feature_importances_

The estimators also accept familiar XGBoost/CatBoost parameter names, so existing model-selection code can usually switch libraries without a parameter rewrite:

model = CTBoostClassifier(
    n_estimators=256,
    depth=3,
    reg_lambda=1.0,       # l2_leaf_reg is accepted too
    random_state=13,
)
model.fit(frame.iloc[:200], y[:200])

leaf_indices = model.apply(frame)
history = model.get_evals_result()
best_iteration = model.get_best_iteration()
native_booster = model.get_booster()

is_fitted(), get_best_score(), evals_result(), and calc_leaf_indexes() are available as convenience aliases. The low-level train(...) API likewise accepts n_estimators/num_trees, eta, depth, reg_lambda/l2_leaf_reg, random_state/seed, and max_bin. Conflicting aliases and unknown parameter names fail early with a useful error instead of being silently ignored.

Low-Level API

import numpy as np
import ctboost

X = np.array([[0.0, 1.0], [1.0, 0.0], [0.5, 0.5]], dtype=np.float32)
y = np.array([0.0, 1.0, 0.5], dtype=np.float32)

pool = ctboost.Pool(X, y)
booster = ctboost.train(
    pool,
    {
        "objective": "RMSE",
        "learning_rate": 0.1,
        "max_depth": 3,
        "alpha": 1.0,
        "lambda_l2": 1.0,
        "eval_metric": "MAE",
    },
    num_boost_round=32,
)

predictions = booster.predict(pool)

For inference-only data, labels are optional: prediction_pool = ctboost.Pool(X_new).

Callable Objectives And Metrics

Custom objectives receive raw predictions followed by labels and return the mathematical gradient and non-negative Hessian for every prediction:

def squared_error(predictions, label, *, weight, **_):
    # Sample weights are passed for context and are applied by CTBoost's tree
    # builder, so they must not be multiplied into these derivatives again.
    return predictions - label, np.ones_like(predictions)

objective = ctboost.make_objective(
    squared_error,
    name="MySquaredError",
    native_objective="RMSE",
)

booster = ctboost.train(
    pool,
    {"objective": objective, "max_depth": 3, "alpha": 1.0},
    num_boost_round=32,
)

A bare callable is also accepted in params["objective"], and the XGBoost-style ctboost.train(..., obj=squared_error) form uses the native objective named in params for output-shape and inference semantics. The scikit-learn estimators accept the same callable or ObjectiveSpec as loss_function= and choose their regression, classification, or ranking semantics for a bare callable. Gradients and Hessians must be finite arrays with exactly the prediction shape; Hessians must be non-negative. Multiclass objectives receive a (rows, classes) prediction matrix. Callables may optionally accept weight, ranking metadata, num_classes, and params keyword arguments. Because a derivative-only callable does not define a scalar loss, loss_history uses the selected native objective's metric; configure a callable eval metric when you need an objective-specific reported score.

Use make_eval_metric(...) for a named callable metric and declare higher_is_better; set allow_early_stopping=True when it should control early stopping. Model artifacts store the learned trees and custom objective name, but never embed Python code. They are therefore self-contained for inference; pass the same callable again when continuing custom-objective training from an init_model or snapshot.

Gamma, Poisson, and Tweedie use a log link. The existing predict contract continues to return the additive raw score; predict_raw makes that explicit, while predict_mean (or its predict_response alias) applies exp(raw) to return the positive response-scale mean.

LambdaMART uses standard, unweighted NDCG inside each query. Row weights must therefore be uniform within a group_id; that common value is treated as a query weight (and may be combined with group_weight). Nonuniform per-document weights are rejected instead of producing an NDCG value outside [0, 1].

Multi-output, multilabel, and AFT estimators

The sklearn API includes independent-tree wrappers for targets that do not fit in a native one-dimensional Pool.label:

multi_reg = ctboost.CTBoostMultiOutputRegressor(
    ctboost.CTBoostRegressor(iterations=300),
    n_jobs=-1,
).fit(X_train, y_train_2d)

multi_label = ctboost.CTBoostMultiLabelClassifier(
    ctboost.CTBoostClassifier(iterations=300),
    n_jobs=-1,
).fit(X_train, binary_labels_2d)

These estimators fit one native CTBoost booster per output. Trees, conditional split tests, early-stopping state, and optional target-aware preprocessing are independent rather than shared across outputs. A one-dimensional sample weight is shared; a (rows, outputs) matrix applies weights per output. CPU child fits can use joblib process parallelism, which requires serializable custom losses, metrics, and schedules. Sequential n_jobs=1 fitting can use non-picklable Python objectives; persisted models retain the learned inference semantics but not that Python code. Callbacks and GPU child fits also require n_jobs=1, and these wrappers do not orchestrate distributed training.

Log-normal accelerated-failure-time survival training accepts exact, left-censored, right-censored, and interval-censored observations:

# A flat sequence contains exact event times. Alternatively, bounds[i] is
# [event_time, event_time] for an observed event,
# [0, upper] for left censoring, [lower, np.inf] for right censoring,
# or [lower, upper] for interval censoring.
aft = ctboost.CTBoostAFTRegressor(
    ctboost.CTBoostRegressor(iterations=300),
    scale=0.8,
    prediction_type="time",
).fit(X_train, bounds, eval_set=(X_valid, valid_bounds))

median_time = aft.predict_time(X_test)
mean_time = aft.predict_time(X_test, kind="mean")
log_time_location = aft.predict_log_time(X_test)

Bounds may also be supplied as a (lower_vector, upper_vector) tuple. A flat two-value tuple such as (1.0, 2.0) is two exact observations, not one interval.

scale is the fixed standard deviation of log(T). The reported AFTNLL metric and negative_log_likelihood use the censoring-aware log-normal likelihood. Internally, RMSE supplies only the scalar model/output and export contract; the custom AFT gradient and Hessian drive every tree. AFT convenience training supports CPU or a single GPU but not distributed fitting, and currently requires numeric or already-prepared features rather than target-aware categorical/text/embedding preprocessing.

All three wrappers use pickle for resumable Python persistence. Their export_model(directory) method writes a manifest plus one standalone JSON predictor per output; load_exported_model(directory) loads that inference-only bundle and records the independent-tree semantics explicitly.

Model selection conveniences

The sklearn estimators expose grid_search, randomized_search, select_features, and plot_metrics. Searches use sklearn's cross-validation contracts and can refit the same estimator object. Feature selection reports permutation importance in raw input space, including categorical/text columns. Use compare_estimators(...), or model.compare(...), to evaluate CTBoost and other sklearn-compatible estimators on identical folds with per-fold scores, timing means, and standard deviations.

Exact TreeSHAP explanations

predict_shap computes exact interventional TreeSHAP values against an explicit empirical background distribution. This is distinct from predict_contrib, which remains available as a faster path-based additive decomposition. The final SHAP column is the expected raw model output over the background, and every explanation row sums to the corresponding raw prediction:

background = X[:32]
shap_values = booster.predict_shap(X[32:40], background)
shap_interactions = booster.predict_shap_interactions(X[32:40], background)

np.testing.assert_allclose(
    shap_values.sum(axis=-1),
    booster.predict(X[32:40]),
    rtol=1e-6,
    atol=1e-6,
)

For a single-output model, SHAP values have shape (rows, features + 1) and interaction values have shape (rows, features + 1, features + 1). Multiclass models add an output dimension after the row dimension. The interaction matrix follows the XGBoost-style bias convention: the expected value is at [..., -1, -1], each feature row sums to its SHAP value, and the whole matrix sums to the raw model prediction. Pool.weight supplies optional background weights. Estimator aliases predict_shap_values and predict_shap_interaction_values are also available. When a categorical/text/embedding FeaturePipeline expands raw columns, explanations are returned in that transformed feature space and the names are available from model.get_booster().feature_names.

Object influence and diagnostic plots

calc_leaf_influence provides a transparent object-attribution approximation. For each tree, it distributes the explained row's signed leaf contribution among reference rows that reach the same leaf. A weighted reference Pool uses its row weights for that distribution:

influence, coverage = booster.calc_leaf_influence(
    X_test[:8],
    train_pool,
    return_coverage=True,
)
indices, scores = booster.get_object_importance(
    X_test[:8],
    train_pool,
    top_size=10,
    importance_type="PerObject",
)

This is deliberately not advertised as exact training influence. It performs no deletion/upweighting refits and does not differentiate the training loss. Positive or negative scores mean co-membership in leaves that raise or lower the raw model output. With the original training rows as the reference, scores sum to the covered tree component of the raw prediction; input baselines are not attributed. coverage reports the fraction of trees whose explained leaf was represented by a positive-weight reference row. The returned dense matrix uses rows × reference_rows memory (plus an output dimension for multiclass), so batch large explanation jobs.

Matplotlib conveniences return their axes and are also available on fitted scikit-learn estimators:

prediction_ax = booster.plot_predictions(X_test, y_test)
residual_ax = booster.plot_predictions(X_test, y_test, kind="residual")
feature_ax = booster.plot_feature_statistics(X_test, y_test, feature=0)
tree_ax = booster.plot_tree(0)

Prediction diagnostics show raw model output. Multiclass plots and ranked object importance therefore require prediction_dimension. Install plotting support with pip install "ctboost[plot]".

Learning-Rate Schedules And Callbacks

schedule = [0.2, 0.2, 0.1, 0.1, 0.05, 0.05]

booster = ctboost.train(
    pool,
    {
        "objective": "RMSE",
        "learning_rate": schedule[0],
        "max_depth": 3,
        "alpha": 1.0,
        "lambda_l2": 1.0,
    },
    num_boost_round=len(schedule),
    learning_rate_schedule=schedule,
    callbacks=[ctboost.log_evaluation(2)],
)

print(booster.learning_rate_history)

Callbacks receive env.learning_rate and may call env.model.set_learning_rate(...) to change the step size used for later rounds. The scikit-learn estimators accept the same learning_rate_schedule= keyword on fit(...).

Categorical, Text, And Embedding Inputs

import numpy as np
import pandas as pd

from ctboost import CTBoostRegressor

frame = pd.DataFrame(
    {
        "city": ["berlin", "paris", "berlin", "rome"],
        "headline": ["red fox", "blue fox", "red hare", "green fox"],
        "embedding": [
            np.array([0.1, 0.4, 0.2], dtype=np.float32),
            np.array([0.7, 0.1, 0.3], dtype=np.float32),
            np.array([0.2, 0.5, 0.6], dtype=np.float32),
            np.array([0.9, 0.2, 0.4], dtype=np.float32),
        ],
        "value": [1.0, 2.0, 1.5, 3.0],
    }
)
y = np.array([0.5, 1.2, 0.7, 1.6], dtype=np.float32)

model = CTBoostRegressor(
    iterations=64,
    learning_rate=0.1,
    max_depth=3,
    ordered_ctr=True,
    cat_features=["city"],
    text_features=["headline"],
    text_tokenizer="word",           # word, whitespace, or character
    text_ngram_range=(1, 2),
    text_min_token_count=2,
    text_max_dictionary_size=20_000,  # 0 keeps fixed-size feature hashing
    text_feature_calcer="tfidf",     # count, binary, or tfidf
    embedding_features=["embedding"],
    embedding_target_features=True,
    embedding_target_regularization=1.0,
    embedding_target_mode="auto",     # auto, regression, or classification
)
model.fit(frame, y)

Text columns use the original deterministic, fixed-size count hashing by default. Setting text_max_dictionary_size learns a frequency-ranked dictionary on the training split; text_min_token_count filters rare tokens, and the fitted vocabulary and TF-IDF weights are stored with the model. text_lowercase=False preserves case. Character tokenization applies text_ngram_range to non-space characters, while word and whitespace tokenization apply it to token sequences.

embedding_target_features=True adds a regularized supervised projection for each embedding column (one projection per class for multiclass targets). The projection is fitted only from the training data and labels; validation and prediction inputs never require labels. Embedding vectors must have a consistent dimension when the target-aware transform is enabled. Estimators resolve auto from their task; direct FeaturePipeline use treats contiguous integer targets with three or more values as multiclass and can be made explicit with embedding_target_mode. These transformations only add input features: CTBoost's conditional-inference split selection is unchanged.

Streaming and columnar input

Pool accepts eager PyArrow, Polars, cuDF, NumPy/DLPack, pandas, and SciPy inputs. For a source that is only available as an iterator, assemble it into a disk-backed numeric pool without retaining all source batches in RAM:

from ctboost import PoolBatch, pool_from_batches, train

def batches():
    for features, target in source:
        yield PoolBatch(features, target)

pool = pool_from_batches(batches(), directory="./ctboost-spill")
model = train(pool, {"iterations": 200, "depth": 7})

Batch items can also be (data, label) tuples, mappings, existing pools, or feature matrices. Metadata must be consistently present across batches. The streaming bridge is numeric: apply text/embedding preprocessing before yielding batches. Pool.from_batches(...) is an equivalent convenience constructor.

Dask, Ray, And Spark

Install only the integration you use:

pip install "ctboost[dask]"  # or ctboost[ray], ctboost[spark]

Dask DataFrames and row-chunked Dask Arrays can train through CTBoost's native TCP collective. One rank is pinned to each selected Dask worker, while row partitions are combined locally on that worker. Workers must be separate processes (the normal dask worker/Nanny deployment), not threads in one Python process. Predictions stay lazy and partitioned:

from dask.distributed import Client
import ctboost.dask as ctd

client = Client("tcp://scheduler:8786")
booster = ctd.train(
    client,
    dask_frame,
    label="target",
    params={"objective": "RMSE", "cat_features": ["city"]},
    num_boost_round=200,
    num_workers=4,
    mode="distributed",
)
dask_predictions = ctd.predict(booster, dask_frame.drop(columns=["target"]))

For small data, mode="materialize" is an explicit driver-memory fallback. String labels and metadata arguments such as weight="sample_weight" are treated as columns and removed from the feature frame. Feature names, pandas dtypes, and CTBoost categorical/text pipeline configuration are retained.

Ray uses the same CTBoost TCP collective over disjoint Ray Dataset shards; the label and optional metadata are named columns. Prediction uses Ray Data's lazy map_batches execution:

import ctboost.ray as ctr

booster = ctr.train(
    ray_dataset,
    {"objective": "Logloss", "cat_features": ["segment"]},
    label="target",
    num_boost_round=200,
    num_workers=4,
)
prediction_dataset = ctr.predict(
    booster,
    ray_dataset,
    feature_columns=["age", "income", "segment"],
)

Automatic Dask and Ray endpoints bind the selected worker's concrete network address and attach a cryptographically random, per-run bearer token. For a manually coordinated run, create one root and pass that same value to every rank:

from ctboost.distributed import authenticated_tcp_root

root = authenticated_tcp_root("10.0.0.12", 19091)

The token is kept only in live runtime configuration; model exports, estimator pickles, and snapshots store the redacted tcp://host:port endpoint. The TCP collective does not provide TLS encryption, so use it only on a trusted private network or through a protected network overlay/firewall. Manually supplied bare or wildcard TCP roots are rejected.

ctboost.spark.train(...) intentionally requires mode="collect" and calls DataFrame.toPandas() for fitting, making the driver-memory boundary explicit. It returns SparkCTBoostModel; its transform(...) method performs partitioned Arrow pandas-UDF inference. Native multi-worker training is exposed for Dask and Ray, whose task APIs can safely pin and coordinate the required TCP ranks.

Persistence, Resume, And Export

import ctboost

metric = ctboost.make_eval_metric(
    lambda predictions, label, **_: float(((predictions >= 0.0) == label).mean()),
    name="SignedAccuracy",
    higher_is_better=True,
    allow_early_stopping=True,
)

booster = ctboost.train(
    pool,
    {
        "objective": "Logloss",
        "learning_rate": 0.1,
        "max_depth": 3,
        "alpha": 1.0,
        "lambda_l2": 1.0,
        "eval_metric": [metric, "AUC"],
    },
    num_boost_round=64,
    eval_set=[(X_valid, y_valid)],
    snapshot_path="run_snapshot.ctb",
)

resumed = ctboost.train(
    pool,
    {
        "objective": "Logloss",
        "learning_rate": 0.1,
        "max_depth": 3,
        "alpha": 1.0,
        "lambda_l2": 1.0,
    },
    num_boost_round=128,
    snapshot_path="run_snapshot.ctb",
    resume_from_snapshot=True,
)

booster.export_model("predictor.json", export_format="json_predictor")
predictor = ctboost.load_exported_predictor("predictor.json")
exported_predictions = predictor.predict(X_numeric)

# Versioned deployment contract: feature schema, objective/output semantics,
# build identity, and a deterministic model fingerprint.
manifest = booster.get_inference_manifest()
booster.export_inference_manifest("inference-manifest.json")
assert ctboost.load_inference_manifest("inference-manifest.json") == manifest

# A dependency-free Python scorer can also be generated.
booster.export_model("standalone_predictor.py", export_format="python")

Standalone predictors expose predict_raw (and its predict alias). Classification exports additionally expose predict_proba and predict_class; estimator exports preserve the fitted class-label order. If a model uses CTBoost categorical, text, or embedding preprocessing, pass prepared_features=True when exporting a standalone scorer and feed it the fitted pipeline's transformed numeric features. The manifest records that preprocessing requirement explicitly.

resume_from_snapshot=True validates the saved training configuration and data schema before loading the checkpoint. It remains a warm-start-based convenience flow rather than a blanket exact-equivalence guarantee for every training path. For per-iteration checkpoint emission and logging hooks, use callbacks=[ctboost.log_evaluation(...), ctboost.checkpoint_callback(...)].

Command-Line Deployment

Install the table/estimator dependencies with pip install "ctboost[cli]" and use either the installed ctboost command or python -m ctboost. The CLI calls the same public estimators, model persistence, prediction, and export APIs as Python code:

ctboost train \
  --task classification \
  --input train.csv \
  --target outcome \
  --categorical country,device \
  --params @training-params.json \
  --model churn.ctb

ctboost predict \
  --model churn.ctb \
  --input scoring.parquet \
  --prediction-type probability \
  --output probabilities.parquet

ctboost inspect --model churn.ctb --output model-info.json
ctboost export --model churn.ctb --format manifest --output inference-manifest.json
ctboost info

--params accepts an inline JSON object, a JSON file path, or @path; explicit flags such as --iterations, --learning-rate, and --random-seed override the JSON values. Regression, classification, and ranking are supported. Ranking also requires --group or --group-file. Target, group, categorical, and prediction drop columns can be selected by table name or zero-based feature index. For NPZ archives, use --array-key for the feature matrix and select a target/group array by key; standalone .npy targets use --target-file.

Inputs may be .npy, .npz, .csv, .tsv, .parquet/.pq, or .feather. Parquet and Feather require pyarrow. Prediction output additionally supports JSON. raw works for every model; probability and class reject non-classification objectives. NumPy inputs are loaded with pickling disabled, and object-valued predictions must use CSV, TSV, JSON, Parquet, or Feather. Commands refuse to replace an existing artifact unless --force is supplied, write stable JSON command summaries, and return exit status 2 with an actionable error for expected input/model failures. JSON .ctb models are the safe default; loading or creating pickle models requires --allow-unsafe-pickle and should be limited to artifacts from a trusted source.

Standalone Python, C++, JSON-predictor, ONNX, and inference-manifest exports are available through ctboost export --format .... Models with categorical, text, or embedding preprocessing need --prepared-features for standalone scorers; the resulting artifact then expects numeric features already transformed by the fitted pipeline. ONNX additionally requires ctboost[onnx].

Metadata

pool = ctboost.Pool(
    X,
    y,
    feature_names=["score", "ratio", "city_code"],
    column_roles=["numeric", "numeric", "categorical"],
    feature_metadata={"score": {"description": "normalized score"}},
    categorical_schema={"city_code": {"categories": ["berlin", "paris", "rome"]}},
)

booster = ctboost.train(pool, {"objective": "RMSE"}, num_boost_round=16)
print(booster.data_schema)

The scikit-learn estimators expose the same persisted schema through data_schema_.

Build And Test

Run the Python tests:

pytest tests

Build an sdist:

python -m build --sdist

Configure and build the native extension directly with CMake:

python -m pip install pybind11 numpy pandas scikit-learn pytest
cmake -S . -B build -DCTBOOST_ENABLE_CUDA=OFF -Dpybind11_DIR="$(python -m pybind11 --cmakedir)"
cmake --build build --config Release --parallel

Project Layout

ctboost/      Python API surface
demo/         local example workflows, including Kaggle demos
include/      public C++ headers
src/core/     core training, data, objectives, trees, statistics
src/bindings/ pybind11 extension bindings
cuda/         optional CUDA backend
tests/        Python test suite

Acknowledgments

CTBoost draws methodological inspiration from the original conditional inference tree work by Torsten Hothorn, Kurt Hornik, and Achim Zeileis, along with the subsequent partykit work on CRAN by Torsten Hothorn, Achim Zeileis, and Heidi Seibold. If you are using CTBoost in research or want the statistical background behind the learner, start with these references:

Hothorn, T., Hornik, K., and Zeileis, A. (2006). Unbiased Recursive Partitioning: A Conditional Inference Framework.
Hothorn, T. and Zeileis, A. (2015). partykit: A Modular Toolkit for Recursive Partytioning in R.

License

Apache 2.0. See LICENSE.

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

ctboost-0.1.54.tar.gz (411.4 kB view details)

Uploaded Aug 10, 2026 Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

ctboost-0.1.54-cp314-cp314-win_amd64.whl (3.4 MB view details)

Uploaded Aug 10, 2026 CPython 3.14Windows x86-64

ctboost-0.1.54-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (3.5 MB view details)

Uploaded Aug 10, 2026 CPython 3.14manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

ctboost-0.1.54-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl (1.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.14manylinux: glibc 2.27+ ARM64manylinux: glibc 2.28+ ARM64

ctboost-0.1.54-cp314-cp314-macosx_10_15_x86_64.whl (772.8 kB view details)

Uploaded Aug 10, 2026 CPython 3.14macOS 10.15+ x86-64

ctboost-0.1.54-cp313-cp313-win_amd64.whl (3.3 MB view details)

Uploaded Aug 10, 2026 CPython 3.13Windows x86-64

ctboost-0.1.54-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (3.5 MB view details)

Uploaded Aug 10, 2026 CPython 3.13manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

ctboost-0.1.54-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl (1.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.13manylinux: glibc 2.27+ ARM64manylinux: glibc 2.28+ ARM64

ctboost-0.1.54-cp313-cp313-macosx_10_15_x86_64.whl (772.1 kB view details)

Uploaded Aug 10, 2026 CPython 3.13macOS 10.15+ x86-64

ctboost-0.1.54-cp312-cp312-win_amd64.whl (3.3 MB view details)

Uploaded Aug 10, 2026 CPython 3.12Windows x86-64

ctboost-0.1.54-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (3.5 MB view details)

Uploaded Aug 10, 2026 CPython 3.12manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

ctboost-0.1.54-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl (998.1 kB view details)

Uploaded Aug 10, 2026 CPython 3.12manylinux: glibc 2.27+ ARM64manylinux: glibc 2.28+ ARM64

ctboost-0.1.54-cp312-cp312-macosx_10_15_x86_64.whl (772.3 kB view details)

Uploaded Aug 10, 2026 CPython 3.12macOS 10.15+ x86-64

ctboost-0.1.54-cp311-cp311-win_amd64.whl (3.3 MB view details)

Uploaded Aug 10, 2026 CPython 3.11Windows x86-64

ctboost-0.1.54-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (3.5 MB view details)

Uploaded Aug 10, 2026 CPython 3.11manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

ctboost-0.1.54-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl (1.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.11manylinux: glibc 2.27+ ARM64manylinux: glibc 2.28+ ARM64

ctboost-0.1.54-cp311-cp311-macosx_10_15_x86_64.whl (769.2 kB view details)

Uploaded Aug 10, 2026 CPython 3.11macOS 10.15+ x86-64

ctboost-0.1.54-cp310-cp310-win_amd64.whl (3.3 MB view details)

Uploaded Aug 10, 2026 CPython 3.10Windows x86-64

ctboost-0.1.54-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (3.5 MB view details)

Uploaded Aug 10, 2026 CPython 3.10manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

ctboost-0.1.54-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl (999.8 kB view details)

Uploaded Aug 10, 2026 CPython 3.10manylinux: glibc 2.27+ ARM64manylinux: glibc 2.28+ ARM64

ctboost-0.1.54-cp310-cp310-macosx_10_15_x86_64.whl (767.5 kB view details)

Uploaded Aug 10, 2026 CPython 3.10macOS 10.15+ x86-64

ctboost-0.1.54-cp39-cp39-win_amd64.whl (714.8 kB view details)

Uploaded Aug 10, 2026 CPython 3.9Windows x86-64

ctboost-0.1.54-cp39-cp39-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (1.1 MB view details)

Uploaded Aug 10, 2026 CPython 3.9manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

ctboost-0.1.54-cp39-cp39-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl (982.3 kB view details)

Uploaded Aug 10, 2026 CPython 3.9manylinux: glibc 2.27+ ARM64manylinux: glibc 2.28+ ARM64

ctboost-0.1.54-cp38-cp38-win_amd64.whl (718.3 kB view details)

Uploaded Aug 10, 2026 CPython 3.8Windows x86-64

ctboost-0.1.54-cp38-cp38-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (1.1 MB view details)

Uploaded Aug 10, 2026 CPython 3.8manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

ctboost-0.1.54-cp38-cp38-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl (976.4 kB view details)

Uploaded Aug 10, 2026 CPython 3.8manylinux: glibc 2.27+ ARM64manylinux: glibc 2.28+ ARM64

File details

Details for the file ctboost-0.1.54.tar.gz.

File metadata

Download URL: ctboost-0.1.54.tar.gz
Upload date: Aug 10, 2026
Size: 411.4 kB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for ctboost-0.1.54.tar.gz
Algorithm	Hash digest
SHA256	`86cfb2c28aceca323aecf1f47a7a365c37848f864e8157d5d578451206af0b6c`
MD5	`e74b374711b18367ed72394859452f06`
BLAKE2b-256	`8059d5b2f8c7c3899e8bda5f2fa36ec673b646db7e44636819c7da481ccad9f8`

Algorithm	Hash digest
SHA256	`012ed63ca2c3e4aceb835e8c84f504f9dcb2077c6a170f37095a0f396c54838b`
MD5	`eb31e3042b6edf5da5bed4c9e5d7a60c`
BLAKE2b-256	`c728be76c9fc0371110ec4c4dd3dfdfc42deb7b4842bc23fd3a6dbcc94871f39`

Algorithm	Hash digest
SHA256	`51ed2af228e93037fd6d8e148164c7d6d65846a5f83d98ee1bbec1959b47b998`
MD5	`f9ad145521817935f3a1aa515bbd82c5`
BLAKE2b-256	`e8b4f110f794c12b8c427151b9533fc4e4ce2576e0eb08f7d54f9a4fa499908e`

Algorithm	Hash digest
SHA256	`bfb80e3fe8c2931d3f43b900cdaf1fbc3d7f182e909844c7b3395cdcfcdf6ca2`
MD5	`5cb932c4cc2c5ae98ae89f42e7c07959`
BLAKE2b-256	`540653db64494d0df96651b93e9513534d6bfb377589aaeae3ad302d08b9cd3d`

Algorithm	Hash digest
SHA256	`144e2ac5e5bfc8ed446ea99cdd61433bc367001c65c805261272a5f751a18de6`
MD5	`52929833ac1df12dd30b944e95cd794f`
BLAKE2b-256	`cb684b7e8b558180f7b32e8881d1df39dba0f2e420c64d716379ac25b7afbcf4`

Algorithm	Hash digest
SHA256	`0faf0d0d0871d19b47d2b38ccf72fb945ced0533e2284d46410ede1cc28b7798`
MD5	`a06c82a3f7eefd68699928eda85ee32e`
BLAKE2b-256	`91e0210cf92a94513aa4b68121a1f2ea1393abd7688f9287d94eb4844ed4bae8`

Algorithm	Hash digest
SHA256	`97dc46fa88d23942f3255f827d9ec294e09acb3cae43b421f9c175817bc6f9cc`
MD5	`79ef46276f9aa1b7fa4e8e5d5bfadc16`
BLAKE2b-256	`3b8e4e1dbcd5f00589f566299d2860f3e4fa480aba9b994c7967cddd8b9a57cf`

Algorithm	Hash digest
SHA256	`7c17b700a479f4282177dd447482245a66f5aa143ddbf6325df11da930139d40`
MD5	`97b90603942c51acd5b13cac019b512a`
BLAKE2b-256	`dbad789a663c54c1a8ef9d5caee1ee54de25a1c3c5ca59686bf84f34b8ffee7e`

Algorithm	Hash digest
SHA256	`c4c8d2be6038f34678eacc0e473329af0bcf52c453a6ac38f36c889e147df71a`
MD5	`5dccc550e1934338fb7318b5095788cf`
BLAKE2b-256	`0852f15ca82862e3ffa8c27c2401450b572f60da81a8d1d0730923376ea8d123`

Algorithm	Hash digest
SHA256	`4a3acca437e71b5b47f2ed5ca1ca84c9f074b08afc777ee4b35cdcec43c7d5bb`
MD5	`0ac6e88c069a927935aa59fc96113ef1`
BLAKE2b-256	`af35f69f8f73b6430558a24b233bc9309b50e81683e4b6b2bcd52093d25776b7`

Algorithm	Hash digest
SHA256	`3452309e030477cb92ae7a86c62bbbee664467308967417968f9b047c78ef78b`
MD5	`5767e7f10e613d0e42bf49ec40efef06`
BLAKE2b-256	`e25ca64cbe74d8cad2c827f59aaf71b4dae1a8fdc9ac20012066054e35c56e3d`

Algorithm	Hash digest
SHA256	`189486841569ae829c97f4dee6cdc119b80eaf69908d289cd188a24645d3f3ce`
MD5	`3dbcebd382281479d6daef752ef1ab59`
BLAKE2b-256	`16bc55673f77df7cdc44df82a171ff43a2ec556bcdee397be834cdbba7268686`

Algorithm	Hash digest
SHA256	`1b292ead3513ae4b778b3e217140db656dff172c77006279b365c838907b96e4`
MD5	`b0d3148b7bd46b8fe4a82c603282e1d4`
BLAKE2b-256	`794040bdc423a2fb01549301b60301e3bd8dcd347df96e5dd4513e0dbe386475`

Algorithm	Hash digest
SHA256	`80d0da4f4ccdf8a1af33c6b7c84ac3303403c07bf4f1a1f5b92ec4c21df5c78d`
MD5	`cd255805e036630410ead1055053db23`
BLAKE2b-256	`6e64771a06d20e847d1521946ab2639ff2d4a3bd31f58356794a86e5520d41bc`

Algorithm	Hash digest
SHA256	`8741b7a47c661817fdf9d681120c505801d17349a9c23477c0d473c87634f64b`
MD5	`814f33ee92ef23dc7978b6802333940a`
BLAKE2b-256	`e2696257e1b65b39ac3690ac9724b56860fcd24dc9296bc5dc0b817fd84dccb8`

Algorithm	Hash digest
SHA256	`e825d0d9d7570b202eb1f6324477bd81add423073823da8ee9f846cfc753c843`
MD5	`0c12b06553c9d42bc669f9b0c1dd5e91`
BLAKE2b-256	`f3259a4f830ce984dc3ee68c0690732dfbd71288351d26ec23ca59cda5647ac8`

Algorithm	Hash digest
SHA256	`954a6829687d406403d33c1756aa6b0a3c6421a5cfffd7139fcdff52234cb91a`
MD5	`e780b12bd9a0e61c9434e2e22354412e`
BLAKE2b-256	`c7ae18341e757752de21b42ed09b3c9e5369f04fef0fb11a404dc8593a64793b`

Algorithm	Hash digest
SHA256	`2ff5ae64b305a6a8280eb34c98c94b303d73589aa43013b723673b89e99c96e8`
MD5	`c8e59ba31021935bb8bc4f13e6138527`
BLAKE2b-256	`8d532d290c41f2b1797bd55b7cdebe7ba2a55313d7908941abebf4df2e874c6a`

Algorithm	Hash digest
SHA256	`6e9da6cfc8642968447ed497321fd062e6cc6c4c8e40c8b9f0181825128b8146`
MD5	`80558590995f8271f51d3da5e0d27f9b`
BLAKE2b-256	`c58370133d19f74e5b9d5996259dbb3c79fcb31aa60255156b97f5156707807d`

Algorithm	Hash digest
SHA256	`08bb74ffab2cbb42ca3a26b7db5e69a61ceedd427e85e939462de392a8fcbb5c`
MD5	`abd4a942c49f5438e67b0e863b4196c6`
BLAKE2b-256	`ea5f3f212353281c6fb5d5ed2181e122fddc13759015b95b4b57ae4c57fdf6ad`

Algorithm	Hash digest
SHA256	`aa025452840e96f7082eb25bdf6eb4b8c80520b7de71c84035214093b82ed737`
MD5	`193a7bbf9f5d08fdcd03e491bebbe5cf`
BLAKE2b-256	`1da77f6efd124cf1903eae4a14c338a0506241353bbb1384bc7585f376642e29`

ctboost 0.1.54

CTBoost

What CTBoost Supports

Demos

Installation

Quick Start

scikit-learn API

Low-Level API

Callable Objectives And Metrics

Multi-output, multilabel, and AFT estimators

Model selection conveniences

Exact TreeSHAP explanations

Object influence and diagnostic plots

Learning-Rate Schedules And Callbacks

Categorical, Text, And Embedding Inputs

Streaming and columnar input

Dask, Ray, And Spark

Persistence, Resume, And Export

Command-Line Deployment

Metadata

Build And Test

Project Layout

Acknowledgments

License

Project links

Key dates

1 maintainer

Credits

GitHub Statistics

License

Requires

Provides Extra

Classifiers

Download files

Source Distribution

Built Distributions

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

Algorithm	Hash digest
SHA256	`ff083f8ecbad16c362def492c24a6522c071e7ae56fbad11710ee662c0f45d85`
MD5	`f7f28d5dcff8ab22ee1e663123e792b1`
BLAKE2b-256	`3bcd7c49da9af39b5c09c8115f57b228e1a876969087d461d3960df618e26075`

Algorithm	Hash digest
SHA256	`721b395a05bd504c84d50793e200026db8fb30880b776e6f03d64f8928c1907c`
MD5	`6577675c564cd82d580c2fb0c4ca5dae`
BLAKE2b-256	`8a9c9e7e32f40af93b1fec910eb15bb1be38c9f7998416963b3e2a370eac0288`

Algorithm	Hash digest
SHA256	`df4d0edf0611d5c1ebcce14bf18e0c13b1b411c3b05ae3fee79d135f0d85058e`
MD5	`291460bfd8ad65812690ba8d62c8cc01`
BLAKE2b-256	`75163f17a3a07dfd72f13abd14db79b011d2952791b118d2a28a81f1a019a319`

Algorithm	Hash digest
SHA256	`b546f4868b68562d1aeacb93a3c3874043f18dcfef46b9440b085f3b2d542b8c`
MD5	`07da162c395938811d7db0f9b08c05e2`
BLAKE2b-256	`6fc15451a14cbb8065057f67d7bf8c6f82a7a76c138a37212a929e2c1110023a`

Algorithm	Hash digest
SHA256	`e3ae12668952eaf55bdfacd209b7a68558ec583be754b339c2caa4366e5a9286`
MD5	`0156550ba0a5a7d07544a023c056da54`
BLAKE2b-256	`a786a3bf22b2110df74d4f20a4d4cdcbe8e63e9168e4d2a4ea07f07d68b6885a`

Algorithm	Hash digest
SHA256	`4160c745a6b76e314252e24abeeed1c3c91ca285c16cf03a1254180866540e93`
MD5	`5ff87ada4a54591369311a61368876ed`
BLAKE2b-256	`169c4cfb88941773664c293fe5e6ee11301087cb7aeba4ee8aef401c813e41d1`