TF Lite Delegate：是什么、GPU 和 NNAPI 委托

什么是 TF Lite Delegate：架构和工作原理

TF Lite Delegate — 是 TensorFlow Lite 运行时和设备硬件加速器之间的软件适配器。委托拦截模型图的操作（卷积、池化、矩阵乘法），并在专用计算器上而非 CPU 上执行它们。如果委托不支持特定操作，则该操作在 CPU 上执行——这称为部分委托（partial delegation）。

TF Lite Delegate 的架构围绕 SimpleDelegate API 接口和 C++ 中的 TfLiteDelegate 结构构建。每个委托实现图节点委托、内存分配和在目标设备上执行的方法。开发者在调用 Invoke 之前通过 Interpreter::ModifyGraphWithDelegate 连接委托。根据 TensorFlow Guide，委托会自动应用于模型的所有支持的操作。

兼容性检查 — 强制步骤。并非所有操作都受每个委托支持。TensorFlow Lite 提供 Delegation Compatibility Check 工具：使用委托运行模型并检查有多少操作（ops）被委托。如果低于 80% — 最好选择其他委托或继续使用 CPU。根据 TensorFlow（2025），GPU Delegate 支持 45 个操作，NNAPI — 60+。

在 IT Sectr 项目中，我们使用 GPU 委托用于 iOS，XNNPACK 用于 Android，并带有内置兼容性检查：模型在所有委托上进行测试，选择委托完成度至少 90% 的最快委托。

// 在 Android 上连接 GPU Delegate
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 委托，用于通过 OpenGL ES 3.1+（Android）或 Metal（iOS）在 GPU 上执行模型。图形处理器针对并行矩阵运算进行了优化——Core ML 和卷积神经网络（CNN）获得最大提升。GPU Delegate 将 MobileNet、EfficientNet、Inception 等模型的推理延迟降低 4–8 倍。

GPU Delegate 的限制：不支持所有操作（仅支持 TF Lite 约 120 个中的 45 个），需要 OpenGL ES 3.1 或 Metal，比 CPU 消耗更多能量。GPU 在移动场景中对于 batch size > 1 效率不高。根据 TensorFlow 基准测试（2025），在搭载 Adreno 740 GPU 的 Pixel 8 设备上，MobileNetV2 模型在 GPU 上运行需要 4.2 毫秒，而在 CPU 上需要 18.7 毫秒——加速 4.4 倍。

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)

iOS 上的 GPU Delegate通过 Metal Delegate 使用 Metal Performance Shaders。在 iOS 上，委托通过 Core ML Delegate 用于 Apple Neural Engine 或直接通过 Metal 工作。Apple A17 Pro 在 1.3 毫秒内执行 MobileNetV2——比 CPU 快 6 倍。Metal Delegate 自 iOS 12 起可用，并支持所有搭载 A7+ 芯片的设备。

NNAPI Delegate：通过 Neural Networks API 在 Android 上运行神经网络

NNAPI Delegate（Android Neural Networks API）—— 一种 TF Lite 委托，通过 Android NN HAL（硬件抽象层）使用硬件加速。NNAPI 根据设备可用的驱动程序将模型操作重定向到 NPU、DSP 或 GPU。支持 Android 8.1+（API 27+），是 Android 推荐的默认委托。

NNAPI 的优势——自动选择加速器。如果设备有 NPU（Qualcomm Hexagon、MediaTek APU、Samsung NPU），NNAPI 将操作委托给它。如果没有 NPU——则通过 OpenCL 委托给 GPU。如果 GPU 也不支持——则通过 DSP 优化委托给 CPU。开发者无需指定具体的加速器——NNAPI 选择最优的。根据 Google I/O 2024，Snapdragon 8 Gen 3 上的 NNAPI 委托可将 LLM 模型加速 12 倍。

NNAPI 的限制：不同设备上的支持不均衡。旧设备（Android 8.1）具有有限的驱动程序集。搭载 Kirin 的华为不支持通过 Google Services 使用 NNAPI——请使用 GPU Delegate。为了确保兼容性，Google 推荐 NNAPI Delegate 作为首选，并回退到 GPU 或 XNNPACK。

// NNAPI Delegate 带 CPU 回退
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：通过 SIMD 优化 CPU

XNNPACK Delegate——TensorFlow Lite 委托，用于通过 SIMD 指令（ARM NEON、SSE、AVX）在 CPU 上进行优化执行。XNNPACK 不需要 GPU 或 NPU——它是一个纯 CPU 委托，但通过 SIMD、算子融合、内存预取和量化推理（INT8）实现 2–4 倍的加速。适用于没有专用 NPU 的设备或需要保证兼容性的情况。

XNNPACK由 Google 开发，作为 CPU 的默认 TF Lite 委托（默认包含在 TFLite 运行时中）。支持 90+ 个操作——比 GPU 或 NNAPI 更多。XNNPACK 对于量化模型（INT8、INT16）特别有效：操作执行速度比 float32 版本快 2–3 倍。根据 Google 基准测试（2025），XNNPACK 将 INT8 MobileNetV2 相对于基础 CPU 加速 2.8 倍。

XNNPACK vs GPU：在没有 NPU 的设备上，对于小批量（1–4），XNNPACK 通常比 GPU Delegate 更快——GPU 在 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 标志：USE_XNNPACK——强制启用委托，FLUSH_TO_ZERO——处理非规格化数以加速，ENABLE_XNNPACK_SHAPES——动态输入尺寸。为了最大兼容性，请使用默认选项。如果在旧设备上出现错误，请禁用 XNNPACK——模型仍在 CPU 上运行，但速度较慢。

Core ML 和 Metal Delegate：在 iOS 上加速

Core ML Delegate——用于 iOS 的 TensorFlow Lite 委托，使用 Apple Core ML 框架。Core ML 将 TF Lite 模型转换为 .mlmodel 格式，并在 Apple Neural Engine（ANE）、GPU（Metal）或 CPU 上执行。Apple A17 Pro 和 M3 具有专用的 Neural Engine，Core ML 会自动使用它。在现代 iOS 设备上，Core ML Delegate 将推理速度比 CPU 提升 5–10 倍。

iOS 上的 Core ML支持灵活委托（动态委托 Core ML 支持的操作）和完整模型转换（将整个模型转换为 .mlmodel）。Apple 推荐灵活委托——它更快，因为它在运行时无需事先转换即可工作。Core ML Delegate 支持 float32、float16 和量化模型（INT8）。

Metal Delegate——一种较低级别的委托，直接与 Metal Performance Shaders 一起工作。当 Core ML 不支持某些操作时，请使用 Metal。Metal Delegate 提供对 GPU 的最大控制，但需要更多代码。根据 Apple（WWDC 2024），对于原生 Swift 模型，Metal Delegate 可能比 Core ML 快 15–20%，因为没有转换开销。

// 通过 TFLite Swift API 在 iOS 上使用 Core ML Delegate
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 项目中，我们对所有 iOS 模型使用 Core ML Delegate，仅在实时视频分析任务中使用 Metal。

如何为项目选择委托

选择 TF Lite Delegate取决于目标平台、模型和延迟要求。没有通用的最佳委托——每个都有优点和缺点。最佳策略：在目标设备上测试所有可用的委托，并选择最低足够快的——不是最快的，而是最低足够的。

选择建议：对于带 NPU 的 Android（Snapdragon 8 Gen 2+、Dimensity 9000+）——使用 NNAPI Delegate。对于不带 NPU 的 Android——使用 XNNPACK Delegate（默认）。对于 iOS——使用 Core ML Delegate。对于跨平台项目，使用策略：Android 上使用 NNAPI，iOS 上使用 Core ML，XNNPACK 作为回退。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()
    }
}

回退策略——无异常加载模型：如果委托不受支持，则在 CPU 上运行。TensorFlow Lite 在创建委托出错时抛出 IllegalArgumentException。将委托创建包装在 try-catch 中，出错时在没有委托的情况下运行模型。对于用户来说，缓慢但运行正常的 AI 总比错误好。