Guía de inicio rápido: NVIDIA Jetson con Ultralytics YOLO11
Esta guía completa proporciona un tutorial detallado para implementar Ultralytics YOLO11 en dispositivos NVIDIA Jetson. Además, muestra pruebas de rendimiento para demostrar las capacidades de YOLO11 en estos dispositivos pequeños y potentes.
Nuevo soporte de producto
Hemos actualizado esta guía con el último NVIDIA Jetson Orin Nano Super Developer Kit que ofrece hasta 67 TOPS de rendimiento de IA, una mejora de 1,7X con respecto a su predecesor, para ejecutar sin problemas los modelos de IA más populares.
Ver: Cómo usar Ultralytics YOLO11 en dispositivos NVIDIA JETSON
Nota
Esta guía ha sido probada con NVIDIA Jetson AGX Orin Developer Kit (64GB) ejecutando la última versión estable de JetPack JP6.2, NVIDIA Jetson Orin Nano Super Developer Kit ejecutando la versión de JetPack JP6.1, Seeed Studio reComputer J4012 que se basa en NVIDIA Jetson Orin NX 16GB ejecutando la versión de JetPack JP6.0/ JetPack versión JP5.1.3 y Seeed Studio reComputer J1020 v2 que se basa en NVIDIA Jetson Nano 4GB ejecutando la versión de JetPack JP4.6.1. Se espera que funcione en toda la línea de hardware NVIDIA Jetson, incluidas las versiones más recientes y las heredadas.
¿Qué es NVIDIA Jetson?
NVIDIA Jetson es una serie de placas informáticas integradas diseñadas para llevar la computación acelerada de IA (inteligencia artificial) a los dispositivos de borde. Estos dispositivos compactos y potentes se basan en la arquitectura de la GPU de NVIDIA y son capaces de ejecutar algoritmos complejos de IA y modelos de aprendizaje profundo directamente en el dispositivo, sin necesidad de depender de los recursos de la computación en la nube. Las placas Jetson se utilizan a menudo en robótica, vehículos autónomos, automatización industrial y otras aplicaciones donde la inferencia de la IA debe realizarse localmente con baja latencia y alta eficiencia. Además, estas placas se basan en la arquitectura ARM64 y funcionan con menor potencia en comparación con los dispositivos informáticos tradicionales de la GPU.
Comparación de la serie NVIDIA Jetson
Jetson Orin es la última iteración de la familia NVIDIA Jetson basada en la arquitectura NVIDIA Ampere, que aporta un rendimiento de IA drásticamente mejorado en comparación con las generaciones anteriores. La siguiente tabla compara algunos de los dispositivos Jetson del ecosistema.
Jetson AGX Orin 64GB | Jetson Orin NX 16GB | Jetson Orin Nano Super | Jetson AGX Xavier | Jetson Xavier NX | Jetson Nano | |
---|---|---|---|---|---|---|
Rendimiento de la IA | 275 TOPS | 100 TOPS | 67 TOPs | 32 TOPS | 21 TOPS | 472 GFLOPS |
GPU | GPU NVIDIA Ampere architecture de 2048 núcleos con 64 Tensor Cores | GPU NVIDIA Ampere architecture de 1024 núcleos con 32 Tensor Cores | GPU NVIDIA Ampere architecture de 1024 núcleos con 32 Tensor Cores | GPU NVIDIA Volta architecture de 512 núcleos con 64 Tensor Cores | GPU NVIDIA Volta™ architecture de 384 núcleos con 48 Tensor Cores | GPU NVIDIA Maxwell™ architecture de 128 núcleos |
Frecuencia Máxima de la GPU | 1.3 GHz | 918 MHz | 1020 MHz | 1377 MHz | 1100 MHz | 921MHz |
CPU | CPU NVIDIA Arm® Cortex A78AE v8.2 de 64 bits y 12 núcleos, 3 MB de L2 + 6 MB de L3 | CPU NVIDIA Arm® Cortex A78AE v8.2 de 64 bits y 8 núcleos, 2 MB de L2 + 4 MB de L3 | CPU Arm® Cortex®-A78AE v8.2 de 64 bits y 6 núcleos, 1,5 MB de L2 + 4 MB de L3 | CPU NVIDIA Carmel Arm®v8.2 de 64 bits y 8 núcleos, 8 MB de L2 + 4 MB de L3 | CPU NVIDIA Carmel Arm®v8.2 de 64 bits y 6 núcleos, 6 MB de L2 + 4 MB de L3 | Procesador MPCore Arm® Cortex®-A57 de cuatro núcleos |
Frecuencia Máxima de la CPU | 2.2 GHz | 2.0 GHz | 1.7 GHz | 2.2 GHz | 1.9 GHz | 1.43GHz |
Memoria | 64 GB LPDDR5 de 256 bits 204,8 GB/s | 16 GB LPDDR5 de 128 bits 102,4 GB/s | 8GB 128-bit LPDDR5 102 GB/s | 32 GB LPDDR4x de 256 bits 136,5 GB/s | 8 GB LPDDR4x de 128 bits 59,7 GB/s | 4 GB LPDDR4 de 64 bits 25,6 GB/s" |
Para una tabla comparativa más detallada, visite la sección de Especificaciones Técnicas de la página oficial de NVIDIA Jetson.
¿Qué es NVIDIA JetPack?
El SDK NVIDIA JetPack que impulsa los módulos Jetson es la solución más completa y proporciona un entorno de desarrollo completo para la creación de aplicaciones de IA aceleradas de extremo a extremo y reduce el tiempo de comercialización. JetPack incluye Jetson Linux con bootloader, kernel de Linux, entorno de escritorio Ubuntu y un conjunto completo de bibliotecas para la aceleración de la computación de GPU, multimedia, gráficos y visión artificial. También incluye ejemplos, documentación y herramientas de desarrollo tanto para el ordenador host como para el kit de desarrollo, y es compatible con SDK de nivel superior como DeepStream para el análisis de vídeo en streaming, Isaac para la robótica y Riva para la IA conversacional.
Flashear JetPack a NVIDIA Jetson
El primer paso después de tener en tus manos un dispositivo NVIDIA Jetson es flashear NVIDIA JetPack en el dispositivo. Hay varias formas diferentes de flashear dispositivos NVIDIA Jetson.
- Si posees un Kit de Desarrollo oficial de NVIDIA, como el Kit de Desarrollo Jetson Orin Nano, puedes descargar una imagen y preparar una tarjeta SD con JetPack para arrancar el dispositivo.
- Si posee cualquier otro kit de desarrollo de NVIDIA, puede flashear JetPack al dispositivo usando SDK Manager.
- Si posee un dispositivo Seeed Studio reComputer J4012, puede flashear JetPack al SSD incluido, y si posee un dispositivo Seeed Studio reComputer J1020 v2, puede flashear JetPack a la eMMC/SSD.
- Si posee cualquier otro dispositivo de terceros alimentado por el módulo NVIDIA Jetson, se recomienda seguir el flasheo por línea de comandos.
Nota
Para los métodos 3 y 4 anteriores, después de flashear el sistema e iniciar el dispositivo, introduzca "sudo apt update && sudo apt install nvidia-jetpack -y" en el terminal del dispositivo para instalar todos los componentes restantes de JetPack necesarios.
Soporte de JetPack según el dispositivo Jetson
La siguiente tabla destaca las versiones de NVIDIA JetPack compatibles con diferentes dispositivos NVIDIA Jetson.
JetPack 4 | JetPack 5 | JetPack 6 | |
---|---|---|---|
Jetson Nano | ✅ | ❌ | ❌ |
Jetson TX2 | ✅ | ❌ | ❌ |
Jetson Xavier NX | ✅ | ✅ | ❌ |
Jetson AGX Xavier | ✅ | ✅ | ❌ |
Jetson AGX Orin | ❌ | ✅ | ✅ |
Jetson Orin NX | ❌ | ✅ | ✅ |
Jetson Orin Nano | ❌ | ✅ | ✅ |
Inicio rápido con Docker
La forma más rápida de empezar con Ultralytics YOLO11 en NVIDIA Jetson es ejecutar con imágenes Docker precompiladas para Jetson. Consulte la tabla anterior y elija la versión de JetPack según el dispositivo Jetson que posea.
t=ultralytics/ultralytics:latest-jetson-jetpack4
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t
t=ultralytics/ultralytics:latest-jetson-jetpack5
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t
t=ultralytics/ultralytics:latest-jetson-jetpack6
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t
Una vez hecho esto, vaya a la sección Usar TensorRT en NVIDIA Jetson.
Comenzar con la instalación nativa
Para una instalación nativa sin Docker, consulte los pasos siguientes.
Ejecutar en JetPack 6.1
Instalar el paquete Ultralytics
Aquí instalaremos el paquete Ultralytics en Jetson con dependencias opcionales para poder exportar los modelos de PyTorch a otros formatos diferentes. Nos centraremos principalmente en las exportaciones de NVIDIA TensorRT porque TensorRT se asegurará de que podamos obtener el máximo rendimiento de los dispositivos Jetson.
-
Actualizar la lista de paquetes, instalar pip y actualizar a la última versión
sudo apt update sudo apt install python3-pip -y pip install -U pip
-
Instalar
ultralytics
paquete pip con dependencias opcionalespip install ultralytics[export]
-
Reiniciar el dispositivo
sudo reboot
Instalar PyTorch y Torchvision
La instalación anterior de Ultralytics instalará Torch y Torchvision. Sin embargo, estos 2 paquetes instalados a través de pip no son compatibles para ejecutarse en la plataforma Jetson, que se basa en la arquitectura ARM64. Por lo tanto, necesitamos instalar manualmente la rueda pip de PyTorch precompilada y compilar/instalar Torchvision desde la fuente.
Instalar torch 2.5.0
y torchvision 0.20
de acuerdo con JP6.1
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.5.0a0+872d972e41.nv24.08-cp310-cp310-linux_aarch64.whl
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.20.0a0+afc54f7-cp310-cp310-linux_aarch64.whl
Nota
Visite la página de PyTorch para Jetson para acceder a todas las diferentes versiones de PyTorch para las diferentes versiones de JetPack. Para obtener una lista más detallada sobre la compatibilidad de PyTorch y Torchvision, visite la página de compatibilidad de PyTorch y Torchvision.
Instalar cuSPARSELt
para solucionar un problema de dependencia con torch 2.5.0
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/arm64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt-get update
sudo apt-get -y install libcusparselt0 libcusparselt-dev
Instalar onnxruntime-gpu
El onnxruntime-gpu el paquete alojado en PyPI no tiene aarch64
binarios para Jetson. Por lo tanto, necesitamos instalar este paquete manualmente. Este paquete es necesario para algunas de las exportaciones.
Puede encontrar todos los onnxruntime-gpu
paquetes, organizados por versión de JetPack, versión de Python y otros detalles de compatibilidad, en el Matriz de compatibilidad de Jetson Zoo con ONNX Runtime. Aquí descargaremos e instalaremos onnxruntime-gpu 1.20.0
con Python3.10
soporte.
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.20.0-cp310-cp310-linux_aarch64.whl
Nota
onnxruntime-gpu
automáticamente revertirá la versión de numpy a la última. Por lo tanto, necesitamos reinstalar numpy a 1.23.5
para solucionar un problema ejecutando:
pip install numpy==1.23.5
Ejecutar en JetPack 5.1.2
Instalar el paquete Ultralytics
Aquí instalaremos el paquete Ultralytics en Jetson con dependencias opcionales para que podamos exportar los modelos PyTorch a otros formatos diferentes. Nos centraremos principalmente en las exportaciones NVIDIA TensorRT porque TensorRT se asegurará de que podamos obtener el máximo rendimiento de los dispositivos Jetson.
-
Actualizar la lista de paquetes, instalar pip y actualizar a la última versión
sudo apt update sudo apt install python3-pip -y pip install -U pip
-
Instalar
ultralytics
paquete pip con dependencias opcionalespip install ultralytics[export]
-
Reiniciar el dispositivo
sudo reboot
Instalar PyTorch y Torchvision
La instalación anterior de Ultralytics instalará Torch y Torchvision. Sin embargo, estos 2 paquetes instalados a través de pip no son compatibles para ejecutarse en la plataforma Jetson, que se basa en la arquitectura ARM64. Por lo tanto, necesitamos instalar manualmente la rueda pip de PyTorch precompilada y compilar/instalar Torchvision desde la fuente.
-
Desinstalar PyTorch y Torchvision actualmente instalados
pip uninstall torch torchvision
-
Instalar
torch 2.2.0
ytorchvision 0.17.2
de acuerdo con JP5.1.2pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.2.0-cp38-cp38-linux_aarch64.whl pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.17.2+c1d70fe-cp38-cp38-linux_aarch64.whl
Nota
Visite la página de PyTorch para Jetson para acceder a todas las diferentes versiones de PyTorch para las diferentes versiones de JetPack. Para obtener una lista más detallada sobre la compatibilidad de PyTorch y Torchvision, visite la página de compatibilidad de PyTorch y Torchvision.
Instalar onnxruntime-gpu
El onnxruntime-gpu el paquete alojado en PyPI no tiene aarch64
binarios para Jetson. Por lo tanto, necesitamos instalar este paquete manualmente. Este paquete es necesario para algunas de las exportaciones.
Puede encontrar todos los onnxruntime-gpu
paquetes, organizados por versión de JetPack, versión de Python y otros detalles de compatibilidad, en el Matriz de compatibilidad de Jetson Zoo con ONNX Runtime. Aquí descargaremos e instalaremos onnxruntime-gpu 1.17.0
con Python3.8
soporte.
wget https://nvidia.box.com/shared/static/zostg6agm00fb6t5uisw51qi6kpcuwzd.whl -O onnxruntime_gpu-1.17.0-cp38-cp38-linux_aarch64.whl
pip install onnxruntime_gpu-1.17.0-cp38-cp38-linux_aarch64.whl
Nota
onnxruntime-gpu
automáticamente revertirá la versión de numpy a la última. Por lo tanto, necesitamos reinstalar numpy a 1.23.5
para solucionar un problema ejecutando:
pip install numpy==1.23.5
Usar TensorRT en NVIDIA Jetson
Entre todos los formatos de exportación de modelos compatibles con Ultralytics, TensorRT ofrece el mayor rendimiento de inferencia en dispositivos NVIDIA Jetson, lo que la convierte en nuestra principal recomendación para implementaciones en Jetson. Para obtener instrucciones de configuración y uso avanzado, consulte nuestra guía de integración de TensorRT.
Convertir el modelo a TensorRT y ejecutar la inferencia
El modelo YOLO11n en formato PyTorch se convierte a TensorRT para ejecutar la inferencia con el modelo exportado.
Ejemplo
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Export the model to TensorRT
model.export(format="engine") # creates 'yolo11n.engine'
# Load the exported TensorRT model
trt_model = YOLO("yolo11n.engine")
# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLO11n PyTorch model to TensorRT format
yolo export model=yolo11n.pt format=engine # creates 'yolo11n.engine'
# Run inference with the exported model
yolo predict model=yolo11n.engine source='https://ultralytics.com/images/bus.jpg'
Nota
Visite la página de exportación para acceder a argumentos adicionales al exportar modelos a diferentes formatos de modelo
Usar el Acelerador de Aprendizaje Profundo (DLA) de NVIDIA
NVIDIA Deep Learning Accelerator (DLA) es un componente de hardware especializado integrado en los dispositivos NVIDIA Jetson que optimiza la inferencia de aprendizaje profundo para la eficiencia energética y el rendimiento. Al descargar tareas de la GPU (liberándola para procesos más intensivos), DLA permite que los modelos se ejecuten con un menor consumo de energía manteniendo un alto rendimiento, ideal para sistemas integrados y aplicaciones de IA en tiempo real.
Los siguientes dispositivos Jetson están equipados con hardware DLA:
Dispositivo Jetson | Núcleos DLA | Frecuencia máxima de DLA |
---|---|---|
Jetson AGX Orin Series | 2 | 1.6 GHz |
Jetson Orin NX 16GB | 2 | 614 MHz |
Jetson Orin NX 8GB | 1 | 614 MHz |
Jetson AGX Xavier Series | 2 | 1.4 GHz |
Jetson Xavier NX Series | 2 | 1.1 GHz |
Ejemplo
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Export the model to TensorRT with DLA enabled (only works with FP16 or INT8)
model.export(format="engine", device="dla:0", half=True) # dla:0 or dla:1 corresponds to the DLA cores
# Load the exported TensorRT model
trt_model = YOLO("yolo11n.engine")
# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLO11n PyTorch model to TensorRT format with DLA enabled (only works with FP16 or INT8)
# Once DLA core number is specified at export, it will use the same core at inference
yolo export model=yolo11n.pt format=engine device="dla:0" half=True # dla:0 or dla:1 corresponds to the DLA cores
# Run inference with the exported model on the DLA
yolo predict model=yolo11n.engine source='https://ultralytics.com/images/bus.jpg'
Nota
Al utilizar las exportaciones de DLA, es posible que algunas capas no sean compatibles para ejecutarse en DLA y recurran a la GPU para su ejecución. Esta alternativa puede introducir latencia adicional e impactar el rendimiento general de la inferencia. Por lo tanto, DLA no está diseñado principalmente para reducir la latencia de la inferencia en comparación con TensorRT que se ejecuta completamente en la GPU. En cambio, su propósito principal es aumentar el rendimiento y mejorar la eficiencia energética.
Benchmarks de Ultralytics YOLO11 en NVIDIA Jetson Orin
El equipo de Ultralytics ejecutó benchmarks de YOLO11 en 10 formatos de modelo diferentes, midiendo la velocidad y la precisión: PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN. Los benchmarks se ejecutaron en NVIDIA Jetson AGX Orin Developer Kit (64GB), NVIDIA Jetson Orin Nano Super Developer Kit y Seeed Studio reComputer J4012 alimentado por el dispositivo Jetson Orin NX 16GB a precisión FP32 con un tamaño de imagen de entrada predeterminado de 640.
Gráficos comparativos
Aunque todas las exportaciones de modelos funcionan con NVIDIA Jetson, solo hemos incluido PyTorch, TorchScript, TensorRT para la tabla comparativa a continuación porque utilizan la GPU en Jetson y se garantiza que producirán los mejores resultados. Todas las demás exportaciones solo utilizan la CPU y el rendimiento no es tan bueno como los tres anteriores. Puede encontrar puntos de referencia para todas las exportaciones en la sección después de esta tabla.
NVIDIA Jetson AGX Orin Developer Kit (64GB)

NVIDIA Jetson Orin Nano Super Developer Kit

NVIDIA Jetson Orin NX 16GB

Tablas de comparación detalladas
La siguiente tabla representa los resultados de referencia para cinco modelos diferentes (YOLO11n, YOLO11s, YOLO11m, YOLO11l, YOLO11x) en diez formatos diferentes (PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN), lo que nos da el estado, el tamaño, la métrica mAP50-95(B) y el tiempo de inferencia para cada combinación.
NVIDIA Jetson AGX Orin Developer Kit (64GB)
Rendimiento
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 5.4 | 0.5101 | 9.40 |
TorchScript | ✅ | 10.5 | 0.5083 | 11.00 |
ONNX | ✅ | 10.2 | 0.5077 | 48.32 |
OpenVINO | ✅ | 10.4 | 0.5058 | 27.24 |
TensorRT (FP32) | ✅ | 12.1 | 0.5085 | 3.93 |
TensorRT (FP16) | ✅ | 8.3 | 0.5063 | 2.55 |
TensorRT (INT8) | ✅ | 5.4 | 0.4719 | 2.18 |
TF SavedModel | ✅ | 25.9 | 0.5077 | 66.87 |
TF GraphDef | ✅ | 10.3 | 0.5077 | 65.68 |
TF Lite | ✅ | 10.3 | 0.5077 | 272.92 |
MNN | ✅ | 10.1 | 0.5059 | 36.33 |
NCNN | ✅ | 10.2 | 0.5031 | 28.51 |
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 18.4 | 0.5783 | 12.10 |
TorchScript | ✅ | 36.5 | 0.5782 | 11.01 |
ONNX | ✅ | 36.3 | 0.5782 | 107.54 |
OpenVINO | ✅ | 36.4 | 0.5810 | 55.03 |
TensorRT (FP32) | ✅ | 38.1 | 0.5781 | 6.52 |
TensorRT (FP16) | ✅ | 21.4 | 0.5803 | 3.65 |
TensorRT (INT8) | ✅ | 12.1 | 0.5735 | 2.81 |
TF SavedModel | ✅ | 91.0 | 0.5782 | 132.73 |
TF GraphDef | ✅ | 36.4 | 0.5782 | 134.96 |
TF Lite | ✅ | 36.3 | 0.5782 | 798.21 |
MNN | ✅ | 36.2 | 0.5777 | 82.35 |
NCNN | ✅ | 36.2 | 0.5784 | 56.07 |
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 38.8 | 0.6265 | 22.20 |
TorchScript | ✅ | 77.3 | 0.6307 | 21.47 |
ONNX | ✅ | 76.9 | 0.6307 | 270.89 |
OpenVINO | ✅ | 77.1 | 0.6284 | 129.10 |
TensorRT (FP32) | ✅ | 78.8 | 0.6306 | 12.53 |
TensorRT (FP16) | ✅ | 41.9 | 0.6305 | 6.25 |
TensorRT (INT8) | ✅ | 23.2 | 0.6291 | 4.69 |
TF SavedModel | ✅ | 192.7 | 0.6307 | 299.95 |
TF GraphDef | ✅ | 77.1 | 0.6307 | 310.58 |
TF Lite | ✅ | 77.0 | 0.6307 | 2400.54 |
MNN | ✅ | 76.8 | 0.6308 | 213.56 |
NCNN | ✅ | 76.8 | 0.6284 | 141.18 |
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 49.0 | 0.6364 | 27.70 |
TorchScript | ✅ | 97.6 | 0.6399 | 27.94 |
ONNX | ✅ | 97.0 | 0.6409 | 345.47 |
OpenVINO | ✅ | 97.3 | 0.6378 | 161.93 |
TensorRT (FP32) | ✅ | 99.1 | 0.6406 | 16.11 |
TensorRT (FP16) | ✅ | 52.6 | 0.6376 | 8.08 |
TensorRT (INT8) | ✅ | 30.8 | 0.6208 | 6.12 |
TF SavedModel | ✅ | 243.1 | 0.6409 | 390.78 |
TF GraphDef | ✅ | 97.2 | 0.6409 | 398.76 |
TF Lite | ✅ | 97.1 | 0.6409 | 3037.05 |
MNN | ✅ | 96.9 | 0.6372 | 265.46 |
NCNN | ✅ | 96.9 | 0.6364 | 179.68 |
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 109.3 | 0.7005 | 44.40 |
TorchScript | ✅ | 218.1 | 0.6898 | 47.49 |
ONNX | ✅ | 217.5 | 0.6900 | 682.98 |
OpenVINO | ✅ | 217.8 | 0.6876 | 298.15 |
TensorRT (FP32) | ✅ | 219.6 | 0.6904 | 28.50 |
TensorRT (FP16) | ✅ | 112.2 | 0.6887 | 13.55 |
TensorRT (INT8) | ✅ | 60.0 | 0.6574 | 9.40 |
TF SavedModel | ✅ | 544.3 | 0.6900 | 749.85 |
TF GraphDef | ✅ | 217.7 | 0.6900 | 753.86 |
TF Lite | ✅ | 217.6 | 0.6900 | 6603.27 |
MNN | ✅ | 217.3 | 0.6868 | 519.77 |
NCNN | ✅ | 217.3 | 0.6849 | 298.58 |
Puesto a prueba con Ultralytics 8.3.157
Nota
El tiempo de inferencia no incluye el pre/post-procesamiento.
NVIDIA Jetson Orin Nano Super Developer Kit
Rendimiento
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 5.4 | 0.5101 | 13.70 |
TorchScript | ✅ | 10.5 | 0.5082 | 13.69 |
ONNX | ✅ | 10.2 | 0.5081 | 14.47 |
OpenVINO | ✅ | 10.4 | 0.5058 | 56.66 |
TensorRT (FP32) | ✅ | 12.0 | 0.5081 | 7.44 |
TensorRT (FP16) | ✅ | 8.2 | 0.5061 | 4.53 |
TensorRT (INT8) | ✅ | 5.4 | 0.4825 | 3.70 |
TF SavedModel | ✅ | 25.9 | 0.5077 | 116.23 |
TF GraphDef | ✅ | 10.3 | 0.5077 | 114.92 |
TF Lite | ✅ | 10.3 | 0.5077 | 340.75 |
MNN | ✅ | 10.1 | 0.5059 | 76.26 |
NCNN | ✅ | 10.2 | 0.5031 | 45.03 |
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 18.4 | 0.5790 | 20.90 |
TorchScript | ✅ | 36.5 | 0.5781 | 21.22 |
ONNX | ✅ | 36.3 | 0.5781 | 25.07 |
OpenVINO | ✅ | 36.4 | 0.5810 | 122.98 |
TensorRT (FP32) | ✅ | 37.9 | 0.5783 | 13.02 |
TensorRT (FP16) | ✅ | 21.8 | 0.5779 | 6.93 |
TensorRT (INT8) | ✅ | 12.2 | 0.5735 | 5.08 |
TF SavedModel | ✅ | 91.0 | 0.5782 | 250.65 |
TF GraphDef | ✅ | 36.4 | 0.5782 | 252.69 |
TF Lite | ✅ | 36.3 | 0.5782 | 998.68 |
MNN | ✅ | 36.2 | 0.5781 | 188.01 |
NCNN | ✅ | 36.2 | 0.5784 | 101.37 |
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 38.8 | 0.6266 | 46.50 |
TorchScript | ✅ | 77.3 | 0.6307 | 47.95 |
ONNX | ✅ | 76.9 | 0.6307 | 53.06 |
OpenVINO | ✅ | 77.1 | 0.6284 | 301.63 |
TensorRT (FP32) | ✅ | 78.8 | 0.6305 | 27.86 |
TensorRT (FP16) | ✅ | 41.7 | 0.6309 | 13.50 |
TensorRT (INT8) | ✅ | 23.2 | 0.6291 | 9.12 |
TF SavedModel | ✅ | 192.7 | 0.6307 | 622.24 |
TF GraphDef | ✅ | 77.1 | 0.6307 | 628.74 |
TF Lite | ✅ | 77.0 | 0.6307 | 2997.93 |
MNN | ✅ | 76.8 | 0.6299 | 509.96 |
NCNN | ✅ | 76.8 | 0.6284 | 292.99 |
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 49.0 | 0.6364 | 56.50 |
TorchScript | ✅ | 97.6 | 0.6409 | 62.51 |
ONNX | ✅ | 97.0 | 0.6399 | 68.35 |
OpenVINO | ✅ | 97.3 | 0.6378 | 376.03 |
TensorRT (FP32) | ✅ | 99.2 | 0.6396 | 35.59 |
TensorRT (FP16) | ✅ | 52.1 | 0.6361 | 17.48 |
TensorRT (INT8) | ✅ | 30.9 | 0.6207 | 11.87 |
TF SavedModel | ✅ | 243.1 | 0.6409 | 807.47 |
TF GraphDef | ✅ | 97.2 | 0.6409 | 822.88 |
TF Lite | ✅ | 97.1 | 0.6409 | 3792.23 |
MNN | ✅ | 96.9 | 0.6372 | 631.16 |
NCNN | ✅ | 96.9 | 0.6364 | 350.46 |
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 109.3 | 0.7005 | 90.00 |
TorchScript | ✅ | 218.1 | 0.6901 | 113.40 |
ONNX | ✅ | 217.5 | 0.6901 | 122.94 |
OpenVINO | ✅ | 217.8 | 0.6876 | 713.1 |
TensorRT (FP32) | ✅ | 219.5 | 0.6904 | 66.93 |
TensorRT (FP16) | ✅ | 112.2 | 0.6892 | 32.58 |
TensorRT (INT8) | ✅ | 61.5 | 0.6612 | 19.90 |
TF SavedModel | ✅ | 544.3 | 0.6900 | 1605.4 |
TF GraphDef | ✅ | 217.8 | 0.6900 | 2961.8 |
TF Lite | ✅ | 217.6 | 0.6900 | 8234.86 |
MNN | ✅ | 217.3 | 0.6893 | 1254.18 |
NCNN | ✅ | 217.3 | 0.6849 | 725.50 |
Puesto a prueba con Ultralytics 8.3.157
Nota
El tiempo de inferencia no incluye el pre/post-procesamiento.
NVIDIA Jetson Orin NX 16GB
Rendimiento
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 5.4 | 0.5101 | 12.90 |
TorchScript | ✅ | 10.5 | 0.5082 | 13.17 |
ONNX | ✅ | 10.2 | 0.5081 | 15.43 |
OpenVINO | ✅ | 10.4 | 0.5058 | 39.80 |
TensorRT (FP32) | ✅ | 11.8 | 0.5081 | 7.94 |
TensorRT (FP16) | ✅ | 8.1 | 0.5085 | 4.73 |
TensorRT (INT8) | ✅ | 5.4 | 0.4786 | 3.90 |
TF SavedModel | ✅ | 25.9 | 0.5077 | 88.48 |
TF GraphDef | ✅ | 10.3 | 0.5077 | 86.67 |
TF Lite | ✅ | 10.3 | 0.5077 | 302.55 |
MNN | ✅ | 10.1 | 0.5059 | 52.73 |
NCNN | ✅ | 10.2 | 0.5031 | 32.04 |
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 18.4 | 0.5790 | 21.70 |
TorchScript | ✅ | 36.5 | 0.5781 | 22.71 |
ONNX | ✅ | 36.3 | 0.5781 | 26.49 |
OpenVINO | ✅ | 36.4 | 0.5810 | 84.73 |
TensorRT (FP32) | ✅ | 37.8 | 0.5783 | 13.77 |
TensorRT (FP16) | ✅ | 21.2 | 0.5796 | 7.31 |
TensorRT (INT8) | ✅ | 12.0 | 0.5735 | 5.33 |
TF SavedModel | ✅ | 91.0 | 0.5782 | 185.06 |
TF GraphDef | ✅ | 36.4 | 0.5782 | 186.45 |
TF Lite | ✅ | 36.3 | 0.5782 | 882.58 |
MNN | ✅ | 36.2 | 0.5775 | 126.36 |
NCNN | ✅ | 36.2 | 0.5784 | 66.73 |
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 38.8 | 0.6266 | 45.00 |
TorchScript | ✅ | 77.3 | 0.6307 | 51.87 |
ONNX | ✅ | 76.9 | 0.6307 | 56.00 |
OpenVINO | ✅ | 77.1 | 0.6284 | 202.69 |
TensorRT (FP32) | ✅ | 78.7 | 0.6305 | 30.38 |
TensorRT (FP16) | ✅ | 41.8 | 0.6302 | 14.48 |
TensorRT (INT8) | ✅ | 23.2 | 0.6291 | 9.74 |
TF SavedModel | ✅ | 192.7 | 0.6307 | 445.58 |
TF GraphDef | ✅ | 77.1 | 0.6307 | 460.94 |
TF Lite | ✅ | 77.0 | 0.6307 | 2653.65 |
MNN | ✅ | 76.8 | 0.6308 | 339.38 |
NCNN | ✅ | 76.8 | 0.6284 | 187.64 |
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 49.0 | 0.6364 | 56.60 |
TorchScript | ✅ | 97.6 | 0.6409 | 66.72 |
ONNX | ✅ | 97.0 | 0.6399 | 71.92 |
OpenVINO | ✅ | 97.3 | 0.6378 | 254.17 |
TensorRT (FP32) | ✅ | 99.2 | 0.6406 | 38.89 |
TensorRT (FP16) | ✅ | 51.9 | 0.6363 | 18.59 |
TensorRT (INT8) | ✅ | 30.9 | 0.6207 | 12.60 |
TF SavedModel | ✅ | 243.1 | 0.6409 | 575.98 |
TF GraphDef | ✅ | 97.2 | 0.6409 | 583.79 |
TF Lite | ✅ | 97.1 | 0.6409 | 3353.41 |
MNN | ✅ | 96.9 | 0.6367 | 421.33 |
NCNN | ✅ | 96.9 | 0.6364 | 228.26 |
Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 109.3 | 0.7005 | 98.50 |
TorchScript | ✅ | 218.1 | 0.6901 | 123.03 |
ONNX | ✅ | 217.5 | 0.6901 | 129.55 |
OpenVINO | ✅ | 217.8 | 0.6876 | 483.44 |
TensorRT (FP32) | ✅ | 219.6 | 0.6904 | 75.92 |
TensorRT (FP16) | ✅ | 112.1 | 0.6885 | 35.78 |
TensorRT (INT8) | ✅ | 61.6 | 0.6592 | 21.60 |
TF SavedModel | ✅ | 544.3 | 0.6900 | 1120.43 |
TF GraphDef | ✅ | 217.7 | 0.6900 | 1172.35 |
TF Lite | ✅ | 217.6 | 0.6900 | 7283.63 |
MNN | ✅ | 217.3 | 0.6877 | 840.16 |
NCNN | ✅ | 217.3 | 0.6849 | 474.41 |
Puesto a prueba con Ultralytics 8.3.157
Nota
El tiempo de inferencia no incluye el pre/post-procesamiento.
Explore más pruebas de rendimiento de Seeed Studio que se ejecutan en diferentes versiones de hardware NVIDIA Jetson.
Reproducir nuestros resultados
Para reproducir los benchmarks de Ultralytics anteriores en todos los formatos de exportación, ejecute este código:
Ejemplo
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Benchmark YOLO11n speed and accuracy on the COCO128 dataset for all all export formats
results = model.benchmark(data="coco128.yaml", imgsz=640)
# Benchmark YOLO11n speed and accuracy on the COCO128 dataset for all all export formats
yolo benchmark model=yolo11n.pt data=coco128.yaml imgsz=640
Tenga en cuenta que los resultados de los benchmarks pueden variar según la configuración exacta de hardware y software de un sistema, así como la carga de trabajo actual del sistema en el momento en que se ejecutan los benchmarks. Para obtener los resultados más fiables, utilice un conjunto de datos con un gran número de imágenes, es decir, data='coco.yaml'
(5000 imágenes de validación).
Mejores prácticas al usar NVIDIA Jetson
Cuando se utiliza NVIDIA Jetson, hay una serie de prácticas recomendadas que se deben seguir para habilitar el máximo rendimiento en NVIDIA Jetson ejecutando YOLO11.
-
Habilitar el modo de máxima potencia (MAX Power Mode)
Habilitar el modo de máxima potencia en Jetson asegurará que todos los núcleos de la CPU y la GPU estén activados.
sudo nvpmodel -m 0
-
Habilitar los relojes de Jetson (Jetson Clocks)
Habilitar los relojes de Jetson asegurará que todos los núcleos de la CPU y la GPU estén sincronizados a su frecuencia máxima.
sudo jetson_clocks
-
Instalar la aplicación Jetson Stats
Podemos utilizar la aplicación Jetson Stats para supervisar las temperaturas de los componentes del sistema y comprobar otros detalles del sistema, como ver la utilización de la CPU, la GPU y la RAM, cambiar los modos de energía, establecer los relojes máximos y comprobar la información de JetPack.
sudo apt update sudo pip install jetson-stats sudo reboot jtop
Próximos pasos
¡Enhorabuena por configurar correctamente YOLO11 en su NVIDIA Jetson! Para obtener más información y soporte, visite más guías en Ultralytics YOLO11 Docs.
Preguntas frecuentes
¿Cómo implemento Ultralytics YOLO11 en dispositivos NVIDIA Jetson?
El despliegue de Ultralytics YOLO11 en dispositivos NVIDIA Jetson es un proceso sencillo. En primer lugar, flashee su dispositivo Jetson con el SDK NVIDIA JetPack. A continuación, utilice una imagen Docker preconstruida para una configuración rápida o instale manualmente los paquetes necesarios. En las secciones Inicio rápido con Docker e Inicio con la instalación nativa encontrará los pasos detallados para cada enfoque.
¿Qué benchmarks de rendimiento puedo esperar de los modelos YOLO11 en dispositivos NVIDIA Jetson?
Los modelos YOLO11 han sido evaluados en varios dispositivos NVIDIA Jetson, mostrando mejoras significativas en el rendimiento. Por ejemplo, el formato TensorRT ofrece el mejor rendimiento de inferencia. La tabla en la sección Tablas de comparación detalladas proporciona una visión completa de las métricas de rendimiento como mAP50-95 y el tiempo de inferencia en diferentes formatos de modelo.
¿Por qué debería usar TensorRT para implementar YOLO11 en NVIDIA Jetson?
TensorRT es muy recomendable para desplegar modelos YOLO11 en NVIDIA Jetson debido a su rendimiento óptimo. Acelera la inferencia aprovechando las capacidades de la GPU de Jetson, garantizando la máxima eficiencia y velocidad. Obtenga más información sobre cómo convertir a TensorRT y ejecutar la inferencia en la sección Usar TensorRT en NVIDIA Jetson.
¿Cómo puedo instalar PyTorch y Torchvision en NVIDIA Jetson?
Para instalar PyTorch y Torchvision en NVIDIA Jetson, primero desinstale cualquier versión existente que pueda haber sido instalada a través de pip. A continuación, instale manualmente las versiones compatibles de PyTorch y Torchvision para la arquitectura ARM64 de Jetson. En la sección Instalar PyTorch y Torchvision se proporcionan instrucciones detalladas para este proceso.
¿Cuáles son las mejores prácticas para maximizar el rendimiento en NVIDIA Jetson al usar YOLO11?
Para maximizar el rendimiento en NVIDIA Jetson con YOLO11, siga estas prácticas recomendadas:
- Habilite el modo de máxima potencia para utilizar todos los núcleos de la CPU y la GPU.
- Habilite los relojes de Jetson para ejecutar todos los núcleos a su frecuencia máxima.
- Instale la aplicación Jetson Stats para supervisar las métricas del sistema.
Para obtener comandos y detalles adicionales, consulte la sección Prácticas recomendadas al utilizar NVIDIA Jetson.