질문이있다? TensorFlow 포럼 방문 포럼 에서 커뮤니티와 연결

TensorFlow Lite 추론

추론 이라는 용어는 입력 데이터를 기반으로 예측을 수행하기 위해 기기에서 TensorFlow Lite 모델을 실행하는 프로세스를 나타냅니다. TensorFlow Lite 모델로 추론을 수행하려면 인터프리터를 통해 실행해야합니다. TensorFlow Lite 인터프리터는 간결하고 빠르도록 설계되었습니다. 인터프리터는 정적 그래프 순서 및 사용자 지정 (덜 동적) 메모리 할당자를 사용하여로드, 초기화 및 실행 대기 시간을 최소화합니다.

이 페이지에서는 TensorFlow Lite 인터프리터에 액세스하고 C ++, 자바, Python을 사용하여 추론을 수행하는 방법과 지원되는플랫폼의 다른 리소스에 대한 링크를 설명 합니다 .

중요한 개념

TensorFlow Lite 추론은 일반적으로 다음 단계를 따릅니다.

  1. 모델로드

    .tflite 모델을 모델의 실행 그래프가 포함 된 메모리에로드해야합니다.

  2. 데이터 변환

    모델의 원시 입력 데이터는 일반적으로 모델에서 예상하는 입력 데이터 형식과 일치하지 않습니다. 예를 들어 이미지 크기를 조정하거나 모델과 호환되도록 이미지 형식을 변경해야 할 수 있습니다.

  3. 추론 실행

    이 단계에서는 TensorFlow Lite API를 사용하여 모델을 실행합니다. 다음 섹션에 설명 된대로 인터프리터 구축 및 텐서 할당과 같은 몇 가지 단계가 포함됩니다.

  4. 출력 해석

    모델 추론에서 결과를 받으면 애플리케이션에 유용한 의미있는 방식으로 텐서를 해석해야합니다.

    예를 들어, 모델은 확률 목록 만 반환 할 수 있습니다. 확률을 관련 범주에 매핑하고 최종 사용자에게 제시하는 것은 귀하에게 달려 있습니다.

지원되는 플랫폼

TensorFlow 추론 API는 Android , iOSLinux 와 같은 가장 일반적인 모바일 / 임베디드 플랫폼을 위해 여러 프로그래밍 언어로 제공됩니다.

대부분의 경우 API 디자인은 사용 편의성보다 성능에 대한 선호를 반영합니다. TensorFlow Lite는 소형 기기에서 빠른 추론을 위해 설계되었으므로 API가 편의성을 희생하면서 불필요한 사본을 피하려고하는 것은 놀라운 일이 아닙니다. 마찬가지로 TensorFlow API와의 일관성은 명시적인 목표가 아니 었으며 언어간에 약간의 차이가있을 것으로 예상됩니다.

모든 라이브러리에서 TensorFlow Lite API를 사용하면 모델을로드하고, 입력을 공급하고, 추론 출력을 검색 할 수 있습니다.

안드로이드 플랫폼

Android에서는 Java 또는 C ++ API를 사용하여 TensorFlow Lite 추론을 수행 할 수 있습니다. Java API는 편리함을 제공하며 Android 활동 클래스 내에서 직접 사용할 수 있습니다. C ++ API는 더 많은 유연성과 속도를 제공하지만 Java와 C ++ 계층간에 데이터를 이동하려면 JNI 래퍼를 작성해야 할 수 있습니다.

C ++Java 사용에 대한 자세한 내용은 아래를 참조하거나 가이드 및 예제 코드는 Android 빠른 시작 을 따르세요.

TensorFlow Lite Android 래퍼 코드 생성기

메타 데이터로 강화 된 TensorFlow Lite 모델의 경우 개발자는 TensorFlow Lite Android 래퍼 코드 생성기를 사용하여 플랫폼 별 래퍼 코드를 만들 수 있습니다. 래퍼 코드는 Android에서 ByteBuffer 와 직접 상호 작용할 필요가 없습니다. 대신 개발자는 BitmapRect 와 같은 형식화 된 개체를 사용하여 TensorFlow Lite 모델과 상호 작용할 수 있습니다. 자세한 내용은 TensorFlow Lite Android 래퍼 코드 생성기 를 참조하세요.

iOS 플랫폼

iOS에서 TensorFlow Lite는 SwiftObjective-C로 작성된 기본 iOS 라이브러리와 함께 사용할 수 있습니다. Objective-C 코드에서 직접 C API를 사용할 수도 있습니다.

Swift , Objective-CC API 사용에 대한 자세한 내용은 아래를 참조하거나 튜토리얼 및 예제 코드는 iOS 빠른 시작 을 따르십시오.

Linux 플랫폼

Linux 플랫폼 ( Raspberry Pi 포함)에서는 다음 섹션에 표시된대로 C ++Python으로 제공되는 TensorFlow Lite API를 사용하여 추론을 실행할 수 있습니다.

모델 실행

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

자바를 사용한 예제 프로젝트는 Android 이미지 분류 샘플을 참조하세요.

지원되는 데이터 유형 (Java에서)

TensorFlow Lite를 사용하려면 입력 및 출력 텐서의 데이터 유형이 다음 기본 유형 중 하나 여야합니다.

  • float
  • int
  • long
  • byte

String 유형도 지원되지만 기본 유형과 다르게 인코딩됩니다. 특히 문자열 Tensor의 모양은 Tensor에서 문자열의 수와 배열을 지시하며 각 요소 자체는 가변 길이 문자열입니다. 이러한 의미에서 Tensor의 (바이트) 크기는 모양과 유형만으로 계산할 수 없으며 결과적으로 문자열은 단일 플랫 ByteBuffer 인수로 제공 될 수 없습니다.

IntegerFloat 와 같은 boxed 유형을 포함한 다른 데이터 유형이 사용되면 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 포드에서 사용할 수 있습니다.

먼저 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:&amp;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 객체로 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.cclabel_image.cc 참조하십시오.

Python에서 모델로드 및 실행

플랫폼 : Linux

추론을 실행하기위한 Python API는 tf.lite 모듈에서 제공됩니다. 여기서 모델을로드하고 추론을 실행하려면 tf.lite.Interpreter 만 필요합니다.

다음 예제는 Python 인터프리터를 사용하여 .tflite 파일을로드하고 임의 입력 데이터로 추론을 실행하는 방법을 보여줍니다.

이 예제는 정의 된 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 파일로로드하는 대신 코드를 TensorFlow Lite Converter Python API ( tf.lite.TFLiteConverter )와 결합하여 TensorFlow 모델을 TensorFlow Lite 형식으로 변환 한 다음 추론 실행 :

import numpy as np
import tensorflow as tf

img = tf.placeholder(name="img", dtype=tf.float32, shape=(1, 64, 64, 3))
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
with tf.Session() as sess:
  converter = tf.lite.TFLiteConverter.from_session(sess, [img], [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 참조 label_image.py .

팁 : 인터프리터에 대한 자세한 문서를 얻으려면 Python 터미널에서 help(tf.lite.Interpreter) 를 실행하십시오.

지원되는 작업

TensorFlow Lite는 몇 가지 제한 사항이있는 TensorFlow 작업의 하위 집합을 지원합니다. 작업 및 제한 사항의 전체 목록은 TF Lite Ops 페이지를 참조하십시오 .