Exportar modelos YOLO para LiteRT para implementação em dispositivos edge e na Web#

LiteRT (abreviação de Lite Runtime) é o runtime de alto desempenho da Google para IA no dispositivo. É 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 é implementado em dispositivos móveis, incorporados, edge e no navegador — abrangendo tudo o que os antigos formatos de exportação tflite e tfjs tratavam separadamente, agora sob uma única plataforma.

O formato de exportação LiteRT otimiza os teus modelos para tarefas como deteção de objetos, segmentação, estimativa de pose e classificação, para que funcionem rapidamente e offline numa vasta gama de dispositivos.

npm i @ultralytics/yolo @litertjs/core

Por que deves exportar para LiteRT?#

LiteRT é uma framework de código aberto concebida para inferência no dispositivo, também conhecida como computação edge. Fornece aos programadores as ferramentas para executar modelos treinados em dispositivos móveis, incorporados e IoT, computadores tradicionais e — através do LiteRT.js — diretamente em navegadores Web e no Node.js.

Um formato de modelo, todos os destinos:

• Móvel e incorporado: Android, iOS, Linux incorporado 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 TensorFlow.js separada.

Principais funcionalidades dos modelos LiteRT#

• Otimização no dispositivo: Reduz a latência ao processar os dados localmente, melhora a privacidade ao não transmitir dados pessoais e minimiza o tamanho do modelo para poupar espaço.
• Suporte a várias plataformas: Funciona em Android, iOS, Linux incorporado, microcontroladores e navegadores Web modernos.
• Aceleração de hardware: Utiliza XNNPACK na CPU e aceleração por GPU através de OpenCL, Metal e WebGPU. O delegado da GPU funciona por predefinição em FP16 para proporcionar velocidade adicional.
• Quantização: Suporta FP32, INT8 estático (quantize=8, pesos int8 + ativações int8), ativação INT16 estática (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 várias linguagens: 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 de 3 nm (SM8850) tem 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 para uma única imagem — a média de 15 execuções após 3 execuções de aquecimento em bus.jpg, medidas com o 0.6.10 do plugin Ultralytics para Flutter e os recursos v0.6.6 padronizados. A ordem CPU/GPU foi alternada entre tarefas numa única sequência. Os registos nativos confirmaram que todas as linhas da CPU utilizaram a CPU/XNNPACK do LiteRT e que todas as linhas da GPU delegaram o grafo completo ao OpenCL do LiteRT (LITERT_CL).
• A exportação LiteRT rastreia diretamente o modelo PyTorch, produzindo um .tflite NCHW com uma entrada float — o delegado da GPU compila o grafo completo (aqui, todas as sete tarefas são executadas na GPU Adreno), e w8a32 não requer dados de calibração. Os consumidores devem ler as formas dos tensores e os nomes das assinaturas em vez de presumir o layout NHWC legado do onnx2tf ou os nomes de saída Identity; os dados RGB devem ser empacotados diretamente como CHW planar ou transpostos antes da inferência. As exportações semânticas devolvem logits NCHW e requerem um argmax de classe no host. Os recursos oficiais para Android estão alojados na versão v0.6.6 da aplicação yolo-flutter-app, com o registo detalhado do benchmark no documento de desempenho do Flutter.
• Os números correspondentes da NPU Hexagon do Snapdragon e da CPU/GPU LiteRT encontram-se na integração Qualcomm QNN.
• Compara os resultados da CPU/acelerador Apple na integração CoreML.

As medições seguintes dos dispositivos utilizam os mesmos recursos v0.6.6 padronizados.

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 Efficiency até 2.25 GHz), GPU PowerVR D-Series e Google TPU. As frequências dos núcleos e o nome do controlador da GPU foram lidos no dispositivo do benchmark, porque a Google não os publica nas especificações associadas.

Benchmark: Média de 15 chamadas predict() após 3 aquecimentos em bus.jpg, utilizando ultralytics_yolo, 0.6.10 e os recursos oficiais v0.6.6. A ordem CPU/GPU alterna entre tarefas numa única sequência. Os registos nativos confirmaram que todas as linhas da CPU utilizaram a CPU/XNNPACK do LiteRT e que todas as linhas da GPU delegaram o grafo completo ao OpenCL do LiteRT (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 C1-Pro de desempenho até 3.26 GHz e 6 núcleos C1-Pro de eficiência até 2.76 GHz), GPU Xclipse 960 e NPU Samsung.

Benchmark: Média de 15 chamadas predict() após 3 aquecimentos em bus.jpg, utilizando ultralytics_yolo, 0.6.10 e os recursos oficiais v0.6.6. A ordem CPU/GPU alterna entre tarefas numa única sequência. Os registos nativos confirmaram que todas as linhas da CPU utilizaram a CPU/XNNPACK do LiteRT e que todas as linhas da GPU delegaram o grafo completo ao OpenCL do LiteRT (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 de 3 nm (MT6993) 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 NPU MediaTek 990.

Benchmark: Média de 15 chamadas predict() após 3 aquecimentos em bus.jpg, utilizando ultralytics_yolo, 0.6.10 e os recursos oficiais v0.6.6. A ordem CPU/GPU alterna entre tarefas numa única sequência. Os registos nativos confirmaram que todas as linhas da CPU utilizaram a CPU/XNNPACK do LiteRT e que todas as linhas da GPU delegaram o grafo completo ao OpenCL do LiteRT (LITERT_CL).

Tarefas suportadas#

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

Exportar para LiteRT: converter o teu modelo YOLO#

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

Instalação#

Para instalar o pacote necessário, executa:

# Install the required package for YOLO
pip install ultralytics

Para obter instruções detalhadas e boas práticas, consulta o nosso guia de instalação da Ultralytics. Se encontrares dificuldades, consulta o nosso guia de problemas comuns.

Utilização#

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

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 obter mais detalhes sobre o processo de exportação, visita a página da documentação da Ultralytics sobre exportação.

Implementação de modelos YOLO LiteRT exportados#

Depois de exportares o teu modelo Ultralytics YOLO para LiteRT, podes implementá-lo em várias plataformas. A forma mais rápida de o verificar localmente é o método YOLO("yolo26n.tflite") mostrado acima. Para implementação noutros ambientes, consulta os seguintes recursos:

Dispositivos móveis e incorporados#

• Android: Um guia de início rápido para integrar o LiteRT em aplicações Android.
• iOS: Um guia para integrar e implementar modelos LiteRT em aplicações iOS.
• Linux incorporado e Raspberry Pi: Executa modelos LiteRT em computadores de placa única, opcionalmente acelerados com um Coral Edge TPU.
• Microcontroladores: Implementa em MCUs com apenas alguns quilobytes de memória — o runtime principal ocupa 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 a computação no servidor e mantendo os dados no dispositivo do utilizador.
• Exemplos de ponta a ponta: Exemplos práticos e tutoriais para implementar o LiteRT em dispositivos móveis, edge e na web.

Resumo#

Neste guia, explicámos como exportar modelos Ultralytics YOLO para o formato LiteRT. Ao consolidar a implementação em dispositivos móveis/edge (anteriormente TFLite) e no navegador (anteriormente TF.js) num único modelo .tflite, o LiteRT torna os teus modelos YOLO mais rápidos, mais pequenos e portáteis em praticamente qualquer destino no dispositivo.

Para mais informações, consulta 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ções, que contém muitos recursos úteis.

Perguntas frequentes#