Saltar para o conteúdo

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

Este guia abrangente fornece um passo-a-passo detalhado para a implantação do Ultralytics YOLO11 em dispositivos NVIDIA Jetson. Além disso, apresenta referências de desempenho para demonstrar as capacidades do YOLO11 nestes dispositivos pequenos e potentes.



Ver: Como configurar o NVIDIA Jetson com Ultralytics YOLO11

NVIDIA Ecossistema Jetson

Nota

Este guia foi testado com o Seeed Studio reComputer J4012, que se baseia no NVIDIA Jetson Orin NX 16GB, executando a última versão estável do JetPack do JP6.0, a versão do JetPack do JP5.1.3 e o Seeed Studio reComputer J1020 v2, que se baseia no NVIDIA Jetson Nano 4GB, executando a versão do JetPack do JP4.6.1. Espera-se que funcione em toda a linha de hardware NVIDIA Jetson, incluindo o mais recente e o mais antigo.

O que é NVIDIA Jetson?

NVIDIA A Jetson é uma série de placas de computação incorporadas concebidas para levar a computação acelerada de IA (inteligência artificial) aos dispositivos periféricos. Estes dispositivos compactos e potentes são construídos em torno da arquitetura NVIDIA's GPU e são capazes de executar algoritmos de IA complexos 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 realizada 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.

NVIDIA Comparação da série Jetson

O Jetson Orin é a mais recente iteração da família NVIDIA Jetson baseada na arquitetura NVIDIA Ampere, que proporciona 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 2048 núcleos NVIDIA Arquitetura Ampere GPU com 64 Tensor núcleos 1024 núcleos NVIDIA Arquitetura Ampere GPU com 32 Tensor núcleos 1024 núcleos NVIDIA Arquitetura Ampere GPU com 32 Tensor núcleos 512 núcleos NVIDIA Arquitetura Volta GPU com 64 Tensor núcleos 384 núcleos NVIDIA Arquitetura Volta™ GPU com 48 Tensor núcleos Arquitetura NVIDIA Maxwell™ com 128 núcleos GPU
GPU Frequência máxima 1,3 GHz 918 MHz 625 MHz 1377 MHz 1100 MHz 921MHz
CPU 12 núcleos NVIDIA Arm® Cortex A78AE v8.2 64-bit CPU 3MB L2 + 6MB L3 8 núcleos NVIDIA Arm® Cortex A78AE v8.2 64-bit CPU 2MB L2 + 4MB L3 Arm® Cortex®-A78AE v8.2 de 6 núcleos e 64 bits CPU 1,5 MB L2 + 4 MB L3 8 núcleos NVIDIA Carmel Arm®v8.2 64-bit CPU 8MB L2 + 4MB L3 6 núcleos NVIDIA Carmel Arm®v8.2 64-bit CPU 6MB L2 + 4MB L3 Processador Quad-Core Arm® Cortex®-A57 MPCore
CPU Frequência máxima 2,2 GHz 2,0 GHz 1,5 GHz 2,2 GHz 1,9 GHz 1.43GHz
Memória 64 GB LPDDR5 de 256 bits 204,8 GB/s 16GB LPDDR5 de 128 bits 102,4GB/s 8GB LPDDR5 de 128 bits 68 GB/s 32 GB LPDDR4x de 256 bits 136,5 GB/s 8GB LPDDR4x de 128 bits 59,7GB/s 4GB LPDDR4 de 64 bits 25,6GB/s"

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

O que é o NVIDIA JetPack?

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

Flash JetPack para NVIDIA Jetson

O primeiro passo depois de deitar as mãos a um dispositivo NVIDIA Jetson é fazer o flash do NVIDIA JetPack para o dispositivo. Existem várias formas diferentes de atualizar os dispositivos NVIDIA Jetson.

  1. Se possuir um kit de desenvolvimento oficial NVIDIA , como o kit de desenvolvimento Jetson Orin Nano, pode descarregar uma imagem e preparar um cartão SD com o JetPack para arrancar o dispositivo.
  2. Se possuir qualquer outro NVIDIA Development Kit, pode instalar o JetPack no dispositivo utilizando o SDK Manager.
  3. Se possuir um dispositivo Seeed Studio reComputer J4012, pode instalar o JetPack no SSD incluído e se possuir um dispositivo Seeed Studio reComputer J1020 v2, pode instalar o JetPack no eMMC/SSD.
  4. Se possuir qualquer outro dispositivo de terceiros alimentado pelo módulo NVIDIA Jetson, recomenda-se que siga a linha de comandos para piscar.

Nota

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

Suporte JetPack baseado no dispositivo Jetson

A tabela abaixo destaca as versões do NVIDIA JetPack suportadas por diferentes dispositivos NVIDIA Jetson.

JetPack 4 JetPack 5 JetPack 6
Jetson Nano
Jetson TX2
Jetson Xavier NX
Jetson AGX Xavier
Jetson AGX Orin
Jetson Orin NX
Jetson Orin Nano

Início rápido com o Docker

A maneira mais rápida de começar a usar o Ultralytics YOLO11 no NVIDIA Jetson é executar com imagens de docker pré-construídas para o Jetson. Consulte a tabela acima e escolha a versão do JetPack de acordo com o dispositivo Jetson que possui.

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

Depois de fazer isto, passe à secção Utilizar TensorRT em NVIDIA Jetson.

Começar com a instalação nativa

Para uma instalação nativa sem o Docker, consulte as etapas abaixo.

Executar no JetPack 6.x

Instalar o pacote Ultralytics

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

  1. 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
    
  2. Instalar ultralytics pacote pip com dependências opcionais

    pip install ultralytics[export]
    
  3. Reiniciar 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 para serem executados na plataforma Jetson, que é baseada na arquitetura ARM64. Portanto, precisamos de instalar manualmente o PyTorch pip wheel pré-construído e compilar/instalar o Torchvision a partir da fonte.

Instalar torch 2.3.0 e torchvision 0.18 de acordo com JP6.0

sudo apt-get install libopenmpi-dev libopenblas-base libomp-dev -y
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.3.0-cp310-cp310-linux_aarch64.whl
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.18.0a0+6043bc2-cp310-cp310-linux_aarch64.whl

Visite a páginaPyTorch for Jetson para aceder 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, visite a página de compatibilidade doPyTorch e do Torchvision.

Instalar onnxruntime-gpu

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

Todos diferentes onnxruntime-gpu os pacotes correspondentes às diferentes versões do JetPack e do Python são listados aqui. No entanto, aqui vamos descarregar e instalar onnxruntime-gpu 1.18.0 com Python3.10 apoio.

wget https://nvidia.box.com/shared/static/48dtuob7meiw6ebgfsfqakc9vse62sg4.whl -O onnxruntime_gpu-1.18.0-cp310-cp310-linux_aarch64.whl
pip install onnxruntime_gpu-1.18.0-cp310-cp310-linux_aarch64.whl

Nota

onnxruntime-gpu reverterá automaticamente a versão do numpy para a mais recente. Portanto, precisamos de reinstalar o numpy para 1.23.5 para corrigir um problema através da execução:

pip install numpy==1.23.5

Executar no JetPack 5.x

Instalar o pacote Ultralytics

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

  1. 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
    
  2. Instalar ultralytics pacote pip com dependências opcionais

    pip install ultralytics[export]
    
  3. Reiniciar 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 para serem executados na plataforma Jetson, que é baseada na arquitetura ARM64. Portanto, precisamos de instalar manualmente o PyTorch pip wheel pré-construído e compilar/instalar o Torchvision a partir da fonte.

  1. Desinstalar o PyTorch e o Torchvision atualmente instalados

    pip uninstall torch torchvision
    
  2. Instalar 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. Instalar 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
    

Visite a páginaPyTorch for Jetson para aceder 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, visite a página de compatibilidade doPyTorch e do Torchvision.

Instalar onnxruntime-gpu

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

Todos diferentes onnxruntime-gpu os pacotes correspondentes às diferentes versões do JetPack e do Python são listados aqui. No entanto, aqui vamos descarregar e instalar onnxruntime-gpu 1.17.0 com Python3.8 apoio.

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. Portanto, precisamos de reinstalar o numpy para 1.23.5 para corrigir um problema através da execução:

pip install numpy==1.23.5

Utilizar TensorRT em NVIDIA Jetson

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

Converter o modelo para TensorRT e executar a inferência

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

Exemplo

from ultralytics import YOLO

# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")

# Export the model to TensorRT
model.export(format="engine")  # creates 'yolo11n.engine'

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

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

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

Nota

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

Utilizar NVIDIA Acelerador de Aprendizagem Profunda (DLA)

NVIDIA O Deep Learning Accelerator (DLA) é um componente de hardware especializado incorporado nos dispositivos NVIDIA Jetson que optimiza a inferência de aprendizagem profunda para eficiência energética e desempenho. Ao descarregar tarefas do GPU (libertando-o para processos mais intensivos), o DLA permite que os modelos sejam executados com menor consumo de energia, mantendo um elevado rendimento, ideal para sistemas incorporados e aplicações de IA em tempo real.

Os seguintes dispositivos Jetson estão equipados com hardware DLA:

  • Jetson Orin NX 16GB
  • Série Jetson AGX Orin
  • Série Jetson AGX Xavier
  • Série Jetson Xavier NX

Exemplo

from ultralytics import YOLO

# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")

# Export the model to TensorRT with DLA enabled (only works with FP16 or INT8)
model.export(format="engine", device="dla:0", half=True)  # dla:0 or dla:1 corresponds to the DLA cores

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

# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLO11n PyTorch model to TensorRT format with DLA enabled (only works with FP16 or INT8)
yolo export model=yolo11n.pt format=engine device="dla:0" half=True  # dla:0 or dla:1 corresponds to the DLA cores

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

Nota

Ao utilizar as exportações do DLA, algumas camadas podem não ser suportadas para execução no DLA e voltarão para o GPU para execução. Este retorno pode introduzir latência adicional e afetar o desempenho geral da inferência. Por conseguinte, o DLA não foi concebido principalmente para reduzir a latência da inferência em comparação com o TensorRT que funciona inteiramente no GPU. Em vez disso, o seu objetivo principal é aumentar o rendimento e melhorar a eficiência energética.

NVIDIA Jetson Orin YOLO11 Referências

YOLO11 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 efectuados no Seeed Studio reComputer J4012 equipado com o 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, incluímos apenas PyTorch, TorchScript, TensorRT no 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 anteriores. Pode encontrar referências para todas as exportações na secção a seguir a este gráfico.

NVIDIA Ecossistema Jetson

Tabela de comparação pormenorizada

A tabela abaixo representa os resultados do teste de referência para cinco modelos diferentes (YOLO11n, YOLO11s, YOLO11m, YOLO11l, YOLO11x) 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 5.4 0.6176 19.80
TorchScript 10.5 0.6100 13.30
ONNX 10.2 0.6082 67.92
OpenVINO 10.4 0.6082 118.21
TensorRT (FP32) 14.1 0.6100 7.94
TensorRT (FP16) 8.3 0.6082 4.80
TensorRT (INT8) 6.6 0.3256 4.17
TF SavedModel 25.8 0.6082 185.88
TF GraphDef 10.3 0.6082 256.66
TF Leve 10.3 0.6082 284.64
PaddlePaddle 20.4 0.6082 477.41
NCNN 10.2 0.6106 32.18
Formato Estado Tamanho no disco (MB) mAP50-95(B) Tempo de inferência (ms/im)
PyTorch 18.4 0.7526 20.20
TorchScript 36.5 0.7416 23.42
ONNX 36.3 0.7416 162.01
OpenVINO 36.4 0.7416 159.61
TensorRT (FP32) 40.3 0.7416 13.93
TensorRT (FP16) 21.7 0.7416 7.47
TensorRT (INT8) 13.6 0.3179 5.66
TF SavedModel 91.1 0.7416 316.46
TF GraphDef 36.4 0.7416 506.71
TF Leve 36.4 0.7416 842.97
PaddlePaddle 72.5 0.7416 1172.57
NCNN 36.2 0.7419 66.00
Formato Estado Tamanho no disco (MB) mAP50-95(B) Tempo de inferência (ms/im)
PyTorch 38.8 0.7595 36.70
TorchScript 77.3 0.7643 50.95
ONNX 76.9 0.7643 416.34
OpenVINO 77.1 0.7643 370.99
TensorRT (FP32) 81.5 0.7640 30.49
TensorRT (FP16) 42.2 0.7658 14.93
TensorRT (INT8) 24.3 0.4118 10.32
TF SavedModel 192.7 0.7643 597.08
TF GraphDef 77.0 0.7643 1016.12
TF Leve 77.0 0.7643 2494.60
PaddlePaddle 153.8 0.7643 3218.99
NCNN 76.8 0.7691 192.77
Formato Estado Tamanho no disco (MB) mAP50-95(B) Tempo de inferência (ms/im)
PyTorch 49.0 0.7475 47.6
TorchScript 97.6 0.7250 66.36
ONNX 97.0 0.7250 532.58
OpenVINO 97.3 0.7250 477.55
TensorRT (FP32) 101.6 0.7250 38.71
TensorRT (FP16) 52.6 0.7265 19.35
TensorRT (INT8) 31.6 0.3856 13.50
TF SavedModel 243.3 0.7250 895.24
TF GraphDef 97.2 0.7250 1301.19
TF Leve 97.2 0.7250 3202.93
PaddlePaddle 193.9 0.7250 4206.98
NCNN 96.9 0.7252 225.75
Formato Estado Tamanho no disco (MB) mAP50-95(B) Tempo de inferência (ms/im)
PyTorch 109.3 0.8288 85.60
TorchScript 218.1 0.8308 121.67
ONNX 217.5 0.8308 1073.14
OpenVINO 217.8 0.8308 955.60
TensorRT (FP32) 221.6 0.8307 75.84
TensorRT (FP16) 113.1 0.8295 35.75
TensorRT (INT8) 62.2 0.4783 22.23
TF SavedModel 545.0 0.8308 1497.40
TF GraphDef 217.8 0.8308 2552.42
TF Leve 217.8 0.8308 7044.58
PaddlePaddle 434.9 0.8308 8386.73
NCNN 217.3 0.8304 486.36

Explore 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 os valores de referência Ultralytics acima referidos em todos os formatos de exportação, execute este código:

Exemplo

from ultralytics import YOLO

# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")

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

Note-se 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, utilize 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).

Melhores práticas ao utilizar NVIDIA Jetson

Ao utilizar o NVIDIA Jetson, existem algumas práticas recomendadas a seguir para permitir o máximo desempenho no NVIDIA Jetson com o YOLO11.

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

    A ativação do modo MAX Power no Jetson garante que todos os núcleos CPU, GPU estão ligados.

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

    A ativação dos relógios Jetson garante que todos os núcleos CPU, GPU têm o seu relógio na frequência máxima.

    sudo jetson_clocks
    
  3. Instalar 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 CPU, GPU, utilização da RAM, alterar os modos de energia, definir 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 ter configurado com êxito o YOLO11 no seu NVIDIA Jetson! Para mais informações e suporte, visite mais guias em Ultralytics YOLO11 Docs!

FAQ

Como posso implementar Ultralytics YOLO11 em dispositivos NVIDIA Jetson?

A implantação do Ultralytics YOLO11 em dispositivos NVIDIA Jetson é um processo simples. Primeiro, instale o seu dispositivo Jetson com o SDK JetPack NVIDIA . Em seguida, utilize uma imagem Docker pré-construída para uma configuração rápida ou instale manualmente os pacotes necessários. Os passos detalhados para cada abordagem podem ser encontrados nas secções Início rápido com o Docker e Início com a instalação nativa.

Que referências de desempenho posso esperar dos modelos YOLO11 em dispositivos NVIDIA Jetson?

YOLO11 foram comparados em vários dispositivos NVIDIA Jetson, mostrando melhorias significativas no desempenho. Por exemplo, o formato TensorRT oferece o melhor desempenho de inferência. A tabela na secção Tabela de comparação detalhada fornece uma visão abrangente das métricas de desempenho como o mAP50-95 e o tempo de inferência em diferentes formatos de modelo.

Por que razão devo utilizar TensorRT para implementar YOLO11 em NVIDIA Jetson?

TensorRT é altamente recomendado para a implementação de modelos YOLO11 em NVIDIA Jetson devido ao seu ótimo desempenho. Ele acelera a inferência aproveitando os recursos GPU do Jetson, garantindo máxima eficiência e velocidade. Saiba mais sobre como converter para TensorRT e executar a inferência na secção Utilizar TensorRT em NVIDIA Jetson.

Como posso instalar o PyTorch e o Torchvision no 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. São fornecidas instruções detalhadas para este processo na secção Instalar o PyTorch e o Torchvision.

Quais são as práticas recomendadas para maximizar o desempenho em NVIDIA Jetson ao usar YOLO11?

Para maximizar o desempenho em NVIDIA Jetson com YOLO11, siga estas práticas recomendadas:

  1. Ativar o modo de alimentação MAX para utilizar todos os núcleos CPU e GPU .
  2. Ativar os relógios Jetson para executar todos os núcleos na sua frequência máxima.
  3. Instale a aplicação Jetson Stats para monitorizar as métricas do sistema.

Para obter comandos e detalhes adicionais, consulte a secção Melhores práticas ao utilizar o NVIDIA Jetson.

📅C riado há 8 meses ✏️ Atualizado há 3 dias

Comentários