yolov26_3d/docs/en/integrations/axelera.md

comments, description, keywords

comments	description	keywords
true	Deploy Ultralytics YOLO models on Axelera AI's Metis hardware. Learn how to export, compile, and run high-performance edge inference with up to 856 TOPS.	Axelera AI, Metis AIPU, Voyager SDK, Edge AI, YOLOv8, YOLO26, Model Export, Computer Vision, PCIe, M.2, Object Detection, quantization

Axelera AI Export and Deployment

!!! tip "Experimental Release"

This is an experimental integration demonstrating deployment on Axelera Metis hardware. Full integration anticipated by **February 2026** with model export without requiring Axelera hardware and standard pip installation.

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.

graph TD
    A[Start: Select Deployment Target] --> B{Device Type?}
    B -->|Edge Server / Workstation| C{Throughput Needs?}
    B -->|Embedded / Robotics| D{Space Constraints?}
    B -->|Standalone / R&D| E[Dev Kits & Systems]

    C -->|Max Density <br> 30+ Streams| F[**Metis PCIe x4**<br>856 TOPS]
    C -->|Standard PC <br> Low Profile| G[**Metis PCIe x1**<br>214 TOPS]

    D -->|Drones & Handhelds| H[**Metis M.2**<br>2280 M-Key]
    D -->|High Performance Embedded| I[**Metis M.2 MAX**<br>Extended Thermal]

    E -->|ARM-based All-in-One| J[**Metis Compute Board**<br>RK3588 + AIPU]
    E -->|Prototyping| K[**Arduino Portenta x8**<br>Integration Kit]

    click F "https://store.axelera.ai/"
    click G "https://store.axelera.ai/"
    click H "https://store.axelera.ai/"
    click J "https://store.axelera.ai/"

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.

Product	Form Factor	Compute	Performance (INT8)	Target Application
Metis PCIe x4	PCIe Gen3 x16	4x Metis AIPUs	856 TOPS	High-density video analytics, smart cities
Metis PCIe x1	PCIe Gen3 x1	1x Metis AIPU	214 TOPS	Industrial PCs, retail queue management
Metis M.2	M.2 2280 M-Key	1x Metis AIPU	214 TOPS	Drones, robotics, portable medical devices
Metis M.2 MAX	M.2 2280	1x Metis AIPU	214 TOPS	Environments requiring advanced thermal management

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

Currently, Object Detection models can be exported to the Axelera format. Additional tasks are being integrated:

Task	Status
Object Detection	✅ Supported
Pose Estimation	Coming soon
Segmentation	Coming soon
Oriented Bounding Boxes	Coming soon

Installation

!!! warning "Platform Requirements"

Exporting to Axelera format requires:

- **Operating System**: Linux only (Ubuntu 22.04/24.04 recommended)
- **Hardware**: Axelera AI accelerator ([Metis devices](https://store.axelera.ai/))
- **Python**: Version 3.10 (3.11 and 3.12 coming soon)

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:

   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"
   

3. Install the SDK and load the driver:

   sudo apt update
   sudo apt install -y axelera-voyager-sdk-base
   sudo modprobe metis
   yes | sudo /opt/axelera/sdk/latest/axelera_fix_groups.sh $USER
   

Exporting YOLO Models to Axelera

Export your trained YOLO models using the standard Ultralytics export command.

!!! example "Export to Axelera Format"

=== "Python"

    ```python
    from ultralytics import YOLO

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

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

=== "CLI"

    ```bash
    yolo export model=yolo26n.pt format=axelera
    ```

Export Arguments

Argument	Type	Default	Description
format	str	'axelera'	Target format for Axelera Metis AIPU hardware
imgsz	int or tuple	640	Image size for model input
int8	bool	True	Enable INT8 quantization for AIPU
data	str	'coco128.yaml'	Dataset config for quantization calibration
fraction	float	1.0	Fraction of dataset for calibration (100-400 images recommended)
device	str	None	Export device: GPU (device=0) or CPU (device=cpu)

For all export options, see the Export Mode documentation.

Output Structure

yolo26n_axelera_model/
├── yolo26n.axm              # Axelera model file
└── metadata.yaml            # Model metadata (classes, image size, etc.)

Running Inference

Load the exported model with the Ultralytics API and run inference, similar to loading ONNX models.

!!! example "Inference with Axelera Model"

=== "Python"

    ```python
    from ultralytics import YOLO

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

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

    # Process results
    for r in results:
        print(f"Detected {len(r.boxes)} objects")
        r.show()  # Display results
    ```

=== "CLI"

    ```bash
    yolo predict model='yolo26n_axelera_model' source='https://ultralytics.com/images/bus.jpg'
    ```

!!! warning "Known Issue"

The first inference run may throw an `ImportError`. Subsequent runs will work correctly. This will be addressed in a future release.

Inference Performance

The Metis AIPU maximizes throughput while minimizing energy consumption.

Metric	Metis PCIe x4	Metis M.2	Note
Peak Throughput	856 TOPS	214 TOPS	INT8 Precision
YOLOv5m FPS	~1539 FPS	~326 FPS	640x640 Input
YOLOv5s FPS	N/A	~827 FPS	640x640 Input
Efficiency	High	Very High	Ideal for battery power

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

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

Device Health Check

Verify your Axelera device is functioning properly:

. /opt/axelera/sdk/latest/axelera_activate.sh
axdevice

For detailed diagnostics, see the AxDevice documentation.

Maximum Performance

This integration uses single-core configuration for compatibility. For production requiring maximum throughput, the Axelera Voyager SDK offers:

• Multi-core utilization (quad-core Metis AIPU)
• Streaming inference pipelines
• Tiled inferencing for higher-resolution cameras

See the model-zoo for FPS benchmarks or contact Axelera for production support.

Known Issues

!!! warning "Known Limitations"

- **PyTorch 2.9 compatibility**: The first `yolo export format=axelera` command may fail due to automatic PyTorch downgrade to 2.8. Run the command a second time to succeed.

- **M.2 power limitations**: Large or extra-large models may encounter runtime errors on M.2 accelerators due to power supply constraints.

- **First inference ImportError**: The first inference run may throw an `ImportError`. Subsequent runs work correctly.

For support, visit the Axelera Community.

FAQ

What YOLO versions are supported on Axelera?

The Voyager SDK supports export of YOLOv8 and YOLO26 models.

Can I deploy custom-trained models?

Yes. Any model trained using Ultralytics Train Mode can be exported to the Axelera format, provided it uses supported layers and operations.

How does INT8 quantization affect accuracy?

Axelera's Voyager SDK automatically quantizes models for the mixed-precision AIPU architecture. For most object detection tasks, the performance gains (higher FPS, lower power) significantly outweigh the minimal impact on mAP. Quantization takes seconds to several hours depending on model size. Run yolo val after export to verify accuracy.

How many calibration images should I use?

We recommend 100 to 400 images. More than 400 provides no additional benefit and increases quantization time. Experiment with 100, 200, and 400 images to find the optimal balance.

Where can I find the Voyager SDK?

The SDK, drivers, and compiler tools are available via the Axelera Developer Portal.