Exportação Ambarella CVflow para modelos Ultralytics YOLO#

A implantação de modelos Ultralytics YOLO em SoCs Ambarella requer a compilação dos modelos 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 da Ultralytics integra diretamente o kit de ferramentas de compressão SpongeTorch da Ambarella ao pipeline de treinamento, validação e exportação, permitindo que os desenvolvedores gerem modelos otimizados para uma implantação eficiente no hardware Ambarella.

Este guia aborda o fluxo de trabalho atual de implantação de detecção de objetos, do treinamento com reconhecimento de compressão à 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. Ele é o artefato do lado do host usado para validar a precisão do modelo compilado antes da implantação; o binário Cavalry separado, produzido para o dispositivo de destino, é 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 computação 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. Antes de serem executados no mecanismo, os modelos treinados em frameworks como PyTorch são compilados para o formato nativo do CVflow com o SDK da Ambarella.

Famílias de SoC CVflow atuais 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, tornando-se mais esparso e eficiente para implantação no 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 habilitar diversos sistemas de câmera com baixo consumo de energia, permitindo que um único SoC Ambarella gerencie todo o pipeline de uma 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 do 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 da Ultralytics e está previsto para uma versão futura.
2. Exportação ONNX — exporte o checkpoint comprimido com o mesmo amba_config, preservando a estrutura de compressão no grafo ONNX.
3. Compilação — compile o modelo ONNX em 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 da Ultralytics usando o backend AmbaPB para verificar a precisão antes da implantação.
5. Conversão Cavalry — converta o checkpoint AmbaPB validado em um binário Cavalry com as ferramentas do SDK.
6. Execução no dispositivo — execute o binário Cavalry no dispositivo com a biblioteca de runtime do SDK da Ambarella.

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

Pré-requisitos#

Instalação#

Instale este fork da Ultralytics e, em seguida, configure o SDK Ambarella CVflow — que inclui as ferramentas de compilação e a biblioteca cvflowbackend — e instale o wheel do spongetorch distribuído 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 disponíveis em 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 do SpongeKit (formato protobuf-text, .prototxt) que define as etapas de poda, incluindo as metas 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 da Ambarella. Para manter a consistência entre o treinamento, a validação e a 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 do 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 fino) seu modelo com a compressão do 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 para a etapa de exportação. Para garantir a reprodutibilidade, o arquivo de configuração é copiado para o diretório da execução como amba_config.prototxt.

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 a referência sem compressão; se a queda de precisão for muito grande, ajuste a configuração do SpongeKit e treine novamente.

Exportar para ONNX#

Exporte o checkpoint comprimido usando a mesma configuração amba_config usada 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 reconstrói o modelo, reaplica spongetorch.prepare() com sua configuração, carrega novamente os pesos do checkpoint esparso na estrutura preparada e converte o modelo para ONNX com o rastreamento, mantendo desativada a fusão Conv+BN — gerando um grafo exatamente no formato esperado pelas ferramentas de compilação do SDK.

Preservar os metadados do modelo#

A exportação ONNX incorpora a tarefa do modelo, os nomes das classes, o stride e o tamanho da entrada ao arquivo ONNX, enquanto o backend AmbaPB lê essas informações de um arquivo auxiliar metadata.yaml ao lado do modelo compilado. Se as ferramentas de compilação do SDK não criarem 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#

Compila o modelo ONNX exportado para o teu chipset de destino usando as ferramentas de compilação do SDK, seguindo o guia de compilação do SDK. As ferramentas mapeiam o grafo para o mecanismo de IA CVflow — aplicando PTQ, agendamento e planeamento de memória — e produzem 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 a precisão pretendida no nível INT8 necessário para o teu limite de latência, a QAT com SpongeTorch é a solução prevista — treina o modelo para tolerar uma quantização INT8 mais agressiva, recuperando precisão num ponto de operação com menor latência. A QAT ainda não está disponível nesta integração e está prevista para uma versão futura.

Executar inferência com o modelo compilado#

O modelo AmbaPB compilado é carregado diretamente através da API Ultralytics — AutoBackend deteta o sufixo .ambapb e encaminha a inferência através de cvflowbackend, executando o modelo tal 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 da precisão antes da implementação no hardware, incluindo todos os efeitos da quantização do compilador. Se existir um ficheiro metadata.yaml junto ao modelo compilado, o backend lê desse ficheiro os nomes das classes, o stride e as informações da tarefa. Por predefinição, o backend usa o modo de inferência CVflow acinf; define a variável de ambiente ULTRALYTICS_AMBAPB_DEBUG=1 para registar detalhes de entrada/saída para depuração.

Converter para um binário Cavalry#

Depois de o checkpoint AmbaPB passar a validação no host, usa as ferramentas de compilação do SDK para o converter num binário Cavalry para o teu 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.

Implementar na placa#

Carrega o binário Cavalry no teu dispositivo Ambarella usando o runtime do SDK Ambarella. O pré-processamento e o pós-processamento têm de corresponder à configuração para a qual o modelo de deteção foi compilado: entrada RGB com letterbox no intervalo 0–255 e descodificação padrão de deteção YOLO nas saídas. Consulta a documentação de implementação do SDK para ver as APIs de runtime.

Exportar sem SpongeTorch#

Se não precisares da poda do SpongeTorch durante o treino, o pipeline padrão do Ultralytics também produz um modelo que as ferramentas do SDK podem compilar:

yolo export model=yolo26n.pt format=onnx

Compila o ONNX resultante com as ferramentas de compilação do SDK, que executam a quantização pós-treino. Este método troca algum desempenho de execução e precisão quantizada por um fluxo de trabalho mais simples, sem dependência de spongetorch durante o treino.

Aplicações no mundo real#

Os modelos Ultralytics YOLO em SoCs Ambarella CVflow alimentam sistemas de visão sempre ativos na periferia:

• Câmaras de segurança com IA: deteção de pessoas e veículos em tempo real em câmaras IP 4K, com um orçamento de energia inferior a 3 W.
• Drones e robótica: deteção e seguimento de objetos a bordo para navegação, inspeção e entregas em chips da classe CV5.
• Análise industrial e de retalho: contagem de pessoas em vários fluxos, deteção de EPI e monitorização de prateleiras em dispositivos de periferia.

Resumo#

Este guia apresentou o fluxo de trabalho atual para implementar modelos Ultralytics YOLO em SoCs Ambarella CVflow: treino com consciência da 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 através do Ultralytics e conversão para um binário Cavalry para implementação no dispositivo com o SDK Ambarella.

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

Perguntas frequentes#