Despliegue de YOLOv8 en NVIDIA Jetson usando TensorRT y DeepStream SDK Support

Esta guía explica cómo implementar un modelo de IA entrenado, corriendo en un dispositivo NVIDIA Jetson y realizar inferencias utilizando TensorRT y DeepStream SDK. Aquí utilizamos TensorRT para maximizar el rendimiento de inferencia el dispositivo Jetson.

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

Versión de DeepStream correspondiente a la versión de JetPack

Para que YOLOv8 funcione junto con DeepStream, estamos usando este repositorio DeepStram-YOLO y admite diferentes versiones de DeepStream. Así que asegúrate de utilizar la versión correcta de JetPack de acuerdo a la versión correcta de DeepStream.

DeepStream Version	JetPack Version
6.2	5.1.1
	5.1
6.1.1	5.0.2
6.1	5.0.1 DP
6.0.1	4.6.3
	4.6.2
	4.6.1
6.0	4.6

Para verificar este wiki, hemos instalado DeepStream SDK 6.2 en un sistema JetPack 5.1.1 que se ejecuta en la reComputer J4012.

Flashear JetPack a la Jetson

Ahora debes asegurarte de que el dispositivo Jetson esté actualizado con un sistema JetPack que incluya componentes SDK como CUDA, TensorRT, cuDNN y más. Puedes utilizar NVIDIA SDK Manager o la línea de comandos para actualizar JetPack en el 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

Instalar DeepStream

Hay varias formas de instalar DeepStream en el dispositivo Jetson. Puedes seguir esta guía para obtener más información. Sin embargo, te recomendamos que instales DeepStream a través del SDK Manager porque puede garantizar una instalación sencilla y exitosa.

Si instalas DeepStream usando el administrador de SDK, debes ejecutar los siguientes comandos, que son dependencias adicionales para DeepStream, después de que se inicie el sistema.

sudo apt install \
libssl1.1 \
libgstreamer1.0-0 \
gstreamer1.0-tools \
gstreamer1.0-plugins-good \
gstreamer1.0-plugins-bad \
gstreamer1.0-plugins-ugly \
gstreamer1.0-libav \
libgstreamer-plugins-base1.0-dev \
libgstrtspserver-1.0-0 \
libjansson4 \
libyaml-cpp-dev

Instalar paquetes necesarios

• Paso 1. Accede a la terminal del dispositivo Jetson, instala pip y actualízalo

sudo apt update
sudo apt install -y python3-pip
pip3 install --upgrade pip

• Paso 2. Clona el siguiente repositorio:

git clone https://github.com/ultralytics/ultralytics.git

• Paso 3. Abre el archivo requirements.txt

cd ultralytics
vi requirements.txt

• Paso 4. Edita las siguientes líneas. Aquí debes presionar i primero para ingresar al modo de edición. Presiona ESC, luego escribe :wq para guardar y salir

# torch>=1.7.0
# torchvision>=0.8.1

Nota: torch y torchvision están excluidos por ahora porque se instalarán más adelante.

• Paso 5. Instalar los paquetes necesarios

pip3 install -r requirements.txt

Si el instalador marca como desactualizado el paquete python-dateutil actualízalo con el siguiente comando:

pip3 install python-dateutil --upgrade

Instalar PyTorch y Torchvision

No podemos instalar PyTorch y Torchvision desde pip porque no son compatibles para ejecutarse en la plataforma 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.

Visita esta página Para acceder a todos los links de PyTorch y Torchvision.

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

PyTorch v1.11.0

Supported by JetPack 5.0 (L4T R34.1.0) / JetPack 5.0.1 (L4T R34.1.1) / JetPack 5.0.2 (L4T R35.1.0) with Python 3.8

file_name: torch-1.11.0-cp38-cp38-linux_aarch64.whl URL: https://nvidia.box.com/shared/static/ssf2v7pf5i245fk4i0q926hy4imzs2ph.whl

PyTorch v1.12.0

Supported by JetPack 5.0 (L4T R34.1.0) / JetPack 5.0.1 (L4T R34.1.1) / JetPack 5.0.2 (L4T R35.1.0) with Python 3.8

file_name: torch-1.12.0a0+2c916ef.nv22.3-cp38-cp38-linux_aarch64.whl URL: https://developer.download.nvidia.com/compute/redist/jp/v50/pytorch/torch-1.12.0a0+2c916ef.nv22.3-cp38-cp38-linux_aarch64.whl

• Paso 1. Instala "Torch" según tu versión JetPack en el siguiente formato

wget <URL> -O <file_name>
pip3 install <file_name>

Por ejemplo, aquí estamos ejecutando JP5.0.2 y por lo tanto elegimos PyTorch v1.12.0

sudo apt-get install -y libopenblas-base libopenmpi-dev
wget https://developer.download.nvidia.com/compute/redist/jp/v50/pytorch/torch-1.12.0a0+2c916ef.nv22.3-cp38-cp38-linux_aarch64.whl -O torch-1.12.0a0+2c916ef.nv22.3-cp38-cp38-linux_aarch64.whl
pip3 install torch-1.12.0a0+2c916ef.nv22.3-cp38-cp38-linux_aarch64.whl

• Paso 2. Instala torchvision según la versión de PyTorch que tengas instalada. Por ejemplo, elegimos PyTorch v1.12.0, lo que significa que debemos elegir Torchvision v0.13.0.

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

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

• PyTorch v1.11 - torchvision v0.12.0
• PyTorch v1.12 - torchvision v0.13.0

Si deseas una lista más detallada, revisa este link.

Configuración de DeepStream para YOLOv8

• Pasos 1. Clona el siguiente repositorio:

cd ~
git clone https://github.com/marcoslucianops/DeepStream-Yolo

• Paso 2. Revisa el siguiente commit del repositorio:

cd DeepStream-Yolo
git checkout 68f762d5bdeae7ac3458529bfe6fed72714336ca

• Paso 3. Copia gen_wts_yoloV8.py de DeepStream-Yolo/utils al directorio ultralytics

cp utils/gen_wts_yoloV8.py ~/ultralytics

• Paso 4. Dentro del repositorio de Ultralytics, descarga pt file de YOLOv8 releases (ejemplo para YOLOv8s)

wget https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt

NOTA: Puedes usar tu modelo personalizado, pero es importante mantener la referencia del modelo YOLO (yolov8_) en sus nombres de archivo cfg y weights/wts para generar el motor correctamente.

• Paso 5. Generar los archivos cfg, wts y etiquetas.txt (si están disponibles) (ejemplo para YOLOv8s)

python3 gen_wts_yoloV8.py -w yolov8s.pt

Nota: Cambiar el tamaño de inferencia (default: 640)

-s SIZE
--size SIZE
-s HEIGHT WIDTH
--size HEIGHT WIDTH

Example for 1280:

-s 1280
or
-s 1280 1280

• Paso 6. Copia los archivos cfg, wts y labels.txt (si se generan) generados en la carpeta DeepStream-Yolos

cp yolov8s.cfg ~/DeepStream-Yolo
cp yolov8s.wts ~/DeepStream-Yolo
cp labels.txt ~/DeepStream-Yolo

• Paso 7. Abre el folder DeepStream-Yolo y compila la librería

cd ~/DeepStream-Yolo
CUDA_VER=11.4 make -C nvdsinfer_custom_impl_Yolo  # for DeepStream 6.2/ 6.1.1 / 6.1
CUDA_VER=10.2 make -C nvdsinfer_custom_impl_Yolo  # for DeepStream 6.0.1 / 6.0

• Paso 8. Edita el archivo config_infer_primary_yoloV8.txt de acuerdo a tu modelo (ejemplo para YOLOv8s con 80 clases)

[property]
...
custom-network-config=yolov8s.cfg
model-file=yolov8s.wts
...
num-detected-classes=80
...

• Paso 9. Edita el archivo deepstream_app_config.txt

...
[primary-gie]
...
config-file=config_infer_primary_yoloV8.txt

• Paso 10. Cambie la fuente del video en el archivo deepstream_app_config.txt. Aquí se carga un archivo de video predeterminado como puedes ver a continuación

...
[source0]
...
uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4

Ejecutar la inferencia

deepstream-app -c deepstream_app_config.txt

El resultado anterior se ejecuta en el kit Jetson AGX Orin 32GB H01 con FP32 y YOLOv8s 640x640. Podemos ver que los FPS rondan los 60 y ese no es el valor real porque cuando configuramos type=2 en [sink0] en el archivo deepstream_app_config.txt, los FPS se limitan a los fps del monitor y el monitor que usamos para esta prueba es un monitor de 60 Hz. Sin embargo, si cambias este valor a type=1, podrás obtener los máximo FPS, pero no habrá salida de detección en vivo.

Para la misma fuente de video y el mismo modelo usado anteriormente, después de cambiar type=1 en [sink0], se puede obtener el siguiente resultado.

Como puedes ver, podemos obtener aproximadamente 139 FPS, que se relaciona con el valor real de fps.

Calibración INT8

Si deseas utilizar la precisión INT8 para la inferencia, debes seguir los siguientes pasos:

• Paso 1. Instalar OpenCV

sudo apt-get install libopencv-dev

• Paso 2. Compilar/recompilar la librería nvdsinfer_custom_impl_Yolo con soporte para OpenCV

cd ~/DeepStream-Yolo
CUDA_VER=11.4 OPENCV=1 make -C nvdsinfer_custom_impl_Yolo  # for DeepStream 6.2/ 6.1.1 / 6.1
CUDA_VER=10.2 OPENCV=1 make -C nvdsinfer_custom_impl_Yolo  # for DeepStream 6.0.1 / 6.0

• Paso 3. Para el conjunto de datos COCO, descarga el archivo val2017, extrae su contenidp, y mueve el contenido al folder DeepStream-Yolo

• Paso 4. Haz un directorio nuevo para las imágenes de calibración

mkdir calibration

• Paso 5. Ejecuta lo siguiente para seleccionar 1000 imágenes aleatorias del conjunto de datos COCO para ejecutar la calibración

for jpg in $(ls -1 val2017/*.jpg | sort -R | head -1000); do \
    cp ${jpg} calibration/; \
done

Nota: NVIDIA recomienda al menos 500 imágenes para obtener una buena precisión. En este ejemplo, se eligen 1000 imágenes para obtener una mayor precisión (más imágenes = más precisión). Los valores más altos de INT8_CALIB_BATCH_SIZE darán como resultado una mayor precisión y una velocidad de calibración más rápida. Configúralo según la memoria de tu GPU. Puedes configurarlo desde head -1000. Por ejemplo, para 2000 imágenes, head = -2000. Este proceso puede llevar mucho tiempo.

• Paso 6. Crea un archivo calibration.txt con todas las imágenes seleccionadas.

realpath calibration/*jpg > calibration.txt

• Paso 7. Configura las variables de entorno

export INT8_CALIB_IMG_PATH=calibration.txt
export INT8_CALIB_BATCH_SIZE=1

• Paso 8. Actualiza el archivo config_infer_primary_yoloV8.txt

De:

...
model-engine-file=model_b1_gpu0_fp32.engine
#int8-calib-file=calib.table
...
network-mode=0
...

A:

...
model-engine-file=model_b1_gpu0_int8.engine
int8-calib-file=calib.table
...
network-mode=1
...

• Paso 9. Antes de ejecutar la inferencia, establezca type=2 en [sink0] en el archivo deepstream_app_config.txt como se mencionó anteriormente para obtener el rendimiento máximo de fps.

• Paso 10. Ejecuta la inferencia

deepstream-app -c deepstream_app_config.txt

¡En esta caso obtenemos alrededor de 350 FPS!

Configuración Multistream

NVIDIA DeepStream te permite configurar fácilmente múltiples transmisiones en un único archivo de configuración para crear aplicaciones de análisis de video de múltiples transmisiones. Más adelante en esta wiki demostraremos cómo los modelos con alto rendimiento de FPS realmente pueden ayudar con aplicaciones multitransmisión junto con algunos puntos de referencia.

Aquí tomaremos 9 streams como ejemplo. Cambiaremos el archivo deepstream_app_config.txt.

• Paso 1. Adentro de la sección [tiled-display], cambia las filas y columnas a 3 y 3 para que podamos tener una cuadrícula de 3x3 con 9 streams.

[tiled-display]
rows=3
columns=3

• Paso 2. Dentro de la sección [source0], establece num-sources=9 y agrega más uri. Aquí simplemente duplicaremos el archivo de vídeo de ejemplo actual 8 veces para formar 9 transmisiones en total. Sin embargo, puedes cambiar a diferentes transmisiones de video según tu aplicación.

[source0]
enable=1
type=3
uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4
uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4
uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4
uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4
uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4
uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4
uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4
uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4
uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4
num-sources=9

Ahora, si ejecutas la aplicación nuevamente con el comando deepstream-app -c deepstream_app_config.txt, verás el siguiente resultado

Herramienta trtexec

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.
• Generando 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. Compila ONNX usando:

yolo mode=export model=yolov8s.pt format=onnx

• Paso 2. Compila el archivo del engine usando trtexec como se muestra:

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. De forma predeterminada, convertirá ONNX en un archivo optimizado para TensorRT con precisión FP32 y podrás ver el resultado de la siguiente manera

Aquí podemos tomar la latencia media como 7,2 ms, lo que se traduce en 139 FPS. Este es el mismo rendimiento que obtuvimos en la demostración anterior de DeepStream.

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

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

Aquí podemos tomar la latencia media como 3,2 ms, lo que se traduce en 313 FPS.

Resultados de referencia de YOLOv8

Hemos realizado pruebas comparativas de rendimiento para diferentes modelos YOLOv8 que se ejecutan en la reComputer J4012, la AGX Orin 32GB H01 Kit y la reComputer J2021

Para conocer más pruebas comparativas de rendimiento que hemos realizado utilizando modelos YOLOv8, consulta nuestro blog.

Resultados de referencia Multistream

Después de ejecutar varias aplicaciones de flujo profundo en los productos de la serie reComputer Jetson Orin, realizamos pruebas comparativas con los modelos YOLOv8s.

• Primero, utilizamos un único modelo de IA y ejecutamos múltiples transmisiones en el mismo modelo de IA.
• En segundo lugar, hemos utilizado múltiples modelos de IA y múltiples flujos en múltiples modelos de IA.

Todos estos benchmarks se llevan a cabo bajo las siguientes condiciones:

• YOLOv8s con imágenes de entrada de 640x640
• UI Deshabilitada
• Modo de max power y max performance habilitados

A partir de estos puntos de referencia, podemos ver que para el dispositivo Orin NX de 16 GB de gama más alta con un solo modelo YOLOv8s en INT8, puedes usar alrededor de 40 cámaras a alrededor de 5 fps y con múltiples modelos YOLOv8s en INT8 para cada transmisión, puedes usar alrededor de 11 cámaras a alrededor de 15 fps. Para aplicaciones de múltiples modelos, la cantidad de cámaras es menor debido a las limitaciones de RAM del dispositivo y cada modelo ocupa una cantidad sustancial de RAM.

En resumen, cuando se opera un dispositivo en el borde (Como la Jetson) con el modelo YOLOv8 solo sin aplicaciones en ejecución, la Jetson Orin Nano de 8 GB puede admitir de 4 a 6 transmisiones, mientras que la Jetson Orin NX de 16 GB puede administrar de 16 a 18 transmisiones a su capacidad máxima. Sin embargo, estos números pueden disminuir a medida que los recursos de RAM se utilizan en aplicaciones del mundo real. Por lo tanto, es aconsejable utilizar estas cifras como guía y realizar tus propias pruebas en tus condiciones específicas.

Recursos

• Documentación YOLOv8
• Documentación TensorRT
• Documentación DeepStream SDK

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.