TF Lite Delegate: mi ez, GPU és NNAPI delegátusok

Mi az a TF Lite Delegate: architektúra és működési elv

TF Lite Delegate — egy szoftveradapter a TensorFlow Lite Runtime és a készülék hardvergyorsítója között. A delegátus elfogja a modellgráf műveleteit (konvolúciók, pooling, mátrixszorzások), és egy specializált számítógépen hajtja végre azokat a CPU helyett. Ha a delegátus nem támogat egy adott műveletet, az a CPU-n kerül végrehajtásra — ezt hívják partial delegation-nek.

A TF Lite Delegate architektúrája a SimpleDelegate API interfész és a TfLiteDelegate struktúra köré épül C++-ban. Minden delegátus implementálja a gráfcsomópontok delegálásának, memóriafoglalásának és a céleszközön történő végrehajtásának módszereit. A fejlesztő az Interpreter::ModifyGraphWithDelegate segítségével csatlakoztatja a delegátust az Invoke meghívása előtt. A TensorFlow Guide szerint a delegátus automatikusan alkalmazásra kerül a modell összes támogatott műveletére.

Kompatibilitás ellenőrzése — kötelező szakasz. Nem minden műveletet támogat minden delegátus. A TensorFlow Lite biztosítja a Delegation Compatibility Check eszközt: futtassa a modellt a delegátussal, és ellenőrizze, hány művelet (ops) lett delegálva. Ha kevesebb mint 80% — érdemes másik delegátust választani vagy a CPU-n maradni. A TensorFlow (2025) szerint a GPU Delegate 45 műveletet támogat, az NNAPI — 60+.

Az IT Sectr projektjeiben GPU delegátusokat használunk iOS-hez és XNNPACK-ot Androidhoz beépített kompatibilitás-ellenőrzéssel: a modellt minden delegátuson teszteljük, a leggyorsabbat választjuk ki legalább 90%-os delegálási teljességgel.

// GPU Delegate csatlakoztatása Androidon
val gpuDelegate = GpuDelegate()
val options = Interpreter.Options().apply {
    addDelegate(gpuDelegate)
    setNumThreads(4)
}
val interpreter = Interpreter(modelBuffer, options)
interpreter.run(input, output)
gpuDelegate.close()

Delegált műveletek ellenőrzése — kompatibilitás ellenőrzése az Interpreteren keresztül. Alapértelmezetten a delegátus elfogadja az összes általa támogatott műveletet. Hibakereséshez használja a delegált csomópontok számának naplózását. Ha a modell egyedi műveleteket (custom ops) tartalmaz, a delegátus nem gyorsítja azokat, de nem is rontja el — a CPU-n hajtódnak végre.

// Ellenőrizze a delegált műveletek számát
val delegateCount = interpreter.getDelegateOpsCount(gpuDelegate)
val totalNodes = interpreter.getNodesCount()
Log.d("TFLite", "Delegálva: $delegateCount / $totalNodes")
if (delegateCount < totalNodes * 0.8) {
    // 80%-os küszöb — válasszon másik delegátust
}

GPU Delegate: gyorsítás a grafikus processzoron

GPU Delegate — TensorFlow Lite delegátus a modell GPU-n való futtatásához OpenGL ES 3.1+ (Android) vagy Metal (iOS) segítségével. A grafikus processzorok párhuzamos mátrixműveletekre vannak optimalizálva — a Core ML és a konvolúciós neurális hálózatok (CNN) kapják a legnagyobb gyorsulást. A GPU Delegate 4–8-szor csökkenti az inferencia késleltetését olyan modelleknél, mint a MobileNet, EfficientNet, Inception.

A GPU Delegate korlátai: nem támogatja az összes műveletet (csak 45-öt a ~120-ból a TF Lite-ban), OpenGL ES 3.1 vagy Metal szükséges, több energiát fogyaszt mint a CPU. A GPU nem hatékony batch size > 1 esetén mobil forgatókönyvekben. A TensorFlow benchmarkok (2025) szerint egy Pixel 8 készüléken Adreno 740 GPU-val a MobileNetV2 modell 4.2 ms alatt fut a GPU-n szemben a CPU 18.7 ms-ával — 4.4x gyorsítás.

A GPU Delegate konfigurációja magában foglalja a pontosság kiválasztását: a float16 csökkenti a pontosságot, de 30–40%-kal gyorsítja az inferenciát észrevehető minőségromlás nélkül (a legtöbb feladatnál). Kapcsolja be az allow_precision_loss=true-t a maximális teljesítményhez a GPU-n. Nagy pontosságot igénylő feladatokhoz (orvostudomány, pénzügy) használjon float32-t.

// GPU Delegate pontosság-optimalizálással
val gpuOptions = GpuDelegateFactory.Options().apply {
    isPrecisionLossAllowed = true
    inferencePreference = GpuDelegateFactory.Options.InferencePreference.SUSTAINED_SPEED
}
val delegate = GpuDelegateFactory.create(gpuOptions)

GPU Delegate iOS-en a Metal Performance Shaders-t használja a Metal Delegate-en keresztül. iOS-en a delegátus a Core ML delegate-en keresztül működik az Apple Neural Engine-hez vagy közvetlenül a Metal-on keresztül. Az Apple A17 Pro 1.3 ms alatt futtatja a MobileNetV2-t — 6-szor gyorsabban mint a CPU. A Metal delegate iOS 12-től elérhető, és támogatja az összes A7+ chipes eszközt.

NNAPI Delegate: neurális hálózatok Androidon a Neural Networks API-n keresztül

NNAPI Delegate (Android Neural Networks API) — TF Lite delegátus, amely hardvergyorsítást használ az Android NN HAL (Hardware Abstraction Layer) segítségével. Az NNAPI a modell műveleteit NPU-ra, DSP-re vagy GPU-ra irányítja a készülék elérhető illesztőprogramjaitól függően. Android 8.1+ (API 27+) támogatott, és ez az ajánlott alapértelmezett delegátus Androidhoz.

Az NNAPI előnye — automatikus gyorsítóválasztás. Ha a készülék rendelkezik NPU-val (Qualcomm Hexagon, MediaTek APU, Samsung NPU), az NNAPI oda delegálja a műveleteket. Ha nincs NPU — GPU-ra OpenCL-en keresztül. Ha a GPU sem támogatja — CPU-ra DSP optimalizálásokkal. A fejlesztő nem ad meg konkrét gyorsítót — az NNAPI kiválasztja az optimálisat. A Google I/O 2024 szerint az NNAPI delegate Snapdragon 8 Gen 3-on 12-szeresére gyorsítja az LLM modelleket.

Az NNAPI korlátai: egyenetlen támogatás a különböző eszközökön. A régi eszközök (Android 8.1) korlátozott illesztőprogram-készlettel rendelkeznek. A Kirin-es Huawei nem támogatja az NNAPI-t Google Services-en keresztül — használjon GPU Delegate-et. Garantált kompatibilitásért a Google az NNAPI Delegate-et ajánlja első választásként, GPU vagy XNNPACK fallback-kel.

// NNAPI Delegate CPU fallback-kel
val nnApiOptions = NnApiDelegate.Options().apply {
    acceleratorName = null // null = automatikus kiválasztás
    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 — paraméter a gyorsító explicit kiválasztásához. Ha null-t ad át, az NNAPI automatikusan választ. Teszteléshez adjon meg egy konkrétat: "qti", "google-edgetpu", "mediatek". Az elérhető gyorsítók listája az NnApiDelegate.getAvailableAccelerators()-on keresztül jeleníthető meg. Élesben használjon automatikus kiválasztást kompatibilitási küszöbértékkel.

XNNPACK Delegate: CPU optimalizálás SIMD-vel

XNNPACK Delegate — TensorFlow Lite delegátus optimalizált CPU végrehajtáshoz SIMD utasításokkal (ARM NEON, SSE, AVX). Az XNNPACK nem igényel GPU-t vagy NPU-t — ez egy tiszta CPU delegátus, de 2–4x gyorsítással a SIMD, operator fusion, memory pre-fetching és quantized inference (INT8) révén. Ideális dedikált NPU nélküli eszközökhöz vagy amikor garantált kompatibilitás szükséges.

Az XNNPACK-ot a Google fejlesztette ki alapértelmezett TF Lite delegátusként CPU-hoz (alapértelmezetten beépítve a TFLite Runtime-ba). 90+ műveletet támogat — többet, mint a GPU vagy az NNAPI. Az XNNPACK különösen hatékony kvantált modelleknél (INT8, INT16): a műveletek 2–3-szor gyorsabban futnak, mint a float32 verzió. A Google benchmarkok (2025) szerint az XNNPACK 2.8x-re gyorsítja az INT8 MobileNetV2-t az alap CPU-hoz képest.

XNNPACK vs GPU: NPU nélküli eszközökön az XNNPACK gyakran gyorsabb, mint a GPU Delegate kis batch-eknél (1–4) — a GPU-nak adatátviteli többletterhe van a CPU és GPU között. Az XNNPACK ugyanabban a CPU címtartományban működik — nincs memóriamásolás. 5MB-ig terjedő modelleknél az XNNPACK gyorsabb lehet a GPU-nál. Nagy CNN modelleknél a GPU nyer a párhuzamosság révén.

// XNNPACK Delegate alapértelmezetten engedélyezve a TFLite 2.18+-ban
// Explicit használat az XnnpackDelegate segítségével
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 — kényszeríti a delegátus bekapcsolását, FLUSH_TO_ZERO — denormalizált számok feldolgozása a gyorsítás érdekében, ENABLE_XNNPACK_SHAPES — dinamikus bemeneti méretek. Maximális kompatibilitásért használja az alapértelmezett opciókat. Ha hibák lépnek fel régi eszközökön, kapcsolja ki az XNNPACK-ot — a modell továbbra is fut a CPU-n, de lassabban.

Core ML és Metal Delegate: gyorsítás iOS-en

Core ML Delegate — TensorFlow Lite delegátus iOS-hez, amely az Apple Core ML Framework-ot használja. A Core ML átalakítja a TF Lite modellt .mlmodel formátumba, és az Apple Neural Engine-en (ANE), GPU-n (Metal) vagy CPU-n futtatja. Az Apple A17 Pro és M3 dedikált Neural Engine-nel rendelkezik, amelyet a Core ML automatikusan használ. A Core ML Delegate 5–10-szeresére gyorsítja az inferenciát a CPU-hoz képest modern iOS eszközökön.

Core ML iOS-en támogatja a flex delegate-et (a Core ML számára elérhető műveletek dinamikus delegálása) és a full model conversion-t (a teljes modell átalakítása .mlmodel formátumba). Az Apple a flex delegate-et ajánlja — gyorsabb, mivel futásidőben működik előzetes konvertálás nélkül. A Core ML Delegate támogatja a float32, float16 és kvantált modelleket (INT8).

Metal Delegate — egy alacsonyabb szintű delegátus, amely közvetlenül a Metal Performance Shaders-szel dolgozik. Használja a Metal-t, amikor a Core ML nem támogat bizonyos műveleteket. A Metal Delegate maximális vezérlést biztosít a GPU felett, de több kódot igényel. Az Apple (WWDC 2024) szerint a Metal Delegate natív Swift modelleknél 15–20%-kal gyorsabb lehet a Core ML-nél a konvertálási többletterhelés hiánya miatt.

// Core ML Delegate iOS-en a TFLite Swift API-n keresztül
import TensorFlowLite

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

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

Választás a Core ML és Metal között: Core ML — éles használatra, Metal — szélső esetekre. A Core ML automatikusan kezeli az NE memóriáját, támogatja a CPU-ra esést (fallback) és nem igényel kézi konvertálást. A Metal vezérlést biztosít a pufferek felett, és alkalmas egyedi műveletekhez. Az IT Sectr projektjeiben a Core ML Delegate-et használjuk minden iOS modellhez, a Metal-t pedig csak valós idejű videóanalitikai feladatokhoz.

Hogyan válasszunk delegátust a projekthez

A TF Lite Delegate kiválasztása a célplatformtól, a modelltől és a késleltetési követelményektől függ. Nincs univerzális legjobb delegátus — mindegyiknek vannak erős és gyenge pontjai. Optimális stratégia: tesztelje az összes elérhető delegátust a céleszközön, és válassza a minimálisan elég gyorsat — nem a leggyorsabbat, hanem a minimálisan elegendőt.

Kiválasztási ajánlások: Androidhoz NPU-val (Snapdragon 8 Gen 2+, Dimensity 9000+) — NNAPI Delegate. Androidhoz NPU nélkül — XNNPACK Delegate (alapértelmezett). iOS-hez — Core ML Delegate. Platformok közötti projektekhez használja a stratégiát: NNAPI Androidon, Core ML iOS-en, XNNPACK fallback-ként. GPU Delegate — amikor az NNAPI nem elérhető, és az XNNPACK nem elég gyors.

Késleltetés tesztelése — a kiválasztás kötelező szakasza. Mérje meg az inferenciát minimális hőmérsékleten (hideg eszköz) és 5 perc folyamatos munka után (termikus fojtás). A GPU és NNAPI csökkentheti a teljesítményt felmelegedéskor. Az XNNPACK (CPU) kevésbé szenved. Használja a TensorFlow Lite Benchmark Tool-t az összes delegátus automatikus teszteléséhez az eszközén.

// Delegátus kiválasztási stratégia
fun selectDelegate(): TfLiteDelegate {
    return when {
        NnApiDelegate.getAvailableAccelerators()?.isNotEmpty == true ->
            NnApiDelegate()
        GpuDelegateFactory.isGpuDelegateAvailable() ->
            GpuDelegate()
        else -> XnnpackDelegate()
    }
}

Fallback stratégia — töltse be a modellt kivételek nélkül: ha a delegátus nem támogatott, futtassa CPU-n. A TensorFlow Lite IllegalArgumentException-t dob a delegátus létrehozásának hibájánál. Csomagolja a delegátus létrehozását try-catch-be, és hiba esetén futtassa a modellt delegátus nélkül. A lassú, de működő AI jobb, mint egy hiba a felhasználónak.