hessboost 0.2.4__tar.gz → 0.3.0__tar.gz

{hessboost-0.2.4 → hessboost-0.3.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hessboost"
-version = "0.2.4"
+version = "0.3.0"
 edition = "2024"
 rust-version = "1.93"
 license = "Apache-2.0"
@@ -24,8 +24,9 @@ include = [
 readme = "README.md"
 
 # docs.rs builds on Linux, where the `wgpu` backend compiles (its drivers
-# load at run time) and `metal` cannot (no Apple SDK), so the wgpu module's
-# real docs render there and Metal's stand-in does.
+# load at run time) and neither `metal` (no Apple SDK) nor `cuda` (no CUDA
+# toolkit headers for `cuda-bindings`) does, so wgpu's real docs render
+# there and the Metal and CUDA modules' stand-ins do.
 [package.metadata.docs.rs]
 features = ["wgpu"]
 
@@ -63,6 +64,17 @@ metal = ["dep:objc2", "dep:objc2-metal", "dep:objc2-foundation"]
 # histogram training (`device = wgpu`) and prediction
 # (`BoostedModel::to_wgpu`). Opt-in and off by default; see `src/backend/`.
 wgpu = ["dep:wgpu", "dep:bytemuck", "dep:parking_lot"]
+# NVIDIA CUDA acceleration for histogram training and prediction on Linux.
+# Opt-in and off by default. The kernels are embedded PTX (Rust compiled by
+# cuda-oxide, `cuda-kernels/`); the host side is cuda-oxide's `cuda-core`,
+# which loads `libcuda` (the driver, CUDA 12.8 or later) at run time.
+# Building it needs the CUDA 13 toolkit's `cuda.h` and `curand.h` and
+# libclang (`cuda-bindings` generates its bindings from them); see AGENTS.md
+# and `src/backend/`.
+cuda = ["dep:cuda-core", "dep:parking_lot"]
+
+[target.'cfg(target_os = "linux")'.dependencies]
+cuda-core = { version = "0.4", optional = true }
 
 [target.'cfg(target_os = "macos")'.dependencies]
 objc2 = { version = "0.6", default-features = false, features = ["std"], optional = true }

hessboost-0.3.0/LICENSE.txt

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

{hessboost-0.2.4 → hessboost-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hessboost
-Version: 0.2.4
+Version: 0.3.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -19,12 +19,15 @@ Classifier: Programming Language :: Rust
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Typing :: Typed
 Requires-Dist: numpy>=2
+Requires-Dist: hessboost-runtime-cuda==0.3.0 ; sys_platform == 'linux' and extra == 'cuda'
 Requires-Dist: pandas>=2.2 ; extra == 'pandas'
 Requires-Dist: polars>=1.0 ; extra == 'polars'
 Requires-Dist: scikit-learn>=1.6 ; extra == 'scikit-learn'
+Provides-Extra: cuda
 Provides-Extra: pandas
 Provides-Extra: polars
 Provides-Extra: scikit-learn
+License-File: LICENSE.txt
 Summary: Fast, deterministic gradient boosting in Rust: conformal intervals, explainable boosting machines, distributional boosting, and tree-based diffusion
 Keywords: xgboost,gradient-boosting,gbdt,machine-learning,decision-trees,rust
 Author-email: Brenden Matthews <brenden@brndn.io>
@@ -65,17 +68,19 @@ UBJSON.
 uv add hessboost        # or: pip install hessboost
 ```
 
-Extras: `hessboost[pandas]`, `hessboost[polars]`, and
-`hessboost[scikit-learn]`. numpy is the only required dependency.
+Extras: `hessboost[pandas]`, `hessboost[polars]`, `hessboost[scikit-learn]`,
+and `hessboost[cuda]` for NVIDIA GPUs on Linux (see
+[GPU training and prediction](#gpu-training-and-prediction)). numpy is the
+only required dependency.
 
 Prebuilt wheels are published for Linux x86_64 and aarch64 (glibc
 manylinux and musl/Alpine musllinux), macOS arm64, and Windows x86_64: one
 `abi3` wheel per platform for CPython 3.11 and newer, plus a wheel for
 free-threaded CPython 3.14t. Every wheel trains and predicts on a GPU
 through wgpu (Vulkan, Metal, DirectX 12), and the macOS wheels also through
-native Metal (see [GPU training and prediction](#gpu-training-and-prediction)).
-Elsewhere the installer builds from the source distribution, which needs
-Rust 1.93 or newer and a C compiler (for libzstd).
+native Metal; CUDA comes only with the `cuda` extra. Elsewhere the
+installer builds from the source distribution, which needs Rust 1.93 or
+newer and a C compiler (for libzstd).
 
 ## Quick start
 
@@ -511,13 +516,18 @@ models save and load like `DiffusionModel`s.
 
 ### GPU training and prediction
 
-Two GPU backends reproduce the CPU's results bit for bit: native Metal
-(`"metal"`, macOS) and wgpu (`"wgpu"`: Vulkan on Linux and Windows, Metal
-on macOS, DirectX 12 on Windows). `Booster.to_gpu()` lays a model out for
-batch prediction (on Metal on macOS and on wgpu elsewhere;
-`to_gpu("wgpu")` asks for wgpu): the forest uploads once, and each call
-predicts bit-identically to `Booster.predict` (values or raw margins).
-`GpuModel.available()` says whether the device can predict here:
+Three GPU backends reproduce the CPU's results bit for bit: native Metal
+(`"metal"`, macOS), wgpu (`"wgpu"`: Vulkan on Linux and Windows, Metal on
+macOS, DirectX 12 on Windows), and NVIDIA CUDA (`"cuda"` or
+`"cuda:<ordinal>"`, Linux, with `hessboost[cuda]`; see below).
+`Booster.to_gpu()` lays a model out for batch
+prediction (on Metal on macOS and on wgpu elsewhere; `to_gpu("wgpu")` asks
+for wgpu, `to_gpu("cuda:1")` for the second NVIDIA GPU): the forest
+uploads once, and each call predicts bit-identically to `Booster.predict`
+(values or raw margins). Objective transforms run on the CPU; models
+trained with model shrinkage predict on the CPU. `gblinear` and
+linear-leaf models are refused. `GpuModel.available()` says whether the
+device can predict here:
 
 ```python
 from hessboost import GpuModel
@@ -527,8 +537,8 @@ if GpuModel.available():
     probabilities = gpu.predict(X_test)
 ```
 
-Training with `device="metal"` or `device="wgpu"` builds the larger nodes'
-histograms on the GPU and gives the CPU's model bit for bit:
+Training with `device="metal"`, `device="wgpu"` or `device="cuda"` builds
+histograms on the selected GPU and gives the CPU's model bit for bit:
 
 ```python
 booster = hessboost.train({"device": "wgpu", "max_depth": 6}, dtrain, 100)
@@ -542,6 +552,31 @@ as Mesa's lavapipe (correct, but slower than the CPU) only when there is no
 other; `GpuModel.device_name("wgpu")` names the adapter it picked, and the
 `WGPU_ADAPTER_NAME` environment variable picks one by name.
 
+The plain package needs no CUDA; CUDA support is the `cuda` extra:
+
+```sh
+uv add 'hessboost[cuda]'        # or: pip install 'hessboost[cuda]'
+```
+
+It installs `hessboost-runtime-cuda`, hessboost's extension built with CUDA
+kernels (Rust compiled to PTX by cuda-oxide), which `import hessboost` loads
+in place of its own. Its wheels cover x86_64 and aarch64 glibc Linux; on
+other Linux platforms the installer builds it from source, which also needs
+CUDA 13's driver and cuRAND headers and libclang. Both packages must come
+from the same release: `import hessboost` refuses to load beside a
+`hessboost-runtime-cuda` of another release. Running needs no CUDA toolkit,
+only an NVIDIA GPU of compute capability 7.5 (Turing) or newer and a driver
+supporting CUDA 12.8 or newer, which compiles the kernels for the GPU on
+first use and caches them. A missing driver or device, or an installation
+without the CUDA runtime, returns an error rather than silently predicting
+on the CPU.
+
+```python
+if GpuModel.available("cuda"):
+    gpu = booster.to_gpu("cuda")
+    probabilities = gpu.predict(X_test)
+```
+
 ### Compact models
 
 `Booster.to_compact()` packs the trees default prediction uses into
@@ -643,17 +678,18 @@ LightGBM's `rank_xendcg` stream.
   scikit-learn behavior); pass `iteration_range=(0, 0)` for all. SHAP and
   leaf ranges start at iteration 0; `pred_leaf` defaults to every iteration
   instead, and returns `int32`.
-- GPUs: `device="metal"` (macOS) or `device="wgpu"` trains on one instead of
-  `device="cuda"`, and `Booster.to_gpu()` lays the model out for GPU batch
-  prediction (`GpuModel.predict`, bit-identical to `Booster.predict`)
-  instead of predicting on the training device.
+- GPUs: besides XGBoost's `device="cuda"`/`"cuda:<ordinal>"` (NVIDIA on
+  Linux, with `hessboost[cuda]`), `device="metal"` (macOS) and
+  `device="wgpu"` train on a GPU.
+  Prediction does not follow the training device: `Booster.to_gpu(device)`
+  lays the model out for GPU batch prediction (`GpuModel.predict`,
+  bit-identical to `Booster.predict`), taking the same GPU `device` strings.
 - Model files do not store feature names or categories (pickles do).
 - Not available: `DMatrix` from files or `QuantileDMatrix`, `inplace_predict`
   (`predict` takes arrays directly, and `predict_row` single rows),
   `Booster.get_dump`/`trees_to_dataframe`/`dump_model` (`model_info()`
   returns the trees as arrays), attributes (`set_attr`), plotting,
-  distributed (Dask/Spark) and CUDA training, `approx_contribs`, and
-  `strict_shape`.
+  distributed (Dask/Spark), `approx_contribs`, and `strict_shape`.
 
 ## Development
 
@@ -666,6 +702,10 @@ uv run --locked pytest
 uv run --locked pyright --verifytypes hessboost --ignoreexternal
 ```
 
+On Linux, with CUDA 13's headers in `CUDA_HOME` and libclang,
+`uv sync --locked --extra cuda` also builds the CUDA runtime from
+`runtime-cuda/`, and `uv run --locked --extra cuda pytest` tests against it.
+
 Lint, format, and type-check all of the repository's Python from its root
 (configuration: `ruff.toml`, `ty.toml`):
 

{hessboost-0.2.4 → hessboost-0.3.0}/README.md

@@ -41,7 +41,7 @@ cargo add hessboost
 For users pinning a release series in a Cargo manifest:
 
 ```toml
-hessboost = "0.2"
+hessboost = "0.3"
 ```
 
 Needs Rust 1.93 or newer and a C compiler (to build libzstd).
@@ -139,7 +139,8 @@ LazyFrames, with labels taken from the frame's columns by name) categorical
 input, and the conformal, distributional, tree-diffusion, ForestFlow,
 in-place update, ordered target statistics, budget training, and compact
 model extras, with GPU training and batch prediction (`device="wgpu"` on
-every platform, `device="metal"` on macOS; `Booster.to_gpu()`):
+every platform, `device="metal"` on macOS, and `device="cuda"` on Linux with
+`pip install 'hessboost[cuda]'`; `Booster.to_gpu()`):
 
 ```python
 import hessboost
@@ -179,6 +180,7 @@ See [`python/README.md`](python/README.md).
   - [Budget training](https://docs.rs/hessboost/latest/hessboost/training/budget/): Training controlled by one budget value, based on PerpetualBooster.
   - [Metal GPU](https://docs.rs/hessboost/latest/hessboost/backend/metal/): Apple Silicon GPU prediction and training (`--features metal`).
   - [wgpu GPU](https://docs.rs/hessboost/latest/hessboost/backend/wgpu/): Vulkan, Metal, and DirectX 12 GPU prediction and training through wgpu (`--features wgpu`), bit-identical to the CPU.
+  - [CUDA GPU](https://docs.rs/hessboost/latest/hessboost/backend/cuda/): NVIDIA GPU prediction and training on Linux (`--features cuda`; building it needs CUDA 13's headers and libclang), bit-identical to the CPU.
 
 ## Caveats
 
@@ -189,7 +191,6 @@ See [`python/README.md`](python/README.md).
 
 - Distributed and external-memory training.
 - CLI and C bindings.
-- CUDA. GPU training runs through Metal (macOS) or wgpu (Vulkan, Metal, DirectX 12).
 - A few XGBoost options exist at one setting only, and a few metrics are
   missing; the [API docs](https://docs.rs/hessboost/latest/hessboost/#not-implemented)
   list them.

{hessboost-0.2.4 → hessboost-0.3.0}/benches/training.rs

@@ -1378,6 +1378,131 @@ fn bench_wgpu(c: &mut Criterion) {
 #[cfg(not(feature = "wgpu"))]
 fn bench_wgpu(_c: &mut Criterion) {}
 
+/// CUDA GPU benches (`cargo bench --features cuda` on Linux with an NVIDIA
+/// GPU): histogram construction and end-to-end training, each against its
+/// CPU counterpart on identical data. The GPU results are bit-identical to
+/// the CPU's, so the benches compare speed only; the per-node strategy
+/// counts are printed so a run shows how much of the work reached the GPU.
+#[cfg(all(target_os = "linux", feature = "cuda"))]
+fn bench_cuda(c: &mut Criterion) {
+    use hessboost::backend::cuda;
+    use hessboost::backend::cuda::CudaHistBackend;
+    use hessboost::config::Device;
+
+    if let Some(reason) = cuda::unavailable_reason(0) {
+        eprintln!("skipping cuda benches: {reason}");
+        return;
+    }
+    eprintln!("cuda device: {}", cuda::device_name(0).unwrap_or_default());
+    {
+        let mut group = c.benchmark_group("cuda_histogram_build");
+        group.sample_size(10);
+        for &n in &[1_000_000usize, 10_000_000] {
+            let (ghist, gpair, rows) = histogram_case(&make_data(n, 30));
+            let gpu = CudaHistBackend::new(&ghist, 0).unwrap();
+            gpu.prepare(&ghist, &gpair);
+            let mut cpu_out = zeroed(ghist.total_bins());
+            let mut gpu_out = zeroed(ghist.total_bins());
+            group.throughput(Throughput::Elements(n as u64));
+            group.bench_with_input(BenchmarkId::new("cpu", n), &n, |b, _| {
+                b.iter(|| CpuBackend.build(&ghist, &rows, &gpair, &mut cpu_out));
+            });
+            group.bench_with_input(BenchmarkId::new("cuda", n), &n, |b, _| {
+                b.iter(|| gpu.build(&ghist, &rows, &gpair, &mut gpu_out));
+            });
+            assert!(
+                cuda::available(0),
+                "CUDA benchmark fell back: {:?}",
+                cuda::unavailable_reason(0)
+            );
+            eprintln!("cuda_histogram_build/{n}: {:?}", gpu.node_counts());
+        }
+        group.finish();
+    }
+    {
+        let data = make_data(1_000_000, 30);
+        let mut group = c.benchmark_group("cuda_train_1m_x30_20rounds_depth8");
+        group.sample_size(10);
+        for (name, device) in [("cpu", Device::Cpu), ("cuda", Device::Cuda { ordinal: 0 })] {
+            let params = TrainingParams::builder()
+                .objective(Objective::SquaredError(RegLoss::default()))
+                .tree_method(TreeMethod::Hist)
+                .max_depth(8)
+                .eta(0.1)
+                .device(device)
+                .build()
+                .unwrap();
+            group.bench_function(name, |b| {
+                b.iter(|| black_box(train(&params, &data, 20).unwrap()));
+            });
+            if matches!(device, Device::Cuda { .. }) {
+                assert!(
+                    cuda::available(0),
+                    "CUDA benchmark fell back: {:?}",
+                    cuda::unavailable_reason(0)
+                );
+            }
+        }
+        group.finish();
+    }
+    {
+        let mut group = c.benchmark_group("cuda_train_variants_200k_x30_20rounds_depth6");
+        group.sample_size(10);
+        for (case, data, policy) in [
+            (
+                "categorical",
+                make_categorical_data(200_000, 30),
+                GrowPolicy::DepthWise,
+            ),
+            ("lossguide", make_data(200_000, 30), GrowPolicy::LossGuide),
+            ("csr", make_csr_data(200_000, 30), GrowPolicy::DepthWise),
+        ] {
+            for (engine, device) in [("cpu", Device::Cpu), ("cuda", Device::Cuda { ordinal: 0 })] {
+                let params = base_hist_params()
+                    .grow_policy(policy)
+                    .max_leaves(64)
+                    .device(device)
+                    .build()
+                    .unwrap();
+                group.bench_function(format!("{case}/{engine}"), |b| {
+                    b.iter(|| black_box(train(&params, &data, 20).unwrap()));
+                });
+                if matches!(device, Device::Cuda { .. }) {
+                    assert!(
+                        cuda::available(0),
+                        "CUDA benchmark fell back: {:?}",
+                        cuda::unavailable_reason(0)
+                    );
+                }
+            }
+        }
+        group.finish();
+    }
+    {
+        let model_data = make_data(100_000, 30);
+        let model = trained_model(&model_data, 100);
+        let gpu = model.to_cuda(0).unwrap();
+        let data = make_data(500_000, 30);
+        // Warm both paths outside timing; CUDA context/forest upload stays
+        // separate from reused-predictor timings, input transfers stay inside.
+        model.predict_margin(&data, ..).unwrap();
+        gpu.predict_margin(&data, ..).unwrap();
+        let mut group = c.benchmark_group("cuda_predict_500k_x30_100trees_depth6");
+        group.sample_size(10);
+        group.throughput(Throughput::Elements(data.n_rows() as u64));
+        group.bench_function("cpu", |b| {
+            b.iter(|| model.predict_margin(black_box(&data), ..).unwrap());
+        });
+        group.bench_function("cuda", |b| {
+            b.iter(|| gpu.predict_margin(black_box(&data), ..).unwrap());
+        });
+        group.finish();
+    }
+}
+
+#[cfg(not(all(target_os = "linux", feature = "cuda")))]
+fn bench_cuda(_c: &mut Criterion) {}
+
 criterion_group!(
     benches,
     bench_histogram_build,
@@ -1399,6 +1524,7 @@ criterion_group!(
     bench_data_prep,
     bench_ebm_fast,
     bench_metal,
-    bench_wgpu
+    bench_wgpu,
+    bench_cuda
 );
 criterion_main!(benches);

{hessboost-0.2.4 → hessboost-0.3.0}/examples/bench_compare.rs

@@ -20,8 +20,11 @@ fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
     let x_test = read_f32(&dir.join("X_test.bin"))?;
     let y_test = read_f32(&dir.join("y_test.bin"))?;
     let dtest = DMatrix::from_dense(&x_test, meta.n_test, meta.n_cols)?.with_labels(&y_test)?;
-    // The XGBoost parameter dict `scripts/bench_xgb.py` trains XGBoost with.
+    // The XGBoost parameter dict `scripts/bench_xgb.py` trains XGBoost with;
+    // `BENCH_DEVICE` is its `--device` (`cpu` unless set).
+    let device = std::env::var("BENCH_DEVICE").unwrap_or_else(|_| "cpu".to_owned());
     let mut xgboost = vec![
+        ("device", json!(device)),
         ("objective", json!(meta.objective)),
         ("tree_method", json!("hist")),
         ("grow_policy", json!("depthwise")),
@@ -52,6 +55,12 @@ fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
         let dtrain = DMatrix::from_dense(&x, meta.n_rows, meta.n_cols)?.with_labels(&y)?;
         let model = train(&params, &dtrain, meta.num_round)?;
         let elapsed = start.elapsed().as_secs_f64();
+        #[cfg(all(target_os = "linux", feature = "cuda"))]
+        if let hessboost::config::Device::Cuda { ordinal } = params.device
+            && let Some(reason) = hessboost::backend::cuda::unavailable_reason(ordinal)
+        {
+            return Err(format!("CUDA timing is invalid after fallback: {reason}").into());
+        }
         if run > 0 {
             samples.push(elapsed);
         }

{hessboost-0.2.4 → hessboost-0.3.0}/pyproject.toml

@@ -9,6 +9,10 @@ description = "Fast, deterministic gradient boosting in Rust: conformal interval
 readme = "README.md"
 requires-python = ">=3.11"
 license = "Apache-2.0"
+# A copy of the repository's LICENSE: `license-files` cannot reach `..`, and
+# the sdist already holds the root crate's `LICENSE`. publish.yml checks
+# that every distribution carries it.
+license-files = ["LICENSE.txt"]
 authors = [{ name = "Brenden Matthews", email = "brenden@brndn.io" }]
 keywords = ["xgboost", "gradient-boosting", "gbdt", "machine-learning", "decision-trees", "rust"]
 classifiers = [
@@ -33,6 +37,10 @@ classifiers = [
 dependencies = ["numpy>=2"]
 
 [project.optional-dependencies]
+# The CUDA runtime: the extension built with CUDA, which the package then
+# loads in place of its own (`hessboost/_hessboost.py`). Linux only, and
+# always this release (release.py bumps the pin with the version).
+cuda = ["hessboost-runtime-cuda==0.3.0; sys_platform == 'linux'"]
 pandas = ["pandas>=2.2"]
 # 1.x and 2.x: uv.lock tests the latest, CI also the oldest and latest 1.x.
 polars = ["polars>=1.0"]
@@ -73,7 +81,7 @@ dev = [{ include-group = "lint" }, "maturin>=1.15,<2"]
 # Every build (maturin CLI, `uv sync`/`uv run`, pip from the sdist) uses the
 # committed Cargo.lock and fails instead of updating it.
 locked = true
-module-name = "hessboost._hessboost"
+module-name = "hessboost._native"
 manifest-path = "python/Cargo.toml"
 python-source = "python"
 
@@ -92,4 +100,19 @@ cache-keys = [
   { file = "src/**/*.rs" },
   { file = "../Cargo.toml" },
   { file = "../src/**/*.rs" },
+  { file = "../src/**/*.ptx" },
+  { env = "MATURIN_PEP517_ARGS" },
 ]
+
+[tool.uv.sources]
+# `uv sync --extra cuda` builds the CUDA runtime from `runtime-cuda/` (which
+# needs the CUDA headers and libclang, see AGENTS.md) rather than fetching a
+# published wheel. uv ignores this table when hessboost is a dependency.
+hessboost-runtime-cuda = { path = "runtime-cuda" }
+
+# uv builds the CUDA runtime concurrently with `hessboost` from the same
+# crate, and maturin stages both extensions at one path in the Cargo target
+# directory; a separate `runtime-cuda/target` keeps each wheel from packaging
+# the other's extension.
+[tool.uv.extra-build-variables]
+hessboost-runtime-cuda = { CARGO_TARGET_DIR = "target" }