TAKT showcase: LightGBM 4.7.0, drop-in with bit-identical output, model analyses up to 18× faster

The numbers below are measured. The free package is on PyPI (pip install lightgbm-takt); the full version is a commercial licence (see "Availability"). This directory holds the measurement scripts and every reading.

Not affiliated with LightGBM. TAKT is not affiliated with or endorsed by the LightGBM project or Microsoft. The name LightGBM is used only to identify the software we measured and build on.

LightGBM (MIT) is one of the most widely used gradient-boosting libraries; its Python package (lightgbm) wraps the C library lib_lightgbm.so.

TAKT builds LightGBM 4.7.0 so that analyses that call predict many times — permutation importance, partial dependence and ICE curves, MDA feature importance across cross-validation folds, what-if scenario sweeps — and batch prediction run several times faster, with every prediction identical to the official build, bit for bit, on the same machine. The Python package and the public API are unchanged (import lightgbm); only the library is replaced. No code changes: sklearn.inspection.permutation_importance, partial_dependence, PartialDependenceDisplay and shap.PermutationExplainer get the speed-up as they are.

Headline

Factors over the official LightGBM 4.7.0 wheel, by user-mode cycles:u with 95% bootstrap CIs, whole process (interpreter start, imports, data loading, the analysis), one core unless noted. The output was identical in every single run.

"Free" is measured on models of up to 300 trees (the free package's limit), "full" on the larger models of the same kind (500 and 1,000 trees; the MDA workload fits 300-tree models in both). In the free columns, the rows not in bold are outside the free package's scope and run LightGBM's own code, at the official speed within a few percent. For the multi-threaded C API row, the full version's wall-time factors are lower than the cycle factors (2.29× on Zen 3 with 4 threads, 3.48× on Zen 4 with 2 threads): the threads' total CPU time falls more than the elapsed time. Every wall-time factor is in the tables below.

Free package vs full version

What was measured

Python workloads (tools/wl.py, tools/worst.py) run with the official wheel and with the TAKT wheel; a C driver (tools/lgbm_block.c) calls LGBM_BoosterPredictForMat with the library swapped through LD_LIBRARY_PATH. Every workload prints every result with 17 significant digits (or the SHA-256 of the raw doubles for large arrays), so a byte compare of the output is a bit compare.

All Python workloads run single-threaded (n_jobs=1), as in these functions' defaults, unless noted.

Stands. AMD Threadripper PRO 5975WX (Zen 3), Ubuntu 24.04, glibc 2.39; AMD Ryzen 9 7950X3D (Zen 4), Debian 13, glibc 2.41. Python 3.12, numpy 2.5.4, scipy 1.18.1, scikit-learn 1.9.1, pandas 3.0.6, shap 0.53.0 on both. Each run pinned to one core (the harness too), takt-harness 0.2.1, interleaved rounds (5 for the long workloads, 9 after a warm-up for the short ones), 95% bootstrap CIs. The harness compared stdout across the builds in every run. Raw readings: results/free/zen3, results/free/zen4, results/full/zen3, results/full/zen4 (.json bundles and .log summaries; paths in them are relative to the measurement directory).

Free package — AMD Zen 3

Free package — AMD Zen 4

Full version — AMD Zen 3

Full version — AMD Zen 4

Equivalence

"Same" means byte-identical output, every number at 17 significant digits.

• Equivalence matrix (tools/eqmatrix.py): 4,497 prediction cases, 1.06 billion values, on 23 models trained on public data — LightGBM's own examples (regression, binary, multiclass, lambdarank), scikit-learn's bundled sets (DART, random forest, linear trees), California housing (1,024 leaves; poisson, tweedie, gamma, huber, quantile, cross-entropy objectives; 30% NaN with and without use_missing; 30% zeros with zero_as_missing), OpenML adult, credit-g and kick (categorical- and missing-heavy). Inputs: the test split plus adversarial rows (NaN, ±inf, −0.0, subnormals, values at ±1e-35 and their float neighbours, values exactly on and next to split thresholds, out-of-range and non-integer categories). Every input type (numpy float64/float32 in C and Fortran order, CSR, CSC, pandas, pyarrow), prediction type (normal, raw, leaf, contributions), iteration range, 1 and 4 threads, prediction early stopping, repeated calls in the pattern of permutation importance and partial dependence, and models changed between calls (set_leaf_output, rollback_one_iter, update, refit). Identical for the free and the full library on both machines.
• LightGBM's own test suites: the C++ test suite (34 of 34) passes with both TAKT builds as with the unmodified source; the Python test suite gives 1,689 passed, 19 skipped with the official wheel and with both TAKT wheels (the same 4 graphviz plotting tests fail with all of them on a machine without the dot binary).
• Concurrency: 8–16 Python threads predicting on shared models, compared with the official sequential results: identical. Soak runs with TAKT_LGBM_VERIFY=1, which recomputes every accelerated call with LightGBM's original code: full version four runs, 10.5 hours in total, 2.4 million calls; free package 30 minutes, 125,000 calls; no difference.
• ABI: the library exports exactly the same 6,469 symbols as the official one, needs the same libraries and symbol versions (glibc 2.27 at most), and is built with the official compiler (gcc 12.2.1) in the manylinux_2_28 image with the official configuration.

Bit-identity is per system. The TAKT build reproduces the official build's output on the same system, bit for bit. Results that pass through the system maths library (for example probabilities) depend on it, so compare on the same machine.

Where the speed-up applies, and where it does not

• Full version: batch prediction through every matrix entry point (numpy and pandas, row pointers, CSR, CSC, Arrow), normal, raw and leaf-index outputs, all boosting types and objectives, numerical and categorical splits with every missing-value mode, linear trees, any number of trees and leaves, iteration ranges, any thread count; and the repeated-call analyses on top of that.
• Free package: the repeated-call analyses on dense inputs (numpy, pandas) with models of up to 300 trees; everything else is LightGBM's own code at its normal speed.
• LightGBM's own code, same result, same speed (both): SHAP contributions (pred_contrib), prediction early stopping, very small calls (under 8 rows), the single-row fast API, prediction from files, models with more than 100,000 features.
• Worst cases (worst_* above): full version 1.00–3.98×, free package 1.01×; none is slower than the official library beyond measurement noise.
• Optional environment variables: TAKT_LGBM_VERIFY=1 recomputes every accelerated call with LightGBM's original code and reports any difference (slow; for checking); TAKT_LGBM_DISABLE=1 turns the acceleration off; TAKT_LGBM_CACHE_MB=N limits the extra memory the acceleration may use (default and, in the free package, maximum 1 GB; 0 turns it off).

LightGBM's own concurrency limits. In LightGBM 4.7.0, with the official library: concurrent predictions on one booster with different start_iteration/num_iteration (LightGBM issue #6142), concurrent calls with different num_threads, and changing a booster (training, set_leaf_output, refit) while another thread predicts with it can crash or return wrong values. Code that avoids these patterns runs the same with TAKT. The parts of TAKT that run LightGBM's own code keep this behaviour; the full version's accelerated calls take the iteration range from each call (a 16-thread test of the first pattern that crashes the official library gave 0 differences with them).

Availability

• Free: pip install lightgbm-takt (after pip uninstall -y lightgbm). Repeated-call analyses accelerated on models up to 300 trees; everything else runs LightGBM's own code at its normal speed, with full LightGBM functionality available. Linux x86-64, Python 3.10–3.14. The library in the free package carries the TAKT Free Binary Licence for TAKT's contributions; LightGBM's code stays under its MIT licence.
• Full version: a commercial licence: every model size and the analyses on several threads, faster batch prediction and explainers, the C/C++ library (lib_lightgbm.so, same exports), builds for other platforms and LightGBM versions, support, and source escrow (the modified source in an encrypted escrow box, released to you on the conditions of our Terms of Service).
• Prices:
• Team, $399 a month billed yearly ($4,788): the full version on one platform, with every new LightGBM release rebuilt and checked bit for bit again.
• Enterprise, from $1,500 a month billed yearly: other platforms and LightGBM versions, an SLA, source escrow and acceptance on your own hardware.
• A licence, a quote, or a free speed check of your own code: https://taktcycles.com/?src=showcase-lightgbm#start
• New measurements of other libraries, one a week: https://t.me/taktcycles

Reproducing the baseline

# The verify script: a 300-tree model on synthetic data, permutation importance and a PDP, compared bytewise.
python -m venv a && a/bin/pip install -q lightgbm==4.7.0 scikit-learn && a/bin/python tools/verify.py > a.txt
python -m venv c && c/bin/pip install -q lightgbm-takt scikit-learn  && c/bin/python tools/verify.py > c.txt
diff a.txt c.txt && echo identical

# The workloads: prepare the models once (official wheel), then run any workload with each wheel.
python tools/wl.py prep .        # the kick and California models (500 trees)
python tools/wl.py prep_free .   # the 300-tree models (the quant model needs the quant data, see below)
python tools/wl.py pi_kick300 . > out.txt

The kick and California housing workloads download their data themselves (OpenML, scikit-learn). The quant-feature workloads (*_alpha*) read features computed with tools/features_alpha158.py from Binance 5-minute klines of five pairs, and the trained model files; these data files are not in this directory (on request). tools/table.py and tools/pubtable.py print the tables above from the readings in results/.

Contents

• tools/: the workload scripts (wl.py, worst.py, features_alpha158.py), the C driver (lgbm_block.c), the equivalence and concurrency checks (eqmatrix.py, concurrency.py), the verify script (verify.py), and the table scripts (table.py, pubtable.py).
• results/free/, results/full/: takt-harness readings (.json) and summaries (.log) for every workload on both machines; results/equiv/SUMMARY.md: the equivalence summary.
• LICENSE: MIT, for the scripts and readings in this directory.