Exportação CVflow do Ambarella para modelos Ultralytics YOLO#

A implantação de modelos Ultralytics YOLO em SoCs Ambarella requer a compilação do modelo usando as ferramentas de compilação da Ambarella, e os modelos otimizados para a arquitetura CVflow têm melhor desempenho durante a inferência. Este fork do Ultralytics integra diretamente o kit de ferramentas de compressão SpongeTorch da Ambarella aos pipelines de treinamento, validação e exportação, permitindo que desenvolvedores gerem modelos otimizados para uma implantação eficiente em hardware Ambarella.

Este guia aborda o fluxo de trabalho atual de implantação de detecção de objetos, desde o treinamento com reconhecimento de compressão até a inferência no dispositivo (consulte a Visão geral do fluxo de trabalho para ver o pipeline completo).

O formato de checkpoint AmbaPB é uma extensão específica da Ambarella da especificação ONNX IR, que oferece suporte a primitivas computacionais CVflow e empacota os artefatos gerados pelas ferramentas do SDK. É o artefato do lado do host usado para validar a precisão do modelo compilado antes da implantação; o binário Cavalry separado, gerado para o dispositivo de destino, é o que é executado na placa.

O que é a Ambarella?#

A Ambarella, com sede em Santa Clara, Califórnia, é uma empresa de semicondutores que projeta SoCs de IA de borda. Seus processadores combinam processamento de sinais de imagem, codificação de vídeo e processamento de IA no chip, e são usados em dispositivos de segurança, automotivos, robóticos, industriais e de consumo.

O que é CVflow?#

CVflow é a arquitetura de processamento de visão da Ambarella. Ela usa um mecanismo de visão dedicado, separado da CPU e da GPU, para executar cargas de trabalho de visão computacional e redes neurais. Modelos treinados em frameworks como PyTorch são compilados para o formato nativo do CVflow com o SDK Ambarella antes de serem executados no mecanismo.

Famílias atuais de SoCs CVflow e suas aplicações típicas:

Por que implantar YOLO na Ambarella?#

• Desempenho por watt: os SoCs CVflow foram projetados para IA de borda sempre ativa, executando detecção de objetos em tempo real dentro dos limites de consumo de energia de câmeras.
• Treinamento com reconhecimento de compressão: o SpongeTorch aplica poda durante o treinamento para ajudar o modelo a manter a precisão enquanto se torna mais esparso e eficiente para a implantação em CVflow.
• Pipeline de câmera integrado: os SoCs Ambarella combinam um processador de sinal de imagem (ISP), codificação de vídeo ultra-HD e CVflow para possibilitar vários sistemas de câmera com baixo consumo de energia, de modo que um único SoC Ambarella gerencie todo o pipeline de câmera com IA.

Visão geral do fluxo de trabalho#

O pipeline tem seis etapas:

1. Treinamento com reconhecimento de compressão — treine com uma configuração SpongeKit (amba_config) para que o SpongeTorch aplique poda não estruturada progressivamente durante o treinamento. Quando a precisão da quantização pós-treinamento (PTQ) não for aceitável, o SpongeTorch também oferece suporte ao treinamento com reconhecimento de quantização (QAT), mas esse fluxo ainda não está integrado a esta integração do Ultralytics e está planejado para uma versão futura.
2. Exportação ONNX — exporte o checkpoint comprimido usando a mesma configuração amba_config, preservando a estrutura de compressão no grafo ONNX.
3. Compilação — compile o modelo ONNX para um checkpoint AmbaPB com as ferramentas de compilação do SDK, que aplicam PTQ para o mecanismo CVflow.
4. Validação no host — execute o modelo compilado *.ambapb.ckpt.onnx por meio de predict/val do Ultralytics, usando o backend AmbaPB para verificar a precisão antes da implantação.
5. Conversão para Cavalry — converta o checkpoint AmbaPB validado em um binário Cavalry usando as ferramentas do SDK.
6. Execução no dispositivo — execute o binário Cavalry no dispositivo com a biblioteca de runtime do SDK Ambarella.

O fluxo de trabalho de treinamento e exportação do SpongeTorch é opcional e pode ser substituído por uma exportação ONNX simples (consulte Exportar sem SpongeTorch).

Pré-requisitos#

Instalação#

Instale este fork do Ultralytics e, em seguida, configure o SDK Ambarella CVflow — que inclui as ferramentas de compilação e a biblioteca cvflowbackend — e instale o wheel spongetorch distribuído junto com ele:

# Install this Ultralytics fork from source
git clone https://github.com/Ambarella-Inc/ultralytics
cd ultralytics
git checkout amba_v8.4.46
pip install -e .

# Access and set up the Ambarella SDK compilation tools
# After the environment is ready, install the spongetorch library
pip install /path/to/spongetorch-*.whl

O AutoBackend localiza cvflowbackend por meio do comando tv2 (tv2 -libpath cvflowbackend) das ferramentas de compilação do SDK; portanto, as ferramentas de compilação do SDK precisam estar instaladas e no seu PATH antes de executar inferência ou validação com modelos compilados.

Arquivo de configuração do SpongeKit#

O SpongeTorch é controlado por um arquivo de configuração SpongeKit (formato protobuf-text, .prototxt) que define as etapas de poda, incluindo os alvos de esparsidade e o cronograma de compressão. Obtenha configurações de exemplo e a documentação do esquema correspondente na versão do SDK Ambarella. Para manter a consistência entre treinamento, validação e implantação, use a configuração de treinamento sempre que a validação precisar preparar o modelo novamente e use sempre a mesma configuração ao exportar um checkpoint comprimido.

Argumentos Amba#

Dois argumentos controlam a integração do SpongeTorch nos modos train, val e export:

O fork também adiciona um argumento geral de exportação:

Treinamento com reconhecimento de compressão#

Treine (ou ajuste) seu modelo com a compressão SpongeTorch ativada:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.train(
    data="coco8.yaml",
    epochs=100,
    amba_config="config.prototxt",
    amba_chipset="CV72",
)

Quando amba_config está definido, o treinador envolve o modelo e o otimizador com spongetorch.prepare() durante a configuração. A compressão é aplicada progressivamente de acordo com um cronograma de etapas, para que a rede aprenda a manter a precisão enquanto se torna esparsa. O checkpoint treinado armazena o estado esparso do SpongeTorch (tensores _orig/_mask), necessário posteriormente na etapa de exportação. O arquivo de configuração é copiado para o diretório da execução como amba_config.prototxt para garantir a reprodutibilidade.

Validar o checkpoint comprimido#

Valide a precisão antes da compilação, usando a mesma configuração:

yolo val model=runs/detect/train/weights/best.pt data=coco8.yaml \
  amba_config=config.prototxt amba_chipset=CV72

O validador reaplica spongetorch.prepare() quando necessário e desativa a fusão Conv+BN para preservar a estrutura de compressão. Compare o mAP com sua referência sem compressão; se a queda na precisão for grande demais, ajuste a configuração SpongeKit e treine novamente.

Exportar para ONNX#

Exporte o checkpoint comprimido usando a mesma configuração amba_config utilizada no treinamento:

from ultralytics import YOLO

model = YOLO("runs/detect/train/weights/best.pt")
model.export(
    format="onnx",
    amba_config="config.prototxt",
    amba_chipset="CV72",
)

O exportador recria o modelo, reaplica spongetorch.prepare() com sua configuração, carrega novamente os pesos do checkpoint esparso na estrutura preparada e gera um rastreamento para ONNX com a fusão Conv+BN desativada — produzindo um grafo exatamente no formato esperado pelas ferramentas de compilação do SDK.

Preservar os metadados do modelo#

A exportação ONNX incorpora no arquivo ONNX a tarefa do modelo, os nomes das classes, o stride e o tamanho de entrada, enquanto o backend AmbaPB lê essas informações de um arquivo auxiliar metadata.yaml ao lado do modelo compilado. A menos que as ferramentas de compilação do SDK criem esse arquivo auxiliar, extraia-o do modelo ONNX antes da compilação:

import onnx

from ultralytics.utils import YAML

model = onnx.load("model.onnx")
YAML.save("metadata.yaml", {item.key: item.value for item in model.metadata_props})

Mantenha metadata.yaml no mesmo diretório do arquivo compilado *.ambapb.ckpt.onnx ou *.ambapb.fastckpt.onnx.

Compilar com as ferramentas do SDK#

Compile o modelo ONNX exportado para o chipset de destino usando as ferramentas de compilação do SDK e seguindo o guia de compilação do SDK. As ferramentas mapeiam o grafo para o mecanismo de IA CVflow — aplicando PTQ, escalonamento e planejamento de memória — e geram o checkpoint AmbaPB para validação no host.

A PTQ aplica quantização INT8 usando imagens de calibração (preparadas conforme descrito no guia de compilação do SDK), e as ferramentas de compilação equilibram a precisão e a latência de execução: mapear mais operações para INT8 reduz a latência, mas pode diminuir a precisão, enquanto manter mais operações em FP16 preserva a precisão com maior latência. Quando a PTQ não consegue atingir sua meta de precisão no nível INT8 exigido pelo seu orçamento de latência, o QAT com SpongeTorch é a solução prevista — ele treina o modelo para tolerar uma quantização INT8 mais agressiva, recuperando precisão em um ponto de operação com menor latência. O QAT ainda não está disponível nesta integração e está planejado para uma versão futura.

Executar inferência com o modelo compilado#

O modelo AmbaPB compilado é carregado diretamente pela API do Ultralytics — o AutoBackend detecta o sufixo .ambapb e direciona a inferência por meio de cvflowbackend, executando o modelo como será executado no mecanismo de IA:

from ultralytics import YOLO

model = YOLO("model.ambapb.ckpt.onnx")

# Inference
results = model("https://ultralytics.com/images/bus.jpg")

# Validation
metrics = model.val(data="coco8.yaml")

Esta é a verificação final de precisão antes da implantação no hardware, incluindo todos os efeitos da quantização do compilador. Se houver um arquivo metadata.yaml ao lado do modelo compilado, o backend lerá dele os nomes das classes, o stride e as informações da tarefa. Por padrão, o backend usa o modo de inferência CVflow acinf; defina a variável de ambiente ULTRALYTICS_AMBAPB_DEBUG=1 para registrar detalhes de entrada/saída durante a depuração.

Converter para um binário Cavalry#

Depois que o checkpoint AmbaPB passar pela validação no host, use as ferramentas de compilação do SDK para convertê-lo em um binário Cavalry para o dispositivo de destino, seguindo o guia de compilação do SDK. O binário Cavalry é o formato executado pela biblioteca de runtime do SDK na placa.

Implantar na placa#

Carregue o binário Cavalry no dispositivo Ambarella usando o runtime do SDK Ambarella. O pré-processamento e o pós-processamento precisam corresponder ao que foi usado na compilação do modelo de detecção: entrada RGB com letterbox na faixa 0–255 e decodificação padrão de detecção YOLO nas saídas. Consulte a documentação de implantação do SDK para ver as APIs de runtime.

Exportar sem SpongeTorch#

Se você não precisa da poda do SpongeTorch durante o treinamento, o pipeline padrão do Ultralytics também produz um modelo que pode ser compilado pelas ferramentas do SDK:

yolo export model=yolo26n.pt format=onnx

Compile o ONNX resultante com as ferramentas de compilação do SDK, que fazem a quantização pós-treinamento. Esse fluxo troca parte do desempenho em tempo de execução e da precisão quantizada por um processo mais simples, sem dependência de spongetorch durante o treinamento.

Aplicações no mundo real#

Os modelos Ultralytics YOLO em SoCs Ambarella CVflow viabilizam visão de borda sempre ativa:

• Câmeras de segurança com IA: detecção de pessoas e veículos em tempo real em câmeras IP 4K, dentro de um orçamento de consumo inferior a 3 W.
• Drones e robótica: detecção e rastreamento de objetos a bordo para navegação, inspeção e entregas em chips da classe CV5.
• Análise industrial e de varejo: contagem de pessoas em múltiplos fluxos, detecção de EPI e monitoramento de prateleiras em dispositivos de borda.

Resumo#

Este guia apresentou o fluxo de trabalho atual para implantar modelos Ultralytics YOLO em SoCs Ambarella CVflow: treinamento com reconhecimento de compressão usando SpongeTorch (amba_config/amba_chipset), exportação ONNX do checkpoint comprimido, compilação offline para um checkpoint AmbaPB com as ferramentas do SDK, validação no host pelo Ultralytics e conversão para um binário Cavalry para implantação no dispositivo com o SDK Ambarella.

Para outros alvos de IA de borda, consulte os guias relacionados de Hailo, Rockchip RKNN, Sony IMX500, Qualcomm QNN, DEEPX e Axelera. Para ver a lista completa de formatos de exportação, acesse a documentação do modo de exportação e a página de integrações.

Perguntas frequentes#