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.

Assista: Como exportar Ultralytics YOLO26 para Google LiteRT | Implante IA de visão em Android e iOS | IA móvel 📱🚀

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 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.

• 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.

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.

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.

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.

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.

Inferência em CPU e NPU Intel#

Os modelos .tflite exportados são executados em hardware Intel por meio do plugin LiteRT Intel OpenVINO. Passa device=intel:cpu ou device=intel:npu, e o Ultralytics instala ai-edge-litert>=2.3.0 e ai-edge-litert-sdk-intel na primeira utilização. A NPU requer um processador Intel Core Ultra com o driver NPU da Intel instalado.

from ultralytics import YOLO

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

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.

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.

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#