Link to this sectionExportação Qualcomm QNN para Modelos Ultralytics YOLO#

Implantar modelos de visão computacional em dispositivos Qualcomm Snapdragon requer um formato de modelo ajustado para o runtime Qualcomm AI Engine Direct (QNN). Exportar modelos Ultralytics YOLO para o formato QNN permite que você execute inferência acelerada no próprio dispositivo em hardwares de CPU Snapdragon, GPU Adreno e NPU Hexagon, presentes em bilhões de celulares, laptops, sistemas automotivos e dispositivos IoT. Este guia percorre como exportar YOLO para Qualcomm QNN e implantá-lo para inferência rápida e de baixo consumo de energia em hardware Snapdragon.

Link to this sectionO que é Qualcomm QNN?#

Qualcomm AI Engine Direct — comumente 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. Ele fornece uma API unificada com bibliotecas específicas de backend que visam a CPU Snapdragon, a GPU Adreno e o Hexagon Tensor Processor (HTP), a unidade de processamento de neural network (NPU) dedicada dentro dos SoCs Snapdragon modernos. O QNN dá aos desenvolvedores acesso full-stack a esses aceleradores de IA Snapdragon e é o sucessor moderno do antigo SDK Snapdragon Neural Processing Engine (SNPE). Ele impulsiona a IA on-device nas plataformas móveis Snapdragon 8 Gen 2, 8 Gen 3 e 8 Elite, notebooks Snapdragon X, e produtos automotivos e de XR.

Link to this sectionPor 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 de NPU Hexagon: Executar YOLO no Hexagon Tensor Processor entrega um throughput 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 QNN quantiza YOLO para pesos INT8 com ativações de 16 bits, o equilíbrio preferido de precisão/desempenho da NPU Hexagon, reduzindo o tamanho do modelo e maximizando 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.

Link to this sectionFormato de Exportação QNN#

Ultralytics compila modelos YOLO para QNN localmente usando o ONNX Runtime QNN Execution Provider (o pacote onnxruntime-qnn instalável via pip, que empacota as bibliotecas 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 cache de contexto binário ativado — isso compila o grafo quantizado em um binário de contexto QNN incorporado em <model>_qnn.onnx. Nenhuma conta da Qualcomm, upload na nuvem ou download separado de SDK é necessário.

Ao contrário do Qualcomm AI Hub baseado na nuvem, que compila e cria perfis de modelos em dispositivos Snapdragon alojados pela Qualcomm e requer uma conta Qualcomm, a exportação QNN do Ultralytics corre 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 alvo de runtime QNN/QAIRT — CPU Snapdragon, GPU Adreno e NPU Hexagon — sem registo, limites de upload ou tempos de fila, e encaixa diretamente no fluxo de trabalho de exportação padrão do YOLO.

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

Link to this sectionPrincipais Recursos dos Modelos QNN#

• Quantização: O modelo é quantizado para ativações de 16 bits e pesos INT8 com o fluxo ONNX Runtime QNN QDQ e um conjunto de dados de calibração, o equilíbrio de precisão/desempenho recomendado da NPU Hexagon. Saiba mais sobre quantização de modelo.
• 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.

Link to this sectionDesempenho Medido#

Link to this sectionSmartphone Android#

Hardware: Xiaomi 17 com 12 GB de memória LPDDR5X e Android 16 / API 36. O seu Snapdragon 8 Elite Gen 5 (SM8850) de 3 nm tem um 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 Speed 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 o mecanismo de benchmark no dispositivo do Flutter plugin's 0.6.10 e os ativos padronizados v0.6.6. A ordem de backend alternou entre tarefas numa varredura sequencial. Os logs nativos confirmaram que cada linha de CPU utilizou o LiteRT CPU/XNNPACK, cada linha de GPU delegou o grafo completo para o LiteRT OpenCL (LITERT_CL), e cada linha de NPU utilizou o backend QNN Hexagon HTP.
• O registo de benchmark detalhado está no Flutter performance doc.
• Compara outros dispositivos Android na LiteRT integration e dispositivos Apple na CoreML integration.

Link to this sectionPortátil Windows on Snapdragon#

Esta varredura histórica utilizou binários QNN v73 pré-padronizados; semântica e OBB utilizaram entradas de 1024px. Correu num portátil Lenovo com 32 GB de memória e Windows 11. O seu Snapdragon X Elite (X1E78100) tem um 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 corre a linha de base de CPU PyTorch FP32 nativa a partir da qual a maioria dos programadores de desktop começam em relação ao caminho ONNX Runtime QNN Hexagon HTP. Cada célula mostra o tempo de execução total model.predict() com os tempos de pré-processamento / inferência / pós-processamento reportados por baixo; o total pode incluir a sobrecarga do framework fora dessas três fases. Os números de CPU são PyTorch FP32 (torch==2.10.0+cpu) e os números de 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 disparo 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 model.predict() em um dispositivo termicamente estável (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.

Link to this sectionTarefas Suportadas#

A exportação QNN suporta o conjunto de tarefas padrão disponível em cada família de modelos, incluindo segmentação semântica YOLO26.

Link to this sectionExportar para QNN: Convertendo seu Modelo YOLO#

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

Link to this sectionArquiteturas HTP Suportadas#

Passe a arquitetura alvo via name (por exemplo, name="73"). Valores válidos:

Link to this sectionInstalação#

Para instalar os pacotes necessários, execute:

# Install the required package for YOLO
pip install ultralytics

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

Link to this sectionUso#

O formato QNN suporta os modos Exportar, Prever e Validar. A inferência e a validação rodam 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, então carregue o modelo exportado em um dispositivo Snapdragon para executar 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), targeting an HTP architecture via 'name'
# 'name' can be one of 68, 69, 73, 75, 79, 81 (Snapdragon 888, 8 Gen 1, 8 Gen 2, 8 Gen 3, 8 Elite, 8 Elite Gen 5)
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")

Link to this sectionArgumentos de Exportação#

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

Link to this sectionEstrutura 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 classe, tamanho de imagem e tarefa em metadata_props do ONNX.

Link to this sectionImplantando Modelos YOLO QNN Exportados#

Modelos QNN rodam em hardware Qualcomm Snapdragon, tornando a implantação de modelo no dispositivo simples. Em um dispositivo Snapdragon com onnxruntime-qnn instalado, execute o modelo exportado diretamente com a API do Ultralytics (yolo predict/yolo val, veja Uso acima) — o Ultralytics carrega o binário de contexto através do ONNX Runtime QNN Execution Provider e seleciona o backend HTP (NPU), GPU ou CPU.

Para pipelines personalizados, você também pode carregar o binário de contexto ONNX diretamente com o ONNX Runtime. onnxruntime-qnn é um Execution Provider de plugin, então 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.

Link to this sectionFluxo de Trabalho Recomendado#

1. Treine seu modelo usando o Modo de Treino do Ultralytics
2. Export para o formato QNN usando model.export(format="qnn", imgsz=640) numa plataforma suportada (usa imgsz=224 para classificação)
3. Implante o arquivo *_qnn.onnx exportado no seu dispositivo Snapdragon
4. Execute a inferência com ONNX Runtime e o QNN Execution Provider, selecionando o backend HTP, GPU ou CPU

Link to this sectionAplicações do Mundo Real#

Modelos YOLO rodando em hardware Qualcomm Snapdragon são bem adequados para uma ampla gama de aplicações de Edge AI:

• Smartphones: Detecção de objetos em tempo real e compreensão de cena em aplicativos de câmera e fotos com aceleração de 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.

Link to this sectionResumo#

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

A combinação do Ultralytics YOLO e da stack 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 implementação em dispositivos móveis e locais, consulta os guias de exportação relacionados ONNX, CoreML, NCNN, LiteRT, ExecuTorch, RKNN, Sony IMX500 e TensorRT. Para comparar formatos antes da implementação, usa o modo Benchmark. Para a lista completa de formatos e opções, visita a documentação do modo Export e a página do guia de integrações.

Link to this sectionFAQ#

Link to this sectionComo exporto meu modelo Ultralytics YOLO para o formato QNN?#

Podes exportar o teu modelo usando export(format="qnn", imgsz=640) (imgsz=224 para classificação) ou os argumentos CLI equivalentes. A exportação cria primeiro um modelo ONNX e depois compila-o localmente num binário de contexto QNN utilizando o ONNX Runtime QNN Execution Provider. O pacote onnxruntime-qnn é instalado automaticamente na primeira exportação.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="qnn", imgsz=640)  # use imgsz=224 for classification

Link to this sectionPreciso de uma conta da Qualcomm ou acesso à nuvem?#

Não. A exportação QNN roda inteiramente na sua máquina local usando o pacote onnxruntime-qnn, que empacota as bibliotecas QAIRT. Nenhuma conta da Qualcomm, token de API ou acesso à rede é necessário.

Link to this sectionComo a exportação QNN do Ultralytics se compara ao Qualcomm AI Hub?#

Qualcomm AI Hub é o serviço de nuvem da Qualcomm para compilar, perfilar e fazer benchmarking de modelos em dispositivos Snapdragon hospedados, e requer uma conta da Qualcomm. A exportação QNN do Ultralytics mira no mesmo runtime QNN/QAIRT (CPU Snapdragon, GPU Adreno e NPU Hexagon), mas compila o binário de contexto localmente com o ONNX Runtime QNN Execution Provider — sem conta, sem upload e sem fila. É a maneira mais rápida de ir de um modelo .pt para uma build pronta para Snapdragon diretamente dentro do fluxo de trabalho padrão de exportação do YOLO.

Link to this sectionEm quais plataformas posso exportar?#

onnxruntime-qnn fornece wheels pré-construídos para Windows (x64 e ARM64) e Linux ARM64 (aarch64); no Linux x86-64, compile o ONNX Runtime a partir da fonte com --use_qnn (nenhum wheel pré-construído é publicado, e macOS não é um host QNN suportado). A geração de binário de contexto roda em um host x64 — Windows x64 ou Linux x86-64 — e não requer um dispositivo Snapdragon físico.

Link to this sectionComo executo YOLO em uma NPU Qualcomm Snapdragon?#

Exporta com model.export(format="qnn", imgsz=640) (imgsz=224 para classificação), copia o ficheiro yolo26n_qnn.onnx resultante para o teu dispositivo Snapdragon e corre yolo predict model=yolo26n_qnn.onnx source=image.jpg (ou yolo val). O Ultralytics carrega o binário de contexto através do ONNX Runtime QNN Execution Provider e executa-o na NPU Hexagon — consulta Deploying Exported YOLO QNN Models.

Link to this sectionQual é a diferença entre QNN e SNPE?#

QNN (Qualcomm AI Engine Direct, parte do SDK QAIRT) é a stack de inferência atual da Qualcomm e a substituição recomendada para o antigo SDK Snapdragon Neural Processing Engine (SNPE). Novas implantações devem focar no QNN.

Link to this sectionPosso executar um modelo QNN com yolo predict e yolo val?#

Sim, em um dispositivo Qualcomm Snapdragon com onnxruntime-qnn instalado — YOLO("yolo26n_qnn.onnx") carrega o binário de contexto através do QNN Execution Provider e executa predict/val como qualquer outro formato. Em um host x86 sem hardware QNN, o modelo não pode ser executado, uma vez que o binário de contexto visa a NPU Snapdragon.

Link to this sectionQual é a saída de uma exportação QNN?#

A exportação cria um arquivo ONNX de binário de contexto autossuficiente (por exemplo, yolo26n_qnn.onnx) com nomes de classe, tamanho de imagem, tarefa e outros metadados do modelo incorporados em metadata_props do ONNX.