TensorFlow Lite sur ESP32

Qu'est-ce que TensorFlow Lite ?

Étapes pour déployer sur ESP32

Former un modèle

• Commande : pip install tensorflow
• Exemple de code :

  importer numpy en tant que np
  import tensorflow as tf
  de tensorflow import keras
  
  angles = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(angles)
  model = keras.Sequential([keras.layers.Dense(1, input_shape=(1,))])
  model.compile(optimizer='adam', loss='erreur quadratique moyenne')
  model.fit(angles, sines, epochs=100, verbose=0)
  model.save('sine_model.h5')
      
    

  Copier le code ✔ Copié !

Convertir en TensorFlow Lite

• Installer l'outil : pip install tflite
• Convertir : tflite_convert --keras_model_file sine_model.h5 --output_file sine_model.tflite

Configurer ESP32

• Ajouter une URL : http://dl.espressif.com/dl/package_esp32_index.json dans les Préférences.
• Installer via le gestionnaire de cartes.
• Ajouter la bibliothèque tflite-micro depuis le dépôt GitHub aux bibliothèques Arduino.

Intégrer et exécuter

• Code:

  #include 
  #include "tflite-micro.h"
  #include "sine_model.h"
  
  tflite::MicroErrorReporter micro_error_reporter;
  tflite::ErrorReporter* error_reporter = µ_error_reporter;
  const unsigned char* model_data = sine_model;
  const size_t taille_modèle = sine_model_len;
  const tflite::Model* model = tflite::GetModel(model_data);
  tflite::AllOpsResolver résolveur;
  constexpr int kTensorArenaSize = 2000;
  uint8_t tensor_arena[kTensorArenaSize];
  tflite::MicroInterpreter interprète (modèle, résolveur, tensor_arène, kTensorArenaSize, rapporteur_d'erreurs);
  
  float randomFloat(float min, float max) {
      return min + (max - min) * (float)random(0, 10000) / 10000.0;
  }
  
  void setup() {
      Serial.begin(115200);
      interpreter.AllocateTensors();
  }
  
  boucle vide() {
      float angle = randomFloat(-3.1416, 3.1416);
      TfLiteTensor* input = interpreter.input(0);
      input->data.f[0] = angle;
      si (interpreter.Invoke() != kTfLiteOk) {
          error_reporter->Report("Échec de l'invocation du modèle");
          retour;
      }
      TfLiteTensor* output = interpreter.output(0);
      float prediction = output->data.f[0];
      Serial.print("Angle : ");
      Serial.print(angle);
      Serial.print(", Sinus prédit : ");
      Serial.println(prédiction);
      délai(1000);
  }
      
    

  Copier le code ✔ Copié !

• Téléchargez sur ESP32, ouvrez le Moniteur Série pour voir les résultats.

Détail inattendu

Déploiement de TensorFlow Lite sur ESP32

Contexte et arrière-plan

Étapes détaillées pour le déploiement

Étape 1 : Entraînement d'un modèle d'apprentissage automatique

• Installation : Installez TensorFlow avec la commande pip install tensorflow.
• Code d'entraînement : Le code suivant génère un jeu de données et entraîne le modèle :

  importer numpy en tant que np
  import tensorflow as tf
  de tensorflow import keras
  
  # Générer un ensemble de données
  angles = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(angles)
  
  # Créer un modèle de réseau neuronal simple
  modèle = keras.Sequential([
      keras.layers.Dense(1, input_shape=(1,))
  ])
  
  # Compiler le modèle
  model.compile(optimizer='adam', loss='erreur quadratique moyenne')
  
  # Entraîner le modèle
  model.fit(angles, sines, epochs=100, verbose=0)
  
  # Enregistrer le modèle
  model.save('sine_model.h5')
      
    

  Copier le code ✔ Copié !

• Notes : Ce modèle est simple, avec une couche dense, adapté aux ressources limitées de l'ESP32. Le jeu de données se compose de 1000 angles aléatoires et de leurs valeurs de sinus, entraîné pendant 100 époques avec l'optimiseur Adam et la perte d'erreur quadratique moyenne.

Étape 2 : Conversion du modèle au format TensorFlow Lite

• Installation : Installez l'outil de conversion avec pip install tflite.
• Commande de conversion : Utilisez ce qui suit pour convertir :

tflite_convert --keras_model_file sine_model.h5 --output_file sine_model.tflite
  

• Détails : Le fichier .tflite est optimisé pour la taille et la performance, ce qui est crucial pour les microcontrôleurs comme l'ESP32 avec une mémoire flash et RAM limitées.

Étape 3 : Configuration de l'environnement de développement ESP32

• Support de la carte ESP32 :
    Ouvrez l'IDE Arduino, allez dans Fichier > Préférences, et ajoutez http://dl.espressif.com/dl/package_esp32_index.json vers des URL supplémentaires du gestionnaire de cartes.
    Allez dans Outils > Carte > Gestionnaire de cartes, recherchez "esp32" et installez la dernière version.
• Bibliothèque TensorFlow Lite Micro :
    Téléchargez depuis le dépôt GitHub et ajoutez-le au répertoire des bibliothèques Arduino, ou utilisez le gestionnaire de bibliothèques si disponible.
    Assurez la compatibilité avec ESP32, car Espressif offre un support spécifique pour tflite-micro.

Étape 4 : Intégration du modèle dans le code ESP32

• Convertir en tableau C : Utilisez xxd -i sine_model.tflite > sine_model.h pour générer un fichier d'en-tête contenant les données du modèle sous forme de tableau C, généralement :

#include 
#include "tflite-micro.h"
#include "sine_model.h"

tflite::MicroErrorReporter micro_error_reporter;
tflite::ErrorReporter* error_reporter = µ_error_reporter;
const unsigned char* model_data = sine_model;
const size_t taille_modèle = sine_model_len;
const tflite::Model* model = tflite::GetModel(model_data);
tflite::AllOpsResolver résolveur;
constexpr int kTensorArenaSize = 2000;
uint8_t tensor_arena[kTensorArenaSize];
tflite::MicroInterpreter interprète (modèle, résolveur, tensor_arène, kTensorArenaSize, rapporteur_d'erreurs);

float randomFloat(float min, float max) {
    return min + (max - min) * (float)random(0, 10000) / 10000.0;
}

void setup() {
    Serial.begin(115200);
    interpreter.AllocateTensors();
}

boucle vide() {
    float angle = randomFloat(-3.1416, 3.1416);
    TfLiteTensor* input = interpreter.input(0);
    input->data.f[0] = angle;
    si (interpreter.Invoke() != kTfLiteOk) {
        error_reporter->Report("Échec de l'invocation du modèle");
        retour;
    }
    TfLiteTensor* output = interpreter.output(0);
    float prediction = output->data.f[0];
    Serial.print("Angle : ");
    Serial.print(angle);
    Serial.print(", Sinus prédit : ");
    Serial.println(prédiction);
    délai(1000);
}
  

• Notes : La fonction randomFloat génère des angles aléatoires pour les tests, en utilisant une méthode de mise à l'échelle simple. La taille de l'arène tensorielle (2000 octets) peut nécessiter un ajustement pour des modèles plus grands, compte tenu des 520 Ko de SRAM de l'ESP32.

Étape 5 : Télécharger et exécuter le code

• Procédure : Assurez-vous que la carte est correctement sélectionnée (par exemple, ESP32 Dev Module), compilez et téléversez. Ouvrez le Moniteur Série à 115200 bauds pour voir les sorties.

Considérations et défis potentiels

• Contraintes de mémoire : l'ESP32 dispose de 520 Ko de SRAM et d'une mémoire flash limitée, assurez-vous donc que le modèle et l'arène de tenseurs tiennent dans ces limites. Optimisez en réduisant la complexité du modèle ou en augmentant la taille de l'arène de tenseurs si nécessaire.
• Compatibilité de la bibliothèque : Assurez-vous que la version de la bibliothèque tflite-micro correspond aux exigences de l'ESP32, car Espressif fournit un support spécifique.
• Génération de nombres aléatoires : La fonction randomFloat utilise une méthode de mise à l'échelle simple, qui peut ne pas être précise pour toutes les applications. Envisagez d'utiliser un générateur de nombres aléatoires plus robuste pour la production.

Observation inattendue

Conclusion

Citations clés

• TinyML facile sur ESP32 et Arduino
• TensorFlow Lite Micro pour les chipsets Espressif
• Premiers pas avec ESP32 et TensorFlow Lite pour microcontrôleurs
• TensorFlow Lite TinyML pour ESP32