Export the trained model to ONNX

Train the model in any major framework, then export to ONNX on the development machine. ONNX is the only input format DX-COM accepts.

Vision architectures (object detection, classification, segmentation, pose) are the supported scope on current DEEPX silicon. LLMs and audio-only transformer architectures are not supported today; LLMs are on the DEEPX roadmap and Sixfab will support them as the silicon enables.

PyTorch export

import torch

# 1. Load your trained model and switch to eval mode
model.eval()

# 2. Provide a dummy input matching the production input shape
dummy_input = torch.randn(1, 3, 640, 640)

# 3. Export to ONNX (opset 11 is widely compatible with DX-COM)
torch.onnx.export(
    model, dummy_input,
    "my_model.onnx",
    opset_version=11,
    input_names=["images"],
    output_names=["output"]
)

Ultralytics YOLO export

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="onnx")
# Produces yolo11n.onnx in the working directory.

Compile ONNX to DXNN with DX-COM

DX-COM reads the ONNX file, calibrates it for INT8 arithmetic, and produces a .dxnn binary that runs natively on the DEEPX DX-M1 family NPU. Quantisation is automatic; expect approximately 2 % accuracy loss versus the original FP32 model. This is the published, honest accuracy envelope for INT8 inference on DEEPX silicon.

Install DX-COM

# 1. Clone the DEEPX compiler repository
git clone https://github.com/DEEPX-AI/dx-compiler
cd dx-compiler
./install.sh

# 2. Install the Python wheel
cd dx_com
pip install dx_com*.whl

# 3. Verify the installation
dxcom --version    # expected: DX-COM v2.3.0

Prepare a calibration dataset

Quantisation requires calibration data: a small set of representative images the compiler uses to estimate activation ranges. Use images from your deployment domain; random stock images degrade quantised accuracy. Start with 100 images.

calibration_images/
├── frame_0001.jpg
├── frame_0002.jpg
└── ...

Write config.json and compile

DX-COM is driven by a JSON configuration file describing input shape, calibration settings, and the preprocessing pipeline. A minimal YOLOv11n configuration:

{
  "inputs":             {"images": [1, 3, 640, 640]},
  "calibration_method": "ema",
  "calibration_num":    100,
  "default_loader": {
    "dataset_path":    "./calibration_images",
    "file_extensions": ["jpeg", "jpg", "png"],
    "preprocessings": [
      {"resize":       {"width": 640, "height": 640}},
      {"convertColor": {"form": "BGR2RGB"}},
      {"div":          {"x": 255}},
      {"transpose":    {"axis": [2, 0, 1]}},
      {"expandDim":    {"axis": 0}}
    ]
  }
}

dxcom -m ./yolo11n.onnx -c config.json -o yolo11n-output

# Successful run ends with:
# [INFO] - Compilation complete.
# [INFO] - Output: yolo11n-output/yolo11n.dxnn

What the compiler does to the model

• Operator mapping. Each ONNX op is mapped to a DEEPX NPU instruction sequence. Unsupported ops either error out or fall back to CPU execution at runtime, depending on architecture.
• INT8 quantisation. Weights and activations are calibrated against your dataset and quantised. No developer configuration required beyond the calibration set.
• Memory planning. The compiler lays out tensors to fit NPU on-chip memory. Models that exceed available NPU memory fail at compile time.
• Optional PPU fusion. For YOLO architectures, the post-processing graph is fused onto the NPU when PPU is enabled.

Compiler upstream reference: github.com/DEEPX-AI/dx-compiler →

Deploy the .dxnn artifact and run inference

The compiled .dxnn file is the deployment artifact. Copy it to the target Sixfab device, then load it with the DEEPX runtime (dxrt-runtime) and run inference. The Python and C++ APIs are functionally equivalent; C++ runs slightly more efficiently on tight inference loops.

Transfer the artifact to the target device

The transfer step is the only stage where the procedure varies by product. The .dxnn file itself is identical across all three.

Run inference with the Python API

from dx_engine import InferenceEngine
import cv2, numpy as np

# 1. Load the compiled model
engine = InferenceEngine("models/my_model.dxnn")

# 2. Preprocess input (remove operations the NPU absorbed)
img = cv2.imread("frame.jpg")
img = cv2.resize(img, (640, 640))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = np.transpose(img, (2, 0, 1))
img = np.expand_dims(img, 0)

# 3. Run inference
output = engine.run(img)

Run inference with the C++ API

#include <dxrt/inference_engine.h>

dxrt::InferenceEngine engine("models/my_model.dxnn");

for (const auto& frame : frames) {
    auto output = engine.Run(frame.data());
    // process output
}

Verify the NPU is being used

On the target device, run dxrt-cli -s to confirm the NPU is loaded and the model is dispatched correctly. For the full monitoring reference (utilisation, temperature, fleet integration with Prometheus and Grafana), see AI Model Deployment · System Monitoring.