Vai al contenuto

Guida Rapida: NVIDIA DGX Spark con Ultralytics YOLO26

Questa guida completa fornisce una panoramica dettagliata per il deployment di Ultralytics YOLO26 su NVIDIA DGX Spark, il supercomputer AI desktop compatto di NVIDIA. Inoltre, presenta benchmark di performance per dimostrare le capacità di YOLO26 su questo potente sistema.

Panoramica sulla workstation NVIDIA Spark AI

Nota

Questa guida è stata testata con NVIDIA DGX Spark Founders Edition che esegue DGX OS basato su Ubuntu. Si prevede che funzioni con le ultime release di DGX OS.

Cos'è NVIDIA DGX Spark?

NVIDIA DGX Spark è un supercomputer AI desktop compatto alimentato dal Superchip NVIDIA GB10 Grace Blackwell. Offre fino a 1 petaFLOP di prestazioni di calcolo AI con precisione FP4, rendendolo ideale per sviluppatori, ricercatori e data scientist che necessitano di potenti capacità AI in un fattore di forma desktop.

Specifiche Chiave

SpecificheDettagli
Prestazioni AIFino a 1 PFLOP (FP4)
GPUArchitettura NVIDIA Blackwell con Tensor Cores di 5a generazione, RT Cores di 4a generazione
CPUProcessore Arm a 20 core (10 Cortex-X925 + 10 Cortex-A725)
MemoriaMemoria di sistema unificata LPDDR5x da 128 GB, 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), ConnectX-7 Smart NIC, 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 fornisce una base di sistema operativo stabile, testata e supportata per l'esecuzione di applicazioni di AI, machine learning e analisi sui sistemi DGX. Include:

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

DGX OS segue un programma di rilascio regolare con aggiornamenti tipicamente forniti due volte all'anno (intorno a febbraio e agosto), con patch di sicurezza aggiuntive fornite tra le versioni principali.

DGX Dashboard

DGX Spark include una DGX Dashboard integrata che fornisce:

  • Monitoraggio del sistema in tempo reale: Panoramica delle metriche operative attuali del sistema
  • Aggiornamenti di sistema: Possibilità di applicare gli aggiornamenti direttamente dalla dashboard
  • Impostazioni di sistema: Modifica del nome del dispositivo e altre configurazioni
  • JupyterLab integrato: Accesso ai Jupyter Notebook locali per lo sviluppo

Interfaccia del pannello di controllo NVIDIA

Accesso alla Dashboard

Cliccare sul pulsante "Mostra applicazioni" nell'angolo in basso a sinistra del desktop Ubuntu, quindi selezionare "DGX Dashboard" per aprirlo nel browser.

# Open an SSH tunnel
ssh -L 11000:localhost:11000 username@spark-abcd.local

# Then open in browser
# http://localhost:11000

Dopo aver effettuato la connessione con NVIDIA Sync, cliccare sul pulsante "DGX Dashboard" per aprire la dashboard all'indirizzo http://localhost:11000.

JupyterLab integrato

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

Guida rapida con Docker

Il modo più rapido per iniziare con Ultralytics YOLO26 su NVIDIA DGX Spark è eseguire con immagini Docker pre-costruite. La stessa immagine Docker che supporta Jetson AGX Thor (JetPack 7.0) funziona su DGX Spark con DGX OS.

t=ultralytics/ultralytics:latest-nvidia-arm64
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia --gpus all $t

Una volta completato, passare alla sezione Utilizzo di TensorRT su NVIDIA DGX Spark.

Inizia con l'installazione nativa

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

Installa il pacchetto Ultralytics

Qui installeremo il pacchetto Ultralytics su DGX Spark con dipendenze opzionali in modo da poter esportare i modelli PyTorch in altri formati. Ci concentreremo principalmente sulle esportazioni NVIDIA TensorRT perché TensorRT garantirà le massime prestazioni dal DGX Spark.

  1. 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
    
  2. Installa ultralytics pacchetto pip con dipendenze opzionali

    pip install ultralytics[export]
    
  3. Riavvia il dispositivo

    sudo reboot
    

Installa PyTorch e Torchvision

L'installazione di Ultralytics sopra menzionata installerà Torch e Torchvision. Tuttavia, questi pacchetti installati tramite pip potrebbero non essere completamente ottimizzati per l'architettura ARM64 del DGX Spark con CUDA 13. Pertanto, si consiglia di installare le versioni compatibili con CUDA 13:

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

Info

Quando si esegue PyTorch 2.9.1 su NVIDIA DGX Spark, si potrebbe riscontrare quanto segue: UserWarning durante l'inizializzazione di CUDA (ad esempio, eseguendo yolo checks, yolo predict, ecc.):

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)

Questo avviso può essere ignorato in sicurezza. Per risolverlo in modo permanente, è stata inviata una correzione nella PR di PyTorch #164590 che sarà inclusa nella release di PyTorch 2.10.

Installa onnxruntime-gpu

Il onnxruntime-gpu package ospitato in PyPI non ha aarch64 binari per sistemi ARM64. Pertanto, è necessario installare manualmente questo pacchetto. Questo pacchetto è richiesto per alcune delle esportazioni.

Qui scaricheremo e installeremo onnxruntime-gpu 1.24.0 con Python3.12 supporto.

pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.24.0-cp312-cp312-linux_aarch64.whl

Utilizzare TensorRT su NVIDIA DGX Spark

Tra tutti i formati di esportazione del modello supportati da Ultralytics, TensorRT offre le massime prestazioni di inferenza su NVIDIA DGX Spark, rendendolo la nostra principale raccomandazione per le distribuzioni. Per le istruzioni di configurazione e l'utilizzo avanzato, consultare la nostra guida dedicata all'integrazione di TensorRT.

Converti il modello in TensorRT ed esegui l'inferenza

Il modello YOLO26n in formato PyTorch viene convertito in TensorRT per eseguire l'inferenza con il modello esportato.

Esempio

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")
# Export a YOLO26n PyTorch model to TensorRT format
yolo export model=yolo26n.pt format=engine # creates 'yolo26n.engine'

# Run inference with the exported model
yolo predict model=yolo26n.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

Benchmark YOLO11 su NVIDIA DGX Spark

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

Tabella comparativa dettagliata

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

Prestazioni

FormatoStatoDimensione su disco (MB)mAP50-95(B)Tempo di inferenza (ms/im)
PyTorch5.40.50712.67
TorchScript10.50.50832.62
ONNX10.20.50745.92
OpenVINO10.40.505814.95
TensorRT (FP32)12.80.50851.95
TensorRT (FP16)7.00.50681.01
TensorRT (INT8)18.60.48801.62
TF SavedModel25.70.507636.39
TF GraphDef10.30.507641.06
TF Lite10.30.507564.36
MNN10.10.507512.14
NCNN10.20.504112.31
ExecuTorch10.20.507527.61
FormatoStatoDimensione su disco (MB)mAP50-95(B)Tempo di inferenza (ms/im)
PyTorch18.40.57675.38
TorchScript36.50.57815.48
ONNX36.30.57848.17
OpenVINO36.40.580927.12
TensorRT (FP32)39.80.57833.59
TensorRT (FP16)20.10.58001.85
TensorRT (INT8)17.50.56641.88
TF SavedModel90.80.578266.63
TF GraphDef36.30.578271.67
TF Lite36.30.5782187.36
MNN36.20.577527.05
NCNN36.20.580626.26
ExecuTorch36.20.578254.73
FormatoStatoDimensione su disco (MB)mAP50-95(B)Tempo di inferenza (ms/im)
PyTorch38.80.625411.14
TorchScript77.30.630412.00
ONNX76.90.630413.83
OpenVINO77.10.628462.44
TensorRT (FP32)79.90.63056.96
TensorRT (FP16)40.60.63133.14
TensorRT (INT8)26.60.62043.30
TF SavedModel192.40.6306139.85
TF GraphDef76.90.6306146.76
TF Lite76.90.6306568.18
MNN76.80.630667.67
NCNN76.80.630860.49
ExecuTorch76.90.6306120.37
FormatoStatoDimensione su disco (MB)mAP50-95(B)Tempo di inferenza (ms/im)
PyTorch49.00.636613.95
TorchScript97.60.639915.67
ONNX97.00.639916.62
OpenVINO97.30.637778.80
TensorRT (FP32)99.20.64078.86
TensorRT (FP16)50.80.63503.85
TensorRT (INT8)32.50.62244.52
TF SavedModel242.70.6409187.45
TF GraphDef97.00.6409193.92
TF Lite97.00.6409728.61
MNN96.90.636985.21
NCNN96.90.637377.62
ExecuTorch97.00.6409153.56
FormatoStatoDimensione su disco (MB)mAP50-95(B)Tempo di inferenza (ms/im)
PyTorch109.30.699223.19
TorchScript218.10.690025.75
ONNX217.50.690027.43
OpenVINO217.80.6872149.44
TensorRT (FP32)222.70.690213.87
TensorRT (FP16)111.10.68836.19
TensorRT (INT8)62.90.67936.62
TF SavedModel543.90.6900335.10
TF GraphDef217.50.6900348.86
TF Lite217.50.69001578.66
MNN217.30.6874168.95
NCNN217.40.6901132.13
ExecuTorch217.40.6900297.17

Benchmark eseguiti con Ultralytics 8.3.249

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 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)
# Benchmark YOLO26n speed and accuracy on the COCO128 dataset for all export formats
yolo benchmark model=yolo26n.pt data=coco128.yaml imgsz=640

Si noti che i risultati del benchmarking potrebbero variare in base all'esatta configurazione hardware e software di un sistema, nonché al carico di lavoro corrente del sistema al momento dell'esecuzione dei benchmark. Per i risultati più affidabili, utilizzare un dataset con un gran numero di immagini, ad esempio, data='coco.yaml' (5000 immagini val).

Best Practices per NVIDIA DGX Spark

Quando si utilizza NVIDIA DGX Spark, ci sono alcune best practice da seguire per abilitare le massime prestazioni nell'esecuzione di YOLO26.

  1. Monitorare le Prestazioni del Sistema

    Utilizzare gli strumenti di monitoraggio di NVIDIA per track l'utilizzo di GPU e CPU:

    nvidia-smi
    
  2. Ottimizzare l'Utilizzo della Memoria

    Con 128GB di memoria unificata, DGX Spark può gestire grandi dimensioni di batch e modelli. Considerare l'aumento della dimensione del batch per un throughput migliorato:

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

    Per prestazioni ottimali, esportare i modelli con precisione FP16 o INT8:

    yolo export model=yolo26n.pt format=engine half=True # FP16
    yolo export model=yolo26n.pt format=engine int8=True # INT8
    

Aggiornamenti del Sistema (Founders Edition)

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

La DGX Dashboard è il metodo consigliato per eseguire gli aggiornamenti di sistema garantendo la compatibilità. 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

Per gli utenti esperti, gli aggiornamenti possono essere eseguiti manualmente tramite terminale:

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

Attenzione

Assicurarsi che il sistema sia collegato a una fonte di alimentazione stabile e di aver eseguito il backup dei dati critici prima di eseguire gli aggiornamenti.

Prossimi passi

Per ulteriori informazioni e supporto, consultare la documentazione di Ultralytics YOLO26.

FAQ

Come si deploy Ultralytics YOLO26 su NVIDIA DGX Spark?

Il deployment di Ultralytics YOLO26 su NVIDIA DGX Spark è semplice. Puoi utilizzare l'immagine Docker pre-costruita per una configurazione rapida o installare manualmente i pacchetti richiesti. I passaggi dettagliati per ciascun approccio sono disponibili nelle sezioni Avvio Rapido con Docker e Avvio con Installazione Nativa.

Quali prestazioni posso aspettarmi da YOLO26 su NVIDIA DGX Spark?

I modelli YOLO26 offrono prestazioni eccellenti su DGX Spark grazie al Superchip GB10 Grace Blackwell. Il formato TensorRT offre le migliori prestazioni di inferenza. Consulta la sezione Tabella di Confronto Dettagliata per i risultati specifici dei benchmark su diverse dimensioni e formati di modello.

Perché dovrei usare TensorRT per YOLO26 su DGX Spark?

TensorRT è altamente raccomandato per il deployment dei modelli YOLO26 su DGX Spark grazie alle sue prestazioni ottimali. Accelera l'inferenza sfruttando le capacità della GPU Blackwell, garantendo massima efficienza e velocità. Scopri di più nella sezione Utilizzo di TensorRT su NVIDIA DGX Spark.

Come si confronta DGX Spark con i dispositivi Jetson per YOLO26?

DGX Spark offre una potenza di calcolo significativamente maggiore rispetto ai dispositivi Jetson, con prestazioni AI fino a 1 PFLOP e 128 GB di memoria unificata, rispetto ai 2070 TFLOPS e 128 GB di memoria di Jetson AGX Thor. DGX Spark è progettato come un supercomputer AI desktop, mentre i dispositivi Jetson sono sistemi embedded ottimizzati per il deployment edge.

Posso usare la stessa immagine Docker per DGX Spark e Jetson AGX Thor?

Sì! L' ultralytics/ultralytics:latest-nvidia-arm64 immagine Docker supporta sia NVIDIA DGX Spark (con DGX OS) che Jetson AGX Thor (con JetPack 7.0), poiché entrambi utilizzano architettura ARM64 con CUDA 13 e stack software simili.



📅 Creato 21 giorni fa ✏️ Aggiornato 9 giorni fa
glenn-jocherlakshanthadonuralpszr

Commenti