Initiez-vous aux microcontrôleurs

Ce document explique comment entraîner un modèle et exécuter une inférence à l'aide d'un microcontrôleur.

L'exemple de Hello World

L'exemple Hello World est conçu pour démontrer les bases absolues de l'utilisation de TensorFlow Lite pour les microcontrôleurs. Nous entraînons et exécutons un modèle qui reproduit une fonction sinusoïdale, c'est-à-dire qu'il prend un seul nombre en entrée et génère la valeur sinusoïdale de ce nombre. Lorsqu'elles sont déployées sur le microcontrôleur, ses prédictions sont utilisées soit pour faire clignoter des LED, soit pour contrôler une animation.

Le flux de travail de bout en bout implique les étapes suivantes :

  1. Entraîner un modèle (en Python) : un fichier Python pour entraîner, convertir et optimiser un modèle pour une utilisation sur l'appareil.
  2. Exécuter l'inférence (en C++ 17) : un test unitaire de bout en bout qui exécute l'inférence sur le modèle à l'aide de la bibliothèque C++ .

Obtenez un appareil pris en charge

L'exemple d'application que nous utiliserons a été testé sur les appareils suivants :

En savoir plus sur les plates-formes prises en charge dans TensorFlow Lite pour microcontrôleurs .

Former un modèle

Utilisez train.py pour la formation du modèle Hello World pour la reconnaissance des ondes sinusoïdales

Exécutez : bazel build tensorflow/lite/micro/examples/hello_world:train bazel-bin/tensorflow/lite/micro/examples/hello_world/train --save_tf_model --save_dir=/tmp/model_created/

Exécuter l'inférence

Pour exécuter le modèle sur votre appareil, nous allons parcourir les instructions du README.md :

Bonjour tout le monde README.md

Les sections suivantes présentent le test unitaire evaluate_test.cc de l'exemple qui montre comment exécuter l'inférence à l'aide de TensorFlow Lite pour microcontrôleurs. Il charge le modèle et exécute l'inférence plusieurs fois.

1. Inclure les en-têtes de bibliothèque

Pour utiliser la bibliothèque TensorFlow Lite for Microcontrollers, nous devons inclure les fichiers d'en-tête suivants :

#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
#include "tensorflow/lite/micro/micro_error_reporter.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "tensorflow/lite/version.h"

2. Inclure l'en-tête du modèle

L'interpréteur TensorFlow Lite for Microcontrollers s'attend à ce que le modèle soit fourni sous forme de tableau C++. Le modèle est défini dans les fichiers model.h et model.cc . L'en-tête est inclus avec la ligne suivante :

#include "tensorflow/lite/micro/examples/hello_world/model.h"

3. Inclure l'en-tête du cadre de tests unitaires

Afin de créer un test unitaire, nous incluons le framework de test unitaire TensorFlow Lite for Microcontrollers en incluant la ligne suivante :

#include "tensorflow/lite/micro/testing/micro_test.h"

Le test est défini à l'aide des macros suivantes :

TF_LITE_MICRO_TESTS_BEGIN

TF_LITE_MICRO_TEST(LoadModelAndPerformInference) {
  . // add code here
  .
}

TF_LITE_MICRO_TESTS_END

Nous discutons maintenant du code inclus dans la macro ci-dessus.

4. Configurer la journalisation

Pour configurer la journalisation, un pointeur tflite::ErrorReporter est créé à l'aide d'un pointeur vers une instance tflite::MicroErrorReporter :

tflite::MicroErrorReporter micro_error_reporter;
tflite::ErrorReporter* error_reporter = &micro_error_reporter;

Cette variable sera passée à l'interpréteur, ce qui lui permettra d'écrire des logs. Étant donné que les microcontrôleurs disposent souvent de divers mécanismes de journalisation, l'implémentation de tflite::MicroErrorReporter est conçue pour être personnalisée pour votre appareil particulier.

5. Charger un modèle

Dans le code suivant, le modèle est instancié à l'aide des données d'un tableau char , g_model , qui est déclaré dans model.h . Nous vérifions ensuite le modèle pour nous assurer que sa version du schéma est compatible avec la version que nous utilisons :

const tflite::Model* model = ::tflite::GetModel(g_model);
if (model->version() != TFLITE_SCHEMA_VERSION) {
  TF_LITE_REPORT_ERROR(error_reporter,
      "Model provided is schema version %d not equal "
      "to supported version %d.\n",
      model->version(), TFLITE_SCHEMA_VERSION);
}

6. Instancier le résolveur d'opérations

Une instance MicroMutableOpResolver est déclarée. Ceci sera utilisé par l'interprète pour enregistrer et accéder aux opérations utilisées par le modèle :

using HelloWorldOpResolver = tflite::MicroMutableOpResolver<1>;

TfLiteStatus RegisterOps(HelloWorldOpResolver& op_resolver) {
  TF_LITE_ENSURE_STATUS(op_resolver.AddFullyConnected());
  return kTfLiteOk;

Le MicroMutableOpResolver nécessite un paramètre de modèle indiquant le nombre d'opérations qui seront enregistrées. La fonction RegisterOps enregistre les opérations auprès du résolveur.

HelloWorldOpResolver op_resolver;
TF_LITE_ENSURE_STATUS(RegisterOps(op_resolver));

7. Allouer de la mémoire

Nous devons pré-allouer une certaine quantité de mémoire pour les tableaux d’entrée, de sortie et intermédiaires. Ceci est fourni sous forme de tableau uint8_t de taille tensor_arena_size :

const int tensor_arena_size = 2 * 1024;
uint8_t tensor_arena[tensor_arena_size];

La taille requise dépendra du modèle que vous utilisez et devra peut-être être déterminée par expérimentation.

8. Instancier l'interprète

Nous créons une instance tflite::MicroInterpreter , en passant les variables créées précédemment :

tflite::MicroInterpreter interpreter(model, resolver, tensor_arena,
                                     tensor_arena_size, error_reporter);

9. Attribuer des tenseurs

Nous disons à l'interpréteur d'allouer de la mémoire du tensor_arena pour les tenseurs du modèle :

interpreter.AllocateTensors();

10. Valider la forme d'entrée

L'instance MicroInterpreter peut nous fournir un pointeur vers le tenseur d'entrée du modèle en appelant .input(0) , où 0 représente le premier (et unique) tenseur d'entrée :

  // Obtain a pointer to the model's input tensor
  TfLiteTensor* input = interpreter.input(0);

Nous inspectons ensuite ce tenseur pour confirmer que sa forme et son type correspondent à ce que nous attendons :

// Make sure the input has the properties we expect
TF_LITE_MICRO_EXPECT_NE(nullptr, input);
// The property "dims" tells us the tensor's shape. It has one element for
// each dimension. Our input is a 2D tensor containing 1 element, so "dims"
// should have size 2.
TF_LITE_MICRO_EXPECT_EQ(2, input->dims->size);
// The value of each element gives the length of the corresponding tensor.
// We should expect two single element tensors (one is contained within the
// other).
TF_LITE_MICRO_EXPECT_EQ(1, input->dims->data[0]);
TF_LITE_MICRO_EXPECT_EQ(1, input->dims->data[1]);
// The input is a 32 bit floating point value
TF_LITE_MICRO_EXPECT_EQ(kTfLiteFloat32, input->type);

La valeur enum kTfLiteFloat32 est une référence à l'un des types de données TensorFlow Lite et est définie dans common.h .

11. Fournissez une valeur d'entrée

Pour fournir une entrée au modèle, nous définissons le contenu du tenseur d'entrée, comme suit :

input->data.f[0] = 0.;

Dans ce cas, nous saisissons une valeur à virgule flottante représentant 0 .

12. Exécutez le modèle

Pour exécuter le modèle, nous pouvons appeler Invoke() sur notre instance tflite::MicroInterpreter :

TfLiteStatus invoke_status = interpreter.Invoke();
if (invoke_status != kTfLiteOk) {
  TF_LITE_REPORT_ERROR(error_reporter, "Invoke failed\n");
}

Nous pouvons vérifier la valeur de retour, un TfLiteStatus , pour déterminer si l'exécution a réussi. Les valeurs possibles de TfLiteStatus , définies dans common.h , sont kTfLiteOk et kTfLiteError .

Le code suivant affirme que la valeur est kTfLiteOk , ce qui signifie que l'inférence a été exécutée avec succès.

TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, invoke_status);

13. Obtenez le résultat

Le tenseur de sortie du modèle peut être obtenu en appelant output(0) sur tflite::MicroInterpreter , où 0 représente le premier (et unique) tenseur de sortie.

Dans l'exemple, la sortie du modèle est une seule valeur à virgule flottante contenue dans un tenseur 2D :

TfLiteTensor* output = interpreter.output(0);
TF_LITE_MICRO_EXPECT_EQ(2, output->dims->size);
TF_LITE_MICRO_EXPECT_EQ(1, input->dims->data[0]);
TF_LITE_MICRO_EXPECT_EQ(1, input->dims->data[1]);
TF_LITE_MICRO_EXPECT_EQ(kTfLiteFloat32, output->type);

Nous pouvons lire la valeur directement à partir du tenseur de sortie et affirmer que c'est ce à quoi nous nous attendons :

// Obtain the output value from the tensor
float value = output->data.f[0];
// Check that the output value is within 0.05 of the expected value
TF_LITE_MICRO_EXPECT_NEAR(0., value, 0.05);

14. Exécutez à nouveau l'inférence

Le reste du code exécute l’inférence plusieurs fois. Dans chaque cas, nous attribuons une valeur au tenseur d'entrée, invoquons l'interpréteur et lisons le résultat du tenseur de sortie :

input->data.f[0] = 1.;
interpreter.Invoke();
value = output->data.f[0];
TF_LITE_MICRO_EXPECT_NEAR(0.841, value, 0.05);

input->data.f[0] = 3.;
interpreter.Invoke();
value = output->data.f[0];
TF_LITE_MICRO_EXPECT_NEAR(0.141, value, 0.05);

input->data.f[0] = 5.;
interpreter.Invoke();
value = output->data.f[0];
TF_LITE_MICRO_EXPECT_NEAR(-0.959, value, 0.05);