Link to this sectionExporta 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

Link to this sectionPor 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.

Link to this sectionPrincipais 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.

Link to this sectionDesempenho Medido#

Inferência de imagem única de ponta a ponta para os assets oficiais do YOLO26n Android LiteRT (w8a32: pesos int8, ativações FP32) em um telefone Xiaomi 17 equipado com o Qualcomm Snapdragon 8 Elite Gen 5 (SM8850), medidos através do plugin Ultralytics Flutter 0.6.10. Cada célula mostra o tempo total (pré-processamento + inferência + pós-processamento, excluindo anotação) com a divisão por etapa logo abaixo. A CPU executa o delegate LiteRT XNNPACK; a GPU executa o delegate LiteRT OpenCL/GL (FP16).

• Os valores de velocidade são latências de disparo em imagem única — a média de 15 execuções após 3 execuções de aquecimento em bus.jpg, medidas com o mecanismo de benchmark no dispositivo do plugin Flutter em modo de perfil. O conjunto completo de tarefas é executado consecutivamente, portanto a fase de pré-processamento vinculada ao CPU reflete a operação sustentada (uma medição de tarefa única com repouso térmico é menor); a fase de inferência GPU/CPU é o custo computacional de estado estacionário.
• A exportação LiteRT rastreia o modelo PyTorch diretamente, produzindo um .tflite NCHW com uma entrada float — o delegate da GPU compila todo o grafo (todas as sete tarefas são executadas na GPU Adreno aqui), e w8a32 não precisa de dados de calibração. Os assets oficiais do Android estão hospedados na versão v0.6.6 do yolo-flutter-app, com o registro detalhado de benchmark no doc de desempenho do Flutter.
• Os números correspondentes da Hexagon NPU da Snapdragon (e a linha de base INT8 TFLite CPU/GPU) estão na Qualcomm QNN integration.

Link to this sectionExportar 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.

Link to this sectionInstalaçã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.

Link to this sectionUso#

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")  # creates 'yolo26n.tflite'

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Dynamic INT8: int8 weights, FP32 activations - no calibration data needed
model.export(format="litert", quantize="w8a32")  # creates 'yolo26n_w8a32.tflite'

# Static INT8: int8 weights + int8 activations - needs calibration data
model.export(format="litert", quantize=8, data="coco8.yaml")  # creates 'yolo26n_int8.tflite'

# Static w8a16: int8 weights + int16 activations (higher accuracy) - needs calibration data
model.export(format="litert", quantize="w8a16", data="coco8.yaml")  # creates 'yolo26n_w8a16.tflite'

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")

Link to this sectionArgumentos de Exportação#

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

Link to this sectionImplementando 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:

Link to this sectionMó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.

Link to this sectionNavegador 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.

Link to this sectionResumo#

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.

Link to this sectionFAQ#

Link to this sectionComo 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")  # creates 'yolo26n.tflite'

Para utilizadores da CLI:

yolo export model=yolo26n.pt format=litert # creates 'yolo26n.tflite'

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

Link to this sectionQual é 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.

Link to this sectionPosso 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.

Link to this sectionPosso 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.

Link to this sectionO 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.

Link to this sectionComo 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.