TF Lite Interpreter — Conceptos clave, interfaz e inferencia de modelos

Conceptos clave de TF Lite Interpreter

TF Lite Interpreter es un runtime minimalista que ejecuta un modelo de aprendizaje automático en el dispositivo sin infraestructura de servidor. El intérprete no admite entrenamiento, solo inferencia. Esto lo hace ligero: el tamaño binario del intérprete base en Android es de aproximadamente 300 KB.

El intérprete trabaja con modelos en formato .tflite, basado en FlatBuffers. Al crearse, el intérprete carga el modelo en memoria mediante mmap, proporcionando acceso directo a los datos sin copias. Luego, el intérprete asigna tensores según la descripción del modelo y queda listo para la ejecución.

Cada instancia del intérprete no es segura para hilos. Para ejecutar el mismo modelo en paralelo en varios hilos, cree instancias separadas del intérprete con copias del modelo. Para llamadas secuenciales en un solo hilo, una instancia del intérprete se puede reutilizar.

API del intérprete en Android e iOS

En Android, el intérprete está disponible a través de la API de Java en el paquete org.tensorflow.lite.Interpreter. El método principal es run(Object input, Object output), que acepta arreglos multidimensionales o ByteBuffer. Para un control más preciso, use los métodos runForMultipleInputsOutputs() y resizeInput().

En iOS, el intérprete está disponible a través de la API de Swift en el módulo TensorFlowLite. La interfaz básica es similar a Android: inicialización mediante Interpreter.init(modelPath:), asignación de tensores mediante allocateTensors(), ejecución mediante invoke(). La API de Swift admite Data y MLMultiTensor como tipos de datos de entrada.

Comparación de API por plataforma

Configuración de delegados para aceleración por hardware

Los delegados son componentes que transfieren la ejecución de operaciones a hardware especializado. El GPU Delegate utiliza OpenGL ES (Android) y Metal (iOS) para acelerar operaciones gráficas. El NNAPI Delegate transfiere la ejecución a NPU, DSP o GPU a través de la Android Neural Networks API.

Core ML Delegate está disponible en iOS y traduce las operaciones de TFLite al formato Core ML. Según Apple ML Benchmarking, el uso de Core ML Delegate en iPhone 15 Pro acelera la inferencia hasta 4x en comparación con la CPU. El delegado admite operaciones FP32 y FP16.

XNNPACK Delegate es una solución universal para CPU ARM, optimizada para procesadores móviles. No requiere hardware especial y admite INT8, FP16 y FP32. Se recomienda como delegado base que se activa en todos los dispositivos.

Gestión de memoria y tensores

El intérprete gestiona los tensores a través de un grupo de memoria que se asigna al llamar a allocateTensors(). El tamaño del grupo se determina según la descripción del modelo en el archivo .tflite. Después de la asignación, el intérprete no asigna memoria adicional durante la inferencia.

Para modelos con tamaños de entrada dinámicos, use resizeInput(). Este método reasigna memoria para los tensores de entrada según el nuevo tamaño. Después de cambiar el tamaño de un tensor de entrada, puede ser necesaria una reasignación mediante allocateTensors().

Al trabajar con múltiples modelos, es importante liberar recursos mediante close(). Las instancias del intérprete no liberadas pueden provocar fugas de memoria, especialmente en dispositivos con RAM limitada. Para iOS, use el conteo automático de referencias ARC; para Android, use try-with-resources o una llamada explícita a close().

Manejo de errores y depuración

Los errores más comunes al trabajar con el intérprete son discrepancias en las dimensiones de los tensores. Si los datos de entrada no coinciden con la forma esperada, el intérprete lanza IllegalArgumentException en Android o un error de runtime en iOS. Verifique las dimensiones mediante inputTensorAt() y outputTensorAt().

El segundo problema común son los operadores no compatibles al usar un delegado. Si un delegado no admite un operador, el intérprete vuelve automáticamente a la CPU para ese operador. Para identificar estas situaciones, active el registro mediante setCancelled() o revise los registros de TFLite.

TFLite proporciona una Herramienta de Benchmark para la creación de perfiles: medición del tiempo de ejecución de cada operador, consumo de memoria, comparación de delegados. La Herramienta de Benchmark está disponible como parte de TFLite Support Library y se puede ejecutar directamente en el dispositivo.

Ejemplos de inferencia mediante el intérprete

Ejemplo de ejecución de un modelo en Android con la API de Java utilizando GPU Delegate. El intérprete se crea con opciones que incluyen el delegado de GPU. Después de la inferencia, el resultado se lee del tensor de salida:

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", "Clase principal: " + bestClass);

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

Ejemplo de ejecución en Python para pruebas antes del despliegue. La API de Python de TFLite permite cargar .tflite, realizar la inferencia y mostrar el resultado. Se utiliza para depuración y verificación de precisión del modelo:

import tensorflow as tf
import numpy as np

# Cargar el modelo TFLite desde archivo
interpreter = tf.lite.Interpreter(model_path="model.tflite")
interpreter.allocate_tensors()

# Obtener detalles de tensores de entrada y salida
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Preparar datos de entrada aleatorios para pruebas
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 salida:", output_data.shape)