Requirements

• Rust 1.85 or later
• Cargo
• Node.js (for PM2 process management)
• Aegis-DB (document store database)

Bundling & Deployment

axonml zip create -o bundle.zip --model m.f --data d/ # Create bundle axonml zip extract bundle.zip -o ./output # Extract bundle axonml zip list bundle.zip # List bundle contents axonml upload model.axonml --hub myrepo # Upload to model hub axonml serve model.axonml --port 8080 # Start inference server

Production Edge Deployment

AxonML powers real-time predictive maintenance on HVAC systems across commercial buildings. 12 models (6 LSTM autoencoders for anomaly detection + 6 GRU failure predictors) run live inference on Raspberry Pi edge controllers, processing sensor data at 1 Hz.

Stack: AxonML training (CPU) → .axonml model files → cross-compiled ARM inference daemons (armv7-unknown-linux-musleabihf) → PM2-managed services on Raspberry Pi → REST API (/api/inference/latest)

Each daemon runs pure-tensor inference (no autograd overhead), polls local NexusEdge for sensor data, maintains rolling time-series buffers, and exposes anomaly scores + failure predictions via HTTP.

Building from Source

Build

git clone https://github.com/automatanexus/axonml
cd axonml
cargo build --release

Install CLI

cargo install --path crates/axonml-cli

Server Deployment

First-time setup

cargo build --release -p axonml-server # Build release binary sudo mkdir -p /var/log/axonml # Create log directory sudo chown $USER:$USER /var/log/axonml

Quick Start

Add Axonml to your Cargo.toml:

[dependencies]
axonml = "0.6"

Basic Usage

use axonml::prelude::*;

fn main() {
    // Create tensors
    let a = zeros::<f32>(&[2, 3]);
    let b = ones::<f32>(&[2, 3]);

    // Arithmetic operations with broadcasting
    let c = &a + &b;
    let d = &c * 2.0;

    // Matrix operations
    let e = randn::<f32>(&[3, 4]);
    let f = randn::<f32>(&[4, 5]);
    let g = e.matmul(&f).unwrap();

    // Reductions
    let sum = d.sum();
    let mean = d.mean().unwrap();

    // Activations
    let h = randn::<f32>(&[10]);
    let activated = h.relu();

    println!("Result shape: {:?}", g.shape());
}

Training Example

use axonml::prelude::*;
use axonml_nn::{Sequential, Linear, ReLU, CrossEntropyLoss, Module};
use axonml_optim::{Adam, Optimizer};
use axonml_data::{DataLoader, Dataset};

fn main() {
    // Build model
    let model = Sequential::new()
        .add(Linear::new(784, 256))
        .add(ReLU)
        .add(Linear::new(256, 10));

    // Setup optimizer
    let mut optimizer = Adam::new(model.parameters(), 0.001);

    // Training loop
    for epoch in 0..10 {
        for batch in dataloader.iter() {
            let output = model.forward(&batch.data);
            let loss = CrossEntropyLoss::new().compute(&output, &batch.targets);

            optimizer.zero_grad();
            loss.backward();
            optimizer.step();
        }
    }
}

Configure W&B

axonml wandb login axonml wandb init --project my-project

Environment Variables

Server Sync (CLI ↔ Webapp Integration)

axonml login # Login to AxonML server axonml login --server http://server:3021 # Login to custom server axonml logout # Logout and clear credentials axonml sync # Check sync status with server axonml sync --full # Full sync of training runs, models, datasets

Start the full stack (dashboard + API server)

axon start

Start only the API server

axon start --server --port 3000

Training (with real axonml integration)

axonml train config.toml # Train from config file axonml train --model mlp --epochs 10 # Quick training axonml resume checkpoint.axonml # Resume from checkpoint

Kaggle Integration

axonml kaggle login <username> <key> # Save Kaggle API credentials axonml kaggle status # Check authentication status axonml kaggle search "image classification" # Search datasets axonml kaggle download owner/dataset # Download dataset axonml kaggle list # List downloaded datasets

Weights & Biases Integration

Built-in experiment tracking with W&B:

```bash