Skip to main content

Desplegar YOLOv8 en NVIDIA Jetson usando TensorRT

Esta guía wiki explica cómo desplegar un modelo YOLOv8 en la plataforma NVIDIA Jetson y realizar inferencia usando TensorRT. Aquí usamos TensorRT para maximizar el rendimiento de inferencia en la plataforma Jetson.

Se introducirán diferentes tareas 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

Prerrequisitos​

  • PC Host Ubuntu (nativo o VM usando VMware Workstation Player)
  • reComputer Jetson o cualquier otro dispositivo NVIDIA Jetson ejecutando JetPack 5.1.1 o superior
note

Esta wiki ha sido probada y verificada en un reComputer J4012 y reComputer Industrial J4012[https://www.seeedstudio.com/reComputer-Industrial-J4012-p-5684.html] alimentado por el módulo NVIDIA Jetson orin NX 16GB

Flashear JetPack a Jetson​

Ahora necesitas asegurarte de que el dispositivo Jetson esté flasheado con un sistema JetPack. Puedes usar NVIDIA SDK Manager o línea de comandos para flashear JetPack al dispositivo.

Para las guías de flasheo de dispositivos Seeed alimentados por Jetson, consulta los siguientes enlaces:

note

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

¡Desplegar YOLOV8 a Jetson en Una Línea de Código!​

Después de flashear el dispositivo Jetson con JetPack, simplemente puedes ejecutar los siguientes comandos para ejecutar modelos YOLOv8. Esto primero descargará e instalará los paquetes necesarios, dependencias, configurará el entorno y descargará modelos preentrenados 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í

Usar modelos pre-entrenados​

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

YOLOv8 ofrece 5 pesos de modelos PyTorch pre-entrenados para detección de objetos, entrenados en el conjunto de datos COCO con tamaño de imagen de entrada de 640x640. Puedes encontrarlos a continuación

Modelotamaño
(píxeles)		mAPval
50-95		Velocidad
CPU ONNX
(ms)		Velocidad
A100 TensorRT
(ms)		parámetros
(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 tu modelo deseado de la tabla anterior y ejecutar el siguiente comando para ejecutar 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 pre-entrenado relevante

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 añadir "device=0" al final del comando

note

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

Usar TensorRT para Mejorar la Velocidad de Inferencia​

Como mencionamos antes, si quieres mejorar la velocidad de inferencia en el Jetson ejecutando modelos YOLOv8, primero necesitas convertir los modelos PyTorch originales a modelos TensorRT.

Sigue los pasos a continuación para convertir modelos PyTorch YOLOv8 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. Por favor ten paciencia hasta que la exportación de TensorRT termine. Puede tomar unos minutos

Después de que el archivo del modelo TensorRT (.engine) sea creado, verás la salida como sigue

  • Paso 2. Si quieres pasar argumentos adicionales, puedes hacerlo siguiendo la tabla de abajo
ClaveValorDescripción
imgsz640Tamaño de imagen como escalar o lista (h, w), ej. (640, 480)
halfFalseCuantización FP16
dynamicFalseEjes dinámicos
simplifyFalseSimplificar modelo
workspace4Tamaño del espacio de trabajo (GB)

Por ejemplo, si quieres convertir tu modelo PyTorch en un modelo TensorRT con cuantización FP16, ejecuta como

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

Una vez que el modelo se exporta exitosamente, 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, con detección de objetos:

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

Trae Tu Propio Modelo de IA​

Recolección y Etiquetado de Datos​

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

Si no quieres recopilar datos por ti mismo, también puedes elegir conjuntos de datos públicos que están fácilmente disponibles. Puedes descargar una serie de conjuntos de datos disponibles públicamente como el conjunto de datos COCO, conjunto de datos Pascal VOC y muchos 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 construir modelos de visión por computadora. Además, puedes simplemente buscar conjuntos de datos de código abierto en Google y elegir entre una variedad de conjuntos de datos disponibles.

Si tienes tu propio conjunto de datos y quieres anotar las imágenes, te recomendamos usar la herramienta de anotación proporcionada por Roboflow. Por favor sigue esta parte del wiki para aprender más sobre ello. También puedes seguir esta guía de Roboflow sobre anotación.

Entrenamiento​

Aquí tenemos 3 métodos para entrenar un modelo.

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

  2. La segunda forma sería usar un espacio de trabajo de Google Colab creado por nosotros para hacer el proceso de entrenamiento más fácil. Aquí usamos la API de Roboflow para descargar el conjunto de datos del proyecto de Roboflow.

  3. La tercera forma sería usar una PC local para el proceso de entrenamiento. Aquí necesitas asegurarte de tener una GPU lo suficientemente potente y también necesitas 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 una cuenta de Ultralytics

  • Paso 2. Una vez que inicies sesión con la cuenta recién creada, serás recibido con el siguiente panel de control

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

  • Paso 4. Una vez que inicies sesión con la cuenta recién creada, serás recibido con el siguiente panel de control

  • Paso 5. Crea un nuevo espacio de trabajo y crea un nuevo proyecto bajo el espacio de trabajo siguiendo esta guía del wiki que hemos preparado. También puedes revisar aquí para aprender más de la documentación oficial de Roboflow.

  • Paso 6. Una vez que tengas un par de proyectos dentro de tu espacio de trabajo, se verá como abajo

  • Paso 7. Ve a Settings y haz clic en Roboflow API
  • Paso 8. Haz clic en el botón copy para copiar la Private API Key
  • Paso 9. Regresa al panel de control de Ultralytics HUB, haz clic en Integrations, pega la API Key que copiamos antes en la columna vacía y haz clic en Add
  • Paso 10 Si ves el nombre de tu espacio de trabajo listado, eso significa que la integración fue exitosa
  • Paso 11 Navega a Datasets y verás todos tus proyectos de Roboflow aquí
  • Paso 12 Haz clic en un proyecto para revisar más sobre el conjunto de datos. Aquí he seleccionado un conjunto de datos que puede detectar manzanas sanas y dañadas
  • Paso 13 Haz clic en Train Model
  • Paso 14 Selecciona la Architecture, establece un Model name (opcional) y luego haz clic en Continue. Aquí hemos seleccionado YOLOv8s como la arquitectura del modelo
  • Paso 15 Bajo Advanced options, configura los ajustes según tu preferencia, copia y pega el código de Colab (esto se pegará más tarde en el espacio de trabajo de Colab) y luego haz clic en Open Google Colab
  • Paso 16 Inicia sesión en tu cuenta de Google si no has iniciado sesión ya
  • Paso 17 Navega a Runtime > Change runtime type
  • Paso 18 Selecciona GPU bajo Hardware accelerator, el más alto disponible bajo GPU type y haz clic en Save
  • Paso 19 Haz clic en Connect
  • Paso 20 Haz clic en el botón RAM, Disk para revisar el uso de recursos de hardware
  • Paso 21 Haz clic en el botón Play para ejecutar la primera celda de código
  • Paso 22 Pega la celda de código que copiamos de Ultralytics HUB antes bajo la sección Start y ejecútala para comenzar el entrenamiento
  • Paso 23 Ahora si regresas a Ultralytics HUB, verás el mensaje Connected. Haz clic en Done
  • Paso 24 Aquí verás Box Loss, Class Loss y Object Loss en tiempo real mientras el modelo se entrena en Google Colab
  • Paso 25 Después de que termine el entrenamiento, verás la siguiente salida en Google Colab
  • Paso 26 Ahora regresa a Ultralytics HUB, ve a la pestaña Preview y sube una imagen de prueba para verificar cómo está funcionando el modelo entrenado
  • Paso 26 Finalmente ve a la pestaña Deploy y descarga el modelo entrenado en el formato que prefieras para hacer inferencia con YOLOv8. Aquí hemos elegido PyTorch.

Ahora puedes usar este modelo descargado con las tareas que hemos explicado en este wiki anteriormente. Solo necesitas reemplazar el archivo del modelo con tu modelo.

Por ejemplo:

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

Benchmarks de Rendimiento​

Preparación​

Hemos realizado benchmarks de rendimiento para todas las tareas de visión por computadora soportadas por YOLOv8 ejecutándose en reComputer J4012/ reComputer Industrial J4012 alimentado por el módulo NVIDIA Jetson Orin NX 16GB.

Incluido en el directorio de muestras hay una herramienta de línea de comandos llamada trtexec. trtexec es una herramienta para usar TensorRT sin tener que desarrollar tu propia aplicación. La herramienta trtexec tiene tres propósitos principales:

  • Hacer benchmarks de redes con datos de entrada aleatorios o proporcionados por el usuario.
  • Generar motores serializados a partir de modelos.
  • Generar una caché de tiempo serializada desde el constructor.

Aquí podemos usar la herramienta trtexec para hacer benchmarks rápidamente de los modelos con diferentes parámetros. Pero primero que nada, necesitas tener un modelo onnx y podemos generar este modelo onnx usando ultralytics yolov8.

  • Paso 1. Construir ONNX usando:
yolo mode=export model=yolov8s.pt format=onnx
  • Paso 2. Construye 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 como se muestra a continuación junto con un archivo .engine generado. Por defecto convertirá ONNX a un archivo optimizado TensorRT en precisión FP32 y puedes ver la salida como sigue

Si quieres precisión FP16 que ofrece mejor rendimiento que FP32, puedes ejecutar el comando anterior como sigue

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

Sin embargo, si deseas precisión INT8 que ofrece 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 obtenemos de las cuatro tareas de visión por computadora ejecutándose en reComputer J4012/ reComputer Industrial J4012.

Demo Adicional: Detector y Contador de Ejercicios con YOLOv8​

Hemos construido una aplicación demo de estimación de pose para detección y conteo de ejercicios con YOLOv8 usando el modelo YOLOv8-Pose. Puedes revisar el proyecto aquí para aprender más sobre esta demo y desplegarla en tu propio dispositivo Jetson!

Configuración Manual de YOLOv8 para NVIDIA Jetson​

Si el script de una línea que mencionamos anteriormente tiene algunos errores, puedes seguir los pasos a continuación uno por uno para preparar el dispositivo Jetson con YOLOv8.

Instalar el Paquete 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. Instalar el paquete Ultralytics
pip3 install ultralytics
  • Paso 3. Actualizar la versión de numpy a la más reciente
pip3 install numpy -U
  • Paso 4. Reinicia el dispositivo
sudo reboot

Desinstalar 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 la plataforma Jetson que está basada en arquitectura ARM aarch64. Por lo tanto, necesitamos instalar manualmente la rueda pip de PyTorch pre-construida y compilar/instalar Torchvision desde el código fuente.

pip3 uninstall torch torchvision

Instalar PyTorch y Torchvision​

Visita esta página para acceder a todos los enlaces de PyTorch y Torchvision.

Aquí tienes algunas de las versiones compatibles con JetPack 5.0 y superior.

PyTorch v2.0.0

Compatible con JetPack 5.1 (L4T R35.2.1) / JetPack 5.1.1 (L4T R35.3.1) con Python 3.8

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

PyTorch v1.13.0

Compatible con 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) con Python 3.8

nombre_archivo: 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. Instala torch según tu versión de 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 dependiendo de la versión de PyTorch que hayas instalado. Por ejemplo, elegimos PyTorch v2.0.0, lo que significa que necesitamos 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í tienes una lista de las versiones correspondientes de torchvision que necesitas instalar según la versión de PyTorch:

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

Si quieres una lista más detallada, por favor consulta este enlace.

Instalar ONNX y Degradar Numpy​

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

  • Paso 1. Instala ONNX que es un requisito
pip3 install onnx
  • Paso 2. Degradar a una versión inferior de Numpy para corregir un error
pip3 install numpy==1.20.3

Recursos​

Soporte Técnico y Discusión de Productos​

¡Gracias por elegir nuestros productos! Estamos aquí para brindarle diferentes tipos de soporte para asegurar que su experiencia con nuestros productos sea lo más fluida posible. Ofrecemos varios canales de comunicación para satisfacer diferentes preferencias y necesidades.

Loading Comments...