# LiteRT 开发者工作流程
您可以通过从开源社区下载现有的 LiteRT 模型来使用它。或者，您可以使用特定工具将 TensorFlow 或 Keras 模型转换为 LiteRT 格式。模型转换完成后，您可以在设备上运行推理并为 LiteRT 模型开发定制应用。
下图展示了使用现有模型、对模型进行转换和量化，以及创建用于运行推理的应用程序所涉及的各项任务。
**图：LiteRT 开发者工作流程**
Note
如果您使用来自 Qualcomm AI Hub 或其他来源的 LiteRT 模型，则可以跳过 LiteRT 开发者工作流中描述的任务。
在 Qualcomm 专用硬件上运行 LiteRT 模型涉及以下任务。
## 将 TensorFlow 模型转换为 LiteRT 模型
您可以将 TensorFlow 模型转换为 LiteRT 模型，并对设备上推理对其进行优化。有关 LiteRT 模型转换的更多信息，请参见[模型转换概述](https://ai.google.dev/edge/litert/models/convert)。
LiteRT 模型转换支持将模型转换为以下格式：
- 32 位浮点精度
- 16 位浮点精度
- UINT8/INT8 精度（量化模型）
### 使用现有的 LiteRT 模型
可以使用 LiteRT 部署来自开源社区的现有LiteRT模型。
Qualcomm AI Hub 发布针对 Qualcomm Linux 开发包优化的 LiteRT 模型。关于 Qualcomm 的 LiteRT 模型，请参阅 [Qualcomm AI Hub](https://aihub.qualcomm.com/)。
如需从 Qualcomm AI Hub 下载优化后的模型，可执行以下操作：
1. 转到 [Qualcomm AI Hub IOT 模型页面](https://aihub.qualcomm.com/iot/models)。
2. 在左侧窗格中，通过选择芯片组筛选可用模型。
3. 选择一个模型。
4. 在下一页，选择 TorchScript > TFLite 路径。
5. 选择 Download model
Note
下载的模型已经过预优化，可直接部署。
**图：在 Qualcomm AI Hub 上优化的 LiteRT 模型**
### 将 TensorFlow 或 Keras 模型转换为 LiteRT 格式
TensorFlow 框架提供 Python API 和命令行界面 (CLI) 工具，用于将 TensorFlow 或 Keras 模型转换为 LiteRT 格式。
表：TensorFlow 模型转换方法
| 转换方法 | 说明 |
| --- | --- |
| Python API | 将模型转换、优化和量化为 LiteRT 格式 |
| CLI 工具 | 将模型转换为 LiteRT 格式，但仅适用于基本模型转换 |
Note
TensorFlow 到 LiteRT Python API 提供了更大的灵活性，可进行模型转换、优化和量化以满足您的要求。
### 使用Python API 进行转换和量化
TensorFlow 提供以下 API 将 TensorFlow SavedModel 或 Keras 模型转换为 LiteRT 模型。
表：用于转换模型的 TensorFlow Python API
| API | 说明 |
| --- | --- |
| tf.lite.TFLiteConverter.from\_saved\_model()（推荐） | 转换 TensorFlow SavedModel |
| tf.lite.TFLiteConverter.from\_keras\_model() | 转换 Keras 模型 |
### 推荐：转换 TensorFlow SavedModel
以下示例展示了如何将以 saved\_model 格式保存的 TensorFlow 模型转换为 LiteRT 模型：
import tensorflow as tf
# Convert the model
saved_model_dir = "/path/to/tf/model/in/saved_model/format"
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
tflite_model = converter.convert()
# Save the model
with open("model.tflite", "wb") as f:
f.write(tflite_model)
Copy to clipboard
Note
转换后的 LiteRT 模型未进行量化，其数据为 32 位浮点精度。
### 转换 Keras 模型
以下示例展示了如何将 Keras 模型转换为 LiteRT 模型：
import tensorflow as tf
# Create a model using high-level tf.keras.* APIs
model = tf.keras.models.Sequential([
tf.keras.layers.Dense(units=1, input_shape=[1]),
tf.keras.layers.Dense(units=16, activation='relu'),
tf.keras.layers.Dense(units=1)
])
# compile the model
model.compile(optimizer='sgd', loss='mean_squared_error')
# train the model
model.fit(x=[-1, 0, 1], y=[-3, -1, 1], epochs=5)
# Convert the model to LiteRT
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
# Save the model
with open('model.tflite', 'wb') as f:
f.write(tflite_model)
Copy to clipboard
Note
转换后的 LiteRT 模型未进行量化，其数据为 32 位浮点精度。
## 量化模型
将模型转换为 LiteRT 格式后，您可以对其进行量化。神经网络模型中的量化涉及以下步骤：
1. 量化权值和阈值：这些已包含在训练好的模型中，无需额外信息即可量化。因此，权值和阈值的量化是一个静态步骤。
2. 量化激活层：激活层输出的范围取决于前向传播期间的输入图像。因此，需要一组称为校准数据集或代表性数据集的样本输入，以量化这些层并确定最小值和最大值范围。
为了将TensorFlow浮点模型处理为量化的 LiteRT 模型，LiteRT 提供了训练后量化技术。有关详细信息，参见[训练后量化](https://ai.google.dev/edge/litert/models/post_training_quantization)。
### 训练后量化
LiteRT 支持两种类型的训练后量化：
- 训练后动态范围量化
- 训练后全整数量化
### 训练后动态范围量化
在训练后动态范围量化中，权重和偏差从浮点精度静态量化为定点整数 8 位精度。激活层范围保持 32 位浮点精度。
为了减少推理过程中的延迟，动态范围运算符：
- 根据激活的范围将其量化为定点整数 8 位精度
- 使用 8 位权重和激活执行计算
Note
此步骤仅量化权重，无需额外校准数据。
以下脚本将 TensorFlow 模型转换并量化为 LiteRT 模型：
import tensorflow as tf
from tensorflow import keras
converter = tf.lite.TFLiteConverter.from_saved_model(exp_model_path)
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS]
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()
save_name = 'quantized_model.tflite'
print('Saving Dynamic Quantized LiteRT model ..................')
with open(save_name, 'wb') as f:
f.write(tflite_model)
Copy to clipboard
### 训练后全整数量化
在全整数量化中，代表性数据会量化模型内的激活层。
以下脚本将 TensorFlow 模型转换并量化为 LiteRT 模型。该脚本生成了一个全整数量化模型，更适合定点整数硬件，例如 Qualcomm Linux 开发包上的 Hexagon Tensor Processor。
import tensorflow as tf
def representative_dataset():
for data in dataset:
yield {
"image": data.image,
"bias": data.bias,
}
saved_model_dir = "/path/to/saved/model"
# prepare converter by loading model in saved_model format.
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
# Set representative dataset used for quantization.
converter.representative_dataset = representative_dataset
# For full-integer quantization, set target_spec supported_ops to TFLITE_BUILTINS_INT8.
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8 # or tf.uint8
converter.inference_output_type = tf.int8 # or tf.uint8
# Convert model
tflite_quant_model = converter.convert()
save_name = 'quantized_model_int8.tflite'
print('Saving Quantized LiteRT model ..................')
with open(save_name, 'wb') as f:
f.write(tflite_model)
Copy to clipboard
Note
转换器中的 `supported_ops` 将 `target_spec` 设置为 `tf.lite.OpsSet.TFLITE_BUILTINS_INT8`。
## 使用离线转换工具进行转换
TensorFlow pip 包包含 tflite\_convert TensorFlow Lite 离线转换器工具 (CLI)，可以在2.x 及更高版本的 TensorFlow 中离线使用。
Tflite\_convert 工具在 CLI 中接受以下输入：
tflite_convert --help
optional arguments:
-h, --help show this help message and exit
--output_file OUTPUT_FILE
Full filepath of the output file.
--saved_model_dir SAVED_MODEL_DIR
Full path of the directory containing the SavedModel.
--keras_model_file KERAS_MODEL_FILE
Full filepath of HDF5 file containing tf.Keras model.
--saved_model_tag_set SAVED_MODEL_TAG_SET
Comma-separated set of tags identifying the MetaGraphDef within the SavedModel to analyze. All tags must be present. To pass in an empty
tag set, pass in "". (default "serve")
--saved_model_signature_key SAVED_MODEL_SIGNATURE_KEY
Key identifying the SignatureDef containing inputs and outputs. (default DEFAULT_SERVING_SIGNATURE_DEF_KEY)
--enable_v1_converter
Enables the TensorFlow V1 converter in 2.0
Copy to clipboard
### 转换 SavedModel
要使用 tflite\_convert工具转换以 saved\_model 格式的典型 TensorFlow 模型，运行以下命令：
tflite_convert \
--saved_model_dir=/tmp/mobilenet_saved_model \
--output_file=/tmp/mobilenet.tflite \
--saved_model_tag_set=serve \
--saved_model_signature_key="serving_default"
Copy to clipboard
### 转换 Keras H5 模型
要使用 tflite\_convert 工具转换 Keras 模型，运行以下命令：
tflite_convert \
--keras_model_file=/tmp/mobilenet_keras_model.h5 \
--output_file=/tmp/mobilenet.tflite
Copy to clipboard
Note
tflite\_convert 工具仅适用于基本用途。对于训练后整数量化，Qualcomm 建议使用 Python API。
## 创建应用程序并运行推理
可以使用 LiteRT C++ API 创建应用程序、加载 LiteRT 模型并使用 delegate 在硬件上运行该模型。
下图展示了使用 C++ API 创建一个用于运行 LiteRT 模型的应用程序所涉及的步骤。
**图：创建应用并运行 LiteRT 模型的工作流程**
### 加载 LiteRT 模型
LiteRT 模型是一个 FlatBuffers 文件，其中包含关于模型运算符以及任何相关权重和偏差的信息。
FlatBuffers 文件包括以下内容：
- 张量（每个操作的输入和输出）
- 缓存（权重和偏差）
- 创建执行图的操作
LiteRT 框架提供了执行以下内容的 API：
- 加载 LiteRT 模型文件
- 将 FlatBuffers 文件的所有内容解压至内存中
可以使用以下 API 加载 LiteRT 模型进行推理：
include
include
include "tensorflow/lite/interpreter.h"
include "tensorflow/lite/kernels/register.h"
include "tensorflow/lite/model.h"
include "tensorflow/lite/optional_debug_tools.h"
std::unique_ptr model;
model = tflite::FlatBufferModel::BuildFromFile(model_name.c_str());
if (!model) {
std::cerr << "Failed to mmap model " << model_name << std::endl;
exit(-1);
}
Copy to clipboard
### 创建 LiteRT 解释
使用 TensorFlow C/C++ API，可编译一个解析器来运行模型。
解析器界面可帮助您执行以下操作：
- 在选定的 delegate 上配置模型执行方法。
- 分配前向传播所需的内存。
以下示例代码演示了如何创建解析器。可配置解析器实例以使用特定的 delegate 并执行前向传播。
//Build the interpreter with the InterpreterBuilder.
//Note: all Interpreters should be built with the InterpreterBuilder,
// which allocates memory for the Interpreter and does various set up
// tasks so that the Interpreter can read the provided model.
tflite::ops::builtin::BuiltinOpResolver resolver;
tflite::InterpreterBuilder builder(*model, resolver);
std::unique_ptr interpreter;
builder(&interpreter);
if (!interpreter) {
std::cerr << "Failed to construct interpreter on provided tflite model" << std::endl;
}
if (interpreter->AllocateTensors() != kTfLiteOk) {
std::cerr << "Failed to allocate tensors!" << std::endl;
exit(-1);
}
Copy to clipboard
### 使用选定的 delegate来准备一个模型
创建解析器并分配运行模型所需的内存后，使用选定的 delegate 准备模型。此步骤从之前加载的模型创建执行图，并使用底层库在 delegate 硬件上执行推理。
以下示例代码创建 XNNPACK Delegate，用于在 Arm CPU 上运行 LiteRT 模型。它通过调用 `TfLiteXNNPackDelegateCreate(…)` API 来创建 delegate。您还可以使用 delegate 选项 API 自定义 delegate。
TfLiteDelegate *delegate = NULL;
TfLiteXNNPackDelegateOptions xnnpack_options =
TfLiteXNNPackDelegateOptionsDefault();
xnnpack_options.num_threads = num_threads;
TfLiteDelegate* xnnpack_delegate =
TfLiteXNNPackDelegateCreate(&xnnpack_options);
if (interpreter->ModifyGraphWithDelegate(xnnpack_delegate) != kTfLiteOk) {
// Report error and fall back to another delegate, or the default backend
}
Copy to clipboard
### 准备输入/输出缓存
编译独立的 LiteRT 应用时，必须准备输入数据（例如相机帧），以便 pipeline 运行 LiteRT 模型。
例如在以下情况下，预处理操作对于确保推理正确进行非常重要：
- 将输入图像调整为模型期望的分辨率
- 归一化
- 均值减法
### 运行模型
您必须使用 `Invoke()` API 调用 delegate，以便对模型运行推理。在调用此 API 之前，创建适当的输入/输出缓冲区并将其提供给解析器。
推理完成后，您可以解析由解释器缓存的输出，生成推理结果。
使用 delegate 运行模型的 `Invoke()` API 示例如下：
// Run Inference
interpreter->Invoke()
Copy to clipboard
推理完成后，您可以在解释器的输出缓存中找到 LiteRT `Invoke()` API 的输出张量。要对这些输出执行进一步的后处理，可以从解析器中进行解析。
有关综合示例，请参见 [TensorFlow GitHub 存储库](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/examples/label_image)中的 label\_image 示例。
关于更多信息，请参阅 [LiteRT 文档](https://ai.google.dev/edge/litert)。
## 开发定制的应用程序
Qualcomm IM SDK 提供了基于 qtimltflite GStreamer、用于执行 LiteRT 模型推理的插件，以便提升开发者体验。
有关更多信息，请参见以下内容：
- [Qualcomm IM SDK](https://docs.qualcomm.com/bundle/publicresource/topics/80-70018-50/overview.html) 文档
- [qtimltflite](https://docs.qualcomm.com/bundle/publicresource/topics/80-70018-50/qtimltflite.html) 插件文档
- [开发您自己的应用程序](https://docs.qualcomm.com/bundle/publicresource/topics/80-70018-15B/develop-your-own-application.html)
Last Published: Apr 29, 2025
[Previous Topic
LiteRT 架构](https://docs.qualcomm.com/bundle/publicresource/80-70018-54SC/topics/arch.md) [Next Topic
运行 LiteRT 示例应用](https://docs.qualcomm.com/bundle/publicresource/80-70018-54SC/topics/sample-applications.md)