Guía de inicio rápido: NVIDIA DGX Spark con Ultralytics YOLO26
Esta guía explica cómo implementar Ultralytics YOLO26 en NVIDIA DGX Spark, el superordenador compacto de sobremesa con IA de NVIDIA, e incluye pruebas de rendimiento de YOLO11 en distintos formatos de exportación en este sistema.
Esta guía se ha probado con NVIDIA DGX Spark Founders Edition, que ejecuta DGX OS basado en Ubuntu. Se espera que funcione con las versiones más recientes de DGX OS.
¿Qué es NVIDIA DGX Spark?#
NVIDIA DGX Spark es un superordenador compacto de sobremesa con IA, equipado con el superchip NVIDIA GB10 Grace Blackwell. Ofrece hasta 1 petaFLOP de rendimiento de computación de IA con precisión FP4 y está diseñado para desarrolladores, investigadores y científicos de datos que necesitan potentes capacidades de IA en un formato de sobremesa.
Ver: Cómo alcanzar hasta 1000 FPS con Ultralytics YOLO26 en NVIDIA DGX Spark | TensorRT e inferencia por lotes
Especificaciones principales#
| Especificación | Detalles |
|---|---|
| Rendimiento de IA | Hasta 1 PFLOP (FP4) |
| GPU | Arquitectura NVIDIA Blackwell con Tensor Cores de 5.ª generación y 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, ancho de banda de 273 GB/s |
| Almacenamiento | 1 TB o 4 TB NVMe M.2 con cifrado automático |
| Red | 1x RJ-45 (10 GbE), tarjeta de red inteligente ConnectX-7, Wi-Fi 7, Bluetooth 5.4 |
| Conectividad | 4x USB Type-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 de Linux personalizada que proporciona una base de sistema operativo estable, probada y con soporte 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 ajustes del sistema preconfigurados para el hardware de NVIDIA
- Actualizaciones de seguridad y funciones de mantenimiento del sistema
- Compatibilidad con el ecosistema de software más amplio de NVIDIA
DGX OS sigue un calendario de lanzamientos periódico, con actualizaciones que suelen publicarse dos veces al año (alrededor de febrero y agosto), además de parches de seguridad adicionales entre las versiones principales.
Panel de control de DGX#
DGX Spark incluye un panel de control de DGX integrado que ofrece:
- Supervisión del sistema en tiempo real: Vista general de las métricas operativas actuales del sistema
- Actualizaciones del sistema: Posibilidad de aplicar actualizaciones directamente desde el panel de control
- Ajustes del sistema: Cambia el nombre del dispositivo y otros parámetros
- JupyterLab integrado: Accede a cuadernos de Jupyter locales para desarrollar
Acceso al panel de control#
Haz clic en el botón «Mostrar aplicaciones» de la esquina inferior izquierda del escritorio de Ubuntu y, después, selecciona «Panel de control de DGX» para abrirlo en el navegador.
El panel incluye una instancia integrada de JupyterLab que crea automáticamente un entorno virtual e instala los paquetes recomendados al iniciarse. A cada cuenta de usuario se le asigna un puerto específico para acceder a JupyterLab.
Inicio rápido con Docker#
La forma más rápida de empezar a usar Ultralytics YOLO26 en NVIDIA DGX Spark es ejecutar las imágenes Docker prediseñadas. La imagen NVIDIA ARM64 es compatible con DGX Spark y DGX OS.
t=ultralytics/ultralytics:latest-nvidia-arm64
sudo docker pull $t && sudo docker run -it --ipc=host --device nvidia.com/gpu=all $tLa solicitud de dispositivo CDI anterior se aplica a DGX Spark con DGX OS. Para cargas de trabajo de PyTorch en Jetson AGX Thor, consulta los requisitos del sistema anfitrión y la restricción de TensorRT en la guía de NVIDIA Jetson.
Esta imagen utiliza NVIDIA PyTorch 26.10, CUDA 13.4 y TensorRT 11.4. Actualiza el controlador del host DGX OS a una versión compatible con NVIDIA PyTorch 26.10 y vuelve a generar los motores TensorRT después de cambiar la imagen o la GPU de destino.
Cuando hayas terminado, ve directamente a Usar TensorRT en NVIDIA DGX Spark.
Empieza con la instalación nativa#
Para instalarlo de forma nativa, sin Docker, sigue estos pasos.
Instala el paquete Ultralytics#
Aquí instalaremos el paquete Ultralytics en DGX Spark. Las dependencias de exportación se instalan automáticamente la primera vez que exportas un modelo, así que aquí solo necesitas el paquete base. Esta guía se centra en las exportaciones a NVIDIA TensorRT, ya que TensorRT ofrece el máximo rendimiento en DGX Spark.
-
Actualiza la lista de paquetes, instala pip y actualízalo a la versión más reciente
sudo apt update sudo apt install python3-pip -y pip install -U pip -
Instala el paquete pip
ultralyticspip install ultralytics -
Reinicia el dispositivo
sudo reboot
Instala PyTorch y Torchvision#
La instalación anterior de ultralytics instala PyTorch y Torchvision. Sin embargo, es posible que estos paquetes instalados mediante pip no estén totalmente optimizados para la arquitectura ARM64 de DGX Spark con CUDA 13. Por eso, recomendamos instalar las versiones compatibles con CUDA 13:
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu130Al ejecutar PyTorch 2.9.1 en NVIDIA DGX Spark, puede aparecer el siguiente mensaje 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)Puedes ignorar esta advertencia sin problema.
Instala onnxruntime-gpu#
Las versiones actuales de ONNX Runtime GPU proporcionan paquetes wheel para Linux ARM64, incluido Python 3.12. La imagen Docker ARM64 de NVIDIA instala el paquete oficial; para instalaciones nativas con CUDA 13, usa:
pip install onnxruntime-gpuUsa TensorRT en NVIDIA DGX Spark#
De todos los formatos de exportación de modelos compatibles con Ultralytics, TensorRT ofrece el mayor rendimiento de inferencia en NVIDIA DGX Spark, por lo que es nuestra opción recomendada para las implementaciones.
Convierte el modelo a TensorRT y ejecuta la inferencia#
El modelo YOLO26n de PyTorch se convierte a TensorRT y, después, se utiliza el modelo exportado para la inferencia.
from ultralytics import YOLO
# Carga un modelo YOLO26n de PyTorch
model = YOLO("yolo26n.pt")
# Exporta el modelo a TensorRT FP16
model.export(format="engine", quantize=16) # crea 'yolo26n.engine'
# Carga el modelo exportado a TensorRT
trt_model = YOLO("yolo26n.engine")
# Ejecutar inferencia
results = trt_model("https://ultralytics.com/images/bus.jpg")Pruebas de rendimiento de YOLO11 en NVIDIA DGX Spark#
El equipo de Ultralytics realizó pruebas de rendimiento de YOLO11 en varios formatos de modelo para medir la velocidad y la precisión: PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN y ExecuTorch. Las pruebas se realizaron en NVIDIA DGX Spark con precisión FP32 y un tamaño de imagen de entrada predeterminado de 640.
Tabla comparativa detallada#
La tabla siguiente muestra los resultados del benchmark de cinco modelos distintos (YOLO11n, YOLO11s, YOLO11m, YOLO11l, YOLO11x) en varios formatos, e indica el estado, el tamaño, la métrica mAP50-95(B) y el tiempo de inferencia de cada combinación.
| 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 |
Pruebas realizadas con Ultralytics 8.3.249
Reproduce nuestros resultados#
Para reproducir las pruebas de rendimiento de Ultralytics anteriores en todos los formatos de exportación, ejecuta este código:
from ultralytics import YOLO
# Carga un modelo YOLO26n de PyTorch
model = YOLO("yolo26n.pt")
# Prueba la velocidad y la precisión de YOLO26n en el conjunto de datos COCO128 con todos los formatos de exportación
results = model.benchmark(data="coco128.yaml", imgsz=640)Ten en cuenta que los resultados de las pruebas de rendimiento pueden variar según la configuración exacta de hardware y software del sistema, así como la carga de trabajo del sistema en el momento de ejecutar las pruebas. Para obtener los resultados más fiables, usa un conjunto de datos con muchas imágenes, p. ej., data='coco.yaml' (5000 imágenes de validación).
Precisión de YOLO26 con TensorRT en DGX Spark#
Con un tamaño de lote de 1 en DGX Spark, TensorRT INT8 es más lento que FP16 para YOLO26n y YOLO26s, y ofrece un rendimiento prácticamente igual para YOLO26m (con una diferencia inferior al 2 % tanto en la validación como en el tiempo de cálculo de GPU de trtexec). INT8 también pierde entre 1,1 y 1,8 mAP, por lo que FP16 es la mejor opción para estos modelos. La tabla de YOLO11 de arriba muestra el mismo patrón: TensorRT (INT8) es más lento que TensorRT (FP16) en los cinco modelos.
| Modelo | Formato | Tamaño en disco (MB) | mAP50-95(B) | Tiempo de inferencia (ms/im) |
|---|---|---|---|---|
| YOLO26n | TensorRT (FP16) | 6.7 | 0.4032 | 0.79 |
| YOLO26n | TensorRT (INT8) | 28.4 | 0.3849 | 1.43 |
| YOLO26s | TensorRT (FP16) | 20.3 | 0.4793 | 1.49 |
| YOLO26s | TensorRT (INT8) | 34.4 | 0.4644 | 1.73 |
| YOLO26m | TensorRT (FP16) | 41.1 | 0.5266 | 2.70 |
| YOLO26m | TensorRT (INT8) | 45.0 | 0.5156 | 2.74 |
La precisión y la velocidad se obtienen mediante la validación en COCO val2017 (5000 imágenes) con un tamaño de imagen de 640 y un tamaño de lote de 1. Los motores INT8 se calibran con COCO128. Pruebas de rendimiento realizadas con Ultralytics 8.4.192 en ultralytics/ultralytics:latest-nvidia-arm64 (NVIDIA PyTorch 26.08, TensorRT 11.2.1.2, ModelOpt 0.45.0).
Prácticas recomendadas para NVIDIA DGX Spark#
Cuando uses NVIDIA DGX Spark, sigue estas prácticas recomendadas para obtener el mejor rendimiento al ejecutar YOLO26.
-
Supervisa el rendimiento del sistema
Usa las herramientas de supervisión de NVIDIA para controlar el uso de GPU y CPU:
nvidia-smi -
Optimiza el uso de memoria
Con 128 GB de memoria unificada, DGX Spark puede manejar tamaños de lote y modelos grandes. Plantéate 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) -
Usa TensorRT FP16
Con un tamaño de lote de 1 en DGX Spark, INT8 es más lento que FP16 para YOLO26n y YOLO26s, no es más rápido para YOLO26m y ofrece menos precisión (consulta Precisión de YOLO26 con TensorRT en DGX Spark):
yolo export model=yolo26n.pt format=engine quantize=16 # FP16
Actualizaciones del sistema (Founders Edition)#
Mantener DGX Spark Founders Edition actualizado es fundamental 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 panel de control de DGX es la forma recomendada de realizar actualizaciones del sistema y garantizar la compatibilidad. Te permite:
- Ver las actualizaciones del sistema disponibles
- Instalar parches de seguridad y actualizaciones del sistema
- Gestionar las actualizaciones de los controladores y el firmware de NVIDIA
Actualizaciones manuales del sistema#
Los usuarios avanzados pueden realizar las actualizaciones manualmente desde el terminal:
sudo apt update
sudo apt dist-upgrade
sudo fwupdmgr refresh
sudo fwupdmgr upgrade
sudo rebootAntes de realizar actualizaciones, asegúrate de que el sistema está conectado a una fuente de alimentación estable y de haber hecho una copia de seguridad de los datos importantes.
Próximos pasos#
Para obtener más información y ayuda, consulta la documentación de Ultralytics YOLO26.
Preguntas frecuentes#
Implementar Ultralytics YOLO26 en NVIDIA DGX Spark es sencillo. Puedes usar la imagen Docker prediseñada para configurarlo rápidamente o instalar manualmente los paquetes necesarios. Encontrarás instrucciones detalladas para cada opción en las secciones Inicio rápido con Docker e Inicio con instalación nativa.
Los modelos YOLO se ejecutan rápidamente en DGX Spark gracias al superchip GB10 Grace Blackwell. El formato TensorRT ofrece el mejor rendimiento de inferencia. Consulta la sección Tabla comparativa detallada para ver los resultados de las pruebas de rendimiento de YOLO11 en DGX Spark con distintos tamaños y formatos de modelo, y la sección Precisión de YOLO26 con TensorRT en DGX Spark para ver los resultados de YOLO26 FP16 e INT8.
Se recomienda TensorRT para implementar modelos YOLO26 en DGX Spark, ya que ofrece la inferencia más rápida de los formatos de exportación compatibles y aprovecha los Tensor Cores de la GPU Blackwell con precisión FP16 o INT8.
DGX Spark ofrece hasta 1 PFLOP de rendimiento de IA y 128 GB de memoria unificada, frente a los 2070 TFLOPS y los 128 GB de memoria de Jetson AGX Thor. DGX Spark está diseñado como un superordenador de sobremesa con IA, mientras que los dispositivos Jetson son sistemas integrados optimizados para implementaciones en el borde.
Para las cargas de trabajo de PyTorch,
ultralytics/ultralytics:latest-nvidia-arm64es compatible con DGX Spark con DGX OS y con Thor con JetPack 7.1. El TensorRT 11.4 incluido no es compatible con JetPack, por lo que los flujos de trabajo de TensorRT en Jetson deben utilizar el runtime TensorRT 10.x compatible con su versión de JetPack. Consulta los requisitos de Docker para Jetson.
Comentarios
Haz una pregunta, comparte tus resultados o ayuda a otra persona.
