Guia de início rápido: NVIDIA DGX Spark com Ultralytics YOLO26
Este guia explica como implementar o Ultralytics YOLO26 no NVIDIA DGX Spark, o supercomputador de IA compacto para desktop da NVIDIA, e inclui benchmarks do YOLO11 em vários formatos de exportação nesse sistema.
Este guia foi testado na NVIDIA DGX Spark Founders Edition com DGX OS baseado em Ubuntu. Espera-se que funcione com as versões mais recentes do DGX OS.
O que é NVIDIA DGX Spark?#
O NVIDIA DGX Spark é um supercomputador de IA compacto para desktop, equipado com o NVIDIA GB10 Grace Blackwell Superchip. Oferece até 1 petaFLOP de desempenho de computação de IA com precisão FP4 e foi projetado para programadores, investigadores e cientistas de dados que precisam de recursos poderosos de IA num formato de desktop.
Assiste: Como atingir até 1000 FPS com o Ultralytics YOLO26 no NVIDIA DGX Spark | TensorRT e inferência em lote
Especificações principais#
| Especificação | Detalhes |
|---|---|
| Desempenho de IA | Até 1 PFLOP (FP4) |
| GPU | Arquitetura NVIDIA Blackwell com Tensor Cores de 5.ª geração e RT Cores de 4.ª geração |
| CPU | Processador Arm de 20 núcleos (10 Cortex-X925 + 10 Cortex-A725) |
| Memória | 128 GB de memória unificada do sistema LPDDR5x, interface de 256 bits, 4266 MHz, largura de banda de 273 GB/s |
| Armazenamento | NVMe M.2 de 1 TB ou 4 TB com criptografia automática |
| Rede | 1x RJ-45 (10 GbE), ConnectX-7 Smart NIC, Wi-Fi 7, Bluetooth 5.4 |
| Conectividade | 4x USB Type-C, 1x HDMI 2.1a, áudio multicanal HDMI |
| Processamento de vídeo | 1x NVENC, 1x NVDEC |
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#
Clique no botão "Show Apps" no canto inferior esquerdo da área de trabalho do Ubuntu e selecione "DGX Dashboard" para abri-lo no navegador.
O painel inclui uma instância integrada do JupyterLab que cria automaticamente um ambiente virtual e instala os pacotes recomendados quando é iniciada. Cada conta de usuário recebe uma porta dedicada para acessar o JupyterLab.
Início rápido com Docker#
A forma mais rápida de começar a usar o Ultralytics YOLO26 no NVIDIA DGX Spark é executar as imagens Docker pré-compiladas. A imagem ARM64 da NVIDIA é 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 $tA 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.10, CUDA 13.4 e TensorRT 11.4. Atualiza o driver do host DGX OS para uma versão compatível com NVIDIA PyTorch 26.10 e reconstrói os engines TensorRT após alterar a imagem ou a GPU de destino.
Depois de concluíres esta etapa, avança para 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 exportas um modelo, por isso só precisas do pacote base neste caso. Este guia concentra-se nas exportações NVIDIA TensorRT, pois o TensorRT oferece o melhor desempenho no DGX Spark.
-
Atualiza a lista de pacotes, instala o pip e atualiza-o para a versão mais recente.
sudo apt update sudo apt install python3-pip -y pip install -U pip -
Instalar o pacote pip
ultralyticspip install ultralytics -
Reiniciar o dispositivo
sudo reboot
Instalar o PyTorch e o Torchvision#
A instalação de ultralytics acima instala o PyTorch e o Torchvision. No entanto, estes 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/cu130Ao executar PyTorch 2.9.1 no NVIDIA DGX Spark, você pode encontrar o seguinte UserWarning ao inicializar o CUDA (por exemplo, ao executar 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)Você pode ignorar este aviso com segurança.
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-gpuUsar TensorRT no NVIDIA DGX Spark#
Entre todos os formatos de exportação de modelos compatíveis com o Ultralytics, o TensorRT oferece o melhor desempenho de inferência no NVIDIA DGX Spark, sendo a nossa principal recomendação para implementações.
Converter o modelo para TensorRT e executar a inferência#
O modelo YOLO26n PyTorch é convertido para TensorRT e, em seguida, o modelo exportado é usado para inferência.
from ultralytics import YOLO
# Carregar um modelo YOLO26n PyTorch
model = YOLO("yolo26n.pt")
# Exporta o modelo para TensorRT FP16
model.export(format="engine", quantize=16) # 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 equipa do 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, em precisão FP32 e com o tamanho de imagem de entrada padrão de 640.
Tabela comparativa detalhada#
A tabela abaixo apresenta os resultados do benchmark de cinco modelos diferentes (YOLO11n, YOLO11s, YOLO11m, YOLO11l, YOLO11x) em vários formatos, indicando o estado, o tamanho, a métrica mAP50-95(B) e o tempo de inferência de cada combinação.
| Formato | Status | Tamanho em disco (MB) | mAP50-95(B) | Tempo de inferência (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 |
Benchmark executado com Ultralytics 8.3.249
Reproduza nossos resultados#
Para reproduzir os benchmarks do Ultralytics acima em todos os formatos de exportação, executa 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)Observe que os resultados do benchmark podem variar conforme a configuração exata de hardware e software de um sistema, bem como a carga de trabalho atual do sistema no momento da execução dos benchmarks. Para obter resultados mais confiáveis, use um conjunto de dados com um grande número de imagens, por exemplo, data='coco.yaml' (5000 imagens de validação).
Precisão do YOLO26 com TensorRT no DGX Spark#
Com tamanho de lote 1 no DGX Spark, o TensorRT INT8 é mais lento que o FP16 para YOLO26n e YOLO26s, e tem desempenho praticamente igual para YOLO26m (diferença de até 2% tanto no tempo de validação quanto no tempo de computação na GPU em trtexec). O INT8 também perde de 1,1 a 1,8 mAP, então o FP16 é a melhor opção para esses modelos. A tabela do YOLO11 acima mostra o mesmo padrão: o TensorRT (INT8) é mais lento que o TensorRT (FP16) nos cinco modelos.
| Modelo | Formato | Tamanho em disco (MB) | mAP50-95(B) | Tempo de inferência (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 |
A precisão e a velocidade são obtidas por meio da validação no COCO val2017 (5000 imagens), com tamanho de imagem 640 e tamanho de lote 1. Os mecanismos INT8 são calibrados no COCO128. Benchmark realizado com Ultralytics 8.4.192 em ultralytics/ultralytics:latest-nvidia-arm64 (NVIDIA PyTorch 26.08, TensorRT 11.2.1.2, ModelOpt 0.45.0).
Práticas recomendadas para o NVIDIA DGX Spark#
Ao usar o NVIDIA DGX Spark, segue estas práticas recomendadas para obter o melhor desempenho ao executar o YOLO26.
-
Monitorar o desempenho do sistema
Use as ferramentas de monitoramento da NVIDIA para acompanhar a utilização da GPU e da CPU:
nvidia-smi -
Otimizar o uso de memória
Com 128 GB de memória unificada, o DGX Spark consegue lidar com tamanhos de lote e modelos grandes. Considera 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) -
Usa TensorRT FP16
Com tamanho de lote 1 no DGX Spark, o INT8 é mais lento que o FP16 para YOLO26n e YOLO26s, não é mais rápido para YOLO26m e tem menor precisão (consulte Precisão do YOLO26 com TensorRT no DGX Spark):
yolo export model=yolo26n.pt format=engine quantize=16 # FP16
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 rebootVerifique se o sistema está conectado a uma fonte de alimentação estável e se você fez backup dos dados essenciais antes de realizar as atualizações.
Próximas etapas#
Para saber mais e obter suporte, consulte a documentação do Ultralytics YOLO26.
Perguntas frequentes#
Implantar o Ultralytics YOLO26 no NVIDIA DGX Spark é simples. Você pode usar a imagem Docker pré-criada para uma configuração rápida ou instalar manualmente os pacotes necessários. As etapas detalhadas de cada abordagem estão nas seções Início rápido com Docker e Começar com a instalação nativa.
Os modelos YOLO rodam rapidamente no DGX Spark graças ao superchip GB10 Grace Blackwell. O formato TensorRT oferece o melhor desempenho de inferência. Confira a seção Tabela de comparação detalhada para ver os resultados de benchmark do YOLO11 no DGX Spark com diferentes tamanhos de modelo e formatos, e a seção Precisão do YOLO26 com TensorRT no DGX Spark para ver os resultados de YOLO26 em FP16 e INT8.
O TensorRT é recomendado para implantar modelos YOLO26 no DGX Spark porque oferece a inferência mais rápida entre os formatos de exportação compatíveis, usando os Tensor Cores da GPU Blackwell com precisão FP16 ou INT8.
O DGX Spark oferece até 1 PFLOP de desempenho de IA e 128 GB de memória unificada, em comparação com os 2070 TFLOPS e 128 GB de memória do Jetson AGX Thor. O DGX Spark foi projetado como um supercomputador de IA para desktop, enquanto os dispositivos Jetson são sistemas embarcados otimizados para implementação na borda.
Para cargas de trabalho PyTorch,
ultralytics/ultralytics:latest-nvidia-arm64é compatível com o DGX Spark com DGX OS e com o Thor com JetPack 7.1. O TensorRT 11.4 incluído não é compatível com o JetPack, por isso os fluxos de trabalho TensorRT no Jetson têm de usar o runtime TensorRT 10.x compatível com a respetiva versão do JetPack. Consulta os requisitos do Docker para Jetson.
Comentários
Faz uma pergunta, partilha os teus resultados ou ajuda alguém.
