Commencer

Guide de démarrage rapide : NVIDIA DGX Spark avec Ultralytics YOLO26

Ce guide explique comment déployer Ultralytics YOLO26 sur NVIDIA DGX Spark, le superordinateur IA de bureau compact de NVIDIA, et présente des benchmarks YOLO11 sur différents formats d’export exécutés sur ce système.

NVIDIA DGX Spark AI workstation overview

Remarque

Ce guide a été testé avec l’édition Founders de NVIDIA DGX Spark exécutant DGX OS basé sur Ubuntu. Il devrait fonctionner avec les versions les plus récentes de DGX OS.

Qu’est-ce que NVIDIA DGX Spark ?#

NVIDIA DGX Spark est un superordinateur IA de bureau compact équipé du NVIDIA GB10 Grace Blackwell Superchip. Il offre jusqu’à 1 pétaFLOP de puissance de calcul IA en précision FP4 et est conçu pour les développeurs, les chercheurs et les spécialistes des données qui ont besoin de puissantes capacités d’IA dans un format de bureau.



À regarder : Comment atteindre jusqu’à 1000 FPS avec Ultralytics YOLO26 sur NVIDIA DGX Spark | TensorRT et inférence par lots

Caractéristiques principales#

CaractéristiqueDétails
Performances IAJusqu’à 1 PFLOP (FP4)
GPUArchitecture NVIDIA Blackwell avec Tensor Cores de 5e génération et RT Cores de 4e génération
CPUProcesseur Arm à 20 cœurs (10 Cortex-X925 + 10 Cortex-A725)
Mémoire128 Go de mémoire système unifiée LPDDR5x, interface 256 bits, 4 266 MHz, bande passante de 273 Go/s
StockageNVMe M.2 de 1 To ou 4 To avec chiffrement automatique
Réseau1x RJ-45 (10 GbE), carte réseau intelligente ConnectX-7, Wi-Fi 7, Bluetooth 5.4
Connectivité4x USB Type-C, 1x HDMI 2.1a, audio multicanal HDMI
Traitement vidéo1x NVENC, 1x NVDEC

DGX OS#

NVIDIA DGX OS est une distribution Linux personnalisée qui fournit une base de système d’exploitation stable, testée et prise en charge pour exécuter des applications d’IA, d’apprentissage automatique et d’analyse sur les systèmes DGX. Elle comprend :

  • Une base Linux robuste, optimisée pour les charges de travail d’IA
  • Des pilotes et des paramètres système préconfigurés pour le matériel NVIDIA
  • Des mises à jour de sécurité et des fonctionnalités de maintenance du système
  • La compatibilité avec l’écosystème logiciel NVIDIA au sens large

DGX OS suit un calendrier de publication régulier, avec des mises à jour généralement proposées deux fois par an (vers février et août) et des correctifs de sécurité supplémentaires entre les versions majeures.

DGX Dashboard#

DGX Spark est livré avec un DGX Dashboard intégré qui offre :

  • Surveillance du système en temps réel : vue d’ensemble des métriques opérationnelles actuelles du système
  • Mises à jour du système : possibilité d’appliquer les mises à jour directement depuis le tableau de bord
  • Paramètres système : modification du nom de l’appareil et d’autres configurations
  • JupyterLab intégré : accès aux notebooks Jupyter locaux pour le développement

NVIDIA DGX management dashboard interface

Accéder au tableau de bord#

Clique sur le bouton « Afficher les applications » dans le coin inférieur gauche du bureau Ubuntu, puis sélectionne « DGX Dashboard » pour l’ouvrir dans ton navigateur.

JupyterLab intégré

Le tableau de bord comprend une instance JupyterLab intégrée qui crée automatiquement un environnement virtuel et installe les packages recommandés au démarrage. Chaque compte utilisateur se voit attribuer un port dédié pour accéder à JupyterLab.

Démarrage rapide avec Docker#

Pour démarrer rapidement avec Ultralytics YOLO26 sur NVIDIA DGX Spark, le plus simple est d’exécuter les images Docker préconstruites. L’image NVIDIA ARM64 prend en charge DGX Spark avec 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 demande de périphérique CDI ci-dessus concerne DGX Spark exécutant DGX OS. Pour les charges de travail PyTorch sur Jetson AGX Thor, consulte les prérequis distincts sur l’hôte et la restriction TensorRT dans le guide NVIDIA Jetson.

Cette image utilise NVIDIA PyTorch 26.10, CUDA 13.4 et TensorRT 11.4. Mets à jour le pilote de l’hôte DGX OS vers une version prise en charge par NVIDIA PyTorch 26.10, puis reconstruis les moteurs TensorRT après avoir changé d’image ou de GPU cible.

Une fois cette étape terminée, passe directement à Utiliser TensorRT sur NVIDIA DGX Spark.

Commencer par une installation native#

Pour une installation native sans Docker, suis les étapes ci-dessous.

Installer le package Ultralytics#

Nous allons ici installer le paquet Ultralytics sur DGX Spark. Les dépendances d’export sont installées automatiquement lors du premier export d’un modèle ; seul le paquet de base est donc nécessaire ici. Ce guide porte sur les exports NVIDIA TensorRT, car TensorRT offre les meilleures performances sur DGX Spark.

  1. Mets à jour la liste des paquets, installe pip, puis passe-le à la dernière version.

    sudo apt update
    sudo apt install python3-pip -y
    pip install -U pip
  2. Installer le package pip ultralytics

    pip install ultralytics
  3. Redémarrer l’appareil

    sudo reboot

Installer PyTorch et Torchvision#

L’installation ultralytics ci-dessus installe PyTorch et Torchvision. Cependant, ces paquets installés via pip ne sont peut-être pas entièrement optimisés pour l’architecture ARM64 de DGX Spark avec CUDA 13. Nous recommandons donc d’installer les versions compatibles avec CUDA 13 :

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

Lors de l’exécution de PyTorch 2.9.1 sur NVIDIA DGX Spark, tu peux rencontrer l’avertissement suivant UserWarning lors de l’initialisation de CUDA (par exemple, en exécutant yolo checks, yolo predict, etc.) :

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)

Tu peux ignorer cet avertissement sans risque.

Installer onnxruntime-gpu#

Les versions actuelles d’ONNX Runtime GPU fournissent des wheels Linux ARM64, notamment pour Python 3.12. L’image Docker NVIDIA ARM64 installe le package officiel ; pour les installations natives avec CUDA 13, utilise :

pip install onnxruntime-gpu

Utiliser TensorRT sur NVIDIA DGX Spark#

Parmi tous les formats d’export de modèles pris en charge par Ultralytics, TensorRT offre les meilleures performances d’inférence sur NVIDIA DGX Spark et constitue donc notre premier choix pour les déploiements.

Convertir le modèle en TensorRT et exécuter l’inférence#

Le modèle YOLO26n PyTorch est converti en TensorRT, puis le modèle exporté est utilisé pour l’inférence.

Exemple
from ultralytics import YOLO

# Charger un modèle YOLO26n PyTorch
model = YOLO("yolo26n.pt")

# Exporter le modèle au format TensorRT FP16
model.export(format="engine", quantize=16)  # crée 'yolo26n.engine'

# Charger le modèle TensorRT exporté
trt_model = YOLO("yolo26n.engine")

# Exécuter l’inférence
results = trt_model("https://ultralytics.com/images/bus.jpg")

Benchmarks YOLO11 sur NVIDIA DGX Spark#

L’équipe Ultralytics a réalisé des benchmarks YOLO11 sur plusieurs formats de modèle, en mesurant la vitesse et la précision : PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN et ExecuTorch. Les benchmarks ont été réalisés sur NVIDIA DGX Spark en précision FP32, avec la taille d’image d’entrée par défaut de 640.

Tableau comparatif détaillé#

Le tableau ci-dessous présente les résultats du benchmark de cinq modèles différents (YOLO11n, YOLO11s, YOLO11m, YOLO11l, YOLO11x) sur plusieurs formats. Pour chaque combinaison, il indique le statut, la taille, la métrique mAP50-95(B) et le temps d’inférence.

Performances
FormatStatutTaille sur le disque (MB)mAP50-95(B)Temps d’inférence (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 réalisé avec Ultralytics 8.3.249

Reproduire nos résultats#

Pour reproduire les benchmarks Ultralytics ci-dessus sur tous les formats d’export, exécute ce code :

Exemple
from ultralytics import YOLO

# Charger un modèle YOLO26n PyTorch
model = YOLO("yolo26n.pt")

# Évaluer la vitesse et la précision de YOLO26n sur le jeu de données COCO128 dans tous les formats d’exportation
results = model.benchmark(data="coco128.yaml", imgsz=640)

Note que les résultats du benchmark peuvent varier selon la configuration matérielle et logicielle précise d’un système, ainsi que sa charge au moment de l’exécution des benchmarks. Pour obtenir les résultats les plus fiables, utilise un jeu de données contenant un grand nombre d’images, par exemple data='coco.yaml' (5000 images de validation).

Précision de YOLO26 avec TensorRT sur DGX Spark#

À une taille de lot de 1 sur DGX Spark, TensorRT INT8 est plus lent que FP16 pour YOLO26n et YOLO26s, et à peu près aussi rapide pour YOLO26m (à 2 % près, aussi bien pour la validation que pour le temps de calcul GPU de trtexec). INT8 perd également de 1,1 à 1,8 mAP, donc FP16 est le meilleur choix pour ces modèles. Le tableau YOLO11 ci-dessus montre la même tendance : TensorRT (INT8) est plus lent que TensorRT (FP16) pour les cinq modèles.

ModèleFormatTaille sur le disque (MB)mAP50-95(B)Temps d’inférence (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

La précision et la vitesse sont mesurées lors de la validation sur COCO val2017 (5 000 images), avec une taille d’image de 640 et une taille de lot de 1. Les moteurs INT8 sont calibrés sur COCO128. Tests réalisés avec Ultralytics 8.4.192 dans ultralytics/ultralytics:latest-nvidia-arm64 (NVIDIA PyTorch 26.08, TensorRT 11.2.1.2, ModelOpt 0.45.0).

Bonnes pratiques pour NVIDIA DGX Spark#

Lorsque tu utilises NVIDIA DGX Spark, suis ces bonnes pratiques pour obtenir les meilleures performances avec YOLO26.

  1. Surveiller les performances du système

    Utilise les outils de surveillance de NVIDIA pour suivre l’utilisation du GPU et du CPU :

    nvidia-smi
  2. Optimiser l’utilisation de la mémoire

    Avec 128 GB de mémoire unifiée, DGX Spark peut gérer de grandes tailles de lot et des modèles volumineux. Envisage d’augmenter la taille de lot pour améliorer le débit :

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

    À une taille de lot de 1 sur DGX Spark, INT8 est plus lent que FP16 pour YOLO26n et YOLO26s, n’est pas plus rapide pour YOLO26m et est moins précis (voir Précision de YOLO26 avec TensorRT sur DGX Spark) :

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

Mises à jour du système (Founders Edition)#

Il est essentiel de maintenir ta DGX Spark Founders Edition à jour pour garantir ses performances et sa sécurité. NVIDIA propose deux méthodes principales pour mettre à jour le système d’exploitation, les pilotes et le micrologiciel.

Le DGX Dashboard est la méthode recommandée pour effectuer les mises à jour du système tout en assurant la compatibilité. Il te permet de :

  • Consulter les mises à jour système disponibles
  • Installer les correctifs de sécurité et les mises à jour système
  • Gérer les mises à jour des pilotes et du micrologiciel NVIDIA

Mises à jour manuelles du système#

Les utilisateurs avancés peuvent effectuer les mises à jour manuellement depuis le terminal :

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

Avant d’effectuer les mises à jour, assure-toi que ton système est connecté à une source d’alimentation stable et que tu as sauvegardé les données essentielles.

Étapes suivantes#

Pour approfondir le sujet et obtenir de l’aide, consulte la documentation Ultralytics YOLO26.

FAQ#

  • Le déploiement d’Ultralytics YOLO26 sur NVIDIA DGX Spark est simple. Tu peux utiliser l’image Docker préconstruite pour une configuration rapide ou installer manuellement les packages nécessaires. Les étapes détaillées de chaque méthode se trouvent dans les sections Démarrage rapide avec Docker et Commencer avec une installation native.

  • Les modèles YOLO s’exécutent rapidement sur DGX Spark grâce à la superpuce Grace Blackwell GB10. Le format TensorRT offre les meilleures performances d’inférence. Consulte la section Tableau comparatif détaillé pour les résultats de benchmark de YOLO11 sur DGX Spark selon différentes tailles de modèles et différents formats, ainsi que la section Précision de YOLO26 avec TensorRT sur DGX Spark pour les résultats de YOLO26 en FP16 et INT8.

  • TensorRT est recommandé pour déployer des modèles YOLO26 sur DGX Spark, car il offre l’inférence la plus rapide parmi les formats d’export pris en charge, en exploitant les Tensor Cores du GPU Blackwell avec une précision FP16 ou INT8.

  • DGX Spark offre jusqu’à 1 PFLOP de performances IA et 128 GB de mémoire unifiée, contre 2070 TFLOPS et 128 GB de mémoire pour le Jetson AGX Thor. DGX Spark est conçu comme un superordinateur IA de bureau, tandis que les appareils Jetson sont des systèmes embarqués optimisés pour les déploiements en périphérie.

  • Pour les charges de travail PyTorch, ultralytics/ultralytics:latest-nvidia-arm64 prend en charge DGX Spark avec DGX OS et Thor avec JetPack 7.1. TensorRT 11.4 fourni avec l’image ne prend pas en charge JetPack : les flux de travail TensorRT sur Jetson doivent donc utiliser le runtime TensorRT 10.x pris en charge par leur version de JetPack. Consulte les exigences Docker pour Jetson.

Commentaires

Pose une question, partage tes résultats ou aide quelqu’un d’autre.