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

LiteRT (abreviatura de ambiente de execução leve) é o ambiente de execução de elevado desempenho da Google para IA no dispositivo. É a nova geração e a nova designação do TensorFlow Lite (TFLite), e utiliza o mesmo formato de modelo .tflite. Com o LiteRT, um único modelo Ultralytics YOLO exportado pode ser implementado em dispositivos móveis, sistemas incorporados, dispositivos de periferia e navegadores — abrangendo tudo o que os formatos de exportação mais antigos tflite e tfjs tratavam separadamente, agora numa única solução.

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 sem ligação à Internet numa ampla variedade de dispositivos.

npm i @ultralytics/yolo @litertjs/core

Por que exportar para LiteRT?#

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

Um formato de modelo, todos os destinos:

• Dispositivos móveis e sistemas incorporados: Android, iOS, Linux incorporado e microcontroladores (MCUs).
• Aceleradores de periferia: compatível com o Coral Edge TPU para obter aceleração adicional.
• Navegador e Node.js: o LiteRT.js executa na Web o mesmo modelo .tflite 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 dados localmente, aumenta a privacidade ao não transmitir dados pessoais e minimiza o tamanho do modelo para economizar espaço.
• Suporte a várias plataformas: funciona em Android, iOS, Linux embarcado, microcontroladores e navegadores modernos.
• Aceleração de hardware: aproveita o XNNPACK na CPU e a aceleração da GPU via OpenCL, Metal e WebGPU. Por padrão, o delegado da GPU executa em FP16 para oferecer mais velocidade.
• Quantização: oferece suporte a FP32, INT8 estático (quantize=8, pesos int8 + ativações int8), INT16-activation estático (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 compactar modelos e acelerar a inferência com perda mínima de precisão.
• Suporte a diversas 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 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 Performance de até 3.62 GHz), GPU Adreno e NPU Hexagon.

• Os valores de velocidade correspondem a 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 plugin Flutter da Ultralytics 0.6.10 e os recursos padronizados v0.6.6. A ordem de CPU/GPU alternou entre tarefas em uma única sequência de testes. Os registros 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).
• 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.6.6 do yolo-flutter-app, e o registro detalhado do benchmark está no documento de desempenho do Flutter.
• Os números correspondentes da NPU Hexagon do Snapdragon e da CPU/GPU do LiteRT estão na integração do Qualcomm QNN.
• Compare os resultados da CPU/acelerador da Apple na integração do CoreML.

Os testes dos dispositivos a seguir usam os mesmos recursos padronizados v0.6.6.

Google Pixel 10#

Hardware: Google Pixel 10 com 12 GB de memória e Android 16 / API 36. 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 Performance de até 3.05 GHz e 2 núcleos Efficiency de até 2.25 GHz), GPU PowerVR D-Series e TPU Google. As frequências dos núcleos e o nome do driver da GPU foram obtidos no dispositivo de benchmark, pois o Google não os publica nas especificações vinculadas.

Benchmark: média de 15 chamadas predict() após 3 execuções de aquecimento em bus.jpg, usando ultralytics_yolo 0.6.10 e os recursos oficiais v0.6.6. A ordem de CPU/GPU alterna entre tarefas em uma única sequência de testes. Os registros 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).

Samsung Galaxy S26#

Hardware: Samsung Galaxy S26 (SM-S942B) com 12 GB de memória e Android 16 / API 36. 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.

Benchmark: média de 15 chamadas predict() após 3 execuções de aquecimento em bus.jpg, usando ultralytics_yolo 0.6.10 e os recursos oficiais v0.6.6. A ordem de CPU/GPU alterna entre tarefas em uma única sequência de testes. Os registros 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).

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.

Benchmark: média de 15 chamadas predict() após 3 execuções de aquecimento em bus.jpg, usando ultralytics_yolo 0.6.10 e os recursos oficiais v0.6.6. A ordem de CPU/GPU alterna entre tarefas em uma única sequência de testes. Os registros 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).

Tarefas suportadas#

A exportação LiteRT oferece suporte às sete tarefas da Ultralytics. A segmentação semântica e a estimativa de profundidade estão disponíveis apenas com YOLO26, a única família que inclui esses cabeçalhos.

Exportar para LiteRT: convertendo seu modelo YOLO#

Você pode melhorar a eficiência da execução no dispositivo e ampliar as opções de implantação convertendo seus modelos para o formato LiteRT.

Instalação#

Para instalar o pacote necessário, executa:

# Install the required package for YOLO
pip install ultralytics

Para ver instruções detalhadas e práticas recomendadas, consulte nosso guia de instalação da Ultralytics. Se encontrar dificuldades, consulte nosso guia de problemas comuns.

Uso#

Todos os modelos YOLO da Ultralytics oferecem suporte à exportação desde o início. O formato LiteRT é compatível com os modos Exportar, Prever e Validar, para que você possa exportar um modelo e, em seguida, carregá-lo para executar inferências ou validar sua precisão localmente.

from ultralytics import YOLO

# Carrega um modelo YOLO26
model = YOLO("yolo26n.pt")

# Exporte o modelo para o formato LiteRT
model.export(format="litert", imgsz=640)  # cria 'yolo26n.tflite'; use imgsz=224 para classificação

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# INT8 dinâmico: pesos int8, ativações FP32 - sem necessidade de dados de calibração
model.export(format="litert", quantize="w8a32", imgsz=640)  # cria 'yolo26n_w8a32.tflite'

# INT8 estático: pesos int8 + ativações int8 - requer dados de calibração
model.export(format="litert", quantize=8, data="coco8.yaml", imgsz=640)  # cria 'yolo26n_int8.tflite'

# w8a16 estático: pesos int8 + ativações int16 (maior precisão) - requer dados de calibração
model.export(format="litert", quantize="w8a16", data="coco8.yaml", imgsz=640)  # cria 'yolo26n_w8a16.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")

Argumentos de exportação#

Para mais detalhes sobre o processo de exportação, visita a página da documentação da Ultralytics sobre exportação.

Implantação de modelos YOLO LiteRT exportados#

Depois de exportar seu modelo YOLO da Ultralytics para LiteRT, você pode implantá-lo em várias plataformas. A maneira mais rápida de verificá-lo localmente é o método YOLO("yolo26n.tflite") mostrado acima. Para implantá-lo em outros ambientes, consulte os recursos a seguir:

Dispositivos móveis e sistemas embarcados#

• Android: Guia de início rápido para integrar LiteRT em aplicações Android.
• iOS: 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 com aceleração de um Coral Edge TPU.
• Microcontroladores: Implanta em MCUs com apenas alguns kilobytes de memória — o ambiente de execução principal ocupa aproximadamente 16 KB em um 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 usuário.
• Exemplos de ponta a ponta: Exemplos práticos e tutoriais para implementar LiteRT em dispositivos móveis, na borda e na web.

Resumo#

Neste guia, mostramos como exportar modelos Ultralytics YOLO para o formato LiteRT. Ao unificar a implantação em dispositivos móveis e na borda (anteriormente TFLite) e no navegador (anteriormente TF.js) em um único modelo .tflite, LiteRT torna seus modelos YOLO mais rápidos, menores e portáteis em praticamente todos os dispositivos.

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

Além disso, se tiver curiosidade sobre outras integrações do Ultralytics YOLO, consulta nossa página do guia de integração para encontrar muitos recursos úteis.

Perguntas frequentes#