TF Lite Delegate: wat is het, GPU- en NNAPI-delegates

Wat is TF Lite Delegate: architectuur en werkingsprincipe

TF Lite Delegate — is een software-adapter tussen TensorFlow Lite Runtime en de hardwareversneller van het apparaat. De delegate onderschept de operaties van de modelgraaf (convoluties, pooling, matrixvermenigvuldigingen) en voert ze uit op een gespecialiseerde rekenaar in plaats van de CPU. Als de delegate een specifieke operatie niet ondersteunt, wordt deze op de CPU uitgevoerd — dit wordt partial delegation genoemd.

De architectuur van TF Lite Delegate is gebouwd rond de SimpleDelegate API-interface en de TfLiteDelegate-structuur in C++. Elke delegate implementeert methoden voor het delegeren van graafknopen, geheugentoewijzing en uitvoering op het doelapparaat. De ontwikkelaar verbindt de delegate via Interpreter::ModifyGraphWithDelegate voordat Invoke wordt aangeroepen. Volgens de TensorFlow Guide wordt de delegate automatisch toegepast op alle ondersteunde operaties van het model.

Compatibiliteitscontrole — een verplichte fase. Niet alle operaties worden door elke delegate ondersteund. TensorFlow Lite biedt de tool Delegation Compatibility Check: voer het model uit met de delegate en controleer hoeveel operaties (ops) zijn gedelegeerd. Indien minder dan 80% — kies dan een andere delegate of blijf op de CPU. Volgens TensorFlow (2025) ondersteunt GPU Delegate 45 operaties, NNAPI — 60+.

In IT Sectr-projecten gebruiken we GPU-delegates voor iOS en XNNPACK voor Android met ingebouwde compatibiliteitscontrole: het model wordt op alle delegates getest, de snelste met een delegatievolledigheid van ten minste 90% wordt gekozen.

// GPU Delegate-verbinding op Android
val gpuDelegate = GpuDelegate()
val options = Interpreter.Options().apply {
    addDelegate(gpuDelegate)
    setNumThreads(4)
}
val interpreter = Interpreter(modelBuffer, options)
interpreter.run(input, output)
gpuDelegate.close()

Controle van gedelegeerde operaties — compatibiliteitscontrole via Interpreter. Standaard accepteert de delegate alle operaties die hij ondersteunt. Gebruik voor foutopsporing logging van het aantal gedelegeerde knopen. Als het model aangepaste operaties (custom ops) bevat, versnelt de delegate deze niet, maar breekt ze ook niet — ze worden op de CPU uitgevoerd.

// Controleer aantal gedelegeerde operaties
val delegateCount = interpreter.getDelegateOpsCount(gpuDelegate)
val totalNodes = interpreter.getNodesCount()
Log.d("TFLite", "Gedelegeerd: $delegateCount / $totalNodes")
if (delegateCount < totalNodes * 0.8) {
    // Drempel 80% — kies een andere delegate
}

GPU Delegate: versnelling op de grafische processor

GPU Delegate — TensorFlow Lite-delegate voor het uitvoeren van het model op de GPU via OpenGL ES 3.1+ (Android) of Metal (iOS). Grafische processoren zijn geoptimaliseerd voor parallelle matrixoperaties — Core ML en convolutionele neurale netwerken (CNN) krijgen de grootste versnelling. GPU Delegate vermindert de inferentielatentie 4–8 keer voor modellen zoals MobileNet, EfficientNet, Inception.

Beperkingen van GPU Delegate: ondersteunt niet alle operaties (slechts 45 van de ~120 in TF Lite), vereist OpenGL ES 3.1 of Metal, verbruikt meer energie dan de CPU. GPU is inefficiënt voor batch size > 1 in mobiele scenario's. Volgens TensorFlow-benchmarks (2025) draait op een Pixel 8 met GPU Adreno 740 het model MobileNetV2 in 4.2 ms op de GPU tegenover 18.7 ms op de CPU — een versnelling van 4.4x.

Configuratie van GPU Delegate omvat de keuze van precisie: float16 vermindert de nauwkeurigheid maar versnelt de inferentie met 30–40% zonder merkbaar kwaliteitsverlies (voor de meeste taken). Schakel allow_precision_loss=true in voor maximale prestaties op de GPU. Gebruik float32 voor taken met hoge precisie (geneeskunde, financiën).

// GPU Delegate met precisie-optimalisatie
val gpuOptions = GpuDelegateFactory.Options().apply {
    isPrecisionLossAllowed = true
    inferencePreference = GpuDelegateFactory.Options.InferencePreference.SUSTAINED_SPEED
}
val delegate = GpuDelegateFactory.create(gpuOptions)

GPU Delegate op iOS gebruikt Metal Performance Shaders via Metal Delegate. Op iOS werkt de delegate via Core ML delegate voor Apple Neural Engine of direct via Metal. Apple A17 Pro voert MobileNetV2 uit in 1.3 ms — 6 keer sneller dan CPU. Metal delegate is beschikbaar vanaf iOS 12 en ondersteunt alle apparaten met een A7+ chip.

NNAPI Delegate: neurale netwerken op Android via Neural Networks API

NNAPI Delegate (Android Neural Networks API) — TF Lite-delegate die hardwareversnelling gebruikt via Android NN HAL (Hardware Abstraction Layer). NNAPI stuurt modeloperaties door naar NPU, DSP of GPU, afhankelijk van de beschikbare stuurprogramma's van het apparaat. Ondersteund op Android 8.1+ (API 27+) en is de aanbevolen standaarddelegate voor Android.

Voordeel van NNAPI — automatische selectie van de versneller. Als het apparaat een NPU heeft (Qualcomm Hexagon, MediaTek APU, Samsung NPU), delegeert NNAPI operaties er naartoe. Indien geen NPU — naar GPU via OpenCL. Als ook de GPU niet ondersteunt — naar CPU met DSP-optimalisaties. De ontwikkelaar specificeert geen concrete versneller — NNAPI kiest de optimale. Volgens Google I/O 2024 versnelt NNAPI delegate op Snapdragon 8 Gen 3 LLM-modellen 12 keer.

Beperkingen van NNAPI: ongelijke ondersteuning op verschillende apparaten. Oude apparaten (Android 8.1) hebben een beperkte set stuurprogramma's. Huawei met Kirin ondersteunt NNAPI niet via Google Services — gebruik GPU Delegate. Voor gegarandeerde compatibiliteit beveelt Google NNAPI Delegate aan als eerste keuze, met fallback naar GPU of XNNPACK.

// NNAPI Delegate met CPU-fallback
val nnApiOptions = NnApiDelegate.Options().apply {
    acceleratorName = null // null = automatische selectie
    allowFp16 = true
    executionPreference = NnApiDelegate.ExecutionPreference.SUSTAINED_SPEED
}
val delegate = NnApiDelegate(nnApiOptions)
val interpreter = Interpreter(model, Interpreter.Options().apply {
    addDelegate(delegate)
    setNumThreads(4)
})

NNAPI Accelerator Name — parameter voor expliciete selectie van de versneller. Indien null doorgegeven, kiest NNAPI automatisch. Specificeer voor testen een concrete: "qti", "google-edgetpu", "mediatek". De lijst met beschikbare versnellers wordt weergegeven via NnApiDelegate.getAvailableAccelerators(). Gebruik in productie automatische selectie met een compatibiliteitsdrempel.

XNNPACK Delegate: CPU-optimalisatie via SIMD

XNNPACK Delegate — TensorFlow Lite-delegate voor geoptimaliseerde uitvoering op de CPU via SIMD-instructies (ARM NEON, SSE, AVX). XNNPACK vereist geen GPU of NPU — het is een pure CPU-delegate, maar met 2–4x versnelling dankzij SIMD, operator fusion, memory pre-fetching en quantized inference (INT8). Ideaal voor apparaten zonder dedicated NPU of wanneer gegarandeerde compatibiliteit nodig is.

XNNPACK is ontwikkeld door Google als de standaard TF Lite-delegate voor CPU (standaard opgenomen in TFLite Runtime). Het ondersteunt 90+ operaties — meer dan GPU of NNAPI. XNNPACK is bijzonder efficiënt voor gekwantiseerde modellen (INT8, INT16): operaties worden 2–3 keer sneller uitgevoerd dan de float32-versie. Volgens Google-benchmarks (2025) versnelt XNNPACK INT8 MobileNetV2 2.8x ten opzichte van basis-CPU.

XNNPACK vs GPU: op apparaten zonder NPU is XNNPACK vaak sneller dan GPU Delegate voor kleine batches (1–4) — GPU heeft overhead voor gegevensoverdracht tussen CPU en GPU. XNNPACK werkt in dezelfde CPU-adresruimte — er is geen geheugenkopie. Voor modellen tot 5MB kan XNNPACK sneller zijn dan GPU. Voor grote CNN-modellen wint GPU vanwege parallellisme.

// XNNPACK Delegate standaard ingeschakeld in TFLite 2.18+
// Expliciet gebruik via 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)
})

XNNPACK Flags: USE_XNNPACK — schakelt de delegate geforceerd in, FLUSH_TO_ZERO — verwerking van gedenormaliseerde getallen voor versnelling, ENABLE_XNNPACK_SHAPES — dynamische ingangsafmetingen. Gebruik standaardopties voor maximale compatibiliteit. Schakel bij fouten op oude apparaten XNNPACK uit — het model werkt nog steeds op de CPU, maar langzamer.

Core ML en Metal Delegate: versnelling op iOS

Core ML Delegate — TensorFlow Lite-delegate voor iOS die het Apple Core ML Framework gebruikt. Core ML converteert het TF Lite-model naar .mlmodel-formaat en voert het uit op Apple Neural Engine (ANE), GPU (Metal) of CPU. Apple A17 Pro en M3 hebben een dedicated Neural Engine die Core ML automatisch gebruikt. Core ML Delegate versnelt de inferentie 5–10 keer ten opzichte van CPU op moderne iOS-apparaten.

Core ML op iOS ondersteunt flex delegate (dynamische delegatie van voor Core ML beschikbare operaties) en full model conversion (conversie van het hele model naar .mlmodel). Apple beveelt flex delegate aan — het is sneller omdat het tijdens runtime werkt zonder voorafgaande conversie. Core ML Delegate ondersteunt float32-, float16- en gekwantiseerde modellen (INT8).

Metal Delegate — een delegate op een lager niveau die direct met Metal Performance Shaders werkt. Gebruik Metal wanneer Core ML bepaalde operaties niet ondersteunt. Metal Delegate geeft maximale controle over de GPU, maar vereist meer code. Volgens Apple (WWDC 2024) kan Metal Delegate voor native Swift-modellen 15–20% sneller zijn dan Core ML vanwege het ontbreken van conversie-overhead.

// Core ML Delegate op iOS via 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)

Keuze tussen Core ML en Metal: Core ML — voor productie, Metal — voor randgevallen. Core ML beheert automatisch het NE-geheugen, ondersteunt fallback naar CPU en vereist geen handmatige conversie. Metal geeft controle over buffers en is geschikt voor aangepaste operaties. In IT Sectr-projecten gebruiken we Core ML Delegate voor alle iOS-modellen en Metal alleen voor realtime videoanalysetaken.

Hoe kiest u een delegate voor uw project

De keuze van TF Lite Delegate hangt af van het doelplatform, het model en de latentievereisten. Er bestaat geen universeel beste delegate — elk heeft sterke en zwakke punten. Optimale strategie: test alle beschikbare delegates op het doelapparaat en kies de minimaal voldoende snelle — niet de snelste, maar de minimaal voldoende.

Aanbevelingen voor keuze: voor Android met NPU (Snapdragon 8 Gen 2+, Dimensity 9000+) — NNAPI Delegate. Voor Android zonder NPU — XNNPACK Delegate (standaard). Voor iOS — Core ML Delegate. Gebruik voor cross-platform projecten de strategie: NNAPI op Android, Core ML op iOS, XNNPACK als fallback. GPU Delegate — wanneer NNAPI niet beschikbaar is en XNNPACK niet snel genoeg is.

Latentietesten — een verplichte selectiefase. Meet de inferentie bij minimale temperatuur (koel apparaat) en na 5 minuten continu werk (thermal throttling). GPU en NNAPI kunnen de prestaties verminderen bij opwarming. XNNPACK (CPU) heeft er minder last van. Gebruik TensorFlow Lite Benchmark Tool voor het automatisch testen van alle delegates op uw apparaat.

// Delegateselectiestrategie
fun selectDelegate(): TfLiteDelegate {
    return when {
        NnApiDelegate.getAvailableAccelerators()?.isNotEmpty == true ->
            NnApiDelegate()
        GpuDelegateFactory.isGpuDelegateAvailable() ->
            GpuDelegate()
        else -> XnnpackDelegate()
    }
}

Fallback-strategie — laad het model zonder uitzonderingen: als de delegate niet wordt ondersteund, voer dan uit op CPU. TensorFlow Lite gooit IllegalArgumentException bij een fout bij het maken van de delegate. Omsluit het maken van de delegate met try-catch en voer bij een fout het model uit zonder delegate. Een langzame maar werkende AI is beter dan een fout voor de gebruiker.