TF Lite Interpreter — Conceitos-chave, interface e inferência de modelos

Conceitos-chave do TF Lite Interpreter

TF Lite Interpreter é um runtime minimalista que executa um modelo de aprendizado de máquina no dispositivo sem infraestrutura de servidor. O interpretador não suporta treinamento — apenas inferência. Isso o torna leve: o tamanho binário do interpretador base no Android é de cerca de 300 KB.

O interpretador trabalha com modelos no formato .tflite, baseado em FlatBuffers. Ao ser criado, o interpretador carrega o modelo na memória via mmap, fornecendo acesso direto aos dados sem cópia. Em seguida, o interpretador aloca tensores com base na descrição do modelo e fica pronto para execução.

Cada instância do interpretador não é thread-safe. Para executar o mesmo modelo em paralelo em várias threads, crie instâncias separadas do interpretador com cópias do modelo. Para chamadas sequenciais em uma única thread, uma instância do interpretador pode ser reutilizada.

API do interpretador no Android e iOS

No Android, o interpretador está disponível através da API Java no pacote org.tensorflow.lite.Interpreter. O método principal é run(Object input, Object output), que aceita arrays multidimensionais ou ByteBuffer. Para controle mais preciso, use os métodos runForMultipleInputsOutputs() e resizeInput().

No iOS, o interpretador está disponível através da API Swift no módulo TensorFlowLite. A interface básica é semelhante ao Android: inicialização via Interpreter.init(modelPath:), alocação de tensores via allocateTensors(), execução via invoke(). A API Swift suporta Data e MLMultiTensor como tipos de dados de entrada.

Comparação de API por plataforma

Configuração de delegados para aceleração de hardware

Delegados são componentes que transferem a execução de operações para hardware especializado. O GPU Delegate usa OpenGL ES (Android) e Metal (iOS) para acelerar operações gráficas. O NNAPI Delegate transfere a execução para NPU, DSP ou GPU através da Android Neural Networks API.

Core ML Delegate está disponível no iOS e traduz operações TFLite para o formato Core ML. De acordo com o Apple ML Benchmarking, usar Core ML Delegate no iPhone 15 Pro acelera a inferência até 4x em comparação com a CPU. O delegado suporta operações FP32 e FP16.

XNNPACK Delegate é uma solução universal para CPU ARM, otimizada para processadores móveis. Não requer hardware especial e suporta INT8, FP16 e FP32. É recomendado como delegado base que ativa em todos os dispositivos.

Gerenciamento de memória e tensores

O interpretador gerencia tensores através de um pool de memória alocado ao chamar allocateTensors(). O tamanho do pool é determinado com base na descrição do modelo no arquivo .tflite. Após a alocação, o interpretador não aloca memória adicional durante a inferência.

Para modelos com tamanhos de entrada dinâmicos, use resizeInput(). Este método realoca memória para tensores de entrada de acordo com o novo tamanho. Após redimensionar um tensor de entrada, pode ser necessária realocação via allocateTensors().

Ao trabalhar com vários modelos, é importante liberar recursos através de close(). Instâncias do interpretador não liberadas podem causar vazamentos de memória, especialmente em dispositivos com RAM limitada. Para iOS, use a contagem automática de referências ARC; para Android, use try-with-resources ou uma chamada explícita a close().

Tratamento de erros e depuração

Os erros mais comuns ao trabalhar com o interpretador são discrepâncias nas dimensões dos tensores. Se os dados de entrada não corresponderem à forma esperada, o interpretador lança IllegalArgumentException no Android ou um erro de runtime no iOS. Verifique as dimensões através de inputTensorAt() e outputTensorAt().

O segundo problema comum são operadores não suportados ao usar um delegado. Se um delegado não suportar um operador, o interpretador volta automaticamente para a CPU para esse operador. Para identificar tais situações, ative o registro através de setCancelled() ou verifique os logs do TFLite.

TFLite fornece uma Ferramenta de Benchmark para criação de perfis: medição do tempo de execução de cada operador, consumo de memória, comparação de delegados. A Ferramenta de Benchmark está disponível como parte da TFLite Support Library e pode ser executada diretamente no dispositivo.

Exemplos de inferência via interpretador

Exemplo de execução de um modelo no Android com API Java usando GPU Delegate. O interpretador é criado com opções incluindo o delegado GPU. Após a inferência, o resultado é lido do tensor de saída:

import org.tensorflow.lite.Interpreter;
import org.tensorflow.lite.gpu.GpuDelegate;
import java.nio.MappedByteBuffer;

MappedByteBuffer model = loadModelFile(context);
GpuDelegate gpu = new GpuDelegate();
Interpreter.Options opts = new Interpreter.Options().addDelegate(gpu);
Interpreter interpreter = new Interpreter.create(model, opts);

float[][] input = preprocessImage(bitmap);
float[][] output = new float[1][1000];
interpreter.run(input, output);

int bestClass = argmax(output[0]);
Log.d("TFLite", "Classe principal: " + bestClass);

gpu.close();
interpreter.close();

Exemplo de execução em Python para testes antes da implantação. A API Python do TFLite permite carregar .tflite, executar a inferência e exibir o resultado. Usado para depuração e verificação de precisão do modelo:

import tensorflow as tf
import numpy as np

# Carregar o modelo TFLite do arquivo
interpreter = tf.lite.Interpreter(model_path="model.tflite")
interpreter.allocate_tensors()

# Obter detalhes dos tensores de entrada e saída
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Preparar dados de entrada aleatórios para teste
input_data = np.random.randn(
    *input_details[0]["shape"]
).astype(np.float32)

interpreter.set_tensor(input_details[0]["index"], input_data)
interpreter.invoke()

output_data = interpreter.get_tensor(output_details[0]["index"])
print("Forma de saída:", output_data.shape)