01Overview

The ALPON X5 AI is an industrial edge AI computer built for image-based inference at the network edge. AI acceleration is provided by the DEEPX DX-M1: a 25 TOPS NPU with 4 GB of dedicated on-chip memory, fully independent of the Raspberry Pi CM5 system RAM. Every developer tool on this page targets that accelerator.

Custom-model pipeline

Path 2 (DXNN SDK) follows a four-stage pipeline. Path 1 (Sixfab Model Zoo) skips the first three stages because the .dxnn file ships pre-compiled inside sixfab-dx.

What lives where

The toolchain is split cleanly between the host PC (your development laptop) and the target device (the ALPON X5 AI). Keep this split in mind when wiring up build systems and CI pipelines.

Languages and APIs

The DEEPX Runtime ships first-class bindings for Python (dx_engine) and C++ (dxrt_api.h). Use Python for rapid prototyping, video analytics with OpenCV or GStreamer, and glue code. Use C++ when you need deterministic latency, embedded integration, or direct runtime control.

Two paths to inference

The ALPON X5 AI supports two complementary workflows. Pick the one that matches what you need today; you can mix them in the same project.

Supported workloads

The DEEPX DX-M1 is optimized for image-based AI workloads. The runtime executes convolutional architectures reliably. Transformer-based models are not supported on the current runtime.

• Object detection: YOLO family (v5, v7, v8, v11, YOLO26, YOLOX), SSD variants.
• Classification: ResNet, MobileNet, EfficientNet.
• Segmentation: U-Net, DeepLabV3, and other semantic segmentation backbones.
• OCR: PaddleOCR-based detection, classification, and recognition heads.
• Face detection and recognition: RetinaFace, SCRFD, ArcFace pipelines.
• Pose estimation: YOLOv8-Pose, HRNet keypoint regressors.

02DEEPX Runtime

How do I install the DEEPX Runtime on the ALPON X5 AI?

The DEEPX kernel driver and the Sixfab APT repository are preconfigured on ALPON X5 AI OS. Install sixfab-dx with a single apt command, or pull it into your Docker image during the build step.

sudo apt update && sudo apt install -y sixfab-dx

# 1. One-shot status check
dxrt-cli -s

# 2. Live monitoring while a workload runs
dxtop

source /opt/sixfab-dx/venv/bin/activate
python -c "import dx_engine; print(dx_engine.__version__)"

Running the runtime inside a Docker container

Production ALPON X5 AI deployments run inference code inside Docker containers. The kernel driver lives on the host, so the container only needs access to the device node and the runtime libraries.

# Minimal run command: privileged mode + NPU device node
docker run --privileged   --device /dev/dxrt0   -v $(pwd)/models:/models   -it your-image:tag

The equivalent in docker-compose.yml:

services:
  inference:
    image: your-image:tag
    privileged: true
    devices:
      - "/dev/dxrt0:/dev/dxrt0"
    volumes:
      - ./models:/models
    restart: unless-stopped

Concurrent models

The DEEPX Runtime schedules NPU time across multiple concurrently loaded models automatically. A typical ALPON X5 AI deployment pairs a detector (for example YOLO) with a classifier or OCR head on the same device. You do not need to implement your own scheduler.

03Sixfab Model Zoo

The Sixfab Model Zoo is the fastest way to validate your hardware and understand the inference pipeline before building your own application. The same runtime powers the demos and your production code, so any zoo demo can ship as-is or serve as a starting point.

Quick demo: run_hello_world

The sixfab-dx package includes a ready-to-run YOLOv8 object detection demo. It draws bounding boxes around cars, people, and other objects in real time using a bundled sample video, so no camera is needed to get started.

# Activate the bundled venv (if not already active)
source /opt/sixfab-dx/venv/bin/activate

# Launch the YOLOv8 demo
run_hello_world

Expected performance summary on the DEEPX DX-M1 (25 TOPS):

         PERFORMANCE SUMMARY
================================================
Pipeline Step   Avg Latency   Throughput
------------------------------------------------
Read              21.45 ms      46.6 FPS
Preprocess        14.11 ms      70.9 FPS
Inference        399.69 ms      16.0 FPS*
Postprocess        2.23 ms     449.0 FPS
Display           32.47 ms      30.8 FPS
------------------------------------------------
* Actual throughput via async inference
Overall FPS   :  16.0 FPS

To watch the NPU in real time, open a second SSH session and run dxtop. Core utilization should sit at 80 to 90 percent during active inference.

Available models

Pre-compiled .dxnn files included with the package. Performance figures are for the 25 TOPS DEEPX DX-M1 at default settings.

Supported camera inputs

The camera connects to the Raspberry Pi CM5 host; the NPU only receives preprocessed frames. Any of these sources work with zoo demos and with custom applications.

04DEEPX Model Zoo

Categories and representative models

Quantization modes: Q-Lite vs Q-Pro

Models in the zoo ship in two quantization flavors. Pick one based on your accuracy headroom and deployment timeline.

How do I download a model from the Model Zoo?

Models are distributed as .dxnn files from the DEEPX developer portal. On the ALPON X5 AI, fetch the file directly with wget or curl and mount it into your container.

# 1. Keep models under /opt/models on the host
sudo mkdir -p /opt/models
cd /opt/models

# 2. Download a Q-Lite YOLOv8 nano model (example path)
sudo curl -L -O   https://developer.deepx.ai/modelzoo/download/yolov8n_qlite.dxnn

Review the per-model license on the DEEPX developer portal before redistributing or shipping a commercial product derived from a zoo model.

05Deploy a custom model

Compiler host requirements

The dx-com compiler runs on a separate Ubuntu x86_64 machine. ARM and aarch64 hosts are not supported for compilation. The ALPON X5 AI itself is the deployment target, not the build host. Compile once per model on Ubuntu; the resulting .dxnn file then runs offline on any number of ALPON X5 AI devices.

Prerequisites

• An ALPON X5 AI powered on and reachable over SSH, with ALPON X5 AI OS up to date.
• sixfab-dx installed on the device per the DEEPX Runtime section.
• Docker available on the device (included with ALPON X5 AI OS).
• An Ubuntu x86_64 host meeting the requirements above for the compile step.
• A .dxnn model, either downloaded from a Model Zoo or compiled with dx-com on your host PC.

Step-by-step walkthrough

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
model.export(format="onnx", opset=13, simplify=True)
# produces yolov8n.onnx

dx-com compile   --model yolov8n.onnx   --config yolov8n.cfg   --output yolov8n.dxnn

ppu:
  enabled: true
  type: yolo
  num_classes: 80
  conf_threshold: 0.25
  iou_threshold: 0.45

scp yolov8n.dxnn alpon@<device-ip>:/opt/models/

import cv2
import numpy as np
from dx_engine import InferenceEngine

# 1) Load the compiled model onto the DX-M1 NPU
engine = InferenceEngine("/models/yolov8n.dxnn")

# 2) Prepare an input frame (BGR, 640x640 for YOLOv8n)
frame = cv2.imread("/models/sample.jpg")
input_tensor = cv2.resize(frame, (640, 640))

# 3) Run inference on the NPU
outputs = engine.run([input_tensor])

# 4) outputs is a list of numpy arrays; shape depends on the model
print("Output tensors:", [o.shape for o in outputs])

FROM debian:trixie-slim

RUN apt-get update && apt-get install -y       wget gnupg ca-certificates python3-opencv  && wget -qO - https://sixfab.github.io/sixfab_dx/public.gpg       | gpg --dearmor -o /usr/share/keyrings/sixfab-dx.gpg  && echo "deb [signed-by=/usr/share/keyrings/sixfab-dx.gpg] https://sixfab.github.io/sixfab_dx trixie main"       > /etc/apt/sources.list.d/sixfab-dx.list  && apt-get update && apt-get install -y sixfab-dx

COPY infer.py /app/infer.py
WORKDIR /app

# Use the pre-built Sixfab venv so dx_engine is importable
CMD ["/opt/sixfab-dx/venv/bin/python", "/app/infer.py"]

docker build -t alpon-infer:latest .

docker run --rm --privileged   --device /dev/dxrt0   -v /opt/models:/models   alpon-infer:latest

# One-shot status, firmware version, PCIe link state
dxrt-cli -s

# Live monitoring; expect 80 to 90% core utilization
dxtop

Common pitfalls

06Performance & benchmarks

YOLO throughput reference

How to benchmark your own model

Use a simple loop around engine.run() and measure wall-clock time over a warm window. Skip the first ~10 iterations to avoid warm-up noise.

import time, numpy as np
from dx_engine import InferenceEngine

engine = InferenceEngine("/models/yolov8n.dxnn")
dummy  = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8)

# Warm-up
for _ in range(10):
    engine.run([dummy])

# Timed window
N = 200
t0 = time.perf_counter()
for _ in range(N):
    engine.run([dummy])
dt = time.perf_counter() - t0
print(f"FPS: {N/dt:.1f} (n={N})")

Variables that move the numbers

• Model variant. Nano tier is the fastest; small, medium, and large variants drop FPS roughly proportional to compute.
• Input resolution. Doubling resolution roughly quarters FPS on detection models.
• PPU compilation. On or off is usually the largest single factor for YOLO.
• Quantization mode. Q-Lite runs slightly faster than Q-Pro; choose Q-Pro only if you measure an accuracy regression.
• Async inference. Use the runtime's async API to overlap NPU compute with CPU pre- and post-processing. Submit the next frame while the previous one is still on the NPU.
• Concurrent models. Running a detector and a classifier simultaneously shares NPU time; each runs slower than in isolation.
• Pre- and post-processing path. OpenCV decode plus color conversion on the CPU can bottleneck high-resolution pipelines. Consider GStreamer with hardware decode for sustained Full HD.

Hard limits

07Examples & references

Working code is the fastest way to evaluate the ALPON X5 AI for a new use case. The Sixfab DX examples repository contains 54 ready-to-run demos (28 Python, 26 C++) covering object detection across all supported YOLO variants, instance and semantic segmentation, pose estimation, OCR, face detection, PPU-accelerated and async pipelines, and analytics applications such as zone intrusion, people tracking, traffic counting, and queue analysis.

Quick demo run

After sixfab-dx is installed, clone the examples repository and run the auto-installer to fetch models and build the C++ demos.

git clone https://github.com/sixfab/sixfab-dx-examples
cd sixfab-dx-examples
./auto-install.sh

# Activate the bundled venv before running Python demos
source /opt/sixfab-dx/venv/bin/activate

# Launch the interactive Python demo menu
bash python_examples/start.sh

# Or the C++ menu
bash cpp_examples/start.sh

External references