Overview

The Model Zoo is the quickest way to get the Sixfab Edge AI Expansion Board doing real AI work on a Raspberry Pi 5. Each entry in the zoo is a single file with a .dxnn ending: a finished AI vision model that has already been optimised to run on the DEEPX NPU. You download it, point the runtime at it, and it works. There is no AI training to do, no model conversion, and no extra computer to set up.

The Model Zoo is one of two ways to get a model onto the Edge AI Expansion Board. Pick the path that matches your goal; both run on the same dxrt-runtime you installed in Quickstart, and you can switch between them later.

Quick demo

The sixfab-dx package you installed in Quickstart already includes a working object-detection demo and a sample video, so you can see your first AI result in a few seconds without plugging in a camera.

# Launch the bundled YOLOv8 object-detection demo on the NPU
run_hello_world

Expected terminal output

         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
------------------------------------------------
* Effective throughput via async inference
Overall FPS    :  16.0 FPS

Watch the NPU work while the demo is running

To see the NPU light up in real time, open a second terminal window on the same Raspberry Pi 5 (leave the demo running in the first one) and start the dxtop live monitor:

dxtop

The NPU usage number should climb to 80, 90 % while the demo is running. If it stays at 0 %, something is making the model run on the Raspberry Pi 5's CPU instead of on the NPU; head to Troubleshooting. dxtop also shows NPU temperature; the DEEPX silicon throttles at approximately 90 °C.

Run the example catalogue from GitHub

The bundled run_hello_world is the first taste; the full catalogue lives in the public sixfab/sixfab-dx-examples repository. A single auto-install.sh script lays out the Python and C++ example trees, and from there a terminal menu (start.sh) lets you pick a model and see it run.

The four-step sequence below pulls the repository, installs its example dependencies, and launches the interactive picker. It assumes you already finished Quickstart (the sixfab-dx APT package is installed and dxrt-cli -s reports the DEEPX NPU).

# 1. Clone the Sixfab examples repository
git clone https://github.com/sixfab/sixfab-dx-examples.git
cd sixfab-dx-examples

# 2. Set up the Python and C++ example trees plus their dependencies
./auto-install.sh

# 3. Choose your language
cd python_examples     # or: cd cpp_examples

# 4. Open the terminal menu and pick a model to run
./start.sh

start.sh prints a numbered menu listing every available model (YOLOv8/v9 detection, SCRFD face, YOLOv5 pose, YOLOv26S-Seg segmentation, and others). Pick a number, choose a video source when prompted, and inference begins on the NPU. Each example folder contains its own README with command-line flags if you want to bypass the menu and launch directly.

Available models

The zoo covers the four most common AI vision tasks. Each card below is a single .dxnn file you can drop in and run. The four tasks are: object detection (find and label things in an image), face detection (find faces specifically), pose estimation (find the joints of a person's body), and instance segmentation (find each object and outline its exact shape, not just a box).

The frame-rate (FPS) figures below are measured on the 25 TOPS DX-M1M variant of the Edge AI Expansion Board at default input resolution. Numbers for the 13 TOPS DX-M1ML variant will land before launch. [NEED FROM SIXFAB: per-model FPS measurements on the Edge AI Expansion Board hardware. The reference card below uses the same DX-M1 silicon as AI HAT+ but figures must be re-measured on this board's PCIe path (Gen 2 default / Gen 3 opt-in via config.txt) before publication.]

Where the video comes from

Every model in the zoo needs frames to look at. The Edge AI Expansion Board itself does not have a camera connector — frames come through the Raspberry Pi 5 on top (CSI, USB, or network). The four options below all work with the bundled demo and with your own Python or C++ code; you only need to pick one.

Performance reference

Headline performance figures for the Sixfab Model Zoo on the 25 TOPS DX-M1M variant of the Edge AI Expansion Board. Treat the FPS column as illustrative until per-model benchmarks ship for this board; see Methodology below for the test setup.

Drawing on the picture and sharing the result

The NPU returns plain numbers (the position of each box, how confident the model is, what label to use). Turning those numbers into something you can see (rectangles, labels, coloured masks) happens in your own Python or C++ code on the Raspberry Pi 5. The runtime deliberately stays out of this step so you can use any drawing library you like.

Draw bounding boxes with OpenCV

OpenCV is the most common image-handling library in Python. The snippet below loops over the boxes the model returned and draws a green rectangle plus a label on each one. Drop it into your existing inference loop right after you read the model's output.

import cv2

# `boxes` comes from the model. Each row: x1, y1, x2, y2, confidence, class_id
for box in boxes:
    x1, y1, x2, y2, conf, cls = box
    cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
    cv2.putText(
        frame,
        f"{cls} {conf:.2f}",
        (x1, y1 - 8),
        cv2.FONT_HERSHEY_SIMPLEX,
        0.5, (0, 255, 0), 1,
    )

Log inference results to NVMe

The Edge AI Expansion Board carries its own NVMe SSD slot for on-device buffering. Once the SSD is mounted (see NVMe Storage), point your inference code's log path or output path at the mount location — for example /mnt/nvme/inference-logs/. The runtime does not write to disk by itself; your application owns the storage policy.

More examples on GitHub

The bundled demo is the simplest possible starting point. When you want to go further, build multi-camera apps, integrate with GStreamer, run face detection, pose estimation, and so on, the Sixfab examples repository has small, focused projects you can clone, read, and run.

The DEEPX-AI organisation also publishes a lower-level reference application, DEEPX-AI/dx_app, which shows the C++ dxrt runtime API in isolation. Useful when you want to see exactly what the runtime exposes, without the example scaffolding.

Methodology disclosure

Frame-rate (FPS) figures used elsewhere on this page will be captured on the exact setup listed below. Treat them as a healthy first-run baseline once published; your own numbers will move with the model you choose, the input resolution, the camera you use, the PCIe generation enabled in config.txt, and how warm the Raspberry Pi 5 is.