Exportación ONNX para modelos YOLO26
Inferencia ONNX en CPU ~43 % más rápida: YOLO26n frente a YOLO11n
- YOLO26n se ejecuta hasta un 43 % más rápido que YOLO11n en inferencias ONNX en CPU (Intel Xeon CPU @ 2.00 GHz). Consulta la página del modelo YOLO26 para ver la comparación completa.
A menudo, al desplegar modelos de visión artificial, necesitas un formato de modelo flexible y compatible con varias plataformas.
La exportación de modelos Ultralytics YOLO26 al formato ONNX simplifica la implementación en numerosos entornos de ejecución y plataformas de hardware. En esta guía se explica cómo convertir tus modelos YOLO26 a ONNX y ejecutarlos en aplicaciones reales.
Ver: Prueba de inferencia ONNX: Ultralytics YOLO26 frente a Ultralytics YOLO11 | YOLO26 ofrece una inferencia ~43 % más rápida 🚀
ONNX y ONNX Runtime#
ONNX, sigla de Intercambio Abierto de Redes Neuronales, es un proyecto comunitario desarrollado inicialmente por Facebook y Microsoft. En la actualidad, el desarrollo de ONNX es un esfuerzo colaborativo respaldado por distintas organizaciones, como IBM, Amazon (a través de AWS) y Google. El proyecto tiene como objetivo crear un formato de archivo abierto para representar modelos de aprendizaje automático de forma que puedan usarse en distintos frameworks de IA y hardware.
Los modelos ONNX permiten pasar de un framework a otro. Por ejemplo, puedes exportar a ONNX un modelo de aprendizaje profundo entrenado en PyTorch e importarlo después en TensorFlow.
También puedes usar modelos ONNX con ONNX Runtime. ONNX Runtime es un acelerador multiplataforma versátil para modelos de aprendizaje automático, compatible con frameworks como PyTorch, TensorFlow, scikit-learn, etc.
ONNX Runtime optimiza la ejecución de modelos ONNX mediante el uso de capacidades específicas del hardware. Esto permite que los modelos se ejecuten de forma eficiente y con un alto rendimiento en distintas plataformas de hardware, incluidas CPU, GPU y aceleradores especializados.
Tanto si se usa de forma independiente como junto con ONNX Runtime, ONNX ofrece una solución flexible para el despliegue de modelos de aprendizaje automático y la compatibilidad.
Características principales de los modelos ONNX#
La capacidad de ONNX para gestionar distintos formatos se debe a las siguientes características principales:
-
Representación común de modelos: ONNX define un conjunto común de operadores (como convoluciones, capas, etc.) y un formato de datos estándar. Al convertir un modelo al formato ONNX, su arquitectura y sus pesos se traducen a esta representación común. Esta uniformidad garantiza que cualquier framework compatible con ONNX pueda interpretar el modelo.
-
Control de versiones y compatibilidad con versiones anteriores: ONNX mantiene un sistema de versiones para sus operadores. Así, aunque el estándar evolucione, los modelos creados con versiones anteriores siguen siendo utilizables. La compatibilidad con versiones anteriores es fundamental para evitar que los modelos queden obsoletos rápidamente.
-
Representación de modelos basada en grafos: ONNX representa los modelos como grafos computacionales. Esta estructura basada en grafos es una forma universal de representar modelos de aprendizaje automático: los nodos representan operaciones o cálculos y las aristas representan los tensores que fluyen entre ellos. Este formato se adapta fácilmente a distintos frameworks que también representan los modelos como grafos.
-
Herramientas y ecosistema: ONNX cuenta con un amplio ecosistema de herramientas para convertir, visualizar y optimizar modelos. Estas herramientas facilitan el trabajo de los desarrolladores con modelos ONNX y su conversión entre distintos frameworks.
Usos habituales de ONNX#
Los modelos ONNX se utilizan habitualmente en los siguientes casos:
Despliegue en CPU#
Los modelos ONNX suelen desplegarse en CPU por su compatibilidad con ONNX Runtime, un entorno de ejecución optimizado para CPU. Mejora considerablemente la velocidad de inferencia y hace viables los despliegues en tiempo real en CPU.
Opciones de despliegue compatibles#
Aunque los modelos ONNX se utilizan habitualmente en CPU, también pueden desplegarse en las siguientes plataformas:
-
Aceleración por GPU: ONNX admite plenamente la aceleración por GPU en GPU NVIDIA mediante CUDA y en GPU AMD mediante ROCm y MIGraphX.
-
Dispositivos móviles y de borde: ONNX también se utiliza en dispositivos móviles y de borde, y es adecuado para casos de inferencia en tiempo real y en el propio dispositivo. Es ligero y compatible con hardware de borde, y sirve de base para formatos NPU de proveedores, como Huawei Ascend, Qualcomm QNN para dispositivos Snapdragon y RKNN para NPU de Rockchip.
-
Navegadores web: ONNX puede ejecutarse directamente en navegadores web y permitir aplicaciones de IA interactivas y dinámicas.
Tareas compatibles#
La exportación ONNX admite las siete tareas de Ultralytics. La segmentación semántica y la estimación de profundidad solo están disponibles con YOLO26, la única familia que incluye esas cabezas.
| Tarea | YOLOv8 | YOLO11 | YOLO26 |
|---|---|---|---|
| Detectar | ✅ | ✅ | ✅ |
| Segmentar | ✅ | ✅ | ✅ |
| Semántica | ❌ | ❌ | ✅ |
| Profundidad | ❌ | ❌ | ✅ |
| Clasificar | ✅ | ✅ | ✅ |
| Pose | ✅ | ✅ | ✅ |
| OBB | ✅ | ✅ | ✅ |
Exportación de modelos YOLO26 a ONNX#
Puedes ampliar la compatibilidad de los modelos y la flexibilidad de implementación convirtiendo los modelos YOLO26 al formato ONNX. Ultralytics YOLO26 ofrece un proceso de exportación sencillo para ejecutar tu modelo en distintas plataformas.
Instalación#
Para instalar el paquete necesario, ejecuta:
# Install the required package for YOLO26
pip install ultralyticsPara obtener instrucciones detalladas y buenas prácticas sobre el proceso de instalación, consulta nuestra guía de instalación de YOLO26. Si tienes dificultades al instalar los paquetes necesarios para YOLO26, consulta nuestra guía de problemas habituales, donde encontrarás soluciones y consejos.
Uso#
El formato ONNX admite los modos Exportar, Predecir y Validar. Exporta tu modelo y, a continuación, carga el modelo exportado para ejecutar inferencias o validar su precisión.
from ultralytics import YOLO
# Carga un modelo YOLO26
model = YOLO("yolo26n.pt")
# Exporta el modelo al formato ONNX
model.export(format="onnx") # crea 'yolo26n.onnx'
# Exporta un modelo ONNX cuantizado a INT8 con datos de calibración
model.export(format="onnx", quantize=8, data="coco8.yaml") # crea 'yolo26n_int8.onnx'from ultralytics import YOLO
# Carga el modelo ONNX exportado
model = YOLO("yolo26n.onnx")
# Ejecutar inferencia
results = model("https://ultralytics.com/images/bus.jpg")from ultralytics import YOLO
# Carga el modelo ONNX exportado
model = YOLO("yolo26n.onnx")
# Valida la precisión con el conjunto de datos COCO8
metrics = model.val(data="coco8.yaml")Argumentos de exportación#
Al exportar tu modelo YOLO26 al formato ONNX, puedes personalizar el proceso con distintos argumentos para adaptarlo a tus necesidades de despliegue:
| Argumento | Tipo | Predeterminado | Descripción |
|---|---|---|---|
format | str | 'onnx' | Formato de destino del modelo exportado, que define su compatibilidad con distintos entornos de implementación. |
imgsz | int o tuple | 640 | Tamaño de imagen deseado para la entrada del modelo. Puede ser un número entero para imágenes cuadradas o una tupla (height, width) para dimensiones específicas. |
quantize | int o str | None | Precisión de cuantización: 16 (FP16) o 8 (cuantización estática INT8 con ONNX Runtime y las imágenes de calibración de data, que genera un modelo _int8.onnx); 32/sin especificar equivale a FP32. Un punto de control entrenado con quantize=8 siempre se exporta a INT8 como nodos Q/DQ a partir de los rangos que contiene, sin calibración y con el nombre simple .onnx. Sustituye a los indicadores obsoletos half/int8. |
data | str | None | Archivo YAML del conjunto de datos utilizado para la calibración INT8; en clasificación, en su lugar se acepta un directorio de conjunto de datos o el nombre de un conjunto de datos integrado. Si se omite con quantize=8, Ultralytics selecciona el conjunto de datos de calibración predeterminado para la tarea del modelo; si el punto de control se ha entrenado con quantize=8, no hace falta. |
fraction | float, int o list | 1.0 | Subconjunto de calibración expresado como proporción, número de imágenes o proporciones/recuentos [train, val, test]. Las listas de dos elementos dejan completo test, mientras que 0 lo omite. |
dynamic | bool | False | Permite tamaños de entrada dinámicos, lo que aumenta la flexibilidad para trabajar con imágenes de distintas dimensiones. |
simplify | bool | True | Simplifica el grafo del modelo con onnxslim, lo que puede mejorar el rendimiento y la compatibilidad. |
opset | int | None | Especifica la versión del opset de ONNX para garantizar la compatibilidad con distintos analizadores y entornos de ejecución de ONNX. Si no se establece, se usa el opset 18 (inferior en PyTorch < 2.4), limitado a la versión instalada de onnx. |
nms | bool, opcional | None | Selecciona la salida sin procesar (None, predeterminada), NMS integrada (True) o el cabezal sin NMS (False). |
batch | int | 1 | Especifica el tamaño del lote de inferencia del modelo exportado o el número máximo de imágenes que el modelo exportado procesará simultáneamente en el modo predict. |
device | str | None | Especifica el dispositivo para la exportación: GPU (device=0), CPU (device=cpu), MPS para Apple silicon (device=mps). |
Para obtener más información sobre el proceso de exportación, visita la página de documentación de Ultralytics sobre exportación.
Cuantización INT8#
Para los puntos de control que no se hayan entrenado con entrenamiento con conciencia de cuantización, quantize=8 aplica cuantización estática de ONNX Runtime solo a los nodos Conv, Gemm y MatMul. Todos los demás nodos se mantienen en coma flotante, incluidas las operaciones que ensamblan output0: las coordenadas de los cuadros (en píxeles) y las puntuaciones de clase (de 0 a 1) comparten ese tensor, por lo que una única escala INT8 para ese tensor redondearía todas las puntuaciones de clase a cero. Los pesos se cuantizan por canal a partir de opset 13. Excluye los mismos nodos y configura per_channel=True si ejecutas quantize_static por tu cuenta en un modelo FP32 exportado:
import onnx
from onnxruntime.quantization import quantize_static
model = "yolo26n.onnx"
exclude = [n.name for n in onnx.load(model).graph.node if n.op_type not in {"Conv", "Gemm", "MatMul"}]
quantize_static(model, "yolo26n_int8.onnx", calibration_reader, nodes_to_exclude=exclude, per_channel=True)Aquí, calibration_reader es un onnxruntime.quantization.CalibrationDataReader que genera {"images": array} para cada imagen de calibración, preprocesada como para la inferencia: ajustada con letterboxing al tamaño de exportación, en RGB, NCHW y con float32 en el intervalo 0-1.
Despliegue de modelos YOLO26 ONNX exportados#
Una vez que hayas exportado correctamente tus modelos Ultralytics YOLO26 al formato ONNX, el siguiente paso es desplegarlos en distintos entornos. Para obtener instrucciones detalladas sobre cómo desplegar tus modelos ONNX, consulta estos recursos:
-
Documentación de la API de Python de ONNX Runtime: esta guía ofrece información esencial para cargar y ejecutar modelos ONNX con ONNX Runtime.
-
Implementación en dispositivos de borde: Ejemplos de implementación de modelos ONNX en dispositivos de borde.
-
Tutoriales de ONNX en GitHub: Una colección de tutoriales sobre distintos aspectos del uso y la implementación de modelos ONNX en diferentes escenarios.
-
Triton Inference Server: aprende a desplegar tus modelos ONNX con Triton Inference Server de NVIDIA para conseguir despliegues escalables y de alto rendimiento.
Inferencia con Windows ML#
En Windows 11 24H2 (compilación 26100) o posterior, con Python 3.10 o superior, puedes instalar onnxruntime-windowsml en un entorno independiente para que Windows ML seleccione proveedores de ejecución para tu hardware. Instálalo en lugar de otras compilaciones de ONNX Runtime y, después, usa el mismo modelo exportado .onnx con YOLO("model.onnx"). El backend conserva el número de subprocesos de PyTorch y las opciones de sesión proporcionadas, incluida una política explícita de proveedores. Si no proporcionas ninguna política, Windows ML selecciona el hardware para obtener el máximo rendimiento, incluso cuando el dispositivo de PyTorch es cpu. Mide la latencia de predicción en tu dispositivo antes de elegir este entorno de ejecución; es opcional y no se instala de forma predeterminada.
En las GPU integradas que comparten la alimentación con la CPU, los subprocesos inactivos de PyTorch durante el preprocesamiento y el posprocesamiento pueden ralentizar la inferencia de Windows ML. Llama a torch.set_num_threads(1) antes de predecir para reducir este efecto. Se aplica a todo el proceso, por lo que los demás modelos de PyTorch de ese proceso también se ejecutan en un único subproceso.
import torch
from ultralytics import YOLO
torch.set_num_threads(1) # opcional, mídelo en tu dispositivo
results = YOLO("yolo26n.onnx")("https://ultralytics.com/images/bus.jpg")Inferencia en GPU AMD con MIGraphX#
Ultralytics ejecuta modelos ONNX exportados en GPU AMD mediante el proveedor de ejecución MIGraphX de ONNX Runtime. En un sistema ROCm (HIP), el backend ONNX instala el complemento onnxruntime-ep-migraphx al primer uso y selecciona automáticamente MIGraphXExecutionProvider sin necesidad de cambiar el código; además, admite todas las tareas de YOLO26. Consulta la guía de inferencia en GPU AMD para conocer los requisitos previos, la instalación, el uso, las evaluaciones comparativas y la caché de programas compilados.
Resumen#
En esta guía has aprendido a exportar modelos Ultralytics YOLO26 al formato ONNX para mejorar su interoperabilidad y rendimiento en distintas plataformas. También has conocido ONNX Runtime y las opciones de despliegue de ONNX.
La exportación ONNX es solo uno de los muchos formatos de exportación compatibles con Ultralytics YOLO26, que te permiten desplegar tus modelos en prácticamente cualquier entorno. Según tus necesidades, quizá también quieras explorar otras opciones de exportación, como TensorRT para obtener el máximo rendimiento de GPU o CoreML para dispositivos Apple.
Para obtener más información sobre el uso, visita la documentación oficial de ONNX.
Preguntas frecuentes#
Para exportar tus modelos YOLO26 al formato ONNX con Ultralytics, sigue estos pasos:
Usofrom ultralytics import YOLO # Carga un modelo YOLO26 model = YOLO("yolo26n.pt") # Exporta el modelo al formato ONNX model.export(format="onnx") # crea 'yolo26n.onnx' # Carga el modelo ONNX exportado onnx_model = YOLO("yolo26n.onnx") # Ejecutar inferencia results = onnx_model("https://ultralytics.com/images/bus.jpg")Para obtener más información, visita la documentación de exportación.
Usar ONNX Runtime para desplegar modelos YOLO26 ofrece varias ventajas:
- Compatibilidad multiplataforma: ONNX Runtime es compatible con distintas plataformas, como Windows, macOS y Linux, lo que garantiza que tus modelos se ejecuten sin problemas en distintos entornos.
- Aceleración por hardware: ONNX Runtime puede utilizar optimizaciones específicas para CPU, GPU y aceleradores dedicados, lo que proporciona inferencias de alto rendimiento.
- Interoperabilidad entre frameworks: Los modelos entrenados con frameworks populares, como PyTorch o TensorFlow, se pueden convertir al formato ONNX y ejecutar con ONNX Runtime.
- Optimización del rendimiento: ONNX Runtime suele ser más rápido que la inferencia nativa de PyTorch en CPU, lo que resulta útil en situaciones de implementación con recursos de GPU limitados.
Obtén más información en la documentación de ONNX Runtime.
Los modelos YOLO26 exportados a ONNX se pueden implementar en diversas plataformas, entre ellas:
- CPU: Usa ONNX Runtime para optimizar la inferencia en CPU.
- GPU NVIDIA: Usa NVIDIA CUDA para obtener una aceleración por GPU de alto rendimiento.
- GPU AMD: utiliza AMD ROCm y el proveedor de ejecución MIGraphX para acelerar la GPU con un alto rendimiento en Linux.
- Dispositivos edge: ejecuta modelos ligeros en dispositivos edge y móviles para realizar inferencias en tiempo real directamente en el dispositivo.
- Navegadores web: ejecuta los modelos directamente en los navegadores web para crear aplicaciones web interactivas.
- Servicios en la nube: implementa los modelos en plataformas en la nube compatibles con el formato ONNX para escalar la inferencia.
Para obtener más información, consulta nuestra guía sobre opciones de implementación de modelos.
El uso del formato ONNX para los modelos Ultralytics YOLO26 ofrece varias ventajas:
- Interoperabilidad: ONNX permite transferir modelos entre distintos frameworks de aprendizaje automático.
- Optimización del rendimiento: ONNX Runtime puede mejorar el rendimiento de los modelos mediante optimizaciones específicas del hardware.
- Flexibilidad: ONNX es compatible con diversos entornos de implementación, por lo que puedes utilizar el mismo modelo en distintas plataformas sin modificarlo.
- Estandarización: ONNX ofrece un formato estandarizado con amplia compatibilidad en el sector, lo que garantiza la compatibilidad a largo plazo.
Al exportar modelos YOLO26 a ONNX, puedes encontrarte con problemas habituales, como dependencias incompatibles u operaciones no admitidas. Para solucionar estos problemas:
- Comprueba que tienes instalada la versión correcta de las dependencias necesarias.
- Consulta la documentación oficial de ONNX para conocer los operadores y las funciones compatibles.
- Revisa los mensajes de error en busca de pistas y consulta la guía de problemas habituales de Ultralytics.
- Prueba a utilizar otros argumentos de exportación, como
simplify=True, o a cambiar la versión deopset. - Si tienes problemas con el tamaño dinámico de entrada, establece
dynamic=Truedurante la exportación.
Si el problema persiste, ponte en contacto con el equipo de asistencia de Ultralytics para obtener ayuda.
Comentarios77
Haz una pregunta, comparte tus resultados o ayuda a otra persona.
dopeggguy
The parameter "half" bost apperence in train and export, what’s difference. when we using this parameter what should we need attention.
Glenn JocherUltralytics(editado)@dopeggguy Good question—summary: training uses mixed precision via
amp=True(weights stay FP32; compute is FP16 where safe), while export usesquantize=16(the formerhalf=True, now deprecated) to write an FP16 model for runtimes that support FP16. During training preferamp; use FP16 only at export/inference, and don't combine it with INT8 (quantize=8). See the train overview and AMP notes in the Train mode docs and thequantizeoption details in Model Export – Arguments and Configuration – Export Settings.from ultralytics import YOLO # Mixed-precision training (recommended) YOLO("yolo26n.yaml").train(data="data.yaml", amp=True) # FP16 export for FP16-capable runtimes (e.g., CUDA/TensorRT/OpenVINO FP16) YOLO("best.pt").export(format="onnx", quantize=16)dopeggguy
yoloModel = YOLO(path_dir) yoloModel.export(format='onnx', dynamic=False, half=True, imgsz=(640, 640))
I'm not sure why. I enabled half=True, but the actual size of the exported model doesn't seem to change at all.
Glenn JocherUltralytics(editado)@dopeggguy
half=Trueis deprecated in favor ofquantize=16. On older releases a CPU-only ONNX export ignored the flag and stayed FP32, so the file size was almost identical. Current releases convert CPU ONNX exports to FP16 too (keeping float32 inputs/outputs), and GPU exports are FP16 natively. If you have a GPU, you can force export on it and re-check:from ultralytics import YOLO YOLO(path_dir).export(format="onnx", imgsz=(640, 640), dynamic=False, quantize=16, device=0)You can then open the ONNX in Netron or inspect it with the
onnxPython API to confirm the weights arefloat16; for pure CPU deployments it is often better to keep ONNX as FP32 or use a CPU‑oriented backend (e.g. OpenVINO) for FP16/INT8 optimization instead, with some general ONNX background outlined in the ONNX: Open Neural Network Exchange overview.
bastinj98
Hi, I trained d a YOLOV8-segn model to detect and segment a single class (nc=1) and then exported in to onnx (simplify, nms, half are all False) with opset = 17. The output shape is 1x37x8400.
I am building a C++ pipeline to use this model to run inference. How can I process this output to get the final segmentation mask ?
NgZiming
I exported a yolo 11 segment model to onnx format, and used onnx-runtime to infer. It responded two ndarrays of shapes (1, 37, 21504) and (1, 32, 256, 256). (imgsz=1024) So, how can i extract masks from these two arrays?
Glenn JocherUltralytics@NgZiming 这两个输出正是分割模型的“检测头 + 原型掩码”:
(1, 37, 21504)=4(xywh) + nc + 32(mask系数),(1, 32, 256, 256)为32个原型;掩码可由原型与对应检测的32维系数线性组合并裁剪到框内,最小示例(Python/NumPy)如下:import numpy as np import cv2 def sigmoid(x): return 1 / (1 + np.exp(-x)) def mask_from_outputs(det, proto, img_h, img_w, det_idx): # det: (1, C, N) -> (C, N), proto: (1, 32, 256, 256) -> (32, 256, 256) det = det[0]; proto = proto[0] nm, ph, pw = proto.shape # 32, 256, 256 nc = det.shape[0] - 4 - nm # 1) 取该检测的框、类别分数与32维掩码系数 cx, cy, w, h = det[0, det_idx], det[1, det_idx], det[2, det_idx], det[3, det_idx] coeff = det[4+nc:4+nc+nm, det_idx] # (32,) # 2) 原型 × 系数 -> 原始掩码 (ph, pw) m = sigmoid((proto.reshape(nm, -1).T @ coeff).reshape(ph, pw)) # 3) 可选:按框在原型分辨率下裁剪(坐标为[0,1]比例) x0 = int(max(0, (cx - w/2) * pw)); x1 = int(min(pw, (cx + w/2) * pw)) y0 = int(max(0, (cy - h/2) * ph)); y1 = int(min(ph, (cy + h/2) * ph)) crop = np.zeros_like(m); crop[y0:y1, x0:x1] = m[y0:y1, x0:x1] # 4) 上采样到原图尺寸并二值化 mask = cv2.resize(crop, (img_w, img_h), interpolation=cv2.INTER_LINEAR) return (mask > 0.5).astype(np.uint8)要点:确保与推理时的预处理一致(letterbox 缩放与填充、RGB/归一化等),否则框与掩码会错位。关于分割导出产生两个输出(
output0检测+系数,output1原型)的由来,可见导出实现参考的export_onnx说明:export_onnx 函数参考.1NgZiming
thanks
Glenn JocherUltralyticsGlad it helped—if you later need a C++ reference for segmentation mask decoding and preprocessing alignment, the step-by-step overview is in the Segmentation task docs.
UserI have a question. If it's convenient, please answer it. Thank you! I'm working with cell images, and the image size is 3072*2048. I trained with imagesize=3072, but if I use imagesize=640, I can't detect objects. I can predict with a 3072 imagesize using a pt file, but now I'm trying to switch to C++ and call onnx, and the 3072 inference is very slow. Is this normal?
denni281
You should keep the same preprocess way between python-inference and cpp-inference.
Glenn JocherUltralytics@giter915 Yes—running 3072×2048 through ONNX/C++ will be much slower; inference time grows quickly with input area. Two practical options: use a faster backend or reduce effective input while keeping accuracy. For GPU, prefer TensorRT; for CPU, OpenVINO FP16/INT8 gives the largest gains. Examples:
from ultralytics import YOLO # GPU-optimized YOLO("best.pt").export(format="engine", imgsz=1536, half=True, dynamic=True) # CPU-optimized YOLO("best.pt").export(format="openvino", imgsz=1536, half=True) # add int8=True with calibration if desiredIf you must keep 3072, tile the image (e.g., 1024×1024 patches), run ONNX per tile, then merge detections with NMS in C++; this is a common approach for microscopy. Also ensure preprocessing in C++ exactly matches Python (letterbox padding, RGB order, 1/255 scaling)—agree with @DennisJcy here. For backend choices and supported export targets, see the export formats table in Object Detection – Ultralytics YOLO Docs, and for high‑throughput GPU serving consider Triton Inference Server with YOLO11.
UserThank you very much!
Glenn JocherUltralyticsGlad it helped—one extra tip for ONNX Runtime C++: enable full graph optimizations and tune threads to squeeze more speed from large inputs like 3072×2048.
#include <onnxruntime_cxx_api.h> #include <thread> Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "yolo"); Ort::SessionOptions so; so.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL); so.SetIntraOpNumThreads(std::thread::hardware_concurrency()); so.SetInterOpNumThreads(1); // often fine to leave at 1 Ort::Session session(env, "best.onnx", so);
denni281(editado)
Hello, I use ultratics to export YOLO11 half-Precision onnx model, but when I load the .onnx model to eval by onnxruntime, exception shows :Unexpected input data type. Actual: (tensor(float16)) , expected: (tensor(float)). And I compare the Float32 and Float16(half) .onnx model,These two files are exactly the same in size and input type.So the "half" keyword doesn't take effect when exporting ONNX, right? I remember Ultralytics didn't have this issue last year.
Here is my python script to export half-precision onnx model:
def main(opt): model = YOLO(opt.model) model.export( format="onnx", # opset=12, simplify=True, dynamic=False, imgsz=opt.imgsz, half=opt.half, batch=opt.batch, ) if __name__ == "__main__": multiprocessing.freeze_support() parser = argparse.ArgumentParser() parser.add_argument( "--model", type=str, default="/home/ultralytics/runs/detect/SHFY/weights/best.pt", ) parser.add_argument("--imgsz", type=int, default=640) parser.add_argument("--half", type=bool, default=True) parser.add_argument("--batch", type=int, default=1) opt, unparsed = parser.parse_known_args() print(opt) main(opt)denni281(editado)
Fine... It's my fault. My docker environment is Python-3.11.9 torch-2.4.1+cu118 CPU (unknown). The error is made by my cpu environment
Glenn JocherUltralytics(editado)@DennisJcy thanks for the update. On older releases
half=Truehad no effect on CPU ONNX exports, so the file stayed FP32. Current Ultralytics usesquantize=16(replacing the deprecatedhalf) and also converts CPU ONNX exports to FP16 while keeping float32 inputs/outputs, whereas GPU exports (device=0) are FP16 natively and need an FP16-capable ONNX Runtime provider. For CPU-optimized FP16 you can also export OpenVINO. For example:from ultralytics import YOLO # FP16 ONNX YOLO("best.pt").export(format="onnx", quantize=16) # CPU-optimized FP16 (OpenVINO) YOLO("best.pt").export(format="openvino", quantize=16)Details on OpenVINO export are in the export_openvino reference.
ShuaibZyx
def yolo_to_onnx(model_path, input_shape=(600, 600)): # Load the YOLOv8 model model = YOLO(model_path)
# Export the model to ONNX format model.export(format='onnx', imgsz=input_shape, dynamic=True, batch=1, device="0")Ultralytics YOLOv8.0.220 🚀 Python-3.9.18 torch-2.1.1+cu121 CUDA:0 (Tesla T4, 14931MiB) Model summary (fused): 268 layers, 43610463 parameters, 0 gradients, 164.8 GFLOPs
PyTorch: starting from 'best.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) (1, 9, 8400) (83.6 MB)
ONNX: starting export with onnx 1.18.0 opset 17... ONNX: export success ✅ 3.3s, saved as 'best.onnx' (166.5 MB) 我的模型在训练时是5个类别的目标检测,导出的模型的输出格式是(1, 9, 8400)。 我想请问您其中9具体代表的是什么呢? 如果是为了预测5个类别(1, 9, 8400)的输出格式是正确的嘛? 期待您的帮助!感谢!
xiaoqiang-l
9指的是:[x,y,w,h,class1_scores,class2_scores,class3_scores,class4_scores,class5_scores],即四个坐标及N个类别分数。 8400指的是:640下采样8倍、16倍、32倍特征图的anchor总数,(640/8)(640/8)+(640/16)(640/16)+(640/32)(640/32)=8080+4040+2020=8400
ShuaibZyx
感谢您的指导!
Glenn JocherUltralytics@ShuaibZyx you're welcome! @xiaoqiang-l provided an excellent explanation. Just to confirm, the output shape (1, 9, 8400) is indeed correct for your 5-class detection model - the 9 channels represent the 4 bounding box coordinates (x, y, w, h) plus 5 class confidence scores. The 8400 represents all detection anchors across the three feature map scales (80×80 + 40×40 + 20×20 = 8400 total anchors).
UltralyticsAssistantUltralytics
👋 Hello, thank you for your interest in Ultralytics 🚀! We recommend a visit to the Docs for new users where you can find many Python and CLI usage examples, as well as detailed guides about exporting YOLO models to ONNX and other formats.
If this is a 🐛 Bug Report, please provide a minimum reproducible example to help us debug it.
If you have a custom training ❓ Question or require help with ONNX export, please include as much detail as possible—such as your command, model version, logs, and environment details. Also, check out our Tips for Best Training Results for optimal performance.
Join the Ultralytics community where it suits you best! For real-time chat, head to Discord 🎧. For in-depth discussions, try Discourse, or join the conversation on our Subreddit.
Upgrade
Upgrade to the latest
ultralyticspackage including all requirements in a Python>=3.8 environment with PyTorch>=1.8 to ensure you’re using the most up-to-date features and bug fixes:pip install -U ultralyticsEnvironments
YOLO can be run in these up-to-date verified environments, with all dependencies including CUDA/CUDNN, Python, and PyTorch preinstalled:
- Notebooks with free GPU:
- Google Cloud Deep Learning VM. See GCP Quickstart Guide
- Amazon Deep Learning AMI. See AWS Quickstart Guide
- Docker Image. See Docker Quickstart Guide
Status
If this badge is green, all Ultralytics CI tests are currently passing. CI tests verify correct operation of all YOLO Modes and Tasks on macOS, Windows, and Ubuntu every 24 hours and on every commit.
This is an automated response 🤖. An Ultralytics engineer will review your discussion and assist you soon!
Glenn JocherUltralyticsHello! Thanks for your interest in exporting YOLO11 models to ONNX format. This is a great option for deployment across different platforms with performance benefits.
Exporting to ONNX is straightforward with Ultralytics:
from ultralytics import YOLO # Load model model = YOLO("yolo11n.pt") # or your custom trained model # Export to ONNX with optional parameters model.export(format="onnx", dynamic=True, simplify=True) # creates 'yolo11n.onnx' # Use the exported model onnx_model = YOLO("yolo11n.onnx") results = onnx_model("https://ultralytics.com/images/bus.jpg")ONNX export can provide up to 3x CPU speedup compared to PyTorch models. You can customize the export with several parameters like
half=Truefor FP16 precision,dynamic=Truefor variable input sizes, oropsetto specify the ONNX version.For deployment, you can use ONNX Runtime or integrate with platforms like NVIDIA Triton Inference Server for production-scale serving.
If you have specific questions about exporting your models or encounter any issues during the process, please let us know!
- Notebooks with free GPU:
UltralyticsAssistantUltralytics
👋 Hello, thank you for your interest in Ultralytics 🚀! For users exploring ONNX integration and YOLO11, we recommend checking out the Docs where you’ll find dedicated Python and CLI tutorials, as well as specific ONNX integration guidance.
If this is a 🐛 Bug Report, please provide a minimum reproducible example to help us investigate further.
For custom deployment or export ❓ questions, please include as many details as possible, such as your export commands, model versions, and error logs. Make sure you review our Tips for Best Training Results for optimal performance.
Join the Ultralytics community where it suits you best: jump into real-time conversations on Discord 🎧, post or search on Discourse, or connect on our Subreddit.
Upgrade
Upgrade to the latest
ultralyticspackage, including all requirements, in a Python>=3.8 environment with PyTorch>=1.8 to ensure you have the latest features and fixes:pip install -U ultralyticsEnvironments
YOLO can be run in any of the following up-to-date verified environments (with all dependencies including CUDA/CUDNN, Python and PyTorch preinstalled):
- Notebooks with free GPU:
- Google Cloud Deep Learning VM. See GCP Quickstart Guide
- Amazon Deep Learning AMI. See AWS Quickstart Guide
- Docker Image. See Docker Quickstart Guide
Status
If this badge is green, all Ultralytics CI tests are currently passing. CI tests verify correct operation of all YOLO Modes and Tasks on macOS, Windows, and Ubuntu every 24 hours and on every commit.
This is an automated response. An Ultralytics engineer will assist you here soon!
Glenn JocherUltralyticsYes, you can adjust the batch size dynamically when exporting to ONNX format by using the
dynamic=Trueparameter in your export call. When this is enabled, the batch dimension becomes dynamic, allowing you to use various batch sizes during inference without reexporting the model.Here's a simple example:
from ultralytics import YOLO # Load your model model = YOLO("yolo11n.pt") # Export with dynamic input size model.export(format="onnx", dynamic=True)This creates dynamic dimensions in the exported ONNX model, where the batch dimension (as well as height and width) can vary during inference. The resulting model will be more flexible for production deployments where batch size requirements might change.
- Notebooks with free GPU:
skyceeee
First of all, thank you for everything. Can we adjust the batch size dynamically when exporting the model as onnx?
xiaoqiang-l
When I export the YOLOV11 onnx model, I use: model.export(format='onnx', imgsz=640, device='cpu'). Then I use onnxruntime (1.14.0) to deploy it on the C++ side, but an error is reported during runtime: onnxruntime::Model::Model Unsupported model IR version: 9, max supported IR version: 8. Is there any parameter or method to set the exported model to support IR version: 8? Because I cannot upgrade onnxruntime to other higher versions locally, I look forward to your help
Glenn JocherUltralytics@xiaoqiang-l to resolve the ONNX IR version compatibility issue, you can specify an older
opsetversion during export. Try addingopset=13to your export command:model.export(format='onnx', imgsz=640, device='cpu', opset=13)This will generate an ONNX model compatible with IR version 8. For detailed version mapping, see the ONNX operator version matrix in the ONNX documentation.
