TF Lite Delegate: vad det är, GPU- och NNAPI-delegater

Vad är TF Lite Delegate: arkitektur och funktionsprincip

TF Lite Delegate — är en mjukvaruadapter mellan TensorFlow Lite Runtime och enhetens hårdvaruaccelerator. Delegaten fångar upp modellgrafens operationer (konvolutioner, pooling, matrismultiplikationer) och utför dem på en specialiserad dator istället för CPU. Om delegaten inte stöder en specifik operation utförs den på CPU — detta kallas partial delegation.

Arkitekturen för TF Lite Delegate är byggd kring SimpleDelegate API-gränssnittet och TfLiteDelegate-strukturen i C++. Varje delegat implementerar metoder för att delegera grafnoder, allokera minne och exekvera på målenheten. Utvecklaren ansluter delegaten via Interpreter::ModifyGraphWithDelegate före anrop av Invoke. Enligt TensorFlow Guide tillämpas delegaten automatiskt på alla operationer som modellen stöder.

Kompatibilitetskontroll — obligatoriskt steg. Alla operationer stöds inte av varje delegat. TensorFlow Lite tillhandahåller verktyget Delegation Compatibility Check: kör modellen med delegaten och kontrollera hur många operationer (ops) som har delegerats. Om mindre än 80% — är det bättre att välja en annan delegat eller stanna på CPU. Enligt TensorFlow (2025) stöder GPU Delegate 45 operationer, NNAPI — 60+.

I IT Sectr-projekt använder vi GPU-delegater för iOS och XNNPACK för Android med inbyggd kompatibilitetskontroll: modellen testas på alla delegater, den snabbaste med delegationsfullständighet på minst 90% väljs.

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

Kontroll av delegerade operationer — kompatibilitetskontroll via Interpreter. Som standard accepterar delegaten alla operationer som den stöder. För felsökning, använd loggning av antalet delegerade noder. Om modellen innehåller anpassade operationer (custom ops) accelererar delegaten dem inte men förstör dem inte heller — de utförs på CPU.

// Kontrollera antalet delegerade operationer
val delegateCount = interpreter.getDelegateOpsCount(gpuDelegate)
val totalNodes = interpreter.getNodesCount()
Log.d("TFLite", "Delegerat: $delegateCount / $totalNodes")
if (delegateCount < totalNodes * 0.8) {
    // 80% tröskel — välj en annan delegat
}

GPU Delegate: acceleration på grafikprocessorn

GPU Delegate — TensorFlow Lite-delegat för att köra modellen på GPU via OpenGL ES 3.1+ (Android) eller Metal (iOS). Grafikprocessorer är optimerade för parallella matrisoperationer — Core ML och konvolutionella neurala nätverk (CNN) får störst acceleration. GPU Delegate minskar inferenslatens med 4–8 gånger för modeller som MobileNet, EfficientNet, Inception.

Begränsningar för GPU Delegate: stöder inte alla operationer (endast 45 av ~120 i TF Lite), kräver OpenGL ES 3.1 eller Metal, förbrukar mer energi än CPU. GPU är ineffektiv för batch size > 1 i mobila scenarier. Enligt TensorFlow-riktmärken (2025) körs på en Pixel 8 med GPU Adreno 740 modellen MobileNetV2 på 4.2 ms på GPU jämfört med 18.7 ms på CPU — en acceleration på 4.4x.

Konfiguration av GPU Delegate inkluderar val av precision: float16 minskar noggrannheten men accelererar inferens med 30–40% utan märkbar kvalitetsförlust (för de flesta uppgifter). Aktivera allow_precision_loss=true för maximal prestanda på GPU. För uppgifter med hög precision (medicin, finans) använd float32.

// GPU Delegate med precisionsoptimering
val gpuOptions = GpuDelegateFactory.Options().apply {
    isPrecisionLossAllowed = true
    inferencePreference = GpuDelegateFactory.Options.InferencePreference.SUSTAINED_SPEED
}
val delegate = GpuDelegateFactory.create(gpuOptions)

GPU Delegate på iOS använder Metal Performance Shaders via Metal Delegate. På iOS fungerar delegaten via Core ML delegate för Apple Neural Engine eller direkt via Metal. Apple A17 Pro utför MobileNetV2 på 1.3 ms — 6 gånger snabbare än CPU. Metal delegate är tillgänglig från iOS 12 och stöder alla enheter med A7+-chip.

NNAPI Delegate: neurala nätverk på Android via Neural Networks API

NNAPI Delegate (Android Neural Networks API) — TF Lite-delegat som använder hårdvaruacceleration via Android NN HAL (Hardware Abstraction Layer). NNAPI omdirigerar modelloperationer till NPU, DSP eller GPU beroende på enhetens tillgängliga drivrutiner. Stöds på Android 8.1+ (API 27+) och är den rekommenderade standarddelegaten för Android.

Fördel med NNAPI — automatisk val av accelerator. Om enheten har NPU (Qualcomm Hexagon, MediaTek APU, Samsung NPU) delegerar NNAPI operationer till den. Om ingen NPU finns — till GPU via OpenCL. Om GPU inte heller stöder — till CPU med DSP-optimeringar. Utvecklaren specificerar inte en specifik accelerator — NNAPI väljer den optimala. Enligt Google I/O 2024 accelererar NNAPI delegate på Snapdragon 8 Gen 3 LLM-modeller 12 gånger.

Begränsningar för NNAPI: ojämnt stöd på olika enheter. Gamla enheter (Android 8.1) har en begränsad uppsättning drivrutiner. Huawei med Kirin stöder inte NNAPI via Google Services — använd GPU Delegate. För garanterad kompatibilitet rekommenderar Google NNAPI Delegate som första val, med fallback till GPU eller XNNPACK.

// NNAPI Delegate med CPU-fallback
val nnApiOptions = NnApiDelegate.Options().apply {
    acceleratorName = null // null = automatiskt val
    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 för explicit val av accelerator. Om null skickas väljer NNAPI automatiskt. För testning, ange en specifik: "qti", "google-edgetpu", "mediatek". Listan över tillgängliga acceleratorer visas via NnApiDelegate.getAvailableAccelerators(). I produktion, använd automatiskt val med kompatibilitetströskel.

XNNPACK Delegate: CPU-optimering via SIMD

XNNPACK Delegate — TensorFlow Lite-delegat för optimerad exekvering på CPU via SIMD-instruktioner (ARM NEON, SSE, AVX). XNNPACK kräver ingen GPU eller NPU — det är en ren CPU-delegat, men med 2–4x acceleration tack vare SIMD, operator fusion, memory pre-fetching och quantized inference (INT8). Idealisk för enheter utan dedicated NPU eller när garanterad kompatibilitet behövs.

XNNPACK utvecklades av Google som standard TF Lite-delegat för CPU (som standard ingår i TFLite Runtime). Stöder 90+ operationer — mer än GPU eller NNAPI. XNNPACK är särskilt effektivt för kvantiserade modeller (INT8, INT16): operationer körs 2–3 gånger snabbare än float32-versionen. Enligt Google-riktmärken (2025) accelererar XNNPACK INT8 MobileNetV2 2.8x jämfört med bas-CPU.

XNNPACK vs GPU: på enheter utan NPU är XNNPACK ofta snabbare än GPU Delegate för små batchar (1–4) — GPU har overhead för dataöverföring mellan CPU och GPU. XNNPACK arbetar i samma CPU-adressutrymme — det finns ingen minneskopiering. För modeller upp till 5MB kan XNNPACK vara snabbare än GPU. För stora CNN-modeller vinner GPU tack vare parallellism.

// XNNPACK Delegate aktiverad som standard i TFLite 2.18+
// Explicit användning 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 — tvingar på delegaten, FLUSH_TO_ZERO — bearbetning av denormaliserade tal för acceleration, ENABLE_XNNPACK_SHAPES — dynamiska inmatningsstorlekar. För maximal kompatibilitet, använd standardalternativ. Vid fel på gamla enheter, stäng av XNNPACK — modellen fungerar fortfarande på CPU, men långsammare.

Core ML och Metal Delegate: acceleration på iOS

Core ML Delegate — TensorFlow Lite-delegat för iOS som använder Apple Core ML Framework. Core ML konverterar TF Lite-modellen till .mlmodel-format och kör på Apple Neural Engine (ANE), GPU (Metal) eller CPU. Apple A17 Pro och M3 har dedicated Neural Engine som Core ML använder automatiskt. Core ML Delegate accelererar inferens 5–10 gånger jämfört med CPU på moderna iOS-enheter.

Core ML på iOS stöder flex delegate (dynamisk delegering av operationer som är tillgängliga för Core ML) och full model conversion (konvertering av hela modellen till .mlmodel). Apple rekommenderar flex delegate — det är snabbare eftersom det fungerar under körning utan föregående konvertering. Core ML Delegate stöder float32-, float16- och kvantiserade modeller (INT8).

Metal Delegate — en delegat på lägre nivå som arbetar direkt med Metal Performance Shaders. Använd Metal när Core ML inte stöder vissa operationer. Metal Delegate ger maximal kontroll över GPU, men kräver mer kod. Enligt Apple (WWDC 2024) kan Metal Delegate för inbyggda Swift-modeller vara 15–20% snabbare än Core ML på grund av avsaknad av konverteringsomkostnader.

// Core ML Delegate på 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)

Val mellan Core ML och Metal: Core ML — för produktion, Metal — för gränsfall. Core ML hanterar automatiskt NE-minne, stöder fallback till CPU och kräver ingen manuell konvertering. Metal ger kontroll över buffertar och är lämplig för anpassade operationer. I IT Sectr-projekt använder vi Core ML Delegate för alla iOS-modeller och Metal endast för realtidsvideoanalysuppgifter.

Hur man väljer delegat för projektet

Val av TF Lite Delegate beror på målplattform, modell och latenskrav. Det finns ingen universell bästa delegat — var och en har styrkor och svagheter. Optimal strategi: testa alla tillgängliga delegater på målenheten och välj den minimalt tillräckligt snabba — inte den snabbaste, utan den minimalt tillräckliga.

Rekommendationer för val: för Android med NPU (Snapdragon 8 Gen 2+, Dimensity 9000+) — NNAPI Delegate. För Android utan NPU — XNNPACK Delegate (standard). För iOS — Core ML Delegate. För plattformsoberoende projekt, använd strategi: NNAPI på Android, Core ML på iOS, XNNPACK som fallback. GPU Delegate — när NNAPI inte är tillgänglig och XNNPACK inte är tillräckligt snabb.

Latens testning — obligatoriskt urvalssteg. Mät inferens vid minimal temperatur (kall enhet) och efter 5 minuters kontinuerligt arbete (termisk strypning). GPU och NNAPI kan minska prestanda vid uppvärmning. XNNPACK (CPU) lider mindre. Använd TensorFlow Lite Benchmark Tool för automatisk testning av alla delegater på din enhet.

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

Fallback-strategi — ladda modellen utan undantag: om delegaten inte stöds, kör på CPU. TensorFlow Lite kastar IllegalArgumentException vid fel vid skapande av delegat. Linda in skapandet av delegaten i try-catch och vid fel kör modellen utan delegat. En långsam men fungerande AI är bättre än ett fel för användaren.