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

LiteRT (abreviação de Lite Runtime) é o runtime de alto desempenho do Google para IA em dispositivos. É 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, integrados, edge e no navegador — cobrindo tudo o que os formatos de exportação 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, estimativa de pose e classificação para que sejam executados de forma rápida e offline numa ampla gama de dispositivos.

npm i @ultralytics/yolo @litertjs/core

Por que deverias exportar para LiteRT?#

LiteRT é uma framework open-source projetada para inferência em dispositivos, também conhecida como computação de edge. Dá aos programadores as ferramentas para executar modelos treinados em dispositivos móveis, integrados e IoT, computadores tradicionais e — através 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 de 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 — substituindo a necessidade de uma exportação separada de 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), 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 compactar 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 de 3 nm (SM8850) possui um 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, medidos com o plugin Flutter do Ultralytics 0.6.10 e os ativos padronizados v0.6.6. A ordem de CPU/GPU alternou entre tarefas numa varredura sequencial. Os registos nativos confirmaram que cada linha de CPU utilizou 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 vírgula flutuante — o delegado de GPU compila o grafo inteiro (as sete tarefas são executadas no GPU Adreno aqui) e o w8a32 não precisa de dados de calibração. Deves ler as formas dos tensores e os nomes das assinaturas em vez de assumir o layout NHWC legado do onnx2tf ou nomes de saída Identity; empacota os dados RGB diretamente como CHW planar ou transpõe-os antes da inferência. As exportações semânticas devolvem logits NCHW e requerem um argmax de classe no lado do anfitrião. Os ativos oficiais do Android estão alojados no lançamento v0.6.6 do yolo-flutter-app, com o registo de desempenho detalhado no documento de desempenho do Flutter.
• Os números correspondentes do Hexagon NPU da Snapdragon e do LiteRT CPU/GPU encontram-se na integração Qualcomm QNN.
• Compara os resultados do CPU/acelerador da Apple na integração CoreML.

As seguintes varreduras de dispositivos utilizam os mesmos ativos 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 possui um 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 Google. As velocidades de relógio do núcleo e o nome do controlador de GPU foram lidos a partir do dispositivo de benchmark porque a Google não os publica nas especificações ligadas.

Benchmark: Média de 15 chamadas predict() após 3 aquecimentos em bus.jpg, utilizando ultralytics_yolo 0.6.10 e os ativos oficiais v0.6.6. A ordem de CPU/GPU alterna entre tarefas numa varredura sequencial. Os registos nativos confirmaram que cada linha de CPU utilizou 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 possui um 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 Samsung.

Benchmark: Média de 15 chamadas predict() após 3 aquecimentos em bus.jpg, utilizando ultralytics_yolo 0.6.10 e os ativos oficiais v0.6.6. A ordem de CPU/GPU alterna entre tarefas numa varredura sequencial. Os registos nativos confirmaram que cada linha de CPU utilizou 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 possui um 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 predict() após 3 aquecimentos em bus.jpg, utilizando ultralytics_yolo 0.6.10 e os ativos oficiais v0.6.6. A ordem de CPU/GPU alterna entre tarefas numa varredura sequencial. Os registos nativos confirmaram que cada linha de CPU utilizou 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 Ultralytics. Se encontrares dificuldades, consulta o nosso guia de problemas comuns.

Uso#

Todos os modelos Ultralytics YOLO suportam exportação nativamente. O formato LiteRT suporta os modos Exportar, Prever e Validar, para que possas exportar um modelo, carregá-lo para executar 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, visite a página de documentação do Ultralytics sobre exportação.

Implementando modelos YOLO LiteRT exportados#

Após exportares o teu modelo Ultralytics YOLO para LiteRT, podes implementá-lo em várias plataformas. A maneira mais rápida de verificar localmente é o método YOLO("yolo26n.tflite") mostrado acima. Para implementação noutros 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 implementar modelos LiteRT em aplicações iOS.
• Linux Integrado 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 kilobytes 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 a computação no lado do servidor e mantendo os dados no dispositivo do utilizador.
• Exemplos de ponta a ponta: Exemplos práticos e tutoriais para implementar LiteRT em dispositivos móveis, edge e web.

Resumo#

Neste guia, abordámos como exportar modelos Ultralytics YOLO para o formato LiteRT. Ao consolidar a implementação móvel/edge (anteriormente TFLite) e navegador (anteriormente TF.js) num único modelo .tflite, o LiteRT torna os teus modelos YOLO mais rápidos, menores e portáteis em praticamente todos os alvos de dispositivos.

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

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

FAQ#

Como exporto um modelo YOLO para o formato LiteRT?#

Usa a biblioteca Ultralytics para exportar um modelo YOLO para LiteRT (.tflite). Primeiro, instala o pacote:

pip install ultralytics

Depois, exporta o teu modelo:

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

Para utilizadores da CLI:

yolo export model=yolo26n.pt format=litert imgsz=640 # use imgsz=224 for classification

Para mais detalhes, visite o guia de exportação do Ultralytics.

Qual é a diferença entre LiteRT, TFLite e TF.js?#

LiteRT é o novo nome para TensorFlow Lite — o mesmo formato de modelo .tflite, a mesma linhagem de runtime, renomeado pelo Google. Na Ultralytics, o único formato de exportação litert cobre agora ambos os casos de uso que anteriormente exigiam dois formatos separados:

• O antigo formato tflite → implementação móvel, integrada e edge.
• O antigo formato tfjs → implementação em navegador e Node.js, agora tratado pelo LiteRT.js executando o mesmo ficheiro .tflite.

Se tiveres um ficheiro .tflite existente, podes carregá-lo diretamente com YOLO("model.tflite") e ele será executado através do backend LiteRT.

Posso executar modelos YOLO LiteRT num Raspberry Pi?#

Sim. Exporta o teu modelo para o formato LiteRT e, em seguida, executa-o num Raspberry Pi para melhorar as velocidades de inferência. Para otimização adicional, considera um Coral Edge TPU. Para passos detalhados, consulta o nosso guia de implementação Raspberry Pi.

Posso executar modelos YOLO no navegador com LiteRT?#

Sim. O LiteRT.js executa o mesmo modelo .tflite exportado diretamente num navegador web ou aplicação Node.js, com aceleração WebGPU/WASM. Isto substitui o fluxo de trabalho anterior do TensorFlow.js — não existe exportação de navegador separada, basta implementar o teu modelo LiteRT com o runtime LiteRT.js.

O LiteRT suporta inferência FP16 (meia precisão)?#

Sim — em tempo de execução. Um modelo LiteRT FP32 é executado automaticamente em FP16 quando executado num delegado de GPU (WebGPU, OpenCL ou Metal), que é a abordagem oficial do LiteRT. Portanto, não precisas de uma exportação FP16 dedicada; para maior compressão, usa quantização INT8 com quantize=8.

Como resolvo problemas comuns durante a exportação LiteRT?#

Se encontrares erros ao exportar modelos YOLO para LiteRT, as soluções comuns incluem:

• Verificar plataforma: A exportação LiteRT é suportada em Linux x86_64 e macOS. Verifica se o teu ambiente corresponde.
• Verificar compatibilidade do pacote: Garante que estás a usar uma versão compatível da Ultralytics. Consulta o nosso guia de instalação.
• Problemas de quantização: Ao usar a quantização INT8, certifique-se de que o caminho do seu conjunto de dados esteja especificado corretamente no parâmetro data.

Para dicas adicionais de solução de problemas, visite nosso Guia de Problemas Comuns.