Guia de início rápido: NVIDIA Spark com Ultralytics YOLO11

Este guia completo fornece instruções detalhadas para a implementação Ultralytics YOLO11 NVIDIA Spark, o supercomputador de IA compacto para desktop NVIDIA. Além disso, ele apresenta benchmarks de desempenho para demonstrar os recursos do YOLO11 poderoso sistema.

O que é NVIDIA Spark?

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

Especificações principais

Sistema operativo DGX

NVIDIA OS é uma distribuição Linux personalizada que fornece 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. Inclui:

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

O DGX OS segue um calendário de lançamentos 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 principais lançamentos.

Painel DGX

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

• Monitorização 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 a partir do painel de controlo
• Configurações do sistema: alterar o nome do dispositivo e outras configurações
• JupyterLab integrado: aceda aos Jupyter Notebooks locais para desenvolvimento

Aceder ao Painel de Controlo

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

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

Início Rápido com Docker

A maneira mais rápida de começar a usar Ultralytics YOLO11 NVIDIA Spark é executá-lo com imagens Docker pré-construídas. A mesma imagem Docker que suporta o Jetson AGX Thor (JetPack 7.0) funciona no DGX Spark com o DGX OS.

t=ultralytics/ultralytics:latest-nvidia-arm64
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia --gpus all $t

Depois de fazer isso, avance para a secção Usar TensorRT NVIDIA Spark.

Comece com a Instalação Nativa

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

Instalar Pacote Ultralytics

Aqui, instalaremos Ultralytics no DGX Spark com dependências opcionais para que possamos exportar o PyTorch para outros formatos diferentes. Vamos nos concentrar principalmente nas TensorRT NVIDIA TensorRT , pois TensorRT 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 ultralytics pacote pip com dependências opcionais

   pip install ultralytics[export]
   

3. Reinicie o dispositivo

   sudo reboot
   

Instalar PyTorch e Torchvision

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

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. Por isso, precisamos instalar manualmente este pacote. 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

Use o TensorRT NVIDIA Spark

Entre todos os formatos de exportação de modelos suportados pelo Ultralytics, TensorRT o melhor desempenho de inferência no NVIDIA Spark, tornando-o a nossa principal recomendação para implementações. Para obter instruções de configuração e uso avançado, consulte o nosso guia TensorRT dedicado TensorRT .

Converter Modelo para TensorRT e Executar Inferência

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

from ultralytics import YOLO

# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")

# Export the model to TensorRT
model.export(format="engine")  # creates 'yolo11n.engine'

# Load the exported TensorRT model
trt_model = YOLO("yolo11n.engine")

# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")

# Export a YOLO11n PyTorch model to TensorRT format
yolo export model=yolo11n.pt format=engine # creates 'yolo11n.engine'

# Run inference with the exported model
yolo predict model=yolo11n.engine source='https://ultralytics.com/images/bus.jpg'

YOLO11 NVIDIA Spark YOLO11

YOLO11 foram executados pela Ultralytics em vários formatos de modelo, medindo velocidade e precisão: PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF , MNN, NCNN, ExecuTorch. Os benchmarks foram executados no NVIDIA Spark com precisão FP32 e 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, fornecendo o status, tamanho, métrica mAP50(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 YOLO11n PyTorch model
model = YOLO("yolo11n.pt")

# Benchmark YOLO11n speed and accuracy on the COCO128 dataset for all export formats
results = model.benchmark(data="coco128.yaml", imgsz=640)

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

Melhores práticas para NVIDIA Spark

Ao utilizar NVIDIA Spark, existem algumas práticas recomendadas a seguir para permitir o máximo desempenho ao executar YOLO11.

1. Monitorizar o desempenho do sistema

   Use as ferramentas de monitoramento NVIDIA para track CPU GPU CPU :

   nvidia-smi
   

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

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

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

3. Use TensorRT FP16 ou INT8

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

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

Atualizações do sistema (Edição Fundadores)

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

Usando o DGX Dashboard (recomendado)

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

• Ver atualizações disponíveis do sistema
• Instale patches de segurança e atualizações do sistema
• Gerir atualizações de NVIDIA e firmware 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óximos Passos

Para mais informações e suporte, consulte a YOLO11 Ultralytics YOLO11 .

FAQ

Como posso implementar Ultralytics YOLO11 NVIDIA Spark?

A implementação Ultralytics YOLO11 NVIDIA Spark é simples. Pode usar a imagem Docker pré-construída para uma configuração rápida ou instalar manualmente os pacotes necessários. As etapas detalhadas para cada abordagem podem ser encontradas nas secções Início rápido com Docker e Início com instalação nativa.

Que desempenho posso esperar do YOLO11 NVIDIA Spark?

YOLO11 oferecem excelente desempenho no DGX Spark graças ao superchip GB10 Grace Blackwell. O TensorRT oferece o melhor desempenho de inferência. Consulte a secção Tabela comparativa detalhada para obter resultados específicos de benchmark em diferentes tamanhos e formatos de modelo.

Por que devo usar TensorRT YOLO11 DGX Spark?

TensorRT altamente recomendado para a implementação YOLO11 no DGX Spark devido ao seu desempenho ideal. Ele acelera a inferência aproveitando os GPU Blackwell, garantindo eficiência e velocidade máximas. Saiba mais na secção Usar TensorRT NVIDIA Spark.

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

O DGX Spark oferece significativamente mais poder de computação do que os dispositivos Jetson, com 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 incorporados otimizados para implementação de ponta.

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

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

📅 Criado há 0 dias ✏️ Atualizado há 0 dias

Comentários