Guia de início rápido: NVIDIA DGX Spark com Ultralytics YOLO26#

Este guia abrangente apresenta instruções detalhadas para implementar Ultralytics YOLO26 no NVIDIA DGX Spark, o supercomputador de IA de mesa compacto da NVIDIA. Também apresenta benchmarks de desempenho para demonstrar os recursos do YOLO26 neste sistema potente.

O que é NVIDIA DGX Spark?#

NVIDIA DGX Spark é um supercomputador de IA de mesa compacto, equipado com o superchip NVIDIA GB10 Grace Blackwell. Oferece até 1 petaFLOP de desempenho de computação de IA com precisão FP4, sendo ideal para desenvolvedores, investigadores e cientistas de dados que precisam de recursos poderosos de IA num formato de computador de mesa.

Especificações principais#

DGX OS#

O NVIDIA DGX OS é uma distribuição Linux personalizada que oferece uma base de sistema operacional estável, testada e com suporte para executar aplicações de IA, aprendizado de máquina e análise em sistemas DGX. Ele inclui:

• Uma base Linux robusta e otimizada para cargas de trabalho de IA
• Drivers e configurações do sistema pré-configurados para hardware NVIDIA
• Atualizações de segurança e recursos de manutenção do sistema
• Compatibilidade com o ecossistema de software NVIDIA mais amplo

O DGX OS segue um cronograma regular de lançamentos, com atualizações normalmente fornecidas duas vezes por ano (por volta de fevereiro e agosto) e patches de segurança adicionais entre os principais lançamentos.

Painel DGX#

O DGX Spark vem com um Painel DGX integrado que oferece:

• Monitoramento do sistema em tempo real: visão geral das métricas operacionais atuais do sistema
• Atualizações do sistema: possibilidade de aplicar atualizações diretamente no painel
• Configurações do sistema: alteração do nome do dispositivo e de outras configurações
• JupyterLab integrado: acesso a Jupyter Notebooks locais para desenvolvimento

Acessar o painel#

Início rápido com Docker#

A maneira mais rápida de começar a usar o Ultralytics YOLO26 no NVIDIA DGX Spark é executar imagens Docker pré-criadas. A imagem NVIDIA ARM64 é compatível com o DGX Spark com DGX OS.

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

A solicitação de dispositivo CDI acima se aplica ao DGX Spark executando DGX OS. Para cargas de trabalho PyTorch no Jetson AGX Thor, consulte os requisitos de host separados e a restrição do TensorRT no guia NVIDIA Jetson.

Esta imagem usa NVIDIA PyTorch 26.08, CUDA 13.4 e TensorRT 11.2. Atualize o driver do host DGX OS para uma versão compatível com NVIDIA PyTorch 26.08 e recrie os mecanismos TensorRT depois de alterar a imagem ou a GPU de destino.

Depois disso, avance para a seção Usar TensorRT no NVIDIA DGX Spark.

Começar com a instalação nativa#

Para uma instalação nativa sem Docker, siga estas etapas.

Instalar o pacote Ultralytics#

Aqui, vamos instalar o pacote Ultralytics no DGX Spark. As dependências de exportação são instaladas automaticamente na primeira vez que você exporta um modelo, então basta instalar o pacote básico aqui. Vamos nos concentrar principalmente nas exportações NVIDIA TensorRT, pois o TensorRT garante que possamos obter o máximo desempenho do DGX Spark.

1. Atualizar a lista de pacotes, instalar o pip e atualizá-lo para a versão mais recente

   sudo apt update
   sudo apt install python3-pip -y
   pip install -U pip

2. Instalar o pacote pip ultralytics

   pip install ultralytics

3. Reiniciar o dispositivo

   sudo reboot

Instalar o PyTorch e o Torchvision#

A instalação do ultralytics acima instalará Torch e Torchvision. No entanto, esses pacotes instalados via pip podem não estar totalmente otimizados para a arquitetura ARM64 do DGX Spark com CUDA 13. Por isso, recomendamos instalar as versões compatíveis com CUDA 13:

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

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)

Instalar onnxruntime-gpu#

As versões atuais do ONNX Runtime GPU fornecem wheels Linux ARM64, incluindo para Python 3.12. A imagem Docker NVIDIA ARM64 instala o pacote oficial; para instalações nativas com CUDA 13, use:

pip install onnxruntime-gpu

Usar TensorRT no NVIDIA DGX Spark#

Entre todos os formatos de exportação de modelos compatíveis com Ultralytics, o TensorRT oferece o maior desempenho de inferência no NVIDIA DGX Spark, sendo nossa principal recomendação para implantações. Para instruções de configuração e uso avançado, consulte nosso guia dedicado à integração com TensorRT.

Converter o modelo para TensorRT e executar a inferência#

O modelo YOLO26n no formato PyTorch é convertido para TensorRT para executar a inferência com o modelo exportado.

from ultralytics import YOLO

# Carregar um modelo YOLO26n PyTorch
model = YOLO("yolo26n.pt")

# Exportar o modelo para TensorRT
model.export(format="engine")  # cria 'yolo26n.engine'

# Carregar o modelo TensorRT exportado
trt_model = YOLO("yolo26n.engine")

# Executar inferência
results = trt_model("https://ultralytics.com/images/bus.jpg")

Benchmarks do NVIDIA DGX Spark com YOLO11#

A equipe Ultralytics executou benchmarks do YOLO11 em vários formatos de modelo, medindo velocidade e precisão: PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN, ExecuTorch. Os benchmarks foram executados no NVIDIA DGX Spark com precisão FP32 e tamanho de imagem de entrada padrão de 640.

Tabela comparativa detalhada#

A tabela abaixo apresenta os resultados dos benchmarks de cinco modelos diferentes (YOLO11n, YOLO11s, YOLO11m, YOLO11l, YOLO11x) em vários formatos, mostrando o status, o tamanho, a métrica mAP50-95(B) e o tempo de inferência de cada combinação.

Reproduza nossos resultados#

Para reproduzir os benchmarks da Ultralytics acima em todos os formatos de exportação, execute este código:

from ultralytics import YOLO

# Carregar um modelo YOLO26n PyTorch
model = YOLO("yolo26n.pt")

# Benchmarke a velocidade e a precisão do YOLO26n no conjunto de dados COCO128 para todos os formatos de exportação
results = model.benchmark(data="coco128.yaml", imgsz=640)

Práticas recomendadas para o NVIDIA DGX Spark#

Ao usar o NVIDIA DGX Spark, siga algumas práticas recomendadas para obter o máximo desempenho ao executar o YOLO26.

1. Monitorar o desempenho do sistema

   Use as ferramentas de monitoramento da NVIDIA para acompanhar a utilização da GPU e da CPU:

   nvidia-smi

2. Otimizar o uso de memória

   Com 128 GB de memória unificada, o DGX Spark pode lidar com grandes tamanhos de lote e modelos. Considere aumentar o tamanho do lote para melhorar a taxa de transferência:

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

3. Usar TensorRT com FP16 ou INT8

   Para obter o melhor desempenho, exporte os modelos com precisão FP16 ou INT8:

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

Atualizações do sistema (Founders Edition)#

Manter o DGX Spark Founders Edition atualizado é fundamental para o desempenho e a segurança. A NVIDIA oferece dois métodos principais para atualizar o sistema operacional, os drivers e o firmware do sistema.

Usar o Painel DGX (recomendado)#

O Painel DGX é a forma recomendada de realizar atualizações do sistema, garantindo a compatibilidade. Ele permite:

• Ver as atualizações de sistema disponíveis
• Instalar patches de segurança e atualizações do sistema
• Gerenciar atualizações de drivers e firmware da NVIDIA

Atualizações manuais do sistema#

Usuários avançados podem realizar atualizações manualmente pelo terminal:

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

Próximas etapas#

Para saber mais e obter suporte, consulte a documentação do Ultralytics YOLO26.

Perguntas frequentes#