Implementation of Machine Learning Workflows with NVIDIA cuML, RAPIDS, GPU Benchmarking, Explainability, Clustering, and Model Inference

In this tutorial, we implement NVIDIA cuML as a GPU-accelerated machine learning framework and build a practical workflow that demonstrates how RAPIDS can accelerate familiar data science and machine learning tasks.We begin by configuring the GPU environment and examining cuml.

accel, which lets us accelerate existing scikit-learn workloads with minimal code changes, before moving to the native cuML API for direct CuPy and cuDF interoperability.

We then benchmark CPU and GPU implementations of PCA, K-Means, nearest-neighbor search, logistic regression, random forests, and DBSCAN, while using synchronized timing to obtain meaningful performance measurements.

We also build GPU-based manifold-learning and clustering pipelines with UMAP, t-SNE, HDBSCAN, and trustworthiness metrics; explore high-throughput forest inference with FIL; validate GPU-generated SHAP explanations; perform hyperparameter optimization with scikit-learn meta-estimators; and finally serialize trained models while examining portability between GPU and CPU environments.

Copy CodeCopiedUse a different Browserimport os import sys import time import json import shutil import warnings import subprocess import importlib import traceback warnings.filterwarnings("ignore") QUICK = False SEED = 42 SCALE = 0.25 if QUICK else 1.

0 NMAIN = int(200000 SCALE) DMAIN = 64 NRF = int(50000 SCALE) DRF = 32 NNNINDEX = int(50000 SCALE) NNNQUERY = int(5000 SCALE) NDBSCAN = int(20000 SCALE) NMANIFOLD = int(60000 SCALE) NACCEL = int(80000 SCALE) RESULTS = [] NOTES = [] def banner(title): line = "=" 78 print(f"\n{line}\n {title}\n{line}", flush=True) def section(title, fn, args, kwargs): banner(title) t0 = time.

perfcounter() try: fn(args, kwargs) except Exception: print(f"[!] Section skipped due to an error:\n{traceback.formatexc()}") print(f"[section wall time: {time.perfcounter() - t0:.1f}s]", flush=True) def bootstrap(): if shutil.which("nvidia-smi") is None: raise SystemExit( "No NVIDIA GPU found.

In Colab: Runtime > Change runtime type > GPU." ) print(subprocess.run( ["nvidia-smi", "--query-gpu=name,memory.total,computecap,driverversion", "--format=csv"], captureoutput=True, text=True).stdout) try: import cuml print("cuML already available — skipping install.

") except ImportError: print("Installing RAPIDS cuML (this takes ~1-3 minutes)...") pin = "" try: import cudf majorminor = ".".join(cudf.version.split("+")[0].split(".")[:2]) pin = f"=={majorminor}.

" print(f" Pinning to the preinstalled cuDF line: cuml-cu12{pin}") except Exception: print(" cuDF not found; installing the latest stable cuml-cu12.") cmd = [sys.executable, "-m", "pip", "install", "-q", "--extra-index-url=https://pypi.nvidia.com", f"cuml-cu12{pin}"] print("$ " + " ".

join(cmd)) rc = subprocess.run(cmd).returncode if rc != 0: raise SystemExit( "pip install failed.Alternative that always works on Colab:\n" " !git clone https://github.com/rapidsai/rapidsai-csp-utils.git\n" " !python rapidsai-csp-utils/colab/pip-install.py" ) importlib.

invalidatecaches() import cuml import cupy print(f"cuml {cuml.version}") print(f"cupy {cupy.version}") try: import cudf print(f"cudf {cudf.version}") except Exception: pass import sklearn print(f"sklearn {sklearn.version} (cuML requires scikit-learn >= 1.

6)") bootstrap() import numpy as np import cupy as cp import cuml import matplotlib.pyplot as plt from cuml.datasets import makeclassification as gpumakeclassification from cuml.datasets import makeblobs as gpumakeblobs rng = np.random.RandomState(SEED) cp.random.

seed(SEED) class Timer: def init(self, label, sync=True): self.label = label self.sync = sync def enter(self): if self.sync: cp.cuda.runtime.deviceSynchronize() self.t0 = time.perfcounter() return self def exit(self, exc): if self.sync: cp.cuda.runtime.deviceSynchronize() self.dt = time.

perfcounter() - self.t0 print(f" {self.label:<44s} {self.dt:8.3f}s") return False def tonumpy(a): if isinstance(a, cp.ndarray): return cp.asnumpy(a) if hasattr(a, "tonumpy"): return a.tonumpy() return np.asarray(a) def record(task, cpus, gpus): RESULTS.

append((task, cpus, gpus)) if cpus and gpus: print(f" -> {task}: {cpus / gpus:.1f}x speedup\n") ACCELSCRIPT = f''' import time import numpy as np from sklearn.datasets import makeblobs from sklearn.decomposition import PCA from sklearn.cluster import KMeans from sklearn.

neighbors import NearestNeighbors from sklearn.linearmodel import Ridge X, y = makeblobs(nsamples={NACCEL}, nfeatures=32, centers=12, randomstate=0) X = X.astype("float32"); y = y.astype("float32") t0 = time.perfcounter() PCA(ncomponents=8).

fittransform(X) KMeans(nclusters=12, ninit=1, randomstate=0).fit(X) NearestNeighbors(nneighbors=8).fit(X[:{NACCEL // 2}]).kneighbors(X[:5000]) Ridge(alpha=1.0).fit(X, y) Ridge(alpha=1.0, positive=True).fit(X[:5000], y[:5000]) print("MODELTIME %.3f" % (time.

perfcounter() - t0)) ''' def demoaccel(): path = "/content/acceldemo.py" if os.path.isdir("/content") else "acceldemo.py" with open(path, "w") as f: f.write(ACCELSCRIPT) def run(cmd, label): print(f"\n$ {' '.join(cmd[1:])}") t0 = time.perfcounter() p = subprocess.

run(cmd, captureoutput=True, text=True) wall = time.perfcounter() - t0 out = p.stdout + p.stderr models = None for line in out.splitlines(): if line.startswith("MODELTIME"): models = float(line.split()[1]) print(out.strip()[:4000]) print(f"[{label}] model time = {models}s | process wall = {wall:.

1f}s") return models cpus = run([sys.executable, path], "stock sklearn") cmd = [sys.executable, "-m", "cuml.accel", "--profile", path] gpus = run(cmd, "cuml.accel") if gpus is None: gpus = run([sys.executable, "-m", "cuml.accel", path], "cuml.accel") record("cuml.

accel (sklearn script, unmodified)", cpus, gpus) NOTES.append( "cuml.accel needed ZERO source changes; the profile table above shows " "which calls ran on GPU and why Ridge(positive=True) fell back to CPU.

" ) We configure the tutorial environment, define dataset sizes and benchmarking utilities, and verify that an NVIDIA GPU is available.We install and initialize RAPIDS cuML when necessary, set up CuPy and reproducibility controls, and create synchronized timing and result-tracking helpers.

We also demonstrate cuml.accel by running an unmodified scikit-learn workload and comparing its CPU execution with GPU-accelerated execution.Copy CodeCopiedUse a different Browserdef demonativeapi(): from cuml.preprocessing import StandardScaler from cuml.

modelselection import traintestsplit X, y = gpumakeblobs(nsamples=50000, nfeatures=8, centers=5, randomstate=SEED, dtype=np.float32) print(f"cuml.datasets output lives on device: {type(X).module}, " f"shape={X.shape}, dtype={X.dtype}") try: import cudf df = cudf.

DataFrame(X, columns=[f"f{i}" for i in range(X.shape[1])]) back = df.values ptra = X.cudaarrayinterface["data"][0] ptrb = back.cudaarrayinterface["data"][0] print(f"CuPy ptr = {hex(ptra)}") print(f"cuDF->CuPy= {hex(ptrb)}") print("Same device pointer (true zero-copy)?

", ptra == ptrb) print("Note: a column-major DataFrame round trip may re-pack; what " "matters is that no host (CPU) round trip ever happens.") scaled = StandardScaler().fittransform(df) print(f"StandardScaler(cuDF) -> {type(scaled).

name}") except Exception as e: print(f"cuDF interop skipped: {e}") from cuml.decomposition import PCA pca = PCA(ncomponents=3).fit(X) print(f"default (mirrors input) -> {type(pca.transform(X)).name}") with cuml.usingoutputtype("numpy"): print(f"inside usingoutputtype() -> {type(pca.transform(X)).

name}") print(f"after the context manager -> {type(pca.transform(X)).name}") NOTES.append( "Keep outputtype as CuPy/cuDF inside a pipeline; converting to NumPy " "on every step forces a device->host copy and eats the speedup." ) Xtr, Xte, ytr, yte = traintestsplit(X, y, testsize=0.

2, randomstate=SEED) print(f"traintestsplit -> {Xtr