TF Lite Delegate: ano ito, mga delegado ng GPU at NNAPI

Ano ang TF Lite Delegate: arkitektura at prinsipyo ng paggana

TF Lite Delegate — ay isang software adapter sa pagitan ng TensorFlow Lite Runtime at ng hardware accelerator ng device. Inaagaw ng delegado ang mga operasyon ng graph ng modelo (convolutions, pooling, matrix multiplications) at isinasagawa ang mga ito sa isang espesyalisadong computer sa halip na CPU. Kung hindi sinusuportahan ng delegado ang isang partikular na operasyon, ito ay isinasagawa sa CPU — ito ay tinatawag na partial delegation.

Ang arkitektura ng TF Lite Delegate ay binuo sa paligid ng SimpleDelegate API interface at TfLiteDelegate structure sa C++. Bawat delegado ay nagpapatupad ng mga pamamaraan ng pag-delegate ng mga node ng graph, paglalaan ng memorya at pagpapatupad sa target na device. Ikinokonekta ng developer ang delegado sa pamamagitan ng Interpreter::ModifyGraphWithDelegate bago tumawag ng Invoke. Ayon sa TensorFlow Guide, ang delegado ay awtomatikong inilalapat sa lahat ng suportadong operasyon ng modelo.

Pagsusuri ng compatibility — sapilitang yugto. Hindi lahat ng operasyon ay sinusuportahan ng bawat delegado. Nagbibigay ang TensorFlow Lite ng tool na Delegation Compatibility Check: patakbuhin ang modelo gamit ang delegado at suriin kung ilang operasyon (ops) ang na-delegate. Kung mas mababa sa 80% — mas mabuting pumili ng ibang delegado o manatili sa CPU. Ayon sa TensorFlow (2025), sinusuportahan ng GPU Delegate ang 45 operasyon, NNAPI — 60+.

Sa mga proyekto ng IT Sectr gumagamit kami ng GPU delegado para sa iOS at XNNPACK para sa Android na may built-in na compatibility check: ang modelo ay sinusuri sa lahat ng delegado, pinipili ang pinakamabilis na may delegation completeness na hindi bababa sa 90%.

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

Pagsusuri ng mga na-delegate na operasyon — kontrol ng compatibility sa pamamagitan ng Interpreter. Bilang default, tinatanggap ng delegado ang lahat ng operasyon na sinusuportahan nito. Para sa debugging, gamitin ang pag-log ng bilang ng mga na-delegate na node. Kung ang modelo ay naglalaman ng mga custom na operasyon (custom ops), hindi ito pinapabilis ng delegado ngunit hindi rin sinisira — ang mga ito ay isinasagawa sa CPU.

// Suriin ang bilang ng mga na-delegate na operasyon
val delegateCount = interpreter.getDelegateOpsCount(gpuDelegate)
val totalNodes = interpreter.getNodesCount()
Log.d("TFLite", "Na-delegate: $delegateCount / $totalNodes")
if (delegateCount < totalNodes * 0.8) {
    // 80% threshold — pumili ng ibang delegado
}

GPU Delegate: acceleration sa graphics processor

GPU Delegate — delegado ng TensorFlow Lite para sa pagpapatakbo ng modelo sa GPU sa pamamagitan ng OpenGL ES 3.1+ (Android) o Metal (iOS). Ang mga graphics processor ay na-optimize para sa parallel matrix operations — ang Core ML at convolutional neural network (CNN) ay nakakakuha ng pinakamalaking pagtaas. Binabawasan ng GPU Delegate ang latency ng inference ng 4–8 beses para sa mga modelo tulad ng MobileNet, EfficientNet, Inception.

Mga limitasyon ng GPU Delegate: hindi sinusuportahan ang lahat ng operasyon (45 lang sa ~120 sa TF Lite), nangangailangan ng OpenGL ES 3.1 o Metal, kumokonsumo ng mas maraming enerhiya kaysa CPU. Hindi epektibo ang GPU para sa batch size > 1 sa mga mobile scenario. Ayon sa TensorFlow benchmarks (2025), sa Pixel 8 device na may GPU Adreno 740, ang modelo ng MobileNetV2 ay tumatakbo sa 4.2 ms sa GPU kumpara sa 18.7 ms sa CPU — acceleration na 4.4x.

Configuration ng GPU Delegate ay may kasamang pagpili ng precision: binabawasan ng float16 ang accuracy ngunit pinapabilis ang inference ng 30–40% nang walang kapansin-pansing pagkawala ng kalidad (para sa karamihan ng mga gawain). I-enable ang allow_precision_loss=true para sa maximum na performance sa GPU. Para sa mga gawaing may mataas na precision (medisina, pananalapi) gamitin ang float32.

// GPU Delegate na may precision optimization
val gpuOptions = GpuDelegateFactory.Options().apply {
    isPrecisionLossAllowed = true
    inferencePreference = GpuDelegateFactory.Options.InferencePreference.SUSTAINED_SPEED
}
val delegate = GpuDelegateFactory.create(gpuOptions)

GPU Delegate sa iOS ay gumagamit ng Metal Performance Shaders sa pamamagitan ng Metal Delegate. Sa iOS, gumagana ang delegado sa pamamagitan ng Core ML delegate para sa Apple Neural Engine o direkta sa pamamagitan ng Metal. Ang Apple A17 Pro ay nagpapatakbo ng MobileNetV2 sa 1.3 ms — 6 na beses na mas mabilis kaysa CPU. Ang Metal delegate ay available mula iOS 12 at sinusuportahan ang lahat ng device na may A7+ chip.

NNAPI Delegate: neural network sa Android sa pamamagitan ng Neural Networks API

NNAPI Delegate (Android Neural Networks API) — delegado ng TF Lite na gumagamit ng hardware acceleration sa pamamagitan ng Android NN HAL (Hardware Abstraction Layer). Ina-redirect ng NNAPI ang mga operasyon ng modelo sa NPU, DSP o GPU depende sa mga available na driver ng device. Suportado sa Android 8.1+ (API 27+) at ito ang inirerekomendang default na delegado para sa Android.

Bentahe ng NNAPI — awtomatikong pagpili ng accelerator. Kung ang device ay may NPU (Qualcomm Hexagon, MediaTek APU, Samsung NPU), ide-delegate ng NNAPI ang mga operasyon dito. Kung walang NPU — sa GPU sa pamamagitan ng OpenCL. Kung hindi rin sinusuportahan ng GPU — sa CPU na may DSP optimizations. Hindi tinutukoy ng developer ang isang partikular na accelerator — pinipili ng NNAPI ang optimal. Ayon sa Google I/O 2024, pinapabilis ng NNAPI delegate sa Snapdragon 8 Gen 3 ang LLM models ng 12 beses.

Mga limitasyon ng NNAPI: hindi pantay na suporta sa iba't ibang device. Ang mga lumang device (Android 8.1) ay may limitadong set ng driver. Ang Huawei na may Kirin ay hindi sumusuporta sa NNAPI sa pamamagitan ng Google Services — gamitin ang GPU Delegate. Para sa garantisadong compatibility, inirerekomenda ng Google ang NNAPI Delegate bilang unang pagpipilian, na may fallback sa GPU o XNNPACK.

// NNAPI Delegate na may CPU fallback
val nnApiOptions = NnApiDelegate.Options().apply {
    acceleratorName = null // null = auto-select
    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 para sa tahasang pagpili ng accelerator. Kung null ang ipinasa, awtomatikong pumipili ang NNAPI. Para sa pagsubok, tukuyin ang isang tiyak: "qti", "google-edgetpu", "mediatek". Ang listahan ng mga available na accelerator ay ipinapakita sa pamamagitan ng NnApiDelegate.getAvailableAccelerators(). Sa produksyon, gamitin ang awtomatikong pagpili na may threshold ng compatibility.

XNNPACK Delegate: CPU optimization sa pamamagitan ng SIMD

XNNPACK Delegate — delegado ng TensorFlow Lite para sa optimized na pagpapatupad sa CPU sa pamamagitan ng SIMD instructions (ARM NEON, SSE, AVX). Ang XNNPACK ay hindi nangangailangan ng GPU o NPU — ito ay purong CPU delegado, ngunit may 2–4x acceleration dahil sa SIMD, operator fusion, memory pre-fetching at quantized inference (INT8). Mainam para sa mga device na walang dedicated na NPU o kapag kailangan ang garantisadong compatibility.

XNNPACK ay binuo ng Google bilang default na TF Lite delegado para sa CPU (kasama sa TFLite Runtime bilang default). Sumusuporta ng 90+ operasyon — higit sa GPU o NNAPI. Ang XNNPACK ay lalong epektibo para sa mga na-quantize na modelo (INT8, INT16): ang mga operasyon ay tumatakbo nang 2–3 beses na mas mabilis kaysa sa float32 na bersyon. Ayon sa Google benchmarks (2025), pinapabilis ng XNNPACK ang INT8 MobileNetV2 ng 2.8x kumpara sa base CPU.

XNNPACK vs GPU: sa mga device na walang NPU, ang XNNPACK ay madalas na mas mabilis kaysa GPU Delegate para sa maliit na batch (1–4) — ang GPU ay may overhead sa paglipat ng data sa pagitan ng CPU at GPU. Ang XNNPACK ay gumagana sa parehong CPU address space — walang pagkopya ng memorya. Para sa mga modelo hanggang 5MB, ang XNNPACK ay maaaring mas mabilis kaysa GPU. Para sa malalaking CNN models, nananalo ang GPU dahil sa parallelism.

// XNNPACK Delegate na naka-default sa TFLite 2.18+
// Eksplisitong paggamit sa pamamagitan ng 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 — sapilitang i-on ang delegado, FLUSH_TO_ZERO — pagproseso ng mga denormalized na numero para sa acceleration, ENABLE_XNNPACK_SHAPES — dynamic na laki ng input. Para sa maximum na compatibility, gamitin ang mga default na opsyon. Kung magkaroon ng error sa mga lumang device, i-off ang XNNPACK — gumagana pa rin ang modelo sa CPU, ngunit mas mabagal.

Core ML at Metal Delegate: acceleration sa iOS

Core ML Delegate — delegado ng TensorFlow Lite para sa iOS na gumagamit ng Apple Core ML Framework. Kino-convert ng Core ML ang TF Lite model sa .mlmodel format at pinapatakbo sa Apple Neural Engine (ANE), GPU (Metal) o CPU. Ang Apple A17 Pro at M3 ay may dedicated na Neural Engine na awtomatikong ginagamit ng Core ML. Pinapabilis ng Core ML Delegate ang inference ng 5–10 beses kumpara sa CPU sa mga modernong iOS device.

Core ML sa iOS ay sumusuporta sa flex delegate (dynamic na pag-delegate ng mga operasyon na available sa Core ML) at full model conversion (conversion ng buong modelo sa .mlmodel). Inirerekomenda ng Apple ang flex delegate — mas mabilis ito dahil gumagana ito sa runtime nang walang paunang conversion. Sinusuportahan ng Core ML Delegate ang float32, float16 at mga na-quantize na modelo (INT8).

Metal Delegate — isang mas mababang antas na delegado na direktang gumagana sa Metal Performance Shaders. Gamitin ang Metal kapag hindi sinusuportahan ng Core ML ang mga partikular na operasyon. Ang Metal Delegate ay nagbibigay ng maximum na kontrol sa GPU, ngunit nangangailangan ng mas maraming code. Ayon sa Apple (WWDC 2024), ang Metal Delegate para sa native na Swift models ay maaaring 15–20% mas mabilis kaysa Core ML dahil sa kawalan ng conversion overhead.

// Core ML Delegate sa iOS sa pamamagitan ng 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)

Pagpili sa pagitan ng Core ML at Metal: Core ML — para sa produksyon, Metal — para sa mga edge case. Awtomatikong pinamamahalaan ng Core ML ang memorya ng NE, sinusuportahan ang fallback sa CPU at hindi nangangailangan ng manu-manong conversion. Nagbibigay ang Metal ng kontrol sa mga buffer at angkop para sa mga custom na operasyon. Sa mga proyekto ng IT Sectr ginagamit namin ang Core ML Delegate para sa lahat ng iOS models at Metal lamang para sa mga real-time na gawain sa video analytics.

Paano pumili ng delegado para sa proyekto

Pagpili ng TF Lite Delegate ay depende sa target na platform, modelo at mga kinakailangan sa latency. Walang unibersal na pinakamahusay na delegado — bawat isa ay may mga kalakasan at kahinaan. Optimal na diskarte: subukan ang lahat ng available na delegado sa target na device at piliin ang minimal na sapat na mabilis — hindi ang pinakamabilis, kundi ang minimal na sapat.

Rekomendasyon sa pagpili: para sa Android na may NPU (Snapdragon 8 Gen 2+, Dimensity 9000+) — NNAPI Delegate. Para sa Android na walang NPU — XNNPACK Delegate (default). Para sa iOS — Core ML Delegate. Para sa cross-platform na mga proyekto, gamitin ang diskarte: NNAPI sa Android, Core ML sa iOS, XNNPACK bilang fallback. GPU Delegate — kapag hindi available ang NNAPI at hindi sapat ang bilis ng XNNPACK.

Pagsubok ng latency — sapilitang yugto ng pagpili. Sukatin ang inference sa minimal na temperatura (malamig na device) at pagkatapos ng 5 minuto ng tuloy-tuloy na trabaho (thermal throttling). Ang GPU at NNAPI ay maaaring magbawas ng performance kapag umiinit. Ang XNNPACK (CPU) ay mas hindi apektado. Gamitin ang TensorFlow Lite Benchmark Tool para sa awtomatikong pagsubok ng lahat ng delegado sa iyong device.

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

Fallback strategy — i-load ang modelo nang walang exceptions: kung hindi sinusuportahan ang delegado, patakbuhin sa CPU. Ang TensorFlow Lite ay nagtatapon ng IllegalArgumentException sa error sa paggawa ng delegado. Balutin ang paggawa ng delegado sa try-catch at sa error ay patakbuhin ang modelo nang walang delegado. Ang mabagal ngunit gumaganang AI ay mas mabuti kaysa error para sa user.