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

A implantação de modelos do Ultralytics YOLO em SoCs da Ambarella requer a compilação de modelos usando as ferramentas de compilação da Ambarella, e os modelos otimizados para a arquitetura CVflow têm um desempenho melhor no momento da inferência. Esta bifurcação do Ultralytics integra o kit de ferramentas de compressão SpongeTorch da Ambarella diretamente no pipeline de treino, validação e exportação, permitindo que os desenvolvedores gerem modelos otimizados para implantação eficiente em hardware da Ambarella.

Este guia aborda o fluxo de trabalho atual de implantação de detecção de objetos, desde o treinamento consciente da compressão até a inferência no dispositivo (consulta o Visão Geral do Fluxo de Trabalho para ver o pipeline completo).

O formato de ponto de verificação AmbaPB é uma extensão específica da Ambarella da especificação ONNX IR que suporta 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 produzido para o dispositivo de destino é o que é executado na placa.

Quem é 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 sinal de imagem, codificação de vídeo e computação de IA no chip, e são usados em dispositivos de segurança, automotivos, de robótica, industriais e de consumo.

O que é o CVflow?#

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

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

Porquê implementar YOLO na Ambarella?#

• Desempenho por watt: os SoCs CVflow foram concebidos para IA periférica sempre ativa, executando deteção de objetos em tempo real dentro dos limites de consumo energético de uma câmara.
• Treinamento consciente da compressão: o SpongeTorch aplica podas durante o treinamento para ajudar o modelo a reter a precisão enquanto se torna mais esparso e eficiente para a implantação no CVflow.
• Pipeline de câmera integrado: os SoCs da Ambarella combinam um processador de sinal de imagem (ISP), codificação de vídeo ultra-HD e CVflow para permitir uma variedade de sistemas de câmera com baixo consumo de energia, de modo que um único SoC da Ambarella gerencia o pipeline completo da câmera de IA.

Visão geral do fluxo de trabalho#

O pipeline tem seis estágios:

1. Treinamento consciente da compressão — treina com uma configuração do SpongeKit (amba_config) para que o SpongeTorch aplique poda não estruturada progressivamente durante o treinamento. Onde a precisão da quantização pós-treinamento (PTQ) não for aceitável, o SpongeTorch também suporta treinamento consciente de quantização (QAT), mas esse caminho ainda não está integrado a esta integração do Ultralytics e está planejado para uma versão futura.
2. Exportação ONNX — exporta o checkpoint comprimido com o mesmo amba_config, preservando a estrutura de compressão no grafo ONNX.
3. Compilação — compila o modelo ONNX em um ponto de verificação AmbaPB com as ferramentas de compilação do SDK, que aplicam PTQ para o mecanismo CVflow.
4. Validação do host — executa o modelo *.ambapb.ckpt.onnx compilado através do predict/val do Ultralytics por meio do backend AmbaPB para verificar a precisão antes da implantação.
5. Conversão Cavalry — converte o ponto de verificação AmbaPB validado em um binário Cavalry com as ferramentas do SDK.
6. Execução no dispositivo — executa o binário Cavalry no dispositivo com a biblioteca de tempo de execução do SDK da Ambarella.

O fluxo de trabalho de treino e exportação do SpongeTorch é opcional e pode ser substituído por uma exportação ONNX simples (consulta Exportação Sem SpongeTorch).

Pré-requisitos#

Instalação#

Instala esta bifurcação do Ultralytics, configura o SDK do Ambarella CVflow — que inclui as ferramentas de compilação e a biblioteca cvflowbackend — e instala o wheel do spongetorch distribuído juntamente 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 o cvflowbackend através do comando tv2 (tv2 -libpath cvflowbackend) das ferramentas de compilação do SDK, portanto, as ferramentas de compilação do SDK devem estar instaladas e no teu PATH antes de executar a inferência ou a validação com modelos compilados.

Ficheiro de configuração do SpongeKit#

O SpongeTorch é impulsionado por um arquivo de configuração do SpongeKit (formato protobuf-text, .prototxt) que define as passagens de poda, incluindo metas de esparsidade e o cronograma de compressão. Obtém configurações de exemplo e a documentação do esquema correspondente a partir do teu lançamento do SDK da Ambarella. Para manter a consistência entre o treinamento, a validação e a implantação, usa a configuração de treinamento sempre que a validação precisar preparar o modelo novamente e usa sempre a mesma configuração ao exportar um ponto de verificação 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:

Treino ciente da compressão#

Treina (ou ajusta) o teu 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 o amba_config é definido, o treinador envolve o modelo e o otimizador com o spongetorch.prepare() na configuração. A compressão é aplicada progressivamente em um cronograma de etapas, para que a rede aprenda a permanecer precisa enquanto se torna esparsa. O ponto de verificação treinado armazena o estado esparso do SpongeTorch (tensores _orig/_mask), que a etapa de exportação exige posteriormente. O arquivo de configuração é copiado para o diretório de execução como amba_config.prototxt para reprodutibilidade.

Validar o checkpoint comprimido#

Valida a precisão antes da compilação, utilizando 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. Compara o mAP com a tua linha de base não comprimida; se a descida da precisão for demasiado grande, ajusta a configuração SpongeKit e volta a treinar.

Exportar para ONNX#

Exporta o checkpoint comprimido com o mesmo amba_config utilizado no treino:

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, re-aplica o spongetorch.prepare() com a tua configuração, recarrega os pesos do ponto de verificação esparso na estrutura preparada e faz o rastreamento para ONNX com a fusão Conv+BN desativada — produzindo um gráfico na forma exata que as ferramentas de compilação do SDK esperam.

Preservar os metadados do modelo#

A exportação ONNX incorpora a tarefa do modelo, os nomes das classes, o stride e o tamanho de entrada no arquivo ONNX, enquanto o backend AmbaPB lê essas informações de um arquivo auxiliar metadata.yaml ao lado do modelo compilado. A menos que as tuas ferramentas de compilação do SDK criem esse arquivo auxiliar, extrai-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})

Mantém metadata.yaml no mesmo diretório que o ficheiro 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 gráfico no mecanismo de IA CVflow — aplicando PTQ, agendamento e planejamento de memória — e produzem o ponto de verificação AmbaPB para validação do host.

O 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 em relação à latência de tempo 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 o PTQ não consegue atingir a tua meta de precisão no nível INT8 necessário para o teu orçamento de latência, o QAT com o SpongeTorch é o remédio pretendido — ele treina o modelo para tolerar uma quantização INT8 mais agressiva, recuperando a precisão em um ponto de operação de 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 através da API do Ultralytics — o AutoBackend detecta o sufixo .ambapb e encaminha a inferência através de cvflowbackend, executando o modelo da maneira como ele 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ê dele os nomes das classes, o stride e as informações da tarefa. Por predefinição, o backend utiliza 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 que o ponto de verificação AmbaPB passa pela validação do host, usa as ferramentas de compilação do SDK para convertê-lo em um binário Cavalry para o teu dispositivo de destino, seguindo o guia de compilação do SDK. O binário Cavalry é a forma executada pela biblioteca de tempo de execução do SDK na placa.

Implementar na placa#

Carrega o binário Cavalry no teu dispositivo Ambarella usando o tempo de execução do SDK da Ambarella. O pré-processamento e o pós-processamento devem corresponder ao que o modelo de detecção foi compilado para: entrada RGB com letterbox no intervalo 0–255, e decodificação de detecção YOLO padrão nas saídas. Consulta a documentação de implantação do SDK para APIs de tempo de execução.

Exportar sem SpongeTorch#

Se não precisares da poda em tempo de treinamento do SpongeTorch, 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-treinamento por conta própria. Esse caminho troca parte do desempenho em tempo de execução e da precisão quantizada por um fluxo de trabalho mais simples, sem dependência do spongetorch no momento do treinamento.

Aplicações no mundo real#

Os modelos Ultralytics YOLO em SoCs Ambarella CVflow alimentam a visão periférica sempre ativa:

• Câmaras de segurança com IA: deteção de pessoas e veículos em tempo real em câmaras IP 4K dentro de um orçamento energético 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 múltiplos fluxos, deteção de EPI e monitorização de prateleiras em dispositivos periféricos.

Resumo#

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

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

Perguntas frequentes#