Guida rapida: NVIDIA Jetson con Ultralytics YOLO11
Questa guida completa fornisce una procedura dettagliata per il deployment di Ultralytics YOLO11 su dispositivi NVIDIA Jetson. Inoltre, presenta benchmark delle prestazioni per dimostrare le capacità di YOLO11 su questi dispositivi piccoli e potenti.
Nuovo supporto per i prodotti
Abbiamo aggiornato questa guida con l'ultimo NVIDIA Jetson Orin Nano Super Developer Kit che offre fino a 67 TOPS di prestazioni AI, un miglioramento di 1,7 volte rispetto al suo predecessore, per eseguire senza problemi i modelli AI più diffusi.
Guarda: Come utilizzare Ultralytics YOLO11 su dispositivi NVIDIA JETSON
Nota
Questa guida è stata testata con NVIDIA Jetson AGX Orin Developer Kit (64GB) con l'ultima versione stabile di JetPack JP6.2, NVIDIA Jetson Orin Nano Super Developer Kit con la versione JetPack JP6.1, Seeed Studio reComputer J4012 basato su NVIDIA Jetson Orin NX 16GB con la versione JetPack JP6.0/ JetPack release di JP5.1.3 e Seeed Studio reComputer J1020 v2 basato su NVIDIA Jetson Nano 4GB con la versione JetPack JP4.6.1. Si prevede che funzioni su tutta la linea hardware NVIDIA Jetson, comprese le versioni più recenti e quelle precedenti.
Cos'è NVIDIA Jetson?
NVIDIA Jetson è una serie di schede embedded progettate per portare l'elaborazione accelerata dell'AI (intelligenza artificiale) sui dispositivi edge. Questi dispositivi compatti e potenti sono costruiti attorno all'architettura GPU di NVIDIA e sono in grado di eseguire complessi algoritmi di AI e modelli di deep learning direttamente sul dispositivo, senza la necessità di fare affidamento sulle risorse di cloud computing. Le schede Jetson sono spesso utilizzate nella robotica, nei veicoli autonomi, nell'automazione industriale e in altre applicazioni in cui l'inferenza AI deve essere eseguita localmente con bassa latenza ed elevata efficienza. Inoltre, queste schede si basano sull'architettura ARM64 e funzionano con un consumo energetico inferiore rispetto ai tradizionali dispositivi di elaborazione GPU.
Confronto tra le serie NVIDIA Jetson
Jetson Orin è l'ultima iterazione della famiglia NVIDIA Jetson basata sull'architettura NVIDIA Ampere che offre prestazioni AI drasticamente migliorate rispetto alle generazioni precedenti. La tabella seguente confronta alcuni dei dispositivi Jetson nell'ecosistema.
Jetson AGX Orin 64GB | Jetson Orin NX 16GB | Jetson Orin Nano Super | Jetson AGX Xavier | Jetson Xavier NX | Jetson Nano | |
---|---|---|---|---|---|---|
Prestazioni AI | 275 TOPS | 100 TOPS | 67 TOPs | 32 TOPS | 21 TOPS | 472 GFLOPS |
GPU | GPU NVIDIA Architettura Ampere a 2048 core con 64 Tensor Core | GPU NVIDIA Ampere architecture da 1024 core con 32 Tensor Core | GPU NVIDIA Ampere architecture da 1024 core con 32 Tensor Core | GPU NVIDIA con architettura Volta a 512 core e 64 Tensor Core | GPU NVIDIA Volta™ con architettura a 384 core e 48 Tensor Core | GPU NVIDIA Maxwell™ architecture da 128 core |
Frequenza massima della GPU | 1.3 GHz | 918 MHz | 1020 MHz | 1377 MHz | 1100 MHz | 921MHz |
CPU | CPU NVIDIA Arm® Cortex A78AE v8.2 a 64 bit da 12 core 3MB L2 + 6MB L3 | CPU 8-core NVIDIA Arm® Cortex A78AE v8.2 64-bit 2MB L2 + 4MB L3 | CPU Arm® Cortex®-A78AE v8.2 a 6 core, 64 bit, 1,5 MB L2 + 4 MB L3 | CPU 8-core NVIDIA Carmel Arm®v8.2 64-bit 8MB L2 + 4MB L3 | CPU NVIDIA Carmel Arm®v8.2 a 6 core, 64 bit, 6 MB L2 + 4 MB L3 | Processore Quad-Core Arm® Cortex®-A57 MPCore |
Frequenza massima della CPU | 2.2 GHz | 2.0 GHz | 1.7 GHz | 2.2 GHz | 1.9 GHz | 1.43GHz |
Memoria | 64 GB LPDDR5 a 256 bit 204,8 GB/s | 16GB 128-bit LPDDR5 102.4GB/s | 8GB 128-bit LPDDR5 102 GB/s | 32GB 256-bit LPDDR4x 136.5GB/s | 8GB 128-bit LPDDR4x 59.7GB/s | 4GB 64-bit LPDDR4 25.6GB/s" |
Per una tabella di confronto più dettagliata, visitare la sezione Specifiche tecniche della pagina ufficiale di NVIDIA Jetson.
Cos'è NVIDIA JetPack?
NVIDIA JetPack SDK che alimenta i moduli Jetson è la soluzione più completa e fornisce un ambiente di sviluppo completo per la creazione di applicazioni AI accelerate end-to-end e riduce i tempi di commercializzazione. JetPack include Jetson Linux con bootloader, kernel Linux, ambiente desktop Ubuntu e un set completo di librerie per l'accelerazione del calcolo GPU, multimedia, grafica e computer vision. Include anche esempi, documentazione e strumenti per sviluppatori sia per computer host che per kit di sviluppo e supporta SDK di livello superiore come DeepStream per l'analisi di video in streaming, Isaac per la robotica e Riva per l'AI conversazionale.
Flash JetPack su NVIDIA Jetson
Il primo passo dopo aver messo le mani su un dispositivo NVIDIA Jetson è flashare NVIDIA JetPack sul dispositivo. Esistono diversi modi per flashare i dispositivi NVIDIA Jetson.
- Se possiedi un kit di sviluppo NVIDIA ufficiale come il Jetson Orin Nano Developer Kit, puoi scaricare un'immagine e preparare una scheda SD con JetPack per l'avvio del dispositivo.
- Se possiedi qualsiasi altro kit di sviluppo NVIDIA, puoi flashare JetPack sul dispositivo utilizzando SDK Manager.
- Se possiedi un dispositivo Seeed Studio reComputer J4012, puoi flashare JetPack sull'SSD incluso e, se possiedi un dispositivo Seeed Studio reComputer J1020 v2, puoi flashare JetPack sull'eMMC/SSD.
- Se possiedi qualsiasi altro dispositivo di terze parti alimentato dal modulo NVIDIA Jetson, si consiglia di seguire il flashing da riga di comando.
Nota
Per i metodi 3 e 4 sopra indicati, dopo aver flashato il sistema e avviato il dispositivo, inserisci "sudo apt update && sudo apt install nvidia-jetpack -y" sul terminale del dispositivo per installare tutti i componenti JetPack rimanenti necessari.
Supporto JetPack basato sul dispositivo Jetson
La tabella seguente evidenzia le versioni di NVIDIA JetPack supportate da diversi dispositivi 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 | ❌ | ✅ | ✅ |
Guida rapida con Docker
Il modo più rapido per iniziare con Ultralytics YOLO11 su NVIDIA Jetson è eseguire con immagini docker pre-compilate per Jetson. Fare riferimento alla tabella sopra e scegliere la versione di JetPack in base al dispositivo Jetson in proprio possesso.
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
Dopo aver fatto ciò, passa alla sezione Usa TensorRT su NVIDIA Jetson.
Inizia con l'installazione nativa
Per un'installazione nativa senza Docker, fare riferimento ai passaggi seguenti.
Esegui su JetPack 6.1
Installa il pacchetto Ultralytics
Qui installeremo il pacchetto Ultralytics su Jetson con dipendenze opzionali in modo da poter esportare i modelli PyTorch in altri formati diversi. Ci concentreremo principalmente sulle esportazioni NVIDIA TensorRT perché TensorRT farà in modo di ottenere le massime prestazioni dai dispositivi Jetson.
-
Aggiorna l'elenco dei pacchetti, installa pip ed esegui l'aggiornamento all'ultima versione
sudo apt update sudo apt install python3-pip -y pip install -U pip
-
Installa
ultralytics
pacchetto pip con dipendenze opzionalipip install ultralytics[export]
-
Riavvia il dispositivo
sudo reboot
Installa PyTorch e Torchvision
L'installazione di Ultralytics di cui sopra installerà Torch e Torchvision. Tuttavia, questi 2 pacchetti installati tramite pip non sono compatibili per l'esecuzione sulla piattaforma Jetson, che si basa sull'architettura ARM64. Pertanto, dobbiamo installare manualmente la ruota pip PyTorch precompilata e compilare/installare Torchvision dal codice sorgente.
Installa torch 2.5.0
e torchvision 0.20
secondo JP6.1
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.5.0a0+872d972e41.nv24.08-cp310-cp310-linux_aarch64.whl
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.20.0a0+afc54f7-cp310-cp310-linux_aarch64.whl
Nota
Visita la pagina PyTorch per Jetson per accedere a tutte le diverse versioni di PyTorch per le diverse versioni di JetPack. Per un elenco più dettagliato sulla compatibilità di PyTorch e Torchvision, visita la pagina di compatibilità di PyTorch e Torchvision.
Installa cuSPARSELt
per risolvere un problema di dipendenza con torch 2.5.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 -y install libcusparselt0 libcusparselt-dev
Installa onnxruntime-gpu
Il onnxruntime-gpu il pacchetto ospitato in PyPI non ha aarch64
binari per Jetson. Quindi dobbiamo installare manualmente questo pacchetto. Questo pacchetto è necessario per alcune delle esportazioni.
Puoi trovare tutti i onnxruntime-gpu
pacchetti, organizzati per versione di JetPack, versione di Python e altri dettagli di compatibilità, nel Matrice di compatibilità di Jetson Zoo ONNX Runtime. Qui scaricheremo e installeremo onnxruntime-gpu 1.20.0
con Python3.10
supporto.
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.20.0-cp310-cp310-linux_aarch64.whl
Nota
onnxruntime-gpu
ripristinerà automaticamente la versione di numpy all'ultima. Quindi dobbiamo reinstallare numpy a 1.23.5
per risolvere un problema eseguendo:
pip install numpy==1.23.5
Esegui su JetPack 5.1.2
Installa il pacchetto Ultralytics
Qui installeremo il pacchetto Ultralytics su Jetson con dipendenze opzionali in modo da poter esportare i modelli PyTorch in altri formati diversi. Ci concentreremo principalmente sulle esportazioni NVIDIA TensorRT perché TensorRT farà in modo di ottenere le massime prestazioni dai dispositivi Jetson.
-
Aggiorna l'elenco dei pacchetti, installa pip ed esegui l'aggiornamento all'ultima versione
sudo apt update sudo apt install python3-pip -y pip install -U pip
-
Installa
ultralytics
pacchetto pip con dipendenze opzionalipip install ultralytics[export]
-
Riavvia il dispositivo
sudo reboot
Installa PyTorch e Torchvision
L'installazione di Ultralytics di cui sopra installerà Torch e Torchvision. Tuttavia, questi 2 pacchetti installati tramite pip non sono compatibili per l'esecuzione sulla piattaforma Jetson, che si basa sull'architettura ARM64. Pertanto, dobbiamo installare manualmente la ruota pip PyTorch precompilata e compilare/installare Torchvision dal codice sorgente.
-
Disinstallare PyTorch e Torchvision attualmente installati
pip uninstall torch torchvision
-
Installa
torch 2.2.0
etorchvision 0.17.2
secondo JP5.1.2pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.2.0-cp38-cp38-linux_aarch64.whl pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.17.2+c1d70fe-cp38-cp38-linux_aarch64.whl
Nota
Visita la pagina PyTorch per Jetson per accedere a tutte le diverse versioni di PyTorch per le diverse versioni di JetPack. Per un elenco più dettagliato sulla compatibilità di PyTorch e Torchvision, visita la pagina di compatibilità di PyTorch e Torchvision.
Installa onnxruntime-gpu
Il onnxruntime-gpu il pacchetto ospitato in PyPI non ha aarch64
binari per Jetson. Quindi dobbiamo installare manualmente questo pacchetto. Questo pacchetto è necessario per alcune delle esportazioni.
Puoi trovare tutti i onnxruntime-gpu
pacchetti, organizzati per versione di JetPack, versione di Python e altri dettagli di compatibilità, nel Matrice di compatibilità di Jetson Zoo ONNX Runtime. Qui scaricheremo e installeremo onnxruntime-gpu 1.17.0
con Python3.8
supporto.
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
ripristinerà automaticamente la versione di numpy all'ultima. Quindi dobbiamo reinstallare numpy a 1.23.5
per risolvere un problema eseguendo:
pip install numpy==1.23.5
Utilizza TensorRT su NVIDIA Jetson
Tra tutti i formati di export dei modelli supportati da Ultralytics, TensorRT offre le massime prestazioni di inferenza sui dispositivi NVIDIA Jetson, rendendolo la nostra raccomandazione principale per i deployment su Jetson. Per istruzioni di configurazione e utilizzo avanzato, consulta la nostra guida dedicata all'integrazione di TensorRT.
Converti il modello in TensorRT ed esegui l'inferenza
Il modello YOLO11n in formato PyTorch viene convertito in TensorRT per eseguire l'inferenza con il modello esportato.
Esempio
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
Visita la pagina di esportazione per accedere ad argomenti aggiuntivi durante l'esportazione di modelli in diversi formati
Utilizza NVIDIA Deep Learning Accelerator (DLA)
NVIDIA Deep Learning Accelerator (DLA) è un componente hardware specializzato integrato nei dispositivi NVIDIA Jetson che ottimizza l'inferenza di deep learning per l'efficienza energetica e le prestazioni. Scaricando i compiti dalla GPU (liberandola per processi più intensivi), DLA consente ai modelli di funzionare con un consumo energetico inferiore pur mantenendo un'elevata produttività, ideale per sistemi embedded e applicazioni di IA in tempo reale.
I seguenti dispositivi Jetson sono dotati di hardware DLA:
Dispositivo Jetson | Core DLA | Frequenza massima DLA |
---|---|---|
Serie Jetson AGX Orin | 2 | 1.6 GHz |
Jetson Orin NX 16GB | 2 | 614 MHz |
Jetson Orin NX 8GB | 1 | 614 MHz |
Serie Jetson AGX Xavier | 2 | 1.4 GHz |
Serie Jetson Xavier NX | 2 | 1.1 GHz |
Esempio
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)
# Once DLA core number is specified at export, it will use the same core at inference
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
Quando si utilizzano le esportazioni DLA, alcuni livelli potrebbero non essere supportati per l'esecuzione su DLA e torneranno alla GPU per l'esecuzione. Questo fallback può introdurre ulteriore latenza e influire sulle prestazioni complessive dell'inferenza. Pertanto, DLA non è progettato principalmente per ridurre la latenza dell'inferenza rispetto a TensorRT in esecuzione interamente sulla GPU. Invece, il suo scopo principale è aumentare il throughput e migliorare l'efficienza energetica.
Benchmark NVIDIA Jetson Orin YOLO11
I benchmark di YOLO11 sono stati eseguiti dal team Ultralytics su 10 diversi formati di modello misurando la velocità e l'accuratezza: PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN. I benchmark sono stati eseguiti su NVIDIA Jetson AGX Orin Developer Kit (64GB), NVIDIA Jetson Orin Nano Super Developer Kit e Seeed Studio reComputer J4012 alimentato dal dispositivo Jetson Orin NX 16GB a precisione FP32 con dimensione dell'immagine di input predefinita di 640.
Grafici di confronto
Anche se tutte le esportazioni del modello funzionano con NVIDIA Jetson, abbiamo incluso solo PyTorch, TorchScript, TensorRT per il grafico di confronto qui sotto perché utilizzano la GPU sul Jetson e garantiscono i migliori risultati. Tutte le altre esportazioni utilizzano solo la CPU e le prestazioni non sono buone come le tre precedenti. Puoi trovare i benchmark per tutte le esportazioni nella sezione successiva a questo grafico.
NVIDIA Jetson AGX Orin Developer Kit (64GB)

NVIDIA Jetson Orin Nano Super Developer Kit

NVIDIA Jetson Orin NX 16GB

Tabelle di confronto dettagliate
La tabella seguente rappresenta i risultati del benchmark per cinque diversi modelli (YOLO11n, YOLO11s, YOLO11m, YOLO11l, YOLO11x) in dieci diversi formati (PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN), fornendoci lo stato, le dimensioni, la metrica mAP50-95(B) e il tempo di inferenza per ogni combinazione.
NVIDIA Jetson AGX Orin Developer Kit (64GB)
Prestazioni
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 5.4 | 0.5101 | 9.40 |
TorchScript | ✅ | 10.5 | 0.5083 | 11.00 |
ONNX | ✅ | 10.2 | 0.5077 | 48.32 |
OpenVINO | ✅ | 10.4 | 0.5058 | 27.24 |
TensorRT (FP32) | ✅ | 12.1 | 0.5085 | 3.93 |
TensorRT (FP16) | ✅ | 8.3 | 0.5063 | 2.55 |
TensorRT (INT8) | ✅ | 5.4 | 0.4719 | 2.18 |
TF SavedModel | ✅ | 25.9 | 0.5077 | 66.87 |
TF GraphDef | ✅ | 10.3 | 0.5077 | 65.68 |
TF Lite | ✅ | 10.3 | 0.5077 | 272.92 |
MNN | ✅ | 10.1 | 0.5059 | 36.33 |
NCNN | ✅ | 10.2 | 0.5031 | 28.51 |
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 18.4 | 0.5783 | 12.10 |
TorchScript | ✅ | 36.5 | 0.5782 | 11.01 |
ONNX | ✅ | 36.3 | 0.5782 | 107.54 |
OpenVINO | ✅ | 36.4 | 0.5810 | 55.03 |
TensorRT (FP32) | ✅ | 38.1 | 0.5781 | 6.52 |
TensorRT (FP16) | ✅ | 21.4 | 0.5803 | 3.65 |
TensorRT (INT8) | ✅ | 12.1 | 0.5735 | 2.81 |
TF SavedModel | ✅ | 91.0 | 0.5782 | 132.73 |
TF GraphDef | ✅ | 36.4 | 0.5782 | 134.96 |
TF Lite | ✅ | 36.3 | 0.5782 | 798.21 |
MNN | ✅ | 36.2 | 0.5777 | 82.35 |
NCNN | ✅ | 36.2 | 0.5784 | 56.07 |
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 38.8 | 0.6265 | 22.20 |
TorchScript | ✅ | 77.3 | 0.6307 | 21.47 |
ONNX | ✅ | 76.9 | 0.6307 | 270.89 |
OpenVINO | ✅ | 77.1 | 0.6284 | 129.10 |
TensorRT (FP32) | ✅ | 78.8 | 0.6306 | 12.53 |
TensorRT (FP16) | ✅ | 41.9 | 0.6305 | 6.25 |
TensorRT (INT8) | ✅ | 23.2 | 0.6291 | 4.69 |
TF SavedModel | ✅ | 192.7 | 0.6307 | 299.95 |
TF GraphDef | ✅ | 77.1 | 0.6307 | 310.58 |
TF Lite | ✅ | 77.0 | 0.6307 | 2400.54 |
MNN | ✅ | 76.8 | 0.6308 | 213.56 |
NCNN | ✅ | 76.8 | 0.6284 | 141.18 |
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 49.0 | 0.6364 | 27.70 |
TorchScript | ✅ | 97.6 | 0.6399 | 27.94 |
ONNX | ✅ | 97.0 | 0.6409 | 345.47 |
OpenVINO | ✅ | 97.3 | 0.6378 | 161.93 |
TensorRT (FP32) | ✅ | 99.1 | 0.6406 | 16.11 |
TensorRT (FP16) | ✅ | 52.6 | 0.6376 | 8.08 |
TensorRT (INT8) | ✅ | 30.8 | 0.6208 | 6.12 |
TF SavedModel | ✅ | 243.1 | 0.6409 | 390.78 |
TF GraphDef | ✅ | 97.2 | 0.6409 | 398.76 |
TF Lite | ✅ | 97.1 | 0.6409 | 3037.05 |
MNN | ✅ | 96.9 | 0.6372 | 265.46 |
NCNN | ✅ | 96.9 | 0.6364 | 179.68 |
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 109.3 | 0.7005 | 44.40 |
TorchScript | ✅ | 218.1 | 0.6898 | 47.49 |
ONNX | ✅ | 217.5 | 0.6900 | 682.98 |
OpenVINO | ✅ | 217.8 | 0.6876 | 298.15 |
TensorRT (FP32) | ✅ | 219.6 | 0.6904 | 28.50 |
TensorRT (FP16) | ✅ | 112.2 | 0.6887 | 13.55 |
TensorRT (INT8) | ✅ | 60.0 | 0.6574 | 9.40 |
TF SavedModel | ✅ | 544.3 | 0.6900 | 749.85 |
TF GraphDef | ✅ | 217.7 | 0.6900 | 753.86 |
TF Lite | ✅ | 217.6 | 0.6900 | 6603.27 |
MNN | ✅ | 217.3 | 0.6868 | 519.77 |
NCNN | ✅ | 217.3 | 0.6849 | 298.58 |
Valutato con Ultralytics 8.3.157
Nota
Il tempo di inferenza non include il pre/post-processing.
NVIDIA Jetson Orin Nano Super Developer Kit
Prestazioni
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 5.4 | 0.5101 | 13.70 |
TorchScript | ✅ | 10.5 | 0.5082 | 13.69 |
ONNX | ✅ | 10.2 | 0.5081 | 14.47 |
OpenVINO | ✅ | 10.4 | 0.5058 | 56.66 |
TensorRT (FP32) | ✅ | 12.0 | 0.5081 | 7.44 |
TensorRT (FP16) | ✅ | 8.2 | 0.5061 | 4.53 |
TensorRT (INT8) | ✅ | 5.4 | 0.4825 | 3.70 |
TF SavedModel | ✅ | 25.9 | 0.5077 | 116.23 |
TF GraphDef | ✅ | 10.3 | 0.5077 | 114.92 |
TF Lite | ✅ | 10.3 | 0.5077 | 340.75 |
MNN | ✅ | 10.1 | 0.5059 | 76.26 |
NCNN | ✅ | 10.2 | 0.5031 | 45.03 |
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 18.4 | 0.5790 | 20.90 |
TorchScript | ✅ | 36.5 | 0.5781 | 21.22 |
ONNX | ✅ | 36.3 | 0.5781 | 25.07 |
OpenVINO | ✅ | 36.4 | 0.5810 | 122.98 |
TensorRT (FP32) | ✅ | 37.9 | 0.5783 | 13.02 |
TensorRT (FP16) | ✅ | 21.8 | 0.5779 | 6.93 |
TensorRT (INT8) | ✅ | 12.2 | 0.5735 | 5.08 |
TF SavedModel | ✅ | 91.0 | 0.5782 | 250.65 |
TF GraphDef | ✅ | 36.4 | 0.5782 | 252.69 |
TF Lite | ✅ | 36.3 | 0.5782 | 998.68 |
MNN | ✅ | 36.2 | 0.5781 | 188.01 |
NCNN | ✅ | 36.2 | 0.5784 | 101.37 |
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 38.8 | 0.6266 | 46.50 |
TorchScript | ✅ | 77.3 | 0.6307 | 47.95 |
ONNX | ✅ | 76.9 | 0.6307 | 53.06 |
OpenVINO | ✅ | 77.1 | 0.6284 | 301.63 |
TensorRT (FP32) | ✅ | 78.8 | 0.6305 | 27.86 |
TensorRT (FP16) | ✅ | 41.7 | 0.6309 | 13.50 |
TensorRT (INT8) | ✅ | 23.2 | 0.6291 | 9.12 |
TF SavedModel | ✅ | 192.7 | 0.6307 | 622.24 |
TF GraphDef | ✅ | 77.1 | 0.6307 | 628.74 |
TF Lite | ✅ | 77.0 | 0.6307 | 2997.93 |
MNN | ✅ | 76.8 | 0.6299 | 509.96 |
NCNN | ✅ | 76.8 | 0.6284 | 292.99 |
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 49.0 | 0.6364 | 56.50 |
TorchScript | ✅ | 97.6 | 0.6409 | 62.51 |
ONNX | ✅ | 97.0 | 0.6399 | 68.35 |
OpenVINO | ✅ | 97.3 | 0.6378 | 376.03 |
TensorRT (FP32) | ✅ | 99.2 | 0.6396 | 35.59 |
TensorRT (FP16) | ✅ | 52.1 | 0.6361 | 17.48 |
TensorRT (INT8) | ✅ | 30.9 | 0.6207 | 11.87 |
TF SavedModel | ✅ | 243.1 | 0.6409 | 807.47 |
TF GraphDef | ✅ | 97.2 | 0.6409 | 822.88 |
TF Lite | ✅ | 97.1 | 0.6409 | 3792.23 |
MNN | ✅ | 96.9 | 0.6372 | 631.16 |
NCNN | ✅ | 96.9 | 0.6364 | 350.46 |
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 109.3 | 0.7005 | 90.00 |
TorchScript | ✅ | 218.1 | 0.6901 | 113.40 |
ONNX | ✅ | 217.5 | 0.6901 | 122.94 |
OpenVINO | ✅ | 217.8 | 0.6876 | 713.1 |
TensorRT (FP32) | ✅ | 219.5 | 0.6904 | 66.93 |
TensorRT (FP16) | ✅ | 112.2 | 0.6892 | 32.58 |
TensorRT (INT8) | ✅ | 61.5 | 0.6612 | 19.90 |
TF SavedModel | ✅ | 544.3 | 0.6900 | 1605.4 |
TF GraphDef | ✅ | 217.8 | 0.6900 | 2961.8 |
TF Lite | ✅ | 217.6 | 0.6900 | 8234.86 |
MNN | ✅ | 217.3 | 0.6893 | 1254.18 |
NCNN | ✅ | 217.3 | 0.6849 | 725.50 |
Valutato con Ultralytics 8.3.157
Nota
Il tempo di inferenza non include il pre/post-processing.
NVIDIA Jetson Orin NX 16GB
Prestazioni
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 5.4 | 0.5101 | 12.90 |
TorchScript | ✅ | 10.5 | 0.5082 | 13.17 |
ONNX | ✅ | 10.2 | 0.5081 | 15.43 |
OpenVINO | ✅ | 10.4 | 0.5058 | 39.80 |
TensorRT (FP32) | ✅ | 11.8 | 0.5081 | 7.94 |
TensorRT (FP16) | ✅ | 8.1 | 0.5085 | 4.73 |
TensorRT (INT8) | ✅ | 5.4 | 0.4786 | 3.90 |
TF SavedModel | ✅ | 25.9 | 0.5077 | 88.48 |
TF GraphDef | ✅ | 10.3 | 0.5077 | 86.67 |
TF Lite | ✅ | 10.3 | 0.5077 | 302.55 |
MNN | ✅ | 10.1 | 0.5059 | 52.73 |
NCNN | ✅ | 10.2 | 0.5031 | 32.04 |
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 18.4 | 0.5790 | 21.70 |
TorchScript | ✅ | 36.5 | 0.5781 | 22.71 |
ONNX | ✅ | 36.3 | 0.5781 | 26.49 |
OpenVINO | ✅ | 36.4 | 0.5810 | 84.73 |
TensorRT (FP32) | ✅ | 37.8 | 0.5783 | 13.77 |
TensorRT (FP16) | ✅ | 21.2 | 0.5796 | 7.31 |
TensorRT (INT8) | ✅ | 12.0 | 0.5735 | 5.33 |
TF SavedModel | ✅ | 91.0 | 0.5782 | 185.06 |
TF GraphDef | ✅ | 36.4 | 0.5782 | 186.45 |
TF Lite | ✅ | 36.3 | 0.5782 | 882.58 |
MNN | ✅ | 36.2 | 0.5775 | 126.36 |
NCNN | ✅ | 36.2 | 0.5784 | 66.73 |
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 38.8 | 0.6266 | 45.00 |
TorchScript | ✅ | 77.3 | 0.6307 | 51.87 |
ONNX | ✅ | 76.9 | 0.6307 | 56.00 |
OpenVINO | ✅ | 77.1 | 0.6284 | 202.69 |
TensorRT (FP32) | ✅ | 78.7 | 0.6305 | 30.38 |
TensorRT (FP16) | ✅ | 41.8 | 0.6302 | 14.48 |
TensorRT (INT8) | ✅ | 23.2 | 0.6291 | 9.74 |
TF SavedModel | ✅ | 192.7 | 0.6307 | 445.58 |
TF GraphDef | ✅ | 77.1 | 0.6307 | 460.94 |
TF Lite | ✅ | 77.0 | 0.6307 | 2653.65 |
MNN | ✅ | 76.8 | 0.6308 | 339.38 |
NCNN | ✅ | 76.8 | 0.6284 | 187.64 |
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 49.0 | 0.6364 | 56.60 |
TorchScript | ✅ | 97.6 | 0.6409 | 66.72 |
ONNX | ✅ | 97.0 | 0.6399 | 71.92 |
OpenVINO | ✅ | 97.3 | 0.6378 | 254.17 |
TensorRT (FP32) | ✅ | 99.2 | 0.6406 | 38.89 |
TensorRT (FP16) | ✅ | 51.9 | 0.6363 | 18.59 |
TensorRT (INT8) | ✅ | 30.9 | 0.6207 | 12.60 |
TF SavedModel | ✅ | 243.1 | 0.6409 | 575.98 |
TF GraphDef | ✅ | 97.2 | 0.6409 | 583.79 |
TF Lite | ✅ | 97.1 | 0.6409 | 3353.41 |
MNN | ✅ | 96.9 | 0.6367 | 421.33 |
NCNN | ✅ | 96.9 | 0.6364 | 228.26 |
Formato | Stato | Dimensione su disco (MB) | mAP50-95(B) | Tempo di inferenza (ms/im) |
---|---|---|---|---|
PyTorch | ✅ | 109.3 | 0.7005 | 98.50 |
TorchScript | ✅ | 218.1 | 0.6901 | 123.03 |
ONNX | ✅ | 217.5 | 0.6901 | 129.55 |
OpenVINO | ✅ | 217.8 | 0.6876 | 483.44 |
TensorRT (FP32) | ✅ | 219.6 | 0.6904 | 75.92 |
TensorRT (FP16) | ✅ | 112.1 | 0.6885 | 35.78 |
TensorRT (INT8) | ✅ | 61.6 | 0.6592 | 21.60 |
TF SavedModel | ✅ | 544.3 | 0.6900 | 1120.43 |
TF GraphDef | ✅ | 217.7 | 0.6900 | 1172.35 |
TF Lite | ✅ | 217.6 | 0.6900 | 7283.63 |
MNN | ✅ | 217.3 | 0.6877 | 840.16 |
NCNN | ✅ | 217.3 | 0.6849 | 474.41 |
Valutato con Ultralytics 8.3.157
Nota
Il tempo di inferenza non include il pre/post-processing.
Esplora ulteriori attività di benchmarking di Seeed Studio eseguite su diverse versioni di hardware NVIDIA Jetson.
Riproduci i nostri risultati
Per riprodurre i benchmark Ultralytics di cui sopra su tutti i formati di esportazione, esegui questo codice:
Esempio
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Benchmark YOLO11n speed and accuracy on the COCO128 dataset for all all export formats
results = model.benchmark(data="coco128.yaml", imgsz=640)
# Benchmark YOLO11n speed and accuracy on the COCO128 dataset for all all export formats
yolo benchmark model=yolo11n.pt data=coco128.yaml imgsz=640
Si noti che i risultati dei benchmark possono variare in base alla configurazione hardware e software esatta di un sistema, nonché al carico di lavoro corrente del sistema al momento dell'esecuzione dei benchmark. Per ottenere risultati più affidabili, utilizzare un dataset con un numero elevato di immagini, ad esempio data='coco.yaml'
(5000 immagini val).
Best practice quando si utilizza NVIDIA Jetson
Quando si utilizza NVIDIA Jetson, ci sono alcune best practice da seguire per abilitare le massime prestazioni su NVIDIA Jetson che esegue YOLO11.
-
Abilita la modalità di massima potenza
Abilitare la modalità MAX Power su Jetson assicurerà che tutti i core di CPU e GPU siano attivati.
sudo nvpmodel -m 0
-
Abilita gli orologi Jetson
Abilitare Jetson Clocks assicurerà che tutti i core di CPU e GPU siano impostati alla loro massima frequenza.
sudo jetson_clocks
-
Installa l'applicazione Jetson Stats
Possiamo utilizzare l'applicazione jetson stats per monitorare le temperature dei componenti del sistema e controllare altri dettagli del sistema come la visualizzazione dell'utilizzo di CPU, GPU, RAM, modificare le modalità di alimentazione, impostare al massimo gli orologi, controllare le informazioni di JetPack
sudo apt update sudo pip install jetson-stats sudo reboot jtop
Prossimi passi
Congratulazioni per aver configurato con successo YOLO11 sul tuo NVIDIA Jetson! Per ulteriore apprendimento e supporto, visita altre guide su Ultralytics YOLO11 Docs!
FAQ
Come posso distribuire Ultralytics YOLO11 su dispositivi NVIDIA Jetson?
La distribuzione di Ultralytics YOLO11 sui dispositivi NVIDIA Jetson è un processo semplice. Innanzitutto, esegui il flashing del tuo dispositivo Jetson con l'SDK NVIDIA JetPack. Quindi, utilizza un'immagine Docker pre-compilata per una configurazione rapida oppure installa manualmente i pacchetti richiesti. Passaggi dettagliati per ciascun approccio sono disponibili nelle sezioni Avvio rapido con Docker e Inizia con l'installazione nativa.
Quali benchmark di performance posso aspettarmi dai modelli YOLO11 sui dispositivi NVIDIA Jetson?
I modelli YOLO11 sono stati sottoposti a benchmark su vari dispositivi NVIDIA Jetson, mostrando significativi miglioramenti delle prestazioni. Ad esempio, il formato TensorRT offre le migliori prestazioni di inferenza. La tabella nella sezione Tabelle di confronto dettagliate fornisce una visione completa delle metriche di performance come mAP50-95 e tempo di inferenza tra diversi formati di modello.
Perché dovrei usare TensorRT per il deployment di YOLO11 su NVIDIA Jetson?
TensorRT è vivamente consigliato per il deployment di modelli YOLO11 su NVIDIA Jetson grazie alle sue prestazioni ottimali. Accelera l'inferenza sfruttando le capacità della GPU Jetson, garantendo la massima efficienza e velocità. Scopri di più su come convertire in TensorRT ed eseguire l'inferenza nella sezione Use TensorRT on NVIDIA Jetson.
Come posso installare PyTorch e Torchvision su NVIDIA Jetson?
Per installare PyTorch e Torchvision su NVIDIA Jetson, disinstallare prima eventuali versioni esistenti installate tramite pip. Quindi, installare manualmente le versioni compatibili di PyTorch e Torchvision per l'architettura ARM64 di Jetson. Istruzioni dettagliate per questo processo sono fornite nella sezione Installazione di PyTorch e Torchvision.
Quali sono le migliori pratiche per massimizzare le prestazioni su NVIDIA Jetson quando si utilizza YOLO11?
Per massimizzare le prestazioni su NVIDIA Jetson con YOLO11, seguire queste best practice:
- Abilita la modalità di massima potenza per utilizzare tutti i core della CPU e della GPU.
- Abilita gli orologi Jetson per eseguire tutti i core alla loro massima frequenza.
- Installa l'applicazione Jetson Stats per monitorare le metriche di sistema.
Per i comandi e ulteriori dettagli, consultare la sezione Best practice quando si utilizza NVIDIA Jetson.