🔥 Bankai Boruta

BankaiBoruta is a fast, memory-efficient implementation of the Boruta all-relevant feature selection algorithm for large tabular datasets.

Boruta rounds run inside the native Rust engine of Bankai Random Forest: real columns are prepared once per fit, shadow columns are shuffled in parallel and trees train without building an augmented real-plus-shadow matrix. The decision rule is the same as BorutaPy's, behind a scikit-learn-compatible selector. Classic Boruta is the default; greedy=True enables the fixed-round Greedy Boruta variant.

⚠️ Bankai Boruta is in Alpha. Its API and fitted objects may change.

Install

Python 3.11 or newer is required:

python -m pip install bankai-boruta

Quick start

This example generates a binary classification dataset with 1,000 rows and 20 features. It fits selection on the training partition and applies the same feature mask to the held-out partition. A pandas DataFrame supplies feature names.

import pandas as pd
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

from bankai_boruta import BankaiBoruta

values, y = make_classification(
    n_samples=1_000,
    n_features=20,
    n_informative=5,
    n_redundant=3,
    random_state=2077,
)
X = pd.DataFrame(values, columns=[f"feature_{i}" for i in range(values.shape[1])])
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=2077,
)

selector = BankaiBoruta(
    n_estimators="auto",
    perc=100,
    alpha=0.05,
    max_iter=100,
    random_state=2077,
)
selector.fit(X_train, y_train)

X_train_selected = selector.transform(X_train)
X_test_selected = selector.transform(X_test)
print(f"Selected features: {selector.n_features_}")
print(selector.get_feature_names_out())
print(f"Train shape: {X_train_selected.shape}; test shape: {X_test_selected.shape}")

selection = pd.DataFrame({
    "feature": selector.feature_names_in_,
    "confirmed": selector.support_,
    "tentative": selector.support_weak_,
    "rank": selector.ranking_,
})
print(selection.sort_values("rank"))

transform returns confirmed features only. fit_transform(X, y) combines the fit and transform steps. NumPy arrays and pandas DataFrames are supported.

Selector reference

BankaiBoruta follows scikit-learn's estimator conventions and uses parameter names familiar from BorutaPy. Its constructor defaults are:

from bankai_boruta import BankaiBoruta

selector = BankaiBoruta(
    estimator=None,
    n_estimators="auto",
    perc=100,
    alpha=0.05,
    two_step=True,
    max_iter=100,
    random_state=None,
    verbose=0,
    early_stopping=False,
    n_iter_no_change=20,
    greedy=False,
    bonferroni=True,
    importance_getter="auto",
    store_history=False,
)

fit(X, y, sample_weight=None) accepts non-negative sample weights with a positive total. The fitted selector exposes:

The selector supports scikit-learn pipelines, cloning and parameter search.

Forests

The default forest is binned Extra Trees with 63 bins:

from bankai_random_forest import BankaiRandomForestClassifier

forest = BankaiRandomForestClassifier(
    extra_trees=True,
    extra_trees_backend="binned",
    max_bins=63,
    importance_type="gain",
    max_depth=6,
    n_jobs=-1,
)

Pass any BankaiRandomForestClassifier to choose another backend. Nested parameters such as estimator__max_depth work with set_params and parameter search:

forest = BankaiRandomForestClassifier(n_estimators=100, max_depth=5, n_jobs=-1)
selector = BankaiBoruta(forest, n_estimators=None, random_state=42)
selector.set_params(estimator__max_depth=7)
selector.fit(X_train, y_train)

All four BankaiRF backends run natively:

On the native path, one shadow session serves the whole fit. Real columns are stored once, as float32 values for exact forests or as one-byte bin codes for binned forests, and every round shuffles shadow columns in parallel inside that session. Float64 binned input is binned again each round so its edges come from the original float64 values. Exact forests with float64 input use the Python adapter, which preserves BankaiRF's float64 split semantics; convert to float32 to use the native path.

The native path forwards n_estimators, max_depth, max_features, n_jobs, random_state, extra_seed, criterion, min_samples_split, min_samples_leaf, min_weight_fraction_leaf, min_impurity_decrease, max_leaf_nodes, bootstrap, max_samples, max_bins, binning_strategy, bin_sample_size and binning_seed. max_features is resolved against each round's current real-plus-shadow width. Gain importance is normalized per tree for Extra Trees and over the forest for Random Forests.

Other configurations use the Python adapter, which fits the estimator on a materialized real-plus-shadow matrix each round. That includes sample or class weights, other importance types, warm_start, OOB scoring, monotonic constraints, custom importance getters and non-BankaiRF classifiers. Both paths apply the same decision rule.

selector = BankaiBoruta(forest, n_estimators=100, random_state=42)
selector.fit(X_train.astype("float32"), y_train)
print(selector.diagnostics_["path"], selector.diagnostics_["reason"])
print(selector.diagnostics_["storage_mode"])  # "shadow_session" on the native path

diagnostics_ reports the path ("rust" or "python") and the reason for it, the storage mode, preparation, training and shuffle times, and explicit buffer sizes such as real_bank_bytes, permutation_bytes, input_conversion_bytes and copied_bytes (augmented-matrix writes on the adapter path). These are buffer sizes, not RSS.

Performance

Medians over five seeds on an AWS c7a.4xlarge (16 AMD cores, 16 threads), against BorutaPy 0.4.3 with scikit-learn ExtraTreesClassifier and the same forest settings. Every method ran up to 40 rounds with the same decision rule. RSS is the fit's peak increase over the loaded data.

Both Bankai backends were faster and used less memory than BorutaPy in all 20 profile × seed pairs. No method confirmed an irrelevant feature. In Industrial, Credit and Bioinformatics, Bankai selected the same sets as BorutaPy. In Cybersecurity, every method reached the round limit and borderline features varied: median recall was 0.67 for Bankai exact, 0.65 for BorutaPy and 0.62 for Bankai binned. These are synthetic datasets; results depend on the workload. Protocol, raw results and the LightGBM comparison are in the benchmark repository.

Greedy mode

selector = BankaiBoruta(
    greedy=True,
    bonferroni=True,
    alpha=0.05,
    random_state=2077,
)
X_selected = selector.fit_transform(X_train, y_train)
print(f"Rounds: {selector.n_iter_}; effective budget: {selector.max_iter_}")

Greedy keeps every original feature throughout the campaign. With p original features, it runs K = ceil(log2(p / alpha)) rounds when bonferroni=True, or K = ceil(log2(1 / alpha)) otherwise.

A feature is confirmed after at least one importance above the shadow percentile. Features with no hits are rejected at completion. support_weak_ is always false and ranking_ uses 1 for confirmed and 2 for rejected features. max_iter, two_step, early_stopping, and n_iter_no_change do not control this mode. Greedy relaxes confirmation and can select more noise.

Development

Local builds need Git, Python 3.11+, stable Rust, and uv. Install the Xcode command-line tools on macOS or the Rust MSVC build tools on Windows.

git clone https://github.com/breno-jesus-fernandes/bankai-boruta.git
cd bankai-boruta
uv python install 3.11
uv sync --locked --no-install-project --extra test
uv run --no-sync maturin develop --release --locked

Run the Python and Rust tests:

uv run --no-sync pytest -q
uv run --no-sync cargo test --workspace --locked

CI tests Python 3.11–3.14 and builds ABI3 wheels for Linux x86_64/ARM64, macOS x86_64/ARM64 and Windows x86_64. Merging a new version to main publishes it to PyPI. See the development guide for the BankaiRF pin and release order, the changelog for release history, the contribution guide and the Code of Conduct.

References

1. Nicolas Vana (2025), The Greedy Boruta Algorithm: Faster Feature Selection Without Sacrificing Recall, author article in Towards Data Science. The published GreedyBoruta 1.0.0 implementation supplies the fixed-round, hit-once reference used here.
2. Pierre Geurts, Damien Ernst and Louis Wehenkel (2006), Extremely randomized trees, Machine Learning 63, 3–42. Author preprint and publication record.
3. Guolin Ke et al. (2017), LightGBM: A Highly Efficient Gradient Boosting Decision Tree, NeurIPS 30, particularly Section 2.1 on histogram-based learning. Paper PDF and official histogram documentation.
4. Miron B. Kursa and Witold R. Rudnicki (2010), Feature Selection with the Boruta Package, Journal of Statistical Software 36(11), 1–13. BorutaPy implementation.

License

Bankai Boruta is distributed under GPL-3.0-or-later. Its BankaiRF Rust backend includes the maintained GPL-3.0-or-later XRF fork.