Exportação Qualcomm QNN para modelos Ultralytics YOLO#

A implementação de modelos de visão computacional em dispositivos Qualcomm Snapdragon exige um formato de modelo ajustado ao ambiente de execução Qualcomm AI Engine Direct (QNN). Exportar modelos Ultralytics YOLO para o formato QNN permite executar inferência acelerada no próprio dispositivo, em hardware de 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 de energia em hardware Snapdragon.

O que é Qualcomm QNN?#

O Qualcomm AI Engine Direct — normalmente designado por QNN e distribuído como parte do SDK Qualcomm AI Runtime (QAIRT) — é a pilha de inferência de baixo nível da Qualcomm para processadores Snapdragon. Fornece uma API unificada com bibliotecas específicas para cada backend, destinadas à CPU Snapdragon, à GPU Adreno e ao processador tensorial Hexagon (HTP), a unidade de processamento de redes neurais (NPU) dedicada existente nos SoCs Snapdragon modernos. O QNN dá aos programadores acesso de pilha completa a estes aceleradores de IA Snapdragon e é o sucessor moderno do antigo SDK Snapdragon Neural Processing Engine (SNPE). Alimenta a 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.

Por que exportar para Qualcomm QNN?#

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

• Aceleração da NPU Hexagon: Executar YOLO no processador tensorial Hexagon proporciona um rendimento muito superior e um consumo de energia inferior à inferência na CPU — ideal para inferência em tempo real e visão computacional sempre ativa em dispositivos Snapdragon.
• No dispositivo e offline: A inferência QNN é executada inteiramente no dispositivo Snapdragon, sem comunicação de ida e volta com a nuvem; 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 entre precisão e desempenho preferido pela NPU Hexagon, reduzindo o tamanho do modelo e maximizando os fotogramas por segundo em hardware alimentado por bateria.
• Um formato, muitos dispositivos: Uma única exportação Qualcomm QNN destina-se à CPU Snapdragon, à GPU Adreno e à NPU Hexagon nas famílias Snapdragon 8 Gen 2, 8 Gen 3 e 8 Elite, e posteriores.
• Pilha de IA Qualcomm pronta para produção: QNN (Qualcomm AI Engine Direct / QAIRT) é o ambiente de execução de IA no dispositivo atual da Qualcomm, mantido ativamente e recomendado como substituto do SNPE.

Formato de exportação QNN#

A Ultralytics compila modelos YOLO para QNN localmente com o ONNX Runtime QNN Execution Provider (o pacote onnxruntime-qnn, instalável com pip, que inclui as bibliotecas QAIRT). O exportador converte o modelo para ONNX, quantiza-o com dados de calibração para obter 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 — esta operação compila o grafo quantizado num binário de contexto QNN incorporado em <model>_qnn.onnx. Não é necessária uma conta Qualcomm, o carregamento de dados para a nuvem nem uma transferência separada do SDK.

Ao contrário do Qualcomm AI Hub, baseado na nuvem, que compila e cria perfis de modelos em dispositivos Snapdragon alojados pela Qualcomm e exige 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 execução QNN/QAIRT — CPU Snapdragon, GPU Adreno e NPU Hexagon — sem registo, limites de carregamento ou tempos de espera na fila, e a exportação integra-se diretamente no fluxo de trabalho padrão de exportação YOLO.

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

Principais funcionalidades dos modelos QNN#

• Quantização: O modelo é quantizado para ativações de 16 bits e pesos INT8 com o fluxo QDQ QNN do ONNX Runtime e um conjunto de dados de calibração, o equilíbrio entre precisão e desempenho recomendado para a 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 nuvem.
• Aceleração completa do Snapdragon: Executa inferência na NPU Hexagon (HTP), na GPU Adreno ou na CPU através de um único ambiente de execução unificado.
• Ampla compatibilidade com dispositivos: Destina-te à vasta gama de plataformas Snapdragon presentes em telemóveis, PCs (Windows on Snapdragon), produtos automóveis, XR e sistemas integrados.
• Binário de contexto pré-compilado: A distribuição de 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 facilitar a implementação.

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) tem 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 rajada para uma única imagem — a média de 15 execuções após 3 execuções de aquecimento em bus.jpg, medidas com o sistema de referência no dispositivo 0.6.10 do plugin Flutter e os recursos padronizados v0.6.6. 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 ao LiteRT OpenCL (LITERT_CL) e todas as linhas da NPU utilizaram o backend QNN Hexagon HTP.
• O registo detalhado da avaliação de desempenho 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 avaliação histórica utilizou binários QNN v73 anteriores à padronização; as tarefas semântica e 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) tem uma CPU Qualcomm Oryon de 12 núcleos, GPU Adreno e NPU Hexagon (HTP v73); o modelo exato do Lenovo não foi registado. Esta comparação Windows on Snapdragon avalia a referência de CPU nativa PyTorch FP32, que é o ponto de partida da maioria dos programadores de computadores de secretária, em relação ao percurso ONNX Runtime QNN Hexagon HTP. Cada célula apresenta o tempo total decorrido de model.predict() com os tempos de pré-processamento / inferência / pós-processamento indicados abaixo; o total pode incluir sobrecarga da framework que não esteja incluída nestas 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 Speed 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 resfriado (ultralytics==8.4.67, Python 3.12.10).
• O NPU Hexagon é aproximadamente 2-4x mais rápido do que a linha de base da CPU PyTorch nas tarefas de 640-1024 px (detecção ~3.4x), chegando a ~1.3x no classificador de 224 px, em que a sobrecarga fixa de pré-processamento predomina sobre a pequena carga de trabalho.

Tarefas suportadas#

A exportação Qualcomm QNN é compatível com 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.

Exportação para QNN: convertendo seu modelo YOLO#

Exporte um modelo Ultralytics YOLO para o formato QNN e implante-o em hardware Qualcomm. O binário de contexto é finalizado para uma arquitetura de processador Tensor Hexagon (HTP) ou SoC compatível, que você seleciona com o argumento name — o mesmo argumento usado para escolher um chip na exportação RKNN.

Destinos HTP compatíveis#

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

O Dragonwing IQ-615 não pode usar a exportação de binário de contexto QNN da Ultralytics porque o ONNX Runtime não expõe seu DSP v66 como destino HTP offline. Uma exportação ONNX padrão ainda pode ser integrada separadamente com um provedor 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 instalar os pacotes necessários, executa:

# Install the required package for YOLO
pip install ultralytics

O pacote onnxruntime-qnn (que fornece o provedor de execução QNN do ONNX Runtime e inclui as bibliotecas QAIRT) é instalado automaticamente na primeira exportação. Para ver instruções detalhadas e práticas recomendadas para o processo de instalação, consulte nosso guia de instalação da Ultralytics. Se encontrar dificuldades ao instalar os pacotes necessários para YOLO, consulte nosso guia de problemas comuns para ver soluções e dicas.

Uso#

O formato QNN é compatível com os modos Export, Predict e Validate. A inferência e a validação são executadas em hardware Qualcomm Snapdragon por meio do provedor de execução QNN do ONNX Runtime (o mesmo pacote onnxruntime-qnn usado na 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

# Carrega um modelo YOLO26
model = YOLO("yolo26n.pt")

# Exportar para o formato Qualcomm QNN (INT8, ativado automaticamente) para o destino HTP v73 padrão
model.export(format="qnn", name="73", imgsz=640)  # usar imgsz=224 para classificação

from ultralytics import YOLO

# Carregar o modelo QNN exportado (em um dispositivo Snapdragon com onnxruntime-qnn)
model = YOLO("yolo26n_qnn.onnx")

# Executar inferência
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carregar o modelo QNN exportado (em um dispositivo Snapdragon com onnxruntime-qnn)
model = YOLO("yolo26n_qnn.onnx")

# Validar a precisão no conjunto de dados COCO8
metrics = model.val(data="coco8.yaml")

Argumentos de exportação#

Para 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 arquivo ONNX autocontido:

O arquivo yolo26n_qnn.onnx incorpora o binário de contexto QNN e é carregado pelo ONNX Runtime com o provedor de execução QNN no dispositivo Snapdragon. Ele também inclui metadados do modelo, como nomes de classe, tamanho da imagem e tarefa, em ONNX metadata_props.

Implantação de modelos YOLO QNN exportados#

Os modelos QNN são executados em hardware Qualcomm compatível, facilitando a implantação de modelos no dispositivo. Em um dispositivo compatível com onnxruntime-qnn instalado, execute o modelo exportado diretamente com a API da Ultralytics (yolo predict/yolo val; consulte Uso acima) — a Ultralytics carrega o binário de contexto HTP por meio do provedor de execução QNN do ONNX Runtime.

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

import onnxruntime as ort
import onnxruntime_qnn as qnn_ep

# No dispositivo Snapdragon, registre o provedor de execução (EP) do plug-in QNN e selecione seus dispositivos
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 BSP Yocto#

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

Esses componentes do dispositivo de destino são fornecidos pelo BSP do fabricante da placa, com QAIRT/QNN habilitado; eles não são incorporados ao modelo exportado. Já a execução na GPU requer libQnnGpu.so e a pilha de drivers de espaço de usuário Adreno correspondente. A saída format=qnn da Ultralytics é um binário de contexto específico para HTP; portanto, a implantação em GPU ou CPU deve começar com uma exportação ONNX padrão, e não com o arquivo *_qnn.onnx pré-compilado.

Fluxo de trabalho recomendado#

1. Treina o teu modelo com o Modo de Treino da Ultralytics
2. Exporte para o formato QNN usando model.export(format="qnn", name="iq-8275", imgsz=640) em uma plataforma compatível (use imgsz=224 para classificação)
3. Implante o arquivo *_qnn.onnx exportado no seu dispositivo Qualcomm
4. Execute a inferência com o ONNX Runtime e o provedor de execução QNN usando o backend HTP

Aplicações no mundo real#

Os modelos YOLO executados em hardware Qualcomm Snapdragon são ideais para uma ampla variedade 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 do NPU.
• Windows em Snapdragon: visão computacional no dispositivo em PCs Copilot+ sem transferir o processamento para a nuvem.
• Automotivo: monitoramento do motorista, detecção de ocupantes e recursos de ADAS em plataformas Snapdragon Digital Chassis.
• XR e dispositivos vestíveis: percepção de baixo consumo e baixa latência para headsets AR/VR e óculos inteligentes.
• IoT e robótica: inferência visual eficiente em câmeras, drones e sistemas embarcados com tecnologia Snapdragon.

Resumo#

Neste guia, você aprendeu a exportar localmente modelos Ultralytics YOLO para o formato Qualcomm QNN usando o provedor de execução QNN do ONNX Runtime. O pipeline de exportação converte seu modelo para ONNX e, em seguida, compila-o em um binário de contexto QNN na sua máquina host — sem exigir uma conta Qualcomm nem acesso à nuvem — e gera um arquivo *_qnn.onnx otimizado para hardware CPU Snapdragon, GPU Adreno e NPU Hexagon por meio do runtime QNN/QAIRT.

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

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

Perguntas frequentes#