.tflite — essence, structure et application du format de modèle TFLite

Qu'est-ce que le format .tflite

.tflite est une représentation sérialisée d'un modèle d'apprentissage automatique optimisée pour l'inférence sur des appareils à mémoire et puissance de calcul limitées. Contrairement au format SavedModel qui stocke un graphe en protobuf et nécessite des ressources importantes pour le chargement, .tflite utilise FlatBuffers — une bibliothèque de sérialisation avec accès aux données sans copie.

Le format .tflite est conçu en tenant compte des spécificités des plateformes mobiles : consommation mémoire minimale au chargement, démarrage rapide et prise en charge des poids quantifiés. Un fichier .tflite ne supporte pas l'apprentissage — seulement l'inférence. C'est une différence fondamentale par rapport aux formats TensorFlow complets, permettant de réduire considérablement la taille de l'exécution.

Selon Google Research, 2024, les modèles au format .tflite avec quantification INT8 se chargent 60% plus rapidement que les modèles FP32 équivalents et consomment 40% moins de RAM pendant l'inférence.

Structure interne du fichier .tflite

Un fichier .tflite est composé de plusieurs sections organisées selon le schéma FlatBuffers. La section principale est Model, qui contient le graphe de calcul (SubGraph), une liste d'opérateurs (OperatorCodes) et des tampons de poids. Chaque SubGraph contient des tenseurs, des opérateurs et des indices d'entrée et de sortie.

La section OperatorCodes contient les identifiants de tous les opérateurs utilisés dans le modèle — Conv2D, DepthwiseConv2D, FullyConnected, Softmax et autres. Chaque opérateur possède un code de la liste prédéfinie BuiltinOperator. Si le modèle contient des opérations absentes de la liste, elles sont marquées comme Custom et nécessitent une implémentation via un délégué ou un opérateur personnalisé.

La section Buffers contient les données binaires des poids du modèle. Selon le mode de quantification, les poids peuvent être stockés en FP32, FP16, INT8 ou dans un format quantifié avec des paramètres d'échelle. Les tampons sont mappés directement en mémoire via mmap, éliminant les copies supplémentaires.

Sections principales du fichier .tflite

Quantification et optimisation du format

.tflite prend en charge trois modes de quantification. La quantification entière complète INT8 — les poids et les activations sont représentés par des entiers 8 bits. La conversion nécessite un ensemble de données représentatif pour calibrer les plages d'activation. La taille du modèle est réduite de 4 fois.

La quantification FP16 — les poids sont convertis en nombres à virgule flottante 16 bits. Ce mode ne nécessite pas de calibrage et offre une perte de précision minimale. Les activations restent en FP32. La taille du modèle est réduite de 2 fois. Recommandé pour les appareils prenant en charge FP16 sur GPU et NPU.

Quantification dynamique — les poids sont convertis en INT8 mais les activations sont calculées en FP32. La taille du modèle est réduite de 4 fois tandis que la précision reste supérieure à celle de l'INT8 complet. Selon Google ML Performance Benchmarks, ce mode est optimal pour les modèles NLP et les modèles à haute sensibilité à la précision.

Création de .tflite à partir d'un modèle TensorFlow

Pour convertir un modèle en .tflite, utilisez TFLite Converter — un composant TensorFlow disponible via l'API Python tf.lite.TFLiteConverter. Le convertisseur prend en charge trois sources : SavedModel, Keras H5 et ConcreteFunction. Un exemple minimal de conversion d'un modèle Keras :

import tensorflow as tf

# Charger le modèle Keras entraîné depuis le fichier
model = tf.keras.models.load_model("my_model.h5")

# Convertir en .tflite avec quantification dynamique
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# Écrire le modèle converti dans un fichier .tflite
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

Pour une conversion avec quantification INT8 complète, un ensemble de données de calibrage est requis. Fournissez un representative_dataset pour déterminer les plages d'activation :

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

Outils pour travailler avec .tflite

Google fournit un ensemble d'outils pour analyser et optimiser les modèles .tflite. TFLite Benchmark Tool mesure le temps d'inférence sur l'appareil et affiche les statistiques de chaque opérateur. TFLite Model Inspector visualise le graphe de calcul et montre les tailles des tenseurs.

Netron est un visualiseur de modèles multiplateforme prenant en charge .tflite aux côtés d'ONNX, Core ML et PyTorch. Netron affiche la structure du graphe, les paramètres de chaque opérateur et les connexions entre tenseurs. Utile pour le débogage lors de la conversion.

L'API de métadonnées TFLite permet d'ajouter des métadonnées au fichier .tflite : description du modèle, format des données d'entrée, unités de mesure, informations sur l'auteur. Les métadonnées sont utilisées par Task Library pour la configuration automatique du prétraitement et du post-traitement.

Exemple de chargement et d'exécution de .tflite

Exemple de chargement d'un modèle .tflite sur iOS avec l'API Swift. L'API Swift de TFLite fournit un Interpreter pour charger le modèle depuis le bundle et exécuter l'inférence. Spécifiez un délégué pour l'accélération matérielle via 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()

// Préparer les données d'entrée pour le modèle
let inputData = Data.init(count: 1 * 224 * 224 * 3)
try interpreter.copy(inputData, toInputAt: 0)

// Exécuter l'inférence du modèle
try interpreter.invoke()

// Lire les données du tenseur de sortie
let outputTensor = try interpreter.output(at: 0)
let results = outputTensor.data.withUnsafeBytes {
    Array($0.bindMemory(to: Float32.self))
}