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

Este guia abrangente fornece um passo a passo detalhado para implementar o Ultralytics YOLO26 no NVIDIA DGX Spark, o supercomputador compacto de IA para desktop da NVIDIA. Além disso, apresenta benchmarks de desempenho para demonstrar as capacidades do YOLO26 neste poderoso sistema.

O que é o NVIDIA DGX Spark?#

O NVIDIA DGX Spark é um supercomputador compacto de IA para desktop equipado com o NVIDIA GB10 Grace Blackwell Superchip. Ele oferece até 1 petaFLOP de desempenho computacional de IA com precisão FP4, sendo ideal para desenvolvedores, investigadores e cientistas de dados que precisam de capacidades avançadas de IA num formato de desktop.

Especificações principais#

DGX OS#

O NVIDIA DGX OS é uma distribuição Linux personalizada que fornece uma base de sistema operativo estável, testada e suportada para executar aplicações de IA, aprendizagem automática e análise em sistemas DGX. Inclui:

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

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

DGX Dashboard#

O DGX Spark inclui um DGX Dashboard integrado que fornece:

• Monitorização 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 a partir do dashboard
• Definições do sistema: alterar o nome do dispositivo e outras configurações
• JupyterLab integrado: acesso a Jupyter Notebooks locais para desenvolvimento

Aceder ao Dashboard#

Início rápido com Docker#

A maneira mais rápida de começar com o Ultralytics YOLO26 no NVIDIA DGX Spark é executar com imagens Docker pré-construídas. A imagem NVIDIA ARM64 suporta o DGX Spark com o 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 aplica-se ao DGX Spark executando o DGX OS. Para cargas de trabalho de PyTorch no Jetson AGX Thor, consulta os requisitos de host separados e a restrição de TensorRT no guia da NVIDIA para Jetson.

Esta imagem usa NVIDIA PyTorch 26.08, CUDA 13.4 e TensorRT 11. Atualiza o driver de host do DGX OS para uma versão suportada pelo NVIDIA PyTorch 26.08 e reconstrói os motores do TensorRT após alterar a imagem ou a GPU de destino.

Depois de concluíres esta etapa, avança para a secção Utilizar TensorRT no NVIDIA DGX Spark.

Começar com a instalação nativa#

Para uma instalação nativa sem Docker, segue estes passos.

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 exportas um modelo, pelo que aqui só é necessário o pacote base. Vamos concentrar-nos principalmente nas exportações NVIDIA TensorRT, porque o TensorRT garante que conseguimos obter o máximo desempenho do DGX Spark.

1. Atualizar a lista de pacotes, instalar o pip e atualizar 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 PyTorch e Torchvision#

A instalação do ultralytics acima instalará Torch e Torchvision. No entanto, estes pacotes instalados através do 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#

Os lançamentos atuais do ONNX Runtime GPU fornecem pacotes wheel para Linux ARM64, incluindo Python 3.12. A imagem Docker da NVIDIA ARM64 instala o pacote oficial; para instalações nativas de CUDA 13, usa:

pip install onnxruntime-gpu

Utilizar TensorRT no NVIDIA DGX Spark#

Entre todos os formatos de exportação de modelos suportados pelo Ultralytics, o TensorRT oferece o maior desempenho de inferência no NVIDIA DGX Spark, sendo a nossa principal recomendação para implementações. Para obter instruções de configuração e utilização avançada, consulta o nosso guia dedicado de integração do TensorRT.

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

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

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")

Benchmarks do YOLO11 no NVIDIA DGX Spark#

A equipa da Ultralytics executou benchmarks do YOLO11 em vários formatos de modelo, medindo a velocidade e a 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 um tamanho de imagem de entrada predefinido de 640.

Tabela de comparação detalhada#

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

Reproduzir os nossos resultados#

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

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)

Práticas recomendadas para o NVIDIA DGX Spark#

Ao utilizar o NVIDIA DGX Spark, há algumas práticas recomendadas que deves seguir para obter o máximo desempenho ao executar o YOLO26.

1. Monitorizar o desempenho do sistema

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

   nvidia-smi

2. Otimizar a utilização da memória

   Com 128 GB de memória unificada, o DGX Spark consegue lidar com tamanhos de batch e modelos grandes. Considera aumentar o tamanho do batch para melhorar o débito:

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

3. Utilizar TensorRT com FP16 ou INT8

   Para obter o melhor desempenho, exporta 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 é essencial para o desempenho e a segurança. A NVIDIA fornece dois métodos principais para atualizar o sistema operativo, os controladores e o firmware.

Utilizar o DGX Dashboard (recomendado)#

O DGX Dashboard é a forma recomendada de realizar atualizações do sistema, garantindo a compatibilidade. Permite-te:

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

Atualizações manuais do sistema#

Para utilizadores avançados, as atualizações podem ser realizadas manualmente através do terminal:

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

Próximas etapas#

Para obter mais informações e suporte, consulta a documentação do Ultralytics YOLO26.

Perguntas frequentes#