Exportação Qualcomm QNN para Modelos Ultralytics YOLO

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

O que é Qualcomm QNN?

Qualcomm AI Engine Direct — comumente referido como 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. 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 rede neural (NPU) dedicada dentro dos SoCs Snapdragon modernos. O QNN dá aos desenvolvedores acesso de pilha completa a esses aceleradores de IA Snapdragon e é o sucessor moderno do antigo SDK Snapdragon Neural Processing Engine (SNPE). Ele impulsiona 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 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 de NPU Hexagon: Executar YOLO no Hexagon Tensor Processor entrega um throughput drasticamente maior e menor consumo de energia do que a inferência de CPU — ideal para inferência em tempo real e visão computacional sempre ativa no Snapdragon.
• No dispositivo e offline: A inferência QNN é executada 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 deixam o dispositivo.
• Eficiência INT8: A exportação QNN quantiza YOLO para INT8, a precisão nativa 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 CPU Snapdragon, GPU Adreno e NPU Hexagon nas famílias Snapdragon 8 Gen 2, 8 Gen 3, 8 Elite e além.
• Pilha de IA Qualcomm pronta para produção: QNN (Qualcomm AI Engine Direct / QAIRT) é o runtime de IA no dispositivo atual e ativamente mantido da Qualcomm, e o substituto recomendado para o SNPE.

Formato de Exportação QNN

A Ultralytics compila modelos YOLO para QNN localmente usando o provedor de execução ONNX Runtime QNN (o pacote onnxruntime-qnn instalável via pip, que empacota as bibliotecas QAIRT). O exportador converte seu modelo para ONNX, quantiza-o em INT8 com dados de calibração (a NPU Hexagon é um acelerador int8), então inicializa uma sessão do ONNX Runtime com cache de binário de contexto ativado — isso compila o gráfico quantizado em um binário de contexto QNN embutido em <model>_qnn.onnx. Nenhuma conta 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 Qualcomm, a exportação QNN da Ultralytics é executada 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 registro, limites de upload ou tempos de fila, e ele cai diretamente no fluxo de trabalho de exportação padrão do YOLO.

O diretório _qnn_model/ exportado agrupa o binário de contexto ONNX e um metadata.yaml descrevendo nomes de classes, tamanho da imagem e tarefa.

Principais recursos dos modelos QNN

• Quantização INT8: O modelo é quantizado para INT8 com o fluxo QDQ do ONNX Runtime QNN e um conjunto de dados de calibração, combinando a precisão nativa da NPU Hexagon para throughput máximo e tamanho mínimo. Saiba mais sobre quantização de modelos.
• Compilação totalmente local: O binário de contexto é gerado inteiramente na sua máquina host — sem conta Qualcomm, token de API ou upload na nuvem.
• Aceleração Snapdragon total: 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), automotivo, XR e produtos embarcados.
• Binário de contexto pré-compilado: Enviar um binário de contexto minimiza a compilação do gráfico no dispositivo, reduzindo a latência de carregamento do modelo no destino.
• Saída autônoma: O diretório exportado inclui o binário de contexto ONNX e metadados para uma implantação direta.

Tarefas Suportadas

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

Exportar 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 destino Hexagon Tensor Processor (HTP), que você seleciona com o argumento name — o mesmo argumento usado para definir um chip na exportação RKNN.

Arquiteturas HTP suportadas

Passe a arquitetura de destino via name (ex: name="73"). Valores válidos:

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 provedor de execução ONNX Runtime QNN e agrupa 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 do Ultralytics. Ao instalar os pacotes necessários para YOLO, se você encontrar alguma dificuldade, consulte nosso guia de Problemas Comuns para soluções e dicas.

Uso

O formato QNN suporta os modos Export, Predict e Validate. A inferência e a validação são executadas em hardware Qualcomm Snapdragon através do provedor de execução QNN do ONNX Runtime (o mesmo pacote onnxruntime-qnn usado para exportação). Exporte seu modelo, depois 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 (Snapdragon 865, 888/8 Gen 1, 8 Gen 2, 8 Gen 3, 8 Elite)
model.export(format="qnn", name="73")  # creates 'yolo26n_qnn_model/'

from ultralytics import YOLO

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

# 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_model")

# 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, visite a página de documentação do Ultralytics sobre exportação.

Estrutura de Saída

Após uma exportação bem-sucedida, um diretório de modelo é criado com o seguinte layout:

yolo26n_qnn_model/
├── yolo26n_qnn.onnx   # ONNX wrapping the precompiled QNN context binary
└── metadata.yaml      # Model metadata (classes, image size, task, etc.)

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. O metadata.yaml contém nomes de classes, tamanho da imagem e outras informações usadas pelo pipeline Ultralytics.

Implantando Modelos YOLO QNN Exportados

Modelos QNN são executados 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 Provedor de Execução ONNX Runtime QNN 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 provedor de execução 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_model/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 gráfico no dispositivo.

Fluxo de Trabalho Recomendado

1. Treine seu modelo usando o Modo de Treino da Ultralytics
2. Exporte para o formato QNN usando model.export(format="qnn") em uma plataforma suportada (Windows ou Linux ARM64)
3. Implante o diretório _qnn_model/ exportado no seu dispositivo Snapdragon
4. Execute inferência com o ONNX Runtime e o provedor de execução QNN, selecionando o backend HTP, GPU ou CPU

Aplicações no Mundo Real

Modelos YOLO executados 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 foto com aceleração NPU.
• Windows no Snapdragon: Visão computacional no dispositivo em PCs Copilot+ sem descarregar para a nuvem.
• Automotivo: Monitoramento de 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 equipados com Snapdragon.

Resumo

Neste guia, você aprendeu como exportar modelos Ultralytics YOLO para o formato Qualcomm QNN localmente com o provedor de execução ONNX Runtime QNN. 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 conta Qualcomm ou nuvem necessária — produzindo um _qnn.onnx otimizado para hardware de CPU Snapdragon, GPU Adreno e NPU Hexagon via runtime QNN/QAIRT.

A combinação de Ultralytics YOLO e a 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 alvos de implantação móvel e no dispositivo, veja os guias relacionados de exportação ONNX, CoreML, NCNN, TFLite, ExecuTorch, RKNN, Sony IMX500 e TensorRT. Para comparar formatos antes de enviar, use o modo Benchmark. Para 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

Como 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 provedor de execução ONNX Runtime QNN. O pacote onnxruntime-qnn é instalado automaticamente na primeira exportação.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="qnn")

Preciso de uma conta Qualcomm ou acesso à nuvem?

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

Como a exportação QNN da Ultralytics se compara ao Qualcomm AI Hub?

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

Em quais plataformas posso exportar?

onnxruntime-qnn fornece rodas estáveis para Windows (x64 e ARM64) e Linux ARM64 (aarch64), além de uma roda Linux x86-64 no feed noturno do ONNX Runtime. O macOS não tem roda — compile o ONNX Runtime a partir da fonte com --use_qnn ou exporte em uma plataforma suportada. A geração de binário de contexto é executada em um host x64 e não requer um dispositivo Snapdragon físico.

Como executo o YOLO em uma NPU Qualcomm Snapdragon?

Exporte com model.export(format="qnn"), copie o diretório yolo26n_qnn_model resultante para seu dispositivo Snapdragon e execute yolo predict model=yolo26n_qnn_model source=image.jpg (ou yolo val). O Ultralytics carrega o binário de contexto através do Provedor de Execução ONNX Runtime QNN e o executa na NPU Hexagon — veja Implantando Modelos YOLO QNN Exportados.

Qual é a diferença entre QNN e SNPE?

QNN (Qualcomm AI Engine Direct, parte do SDK QAIRT) é a pilha de inferência atual da Qualcomm e o substituto recomendado para o antigo SDK Snapdragon Neural Processing Engine (SNPE). Novas implantações devem ter o QNN como alvo.

Posso executar um modelo QNN com yolo predict e yolo val?

Sim, em um dispositivo Qualcomm Snapdragon com onnxruntime-qnn instalado — YOLO("yolo26n_qnn_model") carrega o binário de contexto através do Provedor de Execução QNN e executa predict/val como qualquer outro formato. Em um host x86 sem hardware QNN, o modelo não pode ser executado, já que o binário de contexto tem como alvo a NPU Snapdragon.

Qual é a saída de uma exportação QNN?

A exportação cria um diretório (por exemplo, yolo26n_qnn_model/) contendo o binário de contexto ONNX (yolo26n_qnn.onnx) e um metadata.yaml com nomes de classes, tamanho da imagem e informações de tarefa.