TensorFlow Lite (TFLite) 入门指南：将智能部署到移动及边缘设备

随着人工智能技术的飞速发展，机器学习模型的能力日益强大。然而，这些模型通常需要在强大的计算资源上进行训练。将这些大型模型部署到资源受限的设备上，如智能手机、物联网设备甚至微控制器，一直是实际应用中的一大挑战。TensorFlow Lite (TFLite) 正是为了解决这一问题而诞生的。

本文将为您提供一份详细的 TensorFlow Lite 入门指南，带您了解 TFLite 的核心概念、工作流程、如何转换和优化模型，以及如何在不同平台上进行集成。

第一章：初识 TensorFlow Lite (TFLite)

1.1 什么是 TensorFlow Lite？

TensorFlow Lite 是 Google 为在设备上部署机器学习模型而开发的开源框架。它允许开发者在移动、嵌入式和 IoT 设备上运行 TensorFlow 模型，而无需依赖云端服务器。

1.2 为什么需要 TFLite？

将机器学习模型部署到设备端（On-device inference）具有诸多优势：

低延迟： 推理计算直接在设备本地完成，无需网络往返，响应速度更快，特别适合需要实时处理的应用，如图像识别、语音命令。
保护用户隐私： 用户数据在设备上进行处理，不会上传到云端，提高了数据隐私和安全性。
离线可用： 即使没有网络连接，模型也能正常工作。
降低服务器成本： 将计算转移到设备端，可以减少对云端计算资源的依赖，从而降低运营成本。
降低功耗： TFLite 经过优化，可以在资源有限的设备上高效运行，消耗更少的电量。

1.3 TFLite 的核心组件

TFLite 主要包含以下核心组件：

TFLite Converter (转换器): 将标准的 TensorFlow 模型（如 SavedModel、Keras 模型）转换为 TFLite 特有的 .tflite 格式。.tflite 文件是经过优化、适用于移动和嵌入式设备的模型表示。
TFLite Interpreter (解释器): 在目标设备上加载并运行 .tflite 模型。它负责执行模型中的操作。
TFLite Delegates (代理/委托): 利用设备上的硬件加速器（如 GPU、DSP、NPU 或专用的神经计算引擎）来加速模型的推理过程。Delegates 允许 TFLite 将部分或全部操作 offload 到这些硬件上执行，以提高性能和能效。常见的 Delegate 包括 Android NNAPI、GPU Delegate、Hexagon Delegate、Edge TPU Delegate 等。

第二章：TFLite 工作流程总览

使用 TFLite 将模型部署到设备上的典型工作流程如下：

准备 TensorFlow 模型: 您可以训练自己的 TensorFlow 模型，或者使用预训练的开源模型。模型可以是 Keras 模型或 SavedModel 格式。
将模型转换为 .tflite 格式: 使用 TFLite Converter 将 TensorFlow 模型转换为 .tflite 文件。在此步骤中，您可以选择不同的优化技术，例如量化，以减小模型大小并提高运行速度。
优化 .tflite 模型 (可选但推荐): 量化是常用的优化手段，可以将模型权重和激活值从浮点数转换为较低精度的整数（如 8-bit 整型），从而显著减小模型大小并加速推理。还可以应用剪枝、聚类等技术。
部署到目标设备: 将生成的 .tflite 文件集成到您的移动（Android/iOS）、嵌入式（Linux、Raspberry Pi 等）或微控制器应用中。
创建 Interpreter 并运行推理: 在设备代码中，加载 .tflite 模型，创建 TFLite Interpreter，准备输入数据，运行推理，然后处理模型的输出结果。在这一步，您可以配置使用合适的 Hardware Delegate 来加速计算。

第三章：模型转换 (.tflite)

模型转换是 TFLite 工作流程中的关键一步。您可以使用 Python API (tf.lite.TFLiteConverter) 在开发环境中完成转换。

Converter 可以从以下几种 TensorFlow 模型格式加载模型：

TensorFlow SavedModel: 推荐的转换格式，包含了完整的 TensorFlow 图和变量。
tf.keras 模型: 可以直接从 tf.keras.Model 对象转换。
Concrete Functions: 从 tf.function 生成的具体函数。

3.1 使用 Python API 进行转换

首先，确保您安装了 TensorFlow 1.x 或 2.x（推荐使用 TensorFlow 2.x）。

bash pip install tensorflow

以下是使用 tf.lite.TFLiteConverter 进行模型转换的常见方法示例：

示例 1：从 Keras 模型转换

“`python
import tensorflow as tf

假设您已经有了一个训练好的 Keras 模型

例如：model = tf.keras.applications.MobileNetV2(weights=’imagenet’)

或者您训练的自定义模型

model = tf.keras.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation=’relu’),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10)
])

model.compile(…) # 如果需要训练

model.fit(…) # 如果需要训练

创建 TFLite Converter 实例

converter = tf.lite.TFLiteConverter.from_keras_model(model)

执行转换

tflite_model = converter.convert()

将转换后的模型保存到文件

with open(‘model.tflite’, ‘wb’) as f:
f.write(tflite_model)

print(“Keras 模型已成功转换为 model.tflite”)
“`

示例 2：从 SavedModel 转换

“`python
import tensorflow as tf

假设您有一个 SavedModel 保存路径

saved_model_dir = ‘/path/to/your/saved_model’ # 替换为您的 SavedModel 路径

创建 TFLite Converter 实例

converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)

执行转换

tflite_model = converter.convert()

将转换后的模型保存到文件

with open(‘saved_model.tflite’, ‘wb’) as f:
f.write(tflite_model)

print(“SavedModel 已成功转换为 saved_model.tflite”)
“`

示例 3：从 Concrete Function 转换

这适用于需要更精细控制转换哪些函数的情况。

“`python
import tensorflow as tf

定义一个 TensorFlow 函数

@tf.function(input_signature=[tf.TensorSpec(shape=[None, 28, 28, 1], dtype=tf.float32)])
def simple_model(x):
return tf.nn.softmax(tf.keras.layers.Dense(10)(tf.keras.layers.Flatten()(x)))

获取 Concrete Function

concrete_func = simple_model.get_concrete_function()

创建 TFLite Converter 实例

converter = tf.lite.TFLiteConverter.from_concrete_functions([concrete_func])

执行转换

tflite_model = converter.convert()

将转换后的模型保存到文件

with open(‘concrete_func_model.tflite’, ‘wb’) as f:
f.write(tflite_model)

print(“Concrete Function 已成功转换为 concrete_func_model.tflite”)
“`

3.2 设置优化选项

在转换过程中，您可以设置优化选项 (converter.optimizations) 来减小模型大小并提高推理速度。最常用的优化是量化。

默认优化: 不进行量化，模型保持浮点精度 (float32)。
动态范围量化 (Dynamic Range Quantization): 最简单的量化形式，只量化权重到 8-bit 整数，而激活值在运行时动态量化/反量化。这是减少模型大小和启用某些整数优化的简单方法，对准确率影响较小。

python converter.optimizations = [tf.lite.Optimize.DEFAULT] # 默认也是动态范围量化
Float16 量化: 将模型权重从 float32 转换为 float16。模型大小减半，对准确率影响很小，在支持 float16 计算的硬件上可以加速。

python converter.optimizations = [tf.lite.Optimize.DEFAULT] converter.target_spec.supported_types = [tf.float16]
整型量化 (Full Integer Quantization): 将模型的所有权重和激活值都量化到 8-bit 整型。这是提供最小模型大小和最快推理速度（尤其是在支持整数运算的硬件上）的方式。但它需要一个代表性的数据集进行校准，以确定浮点值到整数的映射范围，对模型准确率的影响最大。

“`python

需要一个代表性数据集用于校准

def representative_dataset_gen():
for _ in range(100): # 迭代少量样本即可
# 根据您的模型输入形状和类型生成代表性输入数据
data = np.random.rand(1, 28, 28, 1).astype(np.float32) # 示例输入形状和类型
yield [data] # converter 需要一个迭代器，每次yield一个包含输入张量的列表

converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset_gen

确保输入输出也是整数类型，以获得端到端的整数推理

converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8 # 或者 tf.uint8
converter.inference_output_type = tf.int8 # 或者 tf.uint8
“`
注意： 整型量化对数据集的选择和校准过程有一定的要求，请参考官方文档以获取更详细的指导。

选择哪种优化取决于您的具体需求：对模型大小和速度要求不高，优先保证准确率 -> 动态范围量化或 Float16 量化；对模型大小和速度要求极高，可以容忍轻微准确率损失 -> 整型量化。

第四章：模型优化详解 (量化)

量化是将模型权重和/或激活值从浮点数（如 32-bit float）转换为低精度数字（如 8-bit 整数）的过程。这是 TFLite 中最重要的优化技术，因为它：

显著减小模型大小： 例如，将 float32 转换为 int8 可以将模型大小减少 75%。
提高推理速度： 许多硬件平台（特别是移动和嵌入式设备）对整数运算的支持更好、更快、更节能。
降低内存带宽需求： 传输更少的数据可以减少内存访问延迟和功耗。

4.1 量化的类型回顾

训练后量化 (Post-training Quantization): 在模型训练完成后进行量化。这是最简单、常用的方式。
- 动态范围量化: 只量化权重。
- 全整型量化: 量化权重和激活值，需要校准数据集。
- Float16 量化: 量化到半精度浮点数。
量化感知训练 (Quantization Aware Training – QAT): 在训练过程中模拟量化误差，使得模型在训练结束时已经对量化“感知”。这种方法通常能获得比训练后全整型量化更高的准确率，但需要修改训练代码。如果您对量化后准确率不满意，可以考虑 QAT。

对于入门，建议先尝试训练后动态范围量化或全整型量化。

第五章：在设备上运行推理

一旦您有了 .tflite 文件，下一步就是将其集成到您的应用程序中并在目标设备上运行推理。TFLite 提供了适用于多种平台的 API。

5.1 Android 平台集成

在 Android Studio 中，通常使用 TFLite 的 Java/Kotlin API。

添加依赖: 在您的 app/build.gradle 文件中添加 TFLite 库依赖。

gradle dependencies { // 如果使用预训练模型，包含内置 ops 和 select ops implementation 'org.tensorflow:tensorflow-lite:2.x.x' implementation 'org.tensorflow:tensorflow-lite-support:0.x.x' // TFLite Support Library，简化常见任务 implementation 'org.tensorflow:tensorflow-lite-gpu:2.x.x' // GPU Delegate (可选) // 根据需要添加其他 Delegate，如 NNAPI: // implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:2.x.x' // 如果模型使用了 TensorFlow ops }
请将 2.x.x 和 0.x.x 替换为最新的 TFLite 版本号。
将 .tflite 模型文件添加到 assets 目录: 在 app/src/main 目录下创建 assets 文件夹，并将 .tflite 文件复制进去。
加载模型并创建 Interpreter: 在您的 Activity 或 Fragment 中加载模型并创建 Interpreter 实例。

“`java
import org.tensorflow.lite.Interpreter;
import org.tensorflow.lite.Interpreter.Options;
import org.tensorflow.lite.gpu.GpuDelegate;

// … 在需要的地方 …

private Interpreter tfliteInterpreter;
private GpuDelegate gpuDelegate = null; // 用于 GPU 加速

private void loadModel() {
try {
// 加载模型文件
ByteBuffer modelBuffer = loadModelFile(this, “your_model.tflite”); // 替换为您的文件名
```
    // 配置 Interpreter 选项
    Options options = new Options();
    options.setNumThreads(4); // 设置线程数

    // 添加 Delegate (可选，根据需要)
    if (/* 检查设备是否支持 GPU */ true) { // 实际中需要更复杂的检查
         gpuDelegate = new GpuDelegate();
         options.addDelegate(gpuDelegate);
    }
    // 可以根据需要添加 NNAPI delegate: options.setUseNNAPI(true);

    // 创建 Interpreter 实例
    tfliteInterpreter = new Interpreter(modelBuffer, options);

    // 获取模型的输入/输出张量信息
    // 例如：获取第一个输入张量的形状和类型
    int[] inputShape = tfliteInterpreter.getInputTensor(0).shape();
    DataType inputType = tfliteInterpreter.getInputTensor(0).dataType();
    // 类似地获取输出张量信息...

} catch (IOException e) {
    e.printStackTrace();
    // 处理加载模型失败的情况
}
```
}

// 辅助方法：从 assets 目录加载模型文件到 ByteBuffer
private MappedByteBuffer loadModelFile(Activity activity, String modelPath) throws IOException {
AssetFileDescriptor fileDescriptor = activity.getAssets().openFd(modelPath);
FileInputStream inputStream = new FileInputStream(fileDescriptor.getFileDescriptor());
FileChannel fileChannel = inputStream.getChannel();
long startOffset = fileDescriptor.getStartOffset();
long declaredLength = fileDescriptor.getDeclaredLength();
return fileChannel.map(FileChannel.MapMode.READ_ONLY, startOffset, declaredLength);
}

// … 在不再需要 Interpreter 时释放资源 …
private void closeInterpreter() {
if (tfliteInterpreter != null) {
tfliteInterpreter.close();
tfliteInterpreter = null;
}
if (gpuDelegate != null) {
gpuDelegate.close();
gpuDelegate = null;
}
}
“`
准备输入数据: 将您的输入数据（如图像像素、传感器读数）转换为 TFLite Interpreter 期望的输入张量格式 (通常是 ByteBuffer 或多维数组)。请注意数据类型（float32, int8, uint8 等）和形状需要与模型定义一致。
运行推理: 使用 Interpreter 的 run() 方法执行推理。

“`java
// 假设输入是 float32 的二维数组
float[][] inputData = … ; // 准备您的输入数据

// 假设输出是 float32 的二维数组
float[][] outputData = new float[1][numOutputClasses]; // 根据模型输出形状定义

if (tfliteInterpreter != null) {
// 运行推理
tfliteInterpreter.run(inputData, outputData);
```
// 处理输出结果 outputData...
```
}
`` 如果模型有多个输入或输出，使用runForMultipleInputsOutputs()方法，它接受Object[]作为输入和Map` 作为输出。
处理输出结果: 从输出张量中获取推理结果，并根据您的应用逻辑进行处理（如解析分类结果、绘制检测框等）。

5.2 iOS 平台集成

在 iOS 应用中，通常使用 TFLite 的 Swift 或 Objective-C API。

安装 TFLite 库: 使用 CocoaPods 或 Carthage 安装 TensorFlowLiteSwift 或 TensorFlowLiteObjC。

使用 CocoaPods (推荐): 在您的 Podfile 中添加：

ruby target 'YourAppTarget' do use_frameworks! pod 'TensorFlowLiteSwift' # 如果需要 GPU delegate pod 'TensorFlowLiteGpuDelegate' # 如果需要其他 delegate 或 select ops # pod 'TensorFlowLiteMetalDelegate' # Metal Delegate for GPU # pod 'TensorFlowLiteSelectTfOps' end
然后运行 pod install。
将 .tflite 模型文件添加到项目中: 将 .tflite 文件拖拽到您的 Xcode 项目中，并确保在“Copy Bundle Resources”阶段被包含。

加载模型并创建 Interpreter (Swift):

“`swift
import TensorFlowLite
import TensorFlowLiteGpuDelegate // 如果使用 GPU Delegate

// … 在需要的地方 …

private var interpreter: Interpreter?

private func loadModel() {
// 获取模型文件路径
guard let modelPath = Bundle.main.path(forResource: “your_model”, ofType: “tflite”) else {
print(“Failed to find the model file.”)
return
}

// 配置 Delegate (可选)
var delegates: [Delegate]? = nil
// 检查设备是否支持 GPU，并创建 GPU Delegate
if /* check if device supports GPU */ true { // 实际中需要更复杂的检查
     delegates = [GpuDelegate()]
}
// 也可以添加 Core ML Delegate: delegates = [CoreMLDelegate()]

// 创建 Interpreter
do {
    interpreter = try Interpreter(modelPath: modelPath, delegates: delegates)
    try interpreter?.allocateTensors() // 分配张量所需的内存

    // 获取模型的输入/输出张量信息
    // 例如：获取第一个输入张量
    if let inputTensor = try interpreter?.input(at: 0) {
        print("Input shape: \(inputTensor.shape)")
        print("Input type: \(inputTensor.dataType)")
    }
    // 类似地获取输出张量信息...

} catch let error {
    print("Failed to create interpreter: \(error.localizedDescription)")
}

}

// … 在 View Controller 或其他地方调用 loadModel()…

// … 在不再需要 Interpreter 时，让对象 deinit 自动释放资源 …
“`

准备输入数据: 将您的输入数据转换为 Tensor 对象或 Data 缓冲区，注意数据类型和形状。
运行推理: 使用 Interpreter 的 invoke() 方法运行推理。

“`swift
// 假设输入数据是 Data 格式，类型是 float32
let inputData: Data = … // 准备您的输入数据

do {
// 复制输入数据到输入张量
try interpreter?.copy(inputData, toInputAt: 0)
```
// 运行推理
try interpreter?.invoke()

// 获取输出张量
if let outputTensor = try interpreter?.output(at: 0) {
    // 将输出张量复制到 Data
    let outputData = outputTensor.data

    // 处理输出结果 outputData...
}
```
} catch let error {
print(“Failed to invoke interpreter: (error.localizedDescription)”)
}
“`
处理输出结果: 从输出张量中获取推理结果并进行处理。

5.3 Linux / IoT 平台集成

在 Linux 或其他嵌入式系统上，您可以使用 TFLite 的 C++ 或 Python API。Python API 与转换模型时使用的 API 类似。

使用 Python API:

“`python
import numpy as np
import tensorflow as tf

Load the TFLite model

interpreter = tf.lite.Interpreter(model_path=”your_model.tflite”)

Allocate tensors

interpreter.allocate_tensors()

Get input and output tensors.

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

Test the model on random input data.

input_shape = input_details[0][‘shape’]
input_data = np.array(np.random.random_sample(input_shape), dtype=np.float32) # 根据模型输入类型调整 dtype

Prepare input data

interpreter.set_tensor(input_details[0][‘index’], input_data)

Run inference

interpreter.invoke()

Get output data

output_data = interpreter.get_tensor(output_details[0][‘index’])

print(“Input shape:”, input_details[0][‘shape’])
print(“Output shape:”, output_details[0][‘shape’])
print(“Input dtype:”, input_details[0][‘dtype’])
print(“Output dtype:”, output_details[0][‘dtype’])
print(“Output data:”, output_data)

对于多个输入/输出，循环处理 input_details/output_details

“`

使用 C++ API: C++ API 提供了更高的灵活性和性能，但集成相对复杂一些，需要编译 TFLite 库。基本步骤包括加载模型 (FlatBufferModel::BuildFromFile), 创建 Interpreter (InterpreterBuilder), 分配张量 (interpreter->AllocateTensors()), 准备输入数据 (interpreter->typed_input_tensor<T>(index)), 运行推理 (interpreter->Invoke())，获取输出数据 (interpreter->typed_output_tensor<T>(index)). 详细请参考 TFLite C++ 官方文档。

5.4 使用 TFLite Task Library (推荐简化开发)

对于常见的机器学习任务（如图像分类、目标检测、文本分类），TensorFlow Lite 提供了 Task Library。Task Library 建立在核心 Interpreter API 之上，提供了开箱即用的、高度优化的模型接口，可以大大简化模型在应用中的集成代码。

例如，使用 Image Classifier Task Library 进行图像分类，代码可以非常简洁：

Android (Kotlin):

“`kotlin
import org.tensorflow.lite.support.image.TensorImage
import org.tensorflow.lite.task.vision.classifier.ImageClassifier
import org.tensorflow.lite.task.vision.classifier.ImageClassifier.ImageClassifierOptions

// … 在需要的地方 …

var imageClassifier: ImageClassifier? = null

fun setupClassifier() {
val options = ImageClassifierOptions.builder()
.setMaxResults(3) // 获取 top 3 结果
.setNumThreads(4)
.build()

try {
    imageClassifier = ImageClassifier.createFromFileAndOptions(context, "your_image_classifier.tflite", options)
} catch (e: Exception) {
    e.printStackTrace()
    // 处理错误
}

}

fun classifyImage(bitmap: Bitmap) {
if (imageClassifier != null) {
val tensorImage = TensorImage.fromBitmap(bitmap)
val results = imageClassifier?.classify(tensorImage)

    // 处理分类结果 results...
    results?.forEach { classification ->
        classification.categories.forEach { category ->
            println("Category: ${category.label}, Score: ${category.score}")
        }
    }
}

}

// … 在不再需要时释放资源
fun closeClassifier() {
imageClassifier?.close()
imageClassifier = null
}
“`

Task Library 支持的常见任务包括：图像分类、目标检测、图像分割、姿态估计、文本分类、 Bert 问答等。如果您的任务属于其中之一，强烈建议使用 Task Library。

第六章：Delegate (硬件加速)

Delegate 是 TFLite 提高推理速度的关键。它允许 TFLite 将部分或全部模型操作交给设备上更专业的硬件执行，而不是仅依赖 CPU。

Android NNAPI Delegate: 利用 Android 设备的神经计算 API (NNAPI)。适用于 Android 8.1 (API 27) 及更高版本。NNAPI 可以调度计算到设备上的 CPU、GPU 或专用 AI 芯片 (NPU)。
GPU Delegate: 利用设备的图形处理器 (GPU) 进行计算。支持 Android (OpenGL/Vulkan) 和 iOS (Metal)。对于图像相关的模型（如 CNN），GPU 通常能提供显著的加速。
Hexagon Delegate: 利用高通 Hexagon DSP (数字信号处理器)。
Edge TPU Delegate: 专为 Google Edge TPU 加速器设计。
XNNPACK Delegate: 一个高度优化的 CPU 浮点运算库，通常作为 TFLite 的默认 CPU 后端。

在设备上使用 Delegate 通常只需要在创建 Interpreter 时配置 Options 或 Delegate 对象即可，如前面 Android 和 iOS 示例所示。选择合适的 Delegate 取决于您的目标硬件和模型类型。

第七章：常见问题与故障排除

Unsupported operations (不受支持的操作): 如果您的模型使用了 TFLite 内置操作集中没有的操作，转换或推理时会报错。解决方法通常是修改原始模型以使用 TFLite 支持的操作，或者为自定义操作实现 TFLite Delegate。
Input/Output tensor shape or type mismatch: 确保您在设备端准备的输入数据形状和类型与 .tflite 模型期望的完全一致。特别注意量化模型的输入/输出类型可能是 int8/uint8。
Performance issues: 如果推理速度不达预期，尝试以下方法：
- 使用更强的量化（如全整型量化）。
- 启用并正确配置 Hardware Delegate (GPU, NNAPI 等)。
- 优化模型结构（使用 MobileNet、EfficientNet 等轻量级模型）。
- 调整 Interpreter 的线程数。
Accuracy drop after quantization: 全整型量化可能会导致模型准确率下降。可以尝试动态范围量化、Float16 量化，或者更复杂的量化感知训练 (QAT)。检查您的校准数据集是否具有代表性。

第八章：总结与展望

TensorFlow Lite 为在移动和边缘设备上部署机器学习模型提供了强大的解决方案。通过模型转换、优化（特别是量化）和灵活的 Delegate 机制，TFLite 使得在资源有限的环境中实现低延迟、高隐私和离线可用的智能应用成为可能。

本文带您了解了 TFLite 的基本概念、标准工作流程、详细的模型转换步骤及优化选项，以及在 Android、iOS 和 Linux 平台上的基本集成方法。Task Library 进一步简化了常见任务的开发。

入门 TFLite 的最好方式是动手实践。从一个简单的预训练模型开始（如图像分类模型），尝试将其转换为 .tflite 文件，然后集成到您的移动应用中，并尝试使用 Delegate 进行加速。随着您对 TFLite 的理解加深，您可以探索更高级的主题，如自定义操作、量化感知训练、更专业的 Delegate 集成以及 TFLite Micro 等。

重要资源:

TensorFlow Lite 官方文档: https://www.tensorflow.org/lite/ (强烈建议查阅最新、最详细的官方资料)
TensorFlow Lite 示例项目: https://github.com/tensorflow/examples (提供了各种平台和任务的示例代码)

TensorFlow Lite (TFLite) 入门指南：将智能部署到移动及边缘设备

第一章：初识 TensorFlow Lite (TFLite)

1.1 什么是 TensorFlow Lite？

1.2 为什么需要 TFLite？

1.3 TFLite 的核心组件

第二章：TFLite 工作流程总览

第三章：模型转换 (.tflite)

3.1 使用 Python API 进行转换

假设您已经有了一个训练好的 Keras 模型

例如：model = tf.keras.applications.MobileNetV2(weights=’imagenet’)

或者您训练的自定义模型

model.compile(…) # 如果需要训练

model.fit(…) # 如果需要训练

创建 TFLite Converter 实例

执行转换

将转换后的模型保存到文件

假设您有一个 SavedModel 保存路径

创建 TFLite Converter 实例

执行转换

将转换后的模型保存到文件

定义一个 TensorFlow 函数

获取 Concrete Function

创建 TFLite Converter 实例

执行转换

将转换后的模型保存到文件

3.2 设置优化选项

需要一个代表性数据集用于校准

确保输入输出也是整数类型，以获得端到端的整数推理

第四章：模型优化详解 (量化)

4.1 量化的类型回顾

第五章：在设备上运行推理

5.1 Android 平台集成

5.2 iOS 平台集成

5.3 Linux / IoT 平台集成

Load the TFLite model

Allocate tensors

Get input and output tensors.

Test the model on random input data.

Prepare input data

Run inference

Get output data

对于多个输入/输出，循环处理 input_details/output_details

5.4 使用 TFLite Task Library (推荐简化开发)

第六章：Delegate (硬件加速)

第七章：常见问题与故障排除

第八章：总结与展望

发表评论 取消回复

发表评论取消回复