Panduan ini memperkenalkan Anda pada proses menjalankan model LiteRT di perangkat untuk membuat prediksi berdasarkan data input. Hal ini dilakukan dengan LiteRT penafsir, yang menggunakan pengurutan grafik statis dan kustom (kurang-dinamis) pengalokasi memori untuk memastikan beban, inisialisasi, dan latensi eksekusi minimal.
Inferensi LiteRT biasanya mengikuti langkah-langkah berikut:
Memuat model: muat model
.tflite
ke memori, yang berisi grafik eksekusi model.Mentransformasi data: Ubah data input menjadi format yang diharapkan dan dimensi kustom. Data input mentah untuk model umumnya tidak cocok dengan input format data yang diharapkan oleh model. Misalnya, Anda mungkin perlu mengubah ukuran atau mengubah format gambar agar kompatibel dengan model.
Menjalankan inferensi: Jalankan model LiteRT untuk membuat prediksi. Ini melibatkan penggunaan LiteRT API untuk mengeksekusi model. Proses ini melibatkan beberapa seperti membangun penafsir, dan mengalokasikan tensor.
Menafsirkan output: Menafsirkan tensor output dengan cara yang bermanfaat yang berguna dalam aplikasi Anda. Misalnya, model mungkin hanya menampilkan daftar probabilitas. Terserah Anda untuk memetakan probabilitas kategori dan memformat {i>outputnya<i}.
Panduan ini menjelaskan cara mengakses penafsir LiteRT dan melakukan inferensi menggunakan C++, Java, dan Python.
Platform yang didukung
API inferensi TensorFlow disediakan untuk perangkat seluler dan sematan platform seperti Android, iOS dan Linux, di beberapa bahasa pemrograman.
Dalam kebanyakan kasus, desain API mencerminkan preferensi terhadap performa daripada kemudahan gunakan. LiteRT dirancang untuk inferensi cepat pada perangkat kecil, sehingga API menghindari salinan yang tidak perlu dengan mengorbankan kenyamanan.
Di semua library, LiteRT API memungkinkan Anda memuat model, input feed, dan mengambil output inferensi.
Platform Android
Di Android, inferensi LiteRT dapat dilakukan menggunakan API Java atau C++. Tujuan API Java memberikan kemudahan dan dapat digunakan langsung dalam Android Class aktivitas. C++ API menawarkan lebih banyak fleksibilitas dan kecepatan, tetapi mungkin memerlukan menulis wrapper JNI untuk memindahkan data antara lapisan Java dan C++.
Lihat bagian C++ dan Java untuk mengetahui informasi selengkapnya, atau ikuti panduan memulai Android.
Platform iOS
Di iOS, LiteRT tersedia di Swift dan Objective-C Library iOS. Anda juga dapat menggunakan C API langsung di kode Objective-C.
Melihat Swift, Objective-C, dan C API bagian, atau ikuti panduan memulai iOS.
Platform Linux
Pada platform Linux, Anda dapat menjalankan inferensi menggunakan API LiteRT yang tersedia di C++.
Memuat dan menjalankan model
Memuat dan menjalankan model LiteRT melibatkan langkah-langkah berikut:
- Memuat model ke dalam memori.
- Membuat
Interpreter
berdasarkan model yang sudah ada. - Menyetel nilai tensor input.
- Memanggil inferensi.
- Menghasilkan nilai tensor.
Android (Java)
Java API untuk menjalankan inferensi dengan LiteRT terutama didesain untuk digunakan
dengan Android, sehingga tersedia sebagai dependensi library Android:
com.google.ai.edge.litert
.
Di Java, Anda akan menggunakan class Interpreter
untuk memuat model dan model drive
inferensi. Dalam banyak kasus, ini mungkin satu-satunya API yang Anda perlukan.
Anda dapat melakukan inisialisasi Interpreter
menggunakan file FlatBuffers (.tflite
):
public Interpreter(@NotNull File modelFile);
Atau dengan MappedByteBuffer
:
public Interpreter(@NotNull MappedByteBuffer mappedByteBuffer);
Dalam kedua kasus tersebut, Anda harus memberikan model LiteRT yang valid atau API akan menampilkan
IllegalArgumentException
. Jika Anda menggunakan MappedByteBuffer
untuk menginisialisasi
Interpreter
, atribut tersebut tidak boleh berubah sepanjang waktu
Interpreter
.
Cara yang lebih disukai untuk menjalankan inferensi pada model adalah menggunakan tanda tangan - Tersedia untuk model yang dikonversi mulai 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");
}
Metode runSignature
menggunakan tiga argumen:
Input : memetakan input dari nama input dalam tanda tangan ke input .
Output : memetakan untuk pemetaan output dari nama output dalam tanda tangan ke output layanan otomatis dan data skalabel.
Signature Name (opsional): Nama tanda tangan (Dapat dibiarkan kosong jika memiliki tanda tangan tunggal).
Cara lain untuk menjalankan inferensi ketika model tidak memiliki tanda tangan yang ditentukan.
Cukup panggil Interpreter.run()
. Contoh:
try (Interpreter interpreter = new Interpreter(file_of_a_tensorflowlite_model)) {
interpreter.run(input, output);
}
Metode run()
hanya mengambil satu input dan hanya menampilkan satu output. Jadi, jika
memiliki beberapa input atau beberapa output, gunakan:
interpreter.runForMultipleInputsOutputs(inputs, map_of_indices_to_outputs);
Dalam hal ini, setiap entri dalam inputs
sesuai dengan tensor input dan
map_of_indices_to_outputs
memetakan indeks tensor output ke
data output.
Dalam kedua kasus tersebut, indeks tensor harus sesuai dengan nilai yang Anda berikan
Konverter LiteRT saat Anda membuat model. Harus tahu
bahwa urutan tensor di input
harus sesuai dengan urutan yang diberikan pada LiteRT
Pengonversi.
Class Interpreter
juga menyediakan fungsi yang mudah bagi Anda untuk mendapatkan
indeks input atau output model apa pun yang menggunakan nama operasi:
public int getInputIndex(String opName);
public int getOutputIndex(String opName);
Jika opName
bukan operasi yang valid dalam model, metode ini akan menampilkan
IllegalArgumentException
.
Selain itu, berhati-hatilah karena Interpreter
memiliki resource. Untuk menghindari kebocoran memori,
resource harus dibebaskan setelah digunakan oleh:
interpreter.close();
Untuk contoh project dengan Java, lihat Contoh deteksi objek Android aplikasi.
Jenis data yang didukung
Untuk menggunakan LiteRT, tipe data tensor input dan output harus berupa salah satu jenis primitif berikut:
float
int
long
byte
Jenis String
juga didukung, tetapi dienkode secara berbeda dengan
jenis primitif. Secara khusus, bentuk string Tensor menentukan jumlah
dan susunan string di Tensor, dengan setiap elemen itu sendiri menjadi
{i>string <i}dengan panjang variabel. Dalam hal ini, ukuran (byte) Tensor tidak bisa
dihitung dari bentuk dan jenis saja, dan akibatnya {i>string<i} tidak bisa
disediakan sebagai argumen ByteBuffer
datar tunggal.
Jika jenis data lain, termasuk jenis kotak seperti Integer
dan Float
, digunakan,
IllegalArgumentException
akan dilempar.
Input
Setiap input harus berupa array atau array multi-dimensi dari elemen
jenis primitif, atau ByteBuffer
mentah dengan ukuran yang sesuai. Jika inputnya adalah
sebuah array atau array multi-dimensi, tensor input terkait akan
secara implisit diubah ukurannya ke dimensi array pada waktu inferensi. Jika inputnya adalah
ByteBuffer, pemanggil harus terlebih dahulu mengubah ukuran input terkait secara manual
Tensor (melalui Interpreter.resizeInput()
) sebelum menjalankan inferensi.
Saat menggunakan ByteBuffer
, lebih baik gunakan buffer byte langsung, karena hal ini memungkinkan
Interpreter
untuk menghindari salinan yang tidak perlu. Jika ByteBuffer
adalah byte langsung
buffer, urutannya harus ByteOrder.nativeOrder()
. Setelah digunakan untuk
inferensi model, tidak boleh berubah sampai inferensi model selesai.
Output
Setiap output harus berupa array atau array multi-dimensi dari output yang didukung jenis primitif, atau ByteBuffer dengan ukuran yang sesuai. Perlu diketahui bahwa beberapa model memiliki output dinamis, dengan bentuk tensor output input. Tidak ada cara mudah untuk menangani hal ini dengan API inferensi Java, tetapi ekstensi terencana akan memungkinkan hal ini.
iOS (Swift)
Swift
API
tersedia di Pod TensorFlowLiteSwift
dari Cocoapods.
Pertama, Anda harus mengimpor modul 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 (Objective-C)
Alat Objective-C
API
tersedia di Pod LiteRTObjC
dari Cocoapods.
Pertama, Anda harus mengimpor modul 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 dalam kode Objective-C
Objective-C API tidak mendukung delegasi. Untuk menggunakan delegasi dengan kode Objective-C, Anda harus langsung memanggil kode C Google Cloud Platform.
#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++
C++ API untuk menjalankan inferensi dengan LiteRT kompatibel dengan Android, iOS, dan Linux. C++ API di iOS hanya tersedia saat menggunakan bazel.
Dalam C++, model disimpan di
Class FlatBufferModel
.
Library ini mengenkapsulasi model LiteRT dan Anda dapat membangunnya dalam beberapa
berbeda, tergantung tempat model disimpan:
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);
};
Setelah memiliki model sebagai objek FlatBufferModel
, Anda dapat menjalankannya
dengan
Interpreter
.
Satu FlatBufferModel
dapat digunakan secara bersamaan oleh lebih dari satu
Interpreter
.
Bagian penting dari Interpreter
API ditampilkan dalam cuplikan kode
di bawah ini. Perlu diperhatikan bahwa:
- Tensor direpresentasikan oleh bilangan bulat untuk menghindari perbandingan string (dan dependensi tetap apa pun pada library string).
- Penerjemah tidak boleh diakses dari thread serentak.
- Alokasi memori untuk tensor input dan output harus dipicu dengan memanggil
AllocateTensors()
tepat setelah mengubah ukuran tensor.
Penggunaan LiteRT paling sederhana dengan C++ terlihat seperti ini:
// 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);
Untuk kode contoh lainnya, lihat
minimal.cc
dan
label_image.cc
Python
Python API untuk menjalankan inferensi menggunakan
Interpreter
untuk memuat model dan
menjalankan inferensi.
Instal paket LiteRT:
$ python3 -m pip install ai-edge-litert
Mengimpor Penerjemah LiteRT
from ai_edge_litert.interpreter import Interpreter
Interpreter = Interpreter(model_path=args.model.file)
Contoh berikut menunjukkan cara menggunakan penafsir Python untuk memuat
File FlatBuffers (.tflite
) dan jalankan inferensi dengan data input acak:
Contoh ini direkomendasikan jika Anda mengonversi dariSavedModel dengan 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'])
Contoh lain jika model belum menentukan 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)
Sebagai alternatif untuk memuat model sebagai file .tflite
yang telah dikonversi sebelumnya, Anda
dapat menggabungkan kode Anda dengan metrik LiteRT
Compiler
, yang memungkinkan Anda mengonversi model Keras ke format LiteRT lalu menjalankan
inferensi:
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...
Untuk kode contoh Python lainnya, lihat
label_image.py
Menjalankan inferensi dengan model bentuk dinamis
Jika Anda ingin menjalankan model dengan bentuk input dinamis, ubah ukuran bentuk input
sebelum menjalankan inferensi. Jika tidak, bentuk None
di model TensorFlow akan
diganti dengan placeholder 1
dalam model LiteRT.
Contoh berikut menunjukkan cara mengubah ukuran bentuk input sebelum menjalankan
inferensi dalam berbagai bahasa. Semua contoh mengasumsikan bahwa bentuk input
ditentukan sebagai [1/None, 10]
, dan harus diubah ukurannya menjadi [3, 10]
.
Contoh C++:
// Resize input tensors before allocate tensors
interpreter->ResizeInputTensor(/*tensor_index=*/0, std::vector<int>{3,10});
interpreter->AllocateTensors();
Contoh 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()