Machine Learning

Train and deploy through one Vulkan compute runtime.

OA is a GPU-first C++ and Python machine-learning stack built around oa::Matrix, graph-recorded operators, automatic differentiation, reusable modules, and portable model artifacts.

RNN · GRU · TransformerDense and sparse MoEMamba-3 · Empyrealm

Machine Learning

One execution model

Operators record into the current compute context. Modules compose those operators,oa::GradientTape builds the backward pass, and the runtime submits the resulting work to Vulkan. Python imports the corresponding values from the oa package root and calls C++-parity operation modules such as FnLoss.

Autograd

Forward operations register their gradient rules; no separate handwritten training graph is required.

Modules

Linear, embedding, recurrent, attention, Transformer, MoE, VQ, and optimizer components share one parameter contract.

Artifacts

.oam files persist architecture metadata, weights, optimizer state, and checkpoint identity.

Measured training

Training logs distinguish wall time, GPU time, validation loss, throughput, and task-specific quality metrics.

Core API

Type or namespace	Role
`oa::Matrix`	Device-backed tensor shared by operators, modules, gradients, Vision, and Audio.
`oa::Module`	Parameter and submodule container with recursive serialization.
`oa::FnMatrix::*`	Stateless matrix, activation, normalization, and sequence operations; loss and metrics retain their own Fn families.
`oa::GradientTape`	Reverse-mode automatic differentiation over the recorded forward graph.
`oa::AdamW`	Optimizer over the recursive parameter list returned by a module.
`oa::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.

1oa::Linear layer(32, 64);
2oa::Matrix input = oa::FnMatrix::randN(oa::MatrixShape{8, 32});
3oa::Matrix output = layer.forward(input);
4oa::Vector<oa::F32> values(output.numElements());
5oa::FnMatrix::copyToHost(output, values.data(), values.size() * sizeof(oa::F32));
6

Verified reference workload

The native NLP suite covers Byte, BPE, and character tokenization across RNN, GRU, Transformer, sparse MoE Transformer, and experimental SSM backbones. Every run trains, evaluates, generates text, and verifies checkpoint round-trip behavior. The current Intel Iris Xe reference uses FP32; precision routes remain capability-gated rather than assumed.

Applications

Text to motion · USD

Alm

Generate prompt-conditioned motion tokens and decode them into a canonical USD skeleton clip through one native OA model bundle.

Android · Physical Vulkan

Mobile Lab

Train the same five OA NLP architectures on a physical Adreno GPU, inspect live GPU metrics, and verify generation plus checkpoint replay from one Android application.