TF Lite Delegate: qué es, delegados GPU y NNAPI

Qué es TF Lite Delegate: arquitectura y principio de funcionamiento

TF Lite Delegate es un adaptador de software entre TensorFlow Lite Runtime y el acelerador hardware del dispositivo. El delegado intercepta las operaciones del grafo del modelo (convoluciones, pooling, multiplicaciones de matrices) y las ejecuta en una unidad de cómputo especializada en lugar de la CPU. Si el delegado no admite una operación concreta, se ejecuta en la CPU — esto se llama delegación parcial.

Arquitectura de TF Lite Delegate se basa en la interfaz SimpleDelegate API y la estructura TfLiteDelegate en C++. Cada delegado implementa métodos de delegación de nodos del grafo, asignación de memoria y ejecución en el dispositivo destino. El desarrollador conecta el delegado mediante Interpreter::ModifyGraphWithDelegate antes de llamar a Invoke. Según la Guía de TensorFlow, el delegado se aplica automáticamente a todas las operaciones compatibles del modelo.

Verificación de compatibilidad es un paso obligatorio. No todas las operaciones son compatibles con cada delegado. TensorFlow Lite proporciona la herramienta Delegation Compatibility Check: ejecute el modelo con el delegado y verifique cuántas operaciones (ops) se delegan. Si menos del 80% están delegadas, considere elegir otro delegado o quedarse con la CPU. Según TensorFlow (2025), GPU Delegate admite 45 operaciones, NNAPI — 60+.

En los proyectos de IT Sectr, utilizamos delegados GPU para iOS y XNNPACK para Android con verificación de compatibilidad integrada: el modelo se prueba en todos los delegados, seleccionando el más rápido con al menos un 90% de delegación completa.

// Conexión de GPU Delegate en Android
val gpuDelegate = GpuDelegate()
val options = Interpreter.Options().apply {
    addDelegate(gpuDelegate)
    setNumThreads(4)
}
val interpreter = Interpreter(modelBuffer, options)
interpreter.run(input, output)
gpuDelegate.close()

Verificación de operaciones delegadas — control de compatibilidad mediante Interpreter. Por defecto, el delegado acepta todas las operaciones que soporta. Para depuración, use el registro de la cantidad de nodos delegados. Si el modelo contiene operaciones personalizadas (custom ops), el delegado no las acelera pero tampoco las rompe — se ejecutan en la CPU.

// Verificar cantidad de operaciones delegadas
val delegateCount = interpreter.getDelegateOpsCount(gpuDelegate)
val totalNodes = interpreter.getNodesCount()
Log.d("TFLite", "Delegadas: $delegateCount / $totalNodes")
if (delegateCount < totalNodes * 0.8) {
    // 80% de umbral — elija otro delegado
}

GPU Delegate: aceleración en el procesador gráfico

GPU Delegate es un delegado de TensorFlow Lite para ejecutar modelos en la GPU mediante OpenGL ES 3.1+ (Android) o Metal (iOS). Los procesadores gráficos están optimizados para operaciones matriciales paralelas — Core ML y las redes neuronales convolucionales (CNN) obtienen el mayor beneficio. GPU Delegate reduce la latencia de inferencia de 4 a 8 veces para modelos como MobileNet, EfficientNet, Inception.

Limitaciones de GPU Delegate: no admite todas las operaciones (solo 45 de ~120 en TF Lite), requiere OpenGL ES 3.1 o Metal, consume más energía que la CPU. La GPU es ineficiente para batch size > 1 en escenarios móviles. Según los benchmarks de TensorFlow (2025), en Pixel 8 con GPU Adreno 740, MobileNetV2 se ejecuta en 4.2 ms en GPU frente a 18.7 ms en CPU — una aceleración de 4.4x.

Configuración de GPU Delegate incluye selección de precisión: float16 reduce la precisión pero acelera la inferencia en un 30–40% sin pérdida de calidad notable (para la mayoría de las tareas). Active allow_precision_loss=true para máximo rendimiento en GPU. Para tareas de alta precisión (medicina, finanzas), use float32.

// GPU Delegate con optimización de precisión
val gpuOptions = GpuDelegateFactory.Options().apply {
    isPrecisionLossAllowed = true
    inferencePreference = GpuDelegateFactory.Options.InferencePreference.SUSTAINED_SPEED
}
val delegate = GpuDelegateFactory.create(gpuOptions)

GPU Delegate en iOS utiliza Metal Performance Shaders mediante Metal Delegate. En iOS, el delegado funciona a través del delegado Core ML para Apple Neural Engine o Metal directamente. Apple A17 Pro ejecuta MobileNetV2 en 1.3 ms — 6 veces más rápido que la CPU. Metal delegate está disponible desde iOS 12 y es compatible con todos los dispositivos con chip A7+.

NNAPI Delegate: redes neuronales en Android mediante Neural Networks API

NNAPI Delegate (Android Neural Networks API) es un delegado de TF Lite que utiliza aceleración hardware mediante Android NN HAL (Hardware Abstraction Layer). NNAPI redirige las operaciones del modelo a NPU, DSP o GPU según los controladores disponibles del dispositivo. Compatible con Android 8.1+ (API 27+) y es el delegado recomendado por defecto para Android.

Ventaja de NNAPI — selección automática del acelerador. Si el dispositivo tiene NPU (Qualcomm Hexagon, MediaTek APU, Samsung NPU), NNAPI delega las operaciones en él. Si no hay NPU — a la GPU mediante OpenCL. Si la GPU tampoco es compatible — a la CPU con optimizaciones DSP. El desarrollador no especifica un acelerador concreto — NNAPI selecciona el óptimo. Según Google I/O 2024, el delegado NNAPI en Snapdragon 8 Gen 3 acelera modelos LLM 12 veces.

Limitaciones de NNAPI: soporte desigual en diferentes dispositivos. Los dispositivos antiguos (Android 8.1) tienen un conjunto limitado de controladores. Huawei con Kirin no admite NNAPI mediante Google Services — use GPU Delegate. Para compatibilidad garantizada, Google recomienda NNAPI Delegate como primera opción, con respaldo a GPU o XNNPACK.

// NNAPI Delegate con respaldo a CPU
val nnApiOptions = NnApiDelegate.Options().apply {
    acceleratorName = null // null = selección automática
    allowFp16 = true
    executionPreference = NnApiDelegate.ExecutionPreference.SUSTAINED_SPEED
}
val delegate = NnApiDelegate(nnApiOptions)
val interpreter = Interpreter(model, Interpreter.Options().apply {
    addDelegate(delegate)
    setNumThreads(4)
})

Nombre del Acelerador NNAPI — un parámetro para la selección explícita del acelerador. Si se pasa null, NNAPI selecciona automáticamente. Para pruebas, especifique uno concreto: "qti", "google-edgetpu", "mediatek". La lista de aceleradores disponibles se obtiene mediante NnApiDelegate.getAvailableAccelerators(). En producción, use autoselección con un umbral de compatibilidad.

XNNPACK Delegate: optimización de CPU mediante SIMD

XNNPACK Delegate es un delegado de TensorFlow Lite para ejecución optimizada en CPU mediante instrucciones SIMD (ARM NEON, SSE, AVX). XNNPACK no requiere GPU ni NPU — es un delegado de CPU puro, pero con aceleración de 2 a 4 veces gracias a SIMD, fusión de operadores, prebúsqueda de memoria e inferencia cuantizada (INT8). Ideal para dispositivos sin NPU dedicada o cuando se necesita compatibilidad garantizada.

XNNPACK fue desarrollado por Google como delegado predeterminado de TF Lite para CPU (incluido en TFLite Runtime por defecto). Admite 90+ operaciones — más que GPU o NNAPI. XNNPACK es especialmente efectivo para modelos cuantizados (INT8, INT16): las operaciones se ejecutan de 2 a 3 veces más rápido que la versión float32. Según los benchmarks de Google (2025), XNNPACK acelera INT8 MobileNetV2 2.8x respecto a la CPU base.

XNNPACK vs GPU: en dispositivos sin NPU, XNNPACK suele ser más rápido que GPU Delegate para lotes pequeños (1–4) — la GPU tiene sobrecarga en la transferencia de datos entre CPU y GPU. XNNPACK opera en el mismo espacio de direcciones de la CPU — sin copia de memoria. Para modelos de hasta 5 MB, XNNPACK puede ser más rápido que GPU. Para modelos CNN grandes, la GPU gana gracias al paralelismo.

// XNNPACK Delegate habilitado por defecto en TFLite 2.18+
// Uso explícito mediante XnnpackDelegate
val xnnpackOptions = XnnpackDelegate.Options().apply {
    numThreads = 4
    flags = XnnpackDelegate.Flags.USE_XNNPACK
}
val delegate = XnnpackDelegate(xnnpackOptions)
val interpreter = Interpreter(modelBuffer, Interpreter.Options().apply {
    addDelegate(delegate)
})

Banderas de XNNPACK: USE_XNNPACK — habilita forzosamente el delegado, FLUSH_TO_ZERO — maneja números desnormalizados para aceleración, ENABLE_XNNPACK_SHAPES — tamaños de entrada dinámicos. Para máxima compatibilidad, use opciones predeterminadas. Si ocurren errores en dispositivos antiguos, desactive XNNPACK — el modelo sigue funcionando en CPU pero más lento.

Core ML y Metal Delegate: aceleración en iOS

Core ML Delegate es un delegado de TensorFlow Lite para iOS que utiliza Apple Core ML Framework. Core ML convierte el modelo TF Lite al formato .mlmodel y lo ejecuta en Apple Neural Engine (ANE), GPU (Metal) o CPU. Apple A17 Pro y M3 tienen un Neural Engine dedicado que Core ML utiliza automáticamente. Core ML Delegate acelera la inferencia de 5 a 10 veces respecto a la CPU en dispositivos iOS modernos.

Core ML en iOS admite flex delegate (delegación dinámica de operaciones disponibles para Core ML) y conversión completa del modelo (conversión de todo el modelo a .mlmodel). Apple recomienda flex delegate — es más rápido porque funciona en tiempo de ejecución sin conversión previa. Core ML Delegate admite modelos float32, float16 y cuantizados (INT8).

Metal Delegate es un delegado de más bajo nivel que funciona directamente con Metal Performance Shaders. Use Metal cuando Core ML no admita operaciones específicas. Metal Delegate proporciona control máximo sobre la GPU pero requiere más código. Según Apple (WWDC 2024), Metal Delegate para modelos Swift nativos puede ser 15–20% más rápido que Core ML debido a la ausencia de sobrecarga de conversión.

// Core ML Delegate en iOS mediante TFLite Swift API
import TensorFlowLite

let coreMLDelegate = CoreMLDelegate()
var options = InterpreterOptions()
options.addDelegate(coreMLDelegate)

let interpreter = try Interpreter(modelPath: modelPath, options: options)
try interpreter.invoke(at: 0)

Elección entre Core ML y Metal: Core ML para producción, Metal para casos extremos. Core ML gestiona automáticamente la memoria de NE, admite respaldo a CPU (fallback) y no requiere conversión manual. Metal proporciona control sobre búferes y es adecuado para operaciones personalizadas. En los proyectos de IT Sectr, usamos Core ML Delegate para todos los modelos iOS y Metal solo para tareas de videovigilancia en tiempo real.

Cómo elegir un delegado para tu proyecto

Elección de un TF Lite Delegate depende de la plataforma destino, el modelo y los requisitos de latencia. No existe un delegado universalmente mejor — cada uno tiene fortalezas y debilidades. La estrategia óptima: probar todos los delegados disponibles en el dispositivo destino y elegir el mínimamente rápido — no el más rápido, sino el mínimamente suficiente.

Recomendaciones por elección: para Android con NPU (Snapdragon 8 Gen 2+, Dimensity 9000+) — NNAPI Delegate. Para Android sin NPU — XNNPACK Delegate (predeterminado). Para iOS — Core ML Delegate. Para proyectos multiplataforma, use la estrategia: NNAPI en Android, Core ML en iOS, XNNPACK como respaldo. GPU Delegate — cuando NNAPI no esté disponible y XNNPACK no sea suficientemente rápido.

Pruebas de latencia son un paso obligatorio en la selección. Mida la inferencia a temperatura mínima (dispositivo frío) y después de 5 minutos de funcionamiento continuo (thermal throttling). GPU y NNAPI pueden reducir el rendimiento al calentarse. XNNPACK (CPU) se ve menos afectado. Use TensorFlow Lite Benchmark Tool para pruebas automáticas de todos los delegados en su dispositivo.

// Estrategia de selección de delegado
fun selectDelegate(): TfLiteDelegate {
    return when {
        NnApiDelegate.getAvailableAccelerators()?.isNotEmpty == true ->
            NnApiDelegate()
        GpuDelegateFactory.isGpuDelegateAvailable() ->
            GpuDelegate()
        else -> XnnpackDelegate()
    }
}

Estrategia de respaldo — cargue el modelo sin excepciones: si el delegado no es compatible, ejecute en CPU. TensorFlow Lite lanza IllegalArgumentException al producirse un error de creación del delegado. Envuelva la creación del delegado en try-catch y ejecute el modelo sin delegado en caso de error. Una IA lenta pero funcional es mejor que un error para el usuario.