.tflite — essenza, struttura e applicazione del formato modello TFLite

Cos'è il formato .tflite

.tflite è una rappresentazione serializzata di un modello di apprendimento automatico ottimizzata per l'inferenza su dispositivi con memoria e potenza di calcolo limitate. A differenza del formato SavedModel, che memorizza un grafo in protobuf e richiede risorse significative per il caricamento, .tflite utilizza FlatBuffers — una libreria di serializzazione con accesso ai dati senza copia.

Il formato .tflite è progettato tenendo conto delle specificità delle piattaforme mobili: consumo minimo di memoria durante il caricamento, avvio rapido e supporto per pesi quantizzati. Un file .tflite non supporta l'addestramento — solo l'inferenza. Questa è una differenza fondamentale rispetto ai formati TensorFlow completi, che consente di ridurre significativamente le dimensioni del runtime.

Secondo Google Research, 2024, i modelli in formato .tflite con quantizzazione INT8 si caricano il 60% più velocemente rispetto ai modelli FP32 equivalenti e consumano il 40% in meno di RAM durante l'inferenza.

Struttura interna del file .tflite

Un file .tflite è composto da diverse sezioni organizzate secondo lo schema FlatBuffers. La sezione principale è Model, che contiene il grafo di calcolo (SubGraph), un elenco di operatori (OperatorCodes) e buffer dei pesi. Ogni SubGraph contiene tensori, operatori e indici di input e output.

La sezione OperatorCodes contiene gli identificatori di tutti gli operatori utilizzati nel modello — Conv2D, DepthwiseConv2D, FullyConnected, Softmax e altri. Ogni operatore ha un codice dall'elenco predefinito BuiltinOperator. Se il modello contiene operazioni non presenti nell'elenco, vengono contrassegnate come Custom e richiedono l'implementazione tramite un delegato o un operatore personalizzato.

La sezione Buffers contiene i dati binari dei pesi del modello. A seconda della modalità di quantizzazione, i pesi possono essere memorizzati in FP32, FP16, INT8 o in un formato quantizzato con parametri di scala. I buffer vengono mappati direttamente in memoria tramite mmap, eliminando copie aggiuntive.

Sezioni principali del file .tflite

Quantizzazione e ottimizzazione del formato

.tflite supporta tre modalità di quantizzazione. Quantizzazione intera completa INT8 — pesi e attivazioni sono rappresentati come interi a 8 bit. La conversione richiede un dataset rappresentativo per calibrare gli intervalli di attivazione. La dimensione del modello si riduce di 4 volte.

Quantizzazione FP16 — i pesi vengono convertiti in numeri a virgola mobile a 16 bit. Questa modalità non richiede calibrazione e offre una perdita minima di precisione. Le attivazioni rimangono in FP32. La dimensione del modello si riduce di 2 volte. Raccomandata per dispositivi con supporto FP16 su GPU e NPU.

Quantizzazione dinamica — i pesi vengono convertiti in INT8 ma le attivazioni vengono calcolate in FP32. La dimensione del modello si riduce di 4 volte mentre la precisione rimane superiore rispetto all'INT8 completo. Secondo Google ML Performance Benchmarks, questa modalità è ottimale per modelli NLP e modelli con elevata sensibilità alla precisione.

Creazione di .tflite da un modello TensorFlow

Per convertire un modello in .tflite, si utilizza TFLite Converter — un componente di TensorFlow disponibile tramite l'API Python tf.lite.TFLiteConverter. Il convertitore supporta tre sorgenti: SavedModel, Keras H5 e ConcreteFunction. Un esempio minimo di conversione di un modello Keras:

import tensorflow as tf

# Caricare il modello Keras addestrato dal file
model = tf.keras.models.load_model("my_model.h5")

# Convertire in .tflite con quantizzazione dinamica
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# Scrivere il modello convertito in un file .tflite
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

Per la conversione con quantizzazione INT8 completa, è necessario un dataset di calibrazione. Fornire un representative_dataset per determinare gli intervalli di attivazione:

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

Strumenti per lavorare con .tflite

Google fornisce una serie di strumenti per analizzare e ottimizzare i modelli .tflite. TFLite Benchmark Tool misura il tempo di inferenza sul dispositivo e mostra le statistiche per ogni operatore. TFLite Model Inspector visualizza il grafo di calcolo e mostra le dimensioni dei tensori.

Netron è un visualizzatore di modelli multipiattaforma che supporta .tflite insieme a ONNX, Core ML e PyTorch. Netron mostra la struttura del grafo, i parametri di ogni operatore e le connessioni tra i tensori. Utile per il debug durante la conversione.

L'API metadati TFLite consente di aggiungere metadati al file .tflite: descrizione del modello, formato dei dati di input, unità di misura, informazioni sull'autore. I metadati vengono utilizzati da Task Library per la configurazione automatica del pre-processing e post-processing.

Esempio di caricamento ed esecuzione di .tflite

Esempio di caricamento di un modello .tflite su iOS con Swift API. L'API Swift di TFLite fornisce un Interpreter per caricare il modello dal bundle ed eseguire l'inferenza. Specificare un delegato per l'accelerazione hardware tramite 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()

// Preparare i dati di input per il modello
let inputData = Data.init(count: 1 * 224 * 224 * 3)
try interpreter.copy(inputData, toInputAt: 0)

// Eseguire l'inferenza del modello
try interpreter.invoke()

// Leggere i dati del tensore di output
let outputTensor = try interpreter.output(at: 0)
let results = outputTensor.data.withUnsafeBytes {
    Array($0.bindMemory(to: Float32.self))
}