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

A robotic intelligence assembled in a machine-learning laboratory

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.

1use oa::{Engine, Matrix, ml};
2
3let engine = Engine::new()?;
4let x = Matrix::from_f32(&engine, [5, 1], &[-2., -1., 0., 1., 2.])?;
5let target = Matrix::from_f32(&engine, [5, 1], &[-3., -1., 1., 3., 5.])?;
6let model = ml::nn::Linear::with_seed(&engine, 1, 1, 0)?;
7let mut optimizer = ml::Sgd::new(model.parameters(), 0.05, 0.0, 0.0)?;
8
9for _ in 0..80 {
10    optimizer.zero_grad();
11    let tape = ml::GradientTape::new();
12    let loss = ml::loss::mse(&model.forward(&x)?, &target)?;
13    tape.backward(&loss)?;
14    drop(tape);
15    optimizer.step()?;
16}

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.5 tree includes newer grouped Mamba-3 correctness evidence; its separately measured current-tree timing is not mixed into this historical five-family table.

Oa Library

One library. Across the stack.

Follow the same Engine, values, and explicit execution contract into another module.

Machines that learn.Systems that remember.