Meet YOLO26: next-gen vision AI.

Exportación a Hailo para modelos YOLO de Ultralytics

No es un formato de exportación directo de Ultralytics

El formato Hailo HEF no es compatible oficialmente como destino directo de model.export(format="hailo") en Ultralytics. El flujo de trabajo que se muestra a continuación exporta primero a ONNX y, a continuación, utiliza la cadena de herramientas Dataflow Compiler externa de Hailo para generar un archivo .hef. Para obtener un mejor rendimiento por vatio que con las implementaciones HEF de Hailo más antiguas, utiliza formatos de exportación directos de Ultralytics más recientes, como Axelera AI o DeepX.

La cadena de herramientas de Hailo utiliza archivos HEF para plataformas integradas, incluyendo el Raspberry Pi AI Kit y AI HAT+, cámaras industriales, puertas de enlace perimetrales y PC con IA.

Esta guía explica cómo exportar modelos de detección Ultralytics YOLO al formato HEF (Hailo Executable Format) de Hailo utilizando el SDK Hailo Dataflow Compiler (DFC). El flujo de trabajo parte de un modelo YOLO .pt, se exporta a ONNX, se compila con las herramientas de Hailo y produce un archivo .hef listo para los aceleradores Hailo-8, Hailo-8L y Hailo-15.

Cuándo utilizar Hailo HEF

HEF es el artefacto compilado que consume HailoRT en los dispositivos de destino Hailo. Utiliza esta guía solo cuando tu hardware de implementación requiera específicamente Hailo HEF. Si aún estás eligiendo hardware perimetral o destinos de exportación, comienza con formatos de exportación directos de Ultralytics más nuevos, como Axelera AI o DeepX, que ofrecen un flujo de trabajo de model.export(...) compatible y mejores opciones de rendimiento por vatio que las implementaciones anteriores de Hailo.

HEF es similar en su función de despliegue a formatos específicos de hardware como RKNN para NPU de Rockchip, IMX500 para cámaras de IA de Raspberry Pi y Qualcomm QNN para NPU de Snapdragon, pero actualmente no es generado directamente por Ultralytics.

Este flujo de trabajo es relevante cuando necesitas:

  • Compatibilidad con Raspberry Pi AI Kit: Hailo-8L se utiliza en el Raspberry Pi AI Kit oficial y en AI HAT+.
  • Postprocesamiento con HailoRT: HailoRT puede incluir la supresión de no máximos de YOLO en la canalización de inferencia compilada.
  • Compilación INT8: El DFC de Hailo cuantiza el modelo con imágenes de calibración representativas para producir un grafo INT8 para el hardware de Hailo. Aprende más sobre la cuantización de modelos.

Formato de exportación Hailo HEF

HEF es un ejecutable específico del hardware generado por el Hailo Dataflow Compiler. Contiene el grafo del modelo cuantizado, la asignación de memoria, la programación y el postprocesamiento opcional configurado para una arquitectura Hailo específica. A diferencia de los formatos estándar del modo Exportación de YOLO que se producen directamente mediante model.export(format=...), la compilación HEF utiliza actualmente un flujo de dos etapas:

  1. Exportar YOLO a ONNX con Ultralytics.
  2. Utilizar las herramientas DFC de Hailo para analizar, optimizar, cuantizar y compilar el modelo ONNX a HEF.

El flujo de trabajo completo se expande en la siguiente canalización:

YOLO (.pt) -> ONNX -> HAR (parse) -> HAR (optimize/quantize) -> HEF (compile)
  1. Exportar a ONNX usando el modo Exportación de Ultralytics
  2. Analizar el modelo ONNX al formato intermedio HAR de Hailo
  3. Cargar un script de modelo (.alls) con directivas de normalización y postprocesamiento
  4. Calibrar y cuantizar usando imágenes representativas
  5. Compilar a un archivo HEF desplegable

Tareas compatibles

Esta guía se centra en modelos de detección de objetos YOLO de Ultralytics, debido a que el script del modelo Hailo y la configuración NMS son específicos del cabezal de detección.

TareaCompatible
Detección de objetos✅ Sí
Segmentación de instancias❌ No
Segmentación semántica❌ No
Estimación de pose❌ No
Detección OBB❌ No
Clasificación❌ No

Para despliegues de segmentación de instancias, segmentación semántica, pose, OBB y clasificación, compara otros formatos perimetrales en la tabla del modo Exportación o utiliza una canalización ONNX genérica donde tu tiempo de ejecución de destino admita la tarea.

Notas de compatibilidad

La compatibilidad de la exportación a Hailo depende del cabezal del modelo, el tamaño de la imagen de entrada, el número de clases, la arquitectura Hailo, el script del modelo (.alls) y la configuración de NMS. Los archivos estáticos del Hailo Model Zoo son referencias útiles, pero no son plantillas universales. Por ejemplo, un JSON de NMS creado para un modelo YOLO11n de 80 clases COCO no es correcto para un modelo personalizado de 3 clases o para un imgsz fijo diferente.

ÁmbitoSoporte esperadoNotas
Detección YOLOv8 / YOLO11, modelos base✅ BuenoCabezal de detección desacoplado compartido; .alls, nodos finales y configuración NMS aún deben coincidir con el grafo exportado y el imgsz fijo.
Detección personalizada YOLOv8 / YOLO11✅ PosibleRequiere configuración NMS por modelo generada a partir del número de clases, zancadas y disposición del cabezal de detección; el JSON estático del Model Zoo no coincidirá.
Detección YOLOv9⚠️ ValidarPatrón de cabezal de detección similar, pero la compilación y el análisis de salida deben probarse antes de tratarlo como compatible.
Detección de extremo a extremo YOLOv10 / YOLO26❌ No compatibleLas exportaciones de extremo a extremo/sin NMS no coinciden con la ruta de postprocesamiento NMS de Hailo; utiliza un cabezal de detección tradicional si pruebas manualmente.
Tamaños de imagen dinámicos o arbitrarios❌ No compatibleLa compilación de Hailo utiliza una forma de entrada fija; los ajustes .alls y NMS deben coincidir con el imgsz exportado.

Instalación

Paso 1: Instala Ultralytics

pip install ultralytics

Paso 2: Instala el SDK Hailo DFC

El Hailo DFC es necesario para el análisis, la optimización y la compilación. Descarga el archivo wheel de Python desde la Hailo Developer Zone (requiere registro gratuito) e instálalo:

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

El SDK Hailo DFC requiere una máquina Linux x86_64. La exportación y la compilación no pueden realizarse en dispositivos ARM como Raspberry Pi. Copia el archivo .hef resultante a tu dispositivo con tecnología Hailo para su despliegue con HailoRT.

Ejemplo de exportación HEF de YOLO11n

El script a continuación compila un modelo de detección YOLO11n de .pt a .hef con un tamaño de entrada fijo de 640 píxeles. Exporta a ONNX usando Ultralytics y, a continuación, compila con Hailo DFC usando COCO128 como un pequeño conjunto de datos de calibración.

Antes de ejecutar el script, descarga el archivo de configuración NMS de YOLO11n correspondiente desde el Hailo Model Zoo o crea tu propio JSON NMS de Hailo para el modelo. Reutiliza este script como un punto de partida conocido para YOLO11n; los modelos personalizados necesitan nodos finales, directivas .alls y ajustes NMS coincidentes.

Canalización completa
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")

El archivo HEF resultante, como yolo11n.hef, está listo para desplegarse en un dispositivo Hailo compatible. Si vas a compilar para Raspberry Pi AI Kit, establece HW_ARCH = "hailo8l" antes de ejecutar el paso de compilación.

Desglose paso a paso

Paso 1: Exportar a ONNX

Ultralytics exporta tu modelo entrenado al formato ONNX, que el Hailo DFC ingiere como entrada. Establece opset=11 para una amplia compatibilidad con DFC.

from ultralytics import YOLO

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

Paso 2: Analizar el modelo ONNX

La llamada translate_onnx_model convierte el grafo ONNX en la representación HAR intermedia de Hailo. La lista end_node_names le indica al DFC dónde cortar el grafo antes de NMS para que Hailo pueda adjuntar su propio postprocesamiento de hardware.

from hailo_sdk_client import ClientRunner

runner = ClientRunner(hw_arch="hailo8")
runner.translate_onnx_model(f"{MODEL}.onnx", end_node_names=END_NODES)
Búsqueda de nodos finales

El DFC imprime una sugerencia después de realizar el análisis:

[info] In order to use HailoRT post-processing capabilities, these end node names should be used: ...

Copia esos nombres de nodos si no estás seguro de cuáles usar, o si estás trabajando con una arquitectura personalizada o menos común.

Paso 3: Cargar el script del modelo

El script del modelo (.alls) configura la normalización de entrada, la activación de salida y el postprocesamiento NMS. El ajuste meta_arch=yolov8 se aplica tanto a YOLOv8 como a YOLO11, ya que comparten la misma disposición del cabezal de detección.

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)
Nota

Los nombres de las capas change_output_activation (conv54, conv65, conv80) son asignados por el DFC durante el análisis y son específicos del modelo. Si estás compilando un modelo de tamaño o arquitectura diferente, consulta la salida del DFC para obtener los nombres correctos, o utiliza un archivo .alls predefinido del Hailo Model Zoo.

El archivo NMS_CONFIG también es específico del modelo. Utiliza la configuración que coincida con tu modelo exportado, o comienza desde la configuración del Hailo Model Zoo para la variante YOLO más cercana.

engine=cpu ejecuta NMS a través de HailoRT en la CPU host. Utiliza engine=nn_core solo para combinaciones de modelo/script que Hailo documente como compatibles con el hardware de destino y la versión del SDK.

Elimina la línea nms_postprocess si prefieres ejecutar NMS completamente en el código de tu aplicación. Si haces esto, actualiza el analizador de inferencia porque el HEF generará tensores de cabezal de detección sin procesar en lugar de detecciones NMS agrupadas.

Paso 4: Construir el conjunto de datos de calibración

La cuantización INT8 requiere un conjunto representativo de imágenes. El script a continuación utiliza COCO128, que Ultralytics descarga automáticamente mediante check_det_dataset:

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"
Consejo

Utiliza al menos 64 imágenes para la calibración. Más imágenes generalmente mejoran la calidad de la cuantización. Para obtener los mejores resultados, utiliza imágenes de tu dominio de despliegue en lugar de COCO128.

Paso 5: Optimizar y cuantizar

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

Este paso aplica un ajuste fino consciente de la cuantización y análisis de ruido de capa. Se recomienda encarecidamente una GPU; sin ella, este paso puede llevar varias horas.

Paso 6: Compilar a HEF

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

Modelos y nodos finales compatibles

Para modelos de detección, end_node_names identifica las salidas del cabezal de detección ONNX que Hailo debe compilar antes de adjuntar su postprocesamiento NMS. Estos nombres varían según la arquitectura y pueden cambiar cuando el grafo exportado cambia.

YOLO11 y YOLOv8

YOLO11 y YOLOv8 comparten el mismo cabezal de detección desacoplado. El índice de capa difiere en uno entre las dos familias:

Familia de modelosCapa del cabezal de detecciónPatrón del nodo final
YOLO11 (todas)model.23/model.23/cv2.0/cv2.0.2/Conv (6 nodos)
YOLOv8 (todas)model.22/model.22/cv2.0/cv2.0.2/Conv (6 nodos)

Nodos finales de YOLO11 (todos los tamaños: 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",
]

Nodos finales de YOLOv8 (todos los tamaños: 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",
]

Otras arquitecturas

Para otras arquitecturas de detección, ejecuta primero el paso de análisis sin end_node_names, lee los nodos sugeridos en la salida del registro del DFC y, después, vuelve a ejecutarlo con esos nodos:

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

Los scripts .alls predefinidos y los archivos de configuración NMS para muchas variantes de YOLO están disponibles en el Hailo Model Zoo.

Arquitecturas de hardware compatibles

ArquitecturaDispositivoPico de computación (especificación del fabricante)Caso de uso común
hailo8Hailo-826 TOPSTarjeta aceleradora Hailo
hailo8lHailo-8L13 TOPSRaspberry Pi AI Kit
hailo15hHailo-15H20 TOPSDispositivos de destino Hailo-15

Establece HW_ARCH en el script para que coincida con tu dispositivo de destino antes de compilar.

Ejecución de inferencia en hardware Hailo

Una vez que tengas el archivo .hef, cópialo en tu dispositivo con tecnología Hailo y ejecuta la inferencia usando la API de Python HailoRT (paquete hailo_platform). A diferencia de los pasos de exportación del DFC, la inferencia se ejecuta directamente en el dispositivo perimetral (edge device).

Nota

El código de inferencia a continuación se ejecuta en el dispositivo con tecnología Hailo (por ejemplo, Raspberry Pi + AI Kit), no en la máquina x86 utilizada para la compilación.

Paso 1: Instala HailoRT en el dispositivo

En el dispositivo de destino, instala HailoRT y los bindings de Python. Para los usuarios de Raspberry Pi AI Kit y AI HAT+, la guía oficial de software de Raspberry Pi AI instala HailoRT, el controlador del dispositivo y los bindings de Python con:

sudo apt install dkms
sudo apt install hailo-all

Para dispositivos Hailo que no sean Raspberry Pi, instala el paquete HailoRT que coincida con tu dispositivo, controlador y versión del SDK desde la Hailo Developer Zone.

Los dispositivos AI HAT+ 2 usan un paquete de Raspberry Pi diferente (hailo-h10-all) y el flujo de trabajo de Hailo-10H. Sigue la guía de software de Raspberry Pi AI para esa generación de hardware.

Paso 2: Comprobación rápida de integridad

Antes de ejecutar la inferencia en Python, confirma que el dispositivo Hailo sea reconocido:

hailortcli fw-control identify

Deberías ver impresos el tipo de dispositivo, la versión del firmware y el número de serie.

Paso 3: Ejecuta la inferencia

El script a continuación ejecuta la detección de objetos en una sola imagen usando el archivo HEF compilado y la API de Python hailo_platform. Maneja el preprocesamiento, la inferencia y el dibujo de cuadros delimitadores (bounding boxes) a partir de la salida NMS de HailoRT.

Script de inferencia
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")
Consejo

El formato de salida de detección asume que el HEF se compiló con nms_postprocess en el script .alls. Si compilaste sin NMS, las salidas sin procesar son los 6 tensores de la cabecera de detección y debes ejecutar NMS en tu aplicación por separado.

Raspberry Pi AI Kit y AI HAT+

Raspberry Pi AI Kit y AI HAT+ de 13 TOPS usan Hailo-8L. Para usar cualquiera de los dispositivos:

  1. Establece HW_ARCH = "hailo8l" antes de compilar tu HEF en la máquina x86.
  2. Copia el archivo .hef a tu Raspberry Pi.
  3. Instala HailoRT siguiendo la guía oficial de software de Raspberry Pi AI.
  4. Ejecuta el script de inferencia de arriba.

Para la inferencia basada en cámara en Raspberry Pi, los ejemplos de Hailo para picamera2 proporcionan scripts listos para usar para detección en vivo con el módulo de cámara. También puedes comparar las rutas de despliegue de Raspberry Pi en la guía de Coral Edge TPU en Raspberry Pi y la guía de integración de Sony IMX500.

Inferencia de vídeo con TAPPAS

Para pipelines de vídeo de alto rendimiento, TAPPAS proporciona elementos de GStreamer que transmiten vídeo a través del chip Hailo en tiempo real:

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

Consulta la documentación de TAPPAS para obtener todas las opciones de configuración del pipeline.

Resumen

Esta guía cubrió el flujo de trabajo completo para exportar modelos de detección Ultralytics YOLO al formato Hailo HEF:

  1. Exportar a ONNX con Ultralytics (model.export(format="onnx")).
  2. Analizar el modelo ONNX con el DFC de Hailo y especificar los nodos finales de la cabecera de detección.
  3. Configurar la normalización y NMS mediante un script de modelo.
  4. Cuantizar con un conjunto de datos de calibración (COCO128 mediante Ultralytics).
  5. Compilar en un archivo .hef listo para Hailo-8, Hailo-8L o Hailo-15.

Para obtener más detalles, consulta la Hailo Developer Zone, la documentación de Hailo y el Hailo Model Zoo. Para otros objetivos de exportación de Ultralytics, consulta las guías relacionadas de ONNX, OpenVINO, TensorRT, NCNN, TFLite Edge TPU, RKNN, Sony IMX500 y Qualcomm QNN. Para comparar la velocidad y la precisión del modelo exportado en diferentes formatos, usa el modo Benchmark. Para obtener la lista completa de formatos y opciones, visita la documentación del modo Exportar y la página de la guía de integraciones.

Preguntas frecuentes

¿Qué dispositivos Hailo son compatibles?

El DFC de Hailo es compatible con Hailo-8 (hailo8), Hailo-8L (hailo8l) y Hailo-15H (hailo15h). Consulta la tabla Arquitecturas de hardware compatibles para conocer el valor HW_ARCH correspondiente.

¿Qué modelos de Ultralytics se pueden exportar?

Esta guía se centra en modelos de detección. Consulta Tareas compatibles para ver el alcance a nivel de tarea, Notas de compatibilidad para conocer los límites de compatibilidad del modelo y Modelos compatibles y nodos finales para ver ejemplos de nodos finales de YOLO11 y YOLOv8.

¿Por qué el script del modelo usa meta_arch=yolov8 para YOLO11?

YOLO11 usa la misma arquitectura de cabecera de detección desacoplada que YOLOv8. El DFC de Hailo usa meta_arch=yolov8 para la configuración de NMS para ambas familias de modelos.

¿Necesito una GPU para el paso de optimización?

Se recomienda encarecidamente una GPU para el ajuste fino consciente de la cuantización en runner.optimize(). Sin ella, el proceso sigue funcionando, pero es significativamente más lento (varias horas frente a unos 10-20 minutos con una GPU).

¿Cómo encuentro los nodos finales correctos para mi modelo?

Ejecuta runner.translate_onnx_model(...) sin especificar end_node_names, luego usa los nodos de cabecera de detección sugeridos e impresos por el DFC. Consulta Otras arquitecturas para ver el comando de ejemplo.

¿Dónde puedo obtener el SDK DFC de Hailo y los archivos de configuración NMS?

El wheel de Python del SDK DFC de Hailo está disponible en la Hailo Developer Zone, mientras que los scripts .alls predefinidos y los archivos de configuración NMS están disponibles en el Hailo Model Zoo.

Contributors
AMambitious-octopus1

Comentarios