Link to this sectionExportação Ambarella CVflow para Modelos Ultralytics YOLO#

A implantação de modelos Ultralytics YOLO em SoCs Ambarella requer um formato de modelo otimizado para o mecanismo de IA CVflow®. Este fork do Ultralytics integra o kit de ferramentas de compressão SpongeTorch da Ambarella diretamente no pipeline de treino, validação e exportação, para que possas produzir modelos podados e otimizados por quantização que executam eficientemente no hardware da Ambarella. Este guia descreve o fluxo de trabalho atual de detecção de objetos: treino ciente da compressão, exportação ONNX, compilação com o conjunto de ferramentas CVflow e inferência com o modelo AmbaPB compilado.

Link to this sectionO que é o Ambarella CVflow?#

Ambarella é uma empresa de semicondutores sediada em Santa Clara, conhecida pelos seus SoCs de visão de IA de baixo consumo, amplamente utilizados em câmaras de segurança IP, câmaras de painel, drones, robótica e sistemas automotivos. Os seus chips são construídos em torno do CVflow®, uma arquitetura dedicada de processamento vetorial neural (o acelerador de IA no chip, ou NPU) que proporciona um elevado rendimento de inferência com um consumo muito baixo — o CV72S executa cargas de trabalho de IA de câmaras de segurança 4K abaixo de 3 W. Modelos treinados em frameworks padrão como PyTorch são compilados para o formato nativo do CVflow com o conjunto de ferramentas offline da Ambarella antes da implantação.

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

Link to this sectionPorquê implantar YOLO na Ambarella?#

• Desempenho por watt: Os SoCs CVflow foram concebidos para IA de edge sempre ativa, executando detecção de objetos em tempo real dentro de orçamentos de energia de classe de câmara.
• Treino ciente da compressão: O SpongeTorch aplica otimização ciente de poda e quantização durante o treino, para que o modelo aprenda a manter a precisão enquanto se torna compatível com NPU.
• Validação de host bit-exact: o modelo AmbaPB compilado executa através de predict/val do Ultralytics na tua estação de trabalho exatamente como irá executar no chip, para que possas medir o mAP quantizado antes de tocar no hardware.
• Pipeline de câmara integrado: Os SoCs da Ambarella combinam o motor de IA com um ISP e codificadores de vídeo, tornando-os uma solução de chip único para câmaras com IA.

Link to this sectionVisão geral do fluxo de trabalho#

O pipeline tem quatro estágios:

1. Treino ciente da compressão — treina com uma configuração SpongeKit (amba_config) para que o SpongeTorch aplique poda/quantização progressivamente durante o treino.
2. Exportação ONNX — exporta o checkpoint comprimido com a mesma amba_config, preservando a estrutura de compressão no grafo ONNX.
3. Compilação CVflow — compila o modelo ONNX para um artefacto AmbaPB com o conjunto de ferramentas CVflow.
4. Inferência e validação — executa o modelo compilado *.ambapb.ckpt.onnx através de predict/val do Ultralytics via backend AmbaPB, depois implanta na placa.

O treino com SpongeTorch e a exportação ciente do SpongeTorch podem ser substituídos por uma exportação ONNX simples se não precisares das otimizações de treino do SpongeTorch (vê Exportar sem SpongeTorch).

Link to this sectionPré-requisitos#

Link to this sectionInstalação#

Instala este fork do Ultralytics, depois instala os wheels do conjunto de ferramentas Ambarella da distribuição do SDK:

!!! Tip "Instalação"

# 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 .

# Install Ambarella toolchain wheels from the SDK
pip install /path/to/spongetorch-*.whl
pip install /path/to/cvflowbackend-*.whl

O backend de inferência AmbaPB localiza o cvflowbackend através do comando tv2 do conjunto de ferramentas CVflow (tv2 -libpath cvflowbackend), portanto, o conjunto de ferramentas deve estar instalado e no teu PATH antes de executar a inferência ou validação com modelos compilados.

Link to this sectionFicheiro de configuração do SpongeKit#

O SpongeTorch é orientado por um ficheiro de configuração do SpongeKit (formato protobuf-text, .prototxt) que define as passagens de compressão a aplicar: metas de esparsidade de poda, definições de quantização e o cronograma de compressão. Obtém exemplos de configurações e a documentação do esquema correspondente a partir do teu lançamento do SDK Ambarella. Utiliza a configuração de treino sempre que a validação necessitar de preparar um modelo não preparado, e utiliza sempre a mesma configuração ao exportar um checkpoint comprimido.

Link to this sectionArgumentos Amba#

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

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

Link to this sectionTreino 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 amba_config está definido, o treinador envolve o modelo e o otimizador com spongetorch.prepare() na configuração. A compressão é aplicada progressivamente num cronograma de passos, para que a rede aprenda a manter a precisão enquanto se torna esparsa e amigável à quantização. O checkpoint treinado armazena o estado esparso do SpongeTorch (tensores _orig/_mask), que o passo de exportação requer posteriormente. O ficheiro de configuração é copiado para o diretório de execução como amba_config.prototxt para reprodutibilidade.

Link to this sectionValidar o checkpoint comprimido#

Valida a precisão antes de compilar, 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 que a estrutura de compressão seja preservada. Compara o mAP com a tua linha de base não comprimida; se a queda de precisão for muito grande, ajusta a configuração SpongeKit e retreina.

Link to this sectionExportar para ONNX#

Exporta o checkpoint comprimido com a mesma amba_config usada 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, reaplica spongetorch.prepare() com a tua configuração, recarrega os pesos do checkpoint esparso na estrutura preparada e rastreia para ONNX com a fusão Conv+BN desativada — produzindo um grafo na forma exata que o compilador CVflow espera.

Link to this sectionPreservar metadados do modelo#

A exportação ONNX incorpora a tarefa do modelo, nomes das classes, stride e tamanho de entrada no ficheiro ONNX, enquanto o backend AmbaPB lê esta informação de um sidecar metadata.yaml junto ao modelo compilado. A menos que o teu compilador CVflow crie este sidecar, 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 *.ambapb.ckpt.onnx ou *.ambapb.fastckpt.onnx compilado.

Link to this sectionCompilar com o conjunto de ferramentas CVflow#

Compila o modelo ONNX exportado para o teu chipset alvo utilizando o compilador CVflow do SDK, seguindo o guia de compilação do SDK. O compilador mapeia o grafo para o motor de IA CVflow (quantização, agendamento, planeamento de memória) e produz o artefacto AmbaPB implantável.

Link to this sectionExecutar inferência com o modelo compilado#

O modelo AmbaPB compilado carrega diretamente através da API do Ultralytics — AutoBackend deteta o sufixo .ambapb e encaminha a inferência através do cvflowbackend, executando o modelo exatamente como irá executar no motor 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 de quantização do compilador. Se um ficheiro metadata.yaml estiver ao lado do modelo compilado, o backend lê os nomes das classes, stride e informação da tarefa a partir dele. O backend usa o modo de inferência CVflow acinf por padrão; define a variável de ambiente ULTRALYTICS_AMBAPB_DEBUG=1 para registar detalhes de entrada/saída para depuração.

Link to this sectionImplantar na placa#

Carrega o modelo compilado no teu dispositivo Ambarella usando o runtime do SDK Ambarella. O pré-processamento e o pós-processamento devem corresponder ao que o modelo de detecção foi compilado: entrada RGB letterboxed na gama 0–255 (o backend AmbaPB do Ultralytics fornece ao modelo compilado RGB 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 runtime.

Link to this sectionExportar sem SpongeTorch#

Se não precisares das otimizações de poda e quantização cientes do treino do SpongeTorch, o pipeline Ultralytics padrão também produz um modelo compilável por CVflow:

yolo export model=yolo26n.pt format=onnx

Compila o ONNX resultante com o conjunto de ferramentas CVflow, que realiza a quantização pós-treino por si só. Este caminho troca algum desempenho de NPU e precisão quantizada por um fluxo de trabalho mais simples sem dependência de spongetorch no momento do treino.

Link to this sectionAplicações do Mundo Real#

Os modelos Ultralytics YOLO em SoCs Ambarella CVflow alimentam visão sempre ativa na edge:

• Câmaras de segurança com IA: detecção de pessoas e veículos em tempo real em câmaras IP 4K dentro de um orçamento de energia abaixo de 3 W.
• Drones e robótica: detecção e rastreamento de objetos a bordo para navegação, inspeção e entrega em chips da classe CV5.
• Automotivo: cargas de trabalho de percepção ADAS como detecção de peões e veículos em controladores de domínio CV3-AD.
• Análise industrial e retalhista: contagem de pessoas multi-stream, detecção de EPI e monitorização de prateleiras em aparelhos de edge.

Link to this sectionResumo#

Este guia de pré-visualização descreveu o fluxo de trabalho atual para implantar modelos Ultralytics YOLO em SoCs Ambarella CVflow: treino ciente da compressão com SpongeTorch (amba_config/amba_chipset), exportação ONNX do checkpoint comprimido, compilação offline para AmbaPB com o conjunto de ferramentas CVflow e validação bit-exact do modelo compilado através do Ultralytics antes da implantação na placa.

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

Link to this sectionFAQ#

Link to this sectionPosso exportar um modelo YOLO diretamente para o formato Ambarella com model.export()?#

Não. Não existe um alvo format="ambarella". Exporta para ONNX (opcionalmente com compressão SpongeTorch via amba_config), depois compila o modelo ONNX para AmbaPB offline com o conjunto de ferramentas CVflow da Ambarella a partir do SDK.

Link to this sectionQuais chips Ambarella podem executar modelos Ultralytics YOLO?#

Qualquer SoC baseado em CVflow suportado pelo teu conjunto de ferramentas CVflow pode ser visado, incluindo as famílias CV72/CV75 para câmaras com IA, CV5/CV52 para drones e robótica, e CV3-AD para automotivo. O argumento amba_chipset configura o alvo de otimização do SpongeTorch; seleciona o alvo correspondente separadamente ao compilar. Strings de chipset aceites e disponibilidade dependem do lançamento do SDK instalado.

Link to this sectionO que é o SpongeTorch e preciso dele?#

SpongeTorch é o kit de ferramentas de compressão de modelos da Ambarella, integrado no fork Ambarella do Ultralytics para treino ciente de poda e quantização. É opcional: uma exportação ONNX simples do Ultralytics também pode ser compilada com o conjunto de ferramentas CVflow usando quantização pós-treino, a algum custo no desempenho da NPU e precisão quantizada.

Link to this sectionOnde obtenho o SDK Ambarella, SpongeTorch e o conjunto de ferramentas CVflow?#

São proprietários e não estão no PyPI. Regista-te na Ambarella Developer Zone para solicitar acesso ao SDK; os wheels spongetorch e cvflowbackend e o compilador CVflow acompanham a distribuição do SDK.

Link to this sectionComo verifico a precisão do modelo compilado antes de implantar?#

Executa yolo val model=model.ambapb.ckpt.onnx data=your_data.yaml com o fork Ambarella instalado. O backend AmbaPB executa o modelo compilado exatamente como ele corre no motor de IA CVflow, portanto, o mAP reportado inclui todos os efeitos de quantização do compilador.