Link to this sectionUltralytics YOLO Modelleri için Hailo Dışa Aktarımı#

Hailo araç zinciri; Raspberry Pi AI Kit ve AI HAT+, endüstriyel kameralar, uç geçitler ve AI PC'ler dahil olmak üzere gömülü platformlar için HEF dosyalarını kullanır.

Bu rehber, seçili Ultralytics YOLO modellerinin Hailo Dataflow Compiler (DFC) SDK'sı kullanılarak Hailo'nun HEF (Hailo Executable Format) formatına nasıl aktarılacağını açıklar. İş akışı, bir YOLO .pt modelinden başlar, ONNX formatına aktarılır, Hailo araçlarıyla derlenir ve desteklenen Hailo hızlandırıcıları için hazır bir .hef dosyası üretir.

Link to this sectionHailo HEF Ne Zaman Kullanılır#

HEF, Hailo hedef cihazlarındaki HailoRT tarafından tüketilen derlenmiş bir yapıdır. Bu manuel rehberi yalnızca, doğrudan Ultralytics Hailo dışa aktarma desteği mevcut olmadan önce dağıtım donanımınız özel olarak Hailo HEF gerektirdiğinde kullanın.

HEF, dağıtım rolü açısından Rockchip NPU'lar için RKNN, Raspberry Pi AI Kameralar için IMX500 ve Snapdragon NPU'lar için Qualcomm QNN gibi donanıma özel formatlara benzer, ancak şu anda Ultralytics tarafından doğrudan oluşturulmamaktadır.

Bu iş akışı şu durumlarda geçerlidir:

• Raspberry Pi AI Kit uyumluluğu: Hailo-8L, resmi Raspberry Pi AI Kit ve AI HAT+'ta kullanılır.
• HailoRT son işleme: HailoRT, derlenmiş çıkarım hattına YOLO non-maximum suppression dahil edebilir.
• INT8 derleme: Hailo DFC, Hailo donanımı için bir INT8 grafiği oluşturmak üzere modeli temsilci kalibrasyon görüntüleri ile niceler. model quantization hakkında daha fazla bilgi edin.

Link to this sectionHailo HEF Dışa Aktarma Formatı#

HEF is a hardware-specific executable generated by the Hailo Dataflow Compiler. It contains the quantized model graph, memory allocation, scheduling, and optional post-processing configured for a target Hailo architecture. Unlike standard YOLO Export mode formats that are produced directly by model.export(format=...), HEF compilation currently uses a two-stage flow:

1. Ultralytics ile YOLO'yu ONNX formatına aktar.
2. ONNX modelini ayrıştırmak, optimize etmek, nicelemek ve HEF formatına derlemek için Hailo DFC araçlarını kullan.

Tam iş akışı aşağıdaki hattı kapsar:

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

1. Ultralytics Export mode kullanarak ONNX'e Aktar
2. ONNX modelini Hailo'nun ara HAR formatına Ayrıştır
3. Normalizasyon ve son işleme yönergelerini içeren bir model betiği (.alls) yükle
4. Temsilci görüntüleri kullanarak Kalibre et ve nicele
5. Dağıtılabilir bir HEF dosyasına Derle

Link to this sectionDesteklenen Görevler#

Mevcut manuel örnek YOLO11 nesne algılamaya odaklanmaktadır çünkü Hailo model betiği ve son işleme yapılandırması, algılama başlığına (detection-head) özeldir. Gelecekteki doğrudan model.export(format="hailo") uygulaması, Hailo dışa aktarımını diğer tüm Ultralytics dışa aktarma formatları gibi hissettirmeli ve görev desteği, harici iş akışı adımları yerine model başlığı ve Hailo derleyici uyumluluğu ile sınırlandırılmalıdır.

Ultralytics'te doğrudan Hailo dışa aktarımı uygulanana kadar, sadece aşağıdaki manuel ONNX-to-HEF iş akışı belgelenmiştir.

Link to this sectionHailo SDK Sürümleri#

Doğrudan Hailo dışa aktarımı, Hailo'nun donanım ve SDK nesil ayrımını hesaba katmalıdır:

• Hailo-8 ve Hailo-8L: Hailo Dataflow Compiler v3.x kullanın. Bu, Raspberry Pi AI Kit ve 13 TOPS AI HAT+ dağıtımları için ilgili yoldur.
• Hailo-10 ve Hailo-15: Hailo Dataflow Compiler v5.x kullanın.

Bu sürüm ayrımı; derleyici API'lerini, desteklenen mimarileri, oluşturulan HEF uyumluluğunu ve doğrudan bir dışa aktarıcının sunması gereken hw_arch değerlerini etkiler. Bir Hailo donanım neslindeki görev desteği, hedef DFC sürümü ve hw_arch doğrulanmadan diğerinde de destek olarak kabul edilmemelidir.

Link to this sectionUyumluluk Notları#

Hailo dışa aktarma uyumluluğu; model başlığına, giriş görsel boyutuna, sınıf sayısına, Hailo mimarisine, oluşturulan model betiğine (.alls) ve son işleme yapılandırmasına bağlıdır. Statik yapılandırmalar evrensel şablonlar değildir. Örneğin, bir COCO 80 sınıflı YOLO11n modeli için oluşturulan NMS JSON'ı, özel bir 3 sınıflı model veya farklı bir sabit imgsz için doğru değildir.

Link to this sectionKurulum#

Link to this sectionAdım 1: Ultralytics'i Kur#

pip install ultralytics

Link to this sectionAdım 2: Hailo DFC SDK'yı Kur#

Hailo DFC ayrıştırma, optimizasyon ve derleme için gereklidir. Python tekerleğini Hailo Developer Zone (ücretsiz kayıt gereklidir) üzerinden indir ve kur:

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

Link to this sectionYOLO11n HEF Dışa Aktarma Örneği#

Aşağıdaki betik, bir YOLO11n algılama modelini .pt dosyasından sabit 640 piksellik giriş boyutunda .hef dosyasına derler. Ultralytics kullanarak ONNX formatına aktarır, ardından küçük bir kalibrasyon veri seti olarak COCO128 kullanarak Hailo DFC ile derler.

Betiği çalıştırmadan önce, tam YOLO11n dışa aktarma grafiği, sınıf sayısı, adımlar ve sabit giriş boyutuyla eşleşen bir Hailo NMS JSON sağlayın. Bu betiği bilinen bir YOLO11n başlangıç noktası olarak yeniden kullanın; özel modeller eşleşen uç düğümler, .alls yönergeleri ve NMS ayarları gerektirir.

import ast
import random
from pathlib import Path

import numpy as np
import onnx
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, YAML

# 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.
OUT_DIR = Path(f"{MODEL}_hailo_model")  # deploy folder (mirrors Ultralytics <model>_<format>_model exports)
OUT_DIR.mkdir(exist_ok=True)

# 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, then move it into the deploy folder to keep the working directory tidy
model = YOLO(f"{MODEL}.pt")
onnx_path = Path(model.export(format="onnx", imgsz=IMGSZ, opset=11))
onnx_path = onnx_path.rename(OUT_DIR / onnx_path.name)

# Copy the metadata Ultralytics embedded in the ONNX into the standard metadata.yaml sidecar.
# The HEF stores no class names, so inference reads them from this file.
meta = {p.key: p.value for p in onnx.load(onnx_path, load_external_data=False).metadata_props}
for k in ("stride", "batch", "channels"):
    if k in meta:
        meta[k] = int(meta[k])
for k in ("imgsz", "names", "args", "end2end"):
    if k in meta:
        meta[k] = ast.literal_eval(meta[k])
YAML.save(OUT_DIR / "metadata.yaml", meta)

# 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(str(onnx_path), 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.
model_script = (
    "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(model_script)

# 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(str(OUT_DIR / f"{MODEL}.o.har"))  # optional intermediate HAR

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

# Note: the Hailo SDK writes *.log files (acceleras.log, allocator.log, hailo_sdk.client.log,
# hailo_sdk.core.log) to the working directory. They are diagnostic scratch, safe to ignore or delete.
print(f"Compiled HEF saved to: {hef_path}")

Dışa aktarma betiği, yapıları ve günlükleri şu şekilde düzenler:

• Deployment Folder: Artifacts are saved to yolo11n_hailo_model/, mirroring the standard <model>_<format>_model/ layout used by other Ultralytics exports.
• Gerekli Dosyalar: Dağıtım için gereken iki dosya, derlenmiş yolo11n.hef ve yan dosya olan metadata.yaml dosyalarıdır.
• Meta Veriler: metadata.yaml, ONNX meta verilerinden çıkarılan temel alanları (names, imgsz, task, stride vb.) içerir. HEF formatı sınıf isimlerini saklamadığından, çıkarım betikleri sınıf isimlerini bu dosyadan yükler.
• Ara Dosyalar: Dışa aktarma klasörü ayrıca ara yolo11n.onnx ve yolo11n.o.har kontrol noktalarını da içerir.
• Günlük Dosyaları: Hailo SDK, çalışma dizininde çeşitli tanılama günlükleri (örneğin: acceleras.log, allocator.log, hailo_sdk.client.log ve hailo_sdk.core.log) oluşturur; bunları güvenle göz ardı edebilir veya silebilirsin.
• Raspberry Pi AI Kit: Bu özel donanım için, derleme adımını çalıştırmadan önce HW_ARCH = "hailo8l" olarak ayarladığından emin ol.

Link to this sectionAdım Adım İnceleme#

Yukarıdaki betiğin tamamı baştan sona çalışır. Bu bölüm, her aşamanın ne işe yaradığını ve onu kendi modeline uyarlarken dikkat etmen gereken modele özel ayrıntıları açıklar.

Link to this sectionAdım 1: ONNX formatına dışa aktar ve meta verileri kaydet#

Ultralytics, eğitilmiş modelini Hailo DFC'nin girdi olarak kabul ettiği ONNX formatına dışa aktarır. opset=11, geniş bir DFC uyumluluğu sağlar ve çalışma dizinini düzenli tutmak için ONNX dosyası bir yolo11n_hailo_model/ dağıtım klasörüne taşınır (diğer Ultralytics dışa aktarmalarının <model>_<format>_model/ düzenini yansıtır).

HEF hiçbir sınıf ismi saklamaz, bu nedenle Ultralytics'in ONNX içine gömdüğü meta veriler yan tarafındaki standart bir metadata.yaml dosyasına kopyalanır. Bu, diğer dışa aktarma formatlarının ürettiği metadata.yaml ile aynıdır (names, imgsz, task, stride ve daha fazlası) ve çıkarım işlemi sınıf isimlerini buradan okur, böylece iş akışı herhangi bir etiket kodlamaya gerek kalmadan özel modeller için çalışır.

Link to this sectionAdım 2: ONNX Modelini Ayrıştır#

runner.translate_onnx_model(...), ONNX grafiğini Hailo'nun ara HAR gösterimine dönüştürür. end_node_names listesi, Hailo'nun kendi donanım tabanlı son işleme sürecini ekleyebilmesi için grafiğin NMS'den önce nerede kesileceğini DFC'ye bildirir.

Link to this sectionAdım 3: Model Betiğini Yükle#

Model betiği (.alls), girdi normalizasyonunu, çıktı aktivasyonunu ve NMS son işlemesini yapılandırır. meta_arch=yolov8 ayarı, aynı algılama kafası düzenini paylaştıkları için hem YOLOv8 hem de YOLO11 için geçerlidir.

MODEL = "yolo11n"
NMS_CONFIG = "yolo11n_nms_config.json"
model_script = (
    "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(model_script)

Link to this sectionAdım 4: Kalibrasyon Veri Setini Oluştur#

INT8 kuantizasyonu, (N, imgsz, imgsz, 3) boyutunda float32 bir dizide istiflenmiş temsili bir görüntü kümesi gerektirir. Betik, Ultralytics'in check_det_dataset aracılığıyla otomatik olarak indirdiği COCO128'i kullanır.

Link to this sectionAdım 5: Optimize Et ve Nicele#

runner.optimize(calibset), kuantizasyon farkındalıklı ince ayar ve katman gürültüsü analizi uygular, ardından runner.save_har(...) isteğe bağlı bir ara kontrol noktası yazar. Bir GPU şiddetle önerilir; GPU olmadan bu adım birkaç saat sürebilir.

Link to this sectionAdım 6: HEF Formatına Derle#

runner.compile(), nihai HEF dosyasını üretir ve yolo11n_hailo_model/yolo11n.hef olarak yazar. Artık metadata.yaml dosyası ile yan yana durur ve çıkarım için cihaza kopyalanmaya hazırdır.

Link to this sectionDesteklenen Modeller ve Uç Düğümler#

Algılama modelleri için end_node_names, NMS son işlemesini eklemeden önce Hailo'nun derlemesi gereken ONNX algılama kafası çıktılarını tanımlar. Bu adlar mimariye göre değişir ve dışa aktarılan grafik değiştiğinde farklılık gösterebilir.

Aşağıdaki uç düğüm örnekleri, Hailo'nun YOLOv8 tarzı NMS son işlemesini kullanan YOLOv8 ve YOLO11 algılama modelleri için geçerlidir. YOLO26, NMS-free'dir ve bu YOLO11 NMS yapılandırmasını kullanmaz.

Link to this sectionYOLO11 ve YOLOv8#

YOLO11 ve YOLOv8, aynı ayrıştırılmış algılama kafasını paylaşır. Katman indeksi iki aile arasında bir basamak fark eder:

YOLO11 uç düğümleri (tüm boyutlar: 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 uç düğümleri (tüm boyutlar: 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",
]

Link to this sectionDiğer Mimariler#

Diğer algılama mimarileri için, önce end_node_names olmadan ayrıştırma adımını çalıştır, DFC günlük çıktısından önerilen düğümleri oku, ardından bu düğümlerle tekrar çalıştır:

# 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..."

Doğrudan Ultralytics desteği için, bu .alls yönergeleri ve son işleme ayarları, kullanıcıların bunları manuel olarak birleştirmesini gerektirmek yerine dışa aktarıcı tarafından oluşturulmalı veya seçilmelidir.

Link to this sectionDesteklenen Donanım Mimarileri#

Derlemeden önce hedef cihazınızla eşleşmesi için betikte HW_ARCH ayarını yapın.

Link to this sectionHailo Donanımında Çıkarım Çalıştırma#

Once compilation finishes, copy the whole yolo11n_hailo_model/ folder (the .hef plus its metadata.yaml) to your Hailo-powered device and run inference using either the HailoRT Python API (hailo_platform package) or, on Raspberry Pi, the picamera2 Hailo helper (a HailoRT wrapper). Both are shown in the tabs below. Keeping the two files together lets the scripts below read the class names from metadata.yaml next to the HEF. Unlike the DFC export steps, inference runs directly on the edge device.

Link to this sectionAdım 1: Cihaza HailoRT Kurulumu#

Hedef cihazda, HailoRT ve Python bağlayıcılarını kurun. Raspberry Pi AI Kit ve AI HAT+ kullanıcıları için resmi Raspberry Pi AI yazılım kılavuzu ile HailoRT, aygıt sürücüsü ve Python bağlayıcılarını şu şekilde kurabilirsiniz:

sudo apt install dkms
sudo apt install hailo-all
sudo reboot

Raspberry Pi dışındaki Hailo cihazları için, Hailo Geliştirici Bölgesi'nden cihazınız, sürücünüz ve SDK sürümünüzle eşleşen HailoRT paketini kurun.

AI HAT+ 2 cihazları farklı bir Raspberry Pi paketi (hailo-h10-all) ve Hailo-10H iş akışı kullanır. Bu donanım nesli için Raspberry Pi AI yazılım kılavuzunu izleyin.

Link to this sectionAdım 2: Hızlı Kontrol#

Python çıkarımını çalıştırmadan önce, Hailo cihazının tanındığını doğrulayın:

hailortcli fw-control identify

Cihaz türünün, aygıt yazılımı sürümünün ve seri numarasının yazdırıldığını görmelisiniz.

Executing on device: 0001:01:00.0
Identifying board
Control Protocol Version: 2
Firmware Version: 4.23.0 (release,app,extended context switch buffer)
Logger Version: 0
Board Name: Hailo-8
Device Architecture: HAILO8

Link to this sectionAdım 3: Çıkarımı Çalıştırın#

Aşağıdaki betikler derlenmiş HEF dosyası ile nesne tespiti gerçekleştirir. Her iki sekme de aynı --source girdilerini (bir görüntü, bir video, bir USB web kamerası indeksi veya Raspberry Pi Kamera Modülü için csi) kabul eder ve sadece çıkarım API'si açısından farklılık gösterir: Hailo SDK sekmesi düşük seviyeli hailo_platform API'sini (taşınabilir, minimum bağımlılık) kullanırken, picamera2 sekmesi Raspberry Pi picamera2 Hailo yardımcısını kullanır. Görüntüler ve videolar açıklamalı bir dosyaya yazılır; web kamerası ve CSI akışları canlı bir pencerede görüntülenir.

import argparse
from pathlib import Path

import cv2
import numpy as np
import yaml
from hailo_platform import (
    HEF,
    ConfigureParams,
    FormatType,
    HailoStreamInterface,
    InferVStreams,
    InputVStreamParams,
    OutputVStreamParams,
    VDevice,
)
from tqdm import tqdm

IMAGE_EXTS = {".jpg", ".jpeg", ".png", ".bmp", ".webp", ".tif", ".tiff"}

def parse_and_draw(per_class, frame, conf, names):
    """Draw HailoRT NMS detections (grouped by class, normalized [0, 1] coords) onto a BGR frame."""
    h, w = frame.shape[:2]
    for cls_idx, cls_dets in enumerate(per_class):
        for det in cls_dets:
            score = float(det[4])
            if score < conf:
                continue
            # HailoRT NMS returns normalized [0, 1] coords as (y1, x1, y2, x2)
            y1, x1, y2, x2 = det[:4]
            x1, y1, x2, y2 = int(x1 * w), int(y1 * h), int(x2 * w), int(y2 * h)
            label = f"{names[cls_idx]} {score:.2f}"
            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
            cv2.putText(frame, label, (x1 + 2, y1 + 15), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1, cv2.LINE_AA)

def preprocess(frame, imgsz):
    """BGR frame -> (1, imgsz, imgsz, 3) float32 in 0-255 (HEF normalizes internally)."""
    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    resized = cv2.resize(rgb, (imgsz, imgsz))
    return np.expand_dims(resized.astype(np.float32), axis=0)

def csi_frames(width=1280, height=720):
    """Yield BGR frames from the Pi CSI Camera Module via picamera2."""
    from picamera2 import Picamera2

    picam2 = Picamera2()
    # picamera2 "RGB888" is BGR-ordered in memory, so it drops straight into OpenCV
    picam2.configure(picam2.create_preview_configuration(main={"size": (width, height), "format": "RGB888"}))
    picam2.start()
    try:
        while True:
            yield picam2.capture_array("main")  # BGR
    finally:
        picam2.stop()
        picam2.close()

def cv2_frames(src):
    """Yield BGR frames from a video file or USB/V4L2 webcam via OpenCV."""
    cap = cv2.VideoCapture(src)
    if not cap.isOpened():
        raise RuntimeError(f"Could not open source {src}")
    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))  # 0 for live webcams
    pbar = tqdm(total=total, desc="Processing video", unit="frame") if total > 0 else None
    try:
        while True:
            ok, frame = cap.read()  # BGR
            if not ok:
                break
            yield frame
            if pbar is not None:
                pbar.update(1)
    finally:
        if pbar is not None:
            pbar.close()
        cap.release()

def open_source(source):
    """Yield (frame, kind) pairs where kind is 'image', 'video', or 'stream'."""
    if source == "csi":
        yield from ((f, "stream") for f in csi_frames())
    elif source.isdigit():
        yield from ((f, "stream") for f in cv2_frames(int(source)))
    elif Path(source).suffix.lower() in IMAGE_EXTS:
        frame = cv2.imread(source)
        if frame is None:
            raise FileNotFoundError(f"Could not read image {source}")
        yield frame, "image"
    else:
        yield from ((f, "video") for f in cv2_frames(source))

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Hailo YOLO inference (image, video, webcam, or CSI camera)")
    parser.add_argument("-m", "--model", default="yolo11n_hailo_model/yolo11n.hef", help="Path to the HEF model.")
    parser.add_argument("--source", default="0", help="Image/video path, webcam index (e.g. 0), or 'csi'.")
    parser.add_argument("--imgsz", type=int, default=640)
    parser.add_argument("--conf", type=float, default=0.25)
    args = parser.parse_args()

    # Load class names from metadata.yaml saved next to the HEF during compilation (keyed by class index)
    with open(Path(args.model).parent / "metadata.yaml") as f:
        names = yaml.safe_load(f)["names"]

    # Configure the device and network group ONCE
    hef = HEF(args.model)
    target = VDevice(VDevice.create_params())
    configure_params = ConfigureParams.create_from_hef(hef, interface=HailoStreamInterface.PCIe)
    network_group = target.configure(hef, configure_params)[0]
    network_group_params = network_group.create_params()
    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)
    input_name = hef.get_input_vstream_infos()[0].name

    writer = None  # lazily created for video output

    # Keep the pipeline and activation OPEN across frames (re-opening per frame is slow)
    with InferVStreams(network_group, input_vstreams_params, output_vstreams_params) as pipeline:
        with network_group.activate(network_group_params):
            try:
                for frame, kind in open_source(args.source):
                    raw = pipeline.infer({input_name: preprocess(frame, args.imgsz)})
                    parse_and_draw(raw[next(iter(raw.keys()))][0], frame, args.conf, names)

                    if kind == "image":
                        cv2.imwrite("output.jpg", frame)
                        print("Saved output.jpg")
                    elif kind == "video":
                        if writer is None:
                            h, w = frame.shape[:2]
                            writer = cv2.VideoWriter("output.mp4", cv2.VideoWriter_fourcc(*"mp4v"), 30, (w, h))
                        writer.write(frame)
                    else:  # live stream
                        cv2.imshow("Hailo YOLO", frame)
                        if cv2.waitKey(1) & 0xFF == ord("q"):
                            break
            finally:
                if writer is not None:
                    writer.release()
                    print("Saved output.mp4")
                cv2.destroyAllWindows()

Bunu herhangi bir kaynakta çalıştır (görüntüler output.jpg olarak kaydedilir, videolar output.mp4 olarak kaydedilir, canlı akışlar bir pencerede görüntülenir, çıkmak için q tuşuna bas):

python hailo_infer.py --source bus.jpg  # single image
python hailo_infer.py --source clip.mp4 # video file
python hailo_infer.py --source 0        # USB webcam, live
python hailo_infer.py --source csi      # Raspberry Pi Camera Module

Link to this sectionTAPPAS ile Video Çıkarımı#

Yüksek verimli video hatları için TAPPAS, videoyu Hailo çipi üzerinden gerçek zamanlı olarak ileten GStreamer öğeleri sağlar:

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

Tam hat yapılandırma seçenekleri için TAPPAS belgelerine bakın.

Link to this sectionÖzet#

Bu kılavuz, Ultralytics YOLO tespit modellerini Hailo HEF formatına aktarmak için gereken eksiksiz iş akışını ele aldı:

1. Ultralytics ile ONNX formatına aktarma (model.export(format="onnx")).
2. ONNX modelini Hailo DFC ile ayrıştırın ve tespit başlığı uç düğümlerini belirtin.
3. Bir model betiği aracılığıyla normalleştirme ve NMS yapılandırın.
4. Bir kalibrasyon veri seti (Ultralytics aracılığıyla COCO128) ile nicemleme (quantization) yapın.
5. Hailo-8, Hailo-8L veya Hailo-15 için hazır bir .hef dosyasına derleyin.

Daha fazla detay için Hailo Developer Zone ve Hailo belgelerine bakın. Diğer Ultralytics dışa aktarma hedefleri için ilgili ONNX, OpenVINO, TensorRT, NCNN, TFLite Edge TPU, RKNN, Sony IMX500 ve Qualcomm QNN rehberlerine bakın. Formatlar arasında aktarılan model hızını ve doğruluğunu karşılaştırmak için Benchmark mode kullanın. Formatların ve seçeneklerin tam listesi için Export mode belgelerini ve entegrasyon rehberi sayfasını ziyaret edin.

Link to this sectionSSS#

Link to this sectionHangi Hailo cihazları destekleniyor?#

The Hailo DFC supports Hailo-8 (hailo8), Hailo-8L (hailo8l), and Hailo-15H (hailo15h). See the Supported Hardware Architectures table for the matching HW_ARCH value.

Link to this sectionHangi Ultralytics modelleri dışa aktarılabilir?#

Bu kılavuz tespit modellerine odaklanmaktadır. Görev düzeyi kapsamı için Desteklenen Görevler, model uyumluluk sınırları için Uyumluluk Notları ve YOLO11 ile YOLOv8 uç düğüm örnekleri için Desteklenen Modeller ve Uç Düğümler bölümlerine bakın.

Link to this sectionModel betiği neden YOLO11 için meta_arch=yolov8 kullanıyor?#

YOLO11, YOLOv8 ile aynı ayrıştırılmış (decoupled) tespit başlığı mimarisini kullanır. Hailo DFC, her iki model ailesi için de NMS yapılandırmasında meta_arch=yolov8 kullanır.

Link to this sectionOptimizasyon adımı için GPU'ya ihtiyacım var mı?#

runner.optimize() içindeki nicemleme duyarlı ince ayar (quantization-aware fine-tuning) için bir GPU şiddetle önerilir. GPU olmadan süreç çalışır ancak önemli ölçüde daha yavaştır (GPU ile yaklaşık 10-20 dakika sürerken, GPU olmadan birkaç saat sürebilir).

Link to this sectionModelim için doğru uç düğümleri nasıl bulabilirim?#

runner.translate_onnx_model(...) komutunu end_node_names belirtmeden çalıştırın, ardından DFC tarafından yazdırılan önerilen tespit başlığı düğümlerini kullanın. Örnek komut için Diğer Mimariler bölümüne bakın.

Link to this sectionHailo DFC SDK'sını nereden edinebilirim?#

Hailo DFC SDK Python wheel dosyası Hailo Developer Zone üzerinden edinilebilir. Doğrudan bir Ultralytics Hailo dışa aktarıcısı için, model betiği ve son işleme yapılandırması dışa aktarma iş akışı içinde oluşturulmalı veya seçilmelidir.