TensorFlow Lite 推理

术语推理是指在设备上执行 TensorFlow Lite 模型以根据输入数据进行预测的过程。要使用 TensorFlow Lite 模型执行推理，您必须通过解释器运行它。TensorFlow Lite 解释器旨在精简且快速。解释器使用静态图排序和自定义（不太动态）内存分配器，以确保最小的负载、初始化和执行延迟。

本页面介绍如何访问 TensorFlow Lite 解释器并使用 C++、Java 和 Python 执行推理，以及指向每个支持平台的其他资源的链接。

重要概念

TensorFlow Lite 推理通常遵循以下步骤

  1. 加载模型

    您必须将.tflite模型加载到内存中，其中包含模型的执行图。

  2. 转换数据

    模型的原始输入数据通常与模型期望的输入数据格式不匹配。例如，您可能需要调整图像大小或更改图像格式以与模型兼容。

  3. 运行推理

    此步骤涉及使用 TensorFlow Lite API 执行模型。它涉及一些步骤，例如构建解释器和分配张量，如以下部分所述。

  4. 解释输出

    当您从模型推理中收到结果时，您必须以对您的应用程序有意义的方式解释张量。

    例如，模型可能只返回概率列表。由您将概率映射到相关类别并将其呈现给您的最终用户。

支持的平台

TensorFlow 推理 API 提供了针对大多数常见的移动/嵌入式平台，例如Android、iOS和Linux，以多种编程语言提供。

在大多数情况下，API 设计反映了对性能而不是易用性的偏好。TensorFlow Lite 旨在为小型设备提供快速推理，因此 API 试图避免不必要的复制，即使这会牺牲便利性，也不足为奇。同样，与 TensorFlow API 的一致性也不是明确的目标，因此语言之间存在一些差异是可以预期的。

在所有库中，TensorFlow Lite API 使您能够加载模型、馈送输入和检索推理输出。

Android 平台

在 Android 上，TensorFlow Lite 推理可以使用 Java 或 C++ API 执行。Java API 提供便利，可以直接在您的 Android Activity 类中使用。C++ API 提供了更大的灵活性和速度，但可能需要编写 JNI 包装器以在 Java 和 C++ 层之间移动数据。

有关使用C++和Java的详细信息，请参见下文，或按照Android 快速入门了解教程和示例代码。

TensorFlow Lite Android 包装器代码生成器

对于使用元数据增强的 TensorFlow Lite 模型，开发人员可以使用 TensorFlow Lite Android 包装器代码生成器来创建特定于平台的包装器代码。包装器代码消除了在 Android 上直接与ByteBuffer交互的需要。相反，开发人员可以使用类型化对象（例如Bitmap和Rect）与 TensorFlow Lite 模型交互。有关更多信息，请参阅TensorFlow Lite Android 包装器代码生成器。

iOS 平台

在 iOS 上，TensorFlow Lite 可与使用Swift和Objective-C编写的原生 iOS 库一起使用。您也可以直接在 Objective-C 代码中使用C API。

有关使用Swift、Objective-C和C API的详细信息，请参见下文，或按照iOS 快速入门了解教程和示例代码。

Linux 平台

在 Linux 平台（包括 树莓派）上，您可以使用 TensorFlow Lite API 在 C++ 和 Python 中运行推理，如下节所示。

运行模型

运行 TensorFlow Lite 模型涉及几个简单的步骤

  1. 将模型加载到内存中。
  2. 基于现有模型构建一个 Interpreter。
  3. 设置输入张量值。（如果不需要预定义大小，可以选择调整输入张量大小。）
  4. 调用推理。
  5. 读取输出张量值。

以下部分描述了如何在每种语言中完成这些步骤。

在 Java 中加载和运行模型

平台：Android

用于使用 TensorFlow Lite 运行推理的 Java API 主要设计用于与 Android 一起使用，因此它作为 Android 库依赖项提供：org.tensorflow:tensorflow-lite。

在 Java 中，您将使用 Interpreter 类来加载模型并驱动模型推理。在许多情况下，这可能是您唯一需要的 API。

您可以使用 .tflite 文件初始化 Interpreter

public Interpreter(@NotNull File modelFile);

或者使用 MappedByteBuffer

public Interpreter(@NotNull MappedByteBuffer mappedByteBuffer);

在这两种情况下，您都必须提供有效的 TensorFlow Lite 模型，否则 API 将抛出 IllegalArgumentException。如果您使用 MappedByteBuffer 初始化 Interpreter，它必须在 Interpreter 的整个生命周期内保持不变。

在模型上运行推理的首选方法是使用签名 - 可用于从 Tensorflow 2.5 开始转换的模型

try (Interpreter interpreter = new Interpreter(file_of_tensorflowlite_model)) {
  Map<String, Object> inputs = new HashMap<>();
  inputs.put("input_1", input1);
  inputs.put("input_2", input2);
  Map<String, Object> outputs = new HashMap<>();
  outputs.put("output_1", output1);
  interpreter.runSignature(inputs, outputs, "mySignature");
}

runSignature 方法接受三个参数

  • 输入：从签名中的输入名称到输入对象的输入映射。

  • 输出：从签名中的输出名称到输出数据的输出映射。

  • 签名名称 [可选]：签名名称（如果模型只有一个签名，可以留空）。

当模型没有定义签名时，另一种运行推理的方法。只需调用 Interpreter.run()。例如

try (Interpreter interpreter = new Interpreter(file_of_a_tensorflowlite_model)) {
  interpreter.run(input, output);
}

run() 方法只接受一个输入并返回一个输出。因此，如果您的模型有多个输入或多个输出，请改用

interpreter.runForMultipleInputsOutputs(inputs, map_of_indices_to_outputs);

在这种情况下，inputs 中的每个条目对应于一个输入张量，而 map_of_indices_to_outputs 将输出张量的索引映射到相应的输出数据。

在这两种情况下，张量索引都应与您在创建模型时提供给 TensorFlow Lite 转换器 的值相对应。请注意，input 中张量的顺序必须与提供给 TensorFlow Lite 转换器的顺序匹配。

Interpreter 类还提供方便的函数，供您使用操作名称获取任何模型输入或输出的索引

public int getInputIndex(String opName);
public int getOutputIndex(String opName);

如果 opName 不是模型中的有效操作，它将抛出 IllegalArgumentException。

还要注意，Interpreter 拥有资源。为了避免内存泄漏，必须在使用后通过以下方式释放资源

interpreter.close();

有关使用 Java 的示例项目，请参阅 Android 图像分类示例。

支持的数据类型（在 Java 中）

要使用 TensorFlow Lite，输入和输出张量的数据类型必须是以下基本类型之一

  • float
  • int
  • long
  • byte

String 类型也受支持，但它们的编码方式与基本类型不同。特别是，字符串张量的形状决定了张量中字符串的数量和排列，每个元素本身都是一个可变长度字符串。从这个意义上说，张量的（字节）大小不能仅从形状和类型计算出来，因此字符串不能作为单个扁平的 ByteBuffer 参数提供。您可以在此 页面 中看到一些示例。

如果使用其他数据类型，包括装箱类型，如 Integer 和 Float，将抛出 IllegalArgumentException。

输入

每个输入都应该是支持的基本类型的数组或多维数组，或者是一个适当大小的原始 ByteBuffer。如果输入是数组或多维数组，则关联的输入张量将在推理时隐式调整为数组的维度。如果输入是 ByteBuffer，则调用者应首先手动调整关联的输入张量的大小（通过 Interpreter.resizeInput()），然后再运行推理。

当使用 ByteBuffer 时，建议使用直接字节缓冲区，因为这允许 Interpreter 避免不必要的复制。如果 ByteBuffer 是直接字节缓冲区，则其顺序必须为 ByteOrder.nativeOrder()。在它用于模型推理后，它必须保持不变，直到模型推理完成。

输出

每个输出都应该是支持的基本类型的数组或多维数组，或者是一个适当大小的 ByteBuffer。请注意，某些模型具有动态输出，其中输出张量的形状可能会根据输入而变化。使用现有的 Java 推理 API 没有直接处理此问题的方法，但计划的扩展将使这成为可能。

在 Swift 中加载和运行模型

平台：iOS

Swift API 在 Cocoapods 的 TensorFlowLiteSwift Pod 中可用。

首先，您需要导入 TensorFlowLite 模块。

import TensorFlowLite

// Getting model path
guard
  let modelPath = Bundle.main.path(forResource: "model", ofType: "tflite")
else {
  // Error handling...
}

do {
  // Initialize an interpreter with the model.
  let interpreter = try Interpreter(modelPath: modelPath)

  // Allocate memory for the model's input `Tensor`s.
  try interpreter.allocateTensors()

  let inputData: Data  // Should be initialized

  // input data preparation...

  // Copy the input data to the input `Tensor`.
  try self.interpreter.copy(inputData, toInputAt: 0)

  // Run inference by invoking the `Interpreter`.
  try self.interpreter.invoke()

  // Get the output `Tensor`
  let outputTensor = try self.interpreter.output(at: 0)

  // Copy output to `Data` to process the inference results.
  let outputSize = outputTensor.shape.dimensions.reduce(1, {x, y in x * y})
  let outputData =
        UnsafeMutableBufferPointer<Float32>.allocate(capacity: outputSize)
  outputTensor.data.copyBytes(to: outputData)

  if (error != nil) { /* Error handling... */ }
} catch error {
  // Error handling...
}

在 Objective-C 中加载和运行模型

平台：iOS

Objective-C API 在 Cocoapods 的 TensorFlowLiteObjC Pod 中可用。

首先，您需要导入 TensorFlowLite 模块。

@import TensorFlowLite;

NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                      ofType:@"tflite"];
NSError *error;

// Initialize an interpreter with the model.
TFLInterpreter *interpreter = [[TFLInterpreter alloc] initWithModelPath:modelPath
                                                                  error:&error];
if (error != nil) { /* Error handling... */ }

// Allocate memory for the model's input `TFLTensor`s.
[interpreter allocateTensorsWithError:&error];
if (error != nil) { /* Error handling... */ }

NSMutableData *inputData;  // Should be initialized
// input data preparation...

// Get the input `TFLTensor`
TFLTensor *inputTensor = [interpreter inputTensorAtIndex:0 error:&error];
if (error != nil) { /* Error handling... */ }

// Copy the input data to the input `TFLTensor`.
[inputTensor copyData:inputData error:&error];
if (error != nil) { /* Error handling... */ }

// Run inference by invoking the `TFLInterpreter`.
[interpreter invokeWithError:&error];
if (error != nil) { /* Error handling... */ }

// Get the output `TFLTensor`
TFLTensor *outputTensor = [interpreter outputTensorAtIndex:0 error:&error];
if (error != nil) { /* Error handling... */ }

// Copy output to `NSData` to process the inference results.
NSData *outputData = [outputTensor dataWithError:&error];
if (error != nil) { /* Error handling... */ }

在 Objective-C 代码中使用 C API

目前 Objective-C API 不支持委托。为了在 Objective-C 代码中使用委托，您需要直接调用底层的 C API。

#include "tensorflow/lite/c/c_api.h"

TfLiteModel* model = TfLiteModelCreateFromFile([modelPath UTF8String]);
TfLiteInterpreterOptions* options = TfLiteInterpreterOptionsCreate();

// Create the interpreter.
TfLiteInterpreter* interpreter = TfLiteInterpreterCreate(model, options);

// Allocate tensors and populate the input tensor data.
TfLiteInterpreterAllocateTensors(interpreter);
TfLiteTensor* input_tensor =
    TfLiteInterpreterGetInputTensor(interpreter, 0);
TfLiteTensorCopyFromBuffer(input_tensor, input.data(),
                           input.size() * sizeof(float));

// Execute inference.
TfLiteInterpreterInvoke(interpreter);

// Extract the output tensor data.
const TfLiteTensor* output_tensor =
    TfLiteInterpreterGetOutputTensor(interpreter, 0);
TfLiteTensorCopyToBuffer(output_tensor, output.data(),
                         output.size() * sizeof(float));

// Dispose of the model and interpreter objects.
TfLiteInterpreterDelete(interpreter);
TfLiteInterpreterOptionsDelete(options);
TfLiteModelDelete(model);

在 C++ 中加载和运行模型

平台：Android、iOS 和 Linux

在 C++ 中，模型存储在 FlatBufferModel 类中。它封装了 TensorFlow Lite 模型，您可以通过几种不同的方式构建它，具体取决于模型的存储位置

class FlatBufferModel {
  // Build a model based on a file. Return a nullptr in case of failure.
  static std::unique_ptr<FlatBufferModel> BuildFromFile(
      const char* filename,
      ErrorReporter* error_reporter);

  // Build a model based on a pre-loaded flatbuffer. The caller retains
  // ownership of the buffer and should keep it alive until the returned object
  // is destroyed. Return a nullptr in case of failure.
  static std::unique_ptr<FlatBufferModel> BuildFromBuffer(
      const char* buffer,
      size_t buffer_size,
      ErrorReporter* error_reporter);
};

现在您已经将模型作为 FlatBufferModel 对象，您可以使用 Interpreter 执行它。单个 FlatBufferModel 可以被多个 Interpreter 同时使用。

Interpreter API 的重要部分在下面的代码片段中显示。需要注意的是

  • 张量用整数表示，以避免字符串比较（以及对字符串库的任何固定依赖）。
  • 解释器不能从并发线程访问。
  • 输入和输出张量的内存分配必须通过在调整张量大小后立即调用 AllocateTensors() 来触发。

使用 C++ 的 TensorFlow Lite 的最简单用法如下所示

// Load the model
std::unique_ptr<tflite::FlatBufferModel> model =
    tflite::FlatBufferModel::BuildFromFile(filename);

// Build the interpreter
tflite::ops::builtin::BuiltinOpResolver resolver;
std::unique_ptr<tflite::Interpreter> interpreter;
tflite::InterpreterBuilder(*model, resolver)(&interpreter);

// Resize input tensors, if desired.
interpreter->AllocateTensors();

float* input = interpreter->typed_input_tensor<float>(0);
// Fill `input`.

interpreter->Invoke();

float* output = interpreter->typed_output_tensor<float>(0);

有关更多示例代码，请参阅 minimal.cc 和 label_image.cc。

在 Python 中加载和运行模型

平台：Linux

用于运行推理的 Python API 在 tf.lite 模块中提供。从中，您主要只需要 tf.lite.Interpreter 来加载模型并运行推理。

以下示例展示了如何使用 Python 解释器加载 .tflite 文件并使用随机输入数据运行推理

如果您是从具有定义的 SignatureDef 的 SavedModel 转换而来，建议使用此示例。从 TensorFlow 2.5 开始可用

class TestModel(tf.Module):
  def __init__(self):
    super(TestModel, self).__init__()

  @tf.function(input_signature=[tf.TensorSpec(shape=[1, 10], dtype=tf.float32)])
  def add(self, x):
    '''
    Simple method that accepts single input 'x' and returns 'x' + 4.
    '''
    # Name the output 'result' for convenience.
    return {'result' : x + 4}


SAVED_MODEL_PATH = 'content/saved_models/test_variable'
TFLITE_FILE_PATH = 'content/test_variable.tflite'

# Save the model
module = TestModel()
# You can omit the signatures argument and a default signature name will be
# created with name 'serving_default'.
tf.saved_model.save(
    module, SAVED_MODEL_PATH,
    signatures={'my_signature':module.add.get_concrete_function()})

# Convert the model using TFLiteConverter
converter = tf.lite.TFLiteConverter.from_saved_model(SAVED_MODEL_PATH)
tflite_model = converter.convert()
with open(TFLITE_FILE_PATH, 'wb') as f:
  f.write(tflite_model)

# Load the TFLite model in TFLite Interpreter
interpreter = tf.lite.Interpreter(TFLITE_FILE_PATH)
# There is only 1 signature defined in the model,
# so it will return it by default.
# If there are multiple signatures then we can pass the name.
my_signature = interpreter.get_signature_runner()

# my_signature is callable with input as arguments.
output = my_signature(x=tf.constant([1.0], shape=(1,10), dtype=tf.float32))
# 'output' is dictionary with all outputs from the inference.
# In this case we have single output 'result'.
print(output['result'])

如果模型没有定义 SignatureDefs，则可以使用另一个示例。

import numpy as np
import tensorflow as tf

# Load the TFLite model and allocate tensors.
interpreter = tf.lite.Interpreter(model_path="converted_model.tflite")
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)
interpreter.set_tensor(input_details[0]['index'], input_data)

interpreter.invoke()

# The function `get_tensor()` returns a copy of the tensor data.
# Use `tensor()` in order to get a pointer to the tensor.
output_data = interpreter.get_tensor(output_details[0]['index'])
print(output_data)

作为将模型加载为预转换的 .tflite 文件的替代方法，您可以将代码与 TensorFlow Lite 转换器 Python API (tf.lite.TFLiteConverter) 结合使用，允许您将 Keras 模型转换为 TensorFlow Lite 格式，然后运行推理

import numpy as np
import tensorflow as tf

img = tf.keras.Input(shape=(64, 64, 3), name="img")
const = tf.constant([1., 2., 3.]) + tf.constant([1., 4., 4.])
val = img + const
out = tf.identity(val, name="out")

# Convert to TF Lite format
converter = tf.lite.TFLiteConverter.from_keras_model(tf.keras.models.Model(inputs=[img], outputs=[out]))
tflite_model = converter.convert()

# Load the TFLite model and allocate tensors.
interpreter = tf.lite.Interpreter(model_content=tflite_model)
interpreter.allocate_tensors()

# Continue to get tensors and so forth, as shown above...

有关更多 Python 示例代码，请参阅 label_image.py。

使用动态形状模型运行推理

如果您想使用动态输入形状运行模型，请在运行推理之前调整输入形状的大小。否则，Tensorflow 模型中的 None 形状将在 TFLite 模型中被 1 的占位符替换。

以下示例展示了如何在不同语言中运行推理之前调整输入形状的大小。所有示例都假设输入形状定义为 [1/None, 10]，并且需要调整为 [3, 10]。

C++ 示例

// Resize input tensors before allocate tensors
interpreter->ResizeInputTensor(/*tensor_index=*/0, std::vector<int>{3,10});
interpreter->AllocateTensors();

Python 示例

# Load the TFLite model in TFLite Interpreter
interpreter = tf.lite.Interpreter(model_path=TFLITE_FILE_PATH)

# Resize input shape for dynamic shape model and allocate tensor
interpreter.resize_tensor_input(interpreter.get_input_details()[0]['index'], [3, 10])
interpreter.allocate_tensors()

# Get input and output tensors.
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()