Implementação AMD Xilinx para Ultralytics YOLO com Vitis AI#

Os dispositivos AMD Xilinx estão presentes em muitas câmaras industriais, sistemas de visão automóvel, robôs, drones e produtos de imagiologia médica em todo o mundo. Combinam processadores Arm com lógica programável e, nos dispositivos mais recentes, AI Engines dedicados, para que um único chip possa capturar vídeo, pré-processá-lo, executar deteção de objetos e agir com base no resultado com latência de inferência baixa e previsível.

Este guia explica o que é cada família de dispositivos AMD Xilinx, como a IA é executada nesses dispositivos, que operadores Ultralytics YOLO são suportados por cada acelerador e o fluxo de trabalho passo a passo para implementar modelos YOLO em hardware Zynq UltraScale+, Kria e Versal.

O que é AMD Xilinx?#

A Xilinx inventou a matriz de portas programável em campo (FPGA) na década de 1980 e tornou-se um fornecedor líder de SoCs adaptativos e FPGAs. A AMD concluiu a aquisição da Xilinx em fevereiro de 2022, e as linhas de produtos são agora comercializadas sob a marca AMD como AMD Zynq, AMD Kria, AMD Versal e AMD Vitis.

Termos e conceitos principais#

A implementação AMD Xilinx utiliza vocabulário próprio. A tabela abaixo explica todos os termos usados neste guia.

Famílias de dispositivos AMD Xilinx para IA de periferia#

Os dispositivos AMD Xilinx para IA de periferia dividem-se em três famílias. Zynq e Kria usam a DPU na lógica programável, enquanto os dispositivos Versal AI Edge aqui abordados usam a NPU nos seus AI Engines.

Zynq UltraScale+ MPSoC#

Cada chip Zynq UltraScale+ combina um sistema de processamento Arm, com núcleos Cortex-A53 de núcleo duplo (CG) ou quádruplo (EG e EV) e núcleos Cortex-R5F em tempo real, com lógica FPGA. Os dispositivos EV acrescentam um codec de vídeo H.264/H.265 dedicado. Para executar redes neuronais, os designers integram uma DPU na lógica, junto dos pipelines de câmara e vídeo. Em dispositivos pequenos, a DPU compete por espaço com o resto do design.

Módulos de sistema Kria#

O módulo Kria K26 integra um Zynq UltraScale+ MPSoC, memória e alimentação num módulo pronto para produção, para não precisares de conceber por conta própria o processador, a memória e o subsistema de alimentação. O módulo liga-se a uma placa transportadora, seja a placa de um kit inicial ou um design teu. Alimenta o KV260 Vision AI Starter Kit para câmaras inteligentes e o KR260 Robotics Starter Kit para robótica. Como o K26 é baseado em Zynq UltraScale+, usa o mesmo fluxo DPU. O portefólio Kria também inclui outros módulos, por isso verifica que processador o teu módulo utiliza antes de escolheres um fluxo.

SoCs adaptativos Versal#

Versal é a família de SoCs adaptativos da AMD. As séries AI Edge e AI Core incluem AI Engines dedicados junto dos núcleos Arm e da lógica programável, enquanto algumas outras séries Versal não têm AI Engines. O IP de NPU da AMD é executado em conjunto nos AI Engines e na lógica programável, e o Vitis AI destina-se aos componentes AIE-ML da série AI Edge, como o VE2302 e o VE2802. A Série Versal AI Edge (kit de avaliação VEK280) e a Série Versal AI Edge Gen 2 (kit de avaliação VEK385) são os destinos atuais da AMD para IA de periferia e o foco das versões atuais do Vitis AI.

Como a IA é executada em dispositivos AMD Xilinx: DPU vs NPU#

A maioria das implementações de IA AMD Xilinx segue o mesmo padrão. O acelerador executa as camadas que suporta, a CPU Arm executa o pré-processamento, o pós-processamento e quaisquer camadas que o acelerador não consiga executar, e um runtime na placa coordena ambos.

graph LR
    A[Camera / video input]:::start --> B[Arm CPU<br>Linux, preprocessing,<br>post-processing]:::proc
    B <--> C[AI accelerator<br>DPU in programmable logic<br>or NPU on AI Engines + PL]:::out
    B --> D[Application<br>alerts, control, display]:::start

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef out fill:#9C27B0,color:#fff

A AMD lançou duas gerações de aceleradores, cada uma com a sua própria cadeia de ferramentas e ficheiro de modelo compilado. Este guia aborda o Vitis AI 3.5 para a DPU e o Vitis AI 6.3 para a NPU; consulta a documentação atual da AMD para versões posteriores.

De qual fluxo do Vitis AI preciso?#

Escolhe o fluxo de acordo com o dispositivo da tua placa:

graph TD
    A[Start: which AMD device<br>is on your board?]:::start --> B{Device family?}:::decide
    B -->|Zynq UltraScale+ MPSoC<br>or Kria K26| C[DPU flow<br>Vitis AI 3.5]:::proc
    B -->|Versal AI Edge<br>VEK280| D[NPU snapshot flow<br>Vitis AI 6.3]:::proc
    B -->|Versal AI Edge Gen 2<br>VEK385| E[NPU Quark flow<br>Vitis AI 6.3]:::proc
    C --> F[Train YOLO with Hard-Swish<br>then compile to .xmodel]:::out
    D --> G[Run your model on calibration<br>images to capture a snapshot]:::out
    E --> H[Quantize ONNX with Quark<br>then compile to .rai]:::out

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef decide fill:#FF9800,color:#fff
    classDef out fill:#9C27B0,color:#fff

Compatibilidade de modelos YOLO e operadores compatíveis#

Um acelerador só acelera os operadores que implementa em hardware. Quando um modelo contém um operador sem suporte, o compilador geralmente envia essa parte da rede para a CPU Arm, e cada ida e volta entre o acelerador e a CPU acrescenta latência. Alguns operadores não podem ser particionados: na NPU Versal AI Edge Gen 2, a AMD lista operadores como NonZero e NonMaxSuppression, que podem forçar a execução do modelo inteiro na CPU. O suporte a operadores é o fator mais importante para o desempenho de um modelo YOLO no hardware AMD Xilinx.

graph LR
    subgraph S1 [Stock YOLO26 on the DPU]
        A1[Conv]:::out --> A2[SiLU<br>CPU]:::error --> A3[Conv]:::out --> A4[SiLU<br>CPU]:::error --> A5[...]:::proc
    end
    subgraph S2 [Hard-Swish YOLO26 on the DPU]
        B1[Backbone<br>Conv + Hard-Swish<br>DPU]:::out --> B2[C2PSA attention<br>CPU]:::error --> B3[Neck<br>DPU]:::out --> B4[C3k2 attention<br>CPU]:::error --> B5[Detect head<br>DPU]:::out --> B6[Sigmoid and<br>post-processing<br>CPU]:::error
    end

    classDef proc fill:#2196F3,color:#fff
    classDef out fill:#9C27B0,color:#fff
    classDef error fill:#F44336,color:#fff

A tabela mostra onde cada operador de um modelo YOLO26 é executado. Uma exportação ONNX padrão de YOLO26n contém 87 ativações SiLU, cada uma exportada como Sigmoid e Mul, além de 4 operadores MatMul e 2 Softmax provenientes dos dois blocos de atenção: o bloco C2PSA no fim do backbone (camada 10) e o bloco C3k2 com atenção ativada, que produz a saída P5 (camada 22).

Fontes: operadores compatíveis UG1414 da AMD, suporte a operadores do PyTorch e listas de operadores compatíveis, de partição na CPU e não compatíveis da Versal AI Edge Gen 2. O suporte também depende da configuração da DPU e dos padrões do grafo, então verifica sempre o relatório de particionamento do compilador.

Prepara o YOLO26 para DPU com Hard-Swish#

A DPU funde nas convoluções apenas ReLU, ReLU6, LeakyReLU, Hard-Swish e Hard-Sigmoid. Hard-Swish é uma aproximação de SiLU compatível com hardware, o que a torna a substituição natural. Os ficheiros YAML dos modelos Ultralytics aceitam uma chave activation que altera a ativação padrão dos blocos Conv (Guia de configuração YAML do modelo).

Copia yolo26.yaml para yolo26-hswish.yaml e adiciona uma linha sob os parâmetros:

# Parameters
nc: 80 # number of classes
activation: nn.Hardswish() # default Conv activation, DPU-native
end2end: True # whether to use end-to-end mode

Em seguida, cria o modelo, transfere os pesos YOLO26 pré-treinados e faz ajuste fino com o teu conjunto de dados:

from ultralytics import YOLO

# # Cria YOLO26n com ativações Hard-Swish; o 'n' no nome seleciona a escala nano
model = YOLO("yolo26n-hswish.yaml").load("yolo26n.pt")  # # transfere os pesos pré-treinados

# # Faz ajuste fino para adaptar a rede a Hard-Swish
model.train(data="coco8.yaml", epochs=100, imgsz=640)

As ativações não têm pesos, então todos os pesos pré-treinados são transferidos. O grafo ONNX exportado contém então 87 operadores HardSwish e nenhum SiLU. Substitui coco8.yaml pelo teu próprio conjunto de dados e compara a precisão com o modelo SiLU usando o modo Val antes da implementação.

Como lidar com blocos de atenção na DPU#

O YOLO26 aplica atenção na resolução mais baixa (uma grelha de 20×20 com entrada 640) em dois pontos: no bloco C2PSA da camada 10 e no bloco C3k2 com atenção ativada da camada 22. O YOLO11 tem um bloco C2PSA. Numa DPU, os operadores MatMul e Softmax são executados na CPU, dividindo o modelo em subgrafos alternados de DPU e CPU. Tens três opções:

1. Aceitar os blocos de CPU. O .xmodel compilado contém então subgrafos de CPU, por isso executa-o com o Graph Runner da AMD, que executa em conjunto os subgrafos de DPU e CPU quando existe uma implementação de CPU para cada operador; caso contrário, tens de implementar e registrar os operadores em falta. Com 20×20, o cálculo da atenção é pequeno, mas cada transferência adicional entre a DPU e a CPU acrescenta latência, então mede o desempenho na tua placa.

2. Usar um YAML sem atenção. No teu YAML de Hard-Swish, substitui a camada C2PSA por nn.Identity para manter válidos os índices de camada usados por Concat e Detect, e desativa a atenção na camada 22:

   backbone:
       # ... layers 0-9 unchanged
       - [-1, 1, nn.Identity, []] # 10 C2PSA removed; keeps later layer indices valid
   
   head:
       # ... layers 11-21 unchanged
       - [-1, 1, C3k2, [1024, True, 0.5, False]] # 22 (P5/32-large), attention disabled
       - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

   O grafo ONNX exportado não contém então operadores MatMul nem Softmax. Os pesos de atenção deixam de ser aplicáveis (624 dos 666 pesos do YOLO26n são transferidos), então faz um ajuste fino mais longo e compara a precisão com o modo Val.

3. Usar um modelo sem atenção, como o YOLOv8, que a AMD já usou nos próprios exemplos de DPU.

Na Versal AI Edge Gen 2, os operadores de atenção aparecem como compatíveis com a NPU, então essas alterações geralmente são desnecessárias. Confirma a atribuição no relatório do compilador, pois a AMD observa que operadores compatíveis ainda podem ser executados na CPU devido a restrições de configuração ou memória.

Compatibilidade de modelos em resumo#

Implementa o YOLO26 hoje no AMD Xilinx#

Até que a exportação nativa esteja disponível, a implementação segue quatro etapas:

graph LR
    A[1. Train or fine-tune<br>Ultralytics YOLO]:::start --> B{Target?}:::decide
    B -->|Versal NPU| C[2. Export to ONNX<br>model.export]:::proc
    B -->|Zynq or Kria DPU| D[2. Keep the trained<br>PyTorch checkpoint]:::proc
    C --> E[3. Quantize and compile<br>Vitis AI 6.3 Docker]:::proc
    D --> F[3. Quantize and compile<br>Vitis AI 3.5 Docker]:::proc
    E --> G[4. Run on the board<br>VART-ML or ONNX Runtime]:::out
    F --> H[4. Run on the board<br>VART]:::out
    G -.->|accuracy check| A
    H -.->|accuracy check| A

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef decide fill:#FF9800,color:#fff
    classDef out fill:#9C27B0,color:#fff

Etapa 1: treina ou faz ajuste fino do modelo#

Treina com os teus próprios dados usando o modo Train ou na Ultralytics Platform. Para alvos DPU, começa pelo YAML Hard-Swish. Registra uma linha de base com o modo Val para medir mais tarde o impacto da quantização na precisão.

Etapa 2: exporta para ONNX para alvos NPU#

ONNX é a entrada comum aos fluxos NPU da AMD. O fluxo DPU quantiza diretamente o checkpoint PyTorch treinado na imagem Docker Vitis AI 3.5, então utilizadores de DPU podem ignorar esta etapa. Exporta com um tamanho de lote fixo de 1 e um opset compatível com a AMD; o tutorial YOLOv8m da AMD para Versal AI Edge Gen 2 usa o opset 17.

from ultralytics import YOLO

# # Carrega o modelo que treinaste na Etapa 1
model = YOLO("runs/detect/train/weights/best.pt")

# # Exporta para ONNX com uma forma estática para o compilador AMD
model.export(format="onnx", opset=17, imgsz=640)  # # cria 'best.onnx' ao lado de 'best.pt'

Consulta a integração ONNX e os argumentos de exportação para ver todas as opções. Com nms não definido, executa NMS na CPU após a inferência; para YOLO26, nms=False seleciona a cabeça sem NMS. Não incorpores NMS com nms=True, porque a AMD lista NonMaxSuppression entre os operadores que podem forçar a execução do modelo inteiro na CPU.

Etapa 3: quantifica e compila com o Vitis AI#

Os fluxos abaixo usam as imagens Docker da AMD num host Linux x86-64. Não precisas da placa nesta etapa. Seleciona o separador correspondente ao teu dispositivo:

Passo 4: Executar e validar na placa#

Prepara primeiro a placa. Tem de executar um design de hardware e uma imagem Linux que incluam a configuração do acelerador para a qual compilaste, além do runtime Vitis AI correspondente. Consulta os guias de configuração da AMD para os destinos DPU Zynq UltraScale+ e Kria, Versal AI Edge (VEK280) e Versal AI Edge Gen 2 (VEK385).

Em seguida, copia os artefactos necessários para o teu runtime:

Nos fluxos da NPU, o grafo ONNX exportado já descodifica as caixas e aplica a função sigmoide às pontuações das classes, pelo que o anfitrião apenas interpreta o resultado:

• nms não definido: os modelos de deteção geram um tensor (1, 4 + nc, anchors) com caixas xywh e pontuações por classe. Seleciona a melhor classe por âncora, converte as caixas em coordenadas dos cantos, filtra por confiança e executa NMS; a função non_max_suppression do Ultralytics executa todos estes passos.
• nms=False (YOLO26): o modelo gera um tensor (1, max_det, 6) com [x1, y1, x2, y2, score, class] linhas, que apenas requerem um limiar de confiança.

Em ambos os casos, redimensiona as caixas da entrada com letterbox para as dimensões da imagem original. Apenas os grafos interrompidos antes da etapa de descodificação precisam de descodificação das caixas no anfitrião. Na DPU, os buffers VART contêm valores INT8 de ponto fixo: consulta a forma e a escala fix_point de cada tensor, quantiza as entradas e desquantiza as saídas antes de aplicares os passos acima. O Graph Runner devolve as saídas do grafo completo, enquanto um executor apenas da DPU devolve saídas intermédias dos subgrafos da DPU que o teu código tem de terminar de calcular. Os formatos acima são os formatos ONNX (vista da CPU): o VART-ML usa por predefinição vistas de tensores do hardware, cuja forma, tipo de dados e disposição de memória podem ser diferentes; por isso, configura os tipos de tensores de entrada e saída do executor como vistas da CPU ou converte tu próprio o formato de hardware (consulta a visão geral da arquitetura VART-ML da AMD).

Compara a precisão no dispositivo com a referência FP32 do Passo 1, usando o teu próprio conjunto de validação e as mesmas métricas de desempenho, como mAP. Os resultados publicados pela AMD para YOLOv8m na VEK385 mostram o custo de precisão da implementação INT8:

Fonte: tutorial de YOLOv8m para Versal AI Edge Gen 2 da AMD, que também indica um tempo médio de inferência de 10,69 ms em 100 execuções VART com dp_size=1.

Aplicações no mundo real#

Os dispositivos AMD Xilinx são comuns sempre que a IA de visão tem de funcionar em tempo real, com baixo consumo de energia e perto do sensor:

• Segurança industrial e na construção: deteta pessoas e máquinas junto a equipamento pesado e monitoriza zonas de trabalho com deteção de objetos e contagem de objetos.
• Visão automóvel e fora de estrada: executa perceção baseada em câmaras em componentes certificados para o setor automóvel, dando suporte a veículos autónomos e à assistência ao condutor.
• Câmaras inteligentes e análise de vídeo: combina captura de vídeo, codificação e inferência YOLO num único chip para sistemas de segurança e análise de vídeo.
• Visão artificial e inspeção de qualidade: combina captura de imagens de alta velocidade baseada em FPGA com segmentação de instâncias ou classificação YOLO para detetar defeitos na linha de produção.
• Robótica e drones: usa módulos Kria KR260 ou Versal para estimativa de pose, deteção de objetos orientados e navegação com latência determinística.

Resumo#

Os dispositivos AMD Xilinx executam modelos YOLO através de duas gerações de aceleradores. A DPU do Zynq UltraScale+ e do Kria usa o fluxo Vitis AI 3.5, que já não evolui, e produz ficheiros .xmodel. Requer ativações nativas da DPU, como Hard-Swish, e executa a atenção na CPU. A NPU do Versal AI Edge e do Versal AI Edge Gen 2 usa as versões atuais do Vitis AI. A NPU Gen 2 suporta operadores SiLU e de atenção, e executa o exemplo YOLOv8m da AMD na VEK385 quase inteiramente na NPU, enquanto a cobertura de operadores na NPU VEK280, mais antiga, depende da versão e da precisão do Vitis AI.

A exportação nativa do Ultralytics para dispositivos AMD Xilinx estará disponível em breve. Até lá, treina com o Ultralytics, exporta para ONNX para destinos NPU Versal ou mantém o checkpoint PyTorch para destinos DPU, e compila com o Vitis AI conforme descrito acima. Para outros destinos de implementação, consulta o guia de opções de implementação de modelos, as melhores práticas de implementação e integrações de aceleradores como Hailo, Rockchip RKNN e Axelera.

Perguntas frequentes#