RAPIDS CUDA Guide: GPU-Accelerated Data Science with cuDF, cuML, cuGraph

# Install via conda (recommended)
conda create -n rapids-env -c rapidsai -c conda-forge -c nvidia \
    rapids=24.10 python=3.11 cudatoolkit=12.0

conda activate rapids-env

# Or install specific packages
conda install -c rapidsai -c conda-forge -c nvidia \
    cudf=24.10 cuml=24.10 cugraph=24.10

# Verify installation
python -c "import cudf; print(f'cuDF {cudf.__version__}')"
python -c "import cuml; print(f'cuML {cuml.__version__}')"

# Check GPU
python -c "import cudf; df = cudf.DataFrame({'a': [1,2,3]}); print(df)"

import cudf
import pandas as pd
import numpy as np

# Create GPU DataFrame - just like pandas
gdf = cudf.DataFrame({
    'a': np.arange(1000000),
    'b': np.random.randn(1000000),
    'c': np.random.choice(['X', 'Y', 'Z'], 1000000)
})

# All pandas operations work on GPU
gdf['d'] = gdf['a'] * gdf['b']
grouped = gdf.groupby('c').agg({'a': 'mean', 'b': 'sum', 'd': 'max'})
filtered = gdf[gdf['b'] > 0]

# Convert between pandas and cuDF
pdf = gdf.to_pandas()  # GPU -> CPU
gdf2 = cudf.from_pandas(pdf)  # CPU -> GPU

# Read CSV directly to GPU
gdf = cudf.read_csv('data.csv')

# SQL queries on GPU DataFrames
from cudf import sql
result = sql.execute("SELECT c, AVG(b) FROM gdf WHERE a > 1000 GROUP BY c")

# Join operations - much faster than pandas
left = cudf.DataFrame({'key': range(1000000), 'val1': range(1000000)})
right = cudf.DataFrame({'key': range(500000), 'val2': range(500000)})
merged = left.merge(right, on='key', how='inner')

# String operations on GPU
gdf = cudf.DataFrame({'text': ['hello', 'world', 'GPU', 'acceleration']})
gdf['upper'] = gdf['text'].str.upper()
gdf['contains'] = gdf['text'].str.contains('GPU')

# DateTime operations
gdf = cudf.DataFrame({
    'date': cudf.date_range('2024-01-01', periods=1000000, freq='1min')
})
gdf['year'] = gdf['date'].dt.year
gdf['month'] = gdf['date'].dt.month

import cudf
import cuml
from cuml.ensemble import RandomForestClassifier
from cuml.preprocessing import train_test_split, StandardScaler
from cuml.metrics import accuracy_score

# Load data to GPU
df = cudf.read_csv('large_dataset.csv')

# Feature engineering on GPU
df['feature_interaction'] = df['feature1'] * df['feature2']
df['log_feature'] = cuml.preprocessing.log1p(df['skewed_feature'])

# Encode categorical variables
from cuml.preprocessing import LabelEncoder
le = LabelEncoder()
df['category_encoded'] = le.fit_transform(df['category'])

# Split data (stays on GPU)
X = df.drop('target', axis=1)
y = df['target']
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Scale features on GPU
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train Random Forest on GPU
rf = RandomForestClassifier(
    n_estimators=100,
    max_depth=10,
    n_bins=128,  # GPU-specific parameter
    max_features=1.0
)
rf.fit(X_train_scaled, y_train)

# Predict on GPU
predictions = rf.predict(X_test_scaled)
accuracy = accuracy_score(y_test, predictions)
print(f"Accuracy: {accuracy:.4f}")

# K-Means clustering on GPU
from cuml.cluster import KMeans
kmeans = KMeans(n_clusters=5)
clusters = kmeans.fit_predict(X_train_scaled)

# PCA dimensionality reduction on GPU
from cuml.decomposition import PCA
pca = PCA(n_components=10)
X_reduced = pca.fit_transform(X_train_scaled)

# Multi-GPU with Dask
import dask_cudf
from dask_ml.model_selection import train_test_split as dask_train_test_split

# Create Dask GPU DataFrame
ddf = dask_cudf.read_csv('huge_dataset_*.csv')

# Operations distributed across GPUs
result = ddf.groupby('category').agg({'value': 'mean'}).compute()

# cuGraph for network analysis
import cugraph

# Create graph on GPU
G = cugraph.Graph()
edges = cudf.DataFrame({
    'src': [0, 1, 2, 3],
    'dst': [1, 2, 3, 0],
    'weight': [1.0, 2.0, 1.5, 0.5]
})
G.from_cudf_edgelist(edges, source='src', destination='dst', edge_attr='weight')

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

# Shortest paths on GPU
paths = cugraph.sssp(G, source=0)