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 connection on 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.

// Check delegated operations count
val delegateCount = interpreter.getDelegateOpsCount(gpuDelegate)
val totalNodes = interpreter.getNodesCount()
Log.d("TFLite", "Delegated: $delegateCount / $totalNodes")
if (delegateCount < totalNodes * 0.8) {
    // 80% threshold — choose another delegate
}

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 with precision optimization
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 with 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 — параметр для явного выбора ускорителя. Если передать 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 enabled by default in TFLite 2.18+
// Explicit usage via 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 on iOS via 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 для автоматического тестирования всех делегатов на вашем устройстве.

// Delegate selection strategy
fun selectDelegate(): TfLiteDelegate {
    return when {
        NnApiDelegate.getAvailableAccelerators()?.isNotEmpty == true ->
            NnApiDelegate()
        GpuDelegateFactory.isGpuDelegateAvailable() ->
            GpuDelegate()
        else -> XnnpackDelegate()
    }
}

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