Ultralytics YOLO26 na NVIDIA Jetson usando DeepStream SDK e TensorRT#

Este guia abrangente apresenta uma explicação detalhada sobre como implementar o Ultralytics YOLO26 em dispositivos NVIDIA Jetson usando DeepStream SDK e TensorRT. Aqui, usamos TensorRT para maximizar o desempenho da inferência na plataforma Jetson.

Este guia explica a configuração do DeepStream para YOLO26, a calibração INT8, a configuração de vários fluxos e os resultados dos benchmarks.

O que é o NVIDIA DeepStream?#

O DeepStream SDK da NVIDIA é um conjunto completo de ferramentas de análise de fluxos, baseado no GStreamer, para processamento multissensor com IA e compreensão de vídeo, áudio e imagens. É ideal para desenvolvedores de IA visual, parceiros de software, startups e fabricantes de equipamento original (OEMs) que criam aplicações e serviços de análise inteligente de vídeo (IVA). Agora, podes criar pipelines de processamento de fluxos que incorporam redes neurais e outras tarefas complexas de processamento, como rastreamento, codificação/descodificação de vídeo e renderização de vídeo. Esses pipelines permitem análises em tempo real de dados de vídeo, imagem e sensores. O suporte multiplataforma do DeepStream oferece uma forma mais rápida e fácil de desenvolver aplicações e serviços de IA visual localmente, na periferia da rede e na nuvem.

Pré-requisitos#

Antes de começares a seguir este guia:

• Consulta a nossa documentação, Guia de início rápido: NVIDIA Jetson com Ultralytics YOLO26, para configurar o teu dispositivo NVIDIA Jetson com o Ultralytics YOLO26
• Instala o DeepStream SDK de acordo com a versão do JetPack
  • Para o JetPack 4.6.4, instala o DeepStream 6.0.1
  • Para o JetPack 5.1.3, instala o DeepStream 6.3
  • Para o JetPack 6.1, instala o DeepStream 7.1
  • Para o JetPack 7.1, instala o DeepStream 9.0

Configuração do DeepStream para YOLO26#

Aqui, usamos o repositório GitHub marcoslucianops/DeepStream-Yolo, que inclui suporte do NVIDIA DeepStream SDK para modelos YOLO. Agradecemos o trabalho e as contribuições de marcoslucianops!

1. Instala o Ultralytics com as dependências necessárias

   pip install ultralytics onnx onnxslim

2. Clona o repositório DeepStream-Yolo

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

3. Transfere um modelo de deteção Ultralytics YOLO26 (.pt) à tua escolha do projeto YOLO26. Aqui, usamos yolo26s.pt.

   wget https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s.pt

4. Converte o modelo para ONNX e escreve o ficheiro labels.txt de onde o DeepStream lê os nomes das classes

   from ultralytics import YOLO
   
   model = YOLO("yolo26s.pt")
   model.export(format="onnx", nms=False, agnostic_nms=True)  # cria 'yolo26s.onnx'
   with open("labels.txt", "w") as f:
       f.write("\n".join(model.names.values()))

5. Copia o ficheiro de modelo gerado .onnx e o ficheiro labels.txt para a pasta DeepStream-Yolo

   cp yolo26s.onnx labels.txt ~/DeepStream-Yolo
   cd ~/DeepStream-Yolo

6. Define a versão do CUDA de acordo com a versão do JetPack instalada

   Para o JetPack 4.6.4:

   export CUDA_VER=10.2

   Para o JetPack 5.1.3:

   export CUDA_VER=11.4

   Para o JetPack 6.1:

   export CUDA_VER=12.6

   Para o JetPack 7.1:

   export CUDA_VER=13.0

7. Compila a biblioteca

   make -C nvdsinfer_custom_impl_Yolo clean && make -C nvdsinfer_custom_impl_Yolo

8. Edita o ficheiro config_infer_primary_yolo26.txt de acordo com o teu modelo (para YOLO26s com 80 classes)

   [property]
   ...
   onnx-file=yolo26s.onnx
   ...
   num-detected-classes=80
   ...
   parse-bbox-func-name=NvDsInferParseYolo
   ...

[property]
...
maintain-aspect-ratio=1
symmetric-padding=1
cluster-mode=4
...

9. Edita o ficheiro deepstream_app_config

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

10. Também podes alterar a origem do vídeo no ficheiro deepstream_app_config. Aqui, é carregado um ficheiro de vídeo predefinido

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

Executa a inferência#

deepstream-app -c deepstream_app_config.txt

Calibração INT8#

Se quiseres usar precisão INT8 para a inferência, tens de seguir estes passos:

1. Define a variável de ambiente OPENCV

   export OPENCV=1

2. Compila a biblioteca

   make -C nvdsinfer_custom_impl_Yolo clean && make -C nvdsinfer_custom_impl_Yolo

3. Para o conjunto de dados COCO, transfere o val2017, extrai-o e move-o para a pasta DeepStream-Yolo

4. Cria um novo diretório para as imagens de calibração

   mkdir calibration

5. Executa o seguinte para selecionar 1000 imagens aleatórias do conjunto de dados COCO para a calibração

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

6. Cria o ficheiro calibration.txt com todas as imagens selecionadas

   realpath calibration/*jpg > calibration.txt

7. Define as variáveis de ambiente

   export INT8_CALIB_IMG_PATH=calibration.txt
   export INT8_CALIB_BATCH_SIZE=1

8. Atualiza o ficheiro config_infer_primary_yolo26.txt

   De

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

   Para

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

Executa a inferência INT8#

Executa o mesmo comando para criar o mecanismo INT8 e iniciar a inferência:

deepstream-app -c deepstream_app_config.txt

Configuração de vários fluxos#

Para configurar vários fluxos numa única aplicação DeepStream, faz as seguintes alterações no ficheiro deepstream_app_config.txt:

1. Altera as linhas e as colunas para criar uma grelha de visualização de acordo com o número de fluxos pretendido. Por exemplo, para 4 fluxos, podemos adicionar 2 linhas e 2 colunas.

   [tiled-display]
   rows=2
   columns=2

2. Adiciona um grupo [sourceN] separado para cada fluxo, cada um com o seu próprio uri e num-sources=1.

   [source0]
   enable=1
   type=3
   uri=file:///path/to/video1.mp4
   num-sources=1
   
   [source1]
   enable=1
   type=3
   uri=file:///path/to/video2.mp4
   num-sources=1
   
   [source2]
   enable=1
   type=3
   uri=file:///path/to/video3.mp4
   num-sources=1
   
   [source3]
   enable=1
   type=3
   uri=file:///path/to/video4.mp4
   num-sources=1

Executa a inferência com vários fluxos#

Executa o mesmo comando para iniciar todos os fluxos na visualização em mosaico:

deepstream-app -c deepstream_app_config.txt

Resultados dos benchmarks#

Os seguintes benchmarks resumem o desempenho dos modelos YOLO11 com diferentes níveis de precisão do TensorRT, usando um tamanho de entrada de 640x640 no NVIDIA Jetson Orin NX de 16 GB. O YOLO26 usa o mesmo fluxo de trabalho de exportação e inferência do DeepStream descrito acima.

Gráfico comparativo#

Tabela comparativa detalhada#

Agradecimentos#

Este guia foi criado inicialmente pelos nossos amigos da Seeed Studio, Lakshantha e Elaine.

Perguntas frequentes#