Axelera AI Export and Deployment#

Ultralytics partners with Axelera AI to enable high-performance, energy-efficient inference on Edge AI devices. Export and deploy Ultralytics YOLO models directly to the Metis® AIPU using the Voyager SDK.

Axelera AI provides dedicated hardware acceleration for computer vision at the edge, using a proprietary dataflow architecture and in-memory computing to deliver up to 856 TOPS with low power consumption.

Selecting the Right Hardware#

Axelera AI offers various form factors to suit different deployment constraints. The chart below helps identify the optimal hardware for your Ultralytics YOLO deployment.

Hardware Portfolio#

The Axelera hardware lineup is optimized to run Ultralytics YOLO26 and legacy versions with high FPS-per-watt efficiency.

Accelerator Cards#

These cards enable AI acceleration in existing host devices, facilitating brownfield deployments.

Integrated Systems#

For turnkey solutions, Axelera partners with manufacturers to provide systems pre-validated for the Metis AIPU.

• Metis Compute Board: A standalone edge device pairing the Metis AIPU with a Rockchip RK3588 ARM CPU.
• Workstations: Enterprise towers from Dell (Precision 3460XE) and Lenovo (ThinkStation P360 Ultra).
• Industrial PCs: Ruggedized systems from Advantech and Aetina designed for manufacturing automation.

Supported Tasks#

Axelera export supports all seven Ultralytics tasks. Semantic segmentation and depth estimation are available only with YOLO26, the only family that ships those heads.

YOLO26 detection, instance segmentation, pose and OBB models export their NMS-free one-to-one head by default, and the Axelera runtime decodes it on the host. Passing nms=True exports the one-to-many head instead, which scores lower on Metis: YOLO26n detection reaches mAP50-95 0.212 on COCO128 that way, against 0.453 with the NMS-free head.

Installation#

Ultralytics Installation#

pip install ultralytics

For detailed instructions, see our Ultralytics Installation guide. If you encounter difficulties, consult our Common Issues guide.

Axelera Driver Installation#

1. Add the Axelera repository key:

   sudo sh -c "curl -fsSL https://software.axelera.ai/artifactory/api/security/keypair/axelera/public | gpg --dearmor -o /etc/apt/keyrings/axelera.gpg"

2. Add the repository to apt:

   Choose the appropriate snippet from below to match the OS being used.

   # Ubuntu 22.04
   sudo sh -c "echo 'deb [signed-by=/etc/apt/keyrings/axelera.gpg] https://software.axelera.ai/artifactory/axelera-apt-source ubuntu22 main' > /etc/apt/sources.list.d/axelera.list"

   # Ubuntu 24.04
   sudo sh -c "echo 'deb [signed-by=/etc/apt/keyrings/axelera.gpg] https://software.axelera.ai/artifactory/axelera-apt-source ubuntu24 main' > /etc/apt/sources.list.d/axelera.list"

3. Install the driver and load it. SDK 1.9 needs metis-dkms 1.7.0 or newer, so the newest is installed here:

   sudo apt update
   sudo apt install -y metis-dkms
   sudo modprobe metis

[libaxldev.c:285] Found kernel driver version 1.6.2, but at least version 1.7.0 is required. Please update the kernel driver
ERROR: AXR_ERROR_CONNECTION_ERROR: Failed to open device metis-0:4:0

sudo apt update
sudo apt install -y metis-dkms
sudo rmmod metis
sudo modprobe metis

pip install axelera-devkit==1.9.0 --extra-index-url https://software.axelera.ai/artifactory/api/pypi/axelera-pypi/simple
pip install axelera-rt==1.9.0 --extra-index-url https://software.axelera.ai/artifactory/api/pypi/axelera-pypi/simple

Error: Unsupported model version: 4.0, expected at least 5.0
Please re-deploy or re-download the model.

Exporting YOLO Models to Axelera#

The Axelera format supports the Export, Predict, and Validate modes. Inference and validation run on Axelera Metis AIPU hardware. Export your model, then load the exported model to run inference or validate its accuracy.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to Axelera format
model.export(format="axelera")  # creates 'yolo26n_axelera_model'

from ultralytics import YOLO

# Load the exported Axelera model
model = YOLO("yolo26n_axelera_model")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported Axelera model
model = YOLO("yolo26n_axelera_model")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Export Arguments#

* Models are compiled for a single image, so the export batch only sets the calibration batch size. Pass batch to predict instead to hand the Axelera scheduler several images at once (Voyager SDK 1.8.0 or newer): see Maximum Performance.

For all export options, see the Export Mode documentation.

Output Structure#

yolo26n_axelera_model/
├── yolo26n.axm                  # Axelera model file
├── compiler_config_final.toml  # Compiler configuration used for the build
└── metadata.yaml               # Model metadata (classes, image size, etc.)

Axelera AI Benchmarks#

The Metis AIPU maximizes throughput while minimizing energy consumption.

Benchmarks based on Axelera AI data. Actual FPS depends on model size, batching, and input resolution.

These are host throughput figures, measured by the model zoo with the Voyager SDK's streaming pipeline over a 720p video file. A single predict call reports per-image latency instead, which is a different quantity.

Real-World Applications#

Ultralytics YOLO on Axelera hardware enables advanced edge computing solutions:

• Smart Retail: Real-time object counting and heatmap analytics for store optimization.
• Industrial Safety: Low-latency PPE detection in manufacturing environments.
• Drone Analytics: High-speed object detection on UAVs for agriculture and search-and-rescue.
• Traffic Systems: Edge-based license plate recognition and speed estimation.

Recommended Workflow#

1. Train your model using Ultralytics Train Mode
2. Export to Axelera format using model.export(format="axelera")
3. Validate accuracy with yolo val to verify minimal quantization loss
4. Predict using yolo predict for qualitative validation
5. Deploy to a high-performance end-to-end pipeline without PyTorch dependency — see the YOLO on Voyager SDK examples for composable Python pipelines using axelera-rt

Device Health Check#

Verify your Axelera device is functioning properly:

# if axdevice cannot be found, please run at least one inference (see above) to ensure the required packages are installed
axdevice

For detailed diagnostics, see the AxDevice documentation.

Maximum Performance#

Models are compiled for a single image, and a single image runs on one AIPU core. Passing several images to Predict hands them to the Axelera scheduler together, which spreads them over the cores of the device:

yolo predict model=yolo26n_axelera_model source=path/to/images batch=32

yolo26n at imgsz=640 over the 128 COCO128 images in a directory, Metis PCIe, median of three runs:

On SDK 1.9 a batch is what raises throughput, 2.7 times at batch=32, where 1.8 stays near 40 img/s at any batch size. Use a large batch for offline throughput and batch=1 when per-image latency matters. A second device adds little to predict: at batch=32 each image already spends about 4 ms in host-side preprocessing, as long as its time on the device.

Beyond predict#

For production requiring maximum throughput, the Axelera Voyager SDK offers:

• Streaming inference pipelines that keep several frames in flight
• Compiling one model across several cores
• Tiled inferencing for higher-resolution cameras

Those paths skip the PyTorch pre- and post-processing that predict runs on the host. See the model-zoo for FPS benchmarks or contact Axelera for production support.

Known Issues#

For support, visit the Axelera Community.

FAQ#