TF Lite Delegate: какво е, делегати GPU и NNAPI

Какво е TF Lite Delegate: архитектура и принцип на работа

TF Lite Delegate — софтуерен адаптор между TensorFlow Lite Runtime и хардуерния ускорител на устройството. Делегатът прихваща операциите на графа на модела (конволюции, пулинг, матрични умножения) и ги изпълнява на специализиран изчислител вместо CPU. Ако делегатът не поддържа конкретна операция, тя се изпълнява на CPU — това се нарича partial delegation.

Архитектурата на TF Lite Delegate е изградена около интерфейса SimpleDelegate API и структурата TfLiteDelegate на C++. Всеки делегат имплементира методи за делегиране на възли на графа, разпределяне на памет и изпълнение на целевото устройство. Разработчикът свързва делегата чрез Interpreter::ModifyGraphWithDelegate преди извикване на Invoke. Според TensorFlow Guide, делегатът се прилага автоматично към всички поддържани операции на модела.

Проверка на съвместимост — задължителен етап. Не всички операции се поддържат от всеки делегат. TensorFlow Lite предоставя инструмента Delegation Compatibility Check: пуснете модела с делегата и проверете колко операции (ops) са делегирани. Ако по-малко от 80% — по-добре изберете друг делегат или останете на CPU. Според TensorFlow (2025), GPU Delegate поддържа 45 операции, NNAPI — 60+.

В проектите на IT Sectr използваме GPU делегати за iOS и XNNPACK за Android с вградена проверка на съвместимост: моделът се тества на всички делегати, избира се най-бързият с пълнота на делегиране поне 90%.

// GPU Delegate свързване на Android
val gpuDelegate = GpuDelegate()
val options = Interpreter.Options().apply {
    addDelegate(gpuDelegate)
    setNumThreads(4)
}
val interpreter = Interpreter(modelBuffer, options)
interpreter.run(input, output)
gpuDelegate.close()

Проверка на делегирани операции — контрол на съвместимостта чрез Interpreter. По подразбиране делегатът приема всички операции, които поддържа. За отстраняване на грешки използвайте логване на броя делегирани възли. Ако моделът съдържа персонализирани операции (custom ops), делегатът не ги ускорява, но и не ги разваля — те се изпълняват на CPU.

// Проверете броя на делегираните операции
val delegateCount = interpreter.getDelegateOpsCount(gpuDelegate)
val totalNodes = interpreter.getNodesCount()
Log.d("TFLite", "Делегирани: $delegateCount / $totalNodes")
if (delegateCount < totalNodes * 0.8) {
    // Праг 80% — изберете друг делегат
}

GPU Delegate: ускорение на графичния процесор

GPU Delegate — делегат на TensorFlow Lite за изпълнение на модела на GPU чрез OpenGL ES 3.1+ (Android) или Metal (iOS). Графичните процесори са оптимизирани за паралелни матрични операции — Core ML и конволюционните невронни мрежи (CNN) получават най-голямо ускорение. GPU Delegate намалява латентността на инференса 4–8 пъти за модели като MobileNet, EfficientNet, Inception.

Ограничения на GPU Delegate: не поддържа всички операции (само 45 от ~120 в TF Lite), изисква OpenGL ES 3.1 или Metal, консумира повече енергия от CPU. GPU е неефективен за batch size > 1 в мобилни сценарии. Според бенчмаркове на TensorFlow (2025), на устройство Pixel 8 с GPU Adreno 740 моделът MobileNetV2 се изпълнява за 4.2 ms на GPU срещу 18.7 ms на CPU — ускорение от 4.4x.

Настройка на GPU Delegate включва избор на точност: float16 намалява точността, но ускорява инференса с 30–40% без забележима загуба на качество (за повечето задачи). Включете allow_precision_loss=true за максимална производителност на GPU. За задачи с висока точност (медицина, финанси) използвайте float32.

// GPU Delegate с оптимизация на точността
val gpuOptions = GpuDelegateFactory.Options().apply {
    isPrecisionLossAllowed = true
    inferencePreference = GpuDelegateFactory.Options.InferencePreference.SUSTAINED_SPEED
}
val delegate = GpuDelegateFactory.create(gpuOptions)

GPU Delegate на iOS използва Metal Performance Shaders чрез Metal Delegate. На iOS делегатът работи чрез Core ML delegate за Apple Neural Engine или директно чрез Metal. Apple A17 Pro изпълнява MobileNetV2 за 1.3 ms — 6 пъти по-бързо от CPU. Metal delegate е достъпен от iOS 12 и поддържа всички устройства с чип A7+.

NNAPI Delegate: невронни мрежи на Android чрез Neural Networks API

NNAPI Delegate (Android Neural Networks API) — делегат на TF Lite, който използва хардуерно ускорение чрез Android NN HAL (Hardware Abstraction Layer). NNAPI пренасочва операциите на модела към NPU, DSP или GPU в зависимост от наличните драйвери на устройството. Поддържа се на Android 8.1+ (API 27+) и е препоръчителният делегат по подразбиране за Android.

Предимство на NNAPI — автоматичен избор на ускорител. Ако устройството има NPU (Qualcomm Hexagon, MediaTek APU, Samsung NPU), NNAPI делегира операции към него. Ако няма NPU — към GPU чрез OpenCL. Ако GPU също не поддържа — към CPU с DSP оптимизации. Разработчикът не посочва конкретен ускорител — NNAPI избира оптималния. Според Google I/O 2024, NNAPI delegate на Snapdragon 8 Gen 3 ускорява LLM модели 12 пъти.

Ограничения на NNAPI: неравномерна поддръжка на различни устройства. Стари устройства (Android 8.1) имат ограничен набор от драйвери. Huawei с Kirin не поддържа NNAPI чрез Google Services — използвайте GPU Delegate. За гарантирана съвместимост Google препоръчва NNAPI Delegate като първи избор, с fallback на GPU или XNNPACK.

// NNAPI Delegate с CPU fallback
val nnApiOptions = NnApiDelegate.Options().apply {
    acceleratorName = null // null = автоматичен избор
    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 — параметър за изричен избор на ускорител. Ако се предаде null, NNAPI избира автоматично. За тестване посочете конкретен: "qti", "google-edgetpu", "mediatek". Списъкът на наличните ускорители се показва чрез NnApiDelegate.getAvailableAccelerators(). В продукция използвайте автоматичен избор с праг на съвместимост.

XNNPACK Delegate: CPU оптимизация чрез SIMD

XNNPACK Delegate — делегат на TensorFlow Lite за оптимизирано изпълнение на CPU чрез SIMD инструкции (ARM NEON, SSE, AVX). XNNPACK не изисква GPU или NPU — това е чист CPU делегат, но с 2–4x ускорение благодарение на SIMD, operator fusion, memory pre-fetching и quantized inference (INT8). Идеален за устройства без специален NPU или когато е необходима гарантирана съвместимост.

XNNPACK е разработен от Google като делегат по подразбиране на TF Lite за CPU (включен в TFLite Runtime по подразбиране). Поддържа 90+ операции — повече от GPU или NNAPI. XNNPACK е особено ефективен за квантувани модели (INT8, INT16): операциите работят 2–3 пъти по-бързо от float32 версията. Според бенчмаркове на Google (2025), XNNPACK ускорява INT8 MobileNetV2 2.8x спрямо базовия CPU.

XNNPACK срещу GPU: на устройства без NPU, XNNPACK често е по-бърз от GPU Delegate за малки batch (1–4) — GPU има overhead за прехвърляне на данни между CPU и GPU. XNNPACK работи в същото CPU адресно пространство — няма копиране на памет. За модели до 5MB, XNNPACK може да е по-бърз от GPU. За големи CNN модели GPU печели благодарение на паралелизма.

// XNNPACK Delegate активиран по подразбиране в TFLite 2.18+
// Изрично използване чрез 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 — принудително включва делегата, FLUSH_TO_ZERO — обработка на денормализирани числа за ускорение, ENABLE_XNNPACK_SHAPES — динамични размери на входа. За максимална съвместимост използвайте опциите по подразбиране. При грешки на стари устройства изключете XNNPACK — моделът все още работи на CPU, но по-бавно.

Core ML и Metal Delegate: ускорение на iOS

Core ML Delegate — делегат на TensorFlow Lite за iOS, който използва Apple Core ML Framework. Core ML конвертира TF Lite модела във формат .mlmodel и го изпълнява на Apple Neural Engine (ANE), GPU (Metal) или CPU. Apple A17 Pro и M3 имат специален Neural Engine, който Core ML използва автоматично. Core ML Delegate ускорява инференса 5–10 пъти спрямо CPU на съвременни iOS устройства.

Core ML на iOS поддържа flex delegate (динамично делегиране на операции, достъпни за Core ML) и full model conversion (конвертиране на целия модел в .mlmodel). Apple препоръчва flex delegate — той е по-бърз, защото работи по време на изпълнение без предварителна конвертация. Core ML Delegate поддържа float32, float16 и квантувани модели (INT8).

Metal Delegate — делегат на по-ниско ниво, който работи директно с Metal Performance Shaders. Използвайте Metal, когато Core ML не поддържа отделни операции. Metal Delegate дава максимален контрол над GPU, но изисква повече код. Според Apple (WWDC 2024), Metal Delegate за нативни Swift модели може да бъде с 15–20% по-бърз от Core ML поради липса на overhead от конвертация.

// Core ML Delegate на iOS чрез 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)

Избор между Core ML и Metal: Core ML — за продукция, Metal — за гранични случаи. Core ML автоматично управлява паметта на NE, поддържа падане към CPU (fallback) и не изисква ръчна конвертация. Metal дава контрол над буферите и е подходящ за персонализирани операции. В проектите на IT Sectr използваме Core ML Delegate за всички iOS модели и Metal само за задачи за видеоаналитика в реално време.

Как да изберем делегат за проекта

Изборът на TF Lite Delegate зависи от целевата платформа, модела и изискванията за латентност. Няма универсален най-добър делегат — всеки има силни и слаби страни. Оптимална стратегия: тествайте всички налични делегати на целевото устройство и изберете минимално достатъчно бързия — не най-бързия, а минимално достатъчния.

Препоръки за избор: за Android с NPU (Snapdragon 8 Gen 2+, Dimensity 9000+) — NNAPI Delegate. За Android без NPU — XNNPACK Delegate (по подразбиране). За iOS — Core ML Delegate. За междуплатформени проекти използвайте стратегия: NNAPI на Android, Core ML на iOS, XNNPACK като fallback. GPU Delegate — когато NNAPI не е наличен, а XNNPACK не е достатъчно бърз.

Тестване на латентност — задължителен етап от избора. Измерете инференса при минимална температура (студено устройство) и след 5 минути непрекъсната работа (термично регулиране). GPU и NNAPI могат да намалят производителността при нагряване. XNNPACK (CPU) страда по-малко. Използвайте TensorFlow Lite Benchmark Tool за автоматично тестване на всички делегати на вашето устройство.

// Стратегия за избор на делегат
fun selectDelegate(): TfLiteDelegate {
    return when {
        NnApiDelegate.getAvailableAccelerators()?.isNotEmpty == true ->
            NnApiDelegate()
        GpuDelegateFactory.isGpuDelegateAvailable() ->
            GpuDelegate()
        else -> XnnpackDelegate()
    }
}

Fallback стратегия — заредете модела без изключения: ако делегатът не се поддържа, пуснете на CPU. TensorFlow Lite хвърля IllegalArgumentException при грешка при създаване на делегат. Обвийте създаването на делегата в try-catch и при грешка пуснете модела без делегат. Бавен, но работещ AI е по-добър от грешка за потребителя.