.tflite — esencia, estructura y aplicación del formato de modelo TFLite

Qué es el formato .tflite

.tflite es una representación serializada de un modelo de aprendizaje automático optimizada para inferencia en dispositivos con memoria y potencia de cálculo limitadas. A diferencia del formato SavedModel, que almacena un grafo en protobuf y requiere recursos significativos para cargarse, .tflite utiliza FlatBuffers, una biblioteca de serialización con acceso a datos sin copia.

El formato .tflite está diseñado teniendo en cuenta las particularidades de las plataformas móviles: consumo mínimo de memoria durante la carga, inicio rápido y soporte para pesos cuantizados. Un archivo .tflite no admite entrenamiento, solo inferencia. Esta es una diferencia fundamental respecto a los formatos completos de TensorFlow, que permite reducir significativamente el tamaño del runtime.

Según Google Research, 2024, los modelos en formato .tflite con cuantización INT8 se cargan un 60% más rápido que los modelos FP32 equivalentes y consumen un 40% menos de RAM durante la inferencia.

Estructura interna del archivo .tflite

Un archivo .tflite consta de varias secciones organizadas según el esquema FlatBuffers. La sección principal es Model, que contiene el grafo de computación (SubGraph), una lista de operadores (OperatorCodes) y búferes de pesos. Cada SubGraph contiene tensores, operadores e índices de entrada y salida.

La sección OperatorCodes contiene los identificadores de todos los operadores utilizados en el modelo: Conv2D, DepthwiseConv2D, FullyConnected, Softmax y otros. Cada operador tiene un código de la lista predefinida BuiltinOperator. Si el modelo contiene operaciones que no están en la lista, se marcan como Custom y requieren implementación mediante un delegado u operador personalizado.

La sección Buffers contiene los datos binarios de los pesos del modelo. Dependiendo del modo de cuantización, los pesos pueden almacenarse en FP32, FP16, INT8 o en un formato cuantizado con parámetros de escalado. Los búferes se mapean directamente en memoria mediante mmap, eliminando copias adicionales.

Secciones principales del archivo .tflite

Cuantización y optimización del formato

.tflite admite tres modos de cuantización. La cuantización entera completa INT8: los pesos y las activaciones se representan como enteros de 8 bits. La conversión requiere un conjunto de datos representativo para calibrar los rangos de activación. El tamaño del modelo se reduce 4 veces.

La cuantización FP16: los pesos se convierten a números de coma flotante de 16 bits. Este modo no requiere calibración y ofrece una pérdida mínima de precisión. Las activaciones permanecen en FP32. El tamaño del modelo se reduce 2 veces. Recomendado para dispositivos con soporte FP16 en GPU y NPU.

Cuantización dinámica: los pesos se convierten a INT8 pero las activaciones se calculan en FP32. El tamaño del modelo se reduce 4 veces mientras la precisión se mantiene superior a la de INT8 completo. Según Google ML Performance Benchmarks, este modo es óptimo para modelos NLP y modelos con alta sensibilidad a la precisión.

Creación de .tflite desde un modelo TensorFlow

Para convertir un modelo a .tflite se utiliza TFLite Converter, un componente de TensorFlow disponible a través de la API de Python tf.lite.TFLiteConverter. El conversor admite tres fuentes: SavedModel, Keras H5 y ConcreteFunction. Un ejemplo mínimo de conversión de un modelo Keras:

import tensorflow as tf

# Cargar el modelo Keras entrenado desde archivo
model = tf.keras.models.load_model("my_model.h5")

# Convertir a .tflite con cuantización dinámica
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# Escribir el modelo convertido en un archivo .tflite
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

Para la conversión con cuantización INT8 completa se requiere un conjunto de datos de calibración. Proporcione un representative_dataset para determinar los rangos de activación:

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

Herramientas para trabajar con .tflite

Google proporciona un conjunto de herramientas para analizar y optimizar modelos .tflite. TFLite Benchmark Tool mide el tiempo de inferencia en el dispositivo y muestra estadísticas de cada operador. TFLite Model Inspector visualiza el grafo de computación y muestra los tamaños de los tensores.

Netron es un visualizador de modelos multiplataforma que admite .tflite junto con ONNX, Core ML y PyTorch. Netron muestra la estructura del grafo, los parámetros de cada operador y las conexiones entre tensores. Es útil para depuración durante la conversión.

La API de metadatos de TFLite permite añadir metadatos al archivo .tflite: descripción del modelo, formato de datos de entrada, unidades de medida e información del autor. Los metadatos son utilizados por Task Library para la configuración automática de preprocesamiento y posprocesamiento.

Ejemplo de carga y ejecución de .tflite

Ejemplo de carga de un modelo .tflite en iOS con Swift API. La API Swift de TFLite proporciona un Interpreter para cargar el modelo desde el paquete y ejecutar la inferencia. Especifique un delegado para aceleración hardware mediante 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 datos de entrada para el modelo
let inputData = Data.init(count: 1 * 224 * 224 * 3)
try interpreter.copy(inputData, toInputAt: 0)

// Ejecutar inferencia del modelo
try interpreter.invoke()

// Leer datos del tensor de salida
let outputTensor = try interpreter.output(at: 0)
let results = outputTensor.data.withUnsafeBytes {
    Array($0.bindMemory(to: Float32.self))
}