# RustyTorch++

> **GPU-Accelerated ML Framework in Pure Rust — Blackwell-Optimized, Production-Grade, JEPA Platform**

[![Status](https://img.shields.io/badge/Status-Production%20Ready-brightgreen)](https://git.redclaw.dev/rustyverse/rustytorch)
[![Crates](https://img.shields.io/badge/Crates-113-blue)](./crates)
[![Tests](https://img.shields.io/badge/Tests-13%2C000%2B-blue)](./crates)
[![GPU](https://img.shields.io/badge/GPU-RTX%205060%20Ti%20SM__120-76B900)](./crates/training/rtx-flash-attention)
[![Rust](https://img.shields.io/badge/Rust-2024%20Edition-orange)](https://doc.rust-lang.org/edition-guide/rust-2024/)

A full PyTorch-equivalent ML framework with multi-backend GPU support (CUDA/Metal/ROCm/WebGPU), 26 rounds of optimization and feature batches targeting Blackwell SM_120, and a comprehensive training + inference arsenal covering every major technique from 2020–2025. Primary goal: the premier JEPA self-supervised learning platform for multi-node GPU clusters.

---

## Contents

- [Architecture](#architecture)
- [GPU Optimizations](#gpu-optimizations) — Batches 1–19 (Blackwell SM_120)
- [JEPA Platform](#jepa-platform) — Batches 20–26 (I-JEPA, V-JEPA, Neuro-JEPA)
- [Training Arsenal](#training-arsenal)
- [Inference Stack](#inference-stack)
- [Distributed Training](#distributed-training)
- [Model Architectures](#model-architectures)
- [Specialized Domains](#specialized-domains)
- [Quick Start](#quick-start)
- [Benchmarks](#benchmarks)
- [CLI & Tooling](#cli--tooling)
- [JEPA Next Steps](#jepa-next-steps)

---

## Architecture

113 crates organized across 8 layers. Every subsystem compiles independently; `rtx`, `rtx-core`, `rtx-training`, and `rtx-inference-stack` meta-crates provide ergonomic entry points.

```
crates/
├── core/              (25 crates) — tensor, autograd, backends, kernels, memory, LoRA, fusion
├── training/          (15 crates) — transformers, distributed, RL, compression, NAS, federated
├── models/            (9 crates)  — vision, multimodal, diffusion, NLG, TTS, time series
├── production/        (9 crates)  — inference, serving, streaming, ONNX, WASM, monitoring
├── specialized/       (43 crates) — medical imaging, neuroimaging (16 crates), physics-informed, CFD/FEM
├── data/              (3 crates)  — ETL, feature store, data validation
├── tooling/           (3 crates)  — benchmarking, evaluation, kernel profiling
├── integration/       (3 crates)  — Burn, Candle, RustyBooks interop
└── meta/              (4 crates)  — rtx, rtx-core, rtx-training, rtx-inference-stack
```

### Backend Support

| Backend | Hardware | Status |
|---------|----------|--------|
| CUDA (cudarc 0.18.1) | NVIDIA RTX / A100 / H100 / Blackwell | Production |
| Metal (objc2-metal) | Apple M1–M5 (unified memory, MPS) | Production |
| ROCm | AMD RDNA 2/3 | Production |
| SYCL | Intel Arc | Experimental |
| WebGPU | Browser / WASM | Experimental |
| CPU (MKL/OpenBLAS) | x86 / ARM | Production |

---

## GPU Optimizations

19 batches of Blackwell SM_120–targeted optimizations (RTX 5060 Ti primary target):

### Batches 1–4 — Core Kernel Infrastructure
- **FP8 training** (E4M3 forward / E5M2 gradients): microscaling block-wise quant, `Fp8GradScaler` with amax tracking
- **FlashAttention-3** WGMMA + TMA + warp specialization (SM_120 codepath); FA2 fallback for older GPUs
- **CUDA Graphs** capture with warmup, static-shape enforcement, `CudaGraphManager`
- **SnapKV attention-score eviction** + Zobrist-hash prefix caching (50–70% KV reduction)
- **EAGLE-3 speculative decoding**, **GaLore-2 gradient projection**
- **W4A16 AWQ** weight-only quantization; **FSDP2** parameter hooks; fused **RMSNorm+SwiGLU** kernel
- **SmoothQuant INT8** forward; varlen Flash Attention; inference graph capture
- Mid-batch request injection; **PagedAttention v2** defrag; fused **RoPE** kernel

### Batches 5–11 — Inference Efficiency
- KV INT8 quantization; col/row-parallel linear; interleaved **1F1B** pipeline schedule
- Attention-selective gradient checkpointing; flash decoding (split-K reduce)
- **Multi-Token Prediction (MTP)** heads (k independent [hidden→vocab] weight matrices)
- Sparse attention masks: local window + global tokens + random LCG; 75% sparsity at n=512
- Sequence length bucketing: Fisher-Yates per-bucket shuffle, 2.2× padding reduction
- **Token Merging (ToMe)**: bipartite soft matching, 75% merge at r=32/seq=64
- Gradient accumulation per-step normalization; **speculative streaming** with Welford latency stats
- **Attention sinks** (StreamingLLM): retains first `sink_size` + last `window_size` positions
- **Chunked prefill** (512-token chunks, interleaved with decode)
- Per-layer LR decay; **WSD scheduler** (warmup → stable → cosine/linear/sqrt decay)
- KV CPU offload (LRU GPU→CPU spill with prefetch); **GQA** KV head expansion

### Batches 12–19 — Advanced Algorithms
- **Online quantization calibration**: MaxAbs / EMA-MaxAbs / Percentile streaming observers
- **Draft distillation**: KL(p_target ‖ p_draft) + CE hard label; temperature scaling
- **Gradient Noise Scale** (McCandlish 2018): two-point B_noise estimator, adaptive batch signal
- **ModelEMA**: decay-weighted shadow weights; bias correction; apply/restore swap
- **ALBERT-style shared layers**: Full/Grouped/Alternating sharing; memory_reduction_ratio
- **Schedule-Free optimizer** (Defazio 2024): z/x dual sequences, `c_t` interpolation
- **Muon optimizer**: Nesterov + quintic Newton-Schulz (5-iter); decoupled weight decay
- **Logit processors**: temperature, top-k, top-p, min-p, repetition/presence/frequency penalty, eta-sampling
- **Per-token activation quantization**: dynamic INT8/FP8E4M3 per-token scaling
- **Shampoo**: Kronecker L/R factors, two-pass Schulz A^{-1/4}
- **Beam search**: length normalization (Wu α=0.6), n-gram blocking, diverse beam search
- **Sliding window attention**: causal/bidirectional, global tokens, O(n·W)
- **SOAP optimizer** (arXiv:2409.11321): Adam in Shampoo eigenbasis (Jacobi eigen)
- **Lookahead decoding** (arXiv:2402.02057): NGramCache FIFO, draft-verify loop
- **SWA + SWAG**: cyclic cosine LR, online incremental mean, diagonal variance + low-rank deviations
- **RoPE scaling**: Linear interpolation, dynamic NTK, YaRN per-freq blending + temperature
- **DPO** (arXiv:2305.18290) + IPO (arXiv:2310.12036) + robust DPO with label smoothing
- **Label-smoothed CE + focal loss** (Lin 2017) + binary CE/focal
- **Contrastive losses**: NT-Xent/SimCLR, InfoNCE, SupCon multi-positive
- **Feature distillation**: FitNets, Attention Transfer, RKD-Distance + RKD-Angle
- **Data samplers**: Temperature, Importance, Stratified, HardNegativeMiner, Curriculum
- **Medusa heads**: SiLU 2-layer FFN; tree generation via cartesian product; path verification
- **TIES + DARE model merging** (arXiv:2306.01708, 2311.03099)
- **Mixture of Depths** (Raposo 2024): top-k token selection, residual bypass, load-balancing loss

---

## JEPA Platform

Batches 20–26 implement a complete JEPA self-supervised learning stack: I-JEPA (Assran 2023), V-JEPA (video), Neuro-JEPA (EEG/MEG), ViT encoder wiring, streaming data pipeline, and cluster-scale parallelism config. All 163 tests pass. All modules are in `crates/training/rtx-transformers/src/ssl/`.

### Batch 20–22 — I-JEPA Core (`ssl/jepa.rs`, 62 tests)

| Component | Description |
|-----------|-------------|
| `BlockMaskStrategy` | Multi-block random masking: 4 target blocks, scale 0.15–0.20, aspect 0.75–1.5; Fisher-Yates context subsampling (keep 15%) |
| `JepaPredictor` | Narrow transformer (encoder_dim/4 hidden); mask tokens + position embeddings; in/out projection |
| `JepaTrainer` | Full I-JEPA step: mask → context encode → predict → target encode → L2 loss → EMA update |
| `EmaTargetEncoder` | τ-weighted shadow encoder; τ anneals 0.996→1.0; bias-corrected |
| `jepa_loss` | L2 in representation space per target block; returns `JepaLossResult` with per-block breakdown |
| `FeatureBank` + k-NN | L2-normalized cosine similarity memory bank; majority vote |
| `LinearProbe` | SGD on frozen encoder features; CE loss; `JepaEvaluator` wraps both |
| `ViTSize` | Tiny/Small/Base/Large/Huge with canonical embed_dim/depth/num_heads/predictor_dim |

### Batch 23 — V-JEPA + Neuro-JEPA (`ssl/vjepa.rs`, 21 tests)

| Component | Description |
|-----------|-------------|
| `PatchEmbed3D` | [T,H,W,C] → [total_patches, embed_dim]; 3D position embeddings |
| `TubeMaskStrategy` | Space-time tube masking: 90% mask ratio; temporal consistency per spatial position |
| `VJepaTrainer` | Video analog of JepaTrainer; supports arbitrary frame counts |
| `NeuroJepaConfig` | EEG/MEG config: 64ch × 16 segments, 256-dim embeddings |
| `NeuroMaskStrategy` | Channel-tube masking: mask entire time axis per selected channel |

### Batch 24 — ViT Encoder Bridge (`ssl/jepa_vit.rs`, 46 tests)

| Component | Description |
|-----------|-------------|
| `JepaEncoder` trait | `encode(&[usize]) -> Vec<f32>`, `embed_dim()`, `num_patches()` — clean abstraction |
| `CpuViTEncoder` | Sinusoidal + learned position embeddings; LCG-seeded weights; GELU FFN; MHSA; all 5 ViT sizes |
| `EmaViTEncoder` | Shadow weight EMA with τ annealing for target encoder |
| `JepaTrainerV2` | Uses `CpuViTEncoder`; wall-clock timing; `JepaViTStepMetrics` with per-block loss + encoder_forward_ms |

### Batch 25 — Streaming Data Pipeline (`ssl/jepa_data.rs`, 35 tests)

| Component | Description |
|-----------|-------------|
| `MultiScaleRandomCrop` | Random scale (0.08–1.0) + aspect ratio crop → resize |
| `JepaAugmentationPipeline` | Crop → horizontal flip → ImageNet normalize (µ=[0.485,0.456,0.406]) |
| `InMemoryShard` | In-memory shard abstraction for fast testing |
| `WebDatasetShard` | Filesystem shard descriptor (path, num_records, compressed) |
| `JepaDataPipeline` | Augmentation + masking + batching; `next_batch() -> JepaBatch` |
| `DatasetStats` | total_images, num_shards, avg_context/target_patches, mask_efficiency |

### Batch 26 — Cluster-Scale Config (`ssl/jepa_cluster.rs`, 42 tests)

| Component | Description |
|-----------|-------------|
| `GpuSpec` | Per-GPU hardware spec; `rtx5060ti()` → SM_120, 16 GB, 25 TFLOPS FP32 |
| `ClusterTopology` | N-node cluster with fabric bandwidth and type (NVLink/Ethernet/InfiniBand) |
| `JepaParallelConfig` | TP/PP/DP auto-config: TP≥4 for ViT-L (300M+), TP=8/PP=2 for ViT-H (600M+) |
| `CompressionMethod` | None / TopK{k_fraction} / PowerSGD{rank} / OneBitSGD |
| `AdaptiveBatchSizer` | GNS-based: double when gns > target, halve when < target/2, clamp [min, max] |
| `ClusterTrainingPlan` | steps_per_epoch, estimated_training_hours, human-readable `summary()` |

---

## Training Arsenal

### Optimizers

| Optimizer | Reference | Notes |
|-----------|-----------|-------|
| Adam / AdamW | Kingma 2014 | Standard baseline |
| Lion | Chen 2023 | Sign-based, memory-efficient |
| Sophia | Liu 2023 | Diagonal Hessian precond |
| AdEMAMix | Pagliardini 2024 | Dual EMA momentum |
| Muon | Jordan 2024 (arXiv:2409.20325) | Newton-Schulz quintic |
| Shampoo | Gupta 2018 | Kronecker factors |
| SOAP | Vyas 2024 (arXiv:2409.11321) | Adam in Shampoo eigenbasis |
| Schedule-Free | Defazio 2024 (arXiv:2405.15682) | No LR scheduler needed |
| GaLore-2 | Zhao 2024 | Gradient subspace projection |
| K-FAC | Martens 2015 | Natural gradient |
| L-BFGS | — | Second-order |
| AdaBound | Luo 2019 | Bounded learning rates |
| Novograd | Ginsburg 2019 | Layer-wise gradient normalization |
| Ranger | Wright 2020 | RAdam + Lookahead |

### LR Schedulers

- **WSD** (Warmup-Stable-Decay): `extend_stable()` mid-run; cosine/linear/sqrt decay modes
- **SWA**: cyclic cosine LR with SWAG posterior sampling
- Per-layer LR decay: `base_lr * decay_rate^(num_layers-1-depth)`
- LR Finder with automatic suggestion

### Loss Functions

- Cross-entropy (label-smoothed, focal, binary, combined)
- **DPO** (standard, IPO, robust with label smoothing)
- **Contrastive**: NT-Xent / SimCLR, InfoNCE, SupCon
- **Feature distillation**: FitNets L2, Attention Transfer, RKD-D + RKD-A
- **Draft distillation**: KL divergence + CE hard label + temperature scaling
- Gradient noise scale (GNS) with adaptive batch sizing

### Training Techniques

- Mixed precision (BF16/FP16/FP8) with loss scaling
- FSDP2 parameter hooks (full sharding)
- Gradient accumulation with per-step normalization
- Attention-selective gradient checkpointing
- Model EMA shadow weights with bias correction
- SWA + SWAG for uncertainty quantification
- **Continual learning**: EWC, SI, MAS, GEM, PackNet, Progressive Networks, Experience Replay
- **Curriculum learning**: difficulty scoring, adaptive sampling, multi-strategy curriculum
- **NAS**: DARTS, PC-DARTS, FairNAS
- **Federated learning**: 100K+ edge device coordination

### SSL Methods (pre-JEPA)

BYOL, MAE, MoCo v3, BEiT, SimCLR, SwAV, VICReg, SimMIM, Barlow Twins, CPC, Mean Teacher, Pseudo-Labeling — all in `rtx-transformers/ssl/`.

---

## Inference Stack

### Speculative Decoding

| Method | Description |
|--------|-------------|
| EAGLE-3 | Draft head trained on hidden states |
| Medusa | k parallel SiLU FFN draft heads, tree verification |
| Lookahead | N-gram cache draft-verify (arXiv:2402.02057) |
| Self-Speculative | Early-exit draft from same model |
| Assisted (EAGLE) | Separate smaller draft model |
| Multi-Token Prediction | k independent [hidden→vocab] heads |

### KV Cache

- Paged KV cache (UUID pages, copy-on-write)
- 3-tier storage: GPU → CPU (LRU offload) → NVMe
- **Attention sink eviction**: first `sink_size` + last `window_size` always retained
- **SnapKV eviction**: attention-score weighted, keep top `keep_ratio` per page
- **Prefix caching**: Zobrist hash, CoW sharing for common prefixes
- KV INT8 + FP8E4M3 quantization
- PagedAttention v2 defrag

### Serving

- Continuous batching with SLA lanes (P0/P1/P2 priority queues)
- Chunked prefill (512-token chunks, interleaved with decode)
- Inference graph capture (CUDA Graphs for static-shape decode)
- Grouped-query attention (GQA) head expansion
- Logit processors: temperature, top-k, top-p, min-p, repetition/presence/frequency, eta-sampling
- Beam search: length normalization, n-gram blocking, diverse beam search
- Speculative streaming: `mpsc` streamer with Welford online latency
- WebSocket + gRPC + HTTP serving

### Quantization

- INT8 (SmoothQuant), INT4, W4A16 AWQ
- FP8 E4M3 (forward) / E5M2 (gradient) with per-tensor and per-token scaling
- Online calibration: MaxAbs, EMA-MaxAbs, Percentile streaming observers
- Mixed-precision: per-layer precision assignment
- Activation quantization: per-token dynamic INT8/FP8

---

## Distributed Training

```
rtx-distributed/
├── FSDP2              — Full sharding with parameter hooks
├── Tensor Parallel    — Column/row-parallel linear layers
├── Pipeline Parallel  — Interleaved 1F1B schedule
├── Context Parallel   — Sequence-parallel ring attention
├── Hybrid Parallel    — TP + PP + DP combined
├── Device Mesh        — N-D parallelism topology
├── NCCL / RCCL       — AllReduce, AllGather, ReduceScatter
├── Gradient Compression — TopK / PowerSGD / 1-bit SGD
├── Elastic Training   — Dynamic node add/remove
├── Fault Tolerance    — Checkpoint + replay
├── DCP               — Distributed checkpointing
├── Comm Overlap      — Async gradient / compute overlap
└── RDMA Transport    — Zero-copy inter-node transfers
```

Collectives: AllReduce, AllGather, ReduceScatter, Broadcast, Scatter, Gather, AllToAll, Barrier.

---

## Model Architectures

### Vision (`rtx-vision`, `rtx-vision-advanced`)

- **ViT** (Tiny/Small/Base/Large/Huge) — patch embeddings, MHSA, classification head; configs: `ViTConfig::tiny()` through `large_14()`
- **ConvNeXt / ConvNeXt V2**, **MaxViT**, **CoAtNet**, **EfficientNet V2**, **MobileNet V3**, **MobileViT**, **EdgeViT**
- **DenseNet**, **ResNet**, **VGG**, **NFNet**, **RegNet**
- Image classification, detection, semantic segmentation, instance segmentation

### Language / Sequence

- **GPT-style LM** with MTP heads (k independent [hidden→vocab] matrices)
- **MQA** (single KV head), **GQA** (n KV heads), **Sliding window attention**, **Sparse attention**
- **Ring attention** — O(n) memory for long sequences across devices
- **FlexAttention** — programmable score modifiers; **SAGE attention** — quantized keys/values
- **Mamba / SSM** — O(n) selective state space; Metal-accelerated hybrid variant
- **RetNet**, **RWKV**, **S4**, **S5**, **Linear attention**, **MEGA**

### Graph, Multimodal, Other

- Graph Attention Networks, Graph Pooling, Graph Transformer
- CLIP-style vision-language models, audio transformers, cross-modal fusion
- **MoE**: SwitchTransformer, ExpertChoice, TokenChoice; Metal-accelerated
- **MoD**: top-k token selection per layer; load-balancing aux loss
- **Diffusion**: DDIM, classifier-free guidance
- **Time series**: ARIMA, Prophet, Transformer-based
- **Shared Layers**: ALBERT-style Full/Grouped/Alternating sharing

---

## Specialized Domains

### Medical Imaging (5 crates)

- DICOM + NIfTI I/O, MRI registration, segmentation (UNet, SegFormer)
- MRI → FEM mesh pipeline for biomechanical simulation (`rtx-mri2fe`)
- Virtual catheter hemodynamics (inverse Navier-Stokes PINN)
- MRE elastography (inverse Helmholtz), thermal ablation simulation

### Neuroimaging (16 crates — `rtx-neuro-*`)

- Real-time EEG/MEG via LSL (`rtx-neuro-lsl`)
- Source localization, GNN connectivity analysis, forward/inverse modeling
- Artifact rejection, signal processing, anatomical atlas integration
- PostgreSQL brain data store, Python bindings for interop

### Physics-Informed ML

- **FNO + DeepONet** (`rtx-neural-operator`): mesh-agnostic PDE solving, 1000× faster than FEM
- **PINNs**: Helmholtz, Navier-Stokes, heat equation, Burgers'
- **Physics-Informed Diffusion** (`rtx-piddm`): generative PDE solving
- **CFD** (`rtx-cfd`), **FEM** (`rtx-fea`, `rtx-fem-export`), **Digital Twin** (`rtx-digital-twin`)

### Interpretability (`rtx-interpret`)

- Sparse Autoencoders (SAE), attribution methods, mechanistic interpretability

---

## Quick Start

### Installation

```bash
# Rust nightly 2024 edition required
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain nightly
source ~/.cargo/env

# CUDA environment (Linux)
export CUDA_PATH=/usr/local/cuda
export LD_LIBRARY_PATH=$CUDA_PATH/lib64:$LD_LIBRARY_PATH
export PATH="/home/$USER/.cargo/bin:$PATH"
```

### Build & Test

```bash
# Build all crates
cargo build --workspace

# Build with CUDA (Blackwell SM_120 target)
cargo build --release --workspace --features cuda

# Build with Metal (Apple Silicon)
cargo build --release --workspace --features metal

# Run tests (key packages)
cargo test -p rtx-transformers --lib    # 2,800+ tests (incl. 163 JEPA SSL)
cargo test -p rtx-tensor --lib          # 706 tests
cargo test -p rtx-inference --lib       # 297 tests
cargo test -p rtx-compress --lib        # 148 tests

# JEPA-specific tests
cargo test -p rtx-transformers -- ssl::jepa
cargo test -p rtx-transformers -- ssl::vjepa
cargo test -p rtx-transformers -- ssl::jepa_vit
cargo test -p rtx-transformers -- ssl::jepa_data
cargo test -p rtx-transformers -- ssl::jepa_cluster

# Full workspace
cargo test --workspace
```

### JEPA Training Example

```rust
use rtx_transformers::ssl::{
    jepa::{JepaTrainer, JepaConfig, ViTSize},
    jepa_vit::{CpuViTEncoder, JepaTrainerV2, JepaViTConfig},
    jepa_data::{JepaDataPipeline, JepaDataConfig},
    jepa_cluster::{ClusterTopology, JepaParallelConfig, AdaptiveBatchSizer},
    vjepa::{VJepaTrainer, VideoPatchConfig, TubeMaskConfig},
};

// I-JEPA with ViT-Large
let config = JepaConfig {
    vit_size: ViTSize::Large,    // d=1024, depth=24, 16 heads
    ema_tau_start: 0.996,
    ema_tau_end: 1.0,
    total_steps: 125_000,
    ..Default::default()
};
let mut trainer = JepaTrainerV2::new(config);

// Cluster auto-parallelism (TP=4 for ViT-L on 8-GPU node)
let topo = ClusterTopology::single_node_8gpu();
let parallel = JepaParallelConfig::for_model_and_cluster(ViTSize::Large, &topo);
// → tensor_parallel=4, data_parallel=2

// GNS-adaptive batch sizing
let mut batcher = AdaptiveBatchSizer::new(256, 4096, 16.0);
// batcher.update(observed_gns) → adjusts batch size each step

// V-JEPA for video
let vjepa = VJepaTrainer::new(VideoPatchConfig::default(), TubeMaskConfig::default());
```

### Inference Example

```rust
use rtx_inference::{
    speculative::{MedusaDraftModel, AdvancedSpeculativeDecoder},
    cache::{PagedKvCache, AttentionSinkEviction},
    logit_processors::{LogitProcessorList, TemperatureProcessor, TopPProcessor},
};
use rtx_transformers::{
    training::{ModelEma, WsdScheduler},
    optimizers::MuonOptimizer,
};

// Medusa speculative decoding
let decoder = AdvancedSpeculativeDecoder::medusa(MedusaConfig { num_heads: 4 });

// WSD scheduler + Muon optimizer
let scheduler = WsdScheduler::new(warmup=2000, stable=100_000, decay=23_000);
let optimizer = MuonOptimizer::new(&params, MuonConfig::default());

// Attention sinks for streaming inference
let cache = PagedKvCache::with_eviction(AttentionSinkEviction { sink_size: 4, window_size: 512 });
```

---

## Benchmarks

### RTX 5060 Ti (Blackwell SM_120) — GPU Perf Targets

| Component | Improvement |
|-----------|-------------|
| FP8 training (vs BF16) | ~40% throughput, ~50% memory |
| FlashAttention v3 (vs FA2) | 1.5–2× throughput on SM_120 |
| CUDA Graphs (decode loop) | 5–20% latency reduction |
| SnapKV (2048-token context) | ≥50% KV page reduction |
| Sparse attention (n=4096) | 97% sparsity, 10× memory |
| Token Merging (r=32) | 75% merge rate, 3× throughput |

### PINN Benchmark (RTX 4090)

| Metric | RustyTorch++ | PyTorch 2.x | Speedup |
|--------|-------------|-------------|---------|
| Forward pass (200 pts) | 41 µs | 97 µs | 2.35× |
| Training step (200 pts) | 127 µs | ~600 µs | 4.7× |
| Training throughput | ~8,000 steps/s | ~1,600 steps/s | 5× |

---

## CLI & Tooling

### `rtx-bench` — Benchmarking Suite

```bash
# Kernel-level benchmarks
cargo run -p rtx-bench -- --kernel flash-attention --seq-len 4096 --heads 32

# End-to-end throughput
cargo run -p rtx-bench -- --model gpt2-small --batch 32 --dtype fp8

# Compare FA2 vs FA3 on current GPU
cargo run -p rtx-kernel-bench -- --attn fa2,fa3
```

### `rtx-eval` — Model Evaluation

```bash
# Linear probe evaluation (frozen encoder)
cargo run -p rtx-eval -- --mode linear-probe --encoder vit-l --dataset imagenet

# k-NN evaluation
cargo run -p rtx-eval -- --mode knn --k 20 --encoder jepa-encoder

# Generation benchmarks (tokens/sec, TTFT)
cargo run -p rtx-eval -- --mode generation --model llama-7b --speculative medusa
```

### Serving API

```bash
# HTTP/gRPC model server
cargo run -p rtx-serving-api --release -- --model path/to/model --port 8080 --speculative medusa
```

### Python Bindings (PyO3)

```python
import rustytorch as rtx

# Tensor operations
x = rtx.Tensor.randn([batch, seq, hidden], device="cuda")
out = rtx.flash_attention(q, k, v, causal=True)

# SSL feature extraction
encoder = rtx.JepaEncoder.load("path/to/jepa-vit-l")
features = encoder.encode(images)  # [N, 1024]
```

### Interactive Demo Platform

Tauri desktop app with 18 GPU-accelerated demos (medical imaging, AI/ML, CFD, computer vision):

```bash
cd demos/ui && pnpm install && pnpm tauri dev
```

---

## JEPA Next Steps

The core JEPA stack (Batches 20–26) is implemented and tested. The gap between the current CPU-testable implementation and a production multi-node cluster run spans six areas:

### 1. GPU Backend Wiring
`CpuViTEncoder` runs pure f32 CPU math. The `JepaEncoder` trait is designed for substitution — the next step is implementing `GpuViTEncoder` that dispatches through `rtx-tensor`'s CUDA backend, enabling FP8 forward on Blackwell SM_120.

### 2. Real ViT Backbone Integration
`rtx-vision/models/vit.rs` has a production ViT. Wire it to implement `JepaEncoder` so `JepaTrainerV2` uses the real backbone instead of `CpuViTEncoder`. This is the single highest-impact integration.

### 3. ImageNet-Scale Data Pipeline
`WebDatasetShard` has the descriptor but `JepaDataPipeline::from_filesystem()` is a stub. Implement actual tar shard reading (WebDataset format), shuffle buffers, and worker-parallel prefetch for multi-node ImageNet.

### 4. Multi-Node AllReduce
`JepaParallelConfig` auto-selects TP/PP/DP. Wire the gradient AllReduce calls through `rtx-distributed::nccl` for actual multi-GPU / multi-node data-parallel training.

### 5. Training Loop CLI
Add a `jepa-train` binary (or subcommand of `rtx-bench`) that reads a TOML config, instantiates `JepaTrainerV2`, runs the data pipeline, logs metrics, and checkpoints via DCP.

### 6. Downstream Evaluation Harness
Wire `JepaEvaluator::linear_probe()` and `knn_eval()` into `rtx-eval` CLI for end-to-end ImageNet linear probe reporting — the canonical JEPA quality metric.

---

## License

Apache 2.0

```bibtex
@software{rustytorch2026,
  title   = {RustyTorch++: GPU-Accelerated ML Framework in Pure Rust},
  author  = {Omar Sobh},
  year    = {2026},
  url     = {https://git.redclaw.dev/rustyverse/rustytorch},
  note    = {113 crates, Blackwell SM\_120 optimized, JEPA platform complete through Batch 26}
}
```

**Where memory safety meets state-of-the-art machine learning.**