TensorFlow Lite sur ESP32

Qu'est-ce que TensorFlow Lite ?

Étapes pour déployer sur ESP32

Entraîner 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)
  modèle = keras.Sequential([keras.layers.Dense(1, input_shape=(1,))])
  model.compile(optimizer='adam', loss='mean_squared_error')
  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.
• Ajoutez 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 model_size = 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éteur(modèle, résolveur, arène_tensor, kTailleArèneTensor, rapporteur_d'erreurs);
  
  float randomFloat(float min, float max) {
      retourner min + (max - min) * (float)random(0, 10000) / 10000.0;
  }
  
  configuration vide() {
      Série.begin(115200);
      interpreter.AllouerTenseurs();
  }
  
  boucle vide() {
      float angle = randomFloat(-3.1416, 3.1416);
      TfLiteTensor* input = interpreter.input(0);
      input->data.f[0] = angle;
      if (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(", Sine prédit : ");
      Serial.println(prévision);
      délai(1000);
  }
  
  
  

  Copier le code ✔ Copié !

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

Détail inattendu

Déployer TensorFlow Lite sur ESP32

Contexte et arrière-plan

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

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

• Installation : Installez TensorFlow avec la commande pip install tensorflow.
• Code de formation : Le code suivant génère un ensemble 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 de neurones simple
  modèle = keras.Sequential([
      keras.layers.Dense(1, input_shape=(1,))
  ])
  
  # Compiler le modèle
  model.compile(optimizer='adam', loss='mean_squared_error')
  
  # 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é !

• Remarques : Ce modèle est simple, avec une couche dense, adapté aux ressources limitées de l'ESP32. L'ensemble 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 les performances, 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 tableau.
    Allez dans Outils > Tableau > Gestionnaire de tableaux, 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-vous de la compatibilité avec l'ESP32, car Espressif fournit 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, typiquement :

#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 model_size = 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éteur(modèle, résolveur, arène_tensor, kTailleArèneTensor, rapporteur_d'erreurs);

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

configuration vide() {
    Série.begin(115200);
    interpreter.AllouerTenseurs();
}

boucle vide() {
    float angle = randomFloat(-3.1416, 3.1416);
    TfLiteTensor* input = interpreter.input(0);
    input->data.f[0] = angle;
    if (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(", Sine prédit : ");
    Serial.println(prévision);
    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 de tenseurs (2000 octets) peut nécessiter un ajustement pour des modèles plus grands, étant donné les 520 Ko de SRAM de l'ESP32.

Étape 5 : Téléchargez et exécutez le code

• Procédure : Assurez-vous que la carte est sélectionnée correctement (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, donc assurez-vous que le modèle et l'arène de tenseurs s'inscrivent 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

• Easy TinyML 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