Train and deploy through one Vulkan compute runtime.
OA is a GPU-first Rust and Python machine-learning stack built around oa::Matrix, graph-recorded operators, automatic differentiation, reusable modules, and portable model artifacts.
One execution model
Operators record into the current compute context. Modules compose those operators,oa::ml::GradientTape builds the backward pass, and the runtime submits the resulting work to Vulkan. Python imports the available values from their owning modules and calls lowercase operation modules such as oa.ml.loss.
Autograd
Modules
Artifacts
Measured training
Core API
| Type or namespace | Role |
|---|---|
oa::Matrix | Device-backed tensor shared by operators, modules, gradients, Vision, and Audio. |
oa::ml::Module | Public model behavior and parameter traversal contract. |
oa::matrix / oa::ml::matrix | Stateless matrix, activation, normalization, and sequence operations; losses and metrics live in their owning ML modules. |
oa::ml::GradientTape | Reverse-mode automatic differentiation over the recorded forward graph. |
oa::ml::AdamW | Optimizer over the recursive parameter list returned by a module. |
oa::ml::ItTraining | Training metrics, validation, checkpoints, throughput, and GPU timing. |
One module, two front ends
The language switch changes the example without changing OA's execution model.
1use oa::{Engine, Matrix, ml};23fn main() -> oa::Result<()> {4 let engine = Engine::new()?;56 let x = Matrix::from_f32(&engine, [5, 1], &[-2.0, -1.0, 0.0, 1.0, 2.0])?;7 let target = Matrix::from_f32(&engine, [5, 1], &[-3.0, -1.0, 1.0, 3.0, 5.0])?;89 let model = ml::nn::Linear::with_seed(&engine, 1, 1, 0)?;10 let mut optimizer = ml::Sgd::new(model.parameters(), 0.05, 0.0, 0.0)?;1112 let mut initial_loss = 0.0_f32;13 let mut loss_matrix = Matrix::from_f32(&engine, [1], &[0.0])?;1415 for step in 0..80 {16 optimizer.zero_grad();17 let tape = ml::GradientTape::new();18 let prediction = model.forward(&x)?;19 loss_matrix = ml::loss::mse(&prediction, &target)?;20 tape.backward(&loss_matrix)?;21 drop(tape);22 optimizer.step()?;2324 if step == 0 {25 initial_loss = loss_matrix.read_f32()?[0];26 }27 }2829 let final_loss = loss_matrix.read_f32()?[0];30 let values = model.forward(&x)?.read_f32()?;3132 assert!(final_loss < initial_loss * 0.01);33 assert!(34 values35 .iter()36 .zip([-3.0_f32, -1.0, 1.0, 3.0, 5.0])37 .all(|(&a, b)| (a - b).abs() < 0.1)38 );3940 println!("loss: {initial_loss:.6} -> {final_loss:.6}");41 println!("{values:?}");42 Ok(())43}44
Verified reference workload
The native NLP suite covers Byte, BPE, and character tokenization across RNN, GRU, Transformer, sparse MoE Transformer, and experimental SSM backbones. The source suite exercises training, evaluation, text generation, and checkpoint workflows; Rust and Python qualification remains scoped to the individual workload. The current Intel Iris Xe reference uses FP32; precision routes remain capability-gated rather than assumed.