TensorFlow Lite — qu’est-ce que c’est, fonctionnalités clés et applications

Qu’est-ce que TensorFlow Lite

TensorFlow Lite est un environnement d’exécution spécialisé pour exécuter des modèles de machine learning sur des appareils aux ressources limitées. Contrairement à TensorFlow complet, TFLite ne prend pas en charge l’apprentissage ou la rétropagation — seulement l’inférence. Cela permet de maintenir la taille binaire de la bibliothèque au minimum : environ 300 Ko pour l’interpréteur de base sur Android.

L’architecture de TFLite est construite autour du format .tflite, basé sur FlatBuffers. FlatBuffers permet un accès direct aux données sans étape d’analyse, ce qui est critique pour les appareils mobiles à mémoire limitée. Un modèle au format .tflite contient le graphe de calcul, les poids et les métadonnées dans un seul fichier binaire.

Selon Google I/O 2024, TFLite est utilisé dans Google Photos, Gboard, YouTube et d’autres applications Google avec une audience combinée de plus de 4 milliards d’appareils. Le framework prend en charge toutes les architectures principales : CNN, RNN, LSTM, Transformer et les opérations personnalisées via les délégués.

Architecture de TensorFlow Lite

L’environnement d’exécution TFLite se compose de quatre composants. TFLite Converter prend un modèle de TensorFlow (SavedModel, Keras, ConcreteFunction) et le convertit au format .tflite avec une optimisation facultative. TFLite Interpreter charge le fichier .tflite et effectue l’inférence, en gérant les tenseurs et la mémoire.

Les délégués sont des composants qui délèguent l’exécution des opérations sur du matériel spécialisé. GPU Delegate utilise OpenGL ES et Metal, NNAPI Delegate utilise l’API Android Neural Networks, Core ML Delegate utilise Apple Core ML. XNNPACK Delegate optimise l’exécution sur CPU ARM. Chaque délégué prend en charge un ensemble spécifique d’opérateurs.

Le quatrième composant est la Task Library, qui fournit des API de haut niveau pour les tâches typiques : classification d’images, détection d’objets, segmentation, NLU. La Task Library fonctionne au-dessus de l’Interpréteur et cache les détails de la gestion des tenseurs.

Optimisation des modèles et quantification

TFLite prend en charge trois niveaux de quantification. La quantification entière complète INT8 convertit les poids et activations de FP32 en entiers 8 bits. La taille du modèle est réduite de 4x et la vitesse d’inférence sur les appareils compatibles INT8 augmente jusqu’à 3x. La quantification FP16 réduit la taille de moitié avec une perte de précision minimale.

La quantification dynamique conserve les poids en INT8 mais effectue les calculs en FP32. Ce mode convient aux modèles sensibles à la précision et offre une réduction de taille jusqu’à 4x tout en maintenant la qualité. Selon les Google ML Performance Benchmarks, la quantification dynamique est recommandée pour les modèles NLP.

Comparaison des modes de quantification TFLite

Accélération matérielle sur Android et iOS

Sur Android, le principal mécanisme d’accélération est le délégué NNAPI, qui délègue l’exécution des opérations au NPU, DSP ou GPU via l’API Android Neural Networks. NNAPI est disponible sur les appareils sous Android 8.1+ et prend en charge les calculs INT8 et FP16. Le délégué GPU pour Android utilise OpenGL ES 3.1+ et Vulkan.

Sur iOS, l’accélération est fournie par le délégué Core ML, qui traduit les opérations TFLite au format Core ML et les exécute sur l’Apple Neural Engine. Selon Apple ML Benchmarking, l’utilisation du délégué Core ML accélère l’inférence sur iPhone 15 Pro jusqu’à 4x par rapport au CPU. Le délégué GPU pour iOS utilise Metal Performance Shaders.

XNNPACK Delegate est une solution multiplateforme pour CPU ARM, optimisée pour les processeurs mobiles. XNNPACK prend en charge les opérations FP32, FP16 et INT8 et ne nécessite pas de matériel spécial. Il est recommandé comme délégué de base pour tous les appareils.

Déploiement de modèles avec TFLite

Le processus de déploiement comprend trois étapes. Première — conversion du modèle en .tflite via TFLite Converter. Deuxième — inclusion du fichier .tflite dans les ressources de l’application. Pour Android, le fichier est placé dans assets ; pour iOS, dans le bundle de l’application via Xcode. Troisième — initialisation de l’Interpréteur et exécution de l’inférence.

Pour les mises à jour dynamiques de modèles, Google recommande d’utiliser Firebase ML Model Downloading ou un mécanisme de téléchargement cloud personnalisé. Le fichier .tflite mis à jour est enregistré dans le stockage local et chargé dans l’Interpréteur au prochain démarrage.

Lors du déploiement, il est important de prendre en compte la taille du fichier .tflite. Google Play limite la taille de l’APK à 200 Mo. Pour les modèles de plus de 50 Mo, il est recommandé d’utiliser Android App Bundle ou de télécharger le modèle séparément via Play Asset Delivery.

Exemples d’utilisation de TFLite en code

Exemple de chargement et d’exécution d’un modèle sur Android avec l’API Java. Utilisez Interpreter.create() pour charger .tflite depuis assets et run() pour l’inférence. Les données d’entrée et de sortie sont passées sous forme de tableaux multidimensionnels ou ByteBuffer :

import org.tensorflow.lite.Interpreter;
import java.nio.MappedByteBuffer;
import java.io.FileInputStream;
import java.nio.channels.FileChannel;

MappedByteBuffer model = new FileInputStream(
    getAssets().openFd("model.tflite")
).getChannel().map(
    FileChannel.MapMode.READ_ONLY, 0, fc.size()
);

Interpreter interpreter = new Interpreter.create(model);
float[][] input = new float[1][224 * 224 * 3];
float[][] output = new float[1][1000];
interpreter.run(input, output);
interpreter.close();

Exemple d’utilisation du délégué GPU sur Android pour l’accélération matérielle. Ajoutez la dépendance com.android.support:tensorflow-lite-gpu et spécifiez le délégué lors de la création de l’Interpréteur :

import org.tensorflow.lite.Interpreter;
import org.tensorflow.lite.gpu.GpuDelegate;

GpuDelegate gpuDelegate = new GpuDelegate.create();
Interpreter.Options options = new Interpreter.Options().addDelegate(gpuDelegate);
Interpreter interpreter = new Interpreter.create(model, options);

// Run inference on the input data
interpreter.run(input, output);

// Release delegate resources after inference
gpuDelegate.close();
interpreter.close();