cuML Cheat Sheet

1Install & verify26.08

pip install cuml-cu12★
pip wheel for CUDA 12.x. The package name encodes the CUDA major version (cuml-cu12). Needs an NVIDIA GPU — there is no CPU-only build.
conda install -c rapidsai -c conda-forge -c nvidia cuml=26.08
Conda is the fully-supported path (pulls the matching cudf, cupy, CUDA runtime). Versions are CalVer = YY.MM.
import cuml; cuml.__version__ # requires NVIDIA GPU, compute capability 7.0+ (Volta or newer), CUDA 12★
One conda env should share ONE RAPIDS version across cuml/cudf/cupy — mismatches are the #1 install failure.

2Zero-code-change · cuml.accelno rewrites

# Jupyter/IPython: FIRST cell, before importing sklearn %load_ext cuml.accel from sklearn.ensemble import RandomForestClassifier★
The headline feature. Load the extension, then use unmodified scikit-learn code — it runs on the GPU automatically. Accelerates scikit-learn, umap-learn, and hdbscan.
python -m cuml.accel my_script.py★
Run any existing sklearn script GPU-accelerated, unchanged, from the CLI. Nothing in the script needs editing.
import cuml cuml.accel.install() from sklearn.cluster import KMeans # re-import AFTER install()
Programmatic form. Import order matters: call install() before importing the ML libraries so their estimators get intercepted. install(log_level="debug") to trace.
# unsupported op (e.g. sparse input) → silent CPU fallback
When an algorithm/param isn't GPU-supported, cuml.accel gracefully falls back to CPU — correct results, no error. Enable logging to see what ran where.

3Data & I/Owhat goes in, what comes out

import cudf gdf = cudf.read_csv("data.csv") # GPU DataFrame★
cuDF is the GPU-DataFrame companion (pandas-like). cuML also accepts cupy arrays, numpy arrays, and pandas — non-GPU inputs are copied to the device.
X = gdf[["f1","f2"]]; y = gdf["label"] model.fit(X, y); model.predict(X)★
Same fit/predict/transform/fit_transform contract as scikit-learn.
cuml.set_global_output_type("numpy") # or "cudf","cupy","input"★
Controls return types. Default output tracks input; set "input" to mirror what you passed, or "numpy" to always get host arrays back.
with cuml.using_output_type("cudf"): preds = model.predict(X)
Context manager to switch output type for just one block, without changing the global setting.

4Linear models & SVMcuml.linear_model · cuml.svm

from cuml.linear_model import LinearRegression, LogisticRegression m = LogisticRegression().fit(X, y); m.predict(X)★
Also Ridge, Lasso, ElasticNet — same package, same API as sklearn's linear_model.
from cuml.svm import SVC, SVR★
Kernel SVMs on GPU — where cuML often shows the biggest speedups over sklearn's libsvm.
from cuml.svm import LinearSVC, LinearSVR
Linear-kernel SVM classifier/regressor for large, high-dimensional data.

5Trees, neighbors & FILcuml.ensemble · cuml.neighbors

from cuml.ensemble import RandomForestClassifier rf = RandomForestClassifier(n_estimators=100).fit(X, y)★
GPU random forest (also RandomForestRegressor). Note cuML has no gradient boosting — use XGBoost/LightGBM's own GPU mode for that.
from cuml.neighbors import KNeighborsClassifier, NearestNeighbors★
Brute-force GPU k-NN (also KNeighborsRegressor). NearestNeighbors for unsupervised neighbor search / recommenders.
from cuml import ForestInference fil = ForestInference.load("xgb.json", model_type="xgboost") fil.predict(X)deploy
FIL = GPU inference for already-trained XGBoost / LightGBM / sklearn forest models — high-throughput batch scoring without retraining.

6Clusteringcuml.cluster

from cuml.cluster import KMeans km = KMeans(n_clusters=8).fit(X); km.labels_★
GPU k-means — scales to millions of rows. .cluster_centers_, .predict(Xnew) as usual.
from cuml.cluster import DBSCAN DBSCAN(eps=0.5, min_samples=5).fit_predict(X)★
Density clustering with a GPU-accelerated neighborhood search.
from cuml.cluster.hdbscan import HDBSCAN from cuml.cluster import AgglomerativeClustering
GPU HDBSCAN (hierarchical density clustering) and agglomerative clustering — HDBSCAN is also one of the libraries cuml.accel speeds up transparently.

7Dimensionality reductioncuml.decomposition · cuml.manifold

from cuml.decomposition import PCA, TruncatedSVD Xr = PCA(n_components=50).fit_transform(X)★
Linear reduction. TruncatedSVD for sparse / LSA-style workloads.
from cuml.manifold import UMAP emb = UMAP(n_neighbors=15, n_components=2).fit_transform(X)★
GPU UMAP — a flagship cuML speedup, and accelerated by cuml.accel over umap-learn too.
from cuml.manifold import TSNE TSNE(n_components=2).fit_transform(X)
GPU t-SNE for 2-D visualization of high-dimensional data.

8Output, multi-GPU & saveproduction

preds.get() # cupy → numpy preds.to_numpy() # cudf → numpy★
Results default to GPU types (cupy/cuDF). Pull them to the host with .get()/.to_numpy(), or set output_type="numpy" globally (card 3).
import pickle pickle.dump(model, open("m.pkl", "wb"))★
cuML estimators pickle like sklearn's. Load on a GPU box to predict again; keep the RAPIDS version consistent across save/load.
from dask_cuda import LocalCUDACluster from cuml.dask.cluster import KMeans # distributed variant
Multi-node / multi-GPU via the cuml.dask.* estimators on a Dask-CUDA cluster — for data too big for one GPU.
model.get_param_names() · model.get_params()
Introspect hyperparameters; combine with sklearn utilities (many work by duck-typing).

!Common gotchasread before shipping

NVIDIA GPU required
There is no CPU-only cuML. It needs an NVIDIA GPU (Volta / CC 7.0+) and CUDA 12; no AMD/Intel/Apple GPUs.
cuml.accel: load BEFORE importing sklearn
The magic/CLI/install() must run first, then (re)import the estimators. Import after and they stay on CPU.
not 100% sklearn parity
Some params are approximate, ignored, or unsupported; results can differ slightly numerically. Under cuml.accel those cases silently fall back to CPU — enable logging to see what actually ran on GPU.
no gradient boosting in cuML
Use XGBoost/LightGBM's native GPU training, then ForestInference for fast GPU scoring.
outputs are GPU types by default
Predictions come back as cupy/cuDF unless you set output_type. Calling numpy-only code on them errors — .get()/.to_numpy() first.
match RAPIDS versions
cuml, cudf, cupy and the CUDA runtime must share one RAPIDS release (CalVer YY.MM). Mixed versions break imports.

cuML cheat sheet