RustyTorch++

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

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
• GPU Optimizations — Batches 1–19 (Blackwell SM_120)
• JEPA Platform — Batches 20–26 (I-JEPA, V-JEPA, Neuro-JEPA)
• Training Arsenal
• Inference Stack
• Distributed Training
• Model Architectures
• Specialized Domains
• Quick Start
• Benchmarks
• CLI & Tooling
• 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

# 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

# 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

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

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

# 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

# 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

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

Python Bindings (PyO3)

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):

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

@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.