.tflite — esensi, struktur dan penerapan format model TFLite

Esensi format .tflite

.tflite adalah representasi serial dari model machine learning, dioptimalkan untuk inferensi pada perangkat dengan memori dan daya komputasi terbatas. Tidak seperti format SavedModel, yang menyimpan grafik dalam protobuf dan memerlukan sumber daya signifikan untuk dimuat, .tflite menggunakan FlatBuffers — pustaka serialisasi dengan akses ke data tanpa penyalinan.

Format .tflite dirancang dengan mempertimbangkan karakteristik platform seluler: konsumsi memori minimal saat memuat, startup cepat, dukungan untuk bobot terkuantisasi. File .tflite tidak mendukung pelatihan — hanya inferensi. Ini adalah perbedaan mendasar dari format TensorFlow penuh, yang memungkinkan pengurangan ukuran runtime secara signifikan.

Menurut Google Research, 2024, model dalam format .tflite dengan kuantisasi INT8 dimuat 60% lebih cepat daripada model serupa dalam format FP32 dan mengkonsumsi 40% lebih sedikit RAM selama inferensi.

Struktur internal file .tflite

File .tflite terdiri dari beberapa bagian, diatur menurut skema FlatBuffers. Bagian utama — Model, yang berisi grafik komputasi (SubGraph), daftar operator (OperatorCodes) dan buffer dengan bobot. Setiap SubGraph berisi tensor, operator, indeks masukan dan keluaran.

Bagian OperatorCodes berisi pengidentifikasi semua operator yang digunakan dalam model — Conv2D, DepthwiseConv2D, FullyConnected, Softmax dan lainnya. Setiap operator memiliki kode dari daftar BuiltinOperator yang telah ditentukan. Jika model berisi operasi yang tidak ada dalam daftar, operasi tersebut ditandai sebagai Custom dan memerlukan implementasi melalui delegat atau operator khusus.

Bagian Buffers berisi data biner bobot model. Tergantung pada mode kuantisasi, bobot dapat disimpan dalam FP32, FP16, INT8 atau dalam format terkuantisasi dengan parameter penskalaan. Buffer dipetakan langsung ke memori melalui mekanisme mmap, yang menghilangkan penyalinan tambahan.

Bagian utama file .tflite

Kuantisasi dan optimasi format

.tflite mendukung tiga mode kuantisasi. Kuantisasi bilangan bulat penuh INT8 — bobot dan aktivasi direpresentasikan sebagai bilangan bulat 8-bit. Untuk konversi diperlukan set data representatif untuk kalibrasi rentang aktivasi. Ukuran model berkurang 4 kali lipat.

Kuantisasi FP16 — bobot dikonversi menjadi angka floating-point 16-bit. Mode ini tidak memerlukan kalibrasi dan memberikan kehilangan presisi minimal. Aktivasi tetap dalam FP32. Ukuran model berkurang 2 kali lipat. Direkomendasikan untuk perangkat dengan dukungan FP16 di GPU dan NPU.

Kuantisasi dinamis — bobot dikonversi ke INT8, tetapi aktivasi dihitung dalam FP32. Ukuran model berkurang 4 kali lipat, tetapi presisi tetap lebih tinggi daripada INT8 penuh. Menurut Google ML Performance Benchmarks, mode ini optimal untuk model NLP dan model dengan sensitivitas tinggi terhadap presisi.

Membuat .tflite dari model TensorFlow

Untuk konversi model ke .tflite digunakan TFLite Converter — komponen TensorFlow yang dapat diakses melalui Python API tf.lite.TFLiteConverter. Converter mendukung tiga sumber: SavedModel, Keras H5 dan ConcreteFunction. Contoh minimal konversi model Keras:

import tensorflow as tf

# Muat model Keras terlatih dari file
model = tf.keras.models.load_model("my_model.h5")

# Konversi ke .tflite dengan kuantisasi dinamis
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# Tulis model yang dikonversi ke file .tflite
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

Untuk konversi dengan kuantisasi INT8 penuh diperlukan set data kalibrasi. Tentukan representative_dataset untuk menentukan rentang aktivasi:

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

Alat untuk bekerja dengan .tflite

Google menyediakan seperangkat alat untuk analisis dan optimasi model .tflite. TFLite Benchmark Tool mengukur waktu inferensi pada perangkat dan menampilkan statistik untuk setiap operator. TFLite Model Inspector memvisualisasikan grafik komputasi dan menunjukkan ukuran tensor.

Netron — visualisator model lintas platform, yang mendukung .tflite bersama ONNX, Core ML dan PyTorch. Netron menampilkan struktur grafik, parameter setiap operator dan koneksi antar tensor. Berguna untuk debugging saat konversi.

TFLite Metadata API memungkinkan penambahan metadata ke file .tflite: deskripsi model, format data masukan, satuan pengukuran, informasi tentang penulis. Metadata digunakan oleh Task Library untuk konfigurasi otomatis preprocessing dan postprocessing.

Contoh memuat dan menjalankan .tflite

Contoh memuat model .tflite di iOS dengan Swift API. TFLite Swift API menyediakan Interpreter untuk memuat model dari bundle dan menjalankan inferensi. Tentukan delegat untuk akselerasi perangkat keras melalui 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()

// Siapkan data masukan untuk model
let inputData = Data.init(count: 1 * 224 * 224 * 3)
try interpreter.copy(inputData, toInputAt: 0)

// Jalankan inferensi model
try interpreter.invoke()

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