.tflite — esensya, istraktura at aplikasyon ng format ng modelong TFLite

Esensya ng .tflite format

.tflite ay isang serialized na representasyon ng machine learning model, na na-optimize para sa inference sa mga device na may limitadong memory at computing power. Hindi tulad ng SavedModel format, na nag-iimbak ng graph sa protobuf at nangangailangan ng malaking resources para ma-load, ang .tflite ay gumagamit ng FlatBuffers — isang serialization library na may access sa data nang walang pagkopya.

Ang .tflite format ay dinisenyo na isinasaalang-alang ang mga katangian ng mobile platforms: minimal na pagkonsumo ng memory sa pag-load, mabilis na pagsisimula, suporta para sa quantized weights. Ang .tflite file ay hindi sumusuporta sa training — inference lang. Ito ay pangunahing pagkakaiba mula sa full TensorFlow format, na nagpapahintulot ng makabuluhang pagbawas sa laki ng runtime.

Ayon sa Google Research, 2024, ang mga modelo sa .tflite format na may INT8 quantization ay na-load nang 60% mas mabilis kaysa sa mga katulad na modelo sa FP32 format at kumukonsumo ng 40% mas kaunting RAM sa panahon ng inference.

Panloob na istraktura ng .tflite file

Ang .tflite file ay binubuo ng ilang mga seksyon, na nakaayos ayon sa FlatBuffers scheme. Ang pangunahing seksyon — Model, na naglalaman ng computation graph (SubGraph), listahan ng operators (OperatorCodes) at buffers na may weights. Bawat SubGraph ay naglalaman ng tensors, operators, input at output indices.

Ang seksyong OperatorCodes ay naglalaman ng mga identifier ng lahat ng operator na ginamit sa modelo — Conv2D, DepthwiseConv2D, FullyConnected, Softmax at iba pa. Bawat operator ay may code mula sa paunang natukoy na listahan ng BuiltinOperator. Kung ang modelo ay naglalaman ng mga operasyon na wala sa listahan, ang mga ito ay minarkahan bilang Custom at nangangailangan ng implementation sa pamamagitan ng delegate o custom operator.

Ang seksyong Buffers ay naglalaman ng binary data ng model weights. Depende sa quantization mode, ang weights ay maaaring i-imbak sa FP32, FP16, INT8 o sa quantized format na may scaling parameters. Ang buffers ay naka-map nang direkta sa memory sa pamamagitan ng mmap mechanism, na nag-aalis ng karagdagang pagkopya.

Mga pangunahing seksyon ng .tflite file

Quantization at optimization ng format

.tflite ay sumusuporta sa tatlong quantization mode. Full integer INT8 quantization — ang weights at activations ay kinakatawan bilang 8-bit integers. Para sa conversion ay kinakailangan ang representative dataset para sa calibration ng activation ranges. Ang laki ng modelo ay nababawasan ng 4 na beses.

FP16 quantization — ang weights ay kino-convert sa 16-bit floating point numbers. Ang mode na ito ay hindi nangangailangan ng calibration at nagbibigay ng minimal na pagkawala ng precision. Ang activations ay nananatili sa FP32. Ang laki ng modelo ay nababawasan ng 2 beses. Inirerekomenda para sa mga device na may FP16 support sa GPU at NPU.

Dynamic quantization — ang weights ay kino-convert sa INT8, ngunit ang activations ay kinakalkula sa FP32. Ang laki ng modelo ay nababawasan ng 4 na beses, ngunit ang precision ay nananatiling mas mataas kaysa sa full INT8. Ayon sa Google ML Performance Benchmarks, ang mode na ito ay optimal para sa NLP models at models na may mataas na sensitivity sa precision.

Paggawa ng .tflite mula sa TensorFlow model

Para sa conversion ng modelo sa .tflite ay ginagamit ang TFLite Converter — isang TensorFlow component na accessible sa pamamagitan ng Python API tf.lite.TFLiteConverter. Ang Converter ay sumusuporta sa tatlong source: SavedModel, Keras H5 at ConcreteFunction. Isang minimal na halimbawa ng conversion ng Keras model:

import tensorflow as tf

# I-load ang trained Keras model mula sa file
model = tf.keras.models.load_model("my_model.h5")

# I-convert sa .tflite na may dynamic quantization
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# Isulat ang converted model sa isang .tflite file
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

Para sa conversion na may full INT8 quantization ay kinakailangan ang calibration dataset. Tukuyin ang representative_dataset para sa pagtukoy ng activation ranges:

converter = tf.lite.TFLiteConverter.from_saved_model("saved_model")
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [
    tf.lite.OpsSet.TFLITE_BUILTINS_INT8
]
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8
tflite_quant_model = converter.convert()

Mga tool para sa pagtatrabaho sa .tflite

Ang Google ay nagbibigay ng isang set ng mga tool para sa pagsusuri at optimization ng .tflite models. Sinusukat ng TFLite Benchmark Tool ang inference time sa device at nagpapakita ng statistics para sa bawat operator. Ang TFLite Model Inspector ay nagvi-visualize ng computation graph at nagpapakita ng laki ng tensors.

Netron — isang cross-platform model visualizer, na sumusuporta sa .tflite kasama ng ONNX, Core ML at PyTorch. Ipinapakita ng Netron ang structure ng graph, parameters ng bawat operator at connections sa pagitan ng tensors. Kapaki-pakinabang para sa debugging sa panahon ng conversion.

Ang TFLite Metadata API ay nagpapahintulot ng pagdaragdag ng metadata sa .tflite file: paglalarawan ng modelo, format ng input data, yunit ng pagsukat, impormasyon tungkol sa may-akda. Ang metadata ay ginagamit ng Task Library para sa awtomatikong configuration ng preprocessing at postprocessing.

Halimbawa ng pag-load at pag-execute ng .tflite

Halimbawa ng pag-load ng .tflite model sa iOS na may Swift API. Ang TFLite Swift API ay nagbibigay ng Interpreter para sa pag-load ng modelo mula sa bundle at pag-execute ng inference. Tukuyin ang delegate para sa hardware acceleration sa pamamagitan ng Core ML Delegate:

import TensorFlowLite

guard let modelPath = Bundle.main.path(
    forResource: "model", ofType: "tflite"
) else { return }

let interpreter = try Interpreter.init(modelPath: modelPath)
try interpreter.allocateTensors()

// Ihanda ang input data para sa modelo
let inputData = Data.init(count: 1 * 224 * 224 * 3)
try interpreter.copy(inputData, toInputAt: 0)

// Patakbuhin ang model inference
try interpreter.invoke()

// Basahin ang output tensor data
let outputTensor = try interpreter.output(at: 0)
let results = outputTensor.data.withUnsafeBytes {
    Array($0.bindMemory(to: Float32.self))
}