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.

Diferente do Qualcomm AI Hub baseado em nuvem, que compila e perfila modelos em dispositivos Snapdragon hospedados pela Qualcomm e requer uma conta da Qualcomm, a exportação QNN do Ultralytics roda inteiramente na sua própria máquina com uma única chamada export(format="qnn"). Você obtém o mesmo alvo de runtime QNN/QAIRT — CPU Snapdragon, GPU Adreno e NPU Hexagon — sem necessidade de registro, limites de upload ou tempos de fila, e ele se integra diretamente ao 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#

Inferência de imagem única de ponta a ponta para os modelos oficiais YOLO26n em um telefone Xiaomi 17 equipado com o Qualcomm Snapdragon 8 Elite Gen 5 (SM8850) — CPU Qualcomm Oryon, GPU Adreno e NPU Hexagon (HTP v81). Cada célula mostra o tempo total (pré-processamento + inferência + pós-processamento, excluindo a anotação) com a divisão por estágio abaixo. CPU e GPU executam TFLite INT8 via LiteRT; a NPU executa binários de contexto QNN (pesos INT8, ativações de 16 bits).

• Os valores de Speed são latências de disparo de imagem única — a média de 15 execuções após 3 execuções de aquecimento em bus.jpg, medidas com o plugin do Flutter de benchmark no dispositivo em um aparelho termicamente estável. Os tempos de quadro da câmera em tempo real sustentados são maiores (letterboxing de captura por quadro mais estabilização térmica); use o detalhamento de pré/inferência/pós na tela do aplicativo para obter números de estado estacionário no seu dispositivo.
• Esta tabela é mantida como um snapshot de comparação do QNN. Os números atuais de CPU/GPU do Android LiteRT medidos com o ultralytics_yolo 0.6.8 estão na integração LiteRT, e o registro detalhado de benchmark está no documento de desempenho do Flutter.
• ¹ O QNN semântico usa a saída de mapa de classe ArgMax dentro do grafo desta versão, que substituiu a decodificação errática de 123-1065 ms de logits por estáveis ~49 ms; a GPU permanece ligeiramente mais rápida para semântica em 1024px.

Link to this sectionPortátil Windows on Snapdragon#

Inferência de imagem única ponta a ponta para os modelos oficiais YOLO26n num portátil Lenovo equipado com Qualcomm Snapdragon X Elite (X1E78100) — CPU Qualcomm Oryon e Hexagon NPU (HTP v73), 32 GB RAM, Windows 11. Esta comparação de Windows-on-Snapdragon executa a base de referência PyTorch FP32 CPU nativa que a maioria dos programadores de desktop utiliza contra o caminho QNN Hexagon NPU. Cada célula mostra o tempo total de model.predict() com os tempos reportados de pré-processamento / inferência / pós-processamento abaixo; o total pode incluir a sobrecarga da framework fora destas três fases. Os números de CPU referem-se a PyTorch FP32 (torch==2.10.0+cpu) e os números de NPU referem-se a 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")  # creates 'yolo26n_qnn.onnx'

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)
outputs = session.run(None, {"images": input_tensor})  # input_tensor: float32 NCHW

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. Exporte para o formato QNN usando model.export(format="qnn") em uma plataforma suportada (Windows x64 ou ARM64, ou Linux ARM64)
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?#

Você pode exportar seu modelo usando o método export() em Python ou via CLI com format="qnn". A exportação primeiro cria um modelo ONNX, depois o compila localmente em um binário de contexto QNN usando 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")

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

Exporte com model.export(format="qnn"), copie o arquivo yolo26n_qnn.onnx resultante para seu dispositivo Snapdragon e execute 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 o executa na NPU Hexagon — veja Implantando Modelos YOLO QNN Exportados.

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.