TF Lite Delegate: що це, делегати GPU та NNAPI

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

TF Lite Delegate — це програмний адаптер між TensorFlow Lite Runtime та апаратним прискорювачем пристрою. Делегат перехоплює операції графа моделі (згортки, пулінг, матричні множення) та виконує їх на спеціалізованому обчислювачі замість CPU. Якщо делегат не підтримує конкретну операцію, вона виконується на CPU — це називається частковим делегуванням.

Архітектура 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 скорочує latency інференсу в 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 мс на GPU проти 18.7 мс на CPU — прискорення в 4.4x.

Налаштування GPU Delegate включає вибір precision: 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 мс — в 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 делегат на 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(). У production використовуйте авто-вибір із порогом сумісності.

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

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

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

XNNPACK vs GPU: на пристроях без NPU XNNPACK часто швидше за GPU Delegate для small 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 — динамічні розміри введення. Для максимальної сумісності використовуйте default options. При виникненні помилок на старих пристроях вимикайте 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 та quantized моделі (INT8).

Metal Delegate — більш низькорівневий делегат, що працює безпосередньо з Metal Performance Shaders. Використовуйте Metal, коли Core ML не підтримує окремі операції. Metal Delegate дає максимальний контроль над GPU, але потребує більше коду. За даними Apple (WWDC 2024), Metal Delegate для нативних Swift-моделей може бути на 15–20% швидше за Core ML через відсутність оверхеду конвертації.

// 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 — для production, Metal — для edge-випадків. Core ML автоматично керує пам'яттю NE, підтримує падіння на CPU (fallback) та не потребує ручної конвертації. Metal дає контроль над буферами та підходить для кастомних операцій. У проєктах IT Sectr ми використовуємо Core ML Delegate для всіх iOS-моделей та Metal лише для задач відеоаналітики в реальному часі.

Як вибрати делегат для проєкту

Вибір TF Lite Delegate залежить від цільової платформи, моделі та вимог до latency. Універсального найкращого делегата не існує — кожен має сильні та слабкі сторони. Оптимальна стратегія: тестувати всі доступні делегати на цільовому пристрої та вибирати мінімально швидкий — не найшвидший, а мінімально достатній.

Рекомендації щодо вибору: для 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 недостатньо швидкий.

Тестування latency — обов'язковий етап вибору. Виміряйте інференс на мінімальній температурі (пристрій холодний) та після 5 хвилин безперервної роботи (thermal throttling). 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 кращий, ніж помилка для користувача.