Falcata

KO | EN

gitlite — search

#list #security #awesome #java #video #kubernetes #golang #framework #artificial-intelligence #anthropic

(★ 9)

GPU-first gradient boosted decision trees. Fastest-growing tree.

파일 탐색기

ZIP 다운로드

- - ci-core.txt
  - README.md
- - requirements-latest.txt
  - requirements-oldest.txt
- append-comment.sh
- build-docs.R
- build-docs.sh
- check-dynamic-dependencies.sh
- check-omp-pragmas.sh
- check-python-dists.sh
- check-workflow-status.sh
- download-artifacts.sh
- gen-c-api-compat.py
- install-opencl.ps1
- install-r-deps.R
- lint-all.sh
- lint-powershell.ps1
- lint-r-code.R
- parameter-generator.py
- rerun-workflow.sh
- run-r-cmd-check.sh
- set-commit-status.sh
- setup.sh
- test-python-latest.sh
- test-python-oldest.sh
- test-r-package-valgrind.sh
- test-r-package-windows.ps1
- test-r-package.sh
- test-windows.ps1
- test.sh
- - build.yml
  - cpp.yml
  - cuda.yml
  - lychee.yml
  - optional_checks.yml
  - python_package.yml
  - python_tests.yml
  - r_configure.yml
  - r_package.yml
  - r_valgrind.yml
  - release_drafter.yml
  - static_analysis.yml
  - swig.yml
- dependabot.yml
- release-drafter.yml
- - lean_construct_ab.cu
  - occ_sweep.cu
  - README.md
- - construct_ab.cu
  - README.md
  - roofline_micro.cu
- ablation.py
- ablation_2026-07-30.txt
- ablation_2026-08-09.txt
- bench.py
- common.py
- datasets.py
- ingest_bench.py
- orchestrate.py
- README.md
- report.py
- requirements.txt
- setup_envs.sh
- tc_hist_prototype.cu
- - FindLibR.cmake
  - FindNCCL.cmake
- IntegratedOpenCL.cmake
- Sanitizer.cmake
- dockerfile-cli
- dockerfile-python
- dockerfile-r
- README.md
- - binary-model-format-plan.md
  - construct-find-jit-levers.md
  - construct-partition-reduction.md
  - format-compatibility.md
  - multi-target-training.md
  - nccl-level-allreduce-plan.md
  - nvrtc-construct-jit.md
  - pack-codecs.md
  - static-planner-tier0.md
  - vector-leaf-plan.md
- - falcata-icon-16.png
  - falcata-icon-180.png
  - falcata-icon-32.png
  - falcata-icon-512.png
  - falcata-icon-64.png
  - falcata-icon.svg
  - falcata-mark-180.png
  - falcata-mark-256.png
  - falcata-mark-512.png
  - falcata-mark.svg
  - README.md
- - ablation_compact_quant.png
  - ablation_fast_rowdata.png
  - construct_time.png
  - cross_library_deep.png
  - generate.py
  - gpu_memory.png
  - hybrid_ablation.png
  - hybrid_growth_diagram.png
  - hybrid_selective_prune.png
  - model_size.png
  - quant_modes.png
  - time_to_quality.png
- .lychee.toml
- Advanced-Topics.rst
- build-docs.sh
- C-API.rst
- conf.py
- Development-Guide.rst
- env.yml
- Features.rst
- index.rst
- Installation-Guide.rst
- Makefile
- Parallel-Learning-Guide.rst
- Parameters-Tuning.rst
- Parameters.rst
- perf-dead-ends.md
- performance.md
- Python-API.rst
- Python-Intro.rst
- Quick-Start.rst
- README.rst
- - binary.test
  - binary.test.weight
  - binary.train
  - binary.train.weight
  - forced_splits.json
  - predict.conf
  - README.md
  - train.conf
  - train_linear.conf
- - predict.conf
  - rank.test
  - rank.test.query
  - rank.train
  - rank.train.query
  - README.md
  - train.conf
- - multiclass.test
  - multiclass.train
  - predict.conf
  - README.md
  - train.conf
- - binary.test
  - binary.train
  - mlist.txt
  - predict.conf
  - README.md
  - train.conf
- - advanced_example.py
  - dataset_from_multi_hdf5.py
  - logistic_regression.py
  - plot_example.py
  - README.md
  - simple_example.py
  - sklearn_example.py
- - forced_bins.json
  - forced_bins2.json
  - predict.conf
  - README.md
  - regression.test
  - regression.test.init
  - regression.train
  - regression.train.init
  - train.conf
- - predict.conf
  - rank.test
  - rank.test.query
  - rank.train
  - rank.train.query
  - README.md
  - train.conf
- README.md
- - nccl.h
- compute
- eigen
- fast_double_parser
- fmt
- nanoarrow
- - application.h
  - arrow.h
  - bin.h
  - boosting.h
  - c_api.h
  - c_api_compat.h
  - config.h
  - dataset.h
  - dataset_loader.h
  - export.h
  - falcata_plan.h
  - feature_group.h
  - meta.h
  - metric.h
  - network.h
  - objective_function.h
  - prediction_early_stop.h
  - sample_strategy.h
  - train_share_states.h
  - tree.h
  - tree_learner.h
  - tree_split_math.h
- - __init__.py
  - __main__.py
  - basic.py
  - callback.py
  - compat.py
  - dask.py
  - engine.py
  - importers.py
  - libpath.py
  - oblique.py
  - plotting.py
  - py.typed
  - sklearn.py
- pyproject.toml
- README.rst
- - agaricus.test.rda
  - agaricus.train.rda
  - bank.rda
- - 00Index
  - basic_walkthrough.R
  - boost_from_prediction.R
  - categorical_features_rules.R
  - cross_validation.R
  - early_stopping.R
  - efficient_many_training.R
  - leaf_stability.R
  - multiclass.R
  - multiclass_custom_objective.R
  - weight_param.R
- - make-r-def.R
  - Makevars
  - Makevars.win
- - agaricus.test.Rd
  - agaricus.train.Rd
  - bank.Rd
  - dim.Rd
  - dimnames.lgb.Dataset.Rd
  - falcata.Rd
  - get_field.Rd
  - getLGBMThreads.Rd
  - getLGBMthreads.Rd
  - lgb.configure_fast_predict.Rd
  - lgb.convert_with_rules.Rd
  - lgb.cv.Rd
  - lgb.Dataset.construct.Rd
  - lgb.Dataset.create.valid.Rd
  - lgb.Dataset.Rd
  - lgb.Dataset.save.Rd
  - lgb.Dataset.set.categorical.Rd
  - lgb.Dataset.set.reference.Rd
  - lgb.drop_serialized.Rd
  - lgb.dump.Rd
  - lgb.get.eval.result.Rd
  - lgb.importance.Rd
  - lgb.interpret.Rd
  - lgb.interprete.Rd
  - lgb.load.Rd
  - lgb.make_serializable.Rd
  - lgb.model.dt.tree.Rd
  - lgb.plot.importance.Rd
  - lgb.plot.interpretation.Rd
  - lgb.restore_handle.Rd
  - lgb.save.Rd
  - lgb.slice.Dataset.Rd
  - lgb.train.Rd
  - lgb_predict_shared_params.Rd
  - lgb_shared_dataset_params.Rd
  - lgb_shared_params.Rd
  - predict.lgb.Booster.Rd
  - print.lgb.Booster.Rd
  - set_field.Rd
  - setLGBMThreads.Rd
  - setLGBMthreads.Rd
  - summary.lgb.Booster.Rd
- - _pkgdown.yml
- - aliases.R
  - callback.R
  - lgb.Booster.R
  - lgb.convert_with_rules.R
  - lgb.cv.R
  - lgb.DataProcessor.R
  - lgb.Dataset.R
  - lgb.drop_serialized.R
  - lgb.importance.R
  - lgb.interpret.R
  - lgb.make_serializable.R
  - lgb.model.dt.tree.R
  - lgb.plot.importance.R
  - lgb.plot.interpretation.R
  - lgb.Predictor.R
  - lgb.restore_handle.R
  - lgb.train.R
  - lightgbm.R
  - metrics.R
  - multithreading.R
  - utils.R
- - falcata-win.def
  - falcata_R.cpp
  - falcata_R.h
  - install.libs.R
  - Makevars.in
  - Makevars.win.in
- - testthat.R
- - basic_walkthrough.Rmd
- .Rbuildignore
- AUTOCONF_UBUNTU_VERSION
- cleanup
- configure
- configure.ac
- configure.win
- DESCRIPTION
- LICENSE
- NAMESPACE
- README.md
- recreate-configure.sh
- - application.cpp
  - predictor.hpp
- - array.hpp
- - bagging.hpp
  - boosting.cpp
  - dart.hpp
  - falb.h
  - gbdt.cpp
  - gbdt.h
  - gbdt_model_binary.cpp
  - gbdt_model_text.cpp
  - gbdt_prediction.cpp
  - goss.hpp
  - prediction_early_stop.cpp
  - rf.hpp
  - sample_strategy.cpp
  - score_updater.hpp
- - cuda_algorithms.cu
  - cuda_driver_shim.cpp
  - cuda_utils.cpp
  - nccl_shim.cpp
- - bin.cpp
  - config.cpp
  - config_auto.cpp
  - dataset.cpp
  - dataset_loader.cpp
  - dense_bin.hpp
  - file_io.cpp
  - json11.cpp
  - metadata.cpp
  - multi_val_dense_bin.hpp
  - multi_val_sparse_bin.hpp
  - parser.cpp
  - parser.hpp
  - sparse_bin.hpp
  - train_share_states.cpp
  - tree.cpp
- - binary_metric.hpp
  - dcg_calculator.cpp
  - map_metric.hpp
  - metric.cpp
  - multiclass_metric.hpp
  - rank_metric.hpp
  - regression_metric.hpp
  - xentropy_metric.hpp
- - linker_topo.cpp
  - linkers.h
  - linkers_mpi.cpp
  - linkers_socket.cpp
  - network.cpp
  - socket_wrapper.hpp
- - binary_objective.hpp
  - multi_regression_objective.hpp
  - multiclass_objective.hpp
  - objective_function.cpp
  - rank_objective.hpp
  - regression_objective.hpp
  - xentropy_objective.hpp
- - col_sampler.hpp
  - cost_effective_gradient_boosting.hpp
  - data_parallel_tree_learner.cpp
  - data_partition.hpp
  - feature_histogram.cpp
  - feature_histogram.hpp
  - feature_parallel_tree_learner.cpp
  - gpu_tree_learner.cpp
  - gpu_tree_learner.h
  - gradient_discretizer.cpp
  - gradient_discretizer.hpp
  - leaf_splits.hpp
  - linear_leaf_solver.h
  - linear_tree_learner.cpp
  - linear_tree_learner.h
  - monotone_constraints.hpp
  - parallel_tree_learner.h
  - serial_tree_learner.cpp
  - serial_tree_learner.h
  - split_info.hpp
  - tree_learner.cpp
  - voting_parallel_tree_learner.cpp
- - openmp_wrapper.cpp
- c_api.cpp
- main.cpp
- ChunkedArray_API_extensions.i
- falcatalib.i
- pointer_manipulation.i
- StringArray.hpp
- StringArray.i
- StringArray_API_extensions.i
- - test_.py
- - predict.conf
  - test.py
  - test_array_args.cpp
  - test_arrow.cpp
  - test_arrow_deprecated.cpp
  - test_byte_buffer.cpp
  - test_chunked_array.cpp
  - test_common.cpp
  - test_main.cpp
  - test_serialize.cpp
  - test_single_row.cpp
  - test_stream.cpp
  - testutils.cpp
  - testutils.h
  - train.conf
- - categorical.data
- - _test_distributed.py
  - conftest.py
- - bench_tier.py
  - canonical.py
  - ci_build.sh
  - cpp_suite.sh
  - falb_compat.py
  - falb_fuzz.py
  - falb_golden.json
  - falb_golden.py
  - falb_python.py
  - falb_roundtrip.py
  - fuzz.py
  - fuzz_corpus.json
  - gpu_guard.py
  - import_catboost.py
  - import_xgboost.py
  - lattice.py
  - leaf_integrity.py
  - md5_lattice.json
  - nibble_validate.py
  - nightly_local.sh
  - perf_gate.py
  - README.md
  - selective_equivalence.py
  - sparse_column_view.py
  - valid_metric.py
- - __init__.py
  - conftest.py
  - test_arrow.py
  - test_basic.py
  - test_callback.py
  - test_chunked_device_dataset.py
  - test_consistency.py
  - test_constant_tree_serialization.py
  - test_dask.py
  - test_device_memory.py
  - test_dual.py
  - test_engine.py
  - test_leaf_integrity.py
  - test_oblique.py
  - test_plotting.py
  - test_polars.py
  - test_sklearn.py
  - test_sparse_column_view.py
  - test_utilities.py
  - test_vector_leaf.py
  - test_vector_leaf_cuda.py
  - utils.py
- - Dockerfile
- build-release-wheel.sh
- release-preflight.sh
- Falcata.sln
- Falcata.vcxproj
- Falcata.vcxproj.filters
.dockerignore
.editorconfig
.git-blame-ignore-revs
.gitattributes
.gitignore
.gitmodules
.pre-commit-config.yaml
.typos.toml
.yamllint.yml
biome.json
build-cran-package.sh
build-python.sh
build_r.R
CMakeLists.txt
CONTRIBUTING.md
LICENSE
MAINTAINING.md
NOTICE
pixi.lock
pixi.toml
README.md
ROADMAP.md
VERSION.txt

# CDN으로 사용하기

jsDelivr

jsDelivr는 공개 GitHub 리포지토리를 별도 설정 없이 CDN으로 즉시 서빙합니다. 버전과 파일을 고르면 웹페이지에 바로 붙일 수 있는 링크와 예시 코드가 만들어집니다.

버전

파일

링크

예시

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

Falcata
=======

GPU-first gradient boosted decision trees.

*Falcataria moluccana* — the falcata — is one of the fastest-growing trees on
earth. This one grows them faster too.

Falcata is a CUDA-native GBDT library: a leaf-wise learner whose training loop
was rebuilt around batched, level-parallel GPU kernels rather than one split at
a time.

What makes it fast
------------------

- **Hybrid level-batched growth.** Whole levels of sibling pairs are scored,
  synchronized, and applied in one launch each instead of per split — turning a
  latency-bound loop into a throughput-bound one, with leaf-wise-identical
  trees.
- **CUDA-graph level loops.** The per-level launch sequence is captured once and
  replayed by a device-side controller, removing host round-trips from the
  inner loop on shallow trees.
- **NVRTC runtime JIT.** Construct kernels are specialized at runtime to the
  actual data shape (bin count, column layout), self-tested against the
  ahead-of-time kernel, and promoted only if bit-identical.
- **Per-tree compact column view.** With any `feature_fraction < 1`, only the
  sampled columns are materialized and gathered for histogram construction.
  The win scales with the excluded fraction: ~3.4× end-to-end training at
  `feature_fraction = 0.1` on wide, low-cardinality data, tapering to ~1.1×
  at 0.6.
- **GPU-native dataset construction.** Dense binning, row-data build, and EFB
  pre-checking run on the device; CuPy and `__cuda_array_interface__` inputs are
  ingested without a host round-trip.
- **Quantized training, two ways.** `quant_mode=stochastic` is the speed end:
  gradients packed into 4 bins with seeded stochastic rounding (unbiased in
  expectation). `quant_mode=fixedpoint` is the near-lossless end: deterministic
  rounding, with an internal outlier-robust gradient scale so rare huge
  gradients don't crush the quantization range. Bin counts default to 4 and 64
  respectively; override with `quant_bins` (any value in `[2, 65534]` —
  training refuses counts whose histogram sums could overflow at your row
  count). Both modes are bit-reproducible — not just run to run, but across GPU
  models and host machines: the same seed trains the bit-identical model on
  any CUDA device (verified sm_89 vs sm_120); `quant_mode=none` is
  full precision.
- **An execution planner.** Shape-conditional kernel choices are resolved once
  from the data and parameters (`cuda_plan=auto`) instead of from a pile of
  environment variables — every decision guaranteed bit-identical, and
  individually overridable for experiments.
- **GPU inference via NVIDIA FIL.** `Booster.predict()` transparently runs on
  cuML's Forest Inference Library when available (see below); CuPy arrays stay
  on the device end to end.

Correctness discipline
----------------------

Every optimization above must be *bit-identical* to the reference path, and
that is enforced mechanically rather than trusted. A regression-gate suite runs
on every commit against a real GPU: a 38-cell lattice of (config × data-shape)
training cells fingerprinted by model md5, plan-flip equality cells that prove
each planner decision changes nothing, validity assertions, metric floors, and
a perf gate against a rolling baseline. A nightly tier adds a config × shape
fuzzer with CPU-parity checks plus full-scale gates on real datasets.

See [tests/gates/README.md](tests/gates/README.md).

Quick start
-----------

```python
import falcata as flc

ds = flc.Dataset(X_train, label=y_train, params={"device_type": "cuda"})
model = flc.train(
    {
        "objective": "regression",
        "device_type": "cuda",
        "num_leaves": 255,
        "quant_mode": "stochastic",   # none | stochastic | fixedpoint
        "cuda_precision": "fp32",     # fp64 (default) | fp32
        "cuda_plan": "auto",          # the planner picks the kernels
    },
    ds,
    num_boost_round=1000,
)
```

GPU inference (NVIDIA FIL)
--------------------------

With cuML installed (`pip install cuml-cu12`), `Booster.predict()` on a
CUDA-trained model transparently runs on NVIDIA's Forest Inference Library —
no API change. 2-D numpy input returns numpy; CuPy (or any
`__cuda_array_interface__` array) stays on the device end to end. Converted
FIL models are cached per iteration slice and invalidated automatically when
the booster changes.

```python
preds = model.predict(X_test)          # numpy in -> numpy out, FIL under the hood
preds = model.predict(cupy_X)          # device in -> device out, no host round-trip
```

- `FALCATA_FIL=0` disables the FIL path; without cuML installed, predict
  silently falls back to the regular CPU predictor.
- `FALCATA_FIL_PRECISION=single` (default) evaluates thresholds in fp32 —
  ~0.01% of rows near a split threshold can route differently than the exact
  predictor; `double` restores exact routing (~1e-13), `native` uses the
  model's own precision.
- Training-time validation metrics (and early stopping) do **not** go through
  FIL: they use the booster's internal evaluation on the attached validation
  set, which is already GPU-resident under `device_type=cuda`.

Install
-------

```bash
pip install falcata
```

On Linux x86_64 this installs a **prebuilt wheel** — no compilation, no CUDA
toolkit needed — with native GPU code for sm_60 through sm_120 (P100, GTX 10xx,
V100, T4, A100, RTX 30xx/40xx, H100, B100/B200, RTX 50xx). A GPU outside that
list fails fast with a message pointing at the source build below.

Everywhere else (and with `pip install --no-binary falcata falcata`), pip
builds from source, which needs the **CUDA toolkit (>= 11.0)**, CMake >= 3.28,
a C++17 compiler and Python >= 3.10. Nothing else:
the source distribution vendors every dependency, so no `git clone` and no
submodule dance.

The build detects the GPU(s) in the machine and **compiles only for those**
(15–20 minutes on typical hardware). When no GPU is visible at build time —
docker build stages, CPU-only CI — it instead targets every architecture the
toolkit supports (sm_60 upward on CUDA 11/12, sm_75 upward on CUDA 13+, plus
PTX for the newest so future cards still run), which takes several times
longer. To build for a card other than the one present, or to pick one
explicitly:

```bash
pip install falcata --config-settings=cmake.define.CMAKE_CUDA_ARCHITECTURES=89
```

No GPU? There is a CPU build, though it is not what this library is for:

```bash
pip install falcata --config-settings=cmake.define.USE_CUDA=OFF
```

**Multi-GPU training** additionally needs NCCL *and its headers* — on
Debian/Ubuntu `sudo apt-get install libnccl2 libnccl-dev`, or
`conda install -c conda-forge nccl`. `BUILD_WITH_SHARED_NCCL` links
`libnccl.so` instead of the static archive, which avoids nvlink failures
against some static NCCL builds on newer architectures:

```bash
pip install falcata \
  --config-settings=cmake.define.USE_NCCL=ON \
  --config-settings=cmake.define.BUILD_WITH_SHARED_NCCL=ON
```

With `USE_NCCL=ON` but no NCCL headers on the include path, configuration
fails with `Could NOT find NCCL (missing: NCCL_INCLUDE_DIR)`.

Build from source (development)
-------------------------------

```bash
git clone https://github.com/MechaFauna-ai/Falcata.git
cd Falcata
git submodule update --init --recursive
sh build-python.sh install --cuda
```

**Windows.** CUDA builds and runs on Windows too (single-GPU). Use the Ninja
generator from an *x64 Native Tools Command Prompt for VS* (so `nvcc` finds
`cl.exe`), then install against the compiled DLL:

```console
cmake -B build -S . -G Ninja -DUSE_CUDA=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build -j
sh ./build-python.sh install --precompile
```

See [docs/Installation-Guide.rst](docs/Installation-Guide.rst) for the details —
notably, use Ninja (not the VS generator), and if `nvcc` rejects your MSVC as an
"unsupported Microsoft Visual Studio version" add
`-DCMAKE_CUDA_FLAGS=-allow-unsupported-compiler`.

Falcata installs under its own name only, so it coexists with stock LightGBM in
one environment; `import lightgbm` keeps resolving to LightGBM.

Compatibility with LightGBM
---------------------------

Falcata began as a fork of LightGBM and deliberately stays interoperable at the
data boundaries:

- **Models** written by Falcata load in stock LightGBM (and vice versa) with
  bit-identical predictions — verified in CI.
- **Binary datasets** (`.dataset`) interchange in both directions.
- **Parameter names** are unchanged; Falcata's additions (`quant_mode`,
  `cuda_precision`, `cuda_plan`) are new names that upstream simply ignores.
- The historical `LGBM_*` C API names remain as aliases for `FLC_*`. The
  Python package is `import falcata` only — code written against
  `import lightgbm` needs its import changed, nothing else.

See [docs/design/format-compatibility.md](docs/design/format-compatibility.md).

Contributing
------------

See [CONTRIBUTING.md](CONTRIBUTING.md). Human and AI contributors are welcome on
the same terms.

License
-------

MIT — see [LICENSE](LICENSE) and [NOTICE](NOTICE). Falcata derives from
LightGBM (copyright Microsoft Corporation and the LightGBM developers, MIT);
that copyright is retained. Falcata is not affiliated with, endorsed by, or
supported by Microsoft or the LightGBM maintainers.

Reference papers
----------------

Falcata builds on the algorithms described in:

- Yu Shi, Guolin Ke, Zhuoming Chen, Shuxin Zheng, Tie-Yan Liu. "[Quantized Training of Gradient Boosting Decision Trees](https://papers.nips.cc/paper_files/paper/2022/hash/77911ed9e6e864ca1a3d165b2c3cb258-Abstract.html)". NeurIPS 2022.
- Guolin Ke, Qi Meng, Thomas Finley, Taifeng Wang, Wei Chen, Weidong Ma, Qiwei Ye, Tie-Yan Liu. "[LightGBM: A Highly Efficient Gradient Boosting Decision Tree](https://papers.nips.cc/paper/6907-lightgbm-a-highly-efficient-gradient-boosting-decision-tree)". NIPS 2017.
- Qi Meng, Guolin Ke, Taifeng Wang, Wei Chen, Qiwei Ye, Zhi-Ming Ma, Tie-Yan Liu. "[A Communication-Efficient Parallel Algorithm for Decision Tree](https://papers.nips.cc/paper/6380-a-communication-efficient-parallel-algorithm-for-decision-tree)". NIPS 2016.
- Huan Zhang, Si Si, Cho-Jui Hsieh. "[GPU Acceleration for Large-scale Tree Boosting](https://arxiv.org/abs/1706.08359)". SysML 2018.

Falcata

파일 탐색기

# CDN으로 사용하기

Was this content helpful?

Recent Feedback

Download README