RAPIDS

https://rapids.ai
Admin
RAPIDS is a suite of open-source GPU-accelerated libraries providing familiar PyData APIs for data...
Tokens:9,156
Snippets:205
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install Miniforge

Source: https://rapids.ai/

Download and run the Miniforge installer script. This script installs the latest Miniforge distribution.

```bash
wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
bash Miniforge3-$(uname)-$(uname -m).shCopy
```

--------------------------------

### Install Polars with GPU Engine

Source: https://rapids.ai/polars-gpu-engine

Install Polars with the GPU engine extra and the NVIDIA PyPI index. This is the initial setup step for using GPU acceleration.

```bash
pip install polars[gpu] --extra-index-url=https://pypi.nvidia.com
```

--------------------------------

### Example: RandomForestClassifier on GPU

Source: https://rapids.ai/cuml-accel

This example demonstrates loading the cuML accelerate extension, importing scikit-learn components, creating a dataset, initializing a RandomForestClassifier, and fitting the model, which runs on the GPU.

```python
In [1]: %load_ext cuml.accel  

In [2]: from sklearn.ensemble import RandomForestClassifier  
In [3]: from sklearn.datasets import make_classification  

In [4]: X, y = make_classification(n_samples=10000, n_features=20)  

In [5]: clf = RandomForestClassifier(n_estimators=100)  

In [6]: clf.fit(X, y) # Runs on GPU!  
Out[6]: RandomForestClassifier()  

```

--------------------------------

### Install nx-cugraph

Source: https://rapids.ai/nx-cugraph

Install the nx-cugraph package using pip. Ensure you use the correct version for your CUDA installation.

```bash
pip install nx-cugraph-cu13 --extra-index-url https://pypi.nvidia.com
```

--------------------------------

### Install RAPIDS with Pip

Source: https://rapids.ai/

Install RAPIDS libraries using pip from the NVIDIA PyPI index. This command installs specific versions of cudf, dask-cudf, cuml, and cugraph.

```bash
pip install \
  --extra-index-url=https://pypi.nvidia.com \
  cudf-cu13==26.6.* \
  dask-cudf-cu13==26.6.* \
  cuml-cu13==26.6.* \
  cugraph-cu13==26.6.*Copy
```

--------------------------------

### NetworkX Graph Creation and Betweenness Centrality (GPU with nx-cugraph)

Source: https://rapids.ai/nx-cugraph

This snippet shows the same graph creation and betweenness centrality computation as the CPU example, but with nx-cugraph enabled via the NX_CUGRAPH_AUTOCONFIG=True environment variable, demonstrating GPU acceleration.

```bash
NX_CUGRAPH_AUTOCONFIG=True ipython demo.ipy
```

--------------------------------

### Explicitly Enable cuML Accelerate in Code

Source: https://rapids.ai/cuml-accel

If command line flags are not an option, you can explicitly enable cuML.accel within your Python code by importing it and calling the install() function.

```python
import cuml.accel  
cuml.accel.install()  

import sklearn  
...
```

--------------------------------

### Install RAPIDS with Conda

Source: https://rapids.ai/

Create a Conda environment and install RAPIDS version 26.06 with Python 3.14 and CUDA 13.1. Ensure you have the 'rapidsai' and 'conda-forge' channels configured.

```bash
conda create -n rapids-26.06 -c rapidsai -c conda-forge rapids=26.06 python=3.14 cuda-version=13.1Copy
```

--------------------------------

### Enable cuDF Pandas via Explicit Import

Source: https://rapids.ai/cudf-pandas

Explicitly import and install `cudf.pandas` in your Python script if command-line flags cannot be used. Ensure this is done before importing pandas.

```python
import cudf.pandas  
cudf.pandas.install()  
  
import pandas as pd  
...
```

--------------------------------

### RAPIDS Citation Guide (BibTeX)

Source: https://rapids.ai/branding

Use this BibTeX entry for citing RAPIDS in LaTeX publications. It includes the title, author, year, and URL.

```bibtex
@Manual{
              title = {RAPIDS: Libraries for End to End GPU Data Science},
              author = {RAPIDS Development Team},
              year = {2023},
              url = {https://rapids.ai}
            }
```

--------------------------------

### Enable nx-cugraph via Environment Variable (Notebook)

Source: https://rapids.ai/nx-cugraph

In a Jupyter notebook, use the %env magic command before importing NetworkX to enable GPU acceleration.

```python
%env NX_CUGRAPH_AUTOCONFIG=True
import networkx
```

--------------------------------

### Enable cuDF Pandas via Command Line

Source: https://rapids.ai/cudf-pandas

Run a Python script with the `cudf.pandas` module flag to enable GPU acceleration for pandas operations.

```bash
python -m cudf.pandas script.py
```

--------------------------------

### Collect with Custom GPU Engine Configuration

Source: https://rapids.ai/polars-gpu-engine

Use a custom `GPUEngine` object for finer control over GPU execution, specifying device and error handling. This allows for more tailored GPU acceleration.

```python
import polars as pl

ldf = pl.LazyFrame({"a": [1.242, 1.535]})

gpu_engine = pl.GPUEngine(
    device=0, 
    raise_on_fail=True, 
)

print(
    ldf.select(
        pl.col("a").round(1)
    ).collect(engine=gpu_engine)
)
```

--------------------------------

### Load cuML Accelerate Extension in IPython/Jupyter

Source: https://rapids.ai/cuml-accel

To accelerate IPython or Jupyter Notebooks, use the %load_ext magic command before importing scikit-learn or other compatible libraries.

```python
%load_ext cuml.accel  
import sklearn  
...
```

--------------------------------

### NetworkX Graph Creation and Betweenness Centrality (CPU)

Source: https://rapids.ai/nx-cugraph

This snippet demonstrates how to create a graph from a Pandas DataFrame and compute betweenness centrality using NetworkX on the CPU. It serves as a baseline for performance comparison.

```python
import networkx as nx
import pandas as pd

url = "https://data.rapids.ai/cugraph/datasets/cit-Patents.csv"
df = pd.read_csv(url, sep=" ", names=["src", "dst"], dtype="int32")
G = nx.from_pandas_edgelist(df, source="src", target="dst")

%time result = nx.betweenness_centrality(G, k=10)
```

--------------------------------

### Import Pandas with cuDF Accelerator

Source: https://rapids.ai/cudf-pandas

Import the pandas library after loading the cudf.pandas extension. This will import a magic module that proxies pandas operations to cuDF.

```python
import pandas as pd
```

--------------------------------

### Enable nx-cugraph via Environment Variable (Shell)

Source: https://rapids.ai/nx-cugraph

Set the NX_CUGRAPH_AUTOCONFIG environment variable to True in your shell before running your Python script to enable GPU acceleration.

```bash
NX_CUGRAPH_AUTOCONFIG=True
python my_networkx_script.py
```

--------------------------------

### Verify cuML Proxy Estimator

Source: https://rapids.ai/cuml-accel

Use the is_proxy function from cuml.accel to confirm if an estimator is a proxy estimator, indicating it is running via cuML's GPU acceleration.

```python
In [7]: from cuml.accel import is_proxy  
In [8]: is_proxy(clf)  
Out[8]: True  

```

--------------------------------

### Enable cuDF Pandas with IPython Magic

Source: https://rapids.ai/cudf-pandas

Use this magic command in IPython or Jupyter Notebooks to enable cuDF's pandas accelerator mode before importing pandas.

```python
%load_ext cudf.pandas  
import pandas as pd  
...
```

--------------------------------

### Profile cuML Execution

Source: https://rapids.ai/cuml-accel

The %%cuml.accel.profile cell magic can be used to profile the execution of estimators, providing a breakdown of GPU and CPU calls and time spent.

```python
In [8]: %%cuml.accel.profile
   ...:
   ...: clf.fit(X, y)
   ...:
   ...: 

```

--------------------------------

### Accelerate Python Script with cuML

Source: https://rapids.ai/cuml-accel

You can accelerate a Python script by using the -m cuml.accel flag from the command line when executing your script.

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

--------------------------------

### Load cuDF Pandas Extension

Source: https://rapids.ai/cudf-pandas

Load the cudf.pandas extension to enable GPU acceleration for pandas operations. This should be done before importing pandas.

```python
%load_ext cudf.pandas
```

--------------------------------

### Collect with Default GPU Engine

Source: https://rapids.ai/polars-gpu-engine

Materialize a Polars LazyFrame into a DataFrame using the default GPU engine configuration. Pass `engine="gpu"` to the `collect` API.

```python
import polars as pl

ldf = pl.LazyFrame({"a": [1.242, 1.535]})

print(
    ldf.select(
        pl.col("a").round(1)
    ).collect(engine="gpu")
)
```

--------------------------------

### Inspect Pandas Module with cuDF Accelerator

Source: https://rapids.ai/cudf-pandas

Inspect the pandas module after importing it with the cuDF accelerator enabled. The output shows that pandas is using the ModuleAccelerator.

```python
pd
```
Tokens:
Raw