Exportação para Google LiteRT
LiteRT é o runtime do Google para IA no dispositivo e o novo nome do TensorFlow Lite (TFLite). Exportar um modelo Ultralytics YOLO26 com format="litert" cria um único ficheiro .tflite para telemóveis Android e iOS, placas Linux integradas e navegadores, em FP32 ou com um de três esquemas de quantização INT8.
Visão geral#
| Propriedade | Detalhes |
|---|---|
Argumento format | litert. Os valores mais antigos tflite e tfjs continuam a funcionar: registam um aviso de descontinuação e exportam o mesmo ficheiro LiteRT |
| Saída | yolo26n.tflite, um ficheiro com os nomes das classes, a tarefa e o tamanho da imagem armazenados como metadados; as exportações quantizadas recebem os nomes yolo26n_w8a32.tflite, yolo26n_int8.tflite e yolo26n_w8a16.tflite |
| Funciona em | Dispositivos Android e iOS, placas Linux integradas, CPUs de computadores de secretária, navegadores através do LiteRT.js e GPUs e NPUs Intel |
| Ambiente de execução | LiteRT: o pacote Python ai-edge-litert (2.1.4 ou posterior), as bibliotecas LiteRT para Android e iOS ou LiteRT.js |
| Precisão | FP32, w8a32, INT8, w8a16. O YOLO26n tem 10.0 MB em FP32, 2.9 MB com w8a32, 3.1 MB em INT8 e 3.0 MB com w8a16 |
| Máquina de exportação | Linux x86-64 ou macOS em Apple silicon, com Python 3.10 ou posterior. A exportação é executada na CPU e não precisa de GPU |
A Ultralytics Platform pode exportar um modelo treinado para LiteRT por ti, por isso não precisas de um ambiente de exportação local.
Início rápido#
Instala o pacote Ultralytics com as dependências de exportação do LiteRT:
pip install "ultralytics[export-litert]"Isto instala litert-torch, ai-edge-litert e ai-edge-quantizer. Com um pip install ultralytics simples, a primeira exportação instala os pacotes em falta e pode parar com um erro se isso substituir o PyTorch. A exportação tem estes requisitos de versão:
| Pacote | Versão necessária |
|---|---|
| Python | 3.10 ou posterior |
litert-torch | 0.10.0 ou posterior |
torch | O intervalo aceite pelo litert-torch instalado: 2.4.0 ou posterior e anterior a 2.15.0 para 0.10.0 |
ai-edge-litert | 2.3.0 ou posterior para exportar; 2.1.4 ou posterior, também em Python 3.10 ou posterior, para executar um modelo exportado |
ai-edge-quantizer | 0.10.0 ou posterior, para quantize="w8a32", quantize=8 e "w8a16" |
Para outros métodos de instalação, consulta o guia de instalação. Depois, exporta o teu modelo e carrega o ficheiro exportado para executar inferência ou validar a sua precisão.
from ultralytics import YOLO
# Carrega um modelo YOLO26
model = YOLO("yolo26n.pt")
# Exporte o modelo para o formato LiteRT
model.export(format="litert") # cria 'yolo26n.tflite'
# Exporta com pesos INT8 e ativações FP32, sem precisar de dados de calibração
model.export(format="litert", quantize="w8a32") # cria 'yolo26n_w8a32.tflite'from ultralytics import YOLO
# Carregue o modelo LiteRT exportado
model = YOLO("yolo26n.tflite")
# Executar inferência
results = model("https://ultralytics.com/images/bus.jpg")from ultralytics import YOLO
# Carregue o modelo LiteRT exportado
model = YOLO("yolo26n.tflite")
# Validar a precisão no conjunto de dados COCO8
metrics = model.val(data="coco8.yaml")Tarefas suportadas#
A exportação LiteRT suporta as sete tarefas da Ultralytics com modelos YOLOv8, YOLO11 e YOLO26: deteção, segmentação, segmentação semântica, estimativa de profundidade, classificação, estimativa de pose e OBB. 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.
Argumentos de exportação#
| Argumento | Tipo | Padrão | Descrição |
|---|---|---|---|
format | str | 'litert' | Formato de destino do modelo exportado, que define a compatibilidade com vários ambientes de implantação. |
imgsz | int ou tuple | 640 | Tamanho da imagem de entrada do modelo: um número inteiro para imagens quadradas ou uma tupla (height, width). Se não for especificado, a exportação usa o tamanho com que o checkpoint foi treinado. Os checkpoints oficiais do YOLO26 usam 640 para modelos de detecção, segmentação e pose, bem como para modelos semânticos pré-treinados no ADE20K; 1024 para modelos OBB e modelos semânticos pré-treinados no Cityscapes; 768 para profundidade; e 224 para classificação. |
quantize | int ou str | None | Esquema de quantização: 'w8a32' (pesos INT8, ativações FP32, sem calibração), 8 (pesos e ativações INT8, calibrados com data) ou 'w8a16' (pesos INT8, ativações INT16, calibrados com data); 32/não definido corresponde a FP32. 16 gera um erro, e um checkpoint treinado com quantize=8 não pode ser exportado para LiteRT; consulta Limitações e resolução de problemas. Substitui as opções descontinuadas half/int8. |
data | str | None | Ficheiro YAML do conjunto de dados usado para a calibração com quantize=8 e 'w8a16'; para a classificação, em vez disso, aceita um diretório do conjunto de dados ou o nome de um conjunto de dados integrado. A calibração usa a divisão val, a menos que split esteja definido. Se não for especificada, a Ultralytics usa o conjunto de dados predefinido pequeno para a tarefa do modelo, como coco8.yaml para deteção. |
fraction | float, int ou list | 1.0 | Subconjunto de calibração: uma proporção, um número de imagens (números inteiros acima de 1) ou uma lista [train, val, test], da qual é usada a entrada da divisão de calibração. |
nms | bool, opcional | None | Seleciona a saída em bruto (None, predefinição) ou a cabeça sem NMS (False, apenas para exportações FP32 e 'w8a32'). A NMS incorporada (True) não está disponível no LiteRT. Consulta o formato de saída. |
batch | int | 1 | Tamanho do lote do modelo exportado, fixo na forma da entrada. É também o tamanho do lote usado na calibração. |
device | str | None | A exportação é sempre executada na CPU, independentemente do valor passado. |
Para consultar os argumentos compartilhados por todos os formatos, veja a documentação do modo de exportação.
Quantização#
quantize seleciona um de três esquemas INT8. Todos armazenam os pesos como números inteiros de 8 bits e diferem na forma como armazenam as ativações, os valores que fluem entre camadas:
quantize | Pesos | Ativações | Dados de calibração | Arquivo YOLO26n | Tamanho |
|---|---|---|---|---|---|
omitido ou 32 | FP32 | FP32 | Não | yolo26n.tflite | 10.0 MB |
'w8a32' | INT8 | FP32 | Não | yolo26n_w8a32.tflite | 2.9 MB |
8 | INT8 | INT8 | Sim | yolo26n_int8.tflite | 3.1 MB |
'w8a16' | INT8 | INT16 | Sim | yolo26n_w8a16.tflite | 3.0 MB |
- Entradas e saídas: a entrada e as saídas mantêm-se como
float32em todas as quatro precisões, por isso o código de inferência escrito para o modelo FP32 executa sem alterações um modelo quantizado exportado com a mesma disposiçãonms. 'w8a32': quantização de intervalo dinâmico. Não precisa de dados de calibração e suporta a cabeça sem NMS comnms=False; é também a precisão dos modelos móveis oficiais nas colunas de CPU e GPU em Desempenho medido.8e'w8a16': quantização estática. A exportação calibra com todos os lotes completos da divisãovaldedata, ou da divisão definida comsplit, e apresenta um aviso com menos de 300 imagens. Usafractionpara limitar o número de imagens.- Saídas da cabeça com
quantize=8: nos modelos de deteção, segmentação, classificação, pose e OBB, as camadas de saída da cabeça e as operações que as descodificam permanecem em ponto flutuante, porque o INT8 limita as pontuações das classes e reduz a precisão das coordenadas das caixas.'w8a16'também quantiza essas camadas, usando ativações de 16 bits. - Cabeça sem NMS: as exportações
quantize=8e'w8a16'de um modelo YOLO26 ou YOLOv10 usam a cabeça um-para-muitos e devolvem previsões em bruto que precisam de NMS, também comnms=False. - FP16: não existe exportação FP16. Por predefinição, os delegados GPU do LiteRT executam um modelo FP32 em precisão de meia, por isso
quantize=16não é necessário e gera um erro.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
# Calibrar com 10% das imagens de validação COCO (500 imagens); substitua coco.yaml pelo seu próprio conjunto de dados
model.export(format="litert", quantize=8, data="coco.yaml", fraction=0.1) # cria 'yolo26n_int8.tflite'
# Carregar o modelo INT8 exportado e executar inferência
model = YOLO("yolo26n_int8.tflite")
results = model("https://ultralytics.com/images/bus.jpg")A quantização altera a precisão, e o efeito depende do modelo, da tarefa e das imagens de calibração. Valida um modelo quantizado com os teus próprios dados antes de o implementar.
Formato de saída#
A exportação grava um único ficheiro .tflite. O modelo recebe uma entrada com a forma (batch, 3, height, width): RGB, canais primeiro (NCHW), float32, escalada para 0-1. Isto difere dos ficheiros TFLite da exportação anterior format="tflite", que recebiam imagens com canais por último (NHWC). O argumento nms e a tarefa determinam as saídas. As formas abaixo correspondem aos checkpoints YOLO26n oficiais com o tamanho de exportação predefinido, usando o checkpoint Cityscapes yolo26n-sem.pt para segmentação semântica:
| Tarefa | imgsz padrão | Saída com nms=None | Saída com nms=False |
|---|---|---|---|
| Detecção | 640 | (1, 84, 8400) | (1, 300, 6) |
| Segmentação | 640 | (1, 116, 8400) e (1, 32, 160, 160) | (1, 300, 38) e (1, 32, 160, 160) |
| Semântica | 1024 | (1, 19, 1024, 1024), uma pontuação para cada classe e píxel | Igual a nms=None |
| Profundidade | 768 | (1, 1, 768, 768), mapa de profundidade | Igual a nms=None |
| Classificação | 224 | (1, 1000), probabilidades das classes | Igual a nms=None |
| Pose | 640 | (1, 56, 8400) | (1, 300, 57): 6 valores da caixa, seguidos de 17 pontos-chave x 3 |
| OBB | 1024 | (1, 20, 21504) | (1, 300, 7): 4 valores da caixa, pontuação, classe, ângulo |
- Saída em bruto (
nms=None): forma(batch, values, anchors). Para cada âncora: o centro x da caixa, o centro y, a largura e a altura; depois, as pontuações das classes; por fim, os valores da tarefa (32 coeficientes de máscara, 17 valores de pontos-chave x 3 ou o ângulo OBB em radianos). Os valores da caixa e as coordenadas x e y dos pontos-chave são normalizados para 0-1, por isso multiplica-os pela largura e altura da entrada. Aplica a NMS por tua conta. - Saída sem NMS (
nms=False):max_det(300 por predefinição) linhas dex1, y1, x2, y2, score, classem píxeis de entrada, sem etapa de NMS. As linhas OBB sãocenter x, center y, width, height, score, class, angle, com o ângulo em radianos. Filtra as linhas pela pontuação. Disponível para exportações FP32 e'w8a32'de modelos com uma cabeça sem NMS. - Segmentação: os 32 coeficientes de máscara são os últimos 32 valores de cada âncora ou linha, e a segunda saída contém os protótipos da máscara.
- Segmentação semântica: a saída contém pontuações das classes, não o mapa de classes da exportação ONNX; por isso, calcula o argmax no eixo das classes no teu próprio código.
YOLO("yolo26n.tflite") lê a disposição dos metadados do ficheiro e escala as coordenadas, por isso só precisas destes detalhes quando executas o modelo no teu próprio código. Os metadados são uma entrada metadata.json que a exportação acrescenta ao ficheiro como arquivo ZIP, legível com qualquer biblioteca ZIP. As chaves incluem names, task, imgsz, stride, batch, end2end, args e, para modelos de pose, kpt_shape.
Executar com o interpretador LiteRT#
Para executar o modelo fora do pacote Ultralytics, carrega-o com o interpretador do pacote ai-edge-litert. Lê as formas das entradas e saídas do modelo em vez de depender dos nomes dos tensores. Um modelo de segmentação tem duas saídas: a saída 3D contém as deteções e a saída 4D contém os protótipos da máscara.
# Exporta primeiro: yolo export model=yolo26n.pt format=litert nms=False
import json
import zipfile
import numpy as np
from ai_edge_litert.interpreter import Interpreter
interpreter = Interpreter(model_path="yolo26n.tflite")
interpreter.allocate_tensors()
image = np.zeros((1, 3, 640, 640), dtype=np.float32) # a tua imagem pré-processada: RGB, NCHW, 0-1
interpreter.set_tensor(interpreter.get_input_details()[0]["index"], image)
interpreter.invoke()
detections = interpreter.get_tensor(interpreter.get_output_details()[0]["index"])[0] # shape (300, 6)
assert detections.shape == (300, 6), "export the model with nms=False"
detections = detections[detections[:, 4] > 0.25] # manter as linhas acima do limiar de confiança
with zipfile.ZipFile("yolo26n.tflite") as z:
names = json.loads(z.read("metadata.json"))["names"] # {'0': 'person', '1': 'bicycle', ...}Implantar#
YOLO("yolo26n.tflite") executa o modelo com o interpretador ai-edge-litert na CPU, com até 8 threads. Outros valores device, como 0 ou mps, também são executados na CPU; xpu e npu selecionam hardware Intel. A tabela de dispositivos de inferência compara estes nomes entre formatos.
O modelo é sempre executado com imgsz e batch da exportação, que a Ultralytics lê dos metadados do ficheiro. Um imgsz passado a predict ou val é ignorado. Os lotes maiores são divididos em blocos do tamanho do lote de exportação e os menores são preenchidos, por isso funciona qualquer número de imagens.
Inferência na GPU e na NPU Intel#
Os modelos .tflite exportados são executados em hardware Intel através do plug-in LiteRT Intel OpenVINO. Passa device=xpu para a GPU ou device=npu para a NPU, e a Ultralytics instala ai-edge-litert>=2.3.0 e ai-edge-litert-sdk-intel na primeira utilização. O plug-in fixa a sua própria versão de openvino, por isso mantém-no num ambiente separado se também executares modelos OpenVINO com outra versão. A NPU precisa de um processador Intel Core Ultra com o controlador NPU Intel instalado; consulta a latência medida num Core Ultra X7 358H. Numa máquina sem o dispositivo Intel pedido, o plug-in OpenVINO não consegue compilar o modelo e o LiteRT executa-o no seu próprio backend de CPU (XNNPACK), não através do OpenVINO: num servidor com CPU AMD, o YOLO26n demorou 29 a 30 ms por imagem com device=xpu e device=npu, face a 18 ms com device=cpu. Neste caso, a Ultralytics não regista nenhum aviso, por isso compara a latência com device=cpu para confirmar que o dispositivo está a ser usado.
from ultralytics import YOLO
model = YOLO("yolo26n.tflite")
results = model("https://ultralytics.com/images/bus.jpg", device="npu") # ou "xpu"Guias de implantação#
- Plug-in Ultralytics YOLO Flutter: executa exportações LiteRT
.tfliteno Android com inferência de câmara em tempo real, previsão de imagem única e aceleração por GPU. - Pacote npm @ultralytics/yolo: executa exportações LiteRT
.tfliteno navegador através do LiteRT.js, com aceleração WebGPU e alternativa de CPU (WASM). Instala-o comnpm i @ultralytics/yolo @litertjs/core. - MediaTek Dimensity: implementação no Android em telemóveis MediaTek, incluindo a NPU.
- Qualcomm QNN e Core ML: os formatos para NPUs Snapdragon e dispositivos Apple.
- NXP i.MX95 e Coral Edge TPU: formatos para estes aceleradores.
- Raspberry Pi: configura a Ultralytics em placas Raspberry Pi.
- Documentação LiteRT: integra o runtime em aplicações Android e iOS ou no navegador.
Limitações e solução de problemas#
- Anfitrião de exportação: no Windows e no Linux ARM64, como num Raspberry Pi, a exportação falha com
LiteRT export only supported on Linux x86 and macOS. Exporta num anfitrião compatível e copia o ficheiro.tflitepara o dispositivo. - Primeira exportação após uma instalação simples: quando a primeira exportação instala um
litert-torchque não aceita a versão instalada do PyTorch (0.10.0 aceita da 2.4.0 até uma versão anterior à 2.15.0), o pip substitui o PyTorch, a Ultralytics registaRestart runtime or rerun command for updates to take effecte essa exportação pode falhar, comRuntimeError: duplicate registrations for aten.miopen_batch_norm.defaultno PyTorch 2.15.0. Executa novamente a exportação. - FP16:
quantize=16falha comquantize=16 (FP16) is not supported; format='litert' supports quantize=8 (INT8), 'w8a16' (INT8 weights + INT16 activations), 'w8a32' (dynamic INT8), 32 or None (FP32).. Exporta em FP32 e deixa o delegado GPU executá-lo em precisão de meia. - Checkpoints treinados com
quantize=8: um checkpoint ajustado com treino com reconhecimento da quantização falha comformat='litert' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. Em vez disso, exporta o checkpoint usado como ponto de partida do ajuste fino comquantize=8, ou exporta o checkpoint ajustado para ONNX ou TensorRT. - Cabeça sem NMS com
quantize=8ou'w8a16': comnms=False, a exportação registaLiteRT INT8 export does not support end2end models, disabling end2end branch.e grava previsões em bruto que precisam de NMS. Usa FP32 ou'w8a32'para manter a cabeça sem NMS. - NMS incorporada:
nms=Trueregistaformat=litert does not support embedded NMS; exporting native outputs for external NMS.e grava a saída bruta. - Cabeça sem NMS noutros modelos:
nms=Falseprecisa de um modelo com uma cabeça sem NMS, como YOLO26 ou YOLOv10. Noutros modelos, por exemplo YOLO11, a exportação apresenta o avisoThis model has no one-to-one head; using one-to-many outputs.e grava a saída em bruto(1, 84, 8400). - Forma de entrada fixa:
dynamic=Truefalha comargument 'dynamic' is not supported for format='litert'. Volte a exportar para alterar o tamanho da imagem ou do lote. - Calibração sem
data: uma exportaçãoquantize=8ou'w8a16'registaINT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'.e calibra com o conjunto de dados predefinido pequeno para a tarefa. Passadatacom imagens representativas dos teus dados de implementação. - Tamanho da calibração: a exportação regista
>300 images recommended for INT8 calibration, found 4 images.quando a divisão de calibração tem menos de 300 imagens.coco8.yamltem apenas 4 imagens de validação, o que é suficiente para testar a exportação, mas não para calibrar um modelo para implementação. 'w8a16'em CPUs x86: o interpretador LiteRT para CPU executou um modelo YOLO26n'w8a16'a cerca de 1 s por imagem numa CPU de servidor AMD EPYC 9655 com 8 threads, face a cerca de 17 ms para o modelo FP32. Mede'w8a16'no dispositivo e no delegado que vais usar na implementação.- Nome do ficheiro: cada exportação de um checkpoint com o mesmo valor
quantizegrava o mesmo ficheiro, comoyolo26n.tflitepara FP32, independentemente deimgsz,batchounms; por isso, a exportação mais recente substitui a anterior.
Para outros erros, consulte o guia de problemas comuns.
Desempenho medido#
As tabelas abaixo apresentam a latência para uma imagem do modelo YOLO26n de cada tarefa em quatro telemóveis Android e num processador Intel Core Ultra. Cada célula indica o tempo total em milissegundos, com a divisão entre pré-processamento, inferência e pós-processamento abaixo; a coluna mais rápida de cada modelo está a negrito. A página do modelo YOLO26 apresenta a precisão dos checkpoints PyTorch.
Xiaomi 17#
Hardware: Xiaomi 17 com 12 GB de memória LPDDR5X e Android 17 / API 37. O Snapdragon 8 Elite Gen 5 de 3 nm (SM8850) tem uma CPU Qualcomm Oryon de 8 núcleos (2 núcleos Prime de até 4.6 GHz e 6 núcleos de desempenho de até 3.62 GHz), GPU Adreno e NPU Hexagon.
| Modelo | Tarefa | tamanho (pixels) | CPU w8a32 LiteRT (ms) | GPU w8a32 LiteRT (ms) | NPU LiteRT FP32 (ms) |
|---|---|---|---|---|---|
| YOLO26n | Detecção | 640 | 36.9 1.9 / 32.6 / 2.3 | 10.6 1.8 / 6.2 / 2.6 | 10.1 3.5 / 4.0 / 2.5 |
| YOLO26n-seg | Segmentação | 640 | 50.5 1.9 / 42.9 / 5.8 | 18.0 1.9 / 9.5 / 6.6 | 19.2 3.6 / 5.9 / 9.7 |
| YOLO26n-sem | Semântica | 640 | 45.7 1.9 / 35.7 / 8.2 | 30.6 1.9 / 20.5 / 8.3 | 25.8 3.6 / 11.0 / 11.3 |
| YOLO26n-depth | Profundidade | 640 | 66.8 2.2 / 55.0 / 9.7 | 21.9 2.1 / 10.1 / 9.8 | 24.8 4.3 / 6.0 / 14.5 |
| YOLO26n-cls | Classificação | 224 | 3.6 0.3 / 3.3 / 0.0 | 2.0 0.4 / 1.4 / 0.2 | 1.5 0.6 / 0.7 / 0.3 |
| YOLO26n-pose | Pose | 640 | 39.9 2.0 / 36.5 / 1.4 | 10.0 1.8 / 6.7 / 1.4 | 11.5 3.5 / 4.2 / 3.8 |
| YOLO26n-obb | OBB | 640 | 36.3 2.0 / 33.2 / 1.2 | 10.1 2.6 / 5.9 / 1.6 | 8.2 3.5 / 3.7 / 0.9 |
- Os valores de velocidade 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 o0.7.1do plugin Flutter da Ultralytics e os recursos oficiaisv0.7.0(exportações Ultralytics 8.4.188). A ordem entre CPU/GPU alternou entre tarefas em uma única varredura sequencial. Os registros nativos confirmaram que cada linha da CPU usou LiteRT CPU/XNNPACK e cada linha da GPU delegou o grafo completo ao LiteRT OpenCL (LITERT_CL). - A exportação para LiteRT rastreia diretamente o modelo PyTorch, gerando um
.tfliteNCHW com entrada float — o delegado da GPU compila o grafo inteiro (aqui, todas as sete tarefas são executadas na GPU Adreno) ew8a32não precisa de dados de calibração. Os consumidores devem consultar os formatos dos tensores e os nomes das assinaturas, em vez de presumir o layout legado NHWC do onnx2tf ou os nomes de saídaIdentity; empacote os dados RGB diretamente no formato CHW planar ou faça a transposição antes da inferência. As exportações semânticas retornam logits NCHW e exigem argmax de classes no host. Os recursos oficiais para Android estão hospedados na versãov0.7.0do yolo-flutter-app, e o registro detalhado do benchmark está no documento de desempenho do Flutter. - A coluna NPU corresponde ao caminho NPU próprio do LiteRT: uma exportação FP32 (
yolo export format=litert, semquantize), compilada no dispositivo pelos tempos de execuçãolitert-npu-runtime-qualcomme-mediatek2.3.0, medida com uma versão de protótipo do plugin Flutter com suporte a NPU (ainda não lançada). O primeiro carregamento inclui essa compilação (cerca de 0.3 s paran, até 6 s parax). Os recursosw8a32não são totalmente compilados nessas NPUs. O LiteRT informa uma compilação para NPU mesmo quando executa silenciosamente o grafo na GPU; por isso, cada linha da NPU foi comparada com o tempo da GPU; as linhas que usaram o fallback são indicadas por —. - Os números correspondentes da NPU Hexagon Snapdragon para os recursos oficiais QNN estão na integração Qualcomm QNN.
- Compare os resultados da CPU/acelerador da Apple na integração do CoreML.
As varreduras dos dispositivos a seguir usam os mesmos recursos oficiais v0.7.0.
Google Pixel 10#
Hardware: Google Pixel 10 com 12 GB de memória e Android 17 / API 37. O Google Tensor G5 de 3 nm tem uma CPU de 8 núcleos (1 núcleo Prime de até 3.78 GHz, 5 núcleos de desempenho de até 3.05 GHz e 2 núcleos de eficiência de até 2.25 GHz), GPU PowerVR D-Series e TPU Google. As frequências dos núcleos da CPU e o nome do driver da GPU foram lidos no dispositivo de benchmark, pois o Google não os publica nas especificações vinculadas.
| Modelo | Tarefa | tamanho (pixels) | CPU w8a32 LiteRT (ms) | GPU w8a32 LiteRT (ms) |
|---|---|---|---|---|
| YOLO26n | Detecção | 640 | 36.6 1.5 / 33.5 / 1.6 | 36.5 3.5 / 28.4 / 4.6 |
| YOLO26n-seg | Segmentação | 640 | 53.1 1.5 / 45.8 / 5.7 | 51.5 1.6 / 40.1 / 9.9 |
| YOLO26n-sem | Semântica | 640 | 57.2 1.5 / 47.7 / 8.0 | 75.9 1.8 / 63.4 / 10.8 |
| YOLO26n-depth | Profundidade | 640 | 75.0 1.6 / 65.1 / 8.3 | 50.1 1.7 / 33.5 / 14.9 |
| YOLO26n-cls | Classificação | 224 | 6.1 0.3 / 5.5 / 0.3 | 12.1 0.9 / 11.0 / 0.1 |
| YOLO26n-pose | Pose | 640 | 35.2 1.5 / 31.9 / 1.8 | 38.2 3.5 / 29.3 / 5.4 |
| YOLO26n-obb | OBB | 640 | 32.7 1.5 / 29.3 / 1.9 | 38.8 3.8 / 29.6 / 5.4 |
Benchmark: Média de 15 chamadas predict() após 3 aquecimentos em bus.jpg, usando ultralytics_yolo 0.7.1 e os recursos oficiais v0.7.0. A ordem entre CPU/GPU alterna entre tarefas em uma única varredura sequencial. Os registros nativos confirmaram que cada linha da CPU usou LiteRT CPU/XNNPACK e cada linha da GPU delegou o grafo completo ao LiteRT OpenCL (LITERT_CL). O Tensor NPU não tem uma linha LiteRT: o serviço EdgeTPU do Google rejeita aplicativos que não estão na lista de permissões, e o LiteRT passa então a executar o modelo na GPU.
Samsung Galaxy S26#
Hardware: Samsung Galaxy S26 (SM-S942B) com 12 GB de memória e Android 17 / API 37. O Exynos 2600 de 2 nm tem uma CPU Armv9.3 de 10 núcleos (1 núcleo C1-Ultra de até 3.8 GHz, 3 núcleos C1-Pro de desempenho de até 3.26 GHz e 6 núcleos C1-Pro de eficiência de até 2.76 GHz), GPU Xclipse 960 e NPU Samsung.
| Modelo | Tarefa | tamanho (pixels) | CPU w8a32 LiteRT (ms) | GPU w8a32 LiteRT (ms) | NPU LiteRT w8a32 AOT (ms) |
|---|---|---|---|---|---|
| YOLO26n | Detecção | 640 | 30.2 1.3 / 27.3 / 1.6 | 15.9 1.4 / 11.5 / 2.9 | 12.2 1.3 / 8.6 / 2.2 |
| YOLO26n-seg | Segmentação | 640 | 45.6 1.3 / 39.1 / 5.2 | 30.5 1.3 / 23.6 / 5.6 | 17.0 1.4 / 9.7 / 5.8 |
| YOLO26n-sem | Semântica | 640 | 38.1 1.3 / 28.6 / 8.2 | 26.1 1.3 / 16.8 / 7.9 | 28.3 1.7 / 15.1 / 11.5 |
| YOLO26n-depth | Profundidade | 640 | 63.5 1.4 / 53.6 / 8.4 | 37.3 1.4 / 24.6 / 11.3 | 28.4 2.1 / 12.9 / 13.4 |
| YOLO26n-cls | Classificação | 224 | 3.8 0.2 / 3.4 / 0.2 | 2.8 0.2 / 2.6 / 0.0 | 6.1 0.5 / 5.2 / 0.4 |
| YOLO26n-pose | Pose | 640 | 31.1 1.3 / 28.4 / 1.4 | 18.4 1.6 / 13.0 / 3.8 | 13.5 1.8 / 9.5 / 2.2 |
| YOLO26n-obb | OBB | 640 | 27.9 1.3 / 25.7 / 0.9 | 15.3 1.9 / 11.4 / 2.1 | 11.4 1.7 / 8.3 / 1.4 |
Benchmark: Média de 15 chamadas predict() após 3 aquecimentos em bus.jpg, usando ultralytics_yolo 0.7.1 e os recursos oficiais v0.7.0. A ordem entre CPU/GPU alterna entre tarefas em uma única varredura sequencial. Os registros nativos confirmaram que cada linha da CPU usou LiteRT CPU/XNNPACK e cada linha da GPU delegou o grafo completo ao LiteRT OpenCL (LITERT_CL). A coluna NPU usa os recursos w8a32 compilados antecipadamente para o Exynos 2600 (E9965) com o plugin compilador Samsung do LiteRT. A Samsung não tem um compilador no dispositivo no LiteRT 2.3, e o Google ainda não disponibiliza um tempo de execução para NPU Samsung, por isso essas linhas usaram uma biblioteca de despacho compilada a partir do código-fonte do LiteRT 2.3.
Xiaomi 17T Pro#
Hardware: Xiaomi 17T Pro (2602EPTC0G) com 12 GB de memória LPDDR5X e Android 16 / API 36. O MediaTek Dimensity 9500 de 3 nm (MT6993) tem uma CPU Armv9.3 de 8 núcleos (1 núcleo C1-Ultra de até 4.21 GHz, 3 núcleos C1-Premium de até 3.5 GHz e 4 núcleos C1-Pro de até 2.7 GHz), GPU Mali-G1 Ultra MC12 e NPU MediaTek 990.
| Modelo | Tarefa | tamanho (pixels) | CPU w8a32 LiteRT (ms) | GPU w8a32 LiteRT (ms) | NPU LiteRT FP32 (ms) |
|---|---|---|---|---|---|
| YOLO26n | Detecção | 640 | 31.4 1.5 / 28.0 / 1.9 | 25.6 1.4 / 22.2 / 2.0 | 11.0 1.3 / 7.8 / 1.8 |
| YOLO26n-seg | Segmentação | 640 | 77.8 2.6 / 65.3 / 9.9 | 47.4 2.6 / 33.6 / 11.3 | 36.5 2.6 / 23.4 / 10.4 |
| YOLO26n-sem | Semântica | 640 | 81.3 2.6 / 62.2 / 16.5 | 79.3 2.6 / 59.5 / 17.1 | 87.6 2.6 / 68.3 / 16.7 |
| YOLO26n-depth | Profundidade | 640 | 111.3 3.4 / 91.1 / 16.8 | 55.3 2.8 / 36.3 / 16.1 | — |
| YOLO26n-cls | Classificação | 224 | 6.3 0.5 / 5.4 / 0.4 | 8.1 0.5 / 7.5 / 0.1 | 3.2 0.5 / 2.2 / 0.5 |
| YOLO26n-pose | Pose | 640 | 53.9 2.6 / 49.5 / 1.8 | 32.8 2.7 / 26.7 / 3.4 | 16.2 2.9 / 11.1 / 2.3 |
| YOLO26n-obb | OBB | 640 | 49.5 2.7 / 44.4 / 2.4 | 29.4 2.8 / 22.7 / 3.9 | — |
Referência de desempenho: média de 15 chamadas predict() após 3 aquecimentos em bus.jpg, usando ultralytics_yolo 0.7.1 e os recursos oficiais v0.7.0. A ordem CPU/GPU alterna entre tarefas em uma única execução sequencial. Os registos nativos confirmaram que todas as linhas de CPU usaram LiteRT CPU/XNNPACK e todas as linhas de GPU delegaram o grafo completo ao LiteRT OpenCL (LITERT_CL). Depth e OBB não têm resultados de NPU: o compilador de NPU da MediaTek rejeita as operações exponenciais e trigonométricas, e o LiteRT executa esses grafos na GPU.
Para saberes mais sobre o fluxo de trabalho de implementação no Android e as limitações da NPU, consulta o guia MediaTek Dimensity.
Intel Core Ultra X7 358H#
Hardware: Intel Core Ultra X7 358H (Panther Lake) e Intel AI Boost NPU 5010, Fedora Linux, driver NPU 1.38.0, ai-edge-litert 2.3.0.
| Modelo | Tarefa | tamanho (pixels) | CPU w8a32 LiteRT (ms) | CPU w8a32 Intel (ms) | NPU w8a32 Intel (ms) |
|---|---|---|---|---|---|
| YOLO26n | Detecção | 640 | 17.5 0.8 / 16.1 / 0.6 | 22.6 1.2 / 20.6 / 0.8 | 4.8 1.0 / 3.3 / 0.4 |
| YOLO26n-seg | Segmentação | 640 | 24.2 0.9 / 22.1 / 1.3 | 32.6 1.0 / 30.1 / 1.5 | 6.2 0.8 / 4.2 / 1.2 |
| YOLO26n-sem | Semântica | 640 | 25.2 1.0 / 14.2 / 10.0 | 33.1 1.1 / 21.9 / 10.2 | 16.5 1.0 / 5.5 / 10.0 |
| YOLO26n-depth | Profundidade | 640 | 31.7 0.9 / 30.2 / 0.5 | 76.6 0.9 / 75.2 / 0.5 | 9.1 1.0 / 7.5 / 0.5 |
| YOLO26n-cls | Classificação | 224 | 4.6 2.8 / 1.7 / 0.0 | 7.3 3.3 / 3.9 / 0.0 | 4.1 3.2 / 0.9 / 0.0 |
| YOLO26n-pose | Pose | 640 | 20.3 0.8 / 19.0 / 0.5 | 28.6 1.1 / 26.8 / 0.8 | 6.3 0.8 / 4.9 / 0.5 |
| YOLO26n-obb | OBB | 640 | 17.2 0.8 / 16.1 / 0.3 | 22.1 1.2 / 20.5 / 0.4 | 4.6 0.9 / 3.4 / 0.3 |
Benchmark: Média de 15 chamadas a predict() após 3 aquecimentos em bus.jpg, usando ultralytics 8.4.174 e ai-edge-litert 2.3.0 com exportações w8a32. Cada célula mostra o tempo total, com a divisão entre pré-processamento / inferência / pós-processamento logo abaixo.
Sobre o LiteRT#
LiteRT, abreviatura de Lite Runtime, dá continuidade ao TensorFlow Lite com um novo nome e executa o mesmo formato de modelo .tflite. Executa modelos na CPU com XNNPACK e em GPUs e NPUs através de delegados de hardware; o LiteRT.js permite usar o mesmo ficheiro em navegadores e no Node.js. Para a referência completa, consulta a documentação LiteRT.
Assista: Como exportar Ultralytics YOLO26 para Google LiteRT | Implante IA de visão em Android e iOS | IA móvel 📱🚀
Perguntas frequentes#
LiteRT é o novo nome do TensorFlow Lite e mantém o mesmo formato de modelo
.tflite. Na Ultralytics,format="litert"substitui dois formatos de exportação anteriores:tflitepara dispositivos móveis, integrados e de edge, etfjspara navegadores e Node.js, onde o LiteRT.js executa agora o mesmo ficheiro.tflite. Ambos os valores anteriores continuam a exportar um ficheiro LiteRT com um aviso de descontinuação. As páginas TFLite e TF.js descrevem os formatos anteriores.Começa com
quantize="w8a32". Não precisa de dados de calibração, reduz o ficheiro para menos de um terço do tamanho FP32, suporta a cabeça sem NMS do YOLO26 comnms=Falsee corresponde à precisão dos modelos móveis oficiais da Ultralytics para CPU e GPU. Usaquantize=8quando o destino precisar de ativações inteiras: por exemplo, a exportação NXP i.MX95 compila um modelo LiteRT INT8 calibrado.'w8a16'mantém mais precisão nas ativações do que8. Ambos precisam de dados de calibração representativos e devolvem previsões em bruto que precisam de NMS. Mede a latência e a precisão no dispositivo de destino antes de escolheres, porque o suporte de cada esquema varia entre delegados de CPU, GPU e NPU.Não. A exportação é executada apenas em Linux x86-64 e em macOS com Apple silicon. Exporta o modelo num destes anfitriões ou através da Ultralytics Platform e copia o ficheiro
.tflitepara o dispositivo. Consulta o guia Raspberry Pi para executar modelos na placa; um Coral Edge TPU pode acelerar a inferência.Sim. O LiteRT.js executa o ficheiro exportado
.tflitenum navegador ou no Node.js com WebGPU ou WASM, por isso não é necessária uma exportação separada para o navegador. O pacote npm @ultralytics/yolo integra-o com inferência por webcam e de imagem única para as tarefas de deteção, segmentação, segmentação semântica, classificação, pose e OBB.Usa o plug-in Ultralytics YOLO Flutter, que carrega exportações LiteRT
.tfliteno Android e abrange as sete tarefas YOLO26. Exporta emimgsz=640, ou emimgsz=224para classificação, para corresponder aos modelos oficiais. Para uma aplicação nativa, segue o guia LiteRT para Android e fornece a entrada ao modelo conforme descrito em Formato de saída. No iPhone, Core ML é o formato nativo.
Comentários
Faz uma pergunta, partilha os teus resultados ou ajuda alguém.