Guia de Início Rápido: NVIDIA DGX Spark com Ultralytics YOLO26#

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

O que é o NVIDIA DGX Spark?#

O NVIDIA DGX Spark é um supercomputador de IA de desktop compacto equipado com o superchip NVIDIA GB10 Grace Blackwell. Ele oferece até 1 petaFLOP de desempenho de computação de IA com precisão FP4, tornando-o ideal para desenvolvedores, pesquisadores e cientistas de dados que precisam de recursos poderosos de IA em um formato de desktop.

Principais Especificações#

DGX OS#

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

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

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

DGX Dashboard#

O DGX Spark vem com um DGX Dashboard integrado que fornece:

• Monitoramento de Sistema em Tempo Real: Visão geral das métricas operacionais atuais do sistema
• Atualizações do Sistema: Capacidade de aplicar atualizações diretamente pelo painel
• Configurações do Sistema: Alterar nome do dispositivo e outras configurações
• JupyterLab Integrado: Acesse Jupyter Notebooks locais para desenvolvimento

Acessando o 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 mesma imagem Docker que suporta Jetson AGX Thor (JetPack 7.0) funciona no 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 o DGX OS. No Jetson AGX Thor, inicie a mesma imagem com --runtime=nvidia em vez disso, conforme mostrado no guia do NVIDIA Jetson.

Após concluir isso, pule para a seção Usar o TensorRT no NVIDIA DGX Spark.

Começar com Instalação Nativa#

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

Instalar o Pacote Ultralytics#

Aqui, instalaremos o pacote Ultralytics no DGX Spark com dependências opcionais para que possamos exportar os modelos PyTorch para outros formatos diferentes. Focaremos principalmente nas exportações do NVIDIA TensorRT, pois o TensorRT garantirá que possamos obter o máximo desempenho do DGX Spark.

1. Atualize a lista de pacotes, instale o pip e atualize 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 com dependências opcionais

   pip install ultralytics[export]

3. Reinicie o dispositivo

   sudo reboot

Instalar PyTorch e Torchvision#

A instalação do ultralytics acima instalará o Torch e o Torchvision. No entanto, esses pacotes instalados via pip podem não estar totalmente otimizados para a arquitetura ARM64 do DGX Spark com CUDA 13. Portanto, 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#

O pacote onnxruntime-gpu hospedado no PyPI não possui binários aarch64 para sistemas ARM64. Portanto, precisamos instalar este pacote manualmente. Este pacote é necessário para algumas das exportações.

Aqui, baixaremos e instalaremos onnxruntime-gpu 1.24.0 com suporte a Python3.12.

pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.24.0-cp312-cp312-linux_aarch64.whl

Usar 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, tornando-se nossa principal recomendação para implantações. Para instruções de configuração e uso avançado, consulte nosso guia de integração dedicado do TensorRT.

Converta o modelo para TensorRT e execute 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#

Os benchmarks do YOLO11 foram executados pela equipe do Ultralytics 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 na precisão FP32 com o tamanho de imagem de entrada padrão de 640.

Tabela de comparação detalhada#

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

Reproduza os Nossos Resultados#

Para reproduzir os benchmarks da Ultralytics acima em todos os formatos de exportação, execute 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)

Melhores práticas para o NVIDIA DGX Spark#

Ao usar o NVIDIA DGX Spark, existem algumas melhores práticas a seguir para permitir o desempenho máximo ao executar o YOLO26.

1. Monitore o desempenho do sistema

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

   nvidia-smi

2. Otimize o uso de memória

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

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

3. Use TensorRT com FP16 ou INT8

   Para obter o melhor desempenho, exporte 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 de sistema (Founders Edition)#

Manter o seu DGX Spark Founders Edition atualizado é crucial para o desempenho e a segurança. A NVIDIA fornece dois métodos principais para atualizar o SO do sistema, drivers e firmware.

Usando o DGX Dashboard (Recomendado)#

O DGX Dashboard é a maneira recomendada de realizar atualizações de sistema, garantindo compatibilidade. Ele permite que você:

• Visualize atualizações de sistema disponíveis
• Instale patches de segurança e atualizações de sistema
• Gerencie atualizações de driver e firmware da NVIDIA

Atualizações manuais de sistema#

Para usuários avançados, as atualizações podem ser realizadas manualmente via terminal:

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

Próximos Passos#

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

FAQ#