TF Lite Delegate: ce este, delegații GPU și NNAPI

Ce este TF Lite Delegate: arhitectură și principiu de funcționare

TF Lite Delegate — este un adaptor software între TensorFlow Lite Runtime și acceleratorul hardware al dispozitivului. Delegațul interceptează operațiile grafului modelului (convoluții, pooling, înmulțiri matriceale) și le execută pe un calculator specializat în locul CPU-ului. Dacă delegațul nu suportă o operație specifică, aceasta este executată pe CPU — aceasta se numește partial delegation.

Arhitectura TF Lite Delegate se bazează pe interfața SimpleDelegate API și structura TfLiteDelegate în C++. Fiecare delegaț implementează metode de delegare a nodurilor grafului, alocare a memoriei și execuție pe dispozitivul țintă. Dezvoltatorul conectează delegațul prin Interpreter::ModifyGraphWithDelegate înainte de apelarea Invoke. Conform TensorFlow Guide, delegațul se aplică automat la toate operațiile suportate ale modelului.

Verificarea compatibilității — etapă obligatorie. Nu toate operațiile sunt suportate de fiecare delegaț. TensorFlow Lite oferă instrumentul Delegation Compatibility Check: rulați modelul cu delegațul și verificați câte operații (ops) sunt delegate. Dacă mai puțin de 80% — este mai bine să alegeți un alt delegaț sau să rămâneți pe CPU. Conform TensorFlow (2025), GPU Delegate suportă 45 de operații, NNAPI — 60+.

În proiectele IT Sectr folosim delegați GPU pentru iOS și XNNPACK pentru Android cu verificare incorporată a compatibilității: modelul este testat pe toți delegații, se alege cel mai rapid cu grad de delegare de cel puțin 90%.

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

Verificarea operațiilor delegate — controlul compatibilității prin Interpreter. În mod implicit, delegațul acceptă toate operațiile pe care le suportă. Pentru depanare, utilizați logarea numărului de noduri delegate. Dacă modelul conține operații personalizate (custom ops), delegațul nu le accelerează, dar nici nu le strică — ele sunt executate pe CPU.

// Verificați numărul de operații delegate
val delegateCount = interpreter.getDelegateOpsCount(gpuDelegate)
val totalNodes = interpreter.getNodesCount()
Log.d("TFLite", "Delegate: $delegateCount / $totalNodes")
if (delegateCount < totalNodes * 0.8) {
    // Prag 80% — alegeți un alt delegaț
}

GPU Delegate: accelerare pe procesorul grafic

GPU Delegate — delegaț TensorFlow Lite pentru executarea modelului pe GPU prin OpenGL ES 3.1+ (Android) sau Metal (iOS). Procesoarele grafice sunt optimizate pentru operații matriceale paralele — Core ML și rețelele neuronale convoluționale (CNN) obțin cea mai mare creștere. GPU Delegate reduce latența inferenței de 4–8 ori pentru modele precum MobileNet, EfficientNet, Inception.

Limitări GPU Delegate: nu suportă toate operațiile (doar 45 din ~120 în TF Lite), necesită OpenGL ES 3.1 sau Metal, consumă mai multă energie decât CPU. GPU-ul este ineficient pentru batch size > 1 în scenarii mobile. Conform benchmark-urilor TensorFlow (2025), pe dispozitivul Pixel 8 cu GPU Adreno 740, modelul MobileNetV2 rulează în 4.2 ms pe GPU față de 18.7 ms pe CPU — accelerare de 4.4x.

Configurarea GPU Delegate include alegerea preciziei: float16 reduce precizia, dar accelerează inferența cu 30–40% fără pierdere vizibilă de calitate (pentru majoritatea sarcinilor). Activați allow_precision_loss=true pentru performanță maximă pe GPU. Pentru sarcini cu precizie ridicată (medicină, finanțe) utilizați float32.

// GPU Delegate cu optimizare de precizie
val gpuOptions = GpuDelegateFactory.Options().apply {
    isPrecisionLossAllowed = true
    inferencePreference = GpuDelegateFactory.Options.InferencePreference.SUSTAINED_SPEED
}
val delegate = GpuDelegateFactory.create(gpuOptions)

GPU Delegate pe iOS utilizează Metal Performance Shaders prin Metal Delegate. Pe iOS, delegațul funcționează prin Core ML delegate pentru Apple Neural Engine sau direct prin Metal. Apple A17 Pro execută MobileNetV2 în 1.3 ms — de 6 ori mai rapid decât CPU. Metal delegate este disponibil de la iOS 12 și suportă toate dispozitivele cu cip A7+.

NNAPI Delegate: rețele neuronale pe Android prin Neural Networks API

NNAPI Delegate (Android Neural Networks API) — delegaț TF Lite care utilizează accelerarea hardware prin Android NN HAL (Hardware Abstraction Layer). NNAPI redirecționează operațiile modelului către NPU, DSP sau GPU în funcție de driverele disponibile ale dispozitivului. Este suportat pe Android 8.1+ (API 27+) și este delegațul recomandat implicit pentru Android.

Avantajul NNAPI — selectarea automată a acceleratorului. Dacă dispozitivul are NPU (Qualcomm Hexagon, MediaTek APU, Samsung NPU), NNAPI delegă operațiile către acesta. Dacă nu are NPU — către GPU prin OpenCL. Dacă nici GPU-ul nu suportă — către CPU cu optimizări DSP. Dezvoltatorul nu specifică un accelerator concret — NNAPI îl alege pe cel optim. Conform Google I/O 2024, delegațul NNAPI pe Snapdragon 8 Gen 3 accelerează modelele LLM de 12 ori.

Limitări NNAPI: suport inegal pe diferite dispozitive. Dispozitivele vechi (Android 8.1) au un set limitat de drivere. Huawei cu Kirin nu suportă NNAPI prin Google Services — utilizați GPU Delegate. Pentru compatibilitate garantată, Google recomandă NNAPI Delegate ca primă alegere, cu fallback pe GPU sau XNNPACK.

// NNAPI Delegate cu fallback pe CPU
val nnApiOptions = NnApiDelegate.Options().apply {
    acceleratorName = null // null = selecție automată
    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 — parametru pentru selectarea explicită a acceleratorului. Dacă transmiteți null, NNAPI alege automat. Pentru testare, specificați unul concret: "qti", "google-edgetpu", "mediatek". Lista acceleratoarelor disponibile este afișată prin NnApiDelegate.getAvailableAccelerators(). În producție, utilizați selecția automată cu prag de compatibilitate.

XNNPACK Delegate: optimizare CPU prin SIMD

XNNPACK Delegate — delegaț TensorFlow Lite pentru execuție optimizată pe CPU prin instrucțiuni SIMD (ARM NEON, SSE, AVX). XNNPACK nu necesită GPU sau NPU — este un delegaț pur CPU, dar cu accelerare de 2–4x datorită SIMD, operator fusion, memory pre-fetching și quantized inference (INT8). Ideal pentru dispozitive fără NPU dedicat sau când este necesară compatibilitate garantată.

XNNPACK a fost dezvoltat de Google ca delegaț implicit TF Lite pentru CPU (inclus în TFLite Runtime implicit). Suportă 90+ operații — mai mult decât GPU sau NNAPI. XNNPACK este deosebit de eficient pentru modele cuantizate (INT8, INT16): operațiile rulează de 2–3 ori mai rapid decât versiunea float32. Conform benchmark-urilor Google (2025), XNNPACK accelerează INT8 MobileNetV2 de 2.8x față de CPU de bază.

XNNPACK vs GPU: pe dispozitivele fără NPU, XNNPACK este adesea mai rapid decât GPU Delegate pentru batch-uri mici (1–4) — GPU-ul are overhead de transfer de date între CPU și GPU. XNNPACK funcționează în același spațiu de adrese CPU — nu există copiere a memoriei. Pentru modele de până la 5MB, XNNPACK poate fi mai rapid decât GPU. Pentru modele CNN mari, GPU câștigă datorită paralelismului.

// XNNPACK Delegate activat implicit în TFLite 2.18+
// Utilizare explicită prin 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 — activează forțat delegațul, FLUSH_TO_ZERO — procesarea numerelor denormalizate pentru accelerare, ENABLE_XNNPACK_SHAPES — dimensiuni dinamice de intrare. Pentru compatibilitate maximă, utilizați opțiunile implicite. La apariția erorilor pe dispozitive vechi, dezactivați XNNPACK — modelul rulează în continuare pe CPU, dar mai lent.

Core ML și Metal Delegate: accelerare pe iOS

Core ML Delegate — delegaț TensorFlow Lite pentru iOS care utilizează Apple Core ML Framework. Core ML convertește modelul TF Lite în format .mlmodel și rulează pe Apple Neural Engine (ANE), GPU (Metal) sau CPU. Apple A17 Pro și M3 au Neural Engine dedicat, pe care Core ML îl folosește automat. Core ML Delegate accelerează inferența de 5–10 ori față de CPU pe dispozitivele iOS moderne.

Core ML pe iOS suportă flex delegate (delegarea dinamică a operațiilor disponibile Core ML) și full model conversion (conversia întregului model în .mlmodel). Apple recomandă flex delegate — este mai rapid deoarece funcționează în runtime fără conversie prealabilă. Core ML Delegate suportă modele float32, float16 și cuantizate (INT8).

Metal Delegate — un delegaț de nivel inferior care lucrează direct cu Metal Performance Shaders. Utilizați Metal când Core ML nu suportă anumite operații. Metal Delegate oferă control maxim asupra GPU-ului, dar necesită mai mult cod. Conform Apple (WWDC 2024), Metal Delegate pentru modelele native Swift poate fi cu 15–20% mai rapid decât Core ML din cauza lipsei de overhead de conversie.

// Core ML Delegate pe iOS prin 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)

Alegerea între Core ML și Metal: Core ML — pentru producție, Metal — pentru cazuri marginale. Core ML gestionează automat memoria NE, suportă fallback pe CPU și nu necesită conversie manuală. Metal oferă control asupra buffer-elor și este potrivit pentru operații personalizate. În proiectele IT Sectr folosim Core ML Delegate pentru toate modelele iOS și Metal doar pentru sarcini de analiză video în timp real.

Cum să alegi delegațul pentru proiect

Alegerea TF Lite Delegate depinde de platforma țintă, model și cerințele de latență. Nu există un delegaț universal cel mai bun — fiecare are puncte tari și puncte slabe. Strategia optimă: testați toți delegații disponibili pe dispozitivul țintă și alegeți-l pe cel minim suficient de rapid — nu cel mai rapid, ci cel minim suficient.

Recomandări de alegere: pentru Android cu NPU (Snapdragon 8 Gen 2+, Dimensity 9000+) — NNAPI Delegate. Pentru Android fără NPU — XNNPACK Delegate (implicit). Pentru iOS — Core ML Delegate. Pentru proiecte cross-platform, utilizați strategia: NNAPI pe Android, Core ML pe iOS, XNNPACK ca fallback. GPU Delegate — când NNAPI nu este disponibil, iar XNNPACK nu este suficient de rapid.

Testarea latenței — etapă obligatorie de selecție. Măsurați inferența la temperatură minimă (dispozitiv rece) și după 5 minute de lucru continuu (thermal throttling). GPU și NNAPI pot reduce performanța la încălzire. XNNPACK (CPU) suferă mai puțin. Utilizați TensorFlow Lite Benchmark Tool pentru testarea automată a tuturor delegaților pe dispozitivul dumneavoastră.

// Strategie de selecție a delegațului
fun selectDelegate(): TfLiteDelegate {
    return when {
        NnApiDelegate.getAvailableAccelerators()?.isNotEmpty == true ->
            NnApiDelegate()
        GpuDelegateFactory.isGpuDelegateAvailable() ->
            GpuDelegate()
        else -> XnnpackDelegate()
    }
}

Strategia Fallback — încărcați modelul fără excepții: dacă delegațul nu este suportat, rulați pe CPU. TensorFlow Lite aruncă IllegalArgumentException la eroarea creării delegațului. Înconjurați crearea delegațului în try-catch și la eroare rulați modelul fără delegaț. Un AI lent dar funcțional este mai bun decât o eroare pentru utilizator.