TF Lite Interpreter — mga pangunahing konsepto, interface at pagpapatakbo ng mga modelo

Mga pangunahing konsepto ng TF Lite Interpreter

TF Lite Interpreter ay isang minimalist na runtime na nagpapatupad ng machine learning model sa device nang walang server infrastructure. Ang Interpreter ay hindi sumusuporta sa pagsasanay — inference lamang. Ginagawa nitong magaan: ang binary size ng base interpreter sa Android ay humigit-kumulang 300 KB.

Ang Interpreter ay gumagana sa modelo sa .tflite format, batay sa FlatBuffers. Sa paggawa, ang Interpreter ay naglo-load ng modelo sa memorya sa pamamagitan ng mmap, na nagbibigay ng direktang access sa data nang walang pagkopya. Pagkatapos ay nag-aalokasyon ang Interpreter ng mga tensor batay sa paglalarawan mula sa modelo at handa nang isagawa.

Ang bawat instance ng Interpreter ay hindi thread-safe. Para sa parallel na pagpapatupad ng isang modelo sa maraming thread, gumawa ng hiwalay na mga instance ng Interpreter na may mga kopya ng modelo. Para sa sequential na mga tawag sa isang thread, ang instance ng Interpreter ay maaaring magamit muli.

API ng interpreter sa Android at iOS

Sa Android, ang Interpreter ay available sa pamamagitan ng Java API sa package na org.tensorflow.lite.Interpreter. Ang pangunahing pamamaraan — run(Object input, Object output) — ay tumatanggap ng multidimensional arrays o ByteBuffer. Para sa mas pinong kontrol, gamitin ang mga pamamaraan na runForMultipleInputsOutputs() at resizeInput().

Sa iOS, ang Interpreter ay available sa pamamagitan ng Swift API sa module na TensorFlowLite. Ang pangunahing interface ay kahalintulad sa Android: pagsisimula sa pamamagitan ng Interpreter.init(modelPath:), alokasyon ng mga tensor sa pamamagitan ng allocateTensors(), pagpapatupad sa pamamagitan ng invoke(). Ang Swift API ay sumusuporta sa Data at MLMultiTensor bilang mga uri ng input data.

Paghahambing ng API ayon sa platform

Pag-configure ng mga delegado para sa hardware acceleration

Ang mga delegado ay mga bahagi na naglilipat ng pagpapatupad ng mga operasyon sa specialized na hardware. Ang GPU Delegate ay gumagamit ng OpenGL ES (Android) at Metal (iOS) para sa pagpapabilis ng mga graphic na operasyon. Ang NNAPI Delegate ay naglilipat ng pagpapatupad sa NPU, DSP o GPU sa pamamagitan ng Android Neural Networks API.

Core ML Delegate ay available sa iOS at nagsasalin ng mga operasyon ng TFLite sa format ng Core ML. Ayon sa Apple ML Benchmarking, ang paggamit ng Core ML Delegate sa iPhone 15 Pro ay nagpapabilis ng inference hanggang 4x kumpara sa CPU. Ang delegado ay sumusuporta sa FP32 at FP16 na operasyon.

Ang XNNPACK Delegate ay isang unibersal na solusyon para sa ARM CPU, na optimized para sa mga mobile processor. Hindi nangangailangan ng espesyal na hardware at sumusuporta sa INT8, FP16 at FP32. Inirerekomenda bilang baseline na delegado na nag-a-activate sa lahat ng device.

Pamamahala ng memorya at mga tensor

Ang Interpreter ay namamahala ng mga tensor sa pamamagitan ng memory pool na ina-alokasyon sa pagtawag ng allocateTensors(). Ang laki ng pool ay tinutukoy batay sa paglalarawan ng modelo sa .tflite file. Pagkatapos ng alokasyon, ang interpreter ay hindi naglalaan ng karagdagang memorya sa panahon ng inference.

Para sa mga modelo na may dynamic na laki ng input gamitin ang resizeInput(). Ang pamamaraang ito ay muling naglalaan ng memorya para sa mga input tensor na isinasaalang-alang ang bagong laki. Pagkatapos baguhin ang laki ng input tensor, maaaring kailanganin ang muling pag-aalokasyon sa pamamagitan ng allocateTensors().

Sa pagtatrabaho sa maraming modelo, mahalagang palayain ang mga resources sa pamamagitan ng close(). Ang hindi napalayang mga Interpreter ay maaaring humantong sa pagtagas ng memorya, lalo na sa mga device na may limitadong RAM. Para sa iOS gamitin ang automatic reference counting ARC, para sa Android — try-with-resources o tahasang tawag ng close().

Pangangasiwa ng error at pag-debug

Ang pinakakaraniwang mga error sa pagtatrabaho sa Interpreter — hindi pagkakatugma ng mga dimensyon ng tensor. Kung ang input data ay hindi tumutugma sa inaasahang hugis, ang Interpreter ay nagtatapon ng IllegalArgumentException sa Android o runtime error sa iOS. Suriin ang mga dimensyon sa pamamagitan ng inputTensorAt() at outputTensorAt().

Ang pangalawang karaniwang problema — hindi suportadong mga operator kapag gumagamit ng delegado. Kung ang delegado ay hindi sumusuporta sa operator, ang Interpreter ay awtomatikong bumalik sa CPU para sa operator na iyon. Para sa pagtuklas ng mga ganitong sitwasyon, i-activate ang logging sa pamamagitan ng setCancelled() o suriin ang TFLite logs.

Ang TFLite ay nagbibigay ng Benchmark Tool para sa profiling: pagsukat ng oras ng bawat operator, konsumo ng memorya, paghahambing ng mga delegado. Ang Benchmark Tool ay available bilang bahagi ng TFLite Support Library at maaaring patakbuhin nang direkta sa device.

Mga halimbawa ng inference sa pamamagitan ng Interpreter

Halimbawa ng pagpapatupad ng modelo sa Android na may Java API gamit ang GPU Delegate. Ang Interpreter ay nilikha na may mga opsyon na kasama ang GPU delegado. Pagkatapos isagawa ang inference, ang resulta ay binabasa mula sa output tensor:

import org.tensorflow.lite.Interpreter;
import org.tensorflow.lite.gpu.GpuDelegate;
import java.nio.MappedByteBuffer;

MappedByteBuffer model = loadModelFile(context);
GpuDelegate gpu = new GpuDelegate();
Interpreter.Options opts = new Interpreter.Options().addDelegate(gpu);
Interpreter interpreter = new Interpreter.create(model, opts);

float[][] input = preprocessImage(bitmap);
float[][] output = new float[1][1000];
interpreter.run(input, output);

int bestClass = argmax(output[0]);
Log.d("TFLite", "Nangungunang klase: " + bestClass);

gpu.close();
interpreter.close();

Halimbawa ng pagpapatupad sa Python para sa pagsubok bago ang deployment. Ang Python API ng TFLite ay nagpapahintulot sa pag-load ng .tflite, pagpapatupad ng inference at pagpapakita ng resulta. Ginagamit para sa pag-debug at pagsusuri ng katumpakan ng modelo:

import tensorflow as tf
import numpy as np

# I-load ang TFLite model mula sa file
interpreter = tf.lite.Interpreter(model_path="model.tflite")
interpreter.allocate_tensors()

# Kunin ang mga detalye ng input at output tensor
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Maghanda ng random na input data para sa pagsubok
input_data = np.random.randn(
    *input_details[0]["shape"]
).astype(np.float32)

interpreter.set_tensor(input_details[0]["index"], input_data)
interpreter.invoke()

output_data = interpreter.get_tensor(output_details[0]["index"])
print("Hugis ng output:", output_data.shape)