NVIDIA Rapid

Parallel execution with CUDA

RAPIDS is built on NVIDIA CUDA to speed up Python

Rapids framework: https://rapids.ai/

GPU-native operations

Instead of using a few CPU cores, RAPIDS distributes work across thousands of CUDA cores simultaneously.

RAPIDS uses GPU-accelerated I/O through libraries like cuDF, cuML, and cuGraph CUDA-based readers to load directly into GPU memory.

Supported formats:

• CSV
• Parquet
• ORC
• JSON

CUDA enables GPUs to launch thousands of lightweight threads in parallel.

For example:

• CPUs → optimized for sequential tasks
• GPUs → optimized for massively parallel workloads

A GPU can process millions of rows concurrently.

import cupy as cp

# Array lives on GPU
arr = cp.random.rand(10_000_000)

# Parallel GPU computation
result = cp.sqrt(arr)

RAPIDS Architecture Overview

flowchart TD

    A["Python API<br/>cuDF / cuML"]
        --> B["CUDA Kernels 📟<br/>Parallel Compute"]

    B --> C["GPU Memory (VRAM) 📼"]

    C --> D["NVIDIA GPU 🧮"]

This minimizes expensive CPU ↔ GPU memory copies and reduces ingestion bottlenecks.

RAPIDS vs Traditional CPU Libraries

Category	Common Python (CPU)	RAPIDS (GPU)
DataFrames	Pandas	cuDF
Arrays	NumPy	cuPy
Data Ingestion	Pandas / PyArrow	cuIO
Machine Learning	scikit-learn	cuML
Graph Analytics	NetworkX	cuGraph

Typical accelerated operations include:

• Filtering
• GroupBy aggregations
• Sorting
• Joins
• Machine learning training
• Graph traversal algorithms

Typical RAPIDS Use Cases

• Large-scale ETL pipelines
• Feature engineering
• Recommendation systems
• Fraud detection
• Real-time analytics
• Graph analytics
• GPU-accelerated ML training
• LLM preprocessing pipelines

Example pipeline:

import cudf
from cuml.linear_model import LinearRegression

# Load data into GPU memory
gdf = cudf.read_parquet("train.parquet")

X = gdf[["feature1", "feature2"]]
y = gdf["target"]

# Train directly on GPU data
model = LinearRegression()
model.fit(X, y)

---

Multi-GPU with Dask + RAPIDS

When a dataset exceeds a single GPU’s memory, RAPIDS can distribute workloads across multiple GPUs using Dask.

from dask_cuda import LocalCUDACluster
from dask.distributed import Client

cluster = LocalCUDACluster()
client = Client(cluster)

Benefits:

• Parallel processing across GPUs
• Larger-than-memory datasets
• Distributed ML training

Multi-node scaling with NCCL + Dask

For clusters spanning multiple machines:

• Dask handles task scheduling
• NCCL handles fast GPU-to-GPU communication

NCCL is optimized for:

• GPU collectives
• All-reduce operations
• High-speed NVLink / InfiniBand transfers

Architecture example:

flowchart TD

    A["Node 1 🧾<br/>GPU 0 🧮"]
    B["Node 2 🧾<br/>GPU 1 🧮"]
    A <--> B

    C["NCCL Communication"]
    C -.-> A
    C -.-> B

---

How RAPIDS Works Under the Hood 𖣘

Data stays on the GPU

One of RAPIDS’ biggest advantages is minimizing data movement.

Traditional workflows often look like this:

flowchart TD

    A["Disk 🛢"]
        --> B["CPU RAM 📏"]
        --> C["GPU 🧮 "]
        --> D["CPU 🧾"]
        --> E["GPU 🧮"]

RAPIDS pipelines are closer to:

flowchart TD

    A["Disk 🛢"]
        --> B["GPU Memory 📼"]
        --> C["GPU Processing 🧮"]
        --> D["GPU Training 𖣘"]

This avoids PCIe transfer overhead, which is often slower than GPU computation itself.

Workflow comparison

Traditional CPU Workflow	RAPIDS GPU Workflow
Few CPU cores	Thousands of CUDA cores
Frequent memory transfers	Data remains on GPU
Sequential execution	Massive parallelism
Slower for large datasets	Optimized for big data + AI

---

Data Ingestion Example

import cudf

# Load CSV directly into GPU memory
gdf = cudf.read_csv("large_dataset.csv")

K-Mean Example

With CPU

# CPU (Pandas + NumPy + scikit-learn)

import pandas as pd
import numpy as np
from sklearn.cluster import KMeans

# Create DataFrame
df = pd.DataFrame({
    "x": np.random.rand(1000),
    "y": np.random.rand(1000)
})

# Train ML model
model = KMeans(n_clusters=3, random_state=42)
model.fit(df)

print(model.labels_[:10])

With GPU and CUDA

# GPU (RAPIDS: cuDF + CuPy + cuML)

import cudf
import cupy as cp
from cuml.cluster import KMeans

# Create GPU DataFrame
gdf = cudf.DataFrame({
    "x": cp.random.rand(1000),
    "y": cp.random.rand(1000)
})

# Train GPU-accelerated ML model
model = KMeans(n_clusters=3, random_state=42)
model.fit(gdf)

print(model.labels_[:10])

Graph Analytics Example

With CPU

# CPU: NetworkX
import networkx as nx

G = nx.karate_club_graph()
pagerank_scores = nx.pagerank(G)

print(list(pagerank_scores.items())[:5])

With GPU

# GPU: cuGraph

import cugraph

# Load graph into GPU
G = cugraph.karate.get_graph()

# Run PageRank on GPU
pagerank_df = cugraph.pagerank(G)

print(pagerank_df.head())

# GPU DataFrame filtering
filtered = gdf[gdf["sales"] > 1000]

# GPU aggregation
summary = gdf.groupby("region").sales.mean()