Skip to main content

Despliegue de YOLOv8 en dispositivos NVIDIA Jetson utilizando TensorRT

Esta wiki explica cómo implementar un modelo YOLOv8 en dispositivos NVIDIA Jetson y realizar inferencias usando TensorRT. Aquí utilizamos TensorRT para maximizar el rendimiento de inferencia en el dispositivo Jetson.

Se presentarán diferentes sistemas de visión por computadora, como:

  • Detección de objetos
  • Segmentación de imágenes
  • Clasificación de imágenes
  • Estimación de pose
  • Seguimiento de objetos

Prerequisitos​

  • PC con Ubuntu OS(nativo o en máquina virtual)
  • reComputer Jetson o cualquier otro dispositivo NVIDIA Jetson corriendo JetPack 4.6 o superior
note

En esta wiki verificamos en funcionamiento en la reComputer J4012 y la reComputer Industrial J4012[https://www.seeedstudio.com/reComputer-Industrial-J4012-p-5684.html] impulsadas por el modulo NVIDIA Jetson orin NX 16GB

Flashear JetPack en la Jetson​

Ahora debes asegurarte de que el dispositivo Jetson esté actualizado con un sistema JetPack. Puedes utilizar NVIDIA SDK Manager o la línea de comandos para actualizar JetPack al dispositivo.

Para obtener guías de actualización de dispositivos impulsados ​​por Seeed Jetson, consulta los enlaces a continuación:

note

Asegúrate de actualizar JetPack versión 5.1.1 porque esa es la versión que hemos verificado para esta wiki.

Despliegue de YOLOV8 en dispositivos Jetson ¡En una sola línea de código!​

Después de actualizar el dispositivo Jetson con JetPack, puedes simplemente ejecutar los siguientes comandos para ejecutar los modelos YOLOv8. Esto primero descargará e instalará los paquetes y dependencias necesarios, configurará el entorno y descargará modelos previamente entrenados de YOLOv8 para realizar tareas de detección de objetos, segmentación de imágenes, estimación de pose y clasificación de imágenes.

wget files.seeedstudio.com/YOLOv8-Jetson.py && python YOLOv8-Jetson.py
note

El código fuente del script anterior se puede encontrar aquí

Utilizar modelos pre entrenados​

La forma más rápida de comenzar con YOLOv8 es utilizar modelos pre entrenados proporcionados por YOLOv8. Sin embargo, estos son modelos de PyTorch y, por lo tanto, solo utilizarán la CPU al inferir en Jetson. Si deseas obtener el mejor rendimiento de estos modelos en Jetson mientras se ejecuta en la GPU, puedes exportar los modelos de PyTorch a TensorRT siguiendo esta sección de la wiki.

YOLOv8 ofrece 5 tamaños de modelo PyTorch pre entrenados para la detección de objetos, entrenados en un conjunto de datos COCO con un tamaño de imagen de entrada de 640x640. Puedes encontrarlos a continuación

Modelsize
(pixels)		mAPval
50-95		Speed
CPU ONNX
(ms)		Speed
A100 TensorRT
(ms)		params
(M)		FLOPs
(B)
YOLOv8n64037.380.40.993.28.7
YOLOv8s64044.9128.41.2011.228.6
YOLOv8m64050.2234.71.8325.978.9
YOLOv8l64052.9375.22.3943.7165.2
YOLOv8x64053.9479.13.5368.2257.8

Referencia: https://docs.ultralytics.com/tasks/detect

Puedes elegir y descargar el modelo que desees de la tabla anterior y ejecutar el siguiente comando para ejecutar la inferencia en una imagen.

yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' show=True

Aquí, para el modelo, puedes cambiar a yolov8s.pt, yolov8m.pt, yolov8l.pt, yolov8x.pt y descargará el modelo previamente entrenado correspondiente.

También puedes conectar una cámara web y ejecutar el siguiente comando

yolo detect predict model=yolov8n.pt source='0' show=True
note

Si encuentras algún error al ejecutar los comandos anteriores, intenta agregar "device = 0" al final del comando.

note

Lo anterior se ejecuta en una reComputer J4012/reComputer Industrial J4012 y utiliza el modelo YOLOv8s entrenado con entrada de 640x640 con una precisión TensorRT FP16.

Utilizar TensorRT para mejorar la velocidad de inferencia​

Como mencionamos antes, si deseas mejorar la velocidad de inferencia de la Jetson que ejecuta modelos YOLOv8, primero debes convertir los modelos PyTorch originales a modelos TensorRT.

Sigue los siguientes pasos para convertir modelos YOLOv8 PyTorch a modelos TensorRT.

note

Esto funciona para las cuatro tareas de visión por computadora que hemos mencionado antes.

  • Paso 1. Ejecuta el comando de exportación especificando la ruta del modelo
yolo export model=<path_to_pt_file> format=engine device=0

Por ejemplo:

yolo export model=yolov8n.pt format=engine device=0
note

Si encuentras un error sobre cmake, puedes ignorarlo. Ten paciencia hasta que finalice la exportación de TensorRT. Puede que tarde unos minutos

Después de crear el archivo de modelo TensorRT (.engine), verás el siguiente resultado

  • Paso 2. Si deseas pasar argumentos adicionales, puedes hacerlo siguiendo la siguiente tabla
KeyValueDescription
imgsz640Image size as scalar or (h, w) list, i.e. (640, 480)
halfFalseFP16 quantization
dynamicFalseDynamic axes
simplifyFalseSimplify model
workspace4Workspace size (GB)

Por ejemplo, si deseas convertir tu modelo PyTorch en un modelo TensorRT en la cuantización FP16, ejecuta el siguiente comando:

yolo export model=yolov8n.pt format=engine half=True device=0

Una vez que el modelo se exporta correctamente, puedes reemplazar directamente este modelo con el argumento model= dentro del comando predict de yolo al ejecutar las 4 tareas de detección, clasificación, segmentación y estimación de pose.

Por ejemplo, para detección de objetos, el comando luciría así:

yolo detect predict model=yolov8n.engine source='0' show=True

Genera tu propio modelo de inteligencia artificial​

Generación de conjunto de datos y etiquetado​

Si tienes una aplicación de IA específica y deseas generar tu propio modelo de IA que sea adecuado para tu aplicación, puedes recopila tu propio conjunto de datos, etiquetarlos y luego entrenar tu modelo usando YOLOv8.

Si no deseas recopilar datos tu mismo, también puedes elegir conjuntos de datos públicos que estén disponibles. Puedes descargar varios conjuntos de datos disponibles públicamente, como el [conjunto de datos COCO] (https://cocodataset.org), el [conjunto de datos Pascal VOC] (http://host.robots.ox.ac.uk/pascal/VOC) y mucho más. Roboflow Universe es una plataforma recomendada que proporciona una amplia gama de conjuntos de datos y tiene más de 90.000 conjuntos de datos con más de 66 millones de imágenes disponibles para crear modelos de visión por computadora. Además, puedes simplemente buscar conjuntos de datos de código abierto en Google y elegir entre una amplia variedad de conjuntos de datos disponibles.

Si tienes tu propio conjunto de datos y deseas etiquetar las imágenes, te recomendamos utilizar la herramienta de etiquetado proporcionada por Roboflow. Sigue esta parte de la wiki para obtener más información al respecto. También puedes seguir esta guía de Roboflow sobre etiquetado.

Entrenamiento​

Aquí tenemos tres métodos disponibles para entrenar tu modelo.

  1. La primera forma sería utilizar Ultralytics HUB. Puedes integrar fácilmente Roboflow en Ultralytics HUB para que todos tus proyectos de Roboflow estén disponibles para entrenamiento. Aquí se ofrece un cuaderno de Google Colab para iniciar fácilmente el proceso de entrenamiento y también ver el progreso del mismo en tiempo real.

  2. La segunda forma sería utilizar un espacio de trabajo de Google Colab creado por nosotros para facilitar el proceso de entrenamiento. Aquí utilizamos la API de Roboflow para descargar el conjunto de datos del proyecto en Roboflow.

  3. La tercera forma sería utilizar una PC local para el proceso de entrenamiento. Aquí debes asegurarte de tener una GPU lo suficientemente potente y también descargar manualmente el conjunto de datos.

Aquí usamos Ultralytics HUB para cargar el proyecto de Roboflow y luego entrenar en Google Colab.

  • Paso 1. Visita esta URL y regístrate para obtener una cuenta de Ultralytics.

  • Paso 2. Una vez que inicies sesión con la cuenta recién creada, verás el siguiente panel:

  • Paso 3. Visita esta URL y regístrate para obtener una cuenta de Roboflow

  • Paso 4. Una vez que inicies sesión con la cuenta recién creada, verás el siguiente panel:

  • Paso 5. Crea un nuevo espacio de trabajo y un nuevo proyecto siguiendo esta wiki que hemos preparado. También puedes consultar aquí para obtener más información en la documentación oficial de Roboflow.

  • Paso 6. Una vez que tengas un par de proyectos dentro de tu espacio de trabajo, lucirá como se muestra a continuación

  • Paso 7. Ve a Settings y haz click en Roboflow API
  • Paso 8. Haz click en el botón copy para copiar la Private API KEY
  • Paso 9. Vuelve al panel de Ultralytics HUB, haz click en Integrations, pega la clave API que copiaste antes en la columna vacía y haz click en Add
  • Paso 10 Si ves el nombre de tu espacio de trabajo en la lista, significa que la integración se realizó correctamente.
  • Paso 11 Navegua hasta datasets y verás todos tus proyectos de Roboflow aquí
  • Paso 12 Haz click en un proyecto para obtener más información sobre el conjunto de datos. Aquí he seleccionado un conjunto de datos que puede detectar manzanas sanas y dañadas.
  • Paso 13 Haz Click en Train Model
  • Paso 14 Selecciona Architecture, establece un Model name (optional) (Nombre del modelo (opcional)) y luego haz click en Continue. Aquí hemos seleccionado YOLOv8s como arquitectura modelo.
  • Paso 15 En Advanced Options, configura los ajustes según tus preferencias, copia y pega el código de Colab (esto se pegará más tarde en el espacio de trabajo de Colab) y luego haz click en Open Google Colab
  • Paso 16 Inicia sesión en tu cuenta de Google si aún no lo has hecho
  • Paso 17 Ve a Runtime > Change runtime type
  • Paso 18 Seleccione GPU en Hardware accelerator, el más alto disponible en GPU Type y haz click en Save
  • Paso 19 Haz click Connect
  • Paso 20 Haz click en el botón RAM, Disk para revisar la utilización de hardware.
  • Paso 21 Haz click en el botón Play para correr la primera celda de código
  • Paso 22 Pega la celda de código que copiamos antes de Ultralytics HUB en la sección Start y ejecútala para comenzar a entrenar.
  • Paso 23 Ahora, si regresas a Ultralytics HUB, verás el mensaje Connected. Haz click en Done
  • Paso 24 Aquí verás Box loss, Class loss y Object loss (Pérdida de caja, pérdida de clase y pérdida de objeto respectivamente) en tiempo real mientras el modelo se entrena en Google Colab.
  • Paso 25 Una vez finalizado el entrenamiento, verás el siguiente resultado en Google Colab
  • Paso 26 Ahora regresa a Ultralytics HUB, ve a la pestaña Preview y carga una imagen de prueba para comprobar cómo se está desempeñando el modelo entrenado.
  • Paso 26 Finalmente, ve a la pestaña Deploy y descarga el modelo entrenado en el formato que prefieras para la inferencia con YOLOv8. Aquí hemos elegido PyTorch.

Ahora puedes utilizar este modelo descargado con las tareas que hemos explicado anteriormente en esta wiki. Sólo necesitas reemplazar el archivo del modelo con tu modelo.

Por ejemplo:

yolo detect predict model=<your_model.pt> source='0' show=True

Puntos de referencia de rendimiento​

Preparación​

Hemos realizado pruebas comparativas de rendimiento para todas las tareas de visión por computadora compatibles con YOLOv8 que se ejecutan en la reComputer J4012/reComputer Industrial J4012 con tecnología del módulo NVIDIA Jetson Orin NX de 16 GB.

En el directorio de ejemplos se incluye una herramienta contenedora de línea de comandos llamada trtexec. trtexec es una herramienta para utilizar TensorRT sin tener que desarrollar tu propia aplicación. La herramienta trtexec tiene tres propósitos principales:

  • Comparación de redes con datos de entrada aleatorios o proporcionados por el usuario.
  • Generación de motores serializados a partir de modelos.
  • Generar un caché de tiempo serializado desde el compilador.

Aquí podemos usar la herramienta trtexec para comparar rápidamente los modelos con diferentes parámetros. Pero antes que nada, es necesario tener un modelo onnx y podemos generar este modelo onnx utilizando ultralytics yolov8.

  • Paso 1. Compilar ONNX usando:
yolo mode=export model=yolov8s.pt format=onnx
  • Paso 2. Crea el archivo del motor usando trtexec de la siguiente manera:
cd /usr/src/tensorrt/bin
./trtexec --onnx=<path_to_onnx_file> --saveEngine=<path_to_save_engine_file>

Por ejemplo:

./trtexec --onnx=/home/nvidia/yolov8s.onnx --saveEngine=/home/nvidia/yolov8s.engine

Esto generará resultados de rendimiento de la siguiente manera junto con un archivo .engine generado. De forma predeterminada, convertirá ONNX a un archivo optimizado para TensorRT con precisión FP32 y podrás ver el resultado de la siguiente manera

Si deseas precisión de FP16 que ofrece un mejor rendimiento que FP32, puedes ejecutar el comando anterior de la siguiente manera

./trtexec --onnx=/home/nvidia/yolov8s.onnx --fp16 --saveEngine=/home/nvidia/yolov8s.engine

Sin embargo, si deseas una precisión INT8 que ofrezca un mejor rendimiento que FP16, puedes ejecutar el comando anterior de la siguiente manera

./trtexec --onnx=/home/nvidia/yolov8s.onnx --int8 --saveEngine=/home/nvidia/yolov8s.engine

Resultados​

A continuación, resumimos los resultados que obtuvimso de las cuatro tareas de visión por computadora que se ejecutaron en la reComputer J4012/reComputer Industrial J4012.

Demostración adicional: detector y contador de ejercicio con YOLOv8​

Hemos creado una aplicación de demostración que estima la pose de un usuario para detectar ejercicios y llevar conteos basada en YOLOv8 utilizando el modelo YOLOv8-Pose. Puedes consultar el proyecto aquí para obtener más información sobre esta demostración e implementarla en tu propio dispositivo Jetson.

Configuración manual de YOLOv8 para NVIDIA Jetson​

Si el script de una línea que mencionamos antes tiene algunos errores, puedes seguir los siguientes pasos uno por uno para preparar el dispositivo Jetson con YOLOv8.

Instalar Ultralytics​

  • Paso 1. Accede a la terminal del dispositivo Jetson, instala pip y actualízalo
sudo apt update
sudo apt install -y python3-pip -y
pip3 install --upgrade pip
  • Paso 2. Instala Ultralytics
pip3 install ultralytics
  • Paso 3. Actualiza a la última versión de Numpy
pip3 install numpy -U
  • Paso 4. Reinicia el dispositivo
sudo reboot

Desinstala torch y torchvision​

La instalación de ultralytics anterior instalará Torch y Torchvision. Sin embargo, estos 2 paquetes instalados a través de pip no son compatibles para ejecutarse en el dispositivo Jetson que se basa en la arquitectura ARM aarch64. Por lo tanto, necesitamos instalar manualmente la pip PyTorch Wheel prediseñada y compilar/instalar Torchvision desde la fuente.

pip3 uninstall torch torchvision

Instalar PyTorch y Torchvision​

Visita está página para acceder a toda la información de PyTorch y torchvision

Estas son algunas de las versiones compatibles con JetPack 5.0 y superiores.

PyTorch v2.0.0

Supported by JetPack 5.1 (L4T R35.2.1) / JetPack 5.1.1 (L4T R35.3.1) with Python 3.8

file_name: torch-2.0.0+nv23.05-cp38-cp38-linux_aarch64.whl URL: https://nvidia.box.com/shared/static/i8pukc49h3lhak4kkn67tg9j4goqm0m7.whl

PyTorch v1.13.0

Supported by JetPack 5.0 (L4T R34.1) / JetPack 5.0.2 (L4T R35.1) / JetPack 5.1 (L4T R35.2.1) / JetPack 5.1.1 (L4T R35.3.1) with Python 3.8

file_name: torch-1.13.0a0+d0d6b1f2.nv22.10-cp38-cp38-linux_aarch64.whl URL: https://developer.download.nvidia.com/compute/redist/jp/v502/pytorch/torch-1.13.0a0+d0d6b1f2.nv22.10-cp38-cp38-linux_aarch64.whl

  • Paso 1. Instalar Torch según tu versión JetPack en el siguiente formato pip3
wget <URL> -O <file_name>
pip3 install <file_name>

Por ejemplo, aquí estamos ejecutando JP5.1.1 y por lo tanto elegimos PyTorch v2.0.0

sudo apt-get install -y libopenblas-base libopenmpi-dev
wget https://nvidia.box.com/shared/static/i8pukc49h3lhak4kkn67tg9j4goqm0m7.whl -O torch-2.0.0+nv23.05-cp38-cp38-linux_aarch64.whl
pip3 install torch-2.0.0+nv23.05-cp38-cp38-linux_aarch64.whl
  • Paso 2. Instala torchvision según la versión de PyTorch que tengas instalada. Por ejemplo, elegimos PyTorch v2.0.0, lo que significa que debemos elegir Torchvision v0.15.2.
sudo apt install -y libjpeg-dev zlib1g-dev
git clone https://github.com/pytorch/vision torchvision
cd torchvision
git checkout v0.15.2
python3 setup.py install --user

Aquí hay una lista de las versiones correspondientes de torchvision que necesitas instalar de acuerdo con la versión de PyTorch:

  • PyTorch v2.0.0 - torchvision v0.15
  • PyTorch v1.13.0 - torchvision v0.14

Si necesitas una lista más detallada por favor revisa este link.

Instalar ONNX y Desactualizar Numpy​

Esto solo es necesario si deseas convertir los modelos de PyTorch a TensorRT.

  • Paso 1. Instalar ONNX
pip3 install onnx
  • Paso 2. Deactualizar a una versión anterior de Numpy para arreglar cualquier bug
pip3 install numpy==1.20.3

Recursos​

Soporte Tech y discusión del producto​

¡Gracias por elegir nuestros productos! Estamos aquí para darte soporte y asegurar que tu experiencia con nuestros productos sea la mejor posible. Tenemos diversos canales de comunicación para adaptarnos distintas preferencias y necesidades.

Loading Comments...