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
:::nota 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:
- reComputer J1010 | J101
- reComputer J2021 | J202
- reComputer J1020 | A206
- reComputer J4012 | J401
- A203 Carrier Board
- A205 Carrier Board
- Jetson Xavier AGX H01 Kit
- Jetson AGX Orin 32GB H01 Kit
:::nota 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
:::nota 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.
- Object Detection
- Image Classification
- Image Segmentation
- Pose Estimation
- Object Tracking
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
| Model | size (pixels) | mAPval 50-95 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
|---|---|---|---|---|---|---|
| YOLOv8n | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
| YOLOv8s | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
| YOLOv8m | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
| YOLOv8l | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
| YOLOv8x | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.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
:::nota Si encuentras algún error al ejecutar los comandos anteriores, intenta agregar "device = 0" al final del comando. :::
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.
YOLOv8 ofrece 5 tamaños de modelo PyTorch pre entrenados para clasificación de imágenes, entrenados en ImageNet con un tamaño de imagen de entrada de 224x224. Puedes encontrarlos a continuación
| Model | size (pixels) | acc top1 | acc top5 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) at 640 |
|---|---|---|---|---|---|---|---|
| YOLOv8n-cls | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 |
| YOLOv8s-cls | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 |
| YOLOv8m-cls | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 |
| YOLOv8l-cls | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 |
| YOLOv8x-cls | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
Referencia: https://docs.ultralytics.com/tasks/classify
Puedes elegir el modelo que desees y ejecutar el siguiente comando para ejecutar la inferencia en una imagen
yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' show=True
Aquí, para el modelo, puedes cambiar a yolov8s-cls.pt, yolov8m-cls.pt, yolov8l-cls.pt, yolov8x-cls.pt y descargará el modelo previamente entrenado correspondiente.
También puedes conectar una cámara web y ejecutar el siguiente comando
yolo classify predict model=yolov8n-cls.pt source='0' show=True
:::nota Si encuentras algún error al ejecutar los comandos anteriores, intenta agregar "device = 0" al final del comando. :::
(update with 224 inference)
:::nota Lo anterior se ejecuta en una reComputer J4012/reComputer Industrial J4012 y utiliza el modelo YOLOv8s-cls entrenado con entrada de 224x224 y utiliza precisión TensorRT FP16. Además, asegúrate de pasar el argumento imgsz=224 dentro del comando de inferencia con las exportaciones de TensorRT porque el motor de inferencia acepta un tamaño de imagen de 640 de forma predeterminada cuando se usan modelos de TensorRT. :::
YOLOv8 ofrece 5 tamaños de modelo PyTorch pre entrenados para la segmentación de imágenes, entrenados en un conjunto de datos COCO con un tamaño de imagen de entrada de 640x640. Puedes encontrarlos a continuación
| Model | size (pixels) | mAPbox 50-95 | mAPmask 50-95 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|
| YOLOv8n-seg | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 |
| YOLOv8s-seg | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 |
| YOLOv8m-seg | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 |
| YOLOv8l-seg | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 |
| YOLOv8x-seg | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
Referencia: https://docs.ultralytics.com/tasks/segment
Puedes elegir el modelo que desees y ejecutar el siguiente comando para ejecutar la inferencia en una imagen
yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' show=True
Aquí, para el modelo, puedes cambiar a yolov8s-seg.pt, yolov8m-seg.pt, yolov8l-seg.pt, yolov8x-seg.pt y descargará el modelo previamente entrenado correspondiente.
También puedes conectar una cámara web y ejecutar el siguiente comando
yolo segment predict model=yolov8n-seg.pt source='0' show=True
:::nota Si encuentras algún error al ejecutar los comandos anteriores, intenta agregar "device = 0" al final del comando. :::
:::nota Lo anterior se ejecuta en una reComputer J4012/reComputer Industrial J4012 y utiliza el modelo YOLOv8s-seg entrenado con entrada de 640x640 con una precisión TensorRT FP16. :::
YOLOv8 ofrece 6 tamaños de modelo PyTorch pre entrenados para la estimación de pose, entrenados en un conjunto de datos de puntos clave COCO con un tamaño de imagen de entrada de 640x640. Puedes encontrarlos a continuación
| Model | size (pixels) | mAPpose 50-95 | mAPpose 50 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|
| YOLOv8n-pose | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 |
| YOLOv8s-pose | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 |
| YOLOv8m-pose | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 |
| YOLOv8l-pose | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 |
| YOLOv8x-pose | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 |
| YOLOv8x-pose-p6 | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 |
Referencia: https://docs.ultralytics.com/tasks/pose
Puedes elegir el modelo que desees y ejecutar el siguiente comando para ejecutar la inferencia en una imagen
yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg'
Aquí, para el modelo, puedes cambiar a yolov8s-pose.pt, yolov8m-pose.pt, yolov8l-pose.pt, yolov8x-pose.pt, yolov8x-pose-p6 y descargará el modelo previamente entrenado correspondiente.
También puedes conectar una cámara web y ejecutar el siguiente comando
yolo pose predict model=yolov8n-pose.pt source='0'
:::nota Si encuentras algún error al ejecutar los comandos anteriores, intenta agregar "device = 0" al final del comando. :::
El seguimiento de objetos es una tarea que implica identificar la ubicación y la clase de objetos y luego asignar una identificación única a esa detección en transmisiones de video.
Básicamente, el resultado del seguimiento de objetos es el mismo que el de la detección de objetos con un ID de objeto agregada.
Referencia: https://docs.ultralytics.com/modes/track
Puedes elegir el modelo que desees en función de detección de objetos/segmentación de imágenes y ejecutar el siguiente comando para ejecutar la inferencia en un vídeo.
yolo track model=yolov8n.pt source="https://youtu.be/Zgi9g1ksQHc"
Aquí, para el modelo, puedes cambiar a yolov8n.pt, yolov8s.pt, yolov8m.pt, yolov8l.pt, yolov8x.pt, yolov8n-seg.pt, yolov8s-seg.pt, yolov8m-seg.pt, yolov8l-seg.pt, yolov8x-seg.pt, y descargará el modelo previamente entrenado correspondiente.
También puedes conectar una cámara web y ejecutar el siguiente comando
yolo track model=yolov8n.pt source="0"
:::nota Si encuentras algún error al ejecutar los comandos anteriores, intenta agregar "device = 0" al final del comando. :::
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.
:::nota 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
:::nota 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
| Key | Value | Description |
|---|---|---|
| imgsz | 640 | Image size as scalar or (h, w) list, i.e. (640, 480) |
| half | False | FP16 quantization |
| dynamic | False | Dynamic axes |
| simplify | False | Simplify model |
| workspace | 4 | Workspace 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.
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.
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.
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.
- Ultralytics HUB + Roboflow + Google Colab
- Roboflow + Google Colab
- Roboflow + Local PC
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
Aquí utilizamos un entorno de Google Colab para correr el entrenamiento en la nube. Además, utilizamos la API de Roboflow dentro de Colab para descargar fácilmente nuestro conjunto de datos.
- Paso 1. Haz click aquí para abrir un espacio de trabajo de Google Colab ya preparado y seguir los pasos mencionados en esta wiki
Una vez finalizadao el entrenamiento, verás el siguiente resultado:
- Paso 2. En la pestaña "Files", si navegas hasta
runs/train/exp/weights, verás un archivo llamado best.pt. Este es el modelo generado a partir del entrenamiento. Descarga este archivo y cópialo en tu dispositivo Jetson porque este es el modelo que usaremos más adelante para inferir en el dispositivo Jetson.
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
Aquí puedes utilizar una PC con sistema operativo Linux para entrenar. Hemos utilizado una PC con Ubuntu 20.04 para esta wiki.
- Paso 1. Instala pip si no lo tienes en tu sistema
sudo apt install python3-pip -y
- Paso 2. Instala Ultralytics y todas sus dependencias
pip install ultralytics
- Paso 3. En Roboflow, dentro de tu proyecto, ve a Versions, selecciona Export Dataset, selecciona Format como YOLOv8, elije donwload zip to computer y haz click en Continue
Paso 4. Extrae el contenido del archivo .zip
Paso 5. Ejecuta lo siguiente para comenzar a entrenar. Aquí debes reemplazar path_to_yaml con la ubicación del archivo .yaml que se encuentra dentro del archivo zip extraído antes.
yolo train data=<path_to_yaml> model=yolov8s.pt epochs=100 imgsz=640 batch=-1
:::nota Aquí el tamaño de la imagen se establece en 640x640. Usamos el tamaño de lote como -1 porque eso determinará automáticamente el mejor tamaño de lote. También puedes cambiar la cantidad de épocas según tus preferencias. Aquí puedes cambiar el modelo pre entrenado a cualquier modelo de detección, segmentación, clasificación y pose. :::
Una vez finalizado el entrenamiento, verás el siguiente resultado:
- Paso 6. En runs/detect/train/weights*, versá un archivo llamado best.pt. Este es el modelo generado a partir del entrenamiento. Descarga este archivo y cópialo en tu dispositivo Jetson porque este es el modelo que usaremos más adelante para inferir en el dispositivo Jetson.
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.