Inizia

Guida rapida: NVIDIA DGX Spark con Ultralytics YOLO26

Questa guida illustra la distribuzione di Ultralytics YOLO26 su NVIDIA DGX Spark, il supercomputer AI desktop compatto di NVIDIA, e include benchmark di YOLO11 sui diversi formati di esportazione in questo sistema.

NVIDIA DGX Spark AI workstation overview

Nota

Questa guida è stata testata con NVIDIA DGX Spark Founders Edition con DGX OS basato su Ubuntu. È previsto che funzioni anche con le versioni più recenti di DGX OS.

Che cos'è NVIDIA DGX Spark?#

NVIDIA DGX Spark è un supercomputer AI desktop compatto, basato sul NVIDIA GB10 Grace Blackwell Superchip. Offre fino a 1 petaFLOP di prestazioni di calcolo AI con precisione FP4 ed è progettato per sviluppatori, ricercatori e data scientist che necessitano di potenti funzionalità AI in un formato desktop.



Guarda: Come raggiungere fino a 1000 FPS con Ultralytics YOLO26 su NVIDIA DGX Spark | TensorRT e inferenza batch

Specifiche principali#

SpecificaDettagli
Prestazioni AIFino a 1 PFLOP (FP4)
GPUArchitettura NVIDIA Blackwell con Tensor Core di quinta generazione e RT Core di quarta generazione
CPUProcessore Arm a 20 core (10 Cortex-X925 + 10 Cortex-A725)
Memoria128 GB di memoria di sistema unificata LPDDR5x, interfaccia a 256 bit, 4266 MHz, larghezza di banda di 273 GB/s
ArchiviazioneNVMe M.2 da 1 TB o 4 TB con crittografia automatica
Rete1x RJ-45 (10 GbE), scheda di rete Smart NIC ConnectX-7, Wi-Fi 7, Bluetooth 5.4
Connettività4x USB Type-C, 1x HDMI 2.1a, audio multicanale HDMI
Elaborazione video1x NVENC, 1x NVDEC

DGX OS#

NVIDIA DGX OS è una distribuzione Linux personalizzata che offre una base di sistema operativo stabile, testata e supportata per eseguire applicazioni di AI, machine learning e analisi sui sistemi DGX. Include:

  • Una solida base Linux ottimizzata per i carichi di lavoro di AI
  • Driver e impostazioni di sistema preconfigurati per l'hardware NVIDIA
  • Aggiornamenti di sicurezza e funzionalità di manutenzione del sistema
  • Compatibilità con il più ampio ecosistema software NVIDIA

DGX OS segue un calendario regolare di rilascio, con aggiornamenti generalmente distribuiti due volte all'anno (intorno a febbraio e agosto) e ulteriori patch di sicurezza rilasciate tra le versioni principali.

DGX Dashboard#

DGX Spark include DGX Dashboard, che offre:

  • Monitoraggio del sistema in tempo reale: panoramica delle metriche operative correnti del sistema
  • Aggiornamenti del sistema: possibilità di applicare gli aggiornamenti direttamente dalla dashboard
  • Impostazioni di sistema: modifica del nome del dispositivo e di altre configurazioni
  • JupyterLab integrato: accesso ai Jupyter Notebook locali per lo sviluppo

NVIDIA DGX management dashboard interface

Accesso alla dashboard#

Fai clic sul pulsante "Mostra applicazioni" nell'angolo in basso a sinistra del desktop Ubuntu, quindi seleziona "DGX Dashboard" per aprirla nel browser.

JupyterLab integrato

La dashboard include un'istanza integrata di JupyterLab che crea automaticamente un ambiente virtuale e installa i pacchetti consigliati all'avvio. A ogni account utente viene assegnata una porta dedicata per accedere a JupyterLab.

Guida introduttiva a Docker#

Il modo più rapido per iniziare a usare Ultralytics YOLO26 su NVIDIA DGX Spark è eseguire le immagini Docker precompilate. L'immagine NVIDIA ARM64 supporta DGX Spark con DGX OS.

t=ultralytics/ultralytics:latest-nvidia-arm64
sudo docker pull $t && sudo docker run -it --ipc=host --device nvidia.com/gpu=all $t

La richiesta del dispositivo CDI precedente si applica a DGX Spark con DGX OS. Per i carichi di lavoro PyTorch su Jetson AGX Thor, consulta i requisiti host separati e la limitazione di TensorRT nella guida NVIDIA Jetson.

Questa immagine usa NVIDIA PyTorch 26.10, CUDA 13.4 e TensorRT 11.4. Aggiorna il driver dell'host DGX OS a una versione supportata da NVIDIA PyTorch 26.10 e ricrea i motori TensorRT dopo aver cambiato l'immagine o la GPU di destinazione.

Una volta completata questa operazione, passa a Usare TensorRT su NVIDIA DGX Spark.

Inizia con l'installazione nativa#

Per un'installazione nativa senza Docker, segui questi passaggi.

Installa il pacchetto Ultralytics#

Qui installeremo il pacchetto Ultralytics su DGX Spark. Le dipendenze per l'esportazione vengono installate automaticamente la prima volta che esporti un modello, quindi qui basta il pacchetto di base. Questa guida si concentra sulle esportazioni NVIDIA TensorRT, perché TensorRT offre le migliori prestazioni su DGX Spark.

  1. Aggiorna l'elenco dei pacchetti, installa pip e aggiornalo all'ultima versione

    sudo apt update
    sudo apt install python3-pip -y
    pip install -U pip
  2. Installa il pacchetto pip ultralytics

    pip install ultralytics
  3. Riavvia il dispositivo

    sudo reboot

Installa PyTorch e Torchvision#

L'installazione di ultralytics descritta sopra installa PyTorch e Torchvision. Tuttavia, questi pacchetti installati tramite pip potrebbero non essere completamente ottimizzati per l'architettura ARM64 di DGX Spark con CUDA 13. Ti consigliamo quindi di installare le versioni compatibili con CUDA 13:

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu130
Informazioni

Quando esegui PyTorch 2.9.1 su NVIDIA DGX Spark, potresti riscontrare il seguente UserWarning durante l'inizializzazione di CUDA (ad esempio, eseguendo yolo checks, yolo predict e così via):

UserWarning: Found GPU0 NVIDIA GB10 which is of cuda capability 12.1.
Minimum and Maximum cuda capability supported by this version of PyTorch is (8.0) - (12.0)

Puoi ignorare questo avviso senza problemi.

Installa onnxruntime-gpu#

Le attuali versioni di ONNX Runtime GPU forniscono pacchetti wheel Linux ARM64, inclusi quelli per Python 3.12. L'immagine Docker NVIDIA ARM64 installa il pacchetto ufficiale; per le installazioni native di CUDA 13, usa:

pip install onnxruntime-gpu

Usare TensorRT su NVIDIA DGX Spark#

Tra tutti i formati di esportazione dei modelli supportati da Ultralytics, TensorRT offre le migliori prestazioni di inferenza su NVIDIA DGX Spark, diventando la nostra scelta consigliata per le distribuzioni.

Converti il modello in TensorRT ed esegui l'inferenza#

Il modello YOLO26n PyTorch viene convertito in TensorRT, quindi il modello esportato viene usato per l'inferenza.

Esempio
from ultralytics import YOLO

# Carica un modello YOLO26n PyTorch
model = YOLO("yolo26n.pt")

# Esporta il modello in TensorRT FP16
model.export(format="engine", quantize=16)  # crea 'yolo26n.engine'

# Carica il modello TensorRT esportato
trt_model = YOLO("yolo26n.engine")

# Esegui l'inferenza
results = trt_model("https://ultralytics.com/images/bus.jpg")

Benchmark di YOLO11 su NVIDIA DGX Spark#

Il team Ultralytics ha eseguito benchmark di YOLO11 su diversi formati di modello, misurando velocità e precisione: PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN, ExecuTorch. I benchmark sono stati eseguiti su NVIDIA DGX Spark a precisione FP32 e con la dimensione predefinita dell'immagine di input pari a 640.

Tabella di confronto dettagliata#

La tabella seguente mostra i risultati dei benchmark per cinque diversi modelli (YOLO11n, YOLO11s, YOLO11m, YOLO11l, YOLO11x) in più formati, indicando lo stato, le dimensioni, la metrica mAP50-95(B) e il tempo di inferenza per ogni combinazione.

Prestazioni
FormatoStatoDimensioni su disco (MB)mAP50-95(B)Tempo di inferenza (ms/im)
PyTorch✅5.40.50712.67
TorchScript✅10.50.50832.62
ONNX✅10.20.50745.92
OpenVINO✅10.40.505814.95
TensorRT (FP32)✅12.80.50851.95
TensorRT (FP16)✅7.00.50681.01
TensorRT (INT8)✅18.60.48801.62
TF SavedModel✅25.70.507636.39
TF GraphDef✅10.30.507641.06
TF Lite✅10.30.507564.36
MNN✅10.10.507512.14
NCNN✅10.20.504112.31
ExecuTorch✅10.20.507527.61

Benchmark eseguiti con Ultralytics 8.3.249

Riproduci i nostri risultati#

Per riprodurre i benchmark Ultralytics riportati sopra in tutti i formati di esportazione, esegui questo codice:

Esempio
from ultralytics import YOLO

# Carica un modello YOLO26n PyTorch
model = YOLO("yolo26n.pt")

# Esegui il benchmark di velocità e accuratezza di YOLO26n sul dataset COCO128 per tutti i formati di esportazione
results = model.benchmark(data="coco128.yaml", imgsz=640)

I risultati dei benchmark possono variare in base alla configurazione hardware e software esatta del sistema e al carico di lavoro del sistema al momento dell'esecuzione dei benchmark. Per ottenere risultati più affidabili, usa un dataset con un numero elevato di immagini, ad es. data='coco.yaml' (5000 immagini di convalida).

Precisione di YOLO26 TensorRT su DGX Spark#

Con batch size 1 su DGX Spark, TensorRT INT8 è più lento di FP16 per YOLO26n e YOLO26s, e ha prestazioni pressoché uguali per YOLO26m (entro il 2% sia nella validazione sia nel tempo di calcolo GPU di trtexec). INT8 perde inoltre da 1,1 a 1,8 mAP, quindi FP16 è la scelta migliore per questi modelli. La tabella YOLO11 qui sopra mostra lo stesso andamento: TensorRT (INT8) è più lento di TensorRT (FP16) per tutti e cinque i modelli.

ModelloFormatoDimensioni su disco (MB)mAP50-95(B)Tempo di inferenza (ms/im)
YOLO26nTensorRT (FP16)6.70.40320.79
YOLO26nTensorRT (INT8)28.40.38491.43
YOLO26sTensorRT (FP16)20.30.47931.49
YOLO26sTensorRT (INT8)34.40.46441.73
YOLO26mTensorRT (FP16)41.10.52662.70
YOLO26mTensorRT (INT8)45.00.51562.74

Accuratezza e velocità sono state misurate durante la validazione su COCO val2017 (5000 immagini), con dimensione immagine 640 e batch size 1. Gli engine INT8 sono calibrati su COCO128. Benchmark eseguito con Ultralytics 8.4.192 in ultralytics/ultralytics:latest-nvidia-arm64 (NVIDIA PyTorch 26.08, TensorRT 11.2.1.2, ModelOpt 0.45.0).

Best practice per NVIDIA DGX Spark#

Quando usi NVIDIA DGX Spark, segui queste best practice per ottenere le migliori prestazioni con YOLO26.

  1. Monitora le prestazioni del sistema

    Usa gli strumenti di monitoraggio NVIDIA per tenere traccia dell'utilizzo di GPU e CPU:

    nvidia-smi
  2. Ottimizza l'utilizzo della memoria

    Con 128 GB di memoria unificata, DGX Spark può gestire batch di grandi dimensioni e modelli di grandi dimensioni. Valuta di aumentare la dimensione del batch per migliorare il throughput:

    from ultralytics import YOLO
    
    model = YOLO("yolo26n.engine")
    results = model.predict(source="path/to/images", batch=16)
  3. Usa TensorRT FP16

    Con batch size 1 su DGX Spark, INT8 è più lento di FP16 per YOLO26n e YOLO26s, non è più veloce per YOLO26m ed è meno accurato (consulta Precisione di YOLO26 TensorRT su DGX Spark):

    yolo export model=yolo26n.pt format=engine quantize=16 # FP16

Aggiornamenti del sistema (Founders Edition)#

Mantenere aggiornata la Founders Edition di DGX Spark è fondamentale per le prestazioni e la sicurezza. NVIDIA offre due metodi principali per aggiornare il sistema operativo, i driver e il firmware.

DGX Dashboard è il metodo consigliato per eseguire gli aggiornamenti del sistema e garantire la compatibilità. Ti consente di:

  • Visualizzare gli aggiornamenti di sistema disponibili
  • Installare patch di sicurezza e aggiornamenti di sistema
  • Gestire gli aggiornamenti dei driver e del firmware NVIDIA

Aggiornamenti manuali del sistema#

Gli utenti esperti possono eseguire gli aggiornamenti manualmente tramite terminale:

sudo apt update
sudo apt dist-upgrade
sudo fwupdmgr refresh
sudo fwupdmgr upgrade
sudo reboot
Attenzione

Prima di eseguire gli aggiornamenti, assicurati che il sistema sia collegato a una fonte di alimentazione stabile e di aver eseguito il backup dei dati importanti.

Prossimi passaggi#

Per approfondire e ricevere supporto, consulta la documentazione Ultralytics YOLO26.

Domande frequenti#

  • Distribuire Ultralytics YOLO26 su NVIDIA DGX Spark è semplice. Puoi usare l'immagine Docker precompilata per una configurazione rapida oppure installare manualmente i pacchetti necessari. Trovi le istruzioni dettagliate per ciascun approccio nelle sezioni Avvio rapido con Docker e Inizia con l'installazione nativa.

  • I modelli YOLO sono veloci su DGX Spark grazie al GB10 Grace Blackwell Superchip. Il formato TensorRT offre le migliori prestazioni di inferenza. Consulta la sezione Tabella comparativa dettagliata per i risultati dei benchmark YOLO11 su DGX Spark con diverse dimensioni e formati dei modelli, e la sezione Precisione di YOLO26 TensorRT su DGX Spark per i risultati di YOLO26 FP16 e INT8.

  • TensorRT è consigliato per distribuire i modelli YOLO26 su DGX Spark perché offre l'inferenza più rapida tra i formati di esportazione supportati, sfruttando i Tensor Core della GPU Blackwell con precisione FP16 o INT8.

  • DGX Spark offre fino a 1 PFLOP di prestazioni AI e 128 GB di memoria unificata, rispetto ai 2070 TFLOPS e ai 128 GB di memoria di Jetson AGX Thor. DGX Spark è progettato come supercomputer AI desktop, mentre i dispositivi Jetson sono sistemi embedded ottimizzati per la distribuzione all'edge.

  • Per i carichi di lavoro PyTorch, ultralytics/ultralytics:latest-nvidia-arm64 supporta DGX Spark con DGX OS e Thor con JetPack 7.1. TensorRT 11.4 incluso non supporta JetPack, quindi i flussi di lavoro TensorRT su Jetson devono usare il runtime TensorRT 10.x supportato dalla rispettiva versione di JetPack. Consulta i requisiti Docker per Jetson.

Commenti

Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.