隆重推出 Google AI Edge Portal：大规模对边缘 AI 进行基准测试。注册以在非公开预览期间申请访问权限。

此页面由 Cloud Translation API 翻译。

利用 LiteRT 实现 NPU 加速

LiteRT 提供了一个统一的接口来使用神经处理单元 (NPU)，而无需您费力地处理特定于供应商的编译器、运行时或库依赖项。使用 LiteRT 进行 NPU 加速可提升实时推理和大型模型推理的性能，并通过零复制硬件缓冲区使用最大限度地减少内存复制。

开始使用

如需开始使用，请参阅 NPU 概览指南：

对于经典机器学习模型，请参阅以下部分，了解转换、编译和部署步骤。
对于大型语言模型 (LLM)，请使用我们的 LiteRT-LM 框架：
- 使用 LiteRT-LM 在 NPU 上执行 LLM

如需查看支持 NPU 的 LiteRT 的示例实现，请参阅以下演示应用：

NPU 供应商

LiteRT 支持以下供应商的 NPU 加速：

Qualcomm AI Engine Direct

通过 Compiled Model API 支持 AOT 和设备端编译执行路径。
如需了解设置详情，请参阅 Qualcomm AI Engine Direct。

MediaTek NeuroPilot

通过 Compiled Model API 支持 AOT 和 JIT 执行路径。
如需了解设置详情，请参阅 MediaTek NeuroPilot。

转换和编译 NPU 模型

为了使用 LiteRT 进行 NPU 加速，模型必须转换为 LiteRT 文件格式，并针对设备端 NPU 使用进行编译。您可以使用 LiteRT AOT（预先）编译器将模型编译为 AI Pack，该 AI Pack 会将编译后的模型与设备定位配置捆绑在一起。这会验证模型是否已正确提供给设备，具体取决于设备是否配备或针对特定 SoC 进行了优化。

转换并编译模型后，您可以使用 Play On-device AI (PODAI) 将模型上传到 Google Play，并通过 On-Demand AI 框架将模型交付给设备。

如需有关如何转换和编译 NPU 模型的端到端指南，请使用 LiteRT AOT 编译笔记本。

[仅限 AOT] 使用 Play AI Pack 进行部署

转换模型并编译 AI Pack 后，请按照以下步骤通过 Google Play 部署 AI Pack。

将 AI Pack 导入到 Gradle 项目中

将 AI Pack 复制到 Gradle 项目的根目录。例如：

my_app/
    ...
    ai_packs/
        my_model/...
        my_model_mtk/...

将每个 AI Pack 添加到 Gradle build 配置中：

// my_app/ai_packs/my_model/build.gradle.kts

plugins { id("com.android.ai-pack") }

aiPack {
  packName = "my_model"  // ai pack dir name
  dynamicDelivery { deliveryType = "on-demand" }
}

// Add another build.gradle.kts for my_model_mtk/ as well

将 NPU 运行时库添加到项目

下载 litert_npu_runtime_libraries.zip（适用于 AOT）或 litert_npu_runtime_libraries_jit.zip（适用于 JIT），并将其解压缩到项目的根目录中：

my_app/
    ...
    litert_npu_runtime_libraries/
        mediatek_runtime/...
        qualcomm_runtime_v69/...
        qualcomm_runtime_v73/...
        qualcomm_runtime_v75/...
        qualcomm_runtime_v79/...
        qualcomm_runtime_v81/...
        fetch_qualcomm_library.sh

运行脚本以下载 NPU 支持库。例如，针对 Qualcomm NPU 运行以下命令：

$ ./litert_npu_runtime_libraries/fetch_qualcomm_library.sh

将 AI 包和 NPU 运行时库添加到 Gradle 配置中

将生成的 AI Pack 中的 device_targeting_configuration.xml 复制到主应用模块的目录。然后更新 settings.gradle.kts：

// my_app/setting.gradle.kts

...

// [AOT only]
// AI Packs
include(":ai_packs:my_model")
include(":ai_packs:my_model_mtk")

// NPU runtime libraries
include(":litert_npu_runtime_libraries:runtime_strings")

include(":litert_npu_runtime_libraries:mediatek_runtime")
include(":litert_npu_runtime_libraries:qualcomm_runtime_v69")
include(":litert_npu_runtime_libraries:qualcomm_runtime_v73")
include(":litert_npu_runtime_libraries:qualcomm_runtime_v75")
include(":litert_npu_runtime_libraries:qualcomm_runtime_v79")
include(":litert_npu_runtime_libraries:qualcomm_runtime_v81")

更新 build.gradle.kts：

// my_app/build.gradle.kts

android {
 ...

 defaultConfig {
    ...

    // API level 31+ is required for NPU support.
    minSdk = 31

    // NPU only supports arm64-v8a
    ndk { abiFilters.add("arm64-v8a") }
    // Needed for Qualcomm NPU runtime libraries
    packaging { jniLibs { useLegacyPackaging = true } }
  }

  // Device targeting
  bundle {
      deviceTargetingConfig = file("device_targeting_configuration.xml")
      deviceGroup {
        enableSplit = true // split bundle by #group
        defaultGroup = "other" // group used for standalone APKs
      }
  }

  // [AOT Only]
  // AI Packs
  assetPacks.add(":ai_packs:my_model")
  assetPacks.add(":ai_packs:my_model_mtk")

  // NPU runtime libraries
  dynamicFeatures.add(":litert_npu_runtime_libraries:mediatek_runtime")
  dynamicFeatures.add(":litert_npu_runtime_libraries:qualcomm_runtime_v69")
  dynamicFeatures.add(":litert_npu_runtime_libraries:qualcomm_runtime_v73")
  dynamicFeatures.add(":litert_npu_runtime_libraries:qualcomm_runtime_v75")
  dynamicFeatures.add(":litert_npu_runtime_libraries:qualcomm_runtime_v79")
  dynamicFeatures.add(":litert_npu_runtime_libraries:qualcomm_runtime_v81")
}

dependencies {
  // Dependencies for strings used in the runtime library modules.
  implementation(project(":litert_npu_runtime_libraries:runtime_strings"))
  ...
}

[仅限 AOT] 使用按需部署

在 build.gradle.kts 文件中配置 Android AI Pack 功能后，检查设备功能并在支持的设备上使用 NPU，同时使用 GPU 和 CPU 作为后备：

val env = Environment.create(BuiltinNpuAcceleratorProvider(context))

val modelProvider = AiPackModelProvider(
    context, "my_model", "model/my_model.tflite") {
    if (NpuCompatibilityChecker.Qualcomm.isDeviceSupported())
      setOf(Accelerator.NPU) else setOf(Accelerator.CPU, Accelerator.GPU)
}
val mtkModelProvider = AiPackModelProvider(
    context, "my_model_mtk", "model/my_model_mtk.tflite") {
    if (NpuCompatibilityChecker.Mediatek.isDeviceSupported())
      setOf(Accelerator.NPU) else setOf()
}
val modelSelector = ModelSelector(modelProvider, mtkModelProvider)
val model = modelSelector.selectModel(env)

val compiledModel = CompiledModel.create(
    model.getPath(),
    CompiledModel.Options(model.getCompatibleAccelerators()),
    env,
)

为 JIT 模式创建 `CompiledModel`

val env = Environment.create(BuiltinNpuAcceleratorProvider(context))

val compiledModel = CompiledModel.create(
    "model/my_model.tflite",
    CompiledModel.Options(Accelerator.NPU),
    env,
)

在 Kotlin 中使用 LiteRT 在 NPU 上进行推理

如需开始使用 NPU 加速器，请在创建编译后的模型 (CompiledModel) 时传递 NPU 参数。

以下代码段展示了整个流程在 Kotlin 中的基本实现：

val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

inputBuffers[0].writeFloat(FloatArray(data_size) { data_value })
model.run(inputBuffers, outputBuffers)
val outputFloatArray = outputBuffers[0].readFloat()

inputBuffers.forEach { it.close() }
outputBuffers.forEach { it.close() }
model.close()

在 C++ 中使用 LiteRT 在 NPU 上进行推理

构建依赖项

C++ 用户必须使用 LiteRT NPU 加速功能构建应用的依赖项。用于打包核心应用逻辑（例如，cc_binarymain.cc）需要以下运行时组件：

LiteRT C API 共享库：data 属性必须包含 LiteRT C API 共享库 (//litert/c:litert_runtime_c_api_shared_lib) 和 NPU 的特定于供应商的调度共享对象 (//litert/vendors/qualcomm/dispatch:dispatch_api_so)。
特定于 NPU 的后端库：例如，适用于 Android 主机（如 libQnnHtp.so、libQnnHtpPrepare.so）的 Qualcomm AI RT (QAIRT) 库和相应的 Hexagon DSP 库 (libQnnHtpV79Skel.so)。这可确保 LiteRT 运行时能够将计算任务分流到 NPU。
属性依赖项：deps 属性会链接到必要的编译时依赖项，例如 LiteRT 的张量缓冲区 (//litert/cc:litert_tensor_buffer) 和 NPU 调度层的 API (//litert/vendors/qualcomm/dispatch:dispatch_api)。这样一来，您的应用代码就能通过 LiteRT 与 NPU 进行交互。
模型文件和其他资源：通过 data 属性包含。

此设置允许已编译的二进制文件动态加载并使用 NPU 来加速机器学习推理。

设置 NPU 环境

某些 NPU 后端需要运行时依赖项或库。使用编译后的模型 API 时，LiteRT 通过 Environment 对象来整理这些要求。使用以下代码查找合适的 NPU 库或驱动程序：

// Provide a dispatch library directory (following is a hypothetical path) for the NPU
std::vector<Environment::Option> environment_options = {
    {
      Environment::OptionTag::DispatchLibraryDir,
      "/usr/lib64/npu_dispatch/"
    }
};

LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create(absl::MakeConstSpan(environment_options)));

运行时集成

以下代码段展示了整个流程在 C++ 中的基本实现：

// 1. Load the model that has NPU-compatible ops
LITERT_ASSIGN_OR_RETURN(auto model, Model::Load("mymodel_npu.tflite"));

// 2. Create a compiled model with NPU acceleration
//    See following section on how to set up NPU environment
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
  CompiledModel::Create(env, model, kLiteRtHwAcceleratorNpu));

// 3. Allocate I/O buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers, compiled_model.CreateInputBuffers());
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// 4. Fill model inputs (CPU array -> NPU buffers)
float input_data[] = { /* your input data */ };
input_buffers[0].Write<float>(absl::MakeConstSpan(input_data, /*size*/));

// 5. Run inference
compiled_model.Run(input_buffers, output_buffers);

// 6. Access model output
std::vector<float> data(output_data_size);
output_buffers[0].Read<float>(absl::MakeSpan(data));

利用 NPU 加速实现零复制

使用零复制可让 NPU 直接访问自身内存中的数据，而无需 CPU 明确复制该数据。通过不将数据复制到 CPU 内存和从 CPU 内存复制数据，零复制可以显著缩短端到端延迟时间。

以下代码是使用 AHardwareBuffer 将数据直接传递给 NPU 的零复制 NPU 的实现示例。此实现避免了与 CPU 内存之间昂贵的往返，从而显著减少了推理开销。

// Suppose you have AHardwareBuffer* ahw_buffer

LITERT_ASSIGN_OR_RETURN(auto tensor_type, model.GetInputTensorType("input_tensor"));

LITERT_ASSIGN_OR_RETURN(auto npu_input_buffer, TensorBuffer::CreateFromAhwb(
    env,
    tensor_type,
    ahw_buffer,
    /* offset = */ 0
));

std::vector<TensorBuffer> input_buffers{npu_input_buffer};

LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// Execute the model
compiled_model.Run(input_buffers, output_buffers);

// Retrieve the output (possibly also an AHWB or other specialized buffer)
auto ahwb_output = output_buffers[0].GetAhwb();

串联多个 NPU 推理

对于复杂的流水线，您可以串联多个 NPU 推理。由于每个步骤都使用加速器友好的缓冲区，因此流水线大部分时间都处于 NPU 管理的内存中：

// compiled_model1 outputs into an AHWB
compiled_model1.Run(input_buffers, intermediate_buffers);

// compiled_model2 consumes that same AHWB
compiled_model2.Run(intermediate_buffers, final_outputs);

NPU 即时编译缓存

LiteRT 支持对 .tflite 模型进行 NPU 即时 (JIT) 编译。在无法提前编译模型的情况下，JIT 编译尤其有用。

不过，JIT 编译在将用户提供的模型按需转换为 NPU 字节码指令时，可能会产生一些延迟和内存开销。为了最大限度地降低性能影响，可以缓存 NPU 编译制品。

启用缓存后，LiteRT 仅会在需要时触发模型重新编译，例如：

供应商的 NPU 编译器插件版本已更改；
Android build 指纹已更改；
用户提供的模型发生了变化；
编译选项已更改。

如需启用 NPU 编译缓存，请在环境选项中指定 CompilerCacheDir 环境标记。该值必须设置为应用的现有可写入路径。

   const std::array environment_options = {
        litert::Environment::Option{
            /*.tag=*/litert::Environment::OptionTag::CompilerPluginLibraryDir,
            /*.value=*/kCompilerPluginLibSearchPath,
        },
        litert::Environment::Option{
            litert::Environment::OptionTag::DispatchLibraryDir,
            kDispatchLibraryDir,
        },
        // 'kCompilerCacheDir' will be used to store NPU-compiled model
        // artifacts.
        litert::Environment::Option{
            litert::Environment::OptionTag::CompilerCacheDir,
            kCompilerCacheDir,
        },
    };

    // Create an environment.
    LITERT_ASSERT_OK_AND_ASSIGN(
        auto environment, litert::Environment::Create(environment_options));

    // Load a model.
    auto model_path = litert::testing::GetTestFilePath(kModelFileName);
    LITERT_ASSERT_OK_AND_ASSIGN(auto model,
                                litert::Model::CreateFromFile(model_path));

    // Create a compiled model, which only triggers NPU compilation if
    // required.
    LITERT_ASSERT_OK_AND_ASSIGN(
        auto compiled_model, litert::CompiledModel::Create(
                                 environment, model, kLiteRtHwAcceleratorNpu));

延迟时间和内存节省示例：

NPU 编译所需的时间和内存可能会因多种因素而异，例如底层 NPU 芯片、输入模型的复杂程度等。

下表比较了需要 NPU 编译时与由于缓存而可以跳过编译时的运行时初始化时间和内存消耗。在一台示例设备上，我们获得了以下信息：

TFLite 模型	使用 NPU 编译进行模型初始化	使用缓存的编译进行模型初始化	使用 NPU 编译初始化内存占用	使用缓存的编译初始化内存
torchvision_resnet152.tflite	7465.22 毫秒	198.34 毫秒	1525.24 MB	355.07 MB
torchvision_lraspp_mobilenet_v3_large.tflite	1592.54 毫秒	166.47 毫秒	254.90 MB	33.78 MB

在其他设备上，我们会获取以下信息：

TFLite 模型	使用 NPU 编译进行模型初始化	使用缓存的编译进行模型初始化	使用 NPU 编译初始化内存占用	使用缓存的编译初始化内存
torchvision_resnet152.tflite	2766.44 毫秒	379.86 毫秒	653.54 MB	501.21 MB
torchvision_lraspp_mobilenet_v3_large.tflite	784.14 毫秒	231.76 毫秒	113.14 MB	67.49 MB