TF Lite Interpreter — concepts clés, interface et inférence de modèles

Concepts clés de TF Lite Interpreter

TF Lite Interpreter est un environnement d'exécution minimaliste qui exécute un modèle d'apprentissage automatique sur l'appareil sans infrastructure serveur. L'interpréteur ne prend pas en charge l'entraînement — seulement l'inférence. Cela le rend léger : la taille binaire de l'interpréteur de base sur Android est d'environ 300 Ko.

L'interpréteur fonctionne avec des modèles au format .tflite, basé sur FlatBuffers. Lors de la création, l'interpréteur charge le modèle en mémoire via mmap, offrant un accès direct aux données sans copie. Ensuite, l'interpréteur alloue les tenseurs en fonction de la description du modèle et est prêt à exécuter.

Chaque instance de l'interpréteur n'est pas thread-safe. Pour exécuter le même modèle en parallèle dans plusieurs threads, créez des instances séparées de l'interpréteur avec des copies du modèle. Pour les appels séquentiels dans un seul thread, une instance de l'interpréteur peut être réutilisée.

API de l'interpréteur sur Android et iOS

Sur Android, l'interpréteur est disponible via l'API Java dans le package org.tensorflow.lite.Interpreter. La méthode principale est run(Object input, Object output), qui accepte des tableaux multidimensionnels ou ByteBuffer. Pour un contrôle plus fin, utilisez les méthodes runForMultipleInputsOutputs() et resizeInput().

Sur iOS, l'interpréteur est disponible via l'API Swift dans le module TensorFlowLite. L'interface de base est similaire à Android : initialisation via Interpreter.init(modelPath:), allocation des tenseurs via allocateTensors(), exécution via invoke(). L'API Swift prend en charge Data et MLMultiTensor comme types de données d'entrée.

Comparaison des API par plateforme

Configuration des délégués pour l'accélération matérielle

Les délégués sont des composants qui délocalisent l'exécution des opérations vers du matériel spécialisé. Le GPU Delegate utilise OpenGL ES (Android) et Metal (iOS) pour accélérer les opérations graphiques. Le NNAPI Delegate délocalise l'exécution vers NPU, DSP ou GPU via l'API Android Neural Networks.

Core ML Delegate est disponible sur iOS et traduit les opérations TFLite au format Core ML. Selon Apple ML Benchmarking, l'utilisation de Core ML Delegate sur iPhone 15 Pro accélère l'inférence jusqu'à 4x par rapport au CPU. Le délégué prend en charge les opérations FP32 et FP16.

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

Gestion de la mémoire et des tenseurs

L'interpréteur gère les tenseurs via un pool de mémoire alloué lors de l'appel à allocateTensors(). La taille du pool est déterminée en fonction de la description du modèle dans le fichier .tflite. Après l'allocation, l'interpréteur n'alloue pas de mémoire supplémentaire pendant l'inférence.

Pour les modèles avec des tailles d'entrée dynamiques, utilisez resizeInput(). Cette méthode réalloue la mémoire pour les tenseurs d'entrée en fonction de la nouvelle taille. Après le redimensionnement d'un tenseur d'entrée, une réallocation via allocateTensors() peut être nécessaire.

Lorsque vous travaillez avec plusieurs modèles, il est important de libérer les ressources via close(). Les instances d'interpréteur non libérées peuvent provoquer des fuites de mémoire, en particulier sur les appareils avec une RAM limitée. Pour iOS, utilisez le comptage automatique de références ARC ; pour Android, utilisez try-with-resources ou un appel explicite à close().

Gestion des erreurs et débogage

Les erreurs les plus courantes lors de l'utilisation de l'interpréteur sont les incohérences de dimensions des tenseurs. Si les données d'entrée ne correspondent pas à la forme attendue, l'interpréteur lance IllegalArgumentException sur Android ou une erreur d'exécution sur iOS. Vérifiez les dimensions via inputTensorAt() et outputTensorAt().

Le deuxième problème courant est celui des opérateurs non pris en charge lors de l'utilisation d'un délégué. Si un délégué ne prend pas en charge un opérateur, l'interpréteur revient automatiquement au CPU pour cet opérateur. Pour identifier ces situations, activez la journalisation via setCancelled() ou vérifiez les journaux TFLite.

TFLite fournit un outil de benchmark pour le profilage : mesure du temps d'exécution de chaque opérateur, consommation mémoire, comparaison des délégués. L'outil de benchmark est disponible dans le cadre de la bibliothèque de support TFLite et peut être exécuté directement sur l'appareil.

Exemples d'inférence via l'interpréteur

Exemple d'exécution d'un modèle sur Android avec l'API Java utilisant GPU Delegate. L'interpréteur est créé avec des options incluant le délégué GPU. Après l'inférence, le résultat est lu à partir du tenseur de sortie :

import org.tensorflow.lite.Interpreter;
import org.tensorflow.lite.gpu.GpuDelegate;
import java.nio.MappedByteBuffer;

MappedByteBuffer model = loadModelFile(context);
GpuDelegate gpu = new GpuDelegate();
Interpreter.Options opts = new Interpreter.Options().addDelegate(gpu);
Interpreter interpreter = new Interpreter.create(model, opts);

float[][] input = preprocessImage(bitmap);
float[][] output = new float[1][1000];
interpreter.run(input, output);

int bestClass = argmax(output[0]);
Log.d("TFLite", "Classe principale : " + bestClass);

gpu.close();
interpreter.close();

Exemple d'exécution en Python pour les tests avant déploiement. L'API Python TFLite permet de charger .tflite, d'exécuter l'inférence et d'afficher le résultat. Utilisé pour le débogage et la vérification de la précision du modèle :

import tensorflow as tf
import numpy as np

# Charger le modèle TFLite depuis un fichier
interpreter = tf.lite.Interpreter(model_path="model.tflite")
interpreter.allocate_tensors()

# Obtenir les détails des tenseurs d'entrée et de sortie
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Préparer des données d'entrée aléatoires pour les tests
input_data = np.random.randn(
    *input_details[0]["shape"]
).astype(np.float32)

interpreter.set_tensor(input_details[0]["index"], input_data)
interpreter.invoke()

output_data = interpreter.get_tensor(output_details[0]["index"])
print("Forme de sortie :", output_data.shape)