.tflite — esența, structura și aplicarea formatului de model TFLite

Esența formatului .tflite

.tflite este o reprezentare serializată a unui model de învățare automată, optimizată pentru inferență pe dispozitive cu memorie și putere de calcul limitate. Spre deosebire de formatul SavedModel, care stochează graficul în protobuf și necesită resurse semnificative pentru încărcare, .tflite folosește FlatBuffers — o bibliotecă de serializare cu acces la date fără copiere.

Formatul .tflite a fost proiectat ținând cont de particularitățile platformelor mobile: consum minim de memorie la încărcare, pornire rapidă, suport pentru greutăți cuantizate. Fișierul .tflite nu suportă antrenarea — doar inferența. Aceasta este o diferență fundamentală față de formatele complete TensorFlow, ceea ce permite reducerea semnificativă a dimensiunii mediului de execuție.

Conform Google Research, 2024, modelele în format .tflite cu cuantizare INT8 se încarcă cu 60% mai rapid decât modelele similare în format FP32 și consumă cu 40% mai puțină memorie RAM în timpul inferenței.

Structura internă a fișierului .tflite

Fișierul .tflite este format din mai multe secțiuni, organizate conform schemei FlatBuffers. Secțiunea principală — Model, care conține graficul de calcul (SubGraph), lista operatorilor (OperatorCodes) și bufferele cu greutăți. Fiecare SubGraph conține tensori, operatori, indici de intrare și ieșire.

Secțiunea OperatorCodes conține identificatorii tuturor operatorilor utilizați în model — Conv2D, DepthwiseConv2D, FullyConnected, Softmax și alții. Fiecare operator are un cod din lista predefinită BuiltinOperator. Dacă modelul conține operații care nu sunt în listă, acestea sunt marcate ca Custom și necesită implementare printr-un delegat sau un operator personalizat.

Secțiunea Buffers conține datele binare ale greutăților modelului. În funcție de modul de cuantizare, greutățile pot fi stocate în FP32, FP16, INT8 sau în format cuantizat cu parametri de scalare. Bufferele sunt mapate direct în memorie prin mecanismul mmap, ceea ce elimină copierea suplimentară.

Principalele secțiuni ale fișierului .tflite

Cuantizarea și optimizarea formatului

.tflite suportă trei moduri de cuantizare. Cuantizarea integrală INT8 — greutățile și activările sunt reprezentate ca numere întregi pe 8 biți. Pentru conversie este necesar un set reprezentativ de date pentru calibrarea intervalelor de activare. Dimensiunea modelului se reduce de 4 ori.

Cuantizarea FP16 — greutățile sunt convertite în numere cu virgulă mobilă pe 16 biți. Acest mod nu necesită calibrare și oferă o pierdere minimă de precizie. Activările rămân în FP32. Dimensiunea modelului se reduce de 2 ori. Recomandat pentru dispozitive cu suport FP16 pe GPU și NPU.

Cuantizarea dinamică — greutățile sunt convertite în INT8, dar activările sunt calculate în FP32. Dimensiunea modelului se reduce de 4 ori, dar precizia rămâne mai mare decât la INT8 complet. Conform Google ML Performance Benchmarks, acest mod este optim pentru modelele NLP și modelele cu sensibilitate ridicată la precizie.

Crearea .tflite dintr-un model TensorFlow

Pentru conversia modelului în .tflite se utilizează TFLite Converter — o componentă TensorFlow accesibilă prin Python API tf.lite.TFLiteConverter. Converter suportă trei surse: SavedModel, Keras H5 și ConcreteFunction. Un exemplu minimal de conversie a modelului Keras:

import tensorflow as tf

# Încărcați modelul Keras antrenat din fișier
model = tf.keras.models.load_model("my_model.h5")

# Convertiți în .tflite cu cuantizare dinamică
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# Scrieți modelul convertit într-un fișier .tflite
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

Pentru conversia cu cuantizare INT8 completă este necesar un set de date de calibrare. Specificați representative_dataset pentru determinarea intervalelor de activare:

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

Instrumente pentru lucrul cu .tflite

Google oferă un set de instrumente pentru analiza și optimizarea modelelor .tflite. TFLite Benchmark Tool măsoară timpul de inferență pe dispozitiv și afișează statistici pentru fiecare operator. TFLite Model Inspector vizualizează graficul de calcul și arată dimensiunile tensorilor.

Netron — un vizualizator de modele multi-platformă, care suportă .tflite alături de ONNX, Core ML și PyTorch. Netron afișează structura graficului, parametrii fiecărui operator și conexiunile între tensori. Util pentru depanare în timpul conversiei.

TFLite Metadata API permite adăugarea de metadate în fișierul .tflite: descrierea modelului, formatul datelor de intrare, unități de măsură, informații despre autor. Metadatele sunt utilizate de Task Library pentru configurarea automată a preprocesării și postprocesării.

Exemplu de încărcare și execuție .tflite

Exemplu de încărcare a modelului .tflite pe iOS cu Swift API. TFLite Swift API oferă un Interpreter pentru încărcarea modelului din bundle și executarea inferenței. Specificați un delegat pentru accelerarea hardware prin 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()

// Pregătiți datele de intrare pentru model
let inputData = Data.init(count: 1 * 224 * 224 * 3)
try interpreter.copy(inputData, toInputAt: 0)

// Rulați inferența modelului
try interpreter.invoke()

// Citiți datele tensorului de ieșire
let outputTensor = try interpreter.output(at: 0)
let results = outputTensor.data.withUnsafeBytes {
    Array($0.bindMemory(to: Float32.self))
}