Le terme inférence fait référence au processus d'exécution d'un modèle TensorFlow Lite sur l'appareil afin de faire des prédictions basées sur les données d'entrée. Pour effectuer une inférence avec un modèle TensorFlow Lite, vous devez l'exécuter via un interpréteur . L'interpréteur TensorFlow Lite est conçu pour être simple et rapide. L'interpréteur utilise un classement graphique statique et un allocateur de mémoire personnalisé (moins dynamique) pour garantir une charge, une initialisation et une latence d'exécution minimales.
Cette page décrit comment accéder à l'interpréteur TensorFlow Lite et effectuer une inférence à l'aide de C++, Java et Python, ainsi que des liens vers d'autres ressources pour chaque plate-forme prise en charge .
Notions importantes
L'inférence TensorFlow Lite suit généralement les étapes suivantes :
Chargement d'un modèle
Vous devez charger en mémoire le modèle
.tflite, qui contient le graphe d'exécution du modèle.Transformer les données
Les données d'entrée brutes du modèle ne correspondent généralement pas au format de données d'entrée attendu par le modèle. Par exemple, vous devrez peut-être redimensionner une image ou modifier le format de l'image pour qu'elle soit compatible avec le modèle.
Exécution de l'inférence
Cette étape implique l'utilisation de l'API TensorFlow Lite pour exécuter le modèle. Cela implique quelques étapes telles que la construction de l'interpréteur et l'attribution des tenseurs, comme décrit dans les sections suivantes.
Interprétation du résultat
Lorsque vous recevez les résultats de l'inférence du modèle, vous devez interpréter les tenseurs d'une manière significative et utile dans votre application.
Par exemple, un modèle peut renvoyer uniquement une liste de probabilités. C'est à vous de mapper les probabilités aux catégories pertinentes et de les présenter à votre utilisateur final.
Plateformes prises en charge
Les API d'inférence TensorFlow sont fournies pour les plates-formes mobiles/embarquées les plus courantes telles qu'Android , iOS et Linux , dans plusieurs langages de programmation.
Dans la plupart des cas, la conception de l’API reflète une préférence pour les performances plutôt que pour la facilité d’utilisation. TensorFlow Lite est conçu pour une inférence rapide sur les petits appareils. Il n'est donc pas surprenant que les API tentent d'éviter les copies inutiles au détriment de la commodité. De même, la cohérence avec les API TensorFlow n'était pas un objectif explicite et il faut s'attendre à des variations entre les langages.
Dans toutes les bibliothèques, l'API TensorFlow Lite vous permet de charger des modèles, d'alimenter les entrées et de récupérer les sorties d'inférence.
Plateforme Android
Sur Android, l'inférence TensorFlow Lite peut être effectuée à l'aide d'API Java ou C++. Les API Java sont pratiques et peuvent être utilisées directement dans vos classes d'activité Android. Les API C++ offrent plus de flexibilité et de vitesse, mais peuvent nécessiter l'écriture de wrappers JNI pour déplacer les données entre les couches Java et C++.
Voir ci-dessous pour plus de détails sur l'utilisation de C++ et Java , ou suivez le démarrage rapide d'Android pour un didacticiel et un exemple de code.
Générateur de code wrapper Android TensorFlow Lite
Pour le modèle TensorFlow Lite amélioré avec des métadonnées , les développeurs peuvent utiliser le générateur de code wrapper Android TensorFlow Lite pour créer un code wrapper spécifique à la plate-forme. Le code wrapper supprime le besoin d'interagir directement avec ByteBuffer sur Android. Au lieu de cela, les développeurs peuvent interagir avec le modèle TensorFlow Lite avec des objets typés tels que Bitmap et Rect . Pour plus d'informations, veuillez vous référer au générateur de code wrapper Android TensorFlow Lite .
Plateforme iOS
Sur iOS, TensorFlow Lite est disponible avec les bibliothèques iOS natives écrites en Swift et Objective-C . Vous pouvez également utiliser l'API C directement dans les codes Objective-C.
Voir ci-dessous pour plus de détails sur l'utilisation de Swift , Objective-C et de l' API C , ou suivez le démarrage rapide iOS pour un didacticiel et un exemple de code.
Plateforme Linux
Sur les plates-formes Linux (y compris Raspberry Pi ), vous pouvez exécuter des inférences à l'aide des API TensorFlow Lite disponibles en C++ et Python , comme indiqué dans les sections suivantes.
Exécuter un modèle
L'exécution d'un modèle TensorFlow Lite implique quelques étapes simples :
- Chargez le modèle en mémoire.
- Créez un
Interpreterbasé sur un modèle existant. - Définissez les valeurs du tenseur d’entrée. (Redimensionnez éventuellement les tenseurs d'entrée si les tailles prédéfinies ne sont pas souhaitées.)
- Invoquez l’inférence.
- Lire les valeurs du tenseur de sortie.
Les sections suivantes décrivent comment ces étapes peuvent être effectuées dans chaque langue.
Charger et exécuter un modèle en Java
Plateforme : Android
L'API Java permettant d'exécuter une inférence avec TensorFlow Lite est principalement conçue pour être utilisée avec Android. Elle est donc disponible en tant que dépendance de bibliothèque Android : org.tensorflow:tensorflow-lite .
En Java, vous utiliserez la classe Interpreter pour charger un modèle et piloter l'inférence de modèle. Dans de nombreux cas, il s’agit peut-être de la seule API dont vous avez besoin.
Vous pouvez initialiser un Interpreter à l'aide d'un fichier .tflite :
public Interpreter(@NotNull File modelFile);
Ou avec un MappedByteBuffer :
public Interpreter(@NotNull MappedByteBuffer mappedByteBuffer);
Dans les deux cas, vous devez fournir un modèle TensorFlow Lite valide, sinon l'API renvoie IllegalArgumentException . Si vous utilisez MappedByteBuffer pour initialiser un Interpreter , il doit rester inchangé pendant toute la durée de vie de l' Interpreter .
La méthode privilégiée pour exécuter une inférence sur un modèle consiste à utiliser des signatures. Disponible pour les modèles convertis à partir de Tensorflow 2.5.
try (Interpreter interpreter = new Interpreter(file_of_tensorflowlite_model)) {
Map<String, Object> inputs = new HashMap<>();
inputs.put("input_1", input1);
inputs.put("input_2", input2);
Map<String, Object> outputs = new HashMap<>();
outputs.put("output_1", output1);
interpreter.runSignature(inputs, outputs, "mySignature");
}
La méthode runSignature prend trois arguments :
Entrées : mapper les entrées du nom d'entrée dans la signature à un objet d'entrée.
Sorties : mappe pour le mappage de sortie du nom de sortie dans la signature aux données de sortie.
Nom de la signature [facultatif] : nom de la signature (peut être laissé vide si le modèle a une seule signature).
Une autre façon d'exécuter une inférence lorsque le modèle n'a pas de signature définie. Appelez simplement Interpreter.run() . Par exemple:
try (Interpreter interpreter = new Interpreter(file_of_a_tensorflowlite_model)) {
interpreter.run(input, output);
}
La méthode run() ne prend qu’une seule entrée et ne renvoie qu’une seule sortie. Donc, si votre modèle a plusieurs entrées ou plusieurs sorties, utilisez plutôt :
interpreter.runForMultipleInputsOutputs(inputs, map_of_indices_to_outputs);
Dans ce cas, chaque entrée dans inputs correspond à un tenseur d'entrée et map_of_indices_to_outputs mappe les indices des tenseurs de sortie aux données de sortie correspondantes.
Dans les deux cas, les indices tensoriels doivent correspondre aux valeurs que vous avez données au TensorFlow Lite Converter lors de la création du modèle. Sachez que l'ordre des tenseurs en input doit correspondre à l'ordre donné au TensorFlow Lite Converter.
La classe Interpreter fournit également des fonctions pratiques qui vous permettent d'obtenir l'index de toute entrée ou sortie de modèle à l'aide d'un nom d'opération :
public int getInputIndex(String opName);
public int getOutputIndex(String opName);
Si opName n'est pas une opération valide dans le modèle, il lève une IllegalArgumentException .
Attention également, Interpreter possède des ressources. Pour éviter les fuites de mémoire, les ressources doivent être libérées après utilisation par :
interpreter.close();
Pour un exemple de projet avec Java, consultez l' exemple de classification d'images Android .
Types de données pris en charge (en Java)
Pour utiliser TensorFlow Lite, les types de données des tenseurs d'entrée et de sortie doivent être l'un des types primitifs suivants :
-
float -
int -
long -
byte
Les types String sont également pris en charge, mais ils sont codés différemment des types primitifs. En particulier, la forme d'un Tensor de chaîne dicte le nombre et la disposition des chaînes dans le Tensor, chaque élément lui-même étant une chaîne de longueur variable. En ce sens, la taille (en octets) du Tensor ne peut pas être calculée à partir de la forme et du type uniquement, et par conséquent les chaînes ne peuvent pas être fournies sous la forme d'un seul argument ByteBuffer plat. Vous pouvez voir quelques exemples sur cette page .
Si d'autres types de données, y compris des types encadrés comme Integer et Float , sont utilisés, une IllegalArgumentException sera levée.
Contributions
Chaque entrée doit être un tableau ou un tableau multidimensionnel des types primitifs pris en charge, ou un ByteBuffer brut de la taille appropriée. Si l'entrée est un tableau ou un tableau multidimensionnel, le tenseur d'entrée associé sera implicitement redimensionné aux dimensions du tableau au moment de l'inférence. Si l'entrée est un ByteBuffer, l'appelant doit d'abord redimensionner manuellement le tenseur d'entrée associé (via Interpreter.resizeInput() ) avant d'exécuter l'inférence.
Lorsque vous utilisez ByteBuffer , préférez utiliser des tampons d'octets directs, car cela permet à l' Interpreter d'éviter les copies inutiles. Si le ByteBuffer est un tampon d'octets direct, son ordre doit être ByteOrder.nativeOrder() . Une fois utilisé pour une inférence de modèle, il doit rester inchangé jusqu'à ce que l'inférence de modèle soit terminée.
Les sorties
Chaque sortie doit être un tableau ou un tableau multidimensionnel des types primitifs pris en charge, ou un ByteBuffer de la taille appropriée. Notez que certains modèles ont des sorties dynamiques, où la forme des tenseurs de sortie peut varier en fonction de l'entrée. Il n'existe pas de moyen simple de gérer cela avec l'API d'inférence Java existante, mais les extensions prévues rendront cela possible.
Charger et exécuter un modèle dans Swift
Plateforme : iOS
L' API Swift est disponible dans le pod TensorFlowLiteSwift de Cocoapods.
Tout d’abord, vous devez importer le module TensorFlowLite .
import TensorFlowLite
// Getting model path
guard
let modelPath = Bundle.main.path(forResource: "model", ofType: "tflite")
else {
// Error handling...
}
do {
// Initialize an interpreter with the model.
let interpreter = try Interpreter(modelPath: modelPath)
// Allocate memory for the model's input `Tensor`s.
try interpreter.allocateTensors()
let inputData: Data // Should be initialized
// input data preparation...
// Copy the input data to the input `Tensor`.
try self.interpreter.copy(inputData, toInputAt: 0)
// Run inference by invoking the `Interpreter`.
try self.interpreter.invoke()
// Get the output `Tensor`
let outputTensor = try self.interpreter.output(at: 0)
// Copy output to `Data` to process the inference results.
let outputSize = outputTensor.shape.dimensions.reduce(1, {x, y in x * y})
let outputData =
UnsafeMutableBufferPointer<Float32>.allocate(capacity: outputSize)
outputTensor.data.copyBytes(to: outputData)
if (error != nil) { /* Error handling... */ }
} catch error {
// Error handling...
}
Charger et exécuter un modèle en Objective-C
Plateforme : iOS
L' API Objective-C est disponible dans le pod TensorFlowLiteObjC de Cocoapods.
Tout d’abord, vous devez importer le module TensorFlowLite .
@import TensorFlowLite;
NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
ofType:@"tflite"];
NSError *error;
// Initialize an interpreter with the model.
TFLInterpreter *interpreter = [[TFLInterpreter alloc] initWithModelPath:modelPath
error:&error];
if (error != nil) { /* Error handling... */ }
// Allocate memory for the model's input `TFLTensor`s.
[interpreter allocateTensorsWithError:&error];
if (error != nil) { /* Error handling... */ }
NSMutableData *inputData; // Should be initialized
// input data preparation...
// Get the input `TFLTensor`
TFLTensor *inputTensor = [interpreter inputTensorAtIndex:0 error:&error];
if (error != nil) { /* Error handling... */ }
// Copy the input data to the input `TFLTensor`.
[inputTensor copyData:inputData error:&error];
if (error != nil) { /* Error handling... */ }
// Run inference by invoking the `TFLInterpreter`.
[interpreter invokeWithError:&error];
if (error != nil) { /* Error handling... */ }
// Get the output `TFLTensor`
TFLTensor *outputTensor = [interpreter outputTensorAtIndex:0 error:&error];
if (error != nil) { /* Error handling... */ }
// Copy output to `NSData` to process the inference results.
NSData *outputData = [outputTensor dataWithError:&error];
if (error != nil) { /* Error handling... */ }
Utilisation de l'API C dans le code Objective-C
Actuellement, l'API Objective-C ne prend pas en charge les délégués. Pour utiliser des délégués avec du code Objective-C, vous devez appeler directement l'API C sous-jacente.
#include "tensorflow/lite/c/c_api.h"
TfLiteModel* model = TfLiteModelCreateFromFile([modelPath UTF8String]);
TfLiteInterpreterOptions* options = TfLiteInterpreterOptionsCreate();
// Create the interpreter.
TfLiteInterpreter* interpreter = TfLiteInterpreterCreate(model, options);
// Allocate tensors and populate the input tensor data.
TfLiteInterpreterAllocateTensors(interpreter);
TfLiteTensor* input_tensor =
TfLiteInterpreterGetInputTensor(interpreter, 0);
TfLiteTensorCopyFromBuffer(input_tensor, input.data(),
input.size() * sizeof(float));
// Execute inference.
TfLiteInterpreterInvoke(interpreter);
// Extract the output tensor data.
const TfLiteTensor* output_tensor =
TfLiteInterpreterGetOutputTensor(interpreter, 0);
TfLiteTensorCopyToBuffer(output_tensor, output.data(),
output.size() * sizeof(float));
// Dispose of the model and interpreter objects.
TfLiteInterpreterDelete(interpreter);
TfLiteInterpreterOptionsDelete(options);
TfLiteModelDelete(model);
Charger et exécuter un modèle en C++
Plateformes : Android, iOS et Linux
En C++, le modèle est stocké dans la classe FlatBufferModel . Il encapsule un modèle TensorFlow Lite et vous pouvez le créer de différentes manières, selon l'emplacement de stockage du modèle :
class FlatBufferModel {
// Build a model based on a file. Return a nullptr in case of failure.
static std::unique_ptr<FlatBufferModel> BuildFromFile(
const char* filename,
ErrorReporter* error_reporter);
// Build a model based on a pre-loaded flatbuffer. The caller retains
// ownership of the buffer and should keep it alive until the returned object
// is destroyed. Return a nullptr in case of failure.
static std::unique_ptr<FlatBufferModel> BuildFromBuffer(
const char* buffer,
size_t buffer_size,
ErrorReporter* error_reporter);
};
Maintenant que vous disposez du modèle en tant qu’objet FlatBufferModel , vous pouvez l’exécuter avec un Interpreter . Un seul FlatBufferModel peut être utilisé simultanément par plusieurs Interpreter .
Les parties importantes de l'API Interpreter sont présentées dans l'extrait de code ci-dessous. Il convient de noter que :
- Les tenseurs sont représentés par des entiers, afin d'éviter les comparaisons de chaînes (et toute dépendance fixe sur les bibliothèques de chaînes).
- Un interpréteur ne doit pas être accessible à partir de threads simultanés.
- L'allocation de mémoire pour les tenseurs d'entrée et de sortie doit être déclenchée en appelant
AllocateTensors()juste après le redimensionnement des tenseurs.
L'utilisation la plus simple de TensorFlow Lite avec C++ ressemble à ceci :
// Load the model
std::unique_ptr<tflite::FlatBufferModel> model =
tflite::FlatBufferModel::BuildFromFile(filename);
// Build the interpreter
tflite::ops::builtin::BuiltinOpResolver resolver;
std::unique_ptr<tflite::Interpreter> interpreter;
tflite::InterpreterBuilder(*model, resolver)(&interpreter);
// Resize input tensors, if desired.
interpreter->AllocateTensors();
float* input = interpreter->typed_input_tensor<float>(0);
// Fill `input`.
interpreter->Invoke();
float* output = interpreter->typed_output_tensor<float>(0);
Pour plus d'exemples de code, voir minimal.cc et label_image.cc .
Charger et exécuter un modèle en Python
Plateforme : Linux
L'API Python pour exécuter une inférence est fournie dans le module tf.lite . À partir de là, vous n’avez généralement besoin que tf.lite.Interpreter pour charger un modèle et exécuter une inférence.
L'exemple suivant montre comment utiliser l'interpréteur Python pour charger un fichier .tflite et exécuter une inférence avec des données d'entrée aléatoires :
Cet exemple est recommandé si vous effectuez une conversion à partir de SavedModel avec un SignatureDef défini. Disponible à partir de TensorFlow 2.5
class TestModel(tf.Module):
def __init__(self):
super(TestModel, self).__init__()
@tf.function(input_signature=[tf.TensorSpec(shape=[1, 10], dtype=tf.float32)])
def add(self, x):
'''
Simple method that accepts single input 'x' and returns 'x' + 4.
'''
# Name the output 'result' for convenience.
return {'result' : x + 4}
SAVED_MODEL_PATH = 'content/saved_models/test_variable'
TFLITE_FILE_PATH = 'content/test_variable.tflite'
# Save the model
module = TestModel()
# You can omit the signatures argument and a default signature name will be
# created with name 'serving_default'.
tf.saved_model.save(
module, SAVED_MODEL_PATH,
signatures={'my_signature':module.add.get_concrete_function()})
# Convert the model using TFLiteConverter
converter = tf.lite.TFLiteConverter.from_saved_model(SAVED_MODEL_PATH)
tflite_model = converter.convert()
with open(TFLITE_FILE_PATH, 'wb') as f:
f.write(tflite_model)
# Load the TFLite model in TFLite Interpreter
interpreter = tf.lite.Interpreter(TFLITE_FILE_PATH)
# There is only 1 signature defined in the model,
# so it will return it by default.
# If there are multiple signatures then we can pass the name.
my_signature = interpreter.get_signature_runner()
# my_signature is callable with input as arguments.
output = my_signature(x=tf.constant([1.0], shape=(1,10), dtype=tf.float32))
# 'output' is dictionary with all outputs from the inference.
# In this case we have single output 'result'.
print(output['result'])
Un autre exemple si le modèle n'a pas défini SignatureDefs.
import numpy as np
import tensorflow as tf
# Load the TFLite model and allocate tensors.
interpreter = tf.lite.Interpreter(model_path="converted_model.tflite")
interpreter.allocate_tensors()
# Get input and output tensors.
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
# Test the model on random input data.
input_shape = input_details[0]['shape']
input_data = np.array(np.random.random_sample(input_shape), dtype=np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()
# The function `get_tensor()` returns a copy of the tensor data.
# Use `tensor()` in order to get a pointer to the tensor.
output_data = interpreter.get_tensor(output_details[0]['index'])
print(output_data)
Au lieu de charger le modèle en tant que fichier .tflite pré-converti, vous pouvez combiner votre code avec l' API Python TensorFlow Lite Converter ( tf.lite.TFLiteConverter ), vous permettant de convertir votre modèle Keras au format TensorFlow Lite, puis exécuter l'inférence :
import numpy as np
import tensorflow as tf
img = tf.keras.Input(shape=(64, 64, 3), name="img")
const = tf.constant([1., 2., 3.]) + tf.constant([1., 4., 4.])
val = img + const
out = tf.identity(val, name="out")
# Convert to TF Lite format
converter = tf.lite.TFLiteConverter.from_keras_model(tf.keras.models.Model(inputs=[img], outputs=[out]))
tflite_model = converter.convert()
# Load the TFLite model and allocate tensors.
interpreter = tf.lite.Interpreter(model_content=tflite_model)
interpreter.allocate_tensors()
# Continue to get tensors and so forth, as shown above...
Pour plus d’exemples de code Python, consultez label_image.py .
Exécuter l'inférence avec un modèle de forme dynamique
Si vous souhaitez exécuter un modèle avec une forme d'entrée dynamique, redimensionnez la forme d'entrée avant d'exécuter l'inférence. Sinon, la forme None dans les modèles Tensorflow sera remplacée par un espace réservé de 1 dans les modèles TFLite.
Les exemples suivants montrent comment redimensionner la forme d'entrée avant d'exécuter l'inférence dans différentes langues. Tous les exemples supposent que la forme d'entrée est définie comme [1/None, 10] et doit être redimensionnée en [3, 10] .
Exemple C++ :
// Resize input tensors before allocate tensors
interpreter->ResizeInputTensor(/*tensor_index=*/0, std::vector<int>{3,10});
interpreter->AllocateTensors();
Exemple Python :
# Load the TFLite model in TFLite Interpreter
interpreter = tf.lite.Interpreter(model_path=TFLITE_FILE_PATH)
# Resize input shape for dynamic shape model and allocate tensor
interpreter.resize_tensor_input(interpreter.get_input_details()[0]['index'], [3, 10])
interpreter.allocate_tensors()
# Get input and output tensors.
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
Opérations prises en charge
TensorFlow Lite prend en charge un sous-ensemble d'opérations TensorFlow avec certaines limitations. Pour la liste complète des opérations et des limitations, consultez la page TF Lite Ops .