cuML - RAPIDS ML Algorithms

cuML provides GPU-accelerated versions of Scikit-Learn preprocessing tools. The code is derived from Scikit-Learn (version/branch 0.23.1) and is modified to support common GPU-compatible inputs including:

• NumPy arrays
• CuPy arrays
• Pandas DataFrames
• cuDF DataFrames
• Numba types

cuML is a suite of GPU-accelerated machine learning algorithms that mirrors the scikit-learn API.

Key Capabilities:

• Scikit-learn Compatibility: Provides a drop-in replacement for most sklearn algorithms using the fit-predict-transform paradigm.
• Zero Code Change Acceleration: Use cuml.accel to automatically accelerate existing code.
• Flexible Input Support: Works with NumPy, cuDF, cuPy, and PyTorch tensors.
• Scalability: Supports multi-GPU and multi-node scaling via Dask.
• Algorithm Coverage: Over 50 algorithms across clustering, regression, classification, dimensionality reduction, and time series analysis.

The cuml.cluster module provides GPU-accelerated implementations of various clustering algorithms. You can use these to group data points based on similarity. Supported algorithms include:

• KMeans: Standard K-means clustering.
• DBSCAN: Density-Based Spatial Clustering of Applications with Noise.
• AgglomerativeClustering: Hierarchical clustering using agglomerative methods.
• SpectralClustering: Clustering based on the eigenvalues of the similarity matrix.
• HDBSCAN: Hierarchical Density-Based Spatial Clustering of Applications with Noise (available via hdbscan.HDBSCAN).

The cuml.compose module provides tools for composing transformations on different subsets of columns in a dataset, similar to scikit-learn's composition utilities. It allows you to apply specific transformers to specific columns (or groups of columns) within a single pipeline step.

Key components include:

• ColumnTransformer: A class to apply different transformers to different columns.
• make_column_transformer: A convenience function to create a ColumnTransformer.
• make_column_selector: A utility to select columns based on data type or name patterns.

The cuml.neighbors module provides GPU-accelerated implementations of common neighbor-based algorithms. It is designed to be compatible with the Scikit-learn API, allowing for efficient nearest neighbor searches, classification, and regression on CUDA devices.

Key algorithms available in this module include:

• NearestNeighbors: Unsupervised nearest neighbor search.
• KNeighborsClassifier: K-Nearest Neighbors classification.
• KNeighborsRegressor: K-Nearest Neighbors regression.
• KernelDensity: Kernel Density Estimation (KDE).

The cuml.decomposition module provides GPU-accelerated implementations of dimensionality reduction algorithms. These algorithms are designed to work with RAPIDS cudf DataFrames or NumPy arrays, providing significant speedups over CPU-based implementations for large datasets.

Supported algorithms include:

• PCA: Principal Component Analysis.
• IncrementalPCA: Incremental Principal Component Analysis, useful for datasets that do not fit into GPU memory.
• TruncatedSVD: Truncated Singular Value Decomposition, often used for sparse matrix decomposition.

The notebooks/data/time_series/ directory contains curated datasets specifically filtered and organized for demonstrating and testing cuML time series models.

Note: These datasets are optimized for time series testing. For production or general-purpose use, it is recommended to source the data directly from the original providers.

The cuml.naive_bayes module provides GPU-accelerated implementations of various Naive Bayes classifiers. These algorithms are designed to work with GPU-accelerated data structures and follow the Scikit-learn API pattern.

Supported classifiers include:

• BernoulliNB: Gaussian Naive Bayes for multivariate Bernoulli distributions.
• CategoricalNB: Naive Bayes for categorical features.
• ComplementNB: An adaptation of MultinomialNB for imbalanced datasets.
• GaussianNB: Naive Bayes for continuous features assuming a Gaussian distribution.
• MultinomialNB: Naive Bayes for discrete counts (e.g., word counts in text classification).

The cuml.manifold module provides GPU-accelerated implementations of manifold learning algorithms, which are used for dimensionality reduction and uncovering the underlying structure of high-dimensional data.

Supported algorithms include:

• UMAP (Uniform Manifold Approximation and Projection)
• TSNE (t-Distributed Stochastic Neighbor Embedding)
• SpectralEmbedding
• spectral_embedding (functional interface)
• umap.fuzzy_simplicial_set
• umap.simplicial_set_embedding
• umap.find_ab_params

When running GPU-backed tests, avoid using -n auto on large machines to prevent GPU memory exhaustion. Instead, use bounded xdist parallelism with a fixed number of workers and the worksteal distribution.

scikit-learn tests example:

./scikit-learn/run-tests.sh \
    --numprocesses=8 \
    --dist=worksteal \
    --junitxml=report-sklearn.xml

scikit-learn examples example:

./scikit-learn/run-examples.sh \
    -vv --durations=0 --durations-min=0 \
    -n 4 --dist worksteal \
    --junitxml=report-sklearn-examples.xml