Metadata-Version: 2.4
Name: cuml-cu12
Version: 26.10.0
Summary: NVIDIA cuML: GPU-Accelerated Machine Learning
Author: NVIDIA Corporation
License-Expression: Apache-2.0
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Project-URL: Homepage, https://github.com/NVIDIA/cuml
Project-URL: Documentation, https://docs.nvidia.com/cuml/latest/
Requires-Python: >=3.11
Requires-Dist: cuda-bindings<13.0,>=12.9.2
Requires-Dist: cuda-toolkit[cublas,cufft,curand,cusolver,cusparse]==12.*
Requires-Dist: cudf-cu12==26.10.*
Requires-Dist: cupy-cuda12x[ctk]!=14.1.0,>=14.0.1
Requires-Dist: joblib>=0.11
Requires-Dist: libcuml-cu12==26.10.*
Requires-Dist: numba-cuda[cu12]>=0.22.2
Requires-Dist: numba<0.65.0,>=0.60.0
Requires-Dist: numpy<3.0,>=2.0
Requires-Dist: nvforest-cu12==26.10.*
Requires-Dist: nvidia-nvjitlink-cu12<13,>=12.9
Requires-Dist: packaging
Requires-Dist: pylibraft-cu12==26.10.*
Requires-Dist: rich
Requires-Dist: rmm-cu12==26.10.*
Requires-Dist: scikit-learn>=1.6
Requires-Dist: scipy>=1.14.0
Requires-Dist: treelite<5.0.0,>=4.7.2
Provides-Extra: test
Requires-Dist: certifi; extra == "test"
Requires-Dist: cython!=3.2.7,>=3.2.2; extra == "test"
Requires-Dist: hdbscan>=0.8.39; extra == "test"
Requires-Dist: hypothesis<7,>=6.0; extra == "test"
Requires-Dist: ipython>=7.32.0; extra == "test"
Requires-Dist: lightgbm; extra == "test"
Requires-Dist: msgspec; extra == "test"
Requires-Dist: nltk; extra == "test"
Requires-Dist: nvidia-ml-py>=12; extra == "test"
Requires-Dist: onnxruntime; extra == "test"
Requires-Dist: pynndescent; extra == "test"
Requires-Dist: pytest; extra == "test"
Requires-Dist: pytest-benchmark; extra == "test"
Requires-Dist: pytest-cov; extra == "test"
Requires-Dist: pytest-xdist; extra == "test"
Requires-Dist: pyyaml; extra == "test"
Requires-Dist: scikit-learn>=1.6; extra == "test"
Requires-Dist: seaborn; extra == "test"
Requires-Dist: shap; extra == "test"
Requires-Dist: skl2onnx; extra == "test"
Requires-Dist: statsmodels; extra == "test"
Requires-Dist: umap-learn<0.5.13,>=0.5.7; extra == "test"
Requires-Dist: xgboost-cu12>=2.1.0; extra == "test"
Provides-Extra: dask
Requires-Dist: dask-cudf-cu12==26.10.*; extra == "dask"
Requires-Dist: raft-dask-cu12==26.10.*; extra == "dask"
Requires-Dist: rapids-dask-dependency==26.10.*; extra == "dask"
Provides-Extra: test-dask
Requires-Dist: dask-cuda==26.10.*; extra == "test-dask"
Requires-Dist: dask-ml>=2024; extra == "test-dask"
Description-Content-Type: text/markdown

# NVIDIA cuML: GPU-Accelerated Machine Learning

NVIDIA cuML is an open-source CUDA-X Data Science library for
GPU-accelerated machine learning. It provides two ways to run machine learning
workloads on NVIDIA GPUs:

- The `cuml` Python API provides GPU-native estimators with familiar
  scikit-learn-style APIs and direct control over machine learning workflows.
- `cuml.accel` accelerates existing scikit-learn, UMAP, and HDBSCAN code without
  changing the Python code that uses those libraries.

On representative benchmarks, cuML can accelerate scikit-learn workflows by
up to 50x. Performance depends on the algorithm, dataset, and hardware. See the
[cuML benchmarks](https://docs.nvidia.com/cuml/latest/cuml-accel/benchmarks/) for
results and methodology.

## Use the GPU-native `cuml` API

The `cuml` Python API follows the familiar scikit-learn fit-predict-transform pattern while keeping data and computation on the GPU. The following example generates sample data and computes DBSCAN clusters on the GPU:

```python
from cuml.datasets import make_blobs
from cuml.cluster import DBSCAN

# Create sample data
X, y = make_blobs(n_samples=100, centers=3, n_features=2, random_state=42)

# Fit clustering model
dbscan = DBSCAN(eps=1.0, min_samples=5)
dbscan.fit(X)
print(dbscan.labels_)
```

`cuml` supports clustering, dimensionality reduction, regression,
classification, preprocessing, model selection, time series, model
explanation, and nearest-neighbor workflows. Browse the [API
reference](https://docs.nvidia.com/cuml/latest/api/) for the current list of
estimators and functions.

## Accelerate existing code with `cuml.accel`

Run an existing Python script through the [`cuml.accel` module](https://docs.nvidia.com/cuml/latest/cuml-accel/):

```console
python -m cuml.accel script.py
```

Or load the extension in a Jupyter notebook before importing scikit-learn,
UMAP, or HDBSCAN:

```python
%load_ext cuml.accel
```

Supported operations run on the GPU. When an estimator or configuration cannot
be accelerated, `cuml.accel` uses the original CPU implementation so the rest
of the workflow can continue. See the [`cuml.accel` compatibility
documentation](https://docs.nvidia.com/cuml/latest/cuml-accel/compatibility/) for
current coverage and fallback conditions. Use the [logging and profiling
tools](https://docs.nvidia.com/cuml/latest/cuml-accel/logging-and-profiling/) to check
which operations ran on the GPU.

## Scale beyond one GPU

The `cuml.dask` API provides distributed implementations of selected algorithms
for multi-GPU and multi-node execution with [Dask](https://www.dask.org). See
the [multi-GPU guide](https://docs.nvidia.com/cuml/latest/dask_multigpu_guide/) for
cluster setup, supported algorithms, and examples.

## Installation

Use the [installation selector](https://docs.nvidia.com/datascience/install#selector) to
generate a command for installing nightly or release cuML packages with conda,
pip, or Docker.

Additional resources:

- [NVIDIA cuML documentation](https://docs.nvidia.com/cuml/)
- [NVIDIA cuML product page](https://developer.nvidia.com/topics/ai/data-science/cuda-x-data-science-libraries/cuml)
- [Walkthrough notebooks](https://github.com/NVIDIA/cuml/tree/release/26.10/notebooks)
- [CUDA-X Data Science libraries](https://developer.nvidia.com/topics/ai/data-science/cuda-x-for-data-science)

## Build and install from source

See the [build guide](BUILD.md).

## Scikit-learn compatibility

cuML is compatible with scikit-learn version 1.6 or higher.

## Model serialization and security

cuML models can be serialized with `pickle` or `joblib` and loaded later for
inference. cuML uses cloudpickle so that models trained with `cuml.accel` can be
loaded and used with scikit-learn.

**Only unpickle or deserialize from trusted sources.** The `pickle` module (and
by extension `joblib`) is not secure: malicious payloads can execute arbitrary
code during deserialization and compromise your system. **Do not unpickle or
load data from untrusted or tampered sources.** This applies to `pickle.load()`,
`pickle.loads()`, `joblib.load()`, and any file-based model loading. For
details and patterns, see the [Model Serialization and
Persistence](docs/source/pickling_cuml_models.ipynb) notebook and the [Python
pickle security documentation](https://docs.python.org/3/library/pickle.html).

## Contributing and support

See the [contributing guide](CONTRIBUTING.md) to contribute to cuML. Report bugs
and request features through [GitHub issues](https://github.com/NVIDIA/cuml/issues).
Join the broader community through the [CUDA-X Data Science libraries
page](https://developer.nvidia.com/topics/ai/data-science/cuda-x-for-data-science#join-the-community).

## Citation

For additional details on the technologies behind cuML and the broader Python
machine learning landscape, see [_Machine Learning in Python: Main developments
and technology trends in data science, machine learning, and artificial
intelligence_ (2020)](https://arxiv.org/abs/2002.04803) by Sebastian Raschka,
Joshua Patterson, and Corey Nolet.

Please consider citing this work when using cuML in a project:

```bibtex
@article{raschka2020machine,
  title={Machine Learning in Python: Main developments and technology trends in data science, machine learning, and artificial intelligence},
  author={Raschka, Sebastian and Patterson, Joshua and Nolet, Corey},
  journal={arXiv preprint arXiv:2002.04803},
  year={2020}
}
```
