Exporta modelos YOLO para LiteRT para implementação em Edge e Web#

LiteRT (abreviação de Lite Runtime) é o runtime de alto desempenho da Google para IA em dispositivos (on-device). É a próxima geração e o novo nome do TensorFlow Lite (TFLite), e executa o mesmo formato de modelo .tflite. Com o LiteRT, um único modelo Ultralytics YOLO exportado é implantado em dispositivos móveis, embarcados, edge e no navegador — cobrindo tudo o que os formatos de exportação mais antigos tflite e tfjs tratavam separadamente, agora sob um único guarda-chuva.

O formato de exportação LiteRT otimiza os teus modelos para tarefas como detecção de objetos, segmentação, estimação de pose e classificação para que sejam executados rapidamente e offline em uma ampla gama de dispositivos.

npm i @ultralytics/yolo @litertjs/core

Por que deverias exportar para LiteRT?#

LiteRT é um framework de código aberto projetado para inferência em dispositivos, também conhecido como edge computing. Ele fornece aos desenvolvedores as ferramentas para executar modelos treinados em dispositivos móveis, embarcados e de IoT, computadores tradicionais e — por meio do LiteRT.js — diretamente em navegadores web e Node.js.

Um formato de modelo, todos os alvos:

• Móvel e Integrado: Android, iOS, Linux integrado e microcontroladores (MCUs).
• Aceleradores Edge: Compatível com o Coral Edge TPU para aceleração adicional.
• Navegador e Node.js: O LiteRT.js executa o mesmo modelo .tflite na web com aceleração WebGPU/WASM — eliminando a necessidade de uma exportação separada para o TensorFlow.js.

Principais recursos dos modelos LiteRT#

• Otimização no dispositivo: Reduz a latência ao processar dados localmente, aumenta a privacidade ao não transmitir dados pessoais e minimiza o tamanho do modelo para economizar espaço.
• Suporte a múltiplas plataformas: Executa em Android, iOS, Linux integrado, microcontroladores e navegadores web modernos.
• Aceleração de hardware: Aproveita o XNNPACK na CPU e aceleração de GPU via OpenCL, Metal e WebGPU. O delegado de GPU executa em FP16 por padrão para maior velocidade.
• Quantização: Suporta FP32, INT8 estático (quantize=8, pesos int8 + ativações int8), INT16 estático para ativação (quantize="w8a16", pesos int8 + ativações int16 para maior precisão) e INT8 dinâmico (quantize="w8a32", pesos int8 + ativações FP32, sem necessidade de dados de calibração) para comprimir modelos e acelerar a inferência com perda mínima de precisão.
• Suporte a diversos idiomas: Compatível com Java/Kotlin, Swift, Objective-C, C++, Python e JavaScript.

Desempenho Medido#

Hardware: Xiaomi 17 com 12 GB de memória LPDDR5X e Android 16 / API 36. O seu Snapdragon 8 Elite Gen 5 (SM8850) de 3 nm possui uma CPU Qualcomm Oryon de 8 núcleos (2 núcleos Prime até 4,6 GHz e 6 núcleos Performance até 3,62 GHz), GPU Adreno e NPU Hexagon.

• 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, medida com o plugin Flutter da Ultralytics 0.6.10 e os assets padronizados v0.6.6. A ordem de CPU/GPU alternou entre as tarefas em uma varredura sequencial. Logs nativos confirmaram que cada linha de CPU usou LiteRT CPU/XNNPACK e cada linha de GPU delegou o grafo completo para LiteRT OpenCL (LITERT_CL).
• A exportação LiteRT rastreia o modelo PyTorch diretamente, produzindo um .tflite NCHW com uma entrada de ponto flutuante — o delegado de GPU compila o grafo inteiro (todas as sete tarefas são executadas na GPU Adreno aqui), e w8a32 não precisa de dados de calibração. Os consumidores devem ler os formatos de tensor e os nomes de assinatura em vez de assumir o layout NHWC legado do onnx2tf ou os nomes de saída de Identity; empacote os dados RGB diretamente como CHW planar ou transponha-os antes da inferência. As exportações semânticas retornam logits NCHW e exigem um argmax de classe no lado do host. Os assets oficiais para Android estão hospedados na release v0.6.6 do yolo-flutter-app, com o registro detalhado de benchmarks em the Flutter performance doc.
• Os números correspondentes à NPU Hexagon do Snapdragon e à CPU/GPU do LiteRT estão na integração Qualcomm QNN.
• Compara os resultados de CPU/acelerador da Apple na integração CoreML.

As seguintes varreduras de dispositivos utilizam os mesmos assets padronizados v0.6.6.

Google Pixel 10#

Hardware: Google Pixel 10 com 12 GB de memória e Android 16 / API 36. O seu Google Tensor G5 de 3 nm tem uma CPU de 8 núcleos (1 núcleo Prime até 3,78 GHz, 5 núcleos Performance até 3,05 GHz e 2 núcleos de Eficiência até 2,25 GHz), GPU PowerVR D-Series e TPU da Google. Os clocks principais e o nome do driver da GPU foram lidos a partir do dispositivo de benchmark, pois a Google não os publica nas especificações vinculadas.

Benchmark: Média de 15 chamadas em predict() após 3 aquecimentos em bus.jpg, usando ultralytics_yolo 0.6.10 e os assets oficiais v0.6.6. A ordem de CPU/GPU alterna entre as tarefas em uma varredura sequencial. Logs nativos confirmaram que cada linha de CPU usou LiteRT CPU/XNNPACK e cada linha de GPU delegou o grafo completo para LiteRT OpenCL (LITERT_CL).

Samsung Galaxy S26#

Hardware: Samsung Galaxy S26 (SM-S942B) com 12 GB de memória e Android 16 / API 36. O seu Exynos 2600 de 2 nm tem uma CPU Armv9.3 de 10 núcleos (1 núcleo C1-Ultra até 3,8 GHz, 3 núcleos de desempenho C1-Pro até 3,26 GHz e 6 núcleos de eficiência C1-Pro até 2,76 GHz), GPU Xclipse 960 e NPU da Samsung.

Benchmark: Média de 15 chamadas em predict() após 3 aquecimentos em bus.jpg, usando ultralytics_yolo 0.6.10 e os assets oficiais v0.6.6. A ordem de CPU/GPU alterna entre as tarefas em uma varredura sequencial. Logs nativos confirmaram que cada linha de CPU usou LiteRT CPU/XNNPACK e cada linha de GPU delegou o grafo completo para LiteRT OpenCL (LITERT_CL).

Xiaomi 17T Pro#

Hardware: Xiaomi 17T Pro (2602EPTC0G) com 12 GB de memória LPDDR5X e Android 16 / API 36. O seu MediaTek Dimensity 9500 (MT6993) de 3 nm tem uma CPU Armv9.3 de 8 núcleos (1 núcleo C1-Ultra até 4,21 GHz, 3 núcleos C1-Premium até 3,5 GHz e 4 núcleos C1-Pro até 2,7 GHz), GPU Mali-G1 Ultra MC12 e MediaTek NPU 990.

Benchmark: Média de 15 chamadas em predict() após 3 aquecimentos em bus.jpg, usando ultralytics_yolo 0.6.10 e os assets oficiais v0.6.6. A ordem de CPU/GPU alterna entre as tarefas em uma varredura sequencial. Logs nativos confirmaram que cada linha de CPU usou LiteRT CPU/XNNPACK e cada linha de GPU delegou o grafo completo para LiteRT OpenCL (LITERT_CL).

Tarefas Suportadas#

A exportação para LiteRT suporta todas as sete tarefas do Ultralytics. Segmentação semântica e estimativa de profundidade estão disponíveis apenas com o YOLO26, a única família que inclui essas cabeças.

Exportar para LiteRT: Convertendo o teu modelo YOLO#

Podes melhorar a eficiência da execução no dispositivo e ampliar as opções de implementação convertendo os teus modelos para o formato LiteRT.

Instalação#

Para instalar o pacote necessário, execute:

# Install the required package for YOLO
pip install ultralytics

Para instruções detalhadas e melhores práticas, consulta o nosso guia de Instalação do Ultralytics. Se encontrares alguma dificuldade, consulta o nosso guia de Problemas Comuns.

Uso#

Todos os modelos Ultralytics YOLO suportam exportação nativamente. O formato LiteRT suporta os modos Export, Predict e Validate, para que possas exportar um modelo e, em seguida, carregá-lo para executar a inferência ou validar a sua precisão localmente.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to LiteRT format
model.export(format="litert", imgsz=640)  # use imgsz=224 for classification

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Dynamic INT8: int8 weights, FP32 activations - no calibration data needed
model.export(format="litert", quantize="w8a32", imgsz=640)  # use imgsz=224 for classification

# Static INT8: int8 weights + int8 activations - needs calibration data
model.export(format="litert", quantize=8, data="coco8.yaml", imgsz=640)  # use 224 for classification

# Static w8a16: int8 weights + int16 activations (higher accuracy) - needs calibration data
model.export(format="litert", quantize="w8a16", data="coco8.yaml", imgsz=640)  # use 224 for classification

from ultralytics import YOLO

# Load the exported LiteRT model
model = YOLO("yolo26n.tflite")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported LiteRT model
model = YOLO("yolo26n.tflite")

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

Implementando modelos YOLO LiteRT exportados#

Após exportar o teu modelo Ultralytics YOLO para LiteRT, podes implantá-lo em várias plataformas. A maneira mais rápida de verificá-lo localmente é o método YOLO("yolo26n.tflite") mostrado acima. Para implantação em outros ambientes, consulta os seguintes recursos:

Móvel e Integrado#

• Android: Um guia de início rápido para integrar o LiteRT em aplicações Android.
• iOS: Um guia para integrar e implantar modelos LiteRT em aplicações iOS.
• Linux Embarcado e Raspberry Pi: Executa modelos LiteRT em computadores de placa única, opcionalmente acelerados com uma Coral Edge TPU.
• Microcontroladores: Implanta em MCUs com apenas alguns quilobytes de memória — o runtime principal cabe em aproximadamente 16 KB num Arm Cortex-M3.

Navegador e Node.js (LiteRT.js)#

• Visão geral do LiteRT.js: Executa o mesmo modelo .tflite diretamente no navegador com aceleração WebGPU/WASM, eliminando o cálculo do lado do servidor e mantendo os dados no dispositivo do usuário.
• Exemplos de Ponta a Ponta: Exemplos práticos e tutoriais para implementar o LiteRT em dispositivos móveis, edge e web.

Resumo#

Neste guia, abordamos como exportar modelos Ultralytics YOLO para o formato LiteRT. Ao consolidar a implantação móvel/edge (antigamente TFLite) e em navegador (antigamente TF.js) num único modelo .tflite, o LiteRT torna os teus modelos YOLO mais rápidos, menores e portáteis em praticamente qualquer destino on-device.

Para mais detalhes, visita a documentação oficial do LiteRT.

Além disso, se tiveres curiosidade sobre outras integrações do Ultralytics YOLO, consulta a nossa página do guia de integração para obteres vários recursos úteis.

FAQ#