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

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

O que é o NVIDIA DGX Spark?

O NVIDIA DGX Spark é um supercomputador de IA de mesa compacto, alimentado pelo 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 poderosas capacidades de IA em um formato de mesa.

Especificações Chave

DGX OS

NVIDIA DGX OS é uma distribuição Linux personalizada que fornece uma base de sistema operacional estável, testada e suportada para executar aplicações de IA, aprendizado de máquina e análise em sistemas DGX. 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 recursos de manutenção do sistema
• Compatibilidade com o ecossistema de software NVIDIA mais amplo

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

Painel DGX

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

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

Acessando o Painel

# Open an SSH tunnel
ssh -L 11000:localhost:11000 username@spark-abcd.local

# Then open in browser
# http://localhost:11000

Início Rápido com Docker

A maneira mais rápida de começar com 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 --runtime=nvidia --gpus all $t

Após concluir esta etapa, prossiga para a seção Usar TensorRT no NVIDIA DGX Spark.

Comece com a Instalação Nativa

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

Instalar Pacote Ultralytics

Aqui, instalaremos o pacote Ultralytics no DGX Spark com dependências opcionais para que possamos exportar os modelos PyTorch para outros formatos. Nos concentraremos principalmente nas exportações NVIDIA TensorRT, pois o TensorRT garantirá 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 ultralytics pacote pip com dependências opcionais

   pip install ultralytics[export]
   

3. Reinicie o dispositivo

   sudo reboot
   

Instalar PyTorch e Torchvision

A instalação Ultralytics mencionada 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 onnxruntime-gpu pacote hospedado no PyPI não tem aarch64 binários para sistemas ARM64. Portanto, precisamos instalar este pacote manualmente. Este pacote é necessário para algumas das exportações.

Aqui vamos baixar e instalar onnxruntime-gpu 1.24.0 com Python3.12 suporte.

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 modelo suportados pela Ultralytics, o TensorRT oferece o maior desempenho de inferência no NVIDIA DGX Spark, tornando-o nossa principal recomendação para implantações. Para instruções de configuração e uso avançado, consulte nosso guia dedicado de integração do TensorRT.

Converter Modelo para TensorRT e Executar Inferência

O modelo YOLO26n no formato PyTorch é convertido para TensorRT para executar 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")

# 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'

Benchmarks do NVIDIA DGX Spark YOLO11

Os benchmarks do YOLO11 foram executados pela equipe 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 com precisão FP32 e tamanho de imagem de entrada padrão 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, fornecendo o status, tamanho, métrica mAP50-95(B) e tempo de inferência para cada combinação.

Reproduzir Nossos Resultados

Para reproduzir os benchmarks 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)

# Benchmark YOLO26n speed and accuracy on the COCO128 dataset for all export formats
yolo benchmark model=yolo26n.pt data=coco128.yaml imgsz=640

Melhores Práticas para o NVIDIA DGX Spark

Ao usar o NVIDIA DGX Spark, há algumas boas práticas a seguir para permitir o desempenho máximo na execução do YOLO26.

1. Monitorar o Desempenho do Sistema

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

   nvidia-smi
   

2. Otimizar o Uso da 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 throughput:

   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 o melhor desempenho, exporte modelos com precisão FP16 ou INT8:

   yolo export model=yolo26n.pt format=engine half=True # FP16
   yolo export model=yolo26n.pt format=engine int8=True # INT8
   

Atualizações do Sistema (Founders Edition)

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

Usando o Painel DGX (Recomendado)

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

• Visualizar atualizações de sistema disponíveis
• Instalar patches de segurança e atualizações de sistema
• Gerenciar atualizações de driver e firmware da NVIDIA

Atualizações Manuais do 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

Como faço para implantar Ultralytics YOLO26 no NVIDIA DGX Spark?

A implantação de Ultralytics YOLO26 no NVIDIA DGX Spark é simples. Você pode usar a imagem Docker pré-construída para uma configuração rápida ou instalar manualmente os pacotes necessários. Etapas detalhadas para cada abordagem podem ser encontradas nas seções Início Rápido com Docker e Início com Instalação Nativa.

Que desempenho posso esperar do YOLO26 no NVIDIA DGX Spark?

Os modelos YOLO26 oferecem excelente desempenho no DGX Spark graças ao Superchip GB10 Grace Blackwell. O formato TensorRT proporciona o melhor desempenho de inferência. Consulte a seção Tabela de Comparação Detalhada para resultados de benchmark específicos em diferentes tamanhos e formatos de modelo.

Por que devo usar TensorRT para YOLO26 no DGX Spark?

O TensorRT é altamente recomendado para a implantação de modelos YOLO26 no DGX Spark devido ao seu desempenho ideal. Ele acelera a inferência ao aproveitar os recursos da GPU Blackwell, garantindo máxima eficiência e velocidade. Saiba mais na seção Usar TensorRT no NVIDIA DGX Spark.

Como o DGX Spark se compara aos dispositivos Jetson para YOLO26?

O DGX Spark oferece significativamente mais poder de computação do que os dispositivos Jetson, com até 1 PFLOP de desempenho de IA e 128GB de memória unificada, em comparação com os 2070 TFLOPS e 128GB de memória do Jetson AGX Thor. O DGX Spark é projetado como um supercomputador de IA de mesa, enquanto os dispositivos Jetson são sistemas embarcados otimizados para implantação em borda.

Posso usar a mesma imagem Docker para o DGX Spark e o Jetson AGX Thor?

Sim! A ultralytics/ultralytics:latest-nvidia-arm64 imagem Docker suporta tanto o NVIDIA DGX Spark (com DGX OS) quanto o Jetson AGX Thor (com JetPack 7.0), pois ambos utilizam arquitetura ARM64 com CUDA 13 e pilhas de software semelhantes.

📅 Criado há 21 dias ✏️ Atualizado há 9 dias

Comentários