Começar

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#

PropriedadeDetalhes
Argumento formatlitert. Os valores mais antigos tflite e tfjs continuam a funcionar: registam um aviso de descontinuação e exportam o mesmo ficheiro LiteRT
Saídayolo26n.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 emDispositivos 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çãoLiteRT: o pacote Python ai-edge-litert (2.1.4 ou posterior), as bibliotecas LiteRT para Android e iOS ou LiteRT.js
PrecisãoFP32, 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çãoLinux 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
Exportar na nuvem

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:

PacoteVersão necessária
Python3.10 ou posterior
litert-torch0.10.0 ou posterior
torchO intervalo aceite pelo litert-torch instalado: 2.4.0 ou posterior e anterior a 2.15.0 para 0.10.0
ai-edge-litert2.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-quantizer0.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.

Exportar
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'
Prever
from ultralytics import YOLO

# Carregue o modelo LiteRT exportado
model = YOLO("yolo26n.tflite")

# Executar inferência
results = model("https://ultralytics.com/images/bus.jpg")
Validar
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#

ArgumentoTipoPadrãoDescrição
formatstr'litert'Formato de destino do modelo exportado, que define a compatibilidade com vários ambientes de implantação.
imgszint ou tuple640Tamanho 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.
quantizeint ou strNoneEsquema 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.
datastrNoneFicheiro 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.
fractionfloat, int ou list1.0Subconjunto 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.
nmsbool, opcionalNoneSeleciona 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.
batchint1Tamanho do lote do modelo exportado, fixo na forma da entrada. É também o tamanho do lote usado na calibração.
devicestrNoneA 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.

Tamanho de imagem dos modelos oficiais para dispositivos móveis e Web

Os modelos móveis oficiais LiteRT, Core ML e QNN são exportados em imgsz=640 e em imgsz=224 para classificação. Por predefinição, os checkpoints Cityscapes de segmentação semântica, profundidade e OBB são exportados com um tamanho maior; passa imgsz=640 para corresponder a esses checkpoints.

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:

quantizePesosAtivaçõesDados de calibraçãoArquivo YOLO26nTamanho
omitido ou 32FP32FP32Nãoyolo26n.tflite10.0 MB
'w8a32'INT8FP32Nãoyolo26n_w8a32.tflite2.9 MB
8INT8INT8Simyolo26n_int8.tflite3.1 MB
'w8a16'INT8INT16Simyolo26n_w8a16.tflite3.0 MB
  • Entradas e saídas: a entrada e as saídas mantêm-se como float32 em 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ção nms.
  • 'w8a32': quantização de intervalo dinâmico. Não precisa de dados de calibração e suporta a cabeça sem NMS com nms=False; é também a precisão dos modelos móveis oficiais nas colunas de CPU e GPU em Desempenho medido.
  • 8 e 'w8a16': quantização estática. A exportação calibra com todos os lotes completos da divisão val de data, ou da divisão definida com split, e apresenta um aviso com menos de 300 imagens. Usa fraction para 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=8 e '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 com nms=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=16 não é necessário e gera um erro.
Exemplo
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:

Tarefaimgsz padrãoSaída com nms=NoneSaída com nms=False
Detecção640(1, 84, 8400)(1, 300, 6)
Segmentação640(1, 116, 8400) e (1, 32, 160, 160)(1, 300, 38) e (1, 32, 160, 160)
Semântica1024(1, 19, 1024, 1024), uma pontuação para cada classe e píxelIgual a nms=None
Profundidade768(1, 1, 768, 768), mapa de profundidadeIgual a nms=None
Classificação224(1, 1000), probabilidades das classesIgual a nms=None
Pose640(1, 56, 8400)(1, 300, 57): 6 valores da caixa, seguidos de 17 pontos-chave x 3
OBB1024(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 de x1, y1, x2, y2, score, class em píxeis de entrada, sem etapa de NMS. As linhas OBB são center 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.

Prever
from ultralytics import YOLO

model = YOLO("yolo26n.tflite")
results = model("https://ultralytics.com/images/bus.jpg", device="npu")  # ou "xpu"

Guias de implantação#

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 .tflite para o dispositivo.
  • Primeira exportação após uma instalação simples: quando a primeira exportação instala um litert-torch que 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 regista Restart runtime or rerun command for updates to take effect e essa exportação pode falhar, com RuntimeError: duplicate registrations for aten.miopen_batch_norm.default no PyTorch 2.15.0. Executa novamente a exportação.
  • FP16: quantize=16 falha com quantize=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 com format='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 com quantize=8, ou exporta o checkpoint ajustado para ONNX ou TensorRT.
  • Cabeça sem NMS com quantize=8 ou 'w8a16': com nms=False, a exportação regista LiteRT 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=True regista format=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=False precisa de um modelo com uma cabeça sem NMS, como YOLO26 ou YOLOv10. Noutros modelos, por exemplo YOLO11, a exportação apresenta o aviso This 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=True falha com argument '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ção quantize=8 ou 'w8a16' regista INT8 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. Passa data com 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.yaml tem 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 quantize grava o mesmo ficheiro, como yolo26n.tflite para FP32, independentemente de imgsz, batch ou nms; 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.

ModeloTarefatamanho
(pixels)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26nDetecção64036.9
1.9 / 32.6 / 2.3
10.6
1.8 / 6.2 / 2.6
10.1
3.5 / 4.0 / 2.5
YOLO26n-segSegmentação64050.5
1.9 / 42.9 / 5.8
18.0
1.9 / 9.5 / 6.6
19.2
3.6 / 5.9 / 9.7
YOLO26n-semSemântica64045.7
1.9 / 35.7 / 8.2
30.6
1.9 / 20.5 / 8.3
25.8
3.6 / 11.0 / 11.3
YOLO26n-depthProfundidade64066.8
2.2 / 55.0 / 9.7
21.9
2.1 / 10.1 / 9.8
24.8
4.3 / 6.0 / 14.5
YOLO26n-clsClassificação2243.6
0.3 / 3.3 / 0.0
2.0
0.4 / 1.4 / 0.2
1.5
0.6 / 0.7 / 0.3
YOLO26n-posePose64039.9
2.0 / 36.5 / 1.4
10.0
1.8 / 6.7 / 1.4
11.5
3.5 / 4.2 / 3.8
YOLO26n-obbOBB64036.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 o 0.7.1 do plugin Flutter da Ultralytics e os recursos oficiais v0.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 .tflite NCHW com entrada float — o delegado da GPU compila o grafo inteiro (aqui, todas as sete tarefas são executadas na GPU Adreno) e w8a32 nã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ída Identity; 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ão v0.7.0 do 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, sem quantize), compilada no dispositivo pelos tempos de execução litert-npu-runtime-qualcomm e -mediatek 2.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 para n, até 6 s para x). Os recursos w8a32 nã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.

ModeloTarefatamanho
(pixels)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
YOLO26nDetecção64036.6
1.5 / 33.5 / 1.6
36.5
3.5 / 28.4 / 4.6
YOLO26n-segSegmentação64053.1
1.5 / 45.8 / 5.7
51.5
1.6 / 40.1 / 9.9
YOLO26n-semSemântica64057.2
1.5 / 47.7 / 8.0
75.9
1.8 / 63.4 / 10.8
YOLO26n-depthProfundidade64075.0
1.6 / 65.1 / 8.3
50.1
1.7 / 33.5 / 14.9
YOLO26n-clsClassificação2246.1
0.3 / 5.5 / 0.3
12.1
0.9 / 11.0 / 0.1
YOLO26n-posePose64035.2
1.5 / 31.9 / 1.8
38.2
3.5 / 29.3 / 5.4
YOLO26n-obbOBB64032.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.

ModeloTarefatamanho
(pixels)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT w8a32 AOT
(ms)
YOLO26nDetecção64030.2
1.3 / 27.3 / 1.6
15.9
1.4 / 11.5 / 2.9
12.2
1.3 / 8.6 / 2.2
YOLO26n-segSegmentação64045.6
1.3 / 39.1 / 5.2
30.5
1.3 / 23.6 / 5.6
17.0
1.4 / 9.7 / 5.8
YOLO26n-semSemântica64038.1
1.3 / 28.6 / 8.2
26.1
1.3 / 16.8 / 7.9
28.3
1.7 / 15.1 / 11.5
YOLO26n-depthProfundidade64063.5
1.4 / 53.6 / 8.4
37.3
1.4 / 24.6 / 11.3
28.4
2.1 / 12.9 / 13.4
YOLO26n-clsClassificação2243.8
0.2 / 3.4 / 0.2
2.8
0.2 / 2.6 / 0.0
6.1
0.5 / 5.2 / 0.4
YOLO26n-posePose64031.1
1.3 / 28.4 / 1.4
18.4
1.6 / 13.0 / 3.8
13.5
1.8 / 9.5 / 2.2
YOLO26n-obbOBB64027.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.

ModeloTarefatamanho
(pixels)
CPU
w8a32 LiteRT
(ms)
GPU
w8a32 LiteRT
(ms)
NPU
LiteRT FP32
(ms)
YOLO26nDetecção64031.4
1.5 / 28.0 / 1.9
25.6
1.4 / 22.2 / 2.0
11.0
1.3 / 7.8 / 1.8
YOLO26n-segSegmentação64077.8
2.6 / 65.3 / 9.9
47.4
2.6 / 33.6 / 11.3
36.5
2.6 / 23.4 / 10.4
YOLO26n-semSemântica64081.3
2.6 / 62.2 / 16.5
79.3
2.6 / 59.5 / 17.1
87.6
2.6 / 68.3 / 16.7
YOLO26n-depthProfundidade640111.3
3.4 / 91.1 / 16.8
55.3
2.8 / 36.3 / 16.1
—
YOLO26n-clsClassificação2246.3
0.5 / 5.4 / 0.4
8.1
0.5 / 7.5 / 0.1
3.2
0.5 / 2.2 / 0.5
YOLO26n-posePose64053.9
2.6 / 49.5 / 1.8
32.8
2.7 / 26.7 / 3.4
16.2
2.9 / 11.1 / 2.3
YOLO26n-obbOBB64049.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.

ModeloTarefatamanho
(pixels)
CPU
w8a32 LiteRT
(ms)
CPU
w8a32 Intel
(ms)
NPU
w8a32 Intel
(ms)
YOLO26nDetecção64017.5
0.8 / 16.1 / 0.6
22.6
1.2 / 20.6 / 0.8
4.8
1.0 / 3.3 / 0.4
YOLO26n-segSegmentação64024.2
0.9 / 22.1 / 1.3
32.6
1.0 / 30.1 / 1.5
6.2
0.8 / 4.2 / 1.2
YOLO26n-semSemântica64025.2
1.0 / 14.2 / 10.0
33.1
1.1 / 21.9 / 10.2
16.5
1.0 / 5.5 / 10.0
YOLO26n-depthProfundidade64031.7
0.9 / 30.2 / 0.5
76.6
0.9 / 75.2 / 0.5
9.1
1.0 / 7.5 / 0.5
YOLO26n-clsClassificação2244.6
2.8 / 1.7 / 0.0
7.3
3.3 / 3.9 / 0.0
4.1
3.2 / 0.9 / 0.0
YOLO26n-posePose64020.3
0.8 / 19.0 / 0.5
28.6
1.1 / 26.8 / 0.8
6.3
0.8 / 4.9 / 0.5
YOLO26n-obbOBB64017.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.

LiteRT edge deployment framework



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: tflite para dispositivos móveis, integrados e de edge, e tfjs para 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 com nms=False e corresponde à precisão dos modelos móveis oficiais da Ultralytics para CPU e GPU. Usa quantize=8 quando 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 que 8. 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 .tflite para 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 .tflite num 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 .tflite no Android e abrange as sete tarefas YOLO26. Exporta em imgsz=640, ou em imgsz=224 para 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.