Guia de Início Rápido: NVIDIA Jetson com Ultralytics YOLO26#
Este guia abrangente fornece um passo a passo detalhado para implantar o Ultralytics YOLO26 em dispositivos NVIDIA Jetson. Além disso, ele apresenta benchmarks de desempenho para demonstrar as capacidades do YOLO26 nesses dispositivos pequenos e potentes.
Atualizamos este guia com o mais recente NVIDIA Jetson AGX Thor Developer Kit, que oferece até 2070 TFLOPS em FP4 de computação de IA e 128 GB de memória com consumo configurável entre 40 W e 130 W. Ele entrega mais de 7,5x mais computação de IA do que o NVIDIA Jetson AGX Orin, com uma eficiência energética 3,5x melhor para executar perfeitamente os modelos de IA mais populares.
Watch: How to use Ultralytics YOLO26 on NVIDIA Jetson Devices
Este guia foi testado com o NVIDIA Jetson AGX Thor Developer Kit (Jetson T5000) e o NVIDIA Jetson AGX Orin Developer Kit (64GB) executando o JetPack 7.2 estável mais recente, o NVIDIA Jetson Orin Nano Super Developer Kit executando a versão de JetPack JP6.1, o Seeed Studio reComputer J4012, que é baseado no NVIDIA Jetson Orin NX 16GB executando a versão de JetPack JP6.0 / versão de JetPack JP5.1.3, e o Seeed Studio reComputer J1020 v2, que é baseado no NVIDIA Jetson Nano 4GB executando a versão de JetPack JP4.6.1. Espera-se que funcione em toda a linha de hardware NVIDIA Jetson, incluindo dispositivos recentes e legados.
O que é NVIDIA Jetson?#
O NVIDIA Jetson é uma série de placas de computação embarcada projetadas para levar computação de IA (inteligência artificial) acelerada a dispositivos de borda. Esses dispositivos compactos e potentes são construídos em torno da arquitetura de GPU da NVIDIA e podem executar algoritmos complexos de IA e modelos de deep learning diretamente no dispositivo, sem depender de recursos de cloud computing. As placas Jetson são frequentemente usadas em robótica, veículos autônomos, automação industrial e outras aplicações onde a inferência de IA precisa ser realizada localmente com baixa latência e alta eficiência. Além disso, essas placas são baseadas na arquitetura ARM64 e operam com menor consumo de energia em comparação com dispositivos tradicionais de computação em GPU.
Comparação da série NVIDIA Jetson#
NVIDIA Jetson AGX Thor é a mais recente iteração da família NVIDIA Jetson baseada na arquitetura NVIDIA Blackwell, 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 Thor(T5000) | Jetson AGX Orin 64GB | Jetson Orin NX 16GB | Jetson Orin Nano Super | Jetson AGX Xavier | Jetson Xavier NX | Jetson Nano | |
|---|---|---|---|---|---|---|---|
| Desempenho de IA | 2070 TFLOPS | 275 TOPS | 100 TOPS | 67 TOPS | 32 TOPS | 21 TOPS | 472 GFLOPS |
| GPU | GPU com arquitetura NVIDIA Blackwell de 2560 núcleos com 96 Tensor Cores | GPU com arquitetura NVIDIA Ampere de 2048 núcleos com 64 Tensor Cores | GPU com arquitetura NVIDIA Ampere de 1024 núcleos com 32 Tensor Cores | GPU com arquitetura NVIDIA Ampere de 1024 núcleos com 32 Tensor Cores | GPU com arquitetura NVIDIA Volta de 512 núcleos com 64 Tensor Cores | GPU com arquitetura NVIDIA Volta™ de 384 núcleos com 48 Tensor Cores | GPU com arquitetura NVIDIA Maxwell™ de 128 núcleos |
| Frequência Máxima da GPU | 1.57 GHz | 1.3 GHz | 918 MHz | 1020 MHz | 1377 MHz | 1100 MHz | 921MHz |
| CPU | CPU Arm® Neoverse®-V3AE de 14 núcleos, 64 bits, 1 MB L2 + 16 MB L3 | CPU NVIDIA Arm® Cortex A78AE v8.2 de 12 núcleos, 64 bits, 3 MB L2 + 6 MB L3 | CPU NVIDIA Arm® Cortex A78AE v8.2 de 8 núcleos, 64 bits, 2 MB L2 + 4 MB L3 | CPU Arm® Cortex®-A78AE v8.2 de 6 núcleos, 64 bits, 1,5 MB L2 + 4 MB L3 | CPU NVIDIA Carmel Arm®v8.2 de 8 núcleos, 64 bits, 8 MB L2 + 4 MB L3 | CPU NVIDIA Carmel Arm®v8.2 de 6 núcleos, 64 bits, 6 MB L2 + 4 MB L3 | Processador Quad-Core Arm® Cortex®-A57 MPCore |
| Frequência Máxima da CPU | 2.6 GHz | 2.2 GHz | 2.0 GHz | 1.7 GHz | 2.2 GHz | 1.9 GHz | 1.43GHz |
| Memória | 128 GB LPDDR5X 256 bits 273 GB/s | 64 GB LPDDR5 256 bits 204,8 GB/s | 16 GB LPDDR5 128 bits 102,4 GB/s | 8 GB LPDDR5 128 bits 102 GB/s | 32 GB LPDDR4x 256 bits 136,5 GB/s | 8 GB LPDDR4x 128 bits 59,7 GB/s | 4 GB LPDDR4 64 bits 25,6 GB/s |
Para uma tabela de comparação mais detalhada, visite a seção Compare Specifications da página oficial do NVIDIA Jetson.
O que é o NVIDIA JetPack?#
O NVIDIA JetPack SDK, que alimenta os módulos Jetson, é a solução mais abrangente e fornece um ambiente de desenvolvimento completo para a construção de aplicações de IA acelerada de ponta a ponta, encurtando o tempo de lançamento no mercado. O JetPack inclui o Jetson Linux com gerenciador de inicialização, kernel Linux, ambiente de desktop Ubuntu e um conjunto completo de bibliotecas para aceleração de computação em GPU, multimídia, gráficos e computer vision. Ele também inclui exemplos, documentação e ferramentas de desenvolvedor para o computador host e o kit de desenvolvedor, além de suportar SDKs de nível superior, como DeepStream para análise de vídeo em streaming, Isaac para robótica e Riva para IA conversacional.
Instalar o JetPack no NVIDIA Jetson#
O primeiro passo após adquirir um dispositivo NVIDIA Jetson é instalar o NVIDIA JetPack no dispositivo. Existem várias formas diferentes de instalar o software em dispositivos NVIDIA Jetson.
- Para o JetPack 7.2 em um kit de desenvolvedor oficial Jetson AGX Thor, AGX Orin ou Orin Nano, baixe a ISO unificada do Jetson, grave-a em uma unidade flash USB e siga o guia de início rápido específico do dispositivo para AGX Thor, AGX Orin ou Orin Nano. A partir do JetPack 7.2, o Orin Nano não usa mais uma imagem de cartão SD baixável; a ISO USB instala o Jetson Linux no cartão microSD ou SSD NVMe do dispositivo.
- Se você usar intencionalmente o JetPack 6 em um kit de desenvolvedor Jetson Orin Nano, siga as instruções de atualização e do cartão SD do JetPack 6.x da NVIDIA.
- Se você possui qualquer outro kit de desenvolvimento da NVIDIA, você pode flashear o JetPack no dispositivo usando o SDK Manager.
- Se você possui um dispositivo Seeed Studio reComputer J4012, você pode flashear o JetPack no SSD incluído e, se você possui um dispositivo Seeed Studio reComputer J1020 v2, você pode flashear o JetPack no eMMC/SSD.
- Se você possui qualquer outro dispositivo de terceiros alimentado pelo módulo NVIDIA Jetson, é recomendável seguir a flasheamento por linha de comando.
Para os métodos 1, 4 e 5 acima, após instalar o sistema e inicializar o dispositivo, digite "sudo apt update && sudo apt install nvidia-jetpack -y" no terminal do dispositivo para instalar todos os componentes restantes do JetPack necessários.
Suporte ao JetPack por dispositivo Jetson#
A tabela abaixo destaca as versões do NVIDIA JetPack suportadas por diferentes dispositivos NVIDIA Jetson.
| JetPack 4 | JetPack 5 | JetPack 6 | JetPack 7 | |
|---|---|---|---|---|
| Jetson Nano | ✅ | ❌ | ❌ | ❌ |
| Jetson TX2 | ✅ | ❌ | ❌ | ❌ |
| Jetson Xavier NX | ✅ | ✅ | ❌ | ❌ |
| Jetson AGX Xavier | ✅ | ✅ | ❌ | ❌ |
| Jetson AGX Orin | ❌ | ✅ | ✅ | ✅ |
| Jetson Orin NX | ❌ | ✅ | ✅ | ✅ |
| Jetson Orin Nano | ❌ | ✅ | ✅ | ✅ |
| Jetson AGX Thor | ❌ | ❌ | ❌ | ✅ |
Início Rápido com Docker#
A maneira mais rápida de começar a usar o Ultralytics YOLO26 no NVIDIA Jetson é executar com imagens Docker pré-construídas para Jetson. Consulte a tabela acima e escolha a versão do JetPack de acordo com o dispositivo Jetson que você possui.
t=ultralytics/ultralytics:latest-jetson-jetpack4
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $tA imagem pública latest-nvidia-arm64 atualmente possui apenas o caminho para o JetPack 7.0 Thor/DGX Spark. Para o JetPack 7.2 no Thor ou Orin, use a instalação nativa abaixo até que a imagem pública seja explicitamente validada e atualizada para essas combinações.
Depois de fazer isso, pule para a seção Use TensorRT on NVIDIA Jetson section.
Começar com Instalação Nativa#
Para uma instalação nativa sem Docker, consulte as etapas abaixo.
Executar no JetPack 7.2#
Instalar o Pacote Ultralytics#
Aqui, instalaremos o pacote Ultralytics no Jetson com dependências opcionais para que possamos exportar os modelos do PyTorch para outros formatos diferentes. Focaremos principalmente nas exportações para o NVIDIA TensorRT, pois o TensorRT garantirá que possamos obter o máximo desempenho dos dispositivos Jetson.
-
Atualize a lista de pacotes, instale o pip e atualize para a versão mais recente
sudo apt update sudo apt install python3-pip -y pip install -U pip -
Instalar o pacote pip
ultralyticscom dependências opcionaispip install ultralytics[export] -
Reinicie o dispositivo
sudo reboot
Instalar PyTorch e Torchvision#
A instalação acima do Ultralytics instalará o Torch e o Torchvision. No entanto, esses 2 pacotes instalados via pip não são compatíveis para rodar em dispositivos JetPack 7.2 com CUDA 13. Portanto, precisamos instalá-los manualmente.
Instalar torch e torchvision de acordo com o JP7.2
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu130Instalar onnxruntime-gpu#
O pacote onnxruntime-gpu hospedado no PyPI não possui binários aarch64 para o Jetson. Portanto, precisamos instalar este pacote manualmente. Este pacote é necessário para algumas das exportações.
Aqui, baixaremos e instalaremos onnxruntime-gpu 1.24.0 com suporte a Python3.12.
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.24.0-cp312-cp312-linux_aarch64.whlExecute no JetPack 6.1#
Instalar o Pacote Ultralytics#
Aqui, instalaremos o pacote Ultralytics no Jetson com dependências opcionais para que possamos exportar os modelos do PyTorch para outros formatos diferentes. Focaremos principalmente nas exportações para o NVIDIA TensorRT, pois o TensorRT garantirá que possamos obter o máximo desempenho dos dispositivos Jetson.
-
Atualize a lista de pacotes, instale o pip e atualize para a versão mais recente
sudo apt update sudo apt install python3-pip -y pip install -U pip -
Instalar o pacote pip
ultralyticscom dependências opcionaispip install ultralytics[export] -
Reinicie o dispositivo
sudo reboot
Instalar PyTorch e Torchvision#
A instalação do Ultralytics acima instalará o Torch e o Torchvision. No entanto, esses dois pacotes instalados via pip não são compatíveis com a plataforma Jetson, que é baseada na arquitetura ARM64. Portanto, precisamos instalar manualmente um wheel PyTorch pré-compilado via pip e compilar ou instalar o Torchvision a partir do código-fonte.
Instalar torch 2.10.0 e torchvision 0.25.0 de acordo com o JP6.1
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.10.0-cp310-cp310-linux_aarch64.whl
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.25.0-cp310-cp310-linux_aarch64.whlVisite a página do PyTorch para Jetson para acessar todas as diferentes versões do PyTorch para diferentes versões do JetPack. Para obter uma lista mais detalhada sobre a compatibilidade do PyTorch e do Torchvision, visite a página de compatibilidade do PyTorch e Torchvision.
Instale cuDSS para corrigir um problema de dependência com torch 2.10.0
wget https://developer.download.nvidia.com/compute/cudss/0.7.1/local_installers/cudss-local-tegra-repo-ubuntu2204-0.7.1_0.7.1-1_arm64.deb
sudo dpkg -i cudss-local-tegra-repo-ubuntu2204-0.7.1_0.7.1-1_arm64.deb
sudo cp /var/cudss-local-tegra-repo-ubuntu2204-0.7.1/cudss-*-keyring.gpg /usr/share/keyrings/
sudo apt-get update
sudo apt-get -y install cudssInstalar onnxruntime-gpu#
O pacote onnxruntime-gpu hospedado no PyPI não possui binários aarch64 para o Jetson. Portanto, precisamos instalar este pacote manualmente. Este pacote é necessário para algumas das exportações.
Você pode encontrar todos os pacotes onnxruntime-gpu disponíveis — organizados por versão do JetPack, versão do Python e outros detalhes de compatibilidade — na matriz de compatibilidade do ONNX Runtime do Jetson Zoo.
Para o JetPack 6 com suporte a Python 3.10, você pode instalar onnxruntime-gpu 1.23.0:
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.23.0-cp310-cp310-linux_aarch64.whlAlternativamente, para onnxruntime-gpu 1.20.0:
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.20.0-cp310-cp310-linux_aarch64.whlExecute no JetPack 5.1.2#
Instalar o Pacote Ultralytics#
Aqui, instalaremos o pacote Ultralytics no Jetson com dependências opcionais para que possamos exportar os modelos do PyTorch para outros formatos diferentes. Focaremos principalmente nas exportações para o NVIDIA TensorRT, pois o TensorRT garantirá que possamos obter o máximo desempenho dos dispositivos Jetson.
-
Atualize a lista de pacotes, instale o pip e atualize para a versão mais recente
sudo apt update sudo apt install python3-pip -y pip install -U pip -
Instalar o pacote pip
ultralyticscom dependências opcionaispip install ultralytics[export] -
Reinicie o dispositivo
sudo reboot
Instalar PyTorch e Torchvision#
A instalação do Ultralytics acima instalará o Torch e o Torchvision. No entanto, esses dois pacotes instalados via pip não são compatíveis com a plataforma Jetson, que é baseada na arquitetura ARM64. Portanto, precisamos instalar manualmente um wheel PyTorch pré-compilado via pip e compilar ou instalar o Torchvision a partir do código-fonte.
-
Desinstale o PyTorch e o Torchvision instalados atualmente
pip uninstall torch torchvision -
Instalar
torch 2.1.0etorchvision 0.16.2de acordo com o JP5.1.2pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.16.2+c6f3977-cp38-cp38-linux_aarch64.whl
Visite a página do PyTorch para Jetson para acessar todas as diferentes versões do PyTorch para diferentes versões do JetPack. Para obter uma lista mais detalhada sobre a compatibilidade do PyTorch e do Torchvision, visite a página de compatibilidade do PyTorch e Torchvision.
Instalar onnxruntime-gpu#
O pacote onnxruntime-gpu hospedado no PyPI não possui binários aarch64 para o Jetson. Portanto, precisamos instalar este pacote manualmente. Este pacote é necessário para algumas das exportações.
Você pode encontrar todos os pacotes onnxruntime-gpu disponíveis — organizados por versão do JetPack, versão do Python e outros detalhes de compatibilidade — na matriz de compatibilidade do ONNX Runtime do Jetson Zoo. Aqui, baixaremos e instalaremos onnxruntime-gpu 1.17.0 com suporte a Python3.8.
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.whlonnxruntime-gpu reverterá automaticamente a versão do NumPy para a mais recente. Portanto, precisamos reinstalar o NumPy para 1.23.5 para corrigir um problema executando:
pip install numpy==1.23.5
Use o TensorRT no NVIDIA Jetson#
Entre todos os formatos de exportação de modelos suportados pela Ultralytics, o TensorRT oferece o mais alto desempenho de inferência em dispositivos NVIDIA Jetson, tornando-se nossaprincipal recomendação para implantações no Jetson. Para instruções de configuração e uso avançado, consulte nosso guia de integração dedicado ao TensorRT.
Você também pode exportar a partir do navegador sem configurar o ambiente de build localmente. Na aba Export de modelos da plataforma Ultralytics, selecione o TensorRT e o destino Jetson pretendido. As seleções para Thor são validadas em hardware Thor físico. As seis seleções para Orin produzem atualmente motores candidatos construídos para AGX-Orin; valide-os no SKU Orin pretendido antes da implantação.
O TensorRT perfila e ajusta uma engine em sua GPU de build. Combine a arquitetura de GPU do destino e o runtime do TensorRT/CUDA, e valide cada engine baixada no dispositivo de implantação. SKUs Orin da mesma arquitetura não garantem portabilidade automática, e a calibração INT8 deve usar o dispositivo de destino para obter os melhores resultados.
Converta o modelo para TensorRT e execute a inferência#
O modelo YOLO26n em formato PyTorch é convertido para TensorRT para executar a inferência com o modelo exportado.
from ultralytics import YOLO
# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")
# Export the model to TensorRT
model.export(format="engine") # creates 'yolo26n.engine'
# Load the exported TensorRT model
trt_model = YOLO("yolo26n.engine")
# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")Visite a página Export para acessar argumentos adicionais ao exportar modelos para diferentes formatos de modelo
Use o NVIDIA Deep Learning Accelerator (DLA)#
O NVIDIA Deep Learning Accelerator (DLA) é um componente de hardware especializado integrado aos dispositivos NVIDIA Jetson que otimiza a inferência de deep learning para eficiência energética e desempenho. Ao descarregar tarefas da GPU (liberando-a para processos mais intensivos), o DLA permite que os modelos sejam executados com menor consumo de energia enquanto mantêm alto rendimento, sendo ideal para sistemas embarcados e aplicações de IA em tempo real.
O DLA não é suportado no TensorRT 11.0 e seu retorno está planejado para uma versão futura, portanto, a exportação DLA requer o TensorRT 10.x. No JetPack 6.x/7.x, exporte com uma versão do TensorRT 10.x para usar DLA ou use a GPU para mecanismos do TensorRT 11.0.
Os seguintes dispositivos Jetson estão equipados com hardware DLA:
| Dispositivo Jetson | Núcleos DLA | Frequência Máxima do DLA |
|---|---|---|
| Série Jetson AGX Orin | 2 | 1.6 GHz |
| Jetson Orin NX 16GB | 2 | 614 MHz |
| Jetson Orin NX 8GB | 1 | 614 MHz |
| Série Jetson AGX Xavier | 2 | 1.4 GHz |
| Série Jetson Xavier NX | 2 | 1.1 GHz |
from ultralytics import YOLO
# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")
# Export the model to TensorRT with DLA enabled (only works with FP16 or INT8)
model.export(format="engine", device="dla:0", quantize=16) # dla:0 or dla:1 corresponds to the DLA cores
# Load the exported TensorRT model
trt_model = YOLO("yolo26n.engine")
# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")Ao usar exportações DLA, algumas camadas podem não ser suportadas para execução no DLA e voltarão para a GPU para execução. Esse fallback pode introduzir latência adicional e impactar o desempenho geral da inferência. Portanto, o DLA não foi projetado principalmente para reduzir a latência de inferência em comparação com o TensorRT sendo executado inteiramente na GPU. Em vez disso, seu objetivo principal é aumentar o rendimento e melhorar a eficiência energética.
Benchmarks do NVIDIA Jetson YOLO11/ YOLO26#
Os benchmarks do YOLO11/ YOLO26 foram executados pela equipe da Ultralytics em 11 formatos de modelo diferentes, medindo a velocidade e a precisão: PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN, ExecuTorch. Os benchmarks foram executados no NVIDIA Jetson AGX Thor Developer Kit, NVIDIA Jetson AGX Orin Developer Kit (64GB), NVIDIA Jetson Orin Nano Super Developer Kit e Seeed Studio reComputer J4012 alimentado pelo dispositivo Jetson Orin NX 16GB em precisão FP32 com tamanho de imagem de entrada padrão de 640.
Gráficos de Comparação#
Embora todas as exportações de modelo funcionem no NVIDIA Jetson, incluímos apenas PyTorch, TorchScript, TensorRT no gráfico de comparação abaixo, pois eles fazem uso da GPU no Jetson e garantem os melhores resultados. Todas as outras exportações utilizam apenas a CPU e o desempenho não é tão bom quanto o dos três acima. Você pode encontrar benchmarks para todas as exportações na seção após este gráfico.
NVIDIA Jetson AGX Thor Developer Kit#
NVIDIA Jetson AGX Orin Developer Kit (64GB)#
NVIDIA Jetson Orin Nano Super Developer Kit#
NVIDIA Jetson Orin NX 16GB#
Tabelas de Comparação Detalhadas#
A tabela abaixo representa os resultados de benchmark para cinco modelos diferentes (YOLO11n, YOLO11s, YOLO11m, YOLO11l, YOLO11x) em 11 formatos diferentes (PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN, ExecuTorch), nos dando o status, tamanho, métrica mAP50-95(B) e tempo de inferência para cada combinação.
NVIDIA Jetson AGX Thor Developer Kit#
| Formato | Status | Tamanho em disco (MB) | mAP50-95(B) | Tempo de inferência (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.3 | 0.4798 | 7.39 |
| TorchScript | ✅ | 9.8 | 0.4789 | 4.21 |
| ONNX | ✅ | 9.5 | 0.4767 | 6.58 |
| OpenVINO | ✅ | 10.1 | 0.4794 | 17.50 |
| TensorRT (FP32) | ✅ | 13.9 | 0.4791 | 1.90 |
| TensorRT (FP16) | ✅ | 7.6 | 0.4797 | 1.39 |
| TensorRT (INT8) | ✅ | 6.5 | 0.4273 | 1.52 |
| TF SavedModel | ✅ | 25.7 | 0.4764 | 47.24 |
| TF GraphDef | ✅ | 9.5 | 0.4764 | 45.98 |
| TF Lite | ✅ | 9.9 | 0.4764 | 182.04 |
| MNN | ✅ | 9.4 | 0.4784 | 21.83 |
Testado com Ultralytics 8.4.7
O tempo de inferência não inclui pré/pós-processamento.
NVIDIA Jetson AGX Orin Developer Kit (64GB)#
| Formato | Status | Tamanho em disco (MB) | mAP50-95(B) | Tempo de inferência (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.3 | 0.4790 | 11.58 |
| TorchScript | ✅ | 9.8 | 0.4770 | 4.60 |
| ONNX | ✅ | 9.5 | 0.4770 | 9.87 |
| OpenVINO | ✅ | 9.6 | 0.4820 | 28.80 |
| TensorRT (FP32) | ✅ | 11.5 | 0.0450 | 4.18 |
| TensorRT (FP16) | ✅ | 7.9 | 0.0450 | 2.62 |
| TensorRT (INT8) | ✅ | 5.4 | 0.4640 | 2.30 |
| TF SavedModel | ✅ | 24.6 | 0.4760 | 71.10 |
| TF GraphDef | ✅ | 9.5 | 0.4760 | 70.02 |
| TF Lite | ✅ | 9.9 | 0.4760 | 227.94 |
| MNN | ✅ | 9.4 | 0.4760 | 32.46 |
| NCNN | ✅ | 9.3 | 0.4810 | 29.93 |
Avaliado com Ultralytics 8.4.32
O tempo de inferência não inclui pré/pós-processamento.
NVIDIA Jetson Orin Nano Super Developer Kit#
| Formato | Status | Tamanho em disco (MB) | mAP50-95(B) | Tempo de inferência (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.3 | 0.4790 | 15.60 |
| TorchScript | ✅ | 9.8 | 0.4770 | 12.60 |
| ONNX | ✅ | 9.5 | 0.4760 | 15.76 |
| OpenVINO | ✅ | 9.6 | 0.4820 | 56.23 |
| TensorRT (FP32) | ✅ | 11.3 | 0.4770 | 7.53 |
| TensorRT (FP16) | ✅ | 8.1 | 0.4800 | 4.57 |
| TensorRT (INT8) | ✅ | 5.3 | 0.4490 | 3.80 |
| TF SavedModel | ✅ | 24.6 | 0.4760 | 118.33 |
| TF GraphDef | ✅ | 9.5 | 0.4760 | 116.30 |
| TF Lite | ✅ | 9.9 | 0.4760 | 286.00 |
| MNN | ✅ | 9.4 | 0.4760 | 68.77 |
| NCNN | ✅ | 9.3 | 0.4810 | 47.50 |
Avaliado com Ultralytics 8.4.33
O tempo de inferência não inclui pré/pós-processamento.
NVIDIA Jetson Orin NX 16GB#
| Formato | Status | Tamanho em disco (MB) | mAP50-95(B) | Tempo de inferência (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.3 | 0.4799 | 13.90 |
| TorchScript | ✅ | 9.8 | 0.4787 | 11.60 |
| ONNX | ✅ | 9.5 | 0.4763 | 14.18 |
| OpenVINO | ✅ | 9.6 | 0.4819 | 40.19 |
| TensorRT (FP32) | ✅ | 11.4 | 0.4770 | 7.01 |
| TensorRT (FP16) | ✅ | 8.0 | 0.4789 | 4.13 |
| TensorRT (INT8) | ✅ | 5.5 | 0.4489 | 3.49 |
| TF SavedModel | ✅ | 24.6 | 0.4764 | 92.34 |
| TF GraphDef | ✅ | 9.5 | 0.4764 | 92.06 |
| TF Lite | ✅ | 9.9 | 0.4764 | 254.43 |
| MNN | ✅ | 9.4 | 0.4760 | 48.55 |
| NCNN | ✅ | 9.3 | 0.4805 | 34.31 |
Avaliado com Ultralytics 8.4.33
O tempo de inferência não inclui pré/pós-processamento.
Explore mais iniciativas de benchmarking da Seeed Studio rodando em diferentes versões de hardware NVIDIA Jetson.
Reproduza os Nossos Resultados#
Para reproduzir os benchmarks da Ultralytics acima em todos os formatos de exportação, execute este código:
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Benchmark YOLO11n speed and accuracy on the COCO128 dataset for all export formats
results = model.benchmark(data="coco128.yaml", imgsz=640)Observe que os resultados dos benchmarks podem variar com base na configuração exata de hardware e software de um sistema, bem como na carga de trabalho atual do sistema no momento em que os benchmarks são executados. Para obter os resultados mais confiáveis, use um conjunto de dados com um grande número de imagens, por exemplo, data='coco.yaml' (5000 imagens de validação).
Melhores Práticas ao utilizar o NVIDIA Jetson#
Ao utilizar o NVIDIA Jetson, existem algumas melhores práticas a seguir para permitir o desempenho máximo no NVIDIA Jetson ao executar o YOLO26.
-
Ativa o Modo de Energia MAX
Ativar o Modo de Energia MAX no Jetson garantirá que todos os núcleos de CPU e GPU estejam ligados.
sudo nvpmodel -m 0 -
Ativa os Clocks do Jetson
Ativar os Clocks do Jetson garantirá que todos os núcleos de CPU e GPU funcionem à sua frequência máxima.
sudo jetson_clocks -
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 de CPU, GPU, RAM, alterar modos de energia, definir os clocks máximos e verificar informações do JetPack
sudo apt update sudo pip install jetson-stats sudo reboot jtop
Dicas de Otimização de Memória para NVIDIA Jetson#
A memória disponível costuma ser o fator limitante em dispositivos Jetson, particularmente em variantes com menos memória, como o Jetson Orin Nano (8 GB) ou o Orin NX 8 GB. As dicas abaixo são alterações práticas e de baixo risco que podem, coletivamente, liberar várias centenas de megabytes e permitir que você execute modelos YOLO maiores ou suporte cargas de trabalho paralelas adicionais. Para uma abordagem abrangente, consulte o blog da NVIDIA sobre como maximizar a eficiência de memória no Jetson.
1. Muda para Boot Headless (Sem GUI)#
Se o teu Jetson estiver ligado via SSH ou a funcionar como um dispositivo de produção sem um monitor ligado, eliminar o ambiente de trabalho e o servidor de visualização pode recuperar até 865 MB de RAM:
sudo systemctl set-default multi-user.target
sudo rebootPara restaurar o ambiente de trabalho mais tarde:
sudo systemctl set-default graphical.target
sudo reboot2. Desativa Serviços de Sistema Não Utilizados#
Serviços em segundo plano não essenciais (Bluetooth, gestores de conectividade, daemons de hardware não utilizados) consomem cerca de 32 MB no total. Lista os serviços ativos e desativa tudo o que a tua implementação não necessite:
# List running services
systemctl list-units --type=service --state=running
# Disable a service
sudo systemctl disable SERVICE_NAME3. Perfil de Utilização de Memória#
Antes de otimizar, identifique quais processos estão realmente consumindo RAM. procrank classifica os processos por PSS (Proportional Set Size), que reflete o uso real de memória por processo com mais precisão do que o RSS (Resident Set Size, o total de páginas de RAM física mapeadas por um processo, incluindo páginas compartilhadas com outros processos):
git clone https://github.com/csimmonds/procrank_linux.git
cd procrank_linux && make
sudo ./procrankPara ver as alocações de GPU e NvMap (pipeline CUDA/vídeo) por processo:
sudo cat /sys/kernel/debug/nvmap/iovmm/clients4. Executa a Inferência Sem Monitor em Produção#
Para pipelines de inferência que não têm requisitos de visualização em tempo real, desativar componentes relacionados com o ecrã (Tiler, OSD, DisplaySink) pode poupar 200+ MB apenas do pipeline. Com a Ultralytics YOLO, suprime o visualizador e escreve os resultados no disco:
from ultralytics import YOLO
model = YOLO("yolo11n.engine")
# show=False prevents any display window; save=True writes annotated output to disk
results = model.predict(source="video.mp4", show=False, save=True)Impacto Acumulado#
| Otimização | Memória Aprox. Poupada |
|---|---|
| Desativar GUI do ambiente de trabalho | ~865 MB |
| Desativar serviços do SO não utilizados | ~32 MB |
| Pipeline de inferência headless (sem ecrã) | ~200+ MB |
| Total (ganhos fáceis) | ~1 GB+ |
Combinar estas alterações é especialmente valioso ao direcionar modelos TensorRT INT8 em dispositivos com limitações de memória — pode ser a diferença entre conseguir ou não adaptar uma variante de modelo maior na memória.
Próximos Passos#
Para mais aprendizado e suporte, consulte a documentação do Ultralytics YOLO26.
FAQ#
A implantação do Ultralytics YOLO26 em dispositivos NVIDIA Jetson é um processo simples. Primeiro, flasheie seu dispositivo Jetson com o NVIDIA JetPack SDK. Em seguida, use uma imagem Docker pré-construída para uma configuração rápida ou instale manualmente os pacotes necessários. Passos detalhados para cada abordagem podem ser encontrados nas seções Quick Start with Docker e Start with Native Installation.
Os modelos YOLO11 foram testados em vários dispositivos NVIDIA Jetson, mostrando melhorias significativas de desempenho. Por exemplo, o formato TensorRT oferece o melhor desempenho de inferência. A tabela na seção Detailed Comparison Tables fornece uma visão abrangente de métricas de desempenho, como o mAP50-95 e o tempo de inferência em diferentes formatos de modelo.
O TensorRT é altamente recomendado para implantar modelos YOLO26 no NVIDIA Jetson devido ao seu desempenho ideal. Ele acelera a inferência aproveitando as capacidades da GPU do Jetson, garantindo máxima eficiência e velocidade. Saiba mais sobre como converter para o TensorRT e executar a inferência na seção Use TensorRT on NVIDIA Jetson.
Para instalar o PyTorch e o Torchvision no NVIDIA Jetson, primeiro desinstale quaisquer versões existentes que possam ter sido instaladas via pip. Em seguida, instale manualmente as versões compatíveis do PyTorch e do Torchvision para a arquitetura ARM64 do Jetson. Instruções detalhadas para esse processo são fornecidas na seção Install PyTorch and Torchvision.
Para maximizar o desempenho no NVIDIA Jetson com o YOLO26, siga estas melhores práticas:
- Ative o modo MAX Power para utilizar todos os núcleos de CPU e GPU.
- Ative os Jetson Clocks para executar todos os núcleos em sua frequência máxima.
- Instale o aplicativo Jetson Stats para monitorar métricas do sistema.
Para comandos e detalhes adicionais, consulte a seção Best Practices when using NVIDIA Jetson.
A RAM disponível costuma ser o gargalo em dispositivos Jetson com menos memória. Três vitórias fáceis que juntas podem recuperar mais de 1 GB:
- Mude para a inicialização em modo de texto (headless) (
sudo systemctl set-default multi-user.target) para eliminar a interface gráfica de desktop (cerca de 865 MB economizados). - Desative serviços não utilizados, como Bluetooth ou gerenciadores de conectividade (~32 MB economizados).
- Execute a inferência sem exibir gráficos definindo
show=Falseem sua chamada do YOLOpredict, o que evita alocar memória para o pipeline de exibição (mais de 200 MB economizados).
Use
procrankpara monitorar o uso de RAM por processo esudo cat /sys/kernel/debug/nvmap/iovmm/clientspara inspecionar as alocações da GPU. Consulte a seção Memory Optimization Tips para obter todos os detalhes.- Mude para a inicialização em modo de texto (headless) (
O TensorRT 10.3.0 fornecido com o JetPack 6 tem um problema conhecido que impede a criação de engines INT8 quando
end2end=Trueestá ativado. Quando o Ultralytics detecta essa combinação, ele desativa automaticamente a ramificação end2end para garantir que a exportação seja bem-sucedida.Para restaurar as exportações INT8 end2end, atualize o TensorRT para uma versão mais recente (por exemplo, 10.7.0+):
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/arm64/cuda-keyring_1.1-1_all.deb sudo dpkg -i cuda-keyring_1.1-1_all.deb sudo apt-get update sudo apt-get install -y tensorrtApós a atualização, execute sua exportação novamente. Para mais detalhes, consulte a issue #23841 no GitHub.