Представляем LiteRT : высокопроизводительную среду выполнения Google для искусственного интеллекта на устройстве, ранее известную как TensorFlow Lite. Узнать больше

Эта страница переведена с помощью Cloud Translation API.

Начните работу с LiteRT

Это руководство познакомит вас с процессом запуска модели LiteRT (сокращение от Lite Runtime) на устройстве для составления прогнозов на основе входных данных. Это достигается с помощью интерпретатора LiteRT, который использует статическое упорядочение графов и собственный (менее динамичный) распределитель памяти для обеспечения минимальной нагрузки, инициализации и задержки выполнения.

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

Загрузка модели : загрузите модель .tflite в память, содержащую граф выполнения модели.
Преобразование данных : Преобразование входных данных в ожидаемый формат и размеры. Необработанные входные данные для модели обычно не соответствуют формату входных данных, ожидаемому моделью. Например, вам может потребоваться изменить размер изображения или изменить формат изображения, чтобы он был совместим с моделью.
Выполнение вывода : выполните модель LiteRT, чтобы сделать прогнозы. Этот шаг включает использование API LiteRT для выполнения модели. Он включает в себя несколько шагов, таких как создание интерпретатора и выделение тензоров.
Интерпретация вывода . Интерпретируйте выходные тензоры осмысленным образом, который будет полезен в вашем приложении. Например, модель может возвращать только список вероятностей. Вам предстоит сопоставить вероятности с соответствующими категориями и отформатировать выходные данные.

В этом руководстве описывается, как получить доступ к интерпретатору LiteRT и выполнить вывод с использованием C++, Java и Python.

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

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

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

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

Платформа Android

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

Дополнительную информацию см. в разделах C++ и Java или воспользуйтесь кратким руководством по Android .

Платформа iOS

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

См. разделы Swift , Objective-C и C API или следуйте краткому руководству по iOS .

Платформа Linux

На платформах Linux вы можете выполнять логические выводы с помощью API-интерфейсов LiteRT, доступных на C++ .

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

Загрузка и запуск модели LiteRT включает следующие шаги:

Загрузка модели в память.
Создание Interpreter на основе существующей модели.
Установка значений входного тензора.
Привлечение умозаключений.
Вывод значений тензора.

Андроид (Ява)

API Java для выполнения выводов с помощью LiteRT в первую очередь предназначен для использования с Android, поэтому он доступен как зависимость библиотеки Android: com.google.ai.edge.litert .

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

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

public Interpreter(@NotNull File modelFile);

Или с помощью MappedByteBuffer :

public Interpreter(@NotNull MappedByteBuffer mappedByteBuffer);

В обоих случаях вы должны предоставить действительную модель LiteRT, иначе 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 отображает индексы выходных тензоров на соответствующие выходные данные.

В обоих случаях индексы тензора должны соответствовать значениям, которые вы указали конвертеру LiteRT при создании модели. Имейте в виду, что порядок input тензоров должен соответствовать порядку, заданному конвертеру LiteRT.

Класс Interpreter также предоставляет удобные функции для получения индекса любого ввода или вывода модели, используя имя операции:

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

Если opName не является допустимой операцией в модели, выдается исключение IllegalArgumentException .

Также помните, что Interpreter владеет ресурсами. Чтобы избежать утечки памяти, ресурсы должны быть освобождены после использования:

interpreter.close();

Пример проекта на Java см. в примере приложения для обнаружения объектов Android .

Поддерживаемые типы данных

Чтобы использовать LiteRT, типы данных входных и выходных тензоров должны быть одним из следующих примитивных типов:

float
int
long
byte

String типы также поддерживаются, но они кодируются иначе, чем примитивные типы. В частности, форма строки Tensor определяет количество и расположение строк в Tensor, причем каждый элемент сам по себе является строкой переменной длины. В этом смысле (байтовый) размер Tensor не может быть вычислен только на основе формы и типа, и, следовательно, строки не могут быть предоставлены как один плоский аргумент ByteBuffer .

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

Входы

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

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

Выходы

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

iOS (Свифт)

Swift API доступен в TensorFlowLiteSwift Pod от 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...
}

iOS (Объект-C)

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

Сначала вам необходимо импортировать модуль TensorFlowLiteObjC .

@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);

С++

API C++ для выполнения вывода с помощью LiteRT совместим с платформами Android, iOS и Linux. API C++ в iOS доступен только при использовании bazel.

В C++ модель хранится в классе FlatBufferModel . Он инкапсулирует модель LiteRT, и вы можете построить ее несколькими способами, в зависимости от того, где хранится модель:

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() сразу после изменения размера тензоров.

Простейшее использование LiteRT с 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 needed.
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 .

Питон

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

Установите пакет LiteRT:

$ python3 -m pip install ai-edge-litert

Импортируйте интерпретатор LiteRT

from ai_edge_litert.interpreter import Interpreter
Interpreter = Interpreter(model_path=args.model.file)

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

Этот пример рекомендуется использовать, если вы выполняете преобразование из SavedModel с определенным SignatureDef.

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 LiteRT model in LiteRT Interpreter
from ai_edge_litert.interpreter import Interpreter
interpreter = 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 LiteRT model and allocate tensors.
from ai_edge_litert.interpreter import Interpreter
interpreter = Interpreter(TFLITE_FILE_PATH)
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 вы можете объединить свой код с компилятором LiteRT , что позволит вам преобразовать вашу модель Keras в формат LiteRT, а затем запустить вывод:

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 LiteRT format
converter = tf.lite.TFLiteConverter.from_keras_model(tf.keras.models.Model(inputs=[img], outputs=[out]))
tflite_model = converter.convert()

# Load the LiteRT model and allocate tensors.
from ai_edge_litert.interpreter import Interpreter
interpreter = 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 в моделях LiteRT.

В следующих примерах показано, как изменить размер входной фигуры перед выполнением вывода на разных языках. Во всех примерах предполагается, что входная форма определена как [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 LiteRT model in LiteRT Interpreter
from ai_edge_litert.interpreter import Interpreter
interpreter = 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()