Guía de inicio rápido: NVIDIA DGX Spark con Ultralytics YOLO26
Esta guía completa ofrece un recorrido detallado para desplegar Ultralytics YOLO26 en NVIDIA DGX Spark, el superordenador de IA de escritorio compacto de NVIDIA. Además, presenta benchmarks de rendimiento para demostrar las capacidades de YOLO26 en este potente sistema.

Nota
Esta guía ha sido probada con NVIDIA DGX Spark Founders Edition ejecutando DGX OS basado en Ubuntu. Se espera que funcione con las últimas versiones de DGX OS.
¿Qué es NVIDIA DGX Spark?
NVIDIA DGX Spark es un superordenador de IA de escritorio compacto impulsado por el superchip NVIDIA GB10 Grace Blackwell. Ofrece hasta 1 petaFLOP de rendimiento de computación de IA con precisión FP4, lo que lo hace ideal para desarrolladores, investigadores y científicos de datos que necesitan potentes capacidades de IA en un formato de escritorio.
Especificaciones clave
| Especificaciones | Detalles |
|---|---|
| Rendimiento de la IA | Hasta 1 PFLOP (FP4) |
| GPU | Arquitectura NVIDIA Blackwell con Tensor Cores de 5ª Generación, RT Cores de 4ª Generación |
| CPU | Procesador Arm de 20 núcleos (10 Cortex-X925 + 10 Cortex-A725) |
| Memoria | 128 GB de memoria unificada del sistema LPDDR5x, interfaz de 256 bits, 4266 MHz, 273 GB/s de ancho de banda |
| Almacenamiento | 1 TB o 4 TB NVMe M.2 con autocifrado |
| Red | 1x RJ-45 (10 GbE), ConnectX-7 Smart NIC, Wi-Fi 7, Bluetooth 5.4 |
| Conectividad | 4x USB Tipo-C, 1x HDMI 2.1a, audio multicanal HDMI |
| Procesamiento de vídeo | 1x NVENC, 1x NVDEC |
DGX OS
NVIDIA DGX OS es una distribución Linux personalizada que proporciona una base de sistema operativo estable, probada y compatible para ejecutar aplicaciones de IA, aprendizaje automático y análisis en sistemas DGX. Incluye:
- Una base Linux robusta optimizada para cargas de trabajo de IA
- Controladores y configuración del sistema preconfigurados para hardware NVIDIA
- Actualizaciones de seguridad y capacidades de mantenimiento del sistema
- Compatibilidad con el ecosistema de software más amplio de NVIDIA
DGX OS sigue un calendario de lanzamientos regular con actualizaciones que suelen proporcionarse dos veces al año (alrededor de febrero y agosto), con parches de seguridad adicionales proporcionados entre las versiones principales.
Panel de control de DGX
DGX Spark incluye un DGX Dashboard integrado que proporciona:
- Monitorización del sistema en tiempo real: Visión general de las métricas operativas actuales del sistema
- Actualizaciones del sistema: Capacidad para aplicar actualizaciones directamente desde el panel de control
- Configuración del sistema: Cambiar el nombre del dispositivo y otras configuraciones
- JupyterLab integrado: Acceso a Jupyter Notebooks locales para desarrollo

Acceso al panel de control
Haga clic en el botón "Mostrar aplicaciones" en la esquina inferior izquierda del escritorio de Ubuntu, luego seleccione "DGX Dashboard" para abrirlo en su navegador.
# Open an SSH tunnel
ssh -L 11000:localhost:11000 username@spark-abcd.local
# Then open in browser
# http://localhost:11000
Después de conectarse con NVIDIA Sync, haga clic en el botón "DGX Dashboard" para abrir el panel de control en http://localhost:11000.
JupyterLab integrado
El panel de control incluye una instancia de JupyterLab integrada que crea automáticamente un entorno virtual e instala los paquetes recomendados al iniciarse. A cada cuenta de usuario se le asigna un puerto dedicado para el acceso a JupyterLab.
Inicio rápido con Docker
La forma más rápida de empezar con Ultralytics YOLO26 en NVIDIA DGX Spark es ejecutarlo con imágenes Docker precompiladas. La misma imagen Docker que es compatible con Jetson AGX Thor (JetPack 7.0) funciona en 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 vez hecho esto, salte a la sección Uso de TensorRT en NVIDIA DGX Spark.
Comenzar con la instalación nativa
Para una instalación nativa sin Docker, siga estos pasos.
Instalar el paquete Ultralytics
Aquí instalaremos el paquete Ultralytics en DGX Spark con dependencias opcionales para poder exportar los modelos de PyTorch a otros formatos diferentes. Nos centraremos principalmente en las exportaciones de NVIDIA TensorRT porque TensorRT garantizará que podamos obtener el máximo rendimiento del DGX Spark.
Actualizar la lista de paquetes, instalar pip y actualizar a la última versión
sudo apt update sudo apt install python3-pip -y pip install -U pipInstalar
ultralyticspaquete pip con dependencias opcionalespip install ultralytics[export]Reiniciar el dispositivo
sudo reboot
Instalar PyTorch y Torchvision
La instalación de Ultralytics anterior instalará Torch y Torchvision. Sin embargo, estos paquetes instalados vía pip pueden no estar completamente optimizados para la arquitectura ARM64 del DGX Spark con CUDA 13. Por lo tanto, recomendamos instalar las versiones compatibles con CUDA 13:
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu130
Información
Al ejecutar PyTorch 2.9.1 en NVIDIA DGX Spark, puede encontrar lo siguiente UserWarning al inicializar CUDA (por ejemplo, al ejecutar 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)
Esta advertencia puede ignorarse de forma segura. Para abordar esto de forma permanente, se ha enviado una corrección en el PR de PyTorch #164590 que se incluirá en la versión 2.10 de PyTorch.
Instalar onnxruntime-gpu
El onnxruntime-gpu paquete alojado en PyPI no tiene aarch64 binarios para sistemas ARM64. Por lo tanto, necesitamos instalar este paquete manualmente. Este paquete es necesario para algunas de las exportaciones.
Aquí descargaremos e instalaremos onnxruntime-gpu 1.24.0 con Python3.12 soporte.
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.24.0-cp312-cp312-linux_aarch64.whl
Uso de TensorRT en NVIDIA DGX Spark
Entre todos los formatos de exportación de modelos compatibles con Ultralytics, TensorRT ofrece el mayor rendimiento de inferencia en NVIDIA DGX Spark, lo que lo convierte en nuestra principal recomendación para despliegues. Para instrucciones de configuración y uso avanzado, consulte nuestra guía de integración de TensorRT dedicada.
Convertir el modelo a TensorRT y ejecutar la inferencia
El modelo YOLO26n en formato PyTorch se convierte a TensorRT para ejecutar inferencia con el modelo exportado.
Ejemplo
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
Visite la página de exportación para acceder a argumentos adicionales al exportar modelos a diferentes formatos de modelo
Benchmarks de YOLO11 en NVIDIA DGX Spark
Los benchmarks de YOLO11 fueron ejecutados por el equipo de Ultralytics en múltiples formatos de modelo midiendo la velocidad y la precisión: PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN, ExecuTorch. Los benchmarks se ejecutaron en NVIDIA DGX Spark con precisión FP32 y un tamaño de imagen de entrada predeterminado de 640.
Tabla de comparación detallada
La siguiente tabla representa los resultados de los benchmarks para cinco modelos diferentes (YOLO11n, YOLO11s, YOLO11m, YOLO11l, YOLO11x) en múltiples formatos, proporcionando el estado, tamaño, métrica mAP50-95(B) y tiempo de inferencia para cada combinación.
Rendimiento
| Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.4 | 0.5071 | 2.67 |
| TorchScript | ✅ | 10.5 | 0.5083 | 2.62 |
| ONNX | ✅ | 10.2 | 0.5074 | 5.92 |
| OpenVINO | ✅ | 10.4 | 0.5058 | 14.95 |
| TensorRT (FP32) | ✅ | 12.8 | 0.5085 | 1.95 |
| TensorRT (FP16) | ✅ | 7.0 | 0.5068 | 1.01 |
| TensorRT (INT8) | ✅ | 18.6 | 0.4880 | 1.62 |
| TF SavedModel | ✅ | 25.7 | 0.5076 | 36.39 |
| TF GraphDef | ✅ | 10.3 | 0.5076 | 41.06 |
| TF Lite | ✅ | 10.3 | 0.5075 | 64.36 |
| MNN | ✅ | 10.1 | 0.5075 | 12.14 |
| NCNN | ✅ | 10.2 | 0.5041 | 12.31 |
| ExecuTorch | ✅ | 10.2 | 0.5075 | 27.61 |
| Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 18.4 | 0.5767 | 5.38 |
| TorchScript | ✅ | 36.5 | 0.5781 | 5.48 |
| ONNX | ✅ | 36.3 | 0.5784 | 8.17 |
| OpenVINO | ✅ | 36.4 | 0.5809 | 27.12 |
| TensorRT (FP32) | ✅ | 39.8 | 0.5783 | 3.59 |
| TensorRT (FP16) | ✅ | 20.1 | 0.5800 | 1.85 |
| TensorRT (INT8) | ✅ | 17.5 | 0.5664 | 1.88 |
| TF SavedModel | ✅ | 90.8 | 0.5782 | 66.63 |
| TF GraphDef | ✅ | 36.3 | 0.5782 | 71.67 |
| TF Lite | ✅ | 36.3 | 0.5782 | 187.36 |
| MNN | ✅ | 36.2 | 0.5775 | 27.05 |
| NCNN | ✅ | 36.2 | 0.5806 | 26.26 |
| ExecuTorch | ✅ | 36.2 | 0.5782 | 54.73 |
| Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 38.8 | 0.6254 | 11.14 |
| TorchScript | ✅ | 77.3 | 0.6304 | 12.00 |
| ONNX | ✅ | 76.9 | 0.6304 | 13.83 |
| OpenVINO | ✅ | 77.1 | 0.6284 | 62.44 |
| TensorRT (FP32) | ✅ | 79.9 | 0.6305 | 6.96 |
| TensorRT (FP16) | ✅ | 40.6 | 0.6313 | 3.14 |
| TensorRT (INT8) | ✅ | 26.6 | 0.6204 | 3.30 |
| TF SavedModel | ✅ | 192.4 | 0.6306 | 139.85 |
| TF GraphDef | ✅ | 76.9 | 0.6306 | 146.76 |
| TF Lite | ✅ | 76.9 | 0.6306 | 568.18 |
| MNN | ✅ | 76.8 | 0.6306 | 67.67 |
| NCNN | ✅ | 76.8 | 0.6308 | 60.49 |
| ExecuTorch | ✅ | 76.9 | 0.6306 | 120.37 |
| Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 49.0 | 0.6366 | 13.95 |
| TorchScript | ✅ | 97.6 | 0.6399 | 15.67 |
| ONNX | ✅ | 97.0 | 0.6399 | 16.62 |
| OpenVINO | ✅ | 97.3 | 0.6377 | 78.80 |
| TensorRT (FP32) | ✅ | 99.2 | 0.6407 | 8.86 |
| TensorRT (FP16) | ✅ | 50.8 | 0.6350 | 3.85 |
| TensorRT (INT8) | ✅ | 32.5 | 0.6224 | 4.52 |
| TF SavedModel | ✅ | 242.7 | 0.6409 | 187.45 |
| TF GraphDef | ✅ | 97.0 | 0.6409 | 193.92 |
| TF Lite | ✅ | 97.0 | 0.6409 | 728.61 |
| MNN | ✅ | 96.9 | 0.6369 | 85.21 |
| NCNN | ✅ | 96.9 | 0.6373 | 77.62 |
| ExecuTorch | ✅ | 97.0 | 0.6409 | 153.56 |
| Formato | Estado | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 109.3 | 0.6992 | 23.19 |
| TorchScript | ✅ | 218.1 | 0.6900 | 25.75 |
| ONNX | ✅ | 217.5 | 0.6900 | 27.43 |
| OpenVINO | ✅ | 217.8 | 0.6872 | 149.44 |
| TensorRT (FP32) | ✅ | 222.7 | 0.6902 | 13.87 |
| TensorRT (FP16) | ✅ | 111.1 | 0.6883 | 6.19 |
| TensorRT (INT8) | ✅ | 62.9 | 0.6793 | 6.62 |
| TF SavedModel | ✅ | 543.9 | 0.6900 | 335.10 |
| TF GraphDef | ✅ | 217.5 | 0.6900 | 348.86 |
| TF Lite | ✅ | 217.5 | 0.6900 | 1578.66 |
| MNN | ✅ | 217.3 | 0.6874 | 168.95 |
| NCNN | ✅ | 217.4 | 0.6901 | 132.13 |
| ExecuTorch | ✅ | 217.4 | 0.6900 | 297.17 |
Evaluado con Ultralytics 8.3.249
Reproducir nuestros resultados
Para reproducir los benchmarks de Ultralytics anteriores en todos los formatos de exportación, ejecute este código:
Ejemplo
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
Tenga en cuenta que los resultados de los benchmarks pueden variar según la configuración exacta de hardware y software de un sistema, así como la carga de trabajo actual del sistema en el momento en que se ejecutan los benchmarks. Para obtener los resultados más fiables, utilice un conjunto de datos con un gran número de imágenes, p. ej., data='coco.yaml' (5000 imágenes de validación).
Mejores prácticas para NVIDIA DGX Spark
Al utilizar NVIDIA DGX Spark, existen algunas buenas prácticas a seguir para habilitar el máximo rendimiento al ejecutar YOLO26.
Monitorizar el Rendimiento del Sistema
Utilice las herramientas de monitorización de NVIDIA para track la utilización de la GPU y la CPU:
nvidia-smiOptimizar el Uso de Memoria
Con 128 GB de memoria unificada, DGX Spark puede manejar grandes tamaños de lote y modelos. Considere aumentar el tamaño del lote para mejorar el rendimiento:
from ultralytics import YOLO model = YOLO("yolo26n.engine") results = model.predict(source="path/to/images", batch=16)Utilizar TensorRT con FP16 o INT8
Para obtener el mejor rendimiento, exporte los modelos con precisión FP16 o INT8:
yolo export model=yolo26n.pt format=engine half=True # FP16 yolo export model=yolo26n.pt format=engine int8=True # INT8
Actualizaciones del sistema (Founders Edition)
Mantener su DGX Spark Founders Edition actualizado es crucial para el rendimiento y la seguridad. NVIDIA ofrece dos métodos principales para actualizar el sistema operativo, los controladores y el firmware.
Uso del panel de control de DGX (Recomendado)
El DGX Dashboard es la forma recomendada de realizar actualizaciones del sistema, garantizando la compatibilidad. Permite:
- Ver las actualizaciones del sistema disponibles
- Instalar parches de seguridad y actualizaciones del sistema
- Gestionar las actualizaciones de controladores y firmware de NVIDIA
Actualizaciones manuales del sistema
Para usuarios avanzados, las actualizaciones pueden realizarse manualmente a través de la terminal:
sudo apt update
sudo apt dist-upgrade
sudo fwupdmgr refresh
sudo fwupdmgr upgrade
sudo reboot
Advertencia
Asegúrese de que su sistema esté conectado a una fuente de alimentación estable y de haber realizado una copia de seguridad de los datos críticos antes de realizar las actualizaciones.
Próximos pasos
Para obtener más información y soporte, consulte la documentación de Ultralytics YOLO26.
Preguntas frecuentes
¿Cómo despliego Ultralytics YOLO26 en NVIDIA DGX Spark?
El despliegue de Ultralytics YOLO26 en NVIDIA DGX Spark es sencillo. Puede utilizar la imagen Docker precompilada para una configuración rápida o instalar manualmente los paquetes necesarios. Los pasos detallados para cada enfoque se encuentran en las secciones Inicio rápido con Docker e Inicio con instalación nativa.
¿Qué rendimiento puedo esperar de YOLO26 en NVIDIA DGX Spark?
Los modelos YOLO26 ofrecen un rendimiento excelente en DGX Spark gracias al Superchip GB10 Grace Blackwell. El formato TensorRT proporciona el mejor rendimiento de inferencia. Consulte la sección Tabla de comparación detallada para ver los resultados específicos de los benchmarks en diferentes tamaños y formatos de modelo.
¿Por qué debería usar TensorRT para YOLO26 en DGX Spark?
TensorRT es altamente recomendado para desplegar modelos YOLO26 en DGX Spark debido a su rendimiento óptimo. Acelera la inferencia aprovechando las capacidades de la GPU Blackwell, asegurando máxima eficiencia y velocidad. Obtenga más información en la sección Uso de TensorRT en NVIDIA DGX Spark.
¿Cómo se compara DGX Spark con los dispositivos Jetson para YOLO26?
DGX Spark ofrece una potencia de cómputo significativamente mayor que los dispositivos Jetson, con hasta 1 PFLOP de rendimiento de IA y 128 GB de memoria unificada, en comparación con los 2070 TFLOPS y 128 GB de memoria del Jetson AGX Thor. DGX Spark está diseñado como un superordenador de IA de escritorio, mientras que los dispositivos Jetson son sistemas embebidos optimizados para el despliegue en el borde.
¿Puedo usar la misma imagen Docker para DGX Spark y Jetson AGX Thor?
¡Sí! La ultralytics/ultralytics:latest-nvidia-arm64 imagen Docker es compatible tanto con NVIDIA DGX Spark (con DGX OS) como con Jetson AGX Thor (con JetPack 7.0), ya que ambos utilizan arquitectura ARM64 con CUDA 13 y pilas de software similares.