Saltar al contenido

Guía de inicio rápido: NVIDIA Jetson con Ultralytics YOLOv8

Esta completa guía proporciona un recorrido detallado para implantar Ultralytics YOLOv8 en dispositivos NVIDIA Jetson. Además, presenta pruebas de rendimiento para demostrar las capacidades de YOLOv8 en estos pequeños y potentes dispositivos.

Ecosistema NVIDIA Jetson

Nota

This guide has been tested with both Seeed Studio reComputer J4012 which is based on NVIDIA Jetson Orin NX 16GB running the latest stable JetPack release of JP5.1.3 and Seeed Studio reComputer J1020 v2 which is based on NVIDIA Jetson Nano 4GB running JetPack release of JP4.6.1. It is expected to work across all the NVIDIA Jetson hardware lineup including latest and legacy.

¿Qué es NVIDIA Jetson?

NVIDIA Jetson es una serie de placas de computación integradas diseñadas para llevar la computación acelerada de la IA (inteligencia artificial) a los dispositivos periféricos. Estos dispositivos compactos y potentes se basan en la arquitectura de 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 recursos de 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 en las que la inferencia de IA debe realizarse localmente con baja latencia y alta eficiencia. Además, estas placas se basan en la arquitectura ARM64 y consumen menos energía que los dispositivos tradicionales de GPU Computing.

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. En la tabla siguiente se comparan algunos de los dispositivos Jetson del ecosistema.

Jetson AGX Orin 64 GB Jetson Orin NX 16GB Jetson Orin Nano 8GB Jetson AGX Xavier Jetson Xavier NX Jetson Nano
Rendimiento de la IA 275 TOPS 100 TOPS 40 TOPs 32 TOPS 21 TOPS 472 GFLOPS
GPU GPU de arquitectura NVIDIA Ampere de 2048 núcleos con 64 Tensor Cores GPU de arquitectura NVIDIA Ampere de 1024 núcleos con 32 Tensor Cores GPU de arquitectura NVIDIA Ampere de 1024 núcleos con 32 Tensor Cores GPU de 512 núcleos de arquitectura NVIDIA Volta con 64 núcleos Tensor GPU de arquitectura NVIDIA Volta™ de 384 núcleos con 48 Tensor Cores GPU de arquitectura NVIDIA Maxwell™ de 128 núcleos
Frecuencia máxima GPU 1,3 GHz 918 MHz 625 MHz 1377 MHz 1100 MHz 921MHz
CPU CPU de 12 núcleos NVIDIA Arm® Cortex A78AE v8.2 de 64 bits 3MB L2 + 6MB L3 CPU de 8 núcleos NVIDIA Arm® Cortex A78AE v8.2 64 bits 2MB L2 + 4MB L3 CPU Arm® Cortex®-A78AE v8.2 de 64 bits de 6 núcleos 1,5 MB L2 + 4 MB L3 CPU de 64 bits NVIDIA Carmel Arm®v8.2 de 8 núcleos 8 MB L2 + 4 MB L3 CPU de 6 núcleos NVIDIA Carmel Arm®v8.2 de 64 bits 6MB L2 + 4MB L3 Procesador MPCore Arm® Cortex®-A57 de cuatro núcleos
Frecuencia máxima de la CPU 2,2 GHz 2,0 GHz 1,5 GHz 2,2 GHz 1,9 GHz 1,43 GHz
Memoria 64 GB LPDDR5 de 256 bits 204,8 GB/s 16 GB LPDDR5 de 128 bits 102,4 GB/s 8 GB LPDDR5 de 128 bits 68 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 ver una tabla comparativa más detallada, visita la sección Especificaciones técnicas de la página oficial de NVIDIA Jetson.

¿Qué es NVIDIA JetPack?

El SDK JetPack de NVIDIA que impulsa los módulos Jetson es la solución más completa y proporciona un entorno de desarrollo completo para crear aplicaciones de IA aceleradas de extremo a extremo y acorta el tiempo de comercialización. JetPack incluye Jetson Linux con gestor de arranque, kernel Linux, entorno de escritorio Ubuntu y un conjunto completo de librerías para la aceleración del GPU computing, multimedia, gráficos y visión computerizada. También incluye muestras, documentación y herramientas para desarrolladores, tanto para el ordenador central como para el kit de desarrollador, y es compatible con SDK de nivel superior como DeepStream para análisis de vídeo en streaming, Isaac para robótica y Riva para IA conversacional.

Flash JetPack a NVIDIA Jetson

El primer paso tras hacerte con un dispositivo NVIDIA Jetson es flashear NVIDIA JetPack al dispositivo. Hay varias formas diferentes de flashear dispositivos NVIDIA Jetson.

  1. If you own an official NVIDIA Development Kit such as the Jetson Orin Nano Developer Kit, you can download an image and prepare an SD card with JetPack for booting the device.
  2. If you own any other NVIDIA Development Kit, you can flash JetPack to the device using SDK Manager.
  3. If you own a Seeed Studio reComputer J4012 device, you can flash JetPack to the included SSD and if you own a Seeed Studio reComputer J1020 v2 device, you can flash JetPack to the eMMC/ SSD.
  4. If you own any other third party device powered by the NVIDIA Jetson module, it is recommended to follow command-line flashing.

Nota

Para los métodos 3 y 4 anteriores, después de flashear el sistema y arrancar el dispositivo, introduce "sudo apt update && sudo apt install nvidia-jetpack -y" en el terminal del dispositivo para instalar el resto de componentes de JetPack necesarios.

Run on JetPack 5.x

If you own a Jetson Xavier NX, AGX Xavier, AGX Orin, Orin Nano or Orin NX which supports JetPack 5.x, you can continue to follow this guide. However, if you have a legacy device such as Jetson Nano, please skip to Run on JetPack 4.x.

Configurar Ultralytics

Hay dos formas de configurar el paquete Ultralytics en NVIDIA Jetson para construir tu próximo proyecto de Visión por Computador. Puedes utilizar cualquiera de ellas.

Empieza con Docker

La forma más rápida de empezar a utilizar Ultralytics YOLOv8 en NVIDIA Jetson es ejecutar con una imagen docker preconstruida para Jetson.

Ejecuta el siguiente comando para extraer el contenedor Docker y ejecutarlo en Jetson. Se basa en la imagen docker l4t-pytorch que contiene PyTorch y Torchvision en un entorno Python3.

t=ultralytics/ultralytics:latest-jetson-jetpack5 && sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t

Una vez hecho esto, pasa a la sección Utilizar TensorRT en NVIDIA Jetson.

Empezar sin Docker

Instala el paquete Ultralytics

Here we will install Ultralytics package on the Jetson with optional dependencies so that we can export the PyTorch models to other different formats. We will mainly focus on NVIDIA TensorRT exports because TensorRT will make sure we can get the maximum performance out of the Jetson devices.

  1. 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
    
  2. Instala ultralytics paquete pip con dependencias opcionales

    pip install ultralytics[export]
    
  3. Reinicia el dispositivo

    sudo reboot
    
Instala PyTorch y Torchvision

La instalación anterior de ultralytics instalará Torch y Torchvision. Sin embargo, estos 2 paquetes instalados mediante pip no son compatibles para ejecutarse en la plataforma Jetson, basada en la arquitectura ARM64. Por lo tanto, tenemos que instalar manualmente PyTorch pip wheel y compilar/instalar Torchvision desde el código fuente.

  1. Desinstala PyTorch y Torchvision instalados actualmente

    pip uninstall torch torchvision
    
  2. Instala PyTorch 2.1.0 según JP5.1.3

    sudo apt-get install -y libopenblas-base libopenmpi-dev
    wget https://developer.download.nvidia.com/compute/redist/jp/v512/pytorch/torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl -O torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl
    pip install torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl
    
  3. Instala Torchvision v0.16.2 según PyTorch v2.1.0

    sudo apt install -y libjpeg-dev zlib1g-dev
    git clone https://github.com/pytorch/vision torchvision
    cd torchvision
    git checkout v0.16.2
    python3 setup.py install --user
    

Visita la páginaPyTorch para Jetson para acceder a todas las versiones de PyTorch para las distintas versiones de JetPack. Para obtener una lista más detallada sobre la compatibilidad de PyTorchy Torchvision, visita la página de compatibilidad dePyTorch y Torchvision.

Instala onnxruntime-gpu

En onnxruntime-gpu alojado en PyPI no tiene aarch64 binarios para la Jetson. Así que tenemos que instalar manualmente este paquete. Este paquete es necesario para algunas de las exportaciones.

Todos diferentes onnxruntime-gpu packages corresponding to different JetPack and Python versions are listed aquí. Sin embargo, aquí descargaremos e instalaremos onnxruntime-gpu 1.17.0 con Python3.8 para el JetPack que utilizamos en esta guía.

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 revertirá automáticamente la versión de numpy a la última. Así que tenemos que reinstalar numpy a 1.23.5 para solucionar un problema ejecutando:

pip install numpy==1.23.5

Run on JetPack 4.x

Here we support to run Ultralytics on legacy hardware such as the Jetson Nano. Currently we use Docker to achieve this.

Execute the below command to pull the Docker container and run on Jetson. This is based on l4t-cuda docker image which contains CUDA in a L4T environment.

t=ultralytics/ultralytics:latest-jetson-jetpack4 && sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t

Utiliza TensorRT en NVIDIA Jetson

De todos los formatos de exportación de modelos admitidos por Ultralytics, TensorRT ofrece el mejor rendimiento de inferencia cuando se trabaja con dispositivos NVIDIA Jetson y nuestra recomendación es utilizar TensorRT con Jetson. También tenemos un documento detallado sobre TensorRT aquí.

Convierte el modelo a TensorRT y ejecuta la inferencia

El modelo YOLOv8n en formato PyTorch se convierte a TensorRT para ejecutar la inferencia con el modelo exportado.

Ejemplo

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Export the model
model.export(format="engine")  # creates 'yolov8n.engine'

# Load the exported TensorRT model
trt_model = YOLO("yolov8n.engine")

# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLOv8n PyTorch model to TensorRT format
yolo export model=yolov8n.pt format=engine  # creates 'yolov8n.engine'

# Run inference with the exported model
yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'

Nota

Visita la página Exportar para acceder a argumentos adicionales al exportar modelos a diferentes formatos de modelo

Benchmarks NVIDIA Jetson Orin YOLOv8

YOLOv8 benchmarks were run by the Ultralytics team on 10 different model formats measuring speed and accuracy: PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, PaddlePaddle, NCNN. Benchmarks were run on Seeed Studio reComputer J4012 powered by Jetson Orin NX 16GB device at FP32 precision with default input image size of 640.

Cuadro comparativo

Even though all model exports are working with NVIDIA Jetson, we have only included PyTorch, TorchScript, TensorRT for the comparison chart below because, they make use of the GPU on the Jetson and are guaranteed to produce the best results. All the other exports only utilize the CPU and the performance is not as good as the above three. You can find benchmarks for all exports in the section after this chart.

Ecosistema NVIDIA Jetson

Tabla comparativa detallada

The below table represents the benchmark results for five different models (YOLOv8n, YOLOv8s, YOLOv8m, YOLOv8l, YOLOv8x) across ten different formats (PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, PaddlePaddle, NCNN), giving us the status, size, mAP50-95(B) metric, and inference time for each combination.

Rendimiento

Formato Estado Tamaño en disco (MB) mAP50-95(B) Tiempo de inferencia (ms/im)
PyTorch ✅ 6.2 0.6381 14.3
TorchScript ✅ 12.4 0.6117 13.3
ONNX ✅ 12.2 0.6092 70.6
OpenVINO ✅ 12.3 0.6092 104.2
TensorRT ✅ 13.6 0.6117 8.9
TF SavedModel ✅ 30.6 0.6092 141.74
TF GraphDef ✅ 12.3 0.6092 199.93
TF Lite ✅ 12.3 0.6092 349.18
PaddlePaddle ✅ 24.4 0.6030 555
NCNN ✅ 12.2 0.6092 32
Formato Estado Tamaño en disco (MB) mAP50-95(B) Tiempo de inferencia (ms/im)
PyTorch ✅ 21.5 0.6967 18
TorchScript ✅ 43.0 0.7136 23.81
ONNX ✅ 42.8 0.7136 185.55
OpenVINO ✅ 42.9 0.7136 243.97
TensorRT ✅ 44.0 0.7136 14.82
TF SavedModel ✅ 107 0.7136 260.03
TF GraphDef ✅ 42.8 0.7136 423.4
TF Lite ✅ 42.8 0.7136 1046.64
PaddlePaddle ✅ 85.5 0.7140 1464
NCNN ✅ 42.7 0.7200 63
Formato Estado Tamaño en disco (MB) mAP50-95(B) Tiempo de inferencia (ms/im)
PyTorch ✅ 49.7 0.7370 36.4
TorchScript ✅ 99.2 0.7285 53.58
ONNX ✅ 99 0.7280 452.09
OpenVINO ✅ 99.1 0.7280 544.36
TensorRT ✅ 100.3 0.7285 33.21
TF SavedModel ✅ 247.5 0.7280 543.65
TF GraphDef ✅ 99 0.7280 906.63
TF Lite ✅ 99 0.7280 2758.08
PaddlePaddle ✅ 197.9 0.7280 3678
NCNN ✅ 98.9 0.7260 135
Formato Estado Tamaño en disco (MB) mAP50-95(B) Tiempo de inferencia (ms/im)
PyTorch ✅ 83.7 0.7768 61.3
TorchScript ✅ 167.2 0.7554 87.9
ONNX ✅ 166.8 0.7551 852.29
OpenVINO ✅ 167 0.7551 1012.6
TensorRT ✅ 168.4 0.7554 51.23
TF SavedModel ✅ 417.2 0.7551 990.45
TF GraphDef ✅ 166.9 0.7551 1649.86
TF Lite ✅ 166.9 0.7551 5652.37
PaddlePaddle ✅ 333.6 0.7551 7114.67
NCNN ✅ 166.8 0.7685 231.9
Formato Estado Tamaño en disco (MB) mAP50-95(B) Tiempo de inferencia (ms/im)
PyTorch ✅ 130.5 0.7759 93
TorchScript ✅ 260.7 0.7472 135.1
ONNX ✅ 260.4 0.7479 1296.13
OpenVINO ✅ 260.6 0.7479 1502.15
TensorRT ✅ 261.8 0.7469 84.53
TF SavedModel ✅ 651.1 0.7479 1451.76
TF GraphDef ✅ 260.5 0.7479 4029.36
TF Lite ✅ 260.4 0.7479 8772.86
PaddlePaddle ✅ 520.8 0.7479 10619.53
NCNN ✅ 260.4 0.7646 376.38

Explore more benchmarking efforts by Seeed Studio running on different versions of NVIDIA Jetson hardware.

Reproducir nuestros resultados

Para reproducir las pruebas anteriores de Ultralytics en todos los formatos de exportación, ejecuta este código:

Ejemplo

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all all export formats
results = model.benchmarks(data="coco8.yaml", imgsz=640)
# Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all all export formats
yolo benchmark model=yolov8n.pt data=coco8.yaml imgsz=640

Ten en cuenta que los resultados de las pruebas comparativas pueden variar en función de la configuración exacta de hardware y software de un sistema, así como de la carga de trabajo actual del sistema en el momento de ejecutar las pruebas comparativas. Para obtener resultados más fiables, utiliza un conjunto de datos con un gran número de imágenes, es decir data='coco8.yaml' (4 val images), ordata='coco.yaml'` (5000 imágenes val).

Buenas prácticas al utilizar NVIDIA Jetson

Cuando utilices NVIDIA Jetson, hay un par de buenas prácticas que debes seguir para conseguir el máximo rendimiento en NVIDIA Jetson ejecutando YOLOv8.

  1. Activar el modo de potencia MAX

    Activando el Modo MAX Power en el Jetson te asegurarás de que todos los núcleos de la CPU y la GPU están encendidos.

    sudo nvpmodel -m 0
    
  2. Activar los Relojes Jetson

    Si activas los Relojes Jetson, te asegurarás de que todos los núcleos de la CPU y la GPU estén sincronizados a su frecuencia máxima.

    sudo jetson_clocks
    
  3. Instalar la aplicación Jetson Stats

    Podemos utilizar la aplicación jetson stats para controlar las temperaturas de los componentes del sistema y comprobar otros detalles del sistema, como ver la utilización de la CPU, GPU y RAM, cambiar los modos de energía, ajustar los relojes al máximo, comprobar la información de JetPack

    sudo apt update
    sudo pip install jetson-stats
    sudo reboot
    jtop
    

Estadísticas Jetson

Próximos pasos

¡Enhorabuena por haber configurado con éxito YOLOv8 en tu NVIDIA Jetson! ¡Para más aprendizaje y soporte, visita más guías en Ultralytics YOLOv8 Docs!



Created 2024-04-02, Updated 2024-06-11
Authors: lakshanthad (3), Ahelsamahy (1), glenn-jocher (7), Burhan-Q (2)

Comentarios