Hailo-Export für Ultralytics YOLO-Modelle

Die Hailo-Toolchain verwendet HEF-Dateien für eingebettete Plattformen, einschließlich des Raspberry Pi AI Kit und AI HAT+, Industriekameras, Edge-Gateways und KI-PCs.

Dieser Leitfaden führt dich durch den Export von Ultralytics YOLO Erkennungsmodellen in Hailos HEF (Hailo Executable Format) unter Verwendung des Hailo Dataflow Compiler (DFC) SDK. Der Arbeitsablauf beginnt mit einem YOLO .pt-Modell, exportiert nach ONNX, kompiliert mit Hailo-Tools und erzeugt eine .hef-Datei, die für Hailo-8, Hailo-8L und Hailo-15 Beschleuniger bereit ist.

Wann man Hailo HEF verwendet

HEF ist das kompilierte Artefakt, das von HailoRT auf Hailo-Zielgeräten verwendet wird. Verwende diesen Leitfaden nur, wenn deine Bereitstellungshardware spezifisch Hailo HEF erfordert. Wenn du dich noch für Edge-Hardware oder Exportziele entscheidest, beginne mit neueren direkten Ultralytics-Exportformaten wie Axelera AI oder DeepX, die einen unterstützten model.export(...)-Arbeitsablauf und bessere Optionen für die Leistung pro Watt bieten als ältere Hailo-Bereitstellungen.

HEF ist in seiner Rolle bei der Bereitstellung vergleichbar mit hardwarespezifischen Formaten wie RKNN für Rockchip-NPUs, IMX500 für Raspberry Pi AI-Kameras und Qualcomm QNN für Snapdragon-NPUs, wird aber derzeit nicht direkt von Ultralytics generiert.

Dieser Arbeitsablauf ist relevant, wenn du Folgendes benötigst:

• Kompatibilität mit dem Raspberry Pi AI Kit: Hailo-8L wird im offiziellen Raspberry Pi AI Kit und AI HAT+ verwendet.
• HailoRT-Nachverarbeitung: HailoRT kann YOLO non-maximum suppression in die kompilierte Inferenz-Pipeline einbinden.
• INT8-Kompilierung: Der Hailo DFC quantisiert das Modell mit repräsentativen Kalibrierungsbildern, um einen INT8-Graphen für Hailo-Hardware zu erstellen. Erfahre mehr über Modellquantisierung.

Hailo HEF-Exportformat

HEF ist eine hardwarespezifische ausführbare Datei, die vom Hailo Dataflow Compiler generiert wird. Sie enthält den quantisierten Modellgraphen, Speicherzuweisung, Zeitplanung und optionale Nachverarbeitung, die für eine Ziel-Hailo-Architektur konfiguriert sind. Im Gegensatz zu standardmäßigen YOLO Export-Modus-Formaten, die direkt durch model.export(format=...) erzeugt werden, verwendet die HEF-Kompilierung derzeit einen zweistufigen Ablauf:

1. Exportiere YOLO mit Ultralytics nach ONNX.
2. Verwende Hailo DFC-Tools, um das ONNX-Modell zu parsen, zu optimieren, zu quantisieren und in HEF zu kompilieren.

Der vollständige Arbeitsablauf erweitert sich zur folgenden Pipeline:

YOLO (.pt) -> ONNX -> HAR (parse) -> HAR (optimize/quantize) -> HEF (compile)

1. Export nach ONNX unter Verwendung des Ultralytics Export-Modus
2. Parsen des ONNX-Modells in das intermediate HAR-Format von Hailo
3. Laden eines Modellskripts (.alls) mit Normalisierungs- und Nachverarbeitungsanweisungen
4. Kalibrieren und Quantisieren unter Verwendung repräsentativer Bilder
5. Kompilieren zu einer bereitstellbaren HEF-Datei

Unterstützte Aufgaben

Dieser Leitfaden konzentriert sich auf Ultralytics YOLO Objekterkennungsmodelle, da das Hailo-Modellskript und die NMS-Konfiguration spezifisch für den Erkennungskopf (Detection-Head) sind.

Für Instanzsegmentierung, semantische Segmentierung, Pose, OBB und Klassifizierungsbereitstellungen vergleiche andere Edge-Formate in der Tabelle zum Export-Modus oder verwende eine generische ONNX-Pipeline, falls deine Ziel-Laufzeitumgebung die Aufgabe unterstützt.

Kompatibilitätshinweise

Die Kompatibilität des Hailo-Exports hängt vom Modellkopf, der Eingabebildgröße, der Klassenanzahl, der Hailo-Architektur, dem Modellskript (.alls) und der NMS-Konfiguration ab. Statische Dateien aus dem Hailo Model Zoo sind nützliche Referenzen, aber keine universellen Vorlagen. Zum Beispiel ist ein NMS-JSON, das für ein COCO 80-Klassen YOLO11n-Modell erstellt wurde, nicht korrekt für ein benutzerdefiniertes 3-Klassen-Modell oder für eine andere feste imgsz.

Installation

Schritt 1: Ultralytics installieren

pip install ultralytics

Schritt 2: Hailo DFC SDK installieren

Das Hailo DFC wird zum Parsen, Optimieren und Kompilieren benötigt. Lade das Python-Wheel aus der Hailo Developer Zone herunter (kostenlose Registrierung erforderlich) und installiere es:

pip install /path/to/hailo_sdk_client-*.whl

YOLO11n HEF-Exportbeispiel

Das Skript unten kompiliert ein YOLO11n-Erkennungsmodell von .pt nach .hef mit einer festen Eingabegröße von 640 Pixeln. Es exportiert mit Ultralytics nach ONNX und kompiliert dann mit Hailo DFC unter Verwendung von COCO128 als kleinem Kalibrierungsdatensatz.

Bevor du das Skript ausführst, lade die passende YOLO11n NMS-Konfigurationsdatei aus dem Hailo Model Zoo herunter oder erstelle dein eigenes Hailo NMS-JSON für das Modell. Verwende dieses Skript als bekannter Ausgangspunkt für YOLO11n; benutzerdefinierte Modelle benötigen übereinstimmende Endknoten, .alls-Anweisungen und NMS-Einstellungen.

import random

import numpy as np
from hailo_sdk_client import ClientRunner
from PIL import Image

from ultralytics import YOLO
from ultralytics.data.utils import check_det_dataset
from ultralytics.utils import DATASETS_DIR

# Configuration
MODEL = "yolo11n"
HW_ARCH = "hailo8"  # hailo8 | hailo8l | hailo15h
IMGSZ = 640
CALIB_IMAGES = 128
NMS_CONFIG = "yolo11n_nms_config.json"  # Download or generate for your exact model.

# YOLO11 detection head end nodes. See "Supported Models and End Nodes" for YOLOv8 and other families.
END_NODES = [
    "/model.23/cv2.0/cv2.0.2/Conv",
    "/model.23/cv3.0/cv3.0.2/Conv",
    "/model.23/cv2.1/cv2.1.2/Conv",
    "/model.23/cv3.1/cv3.1.2/Conv",
    "/model.23/cv2.2/cv2.2.2/Conv",
    "/model.23/cv3.2/cv3.2.2/Conv",
]

# Step 1: Export to ONNX
model = YOLO(f"{MODEL}.pt")
model.export(format="onnx", imgsz=IMGSZ, opset=11)  # creates an ONNX file named after MODEL

# Step 2: Parse ONNX with Hailo DFC
# The DFC prints the detected end nodes after parsing; use them if unsure.
runner = ClientRunner(hw_arch=HW_ARCH)
runner.translate_onnx_model(f"{MODEL}.onnx", end_node_names=END_NODES)

# Step 3: Load model script (normalization + HailoRT NMS)
# The conv layer names are generated by DFC and can change for other model sizes/families.
alls = (
    "normalization1 = normalization([0.0, 0.0, 0.0], [255.0, 255.0, 255.0])\n"
    "change_output_activation(conv54, sigmoid)\n"
    "change_output_activation(conv65, sigmoid)\n"
    "change_output_activation(conv80, sigmoid)\n"
    f'nms_postprocess("{NMS_CONFIG}", meta_arch=yolov8, engine=cpu)\n'
    "allocator_param(width_splitter_defuse=disabled)"
)
runner.load_model_script(alls)

# Step 4: Build calibration dataset (auto-downloads COCO128)
check_det_dataset("coco128.yaml")
calib_dir = DATASETS_DIR / "coco128" / "images" / "train2017"
image_files = list(calib_dir.glob("*.jpg")) + list(calib_dir.glob("*.png"))
if not image_files:
    raise FileNotFoundError(f"No calibration images found in {calib_dir}")

calibset = np.zeros((CALIB_IMAGES, IMGSZ, IMGSZ, 3), dtype=np.float32)
for i in range(CALIB_IMAGES):
    img = Image.open(random.choice(image_files)).convert("RGB").resize((IMGSZ, IMGSZ))
    calibset[i] = np.array(img, dtype=np.float32)

# Step 5: Optimize and quantize
runner.optimize(calibset)
runner.save_har(f"{MODEL}.o.har")  # optional intermediate HAR

# Step 6: Compile to HEF
hef = runner.compile()
with open(f"{MODEL}.hef", "wb") as f:
    f.write(hef)

print(f"Compiled HEF saved to: {MODEL}.hef")

Die resultierende HEF-Datei, wie z.B. yolo11n.hef, ist bereit für die Bereitstellung auf einem kompatiblen Hailo-Gerät. Wenn du für das Raspberry Pi AI Kit kompilierst, setze HW_ARCH = "hailo8l", bevor du den Kompilierungsschritt ausführst.

Schritt-für-Schritt-Aufschlüsselung

Schritt 1: Export nach ONNX

Ultralytics exportiert dein trainiertes Modell in das ONNX-Format, das der Hailo DFC als Eingabe aufnimmt. Setze opset=11 für breite DFC-Kompatibilität.

from ultralytics import YOLO

MODEL = "yolo11n"
model = YOLO(f"{MODEL}.pt")
model.export(format="onnx", imgsz=640, opset=11)

Schritt 2: Das ONNX-Modell parsen

Der translate_onnx_model-Aufruf konvertiert den ONNX-Graphen in die intermediate HAR-Repräsentation von Hailo. Die Liste end_node_names teilt dem DFC mit, wo der Graph vor dem NMS geschnitten werden soll, damit Hailo seine eigene Hardware-Nachverarbeitung anhängen kann.

from hailo_sdk_client import ClientRunner

runner = ClientRunner(hw_arch="hailo8")
runner.translate_onnx_model(f"{MODEL}.onnx", end_node_names=END_NODES)

Schritt 3: Das Modellskript laden

Das Modellskript (.alls) konfiguriert die Eingabenormalisierung, Ausgabeaktivierung und NMS-Nachverarbeitung. Die Einstellung meta_arch=yolov8 gilt sowohl für YOLOv8 als auch für YOLO11, da sie dasselbe Erkennungskopf-Layout teilen.

MODEL = "yolo11n"
NMS_CONFIG = "yolo11n_nms_config.json"
alls = (
    "normalization1 = normalization([0.0, 0.0, 0.0], [255.0, 255.0, 255.0])\n"
    "change_output_activation(conv54, sigmoid)\n"
    "change_output_activation(conv65, sigmoid)\n"
    "change_output_activation(conv80, sigmoid)\n"
    f'nms_postprocess("{NMS_CONFIG}", meta_arch=yolov8, engine=cpu)\n'
    "allocator_param(width_splitter_defuse=disabled)"
)
runner.load_model_script(alls)

Schritt 4: Den Kalibrierungsdatensatz erstellen

Die INT8-Quantisierung erfordert einen repräsentativen Satz von Bildern. Das Skript unten verwendet COCO128, das Ultralytics automatisch über check_det_dataset herunterlädt:

from ultralytics.data.utils import check_det_dataset
from ultralytics.utils import DATASETS_DIR

check_det_dataset("coco128.yaml")  # downloads to DATASETS_DIR if not present
calib_dir = DATASETS_DIR / "coco128" / "images" / "train2017"

Schritt 5: Optimieren und Quantisieren

runner.optimize(calibset)
runner.save_har(f"{MODEL}.o.har")  # optional intermediate checkpoint

Dieser Schritt wendet eine quantisierungsbewusste Feinabstimmung und Schicht-Rauschanalyse an. Eine GPU wird dringend empfohlen; ohne eine solche kann dieser Schritt mehrere Stunden dauern.

Schritt 6: Kompilieren zu HEF

hef = runner.compile()
with open(f"{MODEL}.hef", "wb") as f:
    f.write(hef)

Unterstützte Modelle und Endknoten

Für Erkennungsmodelle identifiziert end_node_names die ONNX-Erkennungskopf-Ausgaben, die Hailo kompilieren soll, bevor es seine NMS-Nachverarbeitung anhängt. Diese Namen variieren je nach Architektur und können sich ändern, wenn sich der exportierte Graph ändert.

YOLO11 und YOLOv8

YOLO11 und YOLOv8 teilen sich denselben entkoppelten Erkennungskopf. Der Schichtindex unterscheidet sich um eins zwischen den beiden Familien:

YOLO11 Endknoten (alle Größen: n, s, m, l, x):

END_NODES = [
    "/model.23/cv2.0/cv2.0.2/Conv",
    "/model.23/cv3.0/cv3.0.2/Conv",
    "/model.23/cv2.1/cv2.1.2/Conv",
    "/model.23/cv3.1/cv3.1.2/Conv",
    "/model.23/cv2.2/cv2.2.2/Conv",
    "/model.23/cv3.2/cv3.2.2/Conv",
]

YOLOv8 Endknoten (alle Größen: n, s, m, l, x):

END_NODES = [
    "/model.22/cv2.0/cv2.0.2/Conv",
    "/model.22/cv3.0/cv3.0.2/Conv",
    "/model.22/cv2.1/cv2.1.2/Conv",
    "/model.22/cv3.1/cv3.1.2/Conv",
    "/model.22/cv2.2/cv2.2.2/Conv",
    "/model.22/cv3.2/cv3.2.2/Conv",
]

Andere Architekturen

Für andere Erkennungsarchitekturen führe den Parse-Schritt zuerst ohne end_node_names aus, lies die vorgeschlagenen Nodes aus dem DFC-Log-Output und führe ihn dann erneut mit diesen Nodes aus:

# First pass: let the DFC suggest end nodes
runner = ClientRunner(hw_arch=HW_ARCH)
runner.translate_onnx_model(f"{MODEL}.onnx")
# Check the printed log for: "[info] In order to use HailoRT post-processing..."

Vordefinierte .alls-Skripte und NMS-Konfigurationsdateien für viele YOLO-Varianten sind im Hailo Model Zoo verfügbar.

Unterstützte Hardwarearchitekturen

Setze HW_ARCH im Skript passend zu deinem Zielgerät, bevor du kompilierst.

Inferenz auf Hailo-Hardware ausführen

Sobald du die .hef-Datei hast, kopiere sie auf dein Hailo-betriebenes Gerät und führe die Inferenz mit der HailoRT Python API (hailo_platform Paket) aus. Im Gegensatz zu den DFC-Export-Schritten läuft die Inferenz direkt auf dem Edge-Gerät.

Schritt 1: Installiere HailoRT auf dem Gerät

Installiere auf dem Zielgerät HailoRT und die Python-Bindings. Für Benutzer des Raspberry Pi AI Kit und AI HAT+ installiert der offizielle Raspberry Pi AI Software-Leitfaden HailoRT, den Gerätetreiber und die Python-Bindings mit:

sudo apt install dkms
sudo apt install hailo-all

Für Hailo-Geräte, die keine Raspberry Pi sind, installiere das HailoRT-Paket, das zu deinem Gerät, Treiber und deiner SDK-Version passt, aus der Hailo Developer Zone.

AI HAT+ 2-Geräte verwenden ein anderes Raspberry Pi-Paket (hailo-h10-all) und den Hailo-10H-Workflow. Folge dem Raspberry Pi AI Software-Leitfaden für diese Hardware-Generation.

Schritt 2: Schneller Plausibilitätscheck

Bevor du die Python-Inferenz ausführst, vergewissere dich, dass das Hailo-Gerät erkannt wird:

hailortcli fw-control identify

Du solltest den Gerätetyp, die Firmware-Version und die Seriennummer ausgegeben sehen.

Schritt 3: Inferenz ausführen

Das unten stehende Skript führt die Objekterkennung auf einem einzelnen Bild unter Verwendung der kompilierten HEF-Datei und der hailo_platform Python API aus. Es übernimmt das Preprocessing, die Inferenz und das Zeichnen der Bounding Boxes aus dem HailoRT NMS-Output.

import numpy as np
from hailo_platform import (
    HEF,
    ConfigureParams,
    FormatType,
    HailoStreamInterface,
    InferVStreams,
    InputVStreamParams,
    OutputVStreamParams,
    VDevice,
)
from PIL import Image, ImageDraw

# Configuration
MODEL = "yolo11n"
HEF_PATH = f"{MODEL}.hef"  # path to your compiled HEF file
SOURCE = "bus.jpg"  # image path
IMGSZ = 640
CONF = 0.25

COCO_NAMES = [
    "person",
    "bicycle",
    "car",
    "motorcycle",
    "airplane",
    "bus",
    "train",
    "truck",
    "boat",
    "traffic light",
    "fire hydrant",
    "stop sign",
    "parking meter",
    "bench",
    "bird",
    "cat",
    "dog",
    "horse",
    "sheep",
    "cow",
    "elephant",
    "bear",
    "zebra",
    "giraffe",
    "backpack",
    "umbrella",
    "handbag",
    "tie",
    "suitcase",
    "frisbee",
    "skis",
    "snowboard",
    "sports ball",
    "kite",
    "baseball bat",
    "baseball glove",
    "skateboard",
    "surfboard",
    "tennis racket",
    "bottle",
    "wine glass",
    "cup",
    "fork",
    "knife",
    "spoon",
    "bowl",
    "banana",
    "apple",
    "sandwich",
    "orange",
    "broccoli",
    "carrot",
    "hot dog",
    "pizza",
    "donut",
    "cake",
    "chair",
    "couch",
    "potted plant",
    "bed",
    "dining table",
    "toilet",
    "tv",
    "laptop",
    "mouse",
    "remote",
    "keyboard",
    "cell phone",
    "microwave",
    "oven",
    "toaster",
    "sink",
    "refrigerator",
    "book",
    "clock",
    "vase",
    "scissors",
    "teddy bear",
    "hair drier",
    "toothbrush",
]

# Load HEF and connect to device
hef = HEF(HEF_PATH)
params = VDevice.create_params()
target = VDevice(params)

configure_params = ConfigureParams.create_from_hef(hef, interface=HailoStreamInterface.PCIe)
network_groups = target.configure(hef, configure_params)
network_group = network_groups[0]
network_group_params = network_group.create_params()

# Setup I/O virtual streams
input_vstreams_params = InputVStreamParams.make(network_group, quantized=False, format_type=FormatType.FLOAT32)
output_vstreams_params = OutputVStreamParams.make(network_group, quantized=False, format_type=FormatType.FLOAT32)

# Preprocess
orig = Image.open(SOURCE).convert("RGB")
ow, oh = orig.size
resized = orig.resize((IMGSZ, IMGSZ))
input_data = np.expand_dims(np.array(resized, dtype=np.float32), axis=0)  # (1,640,640,3)
input_name = hef.get_input_vstream_infos()[0].name

# Inference
with InferVStreams(network_group, input_vstreams_params, output_vstreams_params) as pipeline:
    with network_group.activate(network_group_params):
        pipeline.send({input_name: input_data})
        raw = pipeline.recv()

# Parse HailoRT NMS output and draw results
# When compiled with nms_postprocess the HEF outputs detections grouped by
# class: shape (batch, num_classes, max_dets, 5) where 5 = [y1,x1,y2,x2,score]
draw = ImageDraw.Draw(orig)
output_key = next(iter(raw.keys()))
batch_dets = raw[output_key][0]  # shape: (num_classes, max_dets, 5)

for cls_idx, cls_dets in enumerate(batch_dets):
    for det in cls_dets:
        score = float(det[4])
        if score < CONF:
            continue
        y1, x1, y2, x2 = det[:4]
        # Scale from model coords (0-640) back to original image size
        x1 = int(x1 * ow / IMGSZ)
        y1 = int(y1 * oh / IMGSZ)
        x2 = int(x2 * ow / IMGSZ)
        y2 = int(y2 * oh / IMGSZ)
        label = f"{COCO_NAMES[cls_idx]} {score:.2f}"
        draw.rectangle([x1, y1, x2, y2], outline="red", width=2)
        draw.text((x1 + 2, y1 + 2), label, fill="red")

orig.save("output.jpg")
print("Saved output.jpg")

Raspberry Pi AI Kit und AI HAT+

Das Raspberry Pi AI Kit und das 13 TOPS AI HAT+ verwenden Hailo-8L. Um eines der Geräte zu verwenden:

1. Setze HW_ARCH = "hailo8l", bevor du deine HEF auf dem x86-Rechner kompilierst.
2. Kopiere die .hef auf deinen Raspberry Pi.
3. Installiere HailoRT gemäß dem offiziellen Raspberry Pi AI Software-Leitfaden.
4. Führe das oben stehende Inferenz-Skript aus.

Für kamerabasierte Inferenz auf dem Raspberry Pi bieten die picamera2 Hailo-Beispiele gebrauchsfertige Skripte für die Live-Erkennung mit dem Camera Module. Du kannst auch die Raspberry Pi-Bereitstellungspfade im Coral Edge TPU auf Raspberry Pi-Leitfaden und im Sony IMX500 Integrationsleitfaden vergleichen.

Video-Inferenz mit TAPPAS

Für Video-Pipelines mit hohem Durchsatz bietet TAPPAS GStreamer-Elemente, die Videos in Echtzeit über den Hailo-Chip streamen:

MODEL=yolo11n
gst-launch-1.0 filesrc location=video.mp4 ! decodebin ! \
  hailonet hef-path=${MODEL}.hef ! \
  hailofilter function-name=yolov8 ! \
  hailooverlay ! autovideosink

Siehe die TAPPAS-Dokumentation für vollständige Optionen zur Pipeline-Konfiguration.

Zusammenfassung

Dieser Leitfaden behandelte den vollständigen Workflow zum Exportieren von Ultralytics YOLO-Erkennungsmodellen in das Hailo HEF-Format:

1. Export in ONNX mit Ultralytics (model.export(format="onnx")).
2. Parse das ONNX-Modell mit dem Hailo DFC und gib die End-Nodes der Detektions-Heads an.
3. Konfiguriere Normalisierung und NMS über ein Modellskript.
4. Quantisiere mit einem Kalibrierungsdatensatz (COCO128 via Ultralytics).
5. Kompiliere in eine .hef-Datei, bereit für Hailo-8, Hailo-8L oder Hailo-15.

Weitere Details findest du in der Hailo Developer Zone, in der Hailo-Dokumentation und im Hailo Model Zoo. Für andere Ultralytics-Exportziele siehe die zugehörigen Leitfäden zu ONNX, OpenVINO, TensorRT, NCNN, TFLite Edge TPU, RKNN, Sony IMX500 und Qualcomm QNN. Um die Geschwindigkeit und Genauigkeit exportierter Modelle über Formate hinweg zu vergleichen, verwende den Benchmark-Modus. Für die vollständige Liste der Formate und Optionen besuche die Dokumentation zum Export-Modus und die Integrations-Leitfadenseite.

FAQ

Welche Hailo-Geräte werden unterstützt?

Der Hailo DFC unterstützt Hailo-8 (hailo8), Hailo-8L (hailo8l) und Hailo-15H (hailo15h). Siehe die Tabelle Unterstützte Hardwarearchitekturen für den passenden HW_ARCH-Wert.

Welche Ultralytics-Modelle können exportiert werden?

Dieser Leitfaden konzentriert sich auf Erkennungsmodelle. Siehe Unterstützte Aufgaben für den aufgabenbezogenen Umfang, Kompatibilitätshinweise für Einschränkungen der Modellkompatibilität und Unterstützte Modelle und End-Nodes für Beispiele zu End-Nodes für YOLO11 und YOLOv8.

Warum verwendet das Modellskript meta_arch=yolov8 für YOLO11?

YOLO11 verwendet dieselbe Architektur für den entkoppelten Detektions-Head wie YOLOv8. Der Hailo DFC verwendet meta_arch=yolov8 für die NMS-Konfiguration für beide Modellfamilien.

Benötige ich eine GPU für den Optimierungsschritt?

Eine GPU wird für das quantisierungsbewusste Fine-Tuning in runner.optimize() dringend empfohlen. Ohne GPU funktioniert der Prozess zwar auch, ist aber deutlich langsamer (mehrere Stunden gegenüber etwa 10-20 Minuten mit einer GPU).

Wie finde ich die korrekten End-Nodes für mein Modell?

Führe runner.translate_onnx_model(...) ohne die Angabe von end_node_names aus und verwende dann die vom DFC vorgeschlagenen Detektions-Head-Nodes. Siehe Andere Architekturen für den Beispielbefehl.

Wo bekomme ich das Hailo DFC SDK und die NMS-Konfigurationsdateien?

Das Python-Wheel des Hailo DFC SDK ist in der Hailo Developer Zone verfügbar, während vordefinierte .alls-Skripte und NMS-Konfigurationsdateien im Hailo Model Zoo zu finden sind.