Machine Learning

Machines that learn.
Systems that remember.

A GPU-first Rust system for automatic differentiation, dense and sparse models, state-space intelligence, training control, and portable model artifacts.

Learning path

From raw symbols to a mind you can reload.

The engine sees one connected act: representation, model, differentiation, optimization, evaluation, and memory. Every boundary stays explicit enough to inspect and test.

Represent the world

Byte, character, and deterministic BPE inputs enter the same typed matrix and semantic-operation system.

Compose the mind

RNN, GRU, Transformer, sparse MoE, and Mamba-3 modules share parameters, autograd, loss, and metrics.

Train the graph

Forward, loss, backward, gradient transforms, and AdamW become explicit work owned by one oa::Engine.

Preserve the intelligence

.oam v3 records architecture identity, model state, optimizer progress, and Dense, Q4, or Q8 weights.

One learning system

The machinery disappears. The contracts remain.

One semantic graph carries values, differentiation, optimization, execution, and persistence. Rust owns the native work; language bindings map to that system instead of maintaining parallel learning implementations.

One differentiable system

Modules, parameters, losses, optimizers, and generated backward rules operate over the same semantic graph instead of a separate training framework.

Explicit execution

Stable regions capture as immutable oa::ExecutionPlan values. submit returns the exact oa::Event; metrics and checkpoints remain deliberate host boundaries.

Dense, sparse, and state-space

Classical recurrence, multi-head attention, dropless top-k MoE, grouped-state Mamba-3 SISO, and shared-state MIMO live behind one module surface.

Rust-native training

Rust composes values, modules, autograd, optimizers, and Vulkan kernels through one ownership-safe implementation. Python Ml bindings follow after contract admission.

Semantic Q4 and Q8

Quantized matrices carry packed values, scales, logical shape, and policy explicitly through fused inference and .oam persistence.

Live, bounded control

An opt-in local MCP control plane can inspect, pause, resume, evaluate, and checkpoint an application-approved training session at safe points.

Sequence intelligence

Five ways to remember. One training consciousness.

RNN and GRU establish compact recurrence; dense Transformer and dropless sparse MoE express attention; grouped-state Mamba-3 SISO and shared-state MIMO carry state-space memory. Each is a different theory of sequence intelligence expressed through the same values, gradients, optimizer, metrics, generation, and checkpoint lifecycle.

Native training

A small surface over the complete graph.

Modules register parameters. The tape records semantic backward rules. The training session coordinates steps, validation, metrics, and checkpoints without taking ownership away from oa::Engine.

Train.rs

1use oa::{Engine, ml};
2
3let engine = Engine::new()?;
4let mut optimizer = ml::AdamW::new(model.all_parameters()?, 2.0e-4)?;
5let mut training = ml::ItTraining::new_eager(
6    &engine,
7    &mut optimizer,
8    ml::ItTrainingConfig { total_steps: 300, ..Default::default() },
9)?;
10
11while training.begin_step()? {
12    training.zero_grad();
13    let tape = ml::GradientTape::new();
14    let logits = model.forward(&batch_x)?;
15    let loss = ml::loss::cross_entropy(&logits, &batch_y)?;
16    tape.backward(&loss)?;
17    training.complete_step(&loss)?;
18}

Verified workloads

Evidence before mythology.

Five families, three tokenizers, and 15 complete workloads share one 300-step contract. The table uses the published OA 0.7.4 single-method Byte reference so wall time, source throughput, and learning quality remain directly comparable.

204.68K

RNN source byte/s

128.93K

Transformer source byte/s

118.79K

Sparse MoE source byte/s

30.72K

Mamba-3 source byte/s

ArchitectureWall ms/stepSource byte/sFinal accuracy

RNN5.00 ± 0.08204.68K ± 3.09K92.30%

GRU11.17 ± 1.2692.81K ± 9.74K92.30%

Transformer7.99 ± 0.63128.93K ± 9.53K92.50%

Sparse MoE8.62 ± 0.10118.79K ± 1.38K92.20%

Mamba-333.34 ± 0.4630.72K ± 0.42K93.00%

Iris Xe TGL GT2, FP32, batch 64, sequence 16, 1,024 predicted positions per step. The v0.8.0 tree includes newer grouped Mamba-3 correctness evidence; its separately measured current-tree timing is not mixed into this historical five-family table.

Machines that learn.Systems that remember.