Salta para o conteúdo

Guia de início rápido: NVIDIA Jetson com Ultralytics YOLOv8

Este guia abrangente fornece um passo a passo detalhado para implantar o Ultralytics YOLOv8 em dispositivos NVIDIA Jetson. Além disso, apresenta benchmarks de desempenho para demonstrar os recursos do YOLOv8 nesses dispositivos pequenos e poderosos.

Ecossistema NVIDIA Jetson

Nota

Este guia foi testado com o Seeed Studio reComputer J4012 que é baseado no NVIDIA Jetson Orin NX 16GB executando a última versão estável do JetPack JP5.1.3. Não é garantido que este guia funcione em dispositivos Jetson mais antigos, como o Jetson Nano (que suporta apenas até JP4.6.4). No entanto, espera-se que funcione em todos os dispositivos Jetson Orin, Xavier NX, AGX Xavier com JP5.1.3.

O que é o NVIDIA Jetson?

NVIDIA Jetson é uma série de placas de computação incorporadas concebidas para levar a computação acelerada de IA (inteligência artificial) aos dispositivos de ponta. Estes dispositivos compactos e potentes são construídos em torno da arquitetura GPU da NVIDIA e são capazes de executar algoritmos complexos de IA e modelos de aprendizagem profunda diretamente no dispositivo, sem necessidade de depender de recursos de computação em nuvem. As placas Jetson são frequentemente utilizadas em robótica, veículos autónomos, automação industrial e outras aplicações em que a inferência de IA tem de ser executada localmente com baixa latência e elevada eficiência. Além disso, estas placas baseiam-se na arquitetura ARM64 e consomem menos energia do que os dispositivos de computação GPU tradicionais.

Comparação da série NVIDIA Jetson

O Jetson Orin é a mais recente iteração da família NVIDIA Jetson baseada na arquitetura NVIDIA Ampere, que traz um desempenho de IA drasticamente melhorado em comparação com as gerações anteriores. A tabela abaixo compara alguns dos dispositivos Jetson no ecossistema.

Jetson AGX Orin 64GB Jetson Orin NX 16GB Jetson Orin Nano 8GB Jetson AGX Xavier Jetson Xavier NX Jetson Nano
Desempenho da IA 275 TOPS 100 TOPS 40 TOPs 32 TOPS 21 TOPS 472 GFLOPS
GPU GPU de arquitetura NVIDIA Ampere de 2048 núcleos com 64 Tensor núcleos GPU de arquitetura NVIDIA Ampere de 1024 núcleos com 32 Tensor núcleos GPU de arquitetura NVIDIA Ampere de 1024 núcleos com 32 Tensor núcleos GPU de arquitetura NVIDIA Volta de 512 núcleos com 64 Tensor núcleos GPU de 384 núcleos de arquitetura NVIDIA Volta™ com 48 Tensor Cores GPU de 128 núcleos com arquitetura NVIDIA Maxwell
Frequência máxima da GPU 1,3 GHz 918 MHz 625 MHz 1377 MHz 1100 MHz 921MHz
CPU CPU NVIDIA Arm® Cortex A78AE v8.2 de 64 bits com 12 núcleos 3 MB L2 + 6 MB L3 CPU NVIDIA Arm® Cortex A78AE v8.2 de 64 bits com 8 núcleos 2 MB L2 + 4 MB L3 CPU Arm® Cortex®-A78AE v8.2 de 64 bits com 6 núcleos 1,5 MB L2 + 4 MB L3 CPU NVIDIA Carmel Arm®v8.2 de 8 núcleos e 64 bits 8 MB L2 + 4 MB L3 CPU NVIDIA Carmel Arm®v8.2 de 6 núcleos e 64 bits 6 MB L2 + 4 MB L3 Processador Quad-Core Arm® Cortex®-A57 MPCore
Frequência máxima da CPU 2,2 GHz 2,0 GHz 1,5 GHz 2,2 GHz 1,9 GHz 1.43GHz
Memória 64GB LPDDR5 de 256 bits 204,8GB/s 16GB LPDDR5 de 128 bits 102,4GB/s 8GB LPDDR5 de 128 bits 68 GB/s 32GB LPDDR4x de 256 bits 136,5GB/s 8GB LPDDR4x de 128 bits 59,7GB/s 4GB LPDDR4 de 64 bits 25,6GB/s"

Para uma tabela de comparação mais detalhada, visita a secção Especificações técnicas da página oficial da NVIDIA Jetson.

O que é o NVIDIA JetPack?

O SDK NVIDIA JetPack que alimenta os módulos Jetson é a solução mais abrangente e fornece um ambiente de desenvolvimento completo para a criação de aplicações de IA aceleradas de ponta a ponta e reduz o tempo de colocação no mercado. O JetPack inclui o Jetson Linux com bootloader, kernel Linux, ambiente de trabalho Ubuntu e um conjunto completo de bibliotecas para aceleração da computação GPU, multimédia, gráficos e visão computacional. Inclui também amostras, documentação e ferramentas de desenvolvimento para o computador anfitrião e o kit de desenvolvimento, e suporta SDKs de nível superior, como o DeepStream para análise de streaming de vídeo, Isaac para robótica e Riva para IA de conversação.

Flash JetPack para NVIDIA Jetson

O primeiro passo depois de pores as mãos num dispositivo NVIDIA Jetson é fazer o flash do NVIDIA JetPack para o dispositivo. Existem várias maneiras diferentes de flashear dispositivos NVIDIA Jetson.

  1. Se tiveres um kit de desenvolvimento oficial da NVIDIA, como o Jetson Orin Nano Developer Kit, podes visitar esta ligação para transferir uma imagem e preparar um cartão SD com o JetPack para arrancar o dispositivo.
  2. Se tiveres qualquer outro Kit de Desenvolvimento NVIDIA, podes visitar este link para flashear o JetPack para o dispositivo usando o SDK Manager.
  3. Se tiveres um dispositivo Seeed Studio reComputer J4012, podes visitar esta ligação para flashear o JetPack para o SSD incluído.
  4. Se tiveres qualquer outro dispositivo de terceiros equipado com o módulo NVIDIA Jetson, recomenda-se que sigas a linha de comando para flashes, visitando esta ligação.

Nota

Para os métodos 3 e 4 acima, depois de flashear o sistema e arrancar o dispositivo, introduz "sudo apt update && sudo apt install nvidia-jetpack -y" no terminal do dispositivo para instalar todos os restantes componentes JetPack necessários.

Prepara-te Ultralytics

Existem duas formas de configurar o pacote Ultralytics no NVIDIA Jetson para construir o teu próximo projeto de Visão Computacional. Podes usar qualquer uma delas.

Começa com o Docker

A maneira mais rápida de começar a usar o Ultralytics YOLOv8 no NVIDIA Jetson é executar uma imagem docker pré-construída para o Jetson.

Executa o comando abaixo para puxar o contentor Docker e correr no Jetson. Isto é baseado na imagem docker l4t-pytorch que contém PyTorch e Torchvision num ambiente Python3.

t=ultralytics/ultralytics:latest-jetson && sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t

Depois de fazer isso, passa para a secção Usar TensorRT no NVIDIA Jetson.

Começa sem o Docker

Instala o pacote Ultralytics

Aqui vamos instalar o pacote ultralyics no Jetson com dependências opcionais para que possamos exportar os modelos PyTorch para outros formatos diferentes. Concentrar-nos-emos principalmente nas exportações para NVIDIA TensorRT porque o TensoRT garante que podemos obter o máximo desempenho dos dispositivos Jetson.

  1. Actualiza a lista de pacotes, instala o pip e actualiza para a versão mais recente

    sudo apt update
    sudo apt install python3-pip -y
    pip install -U pip
    
  2. Instala ultralytics pacote pip com dependências opcionais

    pip install ultralytics[export]
    
  3. Reinicia o dispositivo

    sudo reboot
    

Instala PyTorch e Torchvision

A instalação do ultralytics acima instala o Torch e o Torchvision. No entanto, esses dois pacotes instalados via pip não são compatíveis para rodar na plataforma Jetson, que é baseada na arquitetura ARM64. Portanto, precisamos instalar manualmente o PyTorch pip wheel pré-construído e compilar/instalar o Torchvision a partir da fonte.

  1. Desinstala o PyTorch e o Torchvision atualmente instalados

    pip uninstall torch torchvision
    
  2. Instala PyTorch 2.1.0 de acordo com JP5.1.3

    sudo apt-get install -y libopenblas-base libopenmpi-dev
    wget https://developer.download.nvidia.com/compute/redist/jp/v512/pytorch/torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl -O torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl
    pip install torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl
    
  3. Instala o Torchvision v0.16.2 de acordo com PyTorch v2.1.0

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

Visita a páginaPyTorch for Jetson para acederes a todas as diferentes versões de PyTorch para diferentes versões do JetPack. Para obter uma lista mais detalhada sobre a compatibilidade do PyTorch e do Torchvision, visita a página de compatibilidade doPyTorch e do Torchvision.

Instala onnxruntime-gpu

O onnxruntime-gpu hospedado no PyPI não tem o pacote aarch64 para o Jetson. Por isso, tens de instalar manualmente este pacote. Este pacote é necessário para algumas das exportações.

Todos diferentes onnxruntime-gpu Os pacotes que correspondem a diferentes versões do JetPack e do Python estão listados aqui. No entanto, aqui vamos descarregar e instalar onnxruntime-gpu 1.17.0 com Python3.8 suporta o JetPack que estamos a utilizar para este guia.

wget https://nvidia.box.com/shared/static/zostg6agm00fb6t5uisw51qi6kpcuwzd.whl -O onnxruntime_gpu-1.17.0-cp38-cp38-linux_aarch64.whl
pip install onnxruntime_gpu-1.17.0-cp38-cp38-linux_aarch64.whl

Nota

onnxruntime-gpu reverterá automaticamente a versão do numpy para a mais recente. Por isso, precisamos de reinstalar o numpy para 1.23.5 para resolver um problema, executando:

pip install numpy==1.23.5

Usa TensorRT no NVIDIA Jetson

De todos os formatos de exportação de modelos suportados pelo Ultralytics, o TensorRT oferece o melhor desempenho de inferência ao trabalhar com dispositivos NVIDIA Jetson e nossa recomendação é usar o TensorRT com o Jetson. Também temos um documento detalhado sobre TensorRT aqui.

Converte o modelo para TensorRT e executa a inferência

O modelo YOLOv8n no formato PyTorch é convertido para TensorRT para executar a inferência com o modelo exportado.

Exemplo

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Export the model
model.export(format="engine")  # creates 'yolov8n.engine'

# Load the exported TensorRT model
trt_model = YOLO("yolov8n.engine")

# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLOv8n PyTorch model to TensorRT format
yolo export model=yolov8n.pt format=engine  # creates 'yolov8n.engine'

# Run inference with the exported model
yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'

Nota

Visita a página Exportar para aceder a argumentos adicionais ao exportar modelos para diferentes formatos de modelo

NVIDIA Jetson Orin YOLOv8 Benchmarks

YOLOv8 Os testes de referência foram executados pela equipa Ultralytics em 10 formatos de modelos diferentes, medindo a velocidade e a precisão: PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel , TF Graphdef , TF Lite, PaddlePaddle, NCNN. Os testes de referência foram executados no Seeed Studio reComputer J4012 alimentado pelo dispositivo Jetson Orin NX 16GB com precisão FP32 e tamanho de imagem de entrada predefinido de 640.

Gráfico de comparação

Apesar de todas as exportações de modelos estarem a funcionar com NVIDIA Jetson, apenas incluímos PyTorch, TorchScript, TensorRT para o gráfico de comparação abaixo porque utilizam o GPU no Jetson e garantem os melhores resultados. Todas as outras exportações utilizam apenas o CPU e o desempenho não é tão bom como as três acima. Podes encontrar benchmarks para todas as exportações na secção a seguir a este gráfico.

Ecossistema NVIDIA Jetson

Tabela de comparação detalhada

A tabela abaixo representa os resultados do teste de referência para cinco modelos diferentes (YOLOv8n, YOLOv8s, YOLOv8m, YOLOv8l, YOLOv8x) em dez formatos diferentes (PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel , TF Graphdef , TF Lite, PaddlePaddle, NCNN), dando-nos o estado, o tamanho, a métrica mAP50-95(B) e o tempo de inferência para cada combinação.

Desempenho

Formato Estado Tamanho no disco (MB) mAP50-95(B) Tempo de inferência (ms/im)
PyTorch ✅ 6.2 0.6381 14.3
TorchScript ✅ 12.4 0.6117 13.3
ONNX ✅ 12.2 0.6092 70.6
OpenVINO ✅ 12.3 0.6092 104.2
TensorRT ✅ 13.6 0.6117 8.9
TF SavedModel ✅ 30.6 0.6092 141.74
TF GraphDef ✅ 12.3 0.6092 199.93
TF Leve ✅ 12.3 0.6092 349.18
PaddlePaddle ✅ 24.4 0.6030 555
NCNN ✅ 12.2 0.6092 32
Formato Estado Tamanho no disco (MB) mAP50-95(B) Tempo de inferência (ms/im)
PyTorch ✅ 21.5 0.6967 18
TorchScript ✅ 43.0 0.7136 23.81
ONNX ✅ 42.8 0.7136 185.55
OpenVINO ✅ 42.9 0.7136 243.97
TensorRT ✅ 44.0 0.7136 14.82
TF SavedModel ✅ 107 0.7136 260.03
TF GraphDef ✅ 42.8 0.7136 423.4
TF Leve ✅ 42.8 0.7136 1046.64
PaddlePaddle ✅ 85.5 0.7140 1464
NCNN ✅ 42.7 0.7200 63
Formato Estado Tamanho no disco (MB) mAP50-95(B) Tempo de inferência (ms/im)
PyTorch ✅ 49.7 0.7370 36.4
TorchScript ✅ 99.2 0.7285 53.58
ONNX ✅ 99 0.7280 452.09
OpenVINO ✅ 99.1 0.7280 544.36
TensorRT ✅ 100.3 0.7285 33.21
TF SavedModel ✅ 247.5 0.7280 543.65
TF GraphDef ✅ 99 0.7280 906.63
TF Leve ✅ 99 0.7280 2758.08
PaddlePaddle ✅ 197.9 0.7280 3678
NCNN ✅ 98.9 0.7260 135
Formato Estado Tamanho no disco (MB) mAP50-95(B) Tempo de inferência (ms/im)
PyTorch ✅ 83.7 0.7768 61.3
TorchScript ✅ 167.2 0.7554 87.9
ONNX ✅ 166.8 0.7551 852.29
OpenVINO ✅ 167 0.7551 1012.6
TensorRT ✅ 168.4 0.7554 51.23
TF SavedModel ✅ 417.2 0.7551 990.45
TF GraphDef ✅ 166.9 0.7551 1649.86
TF Leve ✅ 166.9 0.7551 5652.37
PaddlePaddle ✅ 333.6 0.7551 7114.67
NCNN ✅ 166.8 0.7685 231.9
Formato Estado Tamanho no disco (MB) mAP50-95(B) Tempo de inferência (ms/im)
PyTorch ✅ 130.5 0.7759 93
TorchScript ✅ 260.7 0.7472 135.1
ONNX ✅ 260.4 0.7479 1296.13
OpenVINO ✅ 260.6 0.7479 1502.15
TensorRT ✅ 261.8 0.7469 84.53
TF SavedModel ✅ 651.1 0.7479 1451.76
TF GraphDef ✅ 260.5 0.7479 4029.36
TF Leve ✅ 260.4 0.7479 8772.86
PaddlePaddle ✅ 520.8 0.7479 10619.53
NCNN ✅ 260.4 0.7646 376.38

Visita esta ligação para explorares mais esforços de avaliação comparativa do Seeed Studio executados em diferentes versões do hardware NVIDIA Jetson.

Reproduzir os nossos resultados

Para reproduzir as referências Ultralytics acima em todos os formatos de exportação, executa este código:

Exemplo

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all all export formats
results = model.benchmarks(data="coco8.yaml", imgsz=640)
# Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all all export formats
yolo benchmark model=yolov8n.pt data=coco8.yaml imgsz=640

Nota que os resultados dos testes de referência podem variar com base na configuração exacta de hardware e software de um sistema, bem como na carga de trabalho atual do sistema no momento em que os testes de referência são executados. Para obter os resultados mais fiáveis, utiliza um conjunto de dados com um grande número de imagens, ou seja data='coco8.yaml' (4 val images), ordata='coco.yaml'` (5000 imagens val).

Práticas recomendadas ao usar o NVIDIA Jetson

Quando utilizas o NVIDIA Jetson, existem algumas práticas recomendadas a seguir para permitir o máximo desempenho no NVIDIA Jetson com YOLOv8.

  1. Ativar o modo de potência máxima

    Se activares o Modo de Energia MÁX no Jetson, certificar-te-ás de que todos os núcleos do CPU e da GPU estão ligados.

    sudo nvpmodel -m 0
    
  2. Ativar os relógios Jetson

    Se activares o Jetson Clocks, certificar-te-ás de que todos os núcleos do CPU e do GPU têm a frequência máxima.

    sudo jetson_clocks
    
  3. Instala a aplicação Jetson Stats

    Podemos utilizar a aplicação jetson stats para monitorizar as temperaturas dos componentes do sistema e verificar outros detalhes do sistema, como ver a utilização do CPU, GPU e RAM, alterar os modos de energia, definir os relógios máximos, verificar as informações do JetPack

    sudo apt update
    sudo pip install jetson-stats
    sudo reboot
    jtop
    

Estatísticas Jetson

Próximos passos

Parabéns por teres configurado com sucesso o YOLOv8 no teu NVIDIA Jetson! Para mais informações e suporte, visita mais guias em Ultralytics YOLOv8 Docs!



Criado em 2024-04-02, Atualizado em 2024-05-18
Autores: glenn-jocher (4), Burhan-Q (2), lakshanthad (2)

Comentários