Guia de início rápido: NVIDIA Jetson com Ultralytics YOLO26#
Este guia abrangente fornece um passo a passo detalhado para implementar o Ultralytics YOLO26 em dispositivos NVIDIA Jetson. Além disso, apresenta benchmarks de desempenho para demonstrar as capacidades do YOLO26 nestes dispositivos pequenos e potentes.
Atualizámos este guia com o mais recente NVIDIA Jetson AGX Thor Developer Kit, que oferece até 2070 TFLOPS FP4 de computação de IA e 128 GB de memória, com potência configurável entre 40 W e 130 W. Oferece mais de 7,5 vezes mais computação de IA do que o NVIDIA Jetson AGX Orin, com uma eficiência energética 3,5 vezes superior para executar sem problemas 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), a executar o mais recente JetPack 7.2 estável; com o NVIDIA Jetson Orin Nano Super Developer Kit, a executar a versão JetPack de JP6.1; com o Seeed Studio reComputer J4012, baseado no NVIDIA Jetson Orin NX 16GB e a executar a versão JetPack de JP6.0/ a versão JetPack de JP5.1.3; e com o Seeed Studio reComputer J1020 v2, baseado no NVIDIA Jetson Nano 4GB e a executar a versão JetPack de JP4.6.1. Espera-se que funcione em toda a linha de hardware NVIDIA Jetson, incluindo os dispositivos mais recentes e antigos.
O que é o NVIDIA Jetson?#
O NVIDIA Jetson é uma série de placas de computação incorporadas concebidas para levar a computação de IA acelerada a dispositivos de edge. Estes dispositivos compactos e potentes baseiam-se na arquitetura de GPU da NVIDIA e podem executar algoritmos complexos de IA e modelos de aprendizagem profunda diretamente no dispositivo, sem depender de recursos de computação na cloud. 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 realizada localmente, com baixa latência e elevada eficiência. Além disso, estas placas baseiam-se na arquitetura ARM64 e funcionam com um consumo energético inferior ao dos dispositivos tradicionais de computação com GPU.
Comparação da série NVIDIA Jetson#
O NVIDIA Jetson AGX Thor é a mais recente iteração da família NVIDIA Jetson, baseada na arquitetura NVIDIA Blackwell, que proporciona um desempenho de IA drasticamente melhorado em comparação com as gerações anteriores. A tabela abaixo compara alguns dos dispositivos Jetson do 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, 2560 núcleos e 96 Tensor Cores | GPU com arquitetura NVIDIA Ampere, 2048 núcleos e 64 Tensor Cores | GPU com arquitetura NVIDIA Ampere, 1024 núcleos e 32 Tensor Cores | GPU com arquitetura NVIDIA Ampere, 1024 núcleos e 32 Tensor Cores | GPU com arquitetura NVIDIA Volta, 512 núcleos e 64 Tensor Cores | GPU com arquitetura NVIDIA Volta™, 384 núcleos e 48 Tensor Cores | GPU com arquitetura NVIDIA Maxwell™, 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 64 bits e 14 núcleos, 1MB de L2 + 16MB de L3 | CPU NVIDIA Arm® Cortex A78AE v8.2 de 64 bits e 12 núcleos, 3MB de L2 + 6MB de L3 | CPU NVIDIA Arm® Cortex A78AE v8.2 de 64 bits e 8 núcleos, 2MB de L2 + 4MB de L3 | CPU Arm® Cortex®-A78AE v8.2 de 64 bits e 6 núcleos, 1,5MB de L2 + 4MB de L3 | CPU NVIDIA Carmel Arm®v8.2 de 64 bits e 8 núcleos, 8MB de L2 + 4MB de L3 | CPU NVIDIA Carmel Arm®v8.2 de 64 bits e 6 núcleos, 6MB de L2 + 4MB de 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 | 128GB LPDDR5X de 256 bits, 273GB/s | 64GB LPDDR5 de 256 bits, 204.8GB/s | 16GB LPDDR5 de 128 bits, 102.4GB/s | 8GB LPDDR5 de 128 bits, 102 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 consultar uma tabela de comparação mais detalhada, visita a secção Comparar especificações 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 criar aplicações de IA aceleradas de ponta a ponta, reduzindo o tempo de comercialização. O JetPack inclui o Jetson Linux com gestor de arranque, kernel Linux, ambiente de trabalho Ubuntu e um conjunto completo de bibliotecas para aceleração de computação com GPU, multimédia, gráficos e visão computacional. Inclui também exemplos, documentação e ferramentas de desenvolvimento para o computador anfitrião e o kit de desenvolvimento, além de suportar SDKs de nível superior, como o DeepStream para análise de vídeo em streaming, o Isaac para robótica e o Riva para IA conversacional.
Gravar o JetPack no NVIDIA Jetson#
O primeiro passo depois de obteres um dispositivo NVIDIA Jetson é gravar o NVIDIA JetPack no dispositivo. Existem várias formas diferentes de gravar dispositivos NVIDIA Jetson.
- Para o JetPack 7.2 num Jetson AGX Thor, AGX Orin ou Orin Nano Developer Kit oficial, transfere a ISO unificada do Jetson, grava-a numa unidade USB e segue 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 já não utiliza uma imagem de cartão SD transferível; a instalação da ISO através de USB instala o Jetson Linux no cartão microSD ou SSD NVMe do dispositivo.
- Se utilizares intencionalmente o JetPack 6 num Jetson Orin Nano Developer Kit, segue as instruções da NVIDIA para atualizar o JetPack 6.x e utilizar o cartão SD.
- Se tiveres qualquer outro Development Kit da NVIDIA, podes gravar o JetPack no dispositivo utilizando o SDK Manager.
- Se tiveres um dispositivo Seeed Studio reComputer J4012, podes gravar o JetPack no SSD incluído; se tiveres um dispositivo Seeed Studio reComputer J1020 v2, podes gravar o JetPack no eMMC/ SSD.
- Se tiveres qualquer outro dispositivo de terceiros alimentado pelo módulo NVIDIA Jetson, recomenda-se seguir o processo de gravação através da linha de comandos.
Para os métodos 1, 4 e 5 acima, depois de gravares o sistema e iniciares o dispositivo, introduz "sudo apt update && sudo apt install nvidia-jetpack -y" no terminal do dispositivo para instalar todos os componentes JetPack restantes necessários.
Suporte do JetPack por dispositivo Jetson#
A tabela abaixo destaca as versões do NVIDIA JetPack suportadas pelos 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 forma mais rápida de começar a utilizar o Ultralytics YOLO26 no NVIDIA Jetson é executá-lo com imagens Docker pré-criadas para Jetson. Consulta a tabela acima e escolhe a versão do JetPack de acordo com o dispositivo Jetson que tens.
t=ultralytics/ultralytics:latest-jetson-jetpack4
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $tA imagem latest-nvidia-arm64 usa NVIDIA PyTorch 26.08, incluindo CUDA 13.4 e TensorRT 11.2. A NVIDIA lista o JetPack 7.1 para PyTorch em sua tabela de compatibilidade, mas o TensorRT 11.2.1 não oferece suporte ao JetPack, incluindo Thor. Usa esta imagem apenas para cargas de trabalho do PyTorch em um host suportado. Para exportações do TensorRT no Jetson, usa a instalação nativa abaixo com o tempo de execução do TensorRT 10.x suportado pelo teu lançamento do JetPack. O JetPack 7.2 no Thor ou Orin requer validação de contêiner separada. Recompila os motores para a GPU de destino e a versão do TensorRT.
Para imagens do JetPack 4, 5 e 6, continua para Usar TensorRT no NVIDIA Jetson. A imagem do JetPack 7.1 acima é apenas para cargas de trabalho do PyTorch.
Começar com a instalação nativa#
Para uma instalação nativa sem Docker, consulta os passos abaixo.
Executar no JetPack 7.2#
Instalar o pacote Ultralytics#
Aqui vamos instalar o pacote Ultralytics no Jetson. As dependências de exportação são instaladas automaticamente na primeira vez que exportas um modelo, pelo que aqui só é necessário o pacote base. Vamos concentrar-nos principalmente nas exportações NVIDIA TensorRT, porque o TensorRT garante que conseguimos obter o máximo desempenho dos dispositivos Jetson.
-
Atualizar a lista de pacotes, instalar o pip e atualizar para a versão mais recente
sudo apt update sudo apt install python3-pip -y pip install -U pip -
Instalar o pacote pip
ultralyticspip install ultralytics -
Reiniciar o dispositivo
sudo reboot
Instalar PyTorch e Torchvision#
A instalação do ultralytics acima instala Torch e Torchvision. No entanto, estes 2 pacotes instalados através do pip não são compatíveis com dispositivos JetPack 7.2 com CUDA 13. Por isso, temos de os instalar 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#
Usa um wheel de GPU do ONNX Runtime correspondente às tuas versões do JetPack, Python e CUDA. Os lançamentos atuais do PyPI incluem wheels ARM64, mas eles não substituem os pacotes específicos do dispositivo para cada lançamento do JetPack.
Aqui vamos transferir e instalar onnxruntime-gpu 1.24.0 com suporte para Python3.12.
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.24.0-cp312-cp312-linux_aarch64.whlExecutar no JetPack 6.1#
Instalar o pacote Ultralytics#
Aqui vamos instalar o pacote Ultralytics no Jetson. As dependências de exportação são instaladas automaticamente na primeira vez que exportas um modelo, pelo que aqui só é necessário o pacote base. Vamos concentrar-nos principalmente nas exportações NVIDIA TensorRT, porque o TensorRT garante que conseguimos obter o máximo desempenho dos dispositivos Jetson.
-
Atualizar a lista de pacotes, instalar o pip e atualizar para a versão mais recente
sudo apt update sudo apt install python3-pip -y pip install -U pip -
Instalar o pacote pip
ultralyticspip install ultralytics -
Reiniciar o dispositivo
sudo reboot
Instalar PyTorch e Torchvision#
A instalação do ultralytics acima instala Torch e Torchvision. No entanto, estes dois pacotes instalados através do pip não são compatíveis com a plataforma Jetson, que se baseia na arquitetura ARM64. Por isso, temos de instalar manualmente um wheel pip pré-criado do PyTorch 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.whlVisita a página do PyTorch para Jetson para acederes a todas as versões do PyTorch para as diferentes versões do JetPack. Para obteres uma lista mais detalhada da compatibilidade entre PyTorch e Torchvision, visita a página de compatibilidade do PyTorch e Torchvision.
Instala 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#
Usa um wheel de GPU do ONNX Runtime correspondente às tuas versões do JetPack, Python e CUDA. Os lançamentos atuais do PyPI incluem wheels ARM64, mas eles não substituem os pacotes específicos do dispositivo para cada lançamento do JetPack.
Podes 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 para Python 3.10, podes 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.whlEm alternativa, 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.whlExecutar no JetPack 5.1.2#
Instalar o pacote Ultralytics#
Aqui vamos instalar o pacote Ultralytics no Jetson. As dependências de exportação são instaladas automaticamente na primeira vez que exportas um modelo, pelo que aqui só é necessário o pacote base. Vamos concentrar-nos principalmente nas exportações NVIDIA TensorRT, porque o TensorRT garante que conseguimos obter o máximo desempenho dos dispositivos Jetson.
-
Atualizar a lista de pacotes, instalar o pip e atualizar para a versão mais recente
sudo apt update sudo apt install python3-pip -y pip install -U pip -
Instalar o pacote pip
ultralyticspip install ultralytics -
Reiniciar o dispositivo
sudo reboot
Instalar PyTorch e Torchvision#
A instalação do ultralytics acima instala Torch e Torchvision. No entanto, estes dois pacotes instalados através do pip não são compatíveis com a plataforma Jetson, que se baseia na arquitetura ARM64. Por isso, temos de instalar manualmente um wheel pip pré-criado do PyTorch e compilar ou instalar o Torchvision a partir do código-fonte.
-
Desinstalar o PyTorch e o Torchvision atualmente instalados
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
Visita a página do PyTorch para Jetson para acederes a todas as versões do PyTorch para as diferentes versões do JetPack. Para obteres uma lista mais detalhada da compatibilidade entre PyTorch e Torchvision, visita a página de compatibilidade do PyTorch e Torchvision.
Instalar onnxruntime-gpu#
Usa um wheel de GPU do ONNX Runtime correspondente às tuas versões do JetPack, Python e CUDA. Os lançamentos atuais do PyPI incluem wheels ARM64, mas eles não substituem os pacotes específicos do dispositivo para cada lançamento do JetPack.
Podes 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 vamos transferir e instalar onnxruntime-gpu 1.17.0 com suporte para 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 reverte automaticamente a versão do NumPy para a mais recente. Por isso, temos de reinstalar o NumPy para 1.23.5 para corrigir um problema, executando:
pip install numpy==1.23.5
Utilizar 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 a nossa principal recomendação para implantações no Jetson. Antes de exportar, instala as ligações em Python do TensorRT fornecidas para o teu lançamento do JetPack e verifica-as com python3 -c "import tensorrt; print(tensorrt.__version__)". Mantém o tempo de execução do TensorRT 10.x suportado no JetPack 6/7; não o substituas pelo TensorRT 11.2.1. Para instruções de configuração e uso avançado, consulta o nosso guia de integração dedicado do TensorRT.
Também podes exportar a partir do navegador sem configurar localmente o ambiente de compilação. No separador Exportar modelo da Ultralytics Platform, seleciona TensorRT e o destino Jetson pretendido. As seleções Thor são validadas em hardware Thor físico. As seis seleções Orin atualmente produzem engines candidatos compilados para AGX-Orin; valida-os no SKU Orin pretendido antes da implementação.
O TensorRT cria perfis e otimiza um engine na GPU onde é compilado. Faz corresponder a arquitetura de GPU do destino e o runtime TensorRT/CUDA e valida todos os engines transferidos no dispositivo de implementação. Os SKUs Orin com a mesma arquitetura não garantem automaticamente a portabilidade, e a calibração INT8 deve utilizar o dispositivo de destino para obter os melhores resultados.
Converter o modelo para TensorRT e executar 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")Visita a página de Exportação para aceder a argumentos adicionais ao exportar modelos para diferentes formatos de modelo
Usar o Acelerador de Aprendizagem Profunda da NVIDIA (DLA)#
O Acelerador de Aprendizagem Profunda da NVIDIA (DLA) é um componente de hardware especializado integrado nos dispositivos NVIDIA Jetson que otimiza a inferência de aprendizagem profunda para melhorar a eficiência energética e o desempenho. Ao transferir tarefas da GPU (libertando-a para processos mais exigentes), o DLA permite executar modelos com menor consumo de energia, mantendo um elevado débito, o que é ideal para sistemas incorporados e aplicações de IA em tempo real.
A NVIDIA lista o TensorRT 10.7 como o último lançamento com suporte ao DLA; o TensorRT 11.0, 11.1 e 11.2 não oferecem suporte ao DLA. Usa um lançamento do TensorRT compatível com DLA suportado pela tua versão do JetPack. O TensorRT 11.2.1 não oferece suporte ao JetPack, incluindo exportações apenas para GPU.
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 compatíveis com a execução no DLA e passarão para a GPU. Esta alternativa pode introduzir latência adicional e afetar o desempenho geral da inferência. Por isso, o DLA não foi concebido principalmente para reduzir a latência da inferência em comparação com o TensorRT executado inteiramente na GPU. Em vez disso, o seu objetivo principal é aumentar o débito e melhorar a eficiência energética.
Testes de desempenho do YOLO26 no NVIDIA Jetson#
Os testes de desempenho do 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 testes de desempenho foram executados no NVIDIA Jetson AGX Thor Developer Kit, NVIDIA Jetson AGX Orin Developer Kit (64GB), NVIDIA Jetson Orin Nano Super Developer Kit e no dispositivo Seeed Studio reComputer J4012 alimentado pelo 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 modelos funcionem no NVIDIA Jetson, incluímos apenas PyTorch, TorchScript, TensorRT no gráfico de comparação abaixo, porque utilizam a GPU do Jetson e garantem os melhores resultados. Todas as outras exportações utilizam apenas a CPU e o desempenho não é tão bom como o dos três formatos acima. Podes encontrar benchmarks de todas as exportações na secção seguinte a 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 dos testes de desempenho para cinco modelos diferentes (YOLO26n, YOLO26s, YOLO26m, YOLO26l, YOLO26x) em 11 formatos diferentes (PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN, ExecuTorch), fornecendo o status, o tamanho, a métrica mAP50-95(B) e o tempo de inferência para cada combinação.
NVIDIA Jetson AGX Thor Developer Kit#
| Formato | Estado | 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 |
Benchmark executado com Ultralytics 8.4.7
O tempo de inferência não inclui o pré-processamento nem o pós-processamento.
NVIDIA Jetson AGX Orin Developer Kit (64GB)#
| Formato | Estado | 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 |
Benchmark executado com Ultralytics 8.4.32
O tempo de inferência não inclui o pré-processamento nem o pós-processamento.
NVIDIA Jetson Orin Nano Super Developer Kit#
| Formato | Estado | 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 |
Benchmark executado com Ultralytics 8.4.33
O tempo de inferência não inclui o pré-processamento nem o pós-processamento.
NVIDIA Jetson Orin NX 16GB#
| Formato | Estado | 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 |
Benchmark executado com Ultralytics 8.4.33
O tempo de inferência não inclui o pré-processamento nem o pós-processamento.
Explora mais esforços de benchmarking da Seeed Studio executados em diferentes versões do hardware NVIDIA Jetson.
Reproduzir os nossos resultados#
Para reproduzir os benchmarks do Ultralytics acima em todos os formatos de exportação, executa este código:
from ultralytics import YOLO
# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")
# Benchmark YOLO26n speed and accuracy on the COCO128 dataset for all export formats
results = model.benchmark(data="coco128.yaml", imgsz=640)Tem em atenção que os resultados dos benchmarks podem variar consoante a configuração exata de hardware e software de um sistema, bem como a carga atual do sistema no momento da execução dos benchmarks. Para obteres resultados mais fiáveis, utiliza um conjunto de dados com um grande número de imagens, por exemplo, data='coco.yaml' (5000 imagens de validação).
Práticas recomendadas ao usar o NVIDIA Jetson#
Ao usar o NVIDIA Jetson, há algumas práticas recomendadas a seguir para permitir o desempenho máximo no NVIDIA Jetson com YOLO26.
-
Ativar o modo de potência MAX
Ativar o modo de potência MAX no Jetson garante que todos os núcleos da CPU e da GPU estão ligados.
sudo nvpmodel -m 0 -
Ativar os Jetson Clocks
Ativar os Jetson Clocks garante que todos os núcleos da CPU e da GPU funcionam à frequência máxima.
sudo jetson_clocks -
Instalar a aplicação Jetson Stats
Podemos usar a aplicação jetson stats para monitorizar as temperaturas dos componentes do sistema e verificar outros detalhes do sistema, como a utilização da CPU, GPU e RAM, alterar os modos de potência, definir as frequências máximas e verificar as informações do JetPack
sudo apt update sudo pip install jetson-stats sudo reboot jtop
Dicas de otimização da memória para NVIDIA Jetson#
A memória disponível é frequentemente o fator limitante nos dispositivos Jetson, sobretudo nas 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, em conjunto, podem libertar várias centenas de megabytes e permitir executar modelos YOLO maiores ou suportar cargas de trabalho paralelas adicionais. Para uma abordagem abrangente, consulta o blogue da NVIDIA sobre como maximizar a eficiência da memória no Jetson.
1. Mudar para o arranque sem interface gráfica (headless)#
Se o teu Jetson estiver ligado através de SSH ou for executado como um dispositivo de produção sem um ecrã ligado, eliminar o ambiente de trabalho e o servidor de ecrã 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. Desativar serviços do sistema não utilizados#
Os serviços em segundo plano não essenciais (Bluetooth, gestores de conectividade e 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 necessitar:
# List running services
systemctl list-units --type=service --state=running
# Disable a service
sudo systemctl disable SERVICE_NAME3. Analisar a utilização da memória#
Antes de otimizar, identifica quais os processos que estão realmente a consumir RAM. procrank ordena os processos por PSS (Proportional Set Size), que reflete de forma mais precisa a ocupação de memória real por processo do que RSS (Resident Set Size, o total de páginas de RAM física mapeadas por um processo, incluindo páginas partilhadas 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. Executar a inferência sem ecrã em produção#
Para pipelines de inferência que não requerem pré-visualização em direto, desativar os componentes relacionados com o ecrã (Tiler, OSD, DisplaySink) pode poupar 200+ MB apenas no pipeline. Com o Ultralytics YOLO, suprime o visualizador e grava os resultados no disco:
from ultralytics import YOLO
model = YOLO("yolo26n.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 cumulativo#
| Otimização | Memória poupada aprox. |
|---|---|
| Desativar a interface gráfica do ambiente de trabalho | ~865 MB |
| Desativar serviços do SO não utilizados | ~32 MB |
| Pipeline de inferência sem interface gráfica (sem ecrã) | ~200+ MB |
| Total (otimizações fáceis) | ~1 GB+ |
Combinar estas alterações é especialmente útil ao utilizar modelos TensorRT INT8 em dispositivos com memória limitada — pode fazer a diferença entre conseguir ou não manter na memória uma variante de modelo maior.
Próximas etapas#
Para obter mais informações e suporte, consulta a documentação do Ultralytics YOLO26.
Perguntas frequentes#
A implementação do Ultralytics YOLO26 em dispositivos NVIDIA Jetson é um processo simples. Primeiro, instala o dispositivo Jetson com o NVIDIA JetPack SDK. Depois, usa uma imagem Docker pré-compilada para uma configuração rápida ou instala manualmente os pacotes necessários. Podes encontrar instruções detalhadas para cada abordagem nas secções Início rápido com Docker e Começar com a instalação nativa.
Os modelos YOLO26 foram testados quanto ao desempenho 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 mAP50-95 e tempo de inferência em diferentes formatos de modelo.
O TensorRT é altamente recomendado para implementar modelos YOLO26 no NVIDIA Jetson devido ao seu desempenho otimizado. Acelera a inferência utilizando as capacidades da GPU do Jetson, garantindo a máxima eficiência e velocidade. Aprende mais sobre como converter para TensorRT e executar a inferência na secção Usar TensorRT no NVIDIA Jetson.
Para instalar PyTorch e Torchvision no NVIDIA Jetson, primeiro desinstala quaisquer versões existentes que possam ter sido instaladas através do pip. Depois, instala manualmente as versões compatíveis do PyTorch e Torchvision para a arquitetura ARM64 do Jetson. As instruções detalhadas para este processo estão disponíveis na secção Instalar PyTorch e Torchvision.
Para maximizar o desempenho no NVIDIA Jetson com YOLO26, segue estas práticas recomendadas:
- Ativa o modo de potência MAX para utilizar todos os núcleos da CPU e da GPU.
- Ativa os Jetson Clocks para executar todos os núcleos à frequência máxima.
- Instala a aplicação Jetson Stats para monitorizar as métricas do sistema.
Para obter comandos e detalhes adicionais, consulta a secção Práticas recomendadas ao usar o NVIDIA Jetson.
A RAM disponível é frequentemente o estrangulamento nos dispositivos Jetson com menos memória. Três otimizações fáceis que, em conjunto, podem recuperar mais de 1 GB:
- Mudar para o arranque sem interface gráfica (
sudo systemctl set-default multi-user.target) para eliminar a interface gráfica do ambiente de trabalho (~865 MB poupados). - Desativar serviços não utilizados, como o Bluetooth ou os gestores de conectividade (~32 MB poupados).
- Executar a inferência sem ecrã definindo
show=Falsena chamadapredictdo teu YOLO, o que evita alocar memória para o pipeline de ecrã (~200+ MB poupados).
Usa
procrankpara analisar a utilização de RAM por processo esudo cat /sys/kernel/debug/nvmap/iovmm/clientspara inspecionar as alocações da GPU. Consulta a secção Dicas de otimização da memória para obter todos os detalhes.- Mudar para o arranque sem interface gráfica (
O TensorRT 10.3.0 fornecido com o JetPack 6 tem um problema conhecido que impede a criação de motores INT8 quando
nms=Falseestá ativado. Quando o Ultralytics detecta esta combinação, ele seleciona automaticamente a cabeça um para muitos para garantir que a exportação seja bem-sucedida.Para restaurar as exportações INT8 sem NMS, 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 tensorrtDepois de atualizar, executa novamente a exportação. Para mais detalhes, consulta o problema #23841 no GitHub.