Examples

Basic Embedding

import graphem_rapids as gr

# Generate and embed
adjacency = gr.generate_er(n=1000, p=0.01, seed=42)
embedder = gr.create_graphem(adjacency, n_components=3)
embedder.run_layout(num_iterations=50)

# Get results
positions = embedder.get_positions()
embedder.display_layout()

Community Detection Visualization

import graphem_rapids as gr

# Generate graph with communities
adjacency, labels = gr.generate_sbm(
    n_per_block=100,
    num_blocks=5,
    p_in=0.2,
    p_out=0.01,
    labels=True,
    seed=42
)

# Compute 2D embedding
embedder = gr.create_graphem(adjacency, n_components=2)
embedder.run_layout(num_iterations=50)

# Visualize with community colors
embedder.display_layout(node_colors=labels, node_size=5)

Influence Maximization

import graphem_rapids as gr
import networkx as nx

# Generate graph
adjacency = gr.generate_er(n=1000, p=0.01, seed=42)

# Compute embedding
embedder = gr.create_graphem(adjacency, n_components=3)
embedder.run_layout(num_iterations=50)

# Select influential nodes (fast, embedding-based)
seeds = gr.graphem_seed_selection(embedder, k=10)

# Evaluate influence spread
G = nx.from_scipy_sparse_array(adjacency)
influence, _ = gr.ndlib_estimated_influence(G, seeds, p=0.1, iterations_count=100)
print(f"Influence: {influence:.1f} nodes ({influence/len(G)*100:.1f}%)")

# Compare with greedy (slow, optimal)
greedy_seeds, _ = gr.greedy_seed_selection(G, k=10, p=0.1)
greedy_influence, _ = gr.ndlib_estimated_influence(G, greedy_seeds, p=0.1, iterations_count=100)
print(f"Greedy influence: {greedy_influence:.1f} nodes ({greedy_influence/len(G)*100:.1f}%)")

Large-Scale Graph with cuVS

import graphem_rapids as gr

# Generate large graph
adjacency = gr.generate_er(n=200000, p=0.00005, seed=42)

# Force cuVS backend for large-scale
embedder = gr.GraphEmbedderCuVS(
    adjacency,
    n_components=3,
    index_type='ivf_flat',
    sample_size=2048,
    batch_size=4096,
    verbose=True
)

# Run layout
embedder.run_layout(num_iterations=30)
positions = embedder.get_positions()

Memory Management

import graphem_rapids as gr
from graphem_rapids.utils.memory_management import MemoryManager, get_gpu_memory_info

# Check GPU memory
mem_info = get_gpu_memory_info()
print(f"GPU: {mem_info['free']:.1f}GB free / {mem_info['total']:.1f}GB total")

# Automatic cleanup
with MemoryManager(cleanup_on_exit=True):
    adjacency = gr.generate_er(n=50000, p=0.0001)
    embedder = gr.create_graphem(adjacency, n_components=3)
    embedder.run_layout(num_iterations=40)
    positions = embedder.get_positions()
    # GPU memory automatically cleaned up

Benchmarking Correlations

import graphem_rapids as gr

# Run correlation benchmark
results = gr.benchmark_correlations(
    gr.generate_ba,
    {"n": 1000, "m": 3, "seed": 42},
    dim=2,
    L_min=40,
    num_iterations=50
)

# Print correlations with centrality measures
print("Spearman correlations with radial distance:")
for measure, corr in results['correlations'].items():
    print(f"{measure:15s}: ρ={corr['rho']:6.3f}, p={corr['p']:.2e}")

Custom Parameters

import graphem_rapids as gr

adjacency = gr.generate_ws(n=1000, k=6, p=0.3, seed=42)

# Fine-tune layout parameters
embedder = gr.GraphEmbedderPyTorch(
    adjacency,
    n_components=2,
    device='cuda',
    L_min=2.0,          # Longer minimum spring length
    k_attr=0.1,         # Weaker attraction
    k_inter=1.0,        # Stronger intersection repulsion
    n_neighbors=15,     # More neighbors for intersection detection
    sample_size=512,
    batch_size=1024,
    memory_efficient=True
)

embedder.run_layout(num_iterations=100)
embedder.display_layout()

Bipartite Graph Visualization

import graphem_rapids as gr
import numpy as np

# Generate bipartite graph
adjacency = gr.generate_complete_bipartite_graph(n_top=30, n_bottom=50)

# Compute 2D embedding
embedder = gr.create_graphem(adjacency, n_components=2)
embedder.run_layout(num_iterations=50)

# Color by partition
n_top, n_bottom = 30, 50
colors = np.concatenate([np.zeros(n_top), np.ones(n_bottom)])
embedder.display_layout(node_colors=colors, node_size=8)

Delaunay Triangulation

import graphem_rapids as gr

# Generate planar graph from Delaunay triangulation
adjacency = gr.generate_delaunay_triangulation(n=200, seed=42)

# Embed in 2D to preserve planarity
embedder = gr.create_graphem(adjacency, n_components=2)
embedder.run_layout(num_iterations=50)

# Visualize
embedder.display_layout(edge_width=0.5, node_size=3)