Вывод TensorFlow Lite

Термин «вывод» относится к процессу выполнения модели TensorFlow Lite на устройстве с целью сделать прогнозы на основе входных данных. Чтобы выполнить вывод с помощью модели TensorFlow Lite, необходимо запустить ее через интерпретатор . Интерпретатор TensorFlow Lite создан экономичным и быстрым. Интерпретатор использует статическое упорядочение графов и собственный (менее динамичный) распределитель памяти, чтобы обеспечить минимальную нагрузку, инициализацию и задержку выполнения.

На этой странице описано, как получить доступ к интерпретатору TensorFlow Lite и выполнить вывод с использованием C++, Java и Python, а также ссылки на другие ресурсы для каждой поддерживаемой платформы .

Важные понятия

Вывод TensorFlow Lite обычно состоит из следующих шагов:

  1. Загрузка модели

    Вы должны загрузить модель .tflite в память, содержащую граф выполнения модели.

  2. Преобразование данных

    Необработанные входные данные для модели обычно не соответствуют формату входных данных, ожидаемому моделью. Например, вам может потребоваться изменить размер изображения или изменить формат изображения, чтобы он был совместим с моделью.

  3. Выполнение вывода

    Этот шаг включает использование API TensorFlow Lite для выполнения модели. Он включает в себя несколько шагов, таких как создание интерпретатора и выделение тензоров, как описано в следующих разделах.

  4. Интерпретация вывода

    Когда вы получаете результаты вывода модели, вы должны интерпретировать тензоры осмысленным образом, который будет полезен в вашем приложении.

    Например, модель может возвращать только список вероятностей. Вам предстоит сопоставить вероятности с соответствующими категориями и представить их конечному пользователю.

Поддерживаемые платформы

API-интерфейсы вывода TensorFlow предоставляются для большинства распространенных мобильных/встраиваемых платформ, таких как Android , iOS и Linux , на нескольких языках программирования.

В большинстве случаев дизайн API отражает предпочтение производительности над простотой использования. TensorFlow Lite предназначен для быстрого вывода на небольших устройствах, поэтому неудивительно, что API стараются избегать ненужных копий в ущерб удобству. Точно так же согласованность с API-интерфейсами TensorFlow не была явной целью, и следует ожидать некоторых различий между языками.

Во всех библиотеках API TensorFlow Lite позволяет загружать модели, подавать входные данные и получать выходные данные вывода.

Платформа Android

В Android вывод TensorFlow Lite может выполняться с использованием API Java или C++. API-интерфейсы Java обеспечивают удобство и могут использоваться непосредственно в классах активности Android. API-интерфейсы C++ обеспечивают большую гибкость и скорость, но могут потребовать написания оболочек JNI для перемещения данных между уровнями Java и C++.

Подробные сведения об использовании C++ и Java см. ниже или ознакомьтесь с кратким руководством по Android , чтобы получить руководство и пример кода.

Генератор кода-оболочки TensorFlow Lite для Android

Для модели TensorFlow Lite, дополненной метаданными , разработчики могут использовать генератор кода оболочки TensorFlow Lite Android для создания кода оболочки для конкретной платформы. Код-оболочка устраняет необходимость прямого взаимодействия с ByteBuffer на Android. Вместо этого разработчики могут взаимодействовать с моделью TensorFlow Lite с помощью типизированных объектов, таких как Bitmap и Rect . Для получения дополнительной информации обратитесь к генератору кода-оболочки TensorFlow Lite для Android .

Платформа iOS

В iOS TensorFlow Lite доступен с собственными библиотеками iOS, написанными на Swift и Objective-C . Вы также можете использовать C API непосредственно в кодах Objective-C.

Подробную информацию об использовании Swift , Objective-C и C API см. ниже или следуйте краткому руководству по iOS , чтобы получить руководство и пример кода.

Платформа Linux

На платформах Linux (включая Raspberry Pi ) вы можете выполнять выводы с помощью API-интерфейсов TensorFlow Lite, доступных на C++ и Python , как показано в следующих разделах.

Запуск модели

Запуск модели TensorFlow Lite включает в себя несколько простых шагов:

  1. Загрузите модель в память.
  2. Создайте Interpreter на основе существующей модели.
  3. Установите значения входного тензора. (При желании измените размер входных тензоров, если предопределенные размеры нежелательны.)
  4. Вызвать умозаключение.
  5. Считайте выходные значения тензора.

В следующих разделах описывается, как эти шаги можно выполнить на каждом языке.

Загрузите и запустите модель на Java

Платформа: Андроид

API Java для выполнения вывода с помощью TensorFlow Lite в первую очередь предназначен для использования с Android, поэтому он доступен как зависимость библиотеки Android: org.tensorflow:tensorflow-lite .

В Java вы будете использовать класс Interpreter для загрузки модели и выполнения вывода модели. Во многих случаях это может быть единственный API, который вам нужен.

Вы можете инициализировать Interpreter , используя файл .tflite :

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 типы также поддерживаются, но они кодируются иначе, чем примитивные типы. В частности, форма строки Tensor определяет количество и расположение строк в Tensor, причем каждый элемент сам по себе является строкой переменной длины. В этом смысле (байтовый) размер Tensor не может быть вычислен только на основе формы и типа, и, следовательно, строки не могут быть предоставлены как один плоский аргумент ByteBuffer . Некоторые примеры вы можете увидеть на этой странице .

Если используются другие типы данных, включая коробочные типы, такие как Integer и Float , будет выдано исключение IllegalArgumentException .

Входы

Каждый вход должен представлять собой массив или многомерный массив поддерживаемых примитивных типов или необработанный ByteBuffer соответствующего размера. Если входные данные представляют собой массив или многомерный массив, размер связанного входного тензора будет неявно изменен в соответствии с размерами массива во время вывода. Если входные данные представляют собой ByteBuffer, вызывающий объект должен сначала вручную изменить размер связанного входного тензора (с помощью Interpreter.resizeInput() ), прежде чем запускать вывод.

При использовании ByteBuffer предпочтительнее использовать прямые байтовые буферы, поскольку это позволяет Interpreter избежать ненужных копий. Если ByteBuffer является прямым байтовым буфером, его порядок должен быть ByteOrder.nativeOrder() . После того, как он используется для вывода модели, он должен оставаться неизменным до завершения вывода модели.

Выходы

Каждый вывод должен представлять собой массив или многомерный массив поддерживаемых примитивных типов или ByteBuffer соответствующего размера. Обратите внимание, что некоторые модели имеют динамические выходные данные, где форма выходных тензоров может меняться в зависимости от входных данных. Не существует простого способа справиться с этим с помощью существующего API вывода Java, но запланированные расширения сделают это возможным.

Загрузите и запустите модель в Swift

Платформа: iOS

Swift API доступен в модуле TensorFlowLiteSwift от Cocoapods.

Сначала вам необходимо импортировать модуль 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

API Objective-C доступен в модуле TensorFlowLiteObjC от Cocoapods.

Сначала вам необходимо импортировать модуль 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... */ }

Использование C API в коде Objective-C

В настоящее время API Objective-C не поддерживает делегатов. Чтобы использовать делегаты с кодом 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 .

Важные части API- Interpreter показаны во фрагменте кода ниже. Необходимо отметить, что:

  • Тензоры представлены целыми числами, чтобы избежать сравнения строк (и любой фиксированной зависимости от библиотек строк).
  • К интерпретатору нельзя обращаться из параллельных потоков.
  • Выделение памяти для входных и выходных тензоров должно быть инициировано вызовом AllocateTensors() сразу после изменения размера тензоров.

Простейшее использование TensorFlow Lite с C++ выглядит следующим образом:

// 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

Платформа: Линукс

API Python для выполнения вывода предоставляется в модуле tf.lite . При этом вам в основном нужен только tf.lite.Interpreter для загрузки модели и выполнения вывода.

В следующем примере показано, как использовать интерпретатор Python для загрузки файла .tflite и выполнения вывода со случайными входными данными:

Этот пример рекомендуется использовать, если вы выполняете преобразование из SavedModel с определенным SignatureDef. Доступно начиная с 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 вы можете объединить свой код с API-интерфейсом Python конвертера TensorFlow Lite ( 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 .

Выполнить вывод с помощью модели динамической формы

Если вы хотите запустить модель с динамической входной формой, измените размер входной формы перед выполнением вывода. В противном случае фигура None в моделях Tensorflow будет заменена заполнителем со значением 1 в моделях TFLite.

В следующих примерах показано, как изменить размер входной фигуры перед выполнением вывода на разных языках. Во всех примерах предполагается, что входная форма определена как [1/None, 10] и ее размер необходимо изменить на [3, 10] .

Пример С++:

// 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()