Exportação Qualcomm QNN para modelos Ultralytics YOLO#

Implementar modelos de visão computacional em dispositivos Qualcomm Snapdragon requer um formato de modelo otimizado para o runtime Qualcomm AI Engine Direct (QNN). Exportar modelos Ultralytics YOLO para o formato QNN permite executar inferência acelerada no dispositivo em hardware CPU Snapdragon, GPU Adreno e NPU Hexagon, presente em milhares de milhões de telemóveis, portáteis, sistemas automóveis e dispositivos IoT. Este guia explica como exportar YOLO para Qualcomm QNN e implementá-lo para obter inferência rápida e de baixo consumo em hardware Snapdragon.

O que é o Qualcomm QNN?#

Qualcomm AI Engine Direct — normalmente referido como QNN e distribuído como parte do SDK Qualcomm AI Runtime (QAIRT) — é a stack de inferência de baixo nível da Qualcomm para processadores Snapdragon. Fornece uma API unificada com bibliotecas específicas para cada backend, direcionadas à CPU Snapdragon, à GPU Adreno e ao Hexagon Tensor Processor (HTP), a unidade de processamento de redes neuronais (NPU) dedicada presente nos SoCs Snapdragon modernos. O QNN oferece aos programadores acesso full-stack a estes aceleradores de IA Snapdragon e é o sucessor moderno do antigo SDK Snapdragon Neural Processing Engine (SNPE). Alimenta aplicações de IA no dispositivo nas plataformas móveis Snapdragon 8 Gen 2, 8 Gen 3 e 8 Elite, nos portáteis Snapdragon X e em produtos automóveis e XR.

Porquê exportar para Qualcomm QNN?#

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

• Aceleração da NPU Hexagon: Executar YOLO no Hexagon Tensor Processor proporciona um débito muito superior e menor consumo de energia do que a inferência na CPU — ideal para inferência em tempo real e visão computacional sempre ativa em Snapdragon.
• No dispositivo e offline: A inferência QNN é executada inteiramente no dispositivo Snapdragon, pelo que não há comunicações de ida e volta com a cloud, a latência mantém-se baixa e os dados nunca saem do dispositivo.
• Eficiência da quantização: A exportação QNN quantiza YOLO para pesos INT8 com ativações de 16 bits, o equilíbrio preferido entre precisão e desempenho da NPU Hexagon, reduzindo o tamanho do modelo e maximizando os frames por segundo em hardware alimentado por bateria.
• Um formato, muitos dispositivos: Uma única exportação Qualcomm QNN é direcionada à CPU Snapdragon, à GPU Adreno e à NPU Hexagon nas famílias Snapdragon 8 Gen 2, 8 Gen 3 e 8 Elite, entre outras.
• Stack de IA Qualcomm pronta para produção: QNN (Qualcomm AI Engine Direct / QAIRT) é o runtime de IA atual da Qualcomm para dispositivos, ativamente mantido, e a substituição recomendada para SNPE.

Formato de exportação QNN#

A Ultralytics compila modelos YOLO para QNN localmente utilizando o ONNX Runtime QNN Execution Provider (o pacote instalável via pip onnxruntime-qnn, que inclui as bibliotecas QAIRT). O exportador converte o modelo para ONNX, quantiza-o com dados de calibração para ativações de 16 bits e pesos INT8 (o equilíbrio recomendado para a NPU Hexagon) e, em seguida, inicializa uma sessão ONNX Runtime com o armazenamento em cache do binário de contexto ativado — isto compila o grafo quantizado num binário de contexto QNN incorporado em <model>_qnn.onnx. Não é necessária uma conta Qualcomm, um carregamento para a cloud ou uma transferência separada do SDK.

Ao contrário do Qualcomm AI Hub baseado na cloud, que compila e analisa modelos em dispositivos Snapdragon alojados pela Qualcomm e requer uma conta Qualcomm, a exportação QNN da Ultralytics é executada inteiramente na tua própria máquina com uma única chamada export(format="qnn", imgsz=640) (imgsz=224 para classificação). Obténs o mesmo destino de runtime QNN/QAIRT — CPU Snapdragon, GPU Adreno e NPU Hexagon — sem registo, limites de carregamento ou tempos de espera, e o resultado integra-se diretamente no fluxo de trabalho de exportação YOLO padrão.

O ficheiro *_qnn.onnx exportado é autónomo: incorpora o binário de contexto QNN e metadados ONNX, como nomes das classes, tamanho da imagem e tarefa.

Principais funcionalidades dos modelos QNN#

• Quantização: O modelo é quantizado para ativações de 16 bits e pesos INT8 através do fluxo QNN QDQ do ONNX Runtime e de um conjunto de dados de calibração, o equilíbrio recomendado entre precisão e desempenho da NPU Hexagon. Sabe mais sobre quantização de modelos.
• Compilação totalmente local: O binário de contexto é gerado inteiramente na tua máquina anfitriã — sem conta Qualcomm, token de API ou carregamento para a cloud.
• Aceleração Snapdragon completa: Executa inferência na NPU Hexagon (HTP), na GPU Adreno ou na CPU através de um único runtime unificado.
• Amplo alcance de dispositivos: Direciona a implementação para a vasta gama de plataformas Snapdragon presentes em telemóveis, PCs (Windows on Snapdragon), produtos automóveis, XR e dispositivos incorporados.
• Binário de contexto pré-compilado: Distribuir um binário de contexto minimiza a compilação do grafo no dispositivo, reduzindo a latência de carregamento do modelo no destino.
• Saída autónoma: O ficheiro ONNX exportado inclui o binário de contexto QNN pré-compilado e metadados para uma implementação simples.

Desempenho medido#

Telemóvel Android#

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

• Os valores de velocidade são latências de rajadas de imagens individuais — a média de 15 execuções após 3 execuções de aquecimento em bus.jpg, medidas com o sistema de referência de benchmark no dispositivo 0.6.10 do plugin Flutter e os recursos v0.6.6 padronizados. A ordem dos backends alternou entre tarefas numa única sequência. Os registos nativos confirmaram que todas as linhas da CPU utilizaram LiteRT CPU/XNNPACK, todas as linhas da GPU delegaram o grafo completo para LiteRT OpenCL (LITERT_CL) e todas as linhas da NPU utilizaram o backend QNN Hexagon HTP.
• O registo detalhado do benchmark encontra-se no documento de desempenho do Flutter.
• Compara outros dispositivos Android na integração LiteRT e dispositivos Apple na integração CoreML.

Portátil Windows on Snapdragon#

Esta análise histórica utilizou binários QNN v73 anteriores ao padrão; a semântica e o OBB utilizaram entradas de 1024 px. Foi executada num portátil Lenovo com 32 GB de memória e Windows 11. O 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 registado. Esta comparação Windows-on-Snapdragon executa a linha de base nativa da CPU PyTorch FP32, que é o ponto de partida da maioria dos programadores desktop, contra o caminho Hexagon HTP QNN do ONNX Runtime. Cada célula mostra o tempo total model.predict() com os tempos de pré-processamento / inferência / pós-processamento indicados abaixo; o total pode incluir sobrecarga da framework fora destas três etapas. Os valores da CPU são PyTorch FP32 (torch==2.10.0+cpu) e os valores 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 rajadas de imagens individuais — 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 model.predict() num dispositivo termicamente estabilizado (ultralytics==8.4.67, Python 3.12.10).
• A NPU Hexagon executa tarefas aproximadamente 2–4x mais rapidamente do que a linha de base da CPU PyTorch nos trabalhos de 640–1024 px (deteção ~3,4x), diminuindo para ~1,3x no classificador de 224 px, onde a sobrecarga fixa do pré-processamento domina a carga de trabalho reduzida.

Tarefas suportadas#

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

Exportar para QNN: converter o teu modelo YOLO#

Exporta um modelo Ultralytics YOLO para o formato QNN para implementação em hardware Qualcomm. O binário de contexto é finalizado para uma arquitetura Hexagon Tensor Processor (HTP) ou um SoC compatível de destino, que selecionas com o argumento name — o mesmo argumento utilizado para direcionar um chip na exportação RKNN.

Destinos HTP compatíveis#

Indica a arquitetura de destino ou o SoC através de name (por exemplo, name="73" ou name="iq-8275"). O suporte é determinado pelo destino HTP, pelo que as linhas Snapdragon abaixo representam plataformas, não uma lista exaustiva de todos os SoCs. Os dispositivos Dragonwing são apresentados 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 destino HTP offline. Ainda é possível integrar separadamente uma exportação ONNX padrão com um fornecedor de execução de CPU ou GPU compatível com o BSP da placa.

from ultralytics import YOLO

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

Instalação#

Para instalares os pacotes necessários, executa:

# Install the required package for YOLO
pip install ultralytics

O pacote onnxruntime-qnn (que fornece o ONNX Runtime QNN Execution Provider e inclui as bibliotecas QAIRT) é instalado automaticamente na primeira exportação. Para obter instruções detalhadas e boas práticas relacionadas com o processo de instalação, consulta o nosso guia de instalação da Ultralytics. Se encontrares dificuldades ao instalar os pacotes necessários para YOLO, consulta o nosso guia de problemas comuns para obteres soluções e sugestões.

Utilização#

O formato QNN suporta os modos Exportar, Prever e Validar. 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 utilizado para a exportação). Exporta o teu modelo e, em seguida, carrega o modelo exportado num dispositivo Snapdragon para executar inferência ou validar a 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 obter mais detalhes sobre o processo de exportação, visita a página da documentação da Ultralytics sobre exportação.

Estrutura de Saída#

Após uma exportação bem-sucedida, é criado um ficheiro ONNX autónomo:

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

Implementação de modelos YOLO QNN exportados#

Os modelos QNN são executados em hardware Qualcomm compatível, tornando simples a implementação de modelos no dispositivo. Num dispositivo compatível com onnxruntime-qnn instalado, executa diretamente o modelo exportado com a API da Ultralytics (yolo predict/yolo val; consulta Utilização acima) — a Ultralytics carrega o binário de contexto HTP através do ONNX Runtime QNN Execution Provider.

Para pipelines personalizados, também podes carregar diretamente o ONNX de contexto binário com o ONNX Runtime. onnxruntime-qnn é um Execution Provider de plug-in, por isso regista-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 é carregada rapidamente sem recompilar o grafo no dispositivo.

Requisitos do Linux e do Yocto BSP#

A placa-alvo tem de disponibilizar um runtime Qualcomm e um BSP mutuamente compatíveis. Para inferência HTP, isto inclui o ONNX Runtime QNN Execution Provider, libQnnSystem.so, libQnnHtp.so, as bibliotecas stub e skeleton HTP v75 para IQ-8275, suporte FastRPC no espaço do utilizador, como libcdsprpc.so, o firmware do DSP e os controladores FastRPC/kernel correspondentes. A biblioteca skeleton tem de ser detetável através do caminho das bibliotecas DSP do BSP.

Estes componentes do lado do alvo provêm do BSP do fabricante da placa com QAIRT/QNN ativado; não estão incorporados no modelo exportado. A execução na GPU requer, em alternativa, libQnnGpu.so e a pilha de controladores do espaço do utilizador Adreno correspondente. O resultado format=qnn da Ultralytics é um binário de contexto específico para HTP, por isso a implementação na GPU ou no CPU deve começar por uma exportação ONNX padrão, em vez do ficheiro pré-compilado *_qnn.onnx.

Fluxo de Trabalho Recomendado#

1. Treina o teu modelo usando o Modo de Treino da Ultralytics
2. Exporta para o formato QNN utilizando model.export(format="qnn", name="iq-8275", imgsz=640) numa plataforma compatível (utiliza imgsz=224 para classificação)
3. Implementa o ficheiro *_qnn.onnx exportado no teu dispositivo Qualcomm
4. Executa a inferência com o ONNX Runtime e o QNN Execution Provider utilizando o backend HTP

Aplicações no mundo real#

Os modelos YOLO executados em hardware Qualcomm Snapdragon são adequados para uma vasta gama de aplicações de IA de edge:

• Smartphones: Deteção de objetos em tempo real e compreensão de cenas em aplicações de câmara e fotografias, com aceleração por NPU.
• Windows em Snapdragon: visão computacional no dispositivo em PCs Copilot+, sem transferir o processamento para a cloud.
• Automóvel: monitorização do condutor, deteção de ocupantes e funcionalidades ADAS em plataformas Snapdragon Digital Chassis.
• XR e dispositivos vestíveis: perceção de baixo consumo e baixa latência para headsets de AR/VR e óculos inteligentes.
• IoT e robótica: inferência de visão eficiente em câmaras, drones e sistemas incorporados com Snapdragon.

Resumo#

Neste guia, aprendeste a exportar localmente modelos YOLO da Ultralytics para o formato Qualcomm QNN com o ONNX Runtime QNN Execution Provider. O pipeline de exportação converte o teu modelo para ONNX e, em seguida, compila-o num binário de contexto QNN na tua máquina anfitriã — sem necessidade de uma conta Qualcomm ou da cloud — produzindo um ficheiro *_qnn.onnx otimizado para hardware Snapdragon CPU, GPU Adreno e NPU Hexagon através do runtime QNN/QAIRT.

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

Para outros destinos de implementação em dispositivos e dispositivos móveis, consulta os guias de exportação relacionados de ONNX, CoreML, NCNN, LiteRT, ExecuTorch, RKNN, Sony IMX500 e TensorRT. Para comparar formatos antes da distribuição, utiliza o modo Benchmark. Para consultar a lista completa de formatos e opções, visita a documentação do modo Export e a página do guia de integrações.

Perguntas frequentes#