¿Qué formato de exportación debo usar?

Usa ONNX u OpenVINO para la implementación en CPU, ya que pueden ser hasta 3 veces más rápidos que PyTorch, y TensorRT para GPU NVIDIA, donde puede ser hasta 5 veces más rápido. CoreML está pensado para dispositivos Apple, y TensorFlow Lite o Edge TPU, para Android y el hardware Coral.

¿Cómo exporto en FP16?

Añade --half. La precisión media requiere una GPU para la mayoría de los formatos, así que añade también --device 0; CoreML es la excepción y puede exportar en FP16 usando la CPU.

¿Puedo exportar con un tamaño de lote dinámico?

Sí. Añade --dynamic. Las exportaciones a ONNX incorporan ejes dinámicos para el lote, la altura y la anchura, y se trazan en la CPU, así que omite --device 0. Las exportaciones a TensorRT mantienen fijo el tamaño de imagen y solo varían la dimensión del lote: siguen necesitando --device 0, y --batch-size establece el tamaño máximo del lote que admite el motor.

¿Cómo ejecuto un modelo exportado?

Pasa el archivo exportado a detect.py --weights, val.py --weights o torch.hub.load("ultralytics/yolov5", "custom", "yolov5s.onnx"). YOLOv5 selecciona el backend correcto según la extensión del archivo.

Exportación a TFLite, ONNX, CoreML y TensorRT#

📚 Esta guía explica cómo exportar un modelo YOLOv5 🚀 entrenado desde PyTorch a distintos formatos de implementación, como ONNX, TensorRT y CoreML, entre otros.

Antes de empezar#

Clona el repositorio e instala requirements.txt en un entorno Python>=3.8.0 que incluya PyTorch>=1.8. Los modelos y los conjuntos de datos se descargan automáticamente desde la versión más reciente de YOLOv5.

git clone https://github.com/ultralytics/yolov5 # clone
cd yolov5
pip install -r requirements.txt # install

Para ver un ejemplo de exportación a TensorRT (requiere GPU), consulta la sección del apéndice del cuaderno de Colab.

Formatos de exportación compatibles#

La inferencia de YOLOv5 es oficialmente compatible con 12 formatos:

Consejos de rendimiento

Exporta a ONNX u OpenVINO para acelerar hasta 3 veces la ejecución en CPU. Consulta las pruebas de rendimiento con CPU.
Exporta a TensorRT para acelerar hasta 5 veces la ejecución en GPU. Consulta las pruebas de rendimiento con GPU.

Formato	`export.py --include`	Modelo
PyTorch	-	`yolov5s.pt`
TorchScript	`torchscript`	`yolov5s.torchscript`
ONNX	`onnx`	`yolov5s.onnx`
OpenVINO	`openvino`	`yolov5s_openvino_model/`
TensorRT	`engine`	`yolov5s.engine`
CoreML	`coreml`	`yolov5s.mlpackage`
TensorFlow SavedModel	`saved_model`	`yolov5s_saved_model/`
TensorFlow GraphDef	`pb`	`yolov5s.pb`
TensorFlow Lite	`tflite`	`yolov5s.tflite`
TensorFlow Edge TPU	`edgetpu`	`yolov5s_edgetpu.tflite`
TensorFlow.js	`tfjs`	`yolov5s_web_model/`
PaddlePaddle	`paddle`	`yolov5s_paddle_model/`

Pruebas de rendimiento#

Las pruebas de rendimiento siguientes se ejecutan en Colab Pro con el cuaderno del tutorial de YOLOv5 . Para reproducirlas:

python benchmarks.py --weights yolov5s.pt --imgsz 640 --device 0

GPU V100 de Colab Pro#

benchmarks: weights=/content/yolov5/yolov5s.pt, imgsz=640, batch_size=1, data=/content/yolov5/data/coco128.yaml, device=0, half=False, test=False
Checking setup...
YOLOv5 🚀 v6.1-135-g7926afc torch 1.10.0+cu111 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)
Setup complete ✅ (8 CPUs, 51.0 GB RAM, 46.7/166.8 GB disk)

Benchmarks complete (458.07s)
                   Format  mAP@0.5:0.95  Inference time (ms)
0                 PyTorch        0.4623                10.19
1             TorchScript        0.4623                 6.85
2                    ONNX        0.4623                14.63
3                OpenVINO           NaN                  NaN
4                TensorRT        0.4617                 1.89
5                  CoreML           NaN                  NaN
6   TensorFlow SavedModel        0.4623                21.28
7     TensorFlow GraphDef        0.4623                21.22
8         TensorFlow Lite           NaN                  NaN
9     TensorFlow Edge TPU           NaN                  NaN
10          TensorFlow.js           NaN                  NaN

CPU de Colab Pro#

benchmarks: weights=/content/yolov5/yolov5s.pt, imgsz=640, batch_size=1, data=/content/yolov5/data/coco128.yaml, device=cpu, half=False, test=False
Checking setup...
YOLOv5 🚀 v6.1-135-g7926afc torch 1.10.0+cu111 CPU
Setup complete ✅ (8 CPUs, 51.0 GB RAM, 41.5/166.8 GB disk)

Benchmarks complete (241.20s)
                   Format  mAP@0.5:0.95  Inference time (ms)
0                 PyTorch        0.4623               127.61
1             TorchScript        0.4623               131.23
2                    ONNX        0.4623                69.34
3                OpenVINO        0.4623                66.52
4                TensorRT           NaN                  NaN
5                  CoreML           NaN                  NaN
6   TensorFlow SavedModel        0.4623               123.79
7     TensorFlow GraphDef        0.4623               121.57
8         TensorFlow Lite        0.4623               316.61
9     TensorFlow Edge TPU           NaN                  NaN
10          TensorFlow.js           NaN                  NaN

Exportar un modelo YOLOv5 entrenado#

Este comando exporta un modelo YOLOv5s preentrenado a los formatos TorchScript y ONNX. yolov5s.pt es el modelo «pequeño», el segundo más pequeño disponible. Las otras opciones son yolov5n.pt, yolov5m.pt, yolov5l.pt y yolov5x.pt, así como sus versiones P6 correspondientes, es decir, yolov5s6.pt, o tu propio punto de control de entrenamiento personalizado, es decir, runs/train/exp/weights/best.pt. Para ver información sobre todos los modelos disponibles, consulta la tabla del README.

python export.py --weights yolov5s.pt --include torchscript onnx

Consejo

Añade --half para exportar modelos con precisión FP16 (media precisión) y reducir el tamaño de los archivos.

Salida:

export: data=data/coco128.yaml, weights=['yolov5s.pt'], imgsz=[640, 640], batch_size=1, device=cpu, half=False, inplace=False, train=False, keras=False, optimize=False, int8=False, dynamic=False, simplify=False, opset=12, verbose=False, workspace=4, nms=False, agnostic_nms=False, topk_per_class=100, topk_all=100, iou_thres=0.45, conf_thres=0.25, include=['torchscript', 'onnx']
YOLOv5 🚀 v6.2-104-ge3e5122 Python-3.8.0 torch-1.12.1+cu113 CPU

Downloading https://github.com/ultralytics/yolov5/releases/download/v6.2/yolov5s.pt to yolov5s.pt...
100% 14.1M/14.1M [00:00<00:00, 274MB/s]

Fusing layers...
YOLOv5s summary: 213 layers, 7225885 parameters, 0 gradients

PyTorch: starting from yolov5s.pt with output shape (1, 25200, 85) (14.1 MB)

TorchScript: starting export with torch 1.12.1+cu113...
TorchScript: export success ✅ 1.7s, saved as yolov5s.torchscript (28.1 MB)

ONNX: starting export with onnx 1.12.0...
ONNX: export success ✅ 2.3s, saved as yolov5s.onnx (28.0 MB)

Export complete (5.5s)
Results saved to /content/yolov5
Detect:          python detect.py --weights yolov5s.onnx
Validate:        python val.py --weights yolov5s.onnx
PyTorch Hub:     model = torch.hub.load('ultralytics/yolov5', 'custom', 'yolov5s.onnx')
Visualize:       https://netron.app/

Los modelos exportados se guardarán junto al modelo PyTorch original:

YOLO export locations

Se recomienda Netron Viewer para visualizar los modelos exportados:

YOLO model visualization

Ejemplos de uso de modelos exportados#

detect.py ejecuta inferencias con modelos exportados:

python detect.py --weights yolov5s.pt             # PyTorch
python detect.py --weights yolov5s.torchscript    # TorchScript
python detect.py --weights yolov5s.onnx           # ONNX Runtime or OpenCV DNN with --dnn
python detect.py --weights yolov5s_openvino_model # OpenVINO
python detect.py --weights yolov5s.engine         # TensorRT
python detect.py --weights yolov5s.mlpackage      # CoreML (macOS only)
python detect.py --weights yolov5s_saved_model    # TensorFlow SavedModel
python detect.py --weights yolov5s.pb             # TensorFlow GraphDef
python detect.py --weights yolov5s.tflite         # TensorFlow Lite
python detect.py --weights yolov5s_edgetpu.tflite # TensorFlow Edge TPU
python detect.py --weights yolov5s_paddle_model   # PaddlePaddle

val.py valida modelos exportados:

python val.py --weights yolov5s.pt             # PyTorch
python val.py --weights yolov5s.torchscript    # TorchScript
python val.py --weights yolov5s.onnx           # ONNX Runtime or OpenCV DNN with --dnn
python val.py --weights yolov5s_openvino_model # OpenVINO
python val.py --weights yolov5s.engine         # TensorRT
python val.py --weights yolov5s.mlpackage      # CoreML (macOS only)
python val.py --weights yolov5s_saved_model    # TensorFlow SavedModel
python val.py --weights yolov5s.pb             # TensorFlow GraphDef
python val.py --weights yolov5s.tflite         # TensorFlow Lite
python val.py --weights yolov5s_edgetpu.tflite # TensorFlow Edge TPU
python val.py --weights yolov5s_paddle_model   # PaddlePaddle

Usa PyTorch Hub con modelos YOLOv5 exportados:

import torch

# Model
model = torch.hub.load("ultralytics/yolov5", "custom", "yolov5s.pt")
model = torch.hub.load("ultralytics/yolov5", "custom", "yolov5s.torchscript")  # TorchScript
model = torch.hub.load("ultralytics/yolov5", "custom", "yolov5s.onnx")  # Entorno de ejecución de ONNX
model = torch.hub.load("ultralytics/yolov5", "custom", "yolov5s_openvino_model")  # OpenVINO
model = torch.hub.load("ultralytics/yolov5", "custom", "yolov5s.engine")  # TensorRT
model = torch.hub.load("ultralytics/yolov5", "custom", "yolov5s.mlpackage")  # CoreML (solo macOS)
model = torch.hub.load("ultralytics/yolov5", "custom", "yolov5s_saved_model")  # TensorFlow SavedModel
model = torch.hub.load("ultralytics/yolov5", "custom", "yolov5s.pb")  # TensorFlow GraphDef
model = torch.hub.load("ultralytics/yolov5", "custom", "yolov5s.tflite")  # TensorFlow Lite
model = torch.hub.load("ultralytics/yolov5", "custom", "yolov5s_edgetpu.tflite")  # TensorFlow Edge TPU
model = torch.hub.load("ultralytics/yolov5", "custom", "yolov5s_paddle_model")  # PaddlePaddle

# Images
img = "https://ultralytics.com/images/zidane.jpg"  # o archivo, Path, PIL, OpenCV, numpy, lista

# Inference
results = model(img)

# Results
results.print()  # o .show(), .save(), .crop(), .pandas(), etc.

Inferencia con OpenCV DNN#

Inferencia con OpenCV y modelos ONNX:

python export.py --weights yolov5s.pt --include onnx

python detect.py --weights yolov5s.onnx --dnn # detect
python val.py --weights yolov5s.onnx --dnn    # validate

Inferencia en C++#

Ejemplos de inferencia en C++ con OpenCV DNN de YOLOv5 en modelos ONNX exportados:

Ejemplos de inferencia en C++ con OpenVINO de YOLOv5:

Inferencia en navegador web con TensorFlow.js#

https://aukerul-shuvo.github.io/YOLOv5_TensorFlow-JS/

Entornos compatibles#

Ultralytics ofrece una variedad de entornos listos para usar, cada uno con dependencias esenciales preinstaladas, como CUDA, CUDNN, Python y PyTorch, para que puedas poner en marcha tus proyectos.

Cuadernos gratuitos con GPU:
Google Cloud: Guía de inicio rápido de GCP
Amazon: Guía de inicio rápido de AWS
Azure: Guía de inicio rápido de AzureML
Docker: Guía de inicio rápido de Docker

Estado del proyecto#

Esta insignia indica que todas las pruebas de integración continua (CI) de GitHub Actions de YOLOv5 se superan correctamente. Estas pruebas de CI comprueban rigurosamente la funcionalidad y el rendimiento de YOLOv5 en varios aspectos clave: entrenamiento, validación, inferencia, exportación y evaluaciones comparativas. Garantizan un funcionamiento uniforme y fiable en macOS, Windows y Ubuntu, con pruebas cada 24 horas y tras cada nueva confirmación.

Preguntas frecuentes#

Usa ONNX u OpenVINO para la implementación en CPU, ya que pueden ser hasta 3 veces más rápidos que PyTorch, y TensorRT para GPU NVIDIA, donde puede ser hasta 5 veces más rápido. CoreML está pensado para dispositivos Apple, y TensorFlow Lite o Edge TPU, para Android y el hardware Coral.
Añade --half. La precisión media requiere una GPU para la mayoría de los formatos, así que añade también --device 0; CoreML es la excepción y puede exportar en FP16 usando la CPU.
Sí. Añade --dynamic. Las exportaciones a ONNX incorporan ejes dinámicos para el lote, la altura y la anchura, y se trazan en la CPU, así que omite --device 0. Las exportaciones a TensorRT mantienen fijo el tamaño de imagen y solo varían la dimensión del lote: siguen necesitando --device 0, y --batch-size establece el tamaño máximo del lote que admite el motor.
Pasa el archivo exportado a detect.py --weights, val.py --weights o torch.hub.load("ultralytics/yolov5", "custom", "yolov5s.onnx"). YOLOv5 selecciona el backend correcto según la extensión del archivo.

Colaboradores

GLglenn-jocher⁴ RAraimbekovm¹ PDpderrenger¹

Creado hace 4 mesesActualizado hace 2 semanas

Get Started