TensorFlow Lite — ano ito, mga pangunahing kakayahan at aplikasyon

Ano ang TensorFlow Lite

TensorFlow Lite — ay isang specialized runtime para sa pagpapatakbo ng machine learning models sa mga device na may limitadong resources. Hindi tulad ng buong TensorFlow, hindi sinusuportahan ng TFLite ang training at backpropagation — inference lamang. Ito ay nagpapahintulot na maging minimal ang binary size ng library: mga 300 KB para sa basic interpreter sa Android.

Ang arkitektura ng TFLite ay binuo sa paligid ng .tflite format, na batay sa FlatBuffers. Ang FlatBuffers ay nagbibigay ng direktang access sa data nang walang parsing stage, na kritikal para sa mga mobile device na may limitadong memorya. Ang model sa .tflite format ay naglalaman ng computation graph, weights at metadata sa iisang binary file.

Ayon sa Google I/O 2024, ang TFLite ay ginagamit sa Google Photos, Gboard, YouTube at iba pang Google application na may kabuuang audience na mahigit 4 bilyong device. Sinusuportahan ng framework ang lahat ng pangunahing arkitektura: CNN, RNN, LSTM, Transformer at custom operations sa pamamagitan ng delegates.

Arkitektura ng TensorFlow Lite

Ang TFLite runtime ay binubuo ng apat na component. Ang TFLite Converter ay tumatanggap ng model mula sa TensorFlow (SavedModel, Keras, ConcreteFunction) at ginagawa itong .tflite format na may opsyonal na optimisasyon. Ang TFLite Interpreter ay naglo-load ng .tflite at nagpapatakbo ng inference, na namamahala sa mga tensor at memorya.

Delegates — ay mga component na naglilipat ng execution ng operations sa specialized hardware. Ang GPU Delegate ay gumagamit ng OpenGL ES at Metal, NNAPI Delegate — Android Neural Networks API, Core ML Delegate — Apple Core ML. Ang XNNPACK Delegate ay nag-o-optimize ng execution sa ARM CPU. Bawat delegate ay sumusuporta sa specific na set ng operators.

Ang ika-apat na component — Task Library, na nagbibigay ng high-level APIs para sa karaniwang tasks: image classification, object detection, segmentation, NLU. Ang Task Library ay gumagana sa ibabaw ng Interpreter at nagtatago ng mga detalye ng tensor management.

Optimisasyon ng Model at Quantization

Sinusuportahan ng TFLite ang tatlong antas ng quantization. Ang full integer quantization INT8 ay nagko-convert ng weights at activations mula FP32 tungo sa 8-bit integers. Ang laki ng model ay nababawasan ng 4 na beses, at ang bilis ng inference sa mga device na may INT8 support ay tumataas hanggang 3x. Ang FP16 quantization ay nagbabawas ng laki ng kalahati na may minimal na pagkawala ng precision.

Ang dynamic quantization ay nagpapanatili ng weights sa INT8, ngunit nagsasagawa ng computations sa FP32. Ang mode na ito ay angkop para sa mga model na sensitibo sa precision at nagbibigay ng pagbawas ng laki hanggang 4x habang pinapanatili ang kalidad. Ayon sa Google ML Performance Benchmarks, ang dynamic quantization ay inirerekomenda para sa NLP models.

Paghahambing ng TFLite Quantization Modes

Hardware Acceleration sa Android at iOS

Sa Android, ang pangunahing mekanismo ng acceleration ay NNAPI Delegate, na naglilipat ng execution ng operations sa NPU, DSP o GPU sa pamamagitan ng Android Neural Networks API. Ang NNAPI ay available sa mga device na may Android 8.1+ at sumusuporta sa INT8 at FP16 computations. Ang GPU Delegate para sa Android ay gumagamit ng OpenGL ES 3.1+ at Vulkan.

Sa iOS, ang acceleration ay ibinibigay sa pamamagitan ng Core ML Delegate, na nagsasalin ng TFLite operations sa Core ML format at pinapatakbo ang mga ito sa Apple Neural Engine. Ayon sa Apple ML Benchmarking, ang paggamit ng Core ML Delegate ay nagpapabilis ng inference sa iPhone 15 Pro hanggang 4x kumpara sa CPU. Ang GPU Delegate para sa iOS ay gumagamit ng Metal Performance Shaders.

Ang XNNPACK Delegate — ay isang cross-platform na solusyon para sa ARM CPU, na optimisado para sa mga mobile processor. Sinusuportahan ng XNNPACK ang FP32, FP16 at INT8 operations at hindi nangangailangan ng specialized hardware. Inirerekomenda bilang baseline delegate para sa lahat ng device.

Paglalagay ng Model gamit ang TFLite

Ang proseso ng deployment ay may kasamang tatlong hakbang. Una — conversion ng model sa .tflite sa pamamagitan ng TFLite Converter. Ikalawa — pagsama ng .tflite file sa resources ng application. Para sa Android ang file ay inilalagay sa assets, para sa iOS — sa bundle ng application sa pamamagitan ng Xcode. Ikatlo — initialisasyon ng Interpreter at pagpapatakbo ng inference.

Para sa dynamic na pag-update ng models, inirerekomenda ng Google ang paggamit ng Firebase ML Model Downloading o sariling mekanismo ng pag-download mula sa cloud. Ang na-update na .tflite file ay nai-save sa local storage at nalo-load sa Interpreter sa susunod na startup.

Sa deployment, mahalagang isaalang-alang ang laki ng .tflite file. Nililimitahan ng Google Play ang laki ng APK sa 200 MB. Para sa mga model na mas malaki sa 50 MB, inirerekomenda ang paggamit ng Android App Bundle o pag-download ng model nang hiwalay sa pamamagitan ng Play Asset Delivery.

Mga Halimbawa ng Paggamit ng TFLite sa Code

Halimbawa ng pag-load at pagpapatakbo ng model sa Android na may Java API. Gamitin ang Interpreter.create() para mag-load ng .tflite mula sa assets at run() para sa inference. Ang input at output data ay ipinapasa bilang multidimensional arrays o ByteBuffer:

import org.tensorflow.lite.Interpreter;
import java.nio.MappedByteBuffer;
import java.io.FileInputStream;
import java.nio.channels.FileChannel;

MappedByteBuffer model = new FileInputStream(
    getAssets().openFd("model.tflite")
).getChannel().map(
    FileChannel.MapMode.READ_ONLY, 0, fc.size()
);

Interpreter interpreter = new Interpreter.create(model);
float[][] input = new float[1][224 * 224 * 3];
float[][] output = new float[1][1000];
interpreter.run(input, output);
interpreter.close();

Halimbawa ng paggamit ng GPU Delegate sa Android para sa hardware acceleration. Idagdag ang dependency com.android.support:tensorflow-lite-gpu at tukuyin ang delegate kapag gumagawa ng Interpreter:

import org.tensorflow.lite.Interpreter;
import org.tensorflow.lite.gpu.GpuDelegate;

GpuDelegate gpuDelegate = new GpuDelegate.create();
Interpreter.Options options = new Interpreter.Options().addDelegate(gpuDelegate);
Interpreter interpreter = new Interpreter.create(model, options);

// Patakbuhin ang inference sa input data
interpreter.run(input, output);

// Pakawalan ang mga resource ng delegate pagkatapos ng inference
gpuDelegate.close();
interpreter.close();