Exportação Qualcomm QNN para Modelos Ultralytics YOLO#

A implantação de modelos de visão computacional em dispositivos Qualcomm Snapdragon exige um formato de modelo ajustado para o tempo de execução do Qualcomm AI Engine Direct (QNN). Exportar modelos do Ultralytics YOLO para o formato QNN permite executar inferência acelerada diretamente no dispositivo em hardware de CPU Snapdragon, GPU Adreno e NPU Hexagon encontrado em bilhões de telefones celulares, laptops, sistemas automotivos e dispositivos IoT. Este guia explica como exportar o YOLO para o Qualcomm QNN e implantá-lo para inferência rápida e de baixo consumo de energia em hardware Snapdragon.

O que é Qualcomm QNN?#

Qualcomm AI Engine Direct — comumente chamado de QNN e distribuído como parte do SDK do Qualcomm AI Runtime (QAIRT) — é a pilha de inferência de baixo nível da Qualcomm para processadores Snapdragon. Ele fornece uma API unificada com bibliotecas específicas de backend direcionadas à CPU Snapdragon, à GPU Adreno e ao Hexagon Tensor Processor (HTP), a unidade de processamento de rede neural (NPU) dedicada dentro de SoCs Snapdragon modernos. O QNN dá aos desenvolvedores acesso de pilha completa a esses aceleradores de IA do Snapdragon e é o sucessor moderno do antigo SDK do Snapdragon Neural Processing Engine (SNPE). Ele alimenta a IA no dispositivo nas plataformas móveis Snapdragon 8 Gen 2, 8 Gen 3 e 8 Elite, laptops Snapdragon X e produtos automotivos e de XR.

Por que exportar para Qualcomm QNN?#

Snapdragon é a plataforma de computação móvel mais amplamente implantada no mundo. Exportar Ultralytics YOLO para o formato Qualcomm QNN desbloqueia o hardware de IA dedicado nesses dispositivos:

• Aceleração por NPU Hexagon: Executar o YOLO no Hexagon Tensor Processor oferece taxa de transferência dramaticamente maior e menor consumo de energia do que a inferência em CPU — ideal para inferência em tempo real e visão computacional sempre ativa no Snapdragon.
• No dispositivo e offline: A inferência QNN roda inteiramente no dispositivo Snapdragon, portanto, não há viagens de ida e volta para a nuvem, a latência permanece baixa e os dados nunca saem do dispositivo.
• Eficiência quantizada: a exportação para QNN quantiza o YOLO para pesos INT8 com ativações de 16 bits, o equilíbrio ideal entre precisão e desempenho da NPU Hexagon, reduzindo o tamanho do modelo e maximizando os quadros por segundo em hardware alimentado por bateria.
• Um formato, muitos dispositivos: Uma única exportação Qualcomm QNN tem como alvo a CPU Snapdragon, GPU Adreno e NPU Hexagon nas famílias Snapdragon 8 Gen 2, 8 Gen 3, 8 Elite e além.
• Stack Qualcomm AI pronta para produção: QNN (Qualcomm AI Engine Direct / QAIRT) é o runtime de IA no dispositivo atual e mantido ativamente da Qualcomm e a substituição recomendada para o SNPE.

Formato de Exportação QNN#

O Ultralytics compila modelos YOLO para QNN localmente usando o QNN Execution Provider do ONNX Runtime (o pacote instalável via pip onnxruntime-qnn, que agrupa as bibliotecas do QAIRT). O exportador converte seu modelo para ONNX, o quantiza com dados de calibração para ativações de 16 bits e pesos INT8 (o equilíbrio recomendado para a NPU Hexagon), e então inicializa uma sessão do ONNX Runtime com o cache de binários de contexto ativado — isso compila o grafo quantizado em um binário de contexto QNN incorporado em <model>_qnn.onnx. Nenhuma conta da Qualcomm, upload em nuvem ou download separado de SDK é necessário.

Ao contrário do Qualcomm AI Hub baseado em nuvem, que compila e analisa o desempenho de modelos em dispositivos Snapdragon hospedados pela Qualcomm e requer uma conta da Qualcomm, a exportação QNN do Ultralytics roda inteiramente em sua própria máquina com uma única chamada de export(format="qnn", imgsz=640) (imgsz=224 para classificação). Você obtém o mesmo destino de tempo de execução QNN/QAIRT — CPU Snapdragon, GPU Adreno e NPU Hexagon — sem cadastro, limites de upload ou tempos de fila, e ele se encaixa diretamente no fluxo de trabalho padrão de exportação do YOLO.

O arquivo *_qnn.onnx exportado é autossuficiente: ele incorpora o binário de contexto QNN e metadados do ONNX, como nomes de classes, tamanho da imagem e tarefa.

Principais Recursos dos Modelos QNN#

• Quantização: o modelo é quantizado para ativações de 16 bits e pesos INT8 com o fluxo QDQ do QNN do ONNX Runtime e um conjunto de dados de calibração, o equilíbrio de precisão/desempenho recomendado pela NPU Hexagon. Saiba mais sobre quantização de modelos.
• Compilação Totalmente Local: O binário de contexto é gerado inteiramente em sua máquina host — sem conta da Qualcomm, token de API ou upload na nuvem.
• Aceleração Snapdragon Completa: Execute inferência na NPU Hexagon (HTP), GPU Adreno ou CPU através de um único runtime unificado.
• Amplo Alcance de Dispositivos: Mire na ampla gama de plataformas Snapdragon enviadas em telefones, PCs (Windows no Snapdragon), automotivos, XR e produtos embarcados.
• Binário de Contexto Pré-compilado: Enviar um binário de contexto minimiza a compilação de grafo no dispositivo, reduzindo a latência de carregamento do modelo no alvo.
• Saída Autossuficiente: O arquivo ONNX exportado inclui o binário de contexto QNN pré-compilado e metadados para implantação direta.

Desempenho Medido#

Smartphone Android#

Hardware: Xiaomi 17 com 12 GB de memória LPDDR5X e Android 16 / API 36. Seu Snapdragon 8 Elite Gen 5 de 3 nm (SM8850) possui uma CPU Qualcomm Oryon de 8 núcleos (2 núcleos Prime de até 4,6 GHz e 6 núcleos Performance de até 3,62 GHz), GPU Adreno e NPU Hexagon (HTP v81).

• Os valores de velocidade são latências de rajada de imagem única — a média de 15 execuções após 3 execuções de aquecimento em bus.jpg, medidas com a ferramenta de benchmark no dispositivo do plug-in Flutter 0.6.10 e os ativos padronizados v0.6.6. A ordem dos backends alternou entre as tarefas em uma varredura sequencial. Os logs nativos confirmaram que cada linha de CPU usou LiteRT CPU/XNNPACK, cada linha de GPU delegou o grafo completo para o OpenCL do LiteRT (LITERT_CL) e cada linha de NPU usou o backend QNN Hexagon HTP.
• O registro detalhado do benchmark está na documentação de desempenho do Flutter.
• Compare outros dispositivos Android na integração com o LiteRT e dispositivos Apple na integração com o CoreML.

Portátil Windows on Snapdragon#

Esta varredura histórica utilizou binários QNN v73 pré-padronizados; semântica e OBB usaram entradas de 1024px. Ela foi executada em um laptop Lenovo com 32 GB de memória e Windows 11. Seu Snapdragon X Elite (X1E78100) possui uma CPU Qualcomm Oryon de 12 núcleos, GPU Adreno e NPU Hexagon (HTP v73); o modelo exato da Lenovo não foi registrado. Esta comparação do Windows no Snapdragon executa a linha de base de CPU PyTorch FP32 nativa da qual a maioria dos desenvolvedores de desktop parte, em comparação com o caminho do ONNX Runtime QNN Hexagon HTP. Cada célula mostra o tempo de parede total model.predict() com os tempos relatados de pré-processamento / inferência / pós-processamento abaixo dela; o total pode incluir a sobrecarga do framework fora desses três estágios. Os números da CPU são PyTorch FP32 (torch==2.10.0+cpu) e os números da NPU são ONNX Runtime QNN (onnxruntime-qnn==2.2.0, pesos INT8 / ativações de 16 bits).

• Os valores de velocidade são latências de rajada de imagem única — a média de 100 execuções após 10 execuções de aquecimento em bus.jpg, medidas com time.perf_counter() em torno da chamada completa de model.predict() em um dispositivo termicamente repousado (ultralytics==8.4.67, Python 3.12.10).
• A Hexagon NPU executa aproximadamente 2-4x mais rápido do que a base de referência PyTorch CPU nas tarefas de 640-1024 px (deteção ~3.4x), diminuindo para ~1.3x no classificador de 224 px onde a sobrecarga de pré-processamento fixo domina a pequena carga de trabalho.

Tarefas Suportadas#

A exportação para o Qualcomm QNN suporta todas as sete tarefas do Ultralytics. A segmentação semântica e a estimativa de profundidade estão disponíveis apenas com o YOLO26, a única família que inclui essas cabeças.

Exportar para QNN: Convertendo seu Modelo YOLO#

Exporte um modelo Ultralytics YOLO para o formato QNN para implantação em hardware da Qualcomm. O binário de contexto é finalizado para uma arquitetura de Hexagon Tensor Processor (HTP) alvo ou SoC suportado, que você seleciona com o argumento name — o mesmo argumento usado para direcionar um chip na exportação RKNN.

Alvos HTP Suportados#

Passe a arquitetura ou SoC de destino via name (por exemplo, name="73" ou name="iq-8275"). O suporte é determinado pelo destino HTP, portanto, as linhas do Snapdragon abaixo são plataformas representativas e não uma lista exaustiva de todos os SoCs. Os dispositivos Dragonwing são listados explicitamente.

O Dragonwing IQ-615 não pode utilizar a exportação de binário de contexto QNN da Ultralytics porque o ONNX Runtime não expõe o seu DSP v66 como um alvo HTP offline. Uma exportação ONNX padrão ainda pode ser integrada separadamente com um fornecedor de execução de CPU ou GPU suportado pelo BSP da placa.

from ultralytics import YOLO

model = YOLO("best.pt")
model.export(format="qnn", name="iq-8275", imgsz=640)

Instalação#

Para instalar os pacotes necessários, execute:

# Install the required package for YOLO
pip install ultralytics

O pacote onnxruntime-qnn (que fornece o QNN Execution Provider do ONNX Runtime e agrupa as bibliotecas do QAIRT) é instalado automaticamente na primeira exportação. Para obter instruções detalhadas e práticas recomendadas relacionadas ao processo de instalação, consulte nosso Guia de Instalação do Ultralytics. Ao instalar os pacotes necessários para o YOLO, se encontrar alguma dificuldade, consulte nosso Guia de Problemas Comuns para soluções e dicas.

Uso#

O formato QNN oferece suporte aos modos Export, Predict e Validate. A inferência e a validação são executadas em hardware Qualcomm Snapdragon através do QNN Execution Provider do ONNX Runtime (o mesmo pacote onnxruntime-qnn usado para exportação). Exporte seu modelo e, em seguida, carregue o modelo exportado em um dispositivo Snapdragon para executar a inferência ou validar sua precisão.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export to Qualcomm QNN format (INT8, enforced automatically) for the default v73 HTP target
model.export(format="qnn", name="73", imgsz=640)  # use imgsz=224 for classification

from ultralytics import YOLO

# Load the exported QNN model (on a Snapdragon device with onnxruntime-qnn)
model = YOLO("yolo26n_qnn.onnx")

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

from ultralytics import YOLO

# Load the exported QNN model (on a Snapdragon device with onnxruntime-qnn)
model = YOLO("yolo26n_qnn.onnx")

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Argumentos de Exportação#

Para mais detalhes sobre o processo de exportação, visita a página de documentação do Ultralytics sobre exportação.

Estrutura de Saída#

Após uma exportação bem-sucedida, um arquivo ONNX autossuficiente é criado:

O arquivo yolo26n_qnn.onnx incorpora o binário de contexto QNN e é carregado pelo ONNX Runtime com o QNN Execution Provider no dispositivo Snapdragon. Ele também carrega metadados do modelo, como nomes de classes, tamanho da imagem e tarefa no ONNX metadata_props.

Implantando Modelos YOLO QNN Exportados#

Os modelos QNN são executados em hardware Qualcomm suportado, tornando a implantação de modelos no dispositivo simples. Em um dispositivo compatível com onnxruntime-qnn instalado, execute o modelo exportado diretamente com a API do Ultralytics (yolo predict/yolo val, consulte Uso acima) — o Ultralytics carrega o binário de contexto HTP através do QNN Execution Provider do ONNX Runtime.

Para pipelines personalizados, você também pode carregar o ONNX do binário de contexto diretamente com o ONNX Runtime. onnxruntime-qnn é um Execution Provider de plug-in, portanto, registre-o em tempo de execução:

import onnxruntime as ort
import onnxruntime_qnn as qnn_ep

# On the Snapdragon device, register the QNN plugin EP and select its device(s)
ort.register_execution_provider_library("QNNExecutionProvider", qnn_ep.get_library_path())
devices = [d for d in ort.get_ep_devices() if d.ep_name == "QNNExecutionProvider"]

options = ort.SessionOptions()
options.add_provider_for_devices(devices, {"backend_path": qnn_ep.get_qnn_htp_path()})
session = ort.InferenceSession("yolo26n_qnn.onnx", sess_options=options)
input_info = session.get_inputs()[0]
outputs = session.run(None, {input_info.name: input_tensor})  # input_tensor: float32 NHWC

Como o binário de contexto QNN é pré-compilado, a sessão carrega rapidamente sem recompilar o grafo no dispositivo.

Requisitos de BSP para Linux e Yocto#

A placa de destino deve fornecer um BSP e um tempo de execução da Qualcomm mutuamente compatíveis. Para inferência HTP, isso inclui o QNN Execution Provider do ONNX Runtime, libQnnSystem.so, libQnnHtp.so, as bibliotecas stub e skeleton HTP v75 para IQ-8275, suporte de espaço de usuário FastRPC como libcdsprpc.so, o firmware DSP e os drivers FastRPC/kernel correspondentes. A biblioteca skeleton deve ser detectável através do caminho da biblioteca DSP do BSP.

Esses componentes do lado do destino vêm do BSP habilitado para QAIRT/QNN do fornecedor da placa; eles não estão embutidos no modelo exportado. A execução na GPU, em vez disso, requer libQnnGpu.so e a pilha de drivers de espaço de usuário Adreno correspondente. A saída de format=qnn do Ultralytics é um binário de contexto específico para HTP, portanto, a implantação em GPU ou CPU deve partir de uma exportação ONNX padrão em vez do arquivo pré-compilado *_qnn.onnx.

Fluxo de Trabalho Recomendado#

1. Treine seu modelo usando o Modo de Treinamento do Ultralytics
2. Exporte para o formato QNN usando model.export(format="qnn", name="iq-8275", imgsz=640) em uma plataforma suportada (use imgsz=224 para classificação)
3. Implante o arquivo *_qnn.onnx exportado em seu dispositivo Qualcomm
4. Executa a inferência com o ONNX Runtime e o QNN Execution Provider utilizando o backend HTP

Aplicações do Mundo Real#

Modelos YOLO executados em hardware Qualcomm Snapdragon são ideais para uma ampla gama de aplicações de IA de borda:

• Smartphones: Detecção de objetos em tempo real e compreensão de cenas em aplicativos de câmera e fotos com aceleração por NPU.
• Windows no Snapdragon: Visão computacional no dispositivo em PCs Copilot+ sem descarregar para a nuvem.
• Automotivo: Monitoramento do motorista, detecção de ocupantes e recursos ADAS em plataformas Snapdragon Digital Chassis.
• XR e Wearables: Percepção de baixa potência e baixa latência para headsets AR/VR e óculos inteligentes.
• IoT e Robótica: Inferência de visão eficiente em câmeras, drones e sistemas embarcados alimentados por Snapdragon.

Resumo#

Neste guia, você aprendeu como exportar modelos Ultralytics YOLO para o formato Qualcomm QNN localmente com o QNN Execution Provider do ONNX Runtime. O pipeline de exportação converte seu modelo para ONNX e, em seguida, o compila em um binário de contexto QNN na sua máquina host — sem necessidade de conta na Qualcomm ou nuvem — produzindo um arquivo *_qnn.onnx otimizado para hardware de CPU Snapdragon, GPU Adreno e NPU Hexagon através do tempo de execução QNN/QAIRT.

A combinação de Ultralytics YOLO e da pilha de IA no dispositivo da Qualcomm fornece uma solução eficaz para executar cargas de trabalho avançadas de visão computacional em todo o ecossistema Snapdragon.

Para outros destinos de implantação móvel e no dispositivo, consulte os guias de exportação relacionados para ONNX, CoreML, NCNN, LiteRT, ExecuTorch, RKNN, Sony IMX500 e TensorRT. Para comparar formatos antes do envio, use o modo Benchmark. Para ver a lista completa de formatos e opções, visite a documentação do modo Export e a página do guia de integrações.

FAQ#