Link to this sectionExportação de modelo TFLite para implantação (obsoleto)#

A implantação de modelos de visão computacional em dispositivos de borda (edge) ou embarcados requer um formato que possa garantir um desempenho contínuo.

O formato de exportação antigo TensorFlow Lite ou TFLite otimizava modelos Ultralytics YOLO26 para tarefas como detecção de objetos e classificação de imagens em aplicações de edge. Este guia preserva o contexto de implantação legado do TFLite; use LiteRT para novas exportações.

Link to this sectionPor que o TFLite era usado para exportação?#

Introduzido pelo Google em maio de 2017 como parte de seu framework TensorFlow, o TensorFlow Lite, ou TFLite para abreviar, foi um framework de deep learning de código aberto projetado para inferência no dispositivo, também conhecido como edge computing. Ele oferecia aos desenvolvedores ferramentas para executar modelos treinados em dispositivos móveis, embarcados e IoT, bem como em computadores tradicionais.

O TensorFlow Lite suportava uma ampla gama de plataformas, incluindo Linux embarcado, Android, iOS e microcontroladores (MCUs). As exportações TFLite permitiam que as aplicações executassem modelos localmente e offline.

Link to this sectionPrincipais recursos dos modelos TFLite#

Os modelos TFLite oferecem uma ampla gama de recursos principais que permitem o aprendizado de máquina no dispositivo, ajudando os desenvolvedores a executar seus modelos em dispositivos móveis, embarcados e de borda:

• Otimização no dispositivo: O TFLite otimiza para ML no dispositivo, reduzindo a latência ao processar dados localmente, aumentando a privacidade ao não transmitir dados pessoais e minimizando o tamanho do modelo para economizar espaço.

• Suporte a múltiplas plataformas: O TFLite oferece ampla compatibilidade de plataforma, suportando Android, iOS, Linux embarcado e microcontroladores.

• Suporte a diversos idiomas: O TFLite é compatível com várias linguagens de programação, incluindo Java, Swift, Objective-C, C++ e Python.

• Alto desempenho: Alcança desempenho superior por meio de aceleração de hardware e otimização de modelo.

Link to this sectionDesempenho medido (histórico)#

Comparação antes/depois por tarefa na GPU Adreno de um Xiaomi 17 (Qualcomm Snapdragon 8 Elite Gen 5, SM8850), medida através do plugin Flutter da Ultralytics 0.6.8: os ativos legados onnx2tf INT8 TFLite (NHWC, entrada images) versus os novos ativos w8a32 LiteRT (NCHW, entrada args_0), ambos executados no LiteRT 2.x na mesma varredura consecutiva no imgsz do Android enviado. Cada célula é o tempo total (pré-processamento + inferência + pós-processamento) com a divisão por estágio abaixo; ambos os formatos compilados totalmente na GPU.

O w8a32 LiteRT iguala ou supera o formato legado onnx2tf INT8 em cinco das seis tarefas em latência total. Semantic continua sendo a regressão de formato porque os logits w8a32 NCHW custam mais tempo de inferência do que os logits legados NHWC, mesmo após a limpeza do pré-processamento. Os modelos legados onnx2tf funcionam inalterados no LiteRT 2.x junto com as novas exportações NCHW. Os ativos oficiais do Android LiteRT estão hospedados no release v0.6.6 do yolo-flutter-app, com o registro detalhado de benchmark no documento de desempenho do Flutter.

Link to this sectionRegressões de formato vs LiteRT#

Detecção YOLO26n no mesmo dispositivo na GPU Adreno de um Xiaomi 17 — TFLite INT8 legado onnx2tf versus os quatro formatos de quantização LiteRT, todos medidos em uma execução contínua (portanto, a inferência é a métrica comparável dependente do formato):

Problemas para a equipe do Google LiteRT / litert-torch, encontrados ao migrar ativos de produção Android do TFLite onnx2tf para o LiteRT:

1. O layout NCHW torna os consumidores cientes do layout. O litert-torch rastreia o modelo PyTorch e emite NCHW [1,3,H,W] com uma entrada float, enquanto a exportação TFLite onnx2tf era NHWC [1,H,W,3] — combinando com o layout da câmera/bitmap. O plugin Flutter atual escreve planar CHW diretamente durante o empacotamento RGB, evitando uma transposição HWC→CHW separada, mas consumidores mais simples ainda precisam de empacotamento planar direto ou uma transposição extra.
2. quantize="w8a16" não compila no delegado de GPU (OpenCL) e retorna silenciosamente para um caminho de CPU que é ~40× mais lento (~660 ms vs ~17 ms), tornando o formato de ativação int16 inutilizável para implantação em GPU.
3. O INT8 estático (quantize=8) é o formato de GPU mais lento — ~11 ms vs ~8,6 ms para o modelo onnx2tf INT8 equivalente, ou seja, o próprio caminho INT8 do LiteRT regride em relação ao formato que substituiu. O w8a32 de alcance dinâmico é o único formato LiteRT que iguala a velocidade do antigo INT8, e é por isso que ele é enviado agora.
4. Modelos semantic exportam como logits NCHW brutos sem opção de ArgMax no grafo, forçando um argmax do lado do host que não é amigável ao cache sobre [1, C, H, W] (cada plano de classe fica a um H×W completo de distância). Os caminhos onnx2tf, CoreML e QNN podem emitir um mapa de classe compacto.
5. Os tensores de saída foram renomeados para output_0, output_1, ... (vs Identity, Identity_1, ... do onnx2tf), o que quebrou silenciosamente a busca de formato de saída em tempo de execução até que o consumidor adicionasse os novos nomes.

Os números correspondentes do LiteRT w8a32 (o formato agora enviado) estão na página do LiteRT.

Link to this sectionOpções de implantação no TFLite#

Antes de analisarmos o exemplo de exportação de substituição pelo LiteRT, vamos entender como os modelos TFLite são normalmente usados.

O TFLite oferece várias opções de implantação no dispositivo para modelos de aprendizado de máquina, incluindo:

• Implantando com Android e iOS: Tanto aplicativos Android quanto iOS com TFLite podem analisar feeds de câmera e sensores baseados em borda para detectar e identificar objetos. O TFLite também oferece bibliotecas nativas para iOS escritas em Swift e Objective-C. O diagrama de arquitetura abaixo mostra o processo de implantação de um modelo treinado em plataformas Android e iOS usando TensorFlow Lite.

• Implementando com Linux embarcado: Se a execução de inferências em um Raspberry Pi usando o Guia Ultralytics não atender aos requisitos de velocidade para o seu caso de uso, você pode usar um modelo TFLite exportado para acelerar os tempos de inferência. Além disso, é possível melhorar ainda mais o desempenho utilizando um dispositivo Coral Edge TPU.

• Implantando com microcontroladores: Os modelos TFLite também podem ser implantados em microcontroladores e outros dispositivos com apenas alguns kilobytes de memória. O tempo de execução principal cabe em apenas 16 KB em um Arm Cortex M3 e pode executar muitos modelos básicos. Ele não requer suporte a sistema operacional, bibliotecas C ou C++ padrão ou alocação dinâmica de memória.

Link to this sectionSubstitua a exportação TFLite por LiteRT#

Para novas exportações, converta seu modelo para LiteRT. O modelo resultante mantém a extensão de arquivo .tflite.

Link to this sectionInstalação#

Para instalar os pacotes necessários, execute:

# Install the required package for YOLO26
pip install ultralytics

Para obter instruções detalhadas e práticas recomendadas relacionadas ao processo de instalação, consulte nosso Guia de Instalação do Ultralytics. Ao instalar os pacotes necessários para o YOLO26, se você encontrar alguma dificuldade, consulte nosso Guia de Problemas Comuns para obter soluções e dicas.

Link to this sectionUso#

Todos os modelos Ultralytics YOLO26 são projetados para suportar exportação pronta para uso, tornando fácil integrá-los ao seu fluxo de trabalho de implantação preferido. Você pode ver a lista completa de formatos de exportação suportados e opções de configuração para escolher a melhor configuração para sua aplicação.

O formato de substituição LiteRT suporta os modos Export, Predict e Validate. Exporte seu modelo e, em seguida, carregue o modelo .tflite exportado para executar a inferência ou validar 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")  # creates 'yolo26n.tflite'

from ultralytics import YOLO

# Load the exported TFLite model
model = YOLO("yolo26n.tflite")

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Load the exported TFLite 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 sectionImplantando modelos YOLO26 TFLite exportados#

Após exportar seu modelo Ultralytics YOLO26 para o formato LiteRT, você pode implantar o modelo .tflite resultante. O primeiro passo principal e recomendado para executar um modelo TFLite é usar o método YOLO("model.tflite"), conforme descrito no trecho de código de uso anterior. No entanto, para instruções detalhadas sobre como implantar seus modelos TFLite em vários outros ambientes, dê uma olhada nos seguintes recursos:

• Android: Um guia de início rápido para integrar o TensorFlow Lite em aplicativos Android, fornecendo etapas fáceis de seguir para configurar e executar modelos de aprendizado de máquina.

• iOS: Confira este guia detalhado para desenvolvedores sobre como integrar e implantar modelos TensorFlow Lite em aplicativos iOS, oferecendo instruções passo a passo e recursos.

• Exemplos de ponta a ponta: Esta página fornece uma visão geral de vários exemplos do TensorFlow Lite, apresentando aplicações práticas e tutoriais projetados para ajudar os desenvolvedores a implementar o TensorFlow Lite em seus projetos de aprendizado de máquina em dispositivos móveis e de borda.

Link to this sectionResumo#

Este guia preserva o fluxo de trabalho de implantação legada do TFLite. Para novas exportações, use LiteRT para criar modelos .tflite para ambientes de edge computing.

Para obter mais detalhes sobre o uso, visite a documentação oficial do TFLite.

Além disso, se você estiver curioso sobre outras integrações do Ultralytics YOLO26, confira nossa página do guia de integração. Você encontrará muitas informações úteis e insights lá.

Link to this sectionFAQ#

Link to this sectionComo substituo uma exportação TFLite pelo LiteRT?#

Para uma nova exportação, use o formato LiteRT. Primeiro, instale o pacote necessário usando:

pip install ultralytics

Em seguida, use o seguinte trecho de código para exportar seu 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 usuários da CLI, você pode fazer isso com:

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

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

Link to this sectionQuais são os benefícios de usar o TensorFlow Lite para implantação de modelos YOLO26?#

O TensorFlow Lite (TFLite) é uma estrutura de aprendizado profundo de código aberto projetada para inferência no dispositivo, tornando-o ideal para implantar modelos YOLO26 em dispositivos móveis, embarcados e de IoT. Os principais benefícios incluem:

• Otimização no dispositivo: Minimize a latência e aumente a privacidade processando dados localmente.
• Compatibilidade de plataforma: Suporta Android, iOS, Linux embarcado e MCU.
• Desempenho: Utiliza aceleração de hardware para otimizar a velocidade e a eficiência do modelo.

Para saber mais, confira o guia do TFLite.

Link to this sectionÉ possível executar modelos YOLO26 TFLite no Raspberry Pi?#

Sim, você pode executar modelos YOLO26 TFLite no Raspberry Pi para melhorar a velocidade de inferência. Primeiro, exporte seu modelo para o formato LiteRT conforme explicado acima. Em seguida, use uma ferramenta como o TensorFlow Lite Interpreter para executar o modelo no seu Raspberry Pi.

Para outras otimizações, considere usar o Coral Edge TPU. Para etapas detalhadas, consulte nosso guia de implantação do Raspberry Pi e o guia de integração do Edge TPU.

Link to this sectionPosso usar modelos TFLite em microcontroladores para previsões YOLO26?#

Sim, o TFLite suporta a implantação em microcontroladores com recursos limitados. O tempo de execução principal do TFLite requer apenas 16 KB de memória em um Arm Cortex M3 e pode executar modelos YOLO26 básicos. Isso o torna adequado para implantação em dispositivos com potência computacional e memória mínimas.

Para começar, visite o guia do TFLite Micro para microcontroladores.

Link to this sectionQuais plataformas são compatíveis com modelos YOLO26 exportados para TFLite?#

O TensorFlow Lite oferece ampla compatibilidade de plataforma, permitindo que você implante modelos YOLO26 em uma ampla gama de dispositivos, incluindo:

• Android e iOS: Suporte nativo por meio das bibliotecas TFLite para Android e iOS.
• Linux embarcado: Ideal para computadores de placa única, como o Raspberry Pi.
• Microcontroladores: Adequado para MCUs com recursos limitados.

Para obter mais informações sobre opções de implantação, consulte nosso guia de implantação detalhado.

Link to this sectionComo soluciono problemas comuns durante a exportação do modelo YOLO26 para LiteRT?#

Se você encontrar erros ao exportar modelos YOLO26 para LiteRT, as soluções comuns incluem:

• Verifique a compatibilidade do pacote: Certifique-se de estar usando versões compatíveis do Ultralytics, litert-torch e ai-edge-litert. Consulte nosso guia de instalação.
• Suporte ao modelo: Verifique se o modelo YOLO26 específico suporta a exportação LiteRT consultando a página de documentação de exportação do Ultralytics.
• 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.