TensorFlow Lite — o que é, principais recursos e aplicações

O que é TensorFlow Lite

TensorFlow Lite é um runtime especializado para executar modelos de machine learning em dispositivos com recursos limitados. Ao contrário do TensorFlow completo, o TFLite não suporta treinamento ou retropropagação — apenas inferência. Isso permite manter o tamanho binário da biblioteca mínimo: cerca de 300 KB para o interpretador base no Android.

A arquitetura do TFLite é construída em torno do formato .tflite, baseado em FlatBuffers. O FlatBuffers fornece acesso direto aos dados sem etapa de parsing, o que é crítico para dispositivos móveis com memória limitada. Um modelo no formato .tflite contém o grafo de computação, pesos e metadados em um único arquivo binário.

De acordo com o Google I/O 2024, o TFLite é usado no Google Photos, Gboard, YouTube e outros aplicativos do Google com um público combinado de mais de 4 bilhões de dispositivos. O framework suporta todas as principais arquiteturas: CNN, RNN, LSTM, Transformer e operações personalizadas via delegados.

Arquitetura do TensorFlow Lite

O runtime do TFLite consiste em quatro componentes. O TFLite Converter pega um modelo do TensorFlow (SavedModel, Keras, ConcreteFunction) e o converte para o formato .tflite com otimização opcional. O TFLite Interpreter carrega o arquivo .tflite e realiza a inferência, gerenciando tensores e memória.

Os delegados são componentes que transferem a execução de operações para hardware especializado. O GPU Delegate usa OpenGL ES e Metal, o NNAPI Delegate usa a API Android Neural Networks, o Core ML Delegate usa o Apple Core ML. O XNNPACK Delegate otimiza a execução em CPU ARM. Cada delegado suporta um conjunto específico de operadores.

O quarto componente é a Task Library, que fornece APIs de alto nível para tarefas típicas: classificação de imagens, detecção de objetos, segmentação, NLU. A Task Library funciona sobre o Interpretador e oculta os detalhes do gerenciamento de tensores.

Otimização de modelos e quantização

O TFLite suporta três níveis de quantização. A quantização inteira completa INT8 converte pesos e ativações de FP32 para inteiros de 8 bits. O tamanho do modelo é reduzido em 4x e a velocidade de inferência em dispositivos com suporte INT8 aumenta até 3x. A quantização FP16 reduz o tamanho pela metade com perda mínima de precisão.

A quantização dinâmica mantém os pesos em INT8 mas realiza os cálculos em FP32. Este modo é adequado para modelos sensíveis à precisão e oferece redução de tamanho de até 4x mantendo a qualidade. De acordo com o Google ML Performance Benchmarks, a quantização dinâmica é recomendada para modelos NLP.

Comparação dos modos de quantização TFLite

Aceleração por hardware no Android e iOS

No Android, o principal mecanismo de aceleração é o NNAPI Delegate, que transfere a execução de operações para NPU, DSP ou GPU via API Android Neural Networks. O NNAPI está disponível em dispositivos com Android 8.1+ e suporta cálculos INT8 e FP16. O GPU Delegate para Android usa OpenGL ES 3.1+ e Vulkan.

No iOS, a aceleração é fornecida pelo Core ML Delegate, que traduz as operações do TFLite para o formato Core ML e as executa no Apple Neural Engine. De acordo com o Apple ML Benchmarking, o uso do Core ML Delegate acelera a inferência no iPhone 15 Pro em até 4x em comparação com a CPU. O GPU Delegate para iOS usa Metal Performance Shaders.

O XNNPACK Delegate é uma solução multiplataforma para CPU ARM, otimizada para processadores móveis. O XNNPACK suporta operações FP32, FP16 e INT8 e não requer hardware especial. É recomendado como delegado base para todos os dispositivos.

Implantação de modelos com TFLite

O processo de implantação inclui três etapas. Primeira — converter o modelo para .tflite via TFLite Converter. Segunda — incluir o arquivo .tflite nos recursos do aplicativo. Para Android, o arquivo é colocado em assets; para iOS, no bundle do app via Xcode. Terceira — inicializar o Interpretador e realizar a inferência.

Para atualizações dinâmicas de modelos, o Google recomenda usar Firebase ML Model Downloading ou um mecanismo próprio de download da nuvem. O arquivo .tflite atualizado é salvo no armazenamento local e carregado no Interpretador na próxima inicialização.

Ao implantar, é importante considerar o tamanho do arquivo .tflite. O Google Play limita o tamanho do APK a 200 MB. Para modelos maiores que 50 MB, recomenda-se usar Android App Bundle ou baixar o modelo separadamente via Play Asset Delivery.

Exemplos de uso do TFLite em código

Exemplo de carregamento e execução de um modelo no Android com API Java. Use Interpreter.create() para carregar .tflite de assets e run() para inferência. Os dados de entrada e saída são passados como arrays multidimensionais ou ByteBuffer:

import org.tensorflow.lite.Interpreter;
import java.nio.MappedByteBuffer;
import java.io.FileInputStream;
import java.nio.channels.FileChannel;

MappedByteBuffer model = new FileInputStream(
    getAssets().openFd("model.tflite")
).getChannel().map(
    FileChannel.MapMode.READ_ONLY, 0, fc.size()
);

Interpreter interpreter = new Interpreter.create(model);
float[][] input = new float[1][224 * 224 * 3];
float[][] output = new float[1][1000];
interpreter.run(input, output);
interpreter.close();

Exemplo de uso do GPU Delegate no Android para aceleração por hardware. Adicione a dependência com.android.support:tensorflow-lite-gpu e especifique o delegado ao criar o Interpretador:

import org.tensorflow.lite.Interpreter;
import org.tensorflow.lite.gpu.GpuDelegate;

GpuDelegate gpuDelegate = new GpuDelegate.create();
Interpreter.Options options = new Interpreter.Options().addDelegate(gpuDelegate);
Interpreter interpreter = new Interpreter.create(model, options);

// Run inference on the input data
interpreter.run(input, output);

// Release delegate resources after inference
gpuDelegate.close();
interpreter.close();