.tflite — essência, estrutura e aplicação do formato de modelo TFLite

O que é o formato .tflite

.tflite é uma representação serializada de um modelo de aprendizagem automática otimizada para inferência em dispositivos com memória e capacidade computacional limitadas. Ao contrário do formato SavedModel, que armazena um grafo em protobuf e requer recursos significativos para carregar, o .tflite usa FlatBuffers — uma biblioteca de serialização com acesso a dados sem cópia.

O formato .tflite foi concebido tendo em conta as especificidades das plataformas móveis: consumo mínimo de memória durante o carregamento, arranque rápido e suporte para pesos quantizados. Um ficheiro .tflite não suporta treino — apenas inferência. Esta é uma diferença fundamental dos formatos completos do TensorFlow, permitindo reduzir significativamente o tamanho do runtime.

De acordo com a Google Research, 2024, os modelos em formato .tflite com quantização INT8 carregam 60% mais rápido que modelos FP32 equivalentes e consomem 40% menos RAM durante a inferência.

Estrutura interna do ficheiro .tflite

Um ficheiro .tflite consiste em várias secções organizadas de acordo com o esquema FlatBuffers. A secção principal é Model, que contém o grafo de computação (SubGraph), uma lista de operadores (OperatorCodes) e buffers de pesos. Cada SubGraph contém tensores, operadores e índices de entrada e saída.

A secção OperatorCodes contém identificadores de todos os operadores usados no modelo — Conv2D, DepthwiseConv2D, FullyConnected, Softmax e outros. Cada operador tem um código da lista predefinida BuiltinOperator. Se o modelo contiver operações não presentes na lista, são marcadas como Custom e requerem implementação através de um delegado ou operador personalizado.

A secção Buffers contém os dados binários dos pesos do modelo. Dependendo do modo de quantização, os pesos podem ser armazenados em FP32, FP16, INT8 ou num formato quantizado com parâmetros de escala. Os buffers são mapeados diretamente em memória via mmap, eliminando cópias adicionais.

Secções principais do ficheiro .tflite

Quantização e otimização do formato

.tflite suporta três modos de quantização. Quantização inteira completa INT8 — pesos e ativações são representados como inteiros de 8 bits. A conversão requer um conjunto de dados representativo para calibrar os intervalos de ativação. O tamanho do modelo é reduzido 4 vezes.

Quantização FP16 — os pesos são convertidos para números de vírgula flutuante de 16 bits. Este modo não requer calibração e oferece uma perda mínima de precisão. As ativações permanecem em FP32. O tamanho do modelo é reduzido 2 vezes. Recomendado para dispositivos com suporte FP16 em GPU e NPU.

Quantização dinâmica — os pesos são convertidos para INT8 mas as ativações são calculadas em FP32. O tamanho do modelo é reduzido 4 vezes enquanto a precisão se mantém superior à do INT8 completo. De acordo com Google ML Performance Benchmarks, este modo é ideal para modelos NLP e modelos com alta sensibilidade à precisão.

Criação de .tflite a partir de um modelo TensorFlow

Para converter um modelo para .tflite, use o TFLite Converter — um componente do TensorFlow disponível através da API Python tf.lite.TFLiteConverter. O conversor suporta três fontes: SavedModel, Keras H5 e ConcreteFunction. Um exemplo mínimo de conversão de um modelo Keras:

import tensorflow as tf

# Carregar o modelo Keras treinado do ficheiro
model = tf.keras.models.load_model("my_model.h5")

# Converter para .tflite com quantização dinâmica
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# Escrever o modelo convertido para um ficheiro .tflite
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

Para conversão com quantização INT8 completa, é necessário um conjunto de dados de calibração. Forneça um representative_dataset para determinar os intervalos de ativação:

converter = tf.lite.TFLiteConverter.from_saved_model("saved_model")
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [
    tf.lite.OpsSet.TFLITE_BUILTINS_INT8
]
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8
tflite_quant_model = converter.convert()

Ferramentas para trabalhar com .tflite

O Google fornece um conjunto de ferramentas para analisar e otimizar modelos .tflite. O TFLite Benchmark Tool mede o tempo de inferência no dispositivo e mostra estatísticas de cada operador. O TFLite Model Inspector visualiza o grafo de computação e mostra os tamanhos dos tensores.

Netron é um visualizador de modelos multiplataforma que suporta .tflite juntamente com ONNX, Core ML e PyTorch. O Netron exibe a estrutura do grafo, os parâmetros de cada operador e as ligações entre tensores. Útil para depuração durante a conversão.

A API de metadados TFLite permite adicionar metadados ao ficheiro .tflite: descrição do modelo, formato dos dados de entrada, unidades de medida e informação do autor. Os metadados são usados pela Task Library para configuração automática de pré-processamento e pós-processamento.

Exemplo de carregamento e execução de .tflite

Exemplo de carregamento de um modelo .tflite em iOS com Swift API. A Swift API do TFLite fornece um Interpreter para carregar o modelo a partir do pacote e executar a inferência. Especifique um delegado para aceleração de hardware através do Core ML Delegate:

import TensorFlowLite

guard let modelPath = Bundle.main.path(
    forResource: "model", ofType: "tflite"
) else { return }

let interpreter = try Interpreter.init(modelPath: modelPath)
try interpreter.allocateTensors()

// Preparar dados de entrada para o modelo
let inputData = Data.init(count: 1 * 224 * 224 * 3)
try interpreter.copy(inputData, toInputAt: 0)

// Executar inferência do modelo
try interpreter.invoke()

// Ler dados do tensor de saída
let outputTensor = try interpreter.output(at: 0)
let results = outputTensor.data.withUnsafeBytes {
    Array($0.bindMemory(to: Float32.self))
}