TensorFlow Lite auf ESP32

Was ist TensorFlow Lite?

Schritte zur Bereitstellung auf ESP32

Trainieren eines Modells

• Befehl: pip install tensorflow
• Beispielcode:

  importiere Numpy als np
  importiere tensorflow als tf
  von tensorflow import keras
  
  Winkel = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(winkel)
  model = keras.Sequential([keras.layers.Dense(1, input_shape=(1,))])
  model.compile(optimizer='adam', loss='mean_squared_error')
  model.fit(winkel, sinuswerte, epochen=100, ausgabe=0)
  model.save('sine_model.h5')
      
    

  Code kopieren ✔ Kopiert!

In TensorFlow Lite konvertieren

• Installationswerkzeug: pip install tflite
• Konvertieren: tflite_convert --keras_model_file sine_model.h5 --output_file sine_model.tflite

ESP32 einrichten

• URL hinzufügen: http://dl.espressif.com/dl/package_esp32_index.json in den Einstellungen.
• Über den Board-Manager installieren.
• Fügen Sie die tflite-micro-Bibliothek aus dem GitHub-Repository zu den Arduino-Bibliotheken hinzu.

Integrieren und ausführen

• 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* modell = tflite::GetModel(model_daten);
  tflite::AllOpsResolver resolver;
  constexpr int kTensorArenaSize = 2000;
  uint8_t tensor_arena[kTensorArenaSize];
  tflite::MicroInterpreter Interpreter(Modell, Resolver, Tensor_Arena, kTensorArenaSize, Fehlerbericht) ;
  
  float zufälligeGleitkommazahl(float min, float max) {
      return min + (max - min) * (float)random(0, 10000) / 10000.0;
  }
  
  void setup() {
      Serial.begin(115200);
      interpreter.AllocateTensors();
  }
  
  void-Schleife() {
      float winkel = randomFloat(-3.1416, 3.1416);
      TfLiteTensor* Eingabe = interpreter.input(0);
      input->data.f[0] = Winkel;
      if (interpreter.Invoke() != kTfLiteOk) {
          error_reporter->Report("Modell konnte nicht aufgerufen werden");
          zurückkehren;
      }
      TfLiteTensor* Ausgabe = interpreter.output(0);
      float Vorhersage = output->data.f[0];
      Serial.print("Winkel: ");
      Serial.print(Winkel);
      Serial.print(", Vorhergesagte Sinuskurve: ");
      Serial.println(Vorhersage);
      Verzögerung (1000);
  }
      
    

  Code kopieren ✔ Kopiert!

• Auf ESP32 hochladen, Serial Monitor öffnen, um Ergebnisse zu sehen.

Unerwartetes Detail

TensorFlow Lite auf ESP32 bereitstellen

Hintergrund und Kontext

Detaillierte Schritte für die Bereitstellung

Schritt 1: Training eines Machine-Learning-Modells

• Installation: Installieren Sie TensorFlow mit dem Befehl pip install tensorflow.
• Trainingscode: Der folgende Code erzeugt einen Datensatz und trainiert das Modell:

  importiere Numpy als np
  importiere tensorflow als tf
  von tensorflow import keras
  
  # Datensatz generieren
  Winkel = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(winkel)
  
  # Erstellen Sie ein einfaches neuronales Netzwerkmodell
  model = keras.Sequential([
      keras.layers.Dense(1, input_shape=(1,))
  ])
  
  # Kompilieren Sie das Modell
  model.compile(optimizer='adam', loss='mean_squared_error')
  
  # Trainieren Sie das Modell
  model.fit(winkel, sinuswerte, epochen=100, ausgabe=0)
  
  # Speichern Sie das Modell
  model.save('sine_model.h5')
      
    

  Code kopieren ✔ Kopiert!

• Hinweise: Dieses Modell ist einfach, mit einer dichten Schicht, geeignet für die begrenzten Ressourcen des ESP32. Der Datensatz besteht aus 1000 zufälligen Winkeln und deren Sinuswerten, trainiert über 100 Epochen mit dem Adam-Optimierer und mittlerem quadratischem Fehler als Verlustfunktion.

Schritt 2: Umwandlung des Modells in das TensorFlow Lite-Format

• Installation: Installieren Sie das Konvertierungstool mit pip install tflite.
• Konvertierungsbefehl: Verwenden Sie Folgendes zur Umwandlung:

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

• Details: Die .tflite-Datei ist für Größe und Leistung optimiert, was für Mikrocontroller wie den ESP32 mit begrenztem Flash und RAM entscheidend ist.

Schritt 3: Einrichtung der ESP32-Entwicklungsumgebung

• ESP32 Board-Unterstützung:
    Öffnen Sie die Arduino IDE, gehen Sie zu Datei > Einstellungen, und fügen Sie hinzu http://dl.espressif.com/dl/package_esp32_index.json zu zusätzlichen Board-Manager-URLs.
    Gehe zu Werkzeuge > Board > Board-Verwalter, suche nach "esp32" und installiere die neueste Version.
• TensorFlow Lite Micro Bibliothek:
    Laden Sie es aus dem GitHub-Repository herunter und fügen Sie es dem Arduino-Bibliotheksverzeichnis hinzu, oder verwenden Sie den Bibliotheksmanager, falls verfügbar.
    Stellen Sie die Kompatibilität mit ESP32 sicher, da Espressif spezifische Unterstützung für tflite-micro bietet.

Schritt 4: Integration des Modells in den ESP32-Code

• In ein C-Array umwandeln: Verwenden Sie xxd -i sine_model.tflite > sine_model.h, um eine Header-Datei zu erzeugen, die die Modelldaten als C-Array enthält, typischerweise:

#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* modell = tflite::GetModel(model_daten);
tflite::AllOpsResolver resolver;
constexpr int kTensorArenaSize = 2000;
uint8_t tensor_arena[kTensorArenaSize];
tflite::MicroInterpreter Interpreter(Modell, Resolver, Tensor_Arena, kTensorArenaSize, Fehlerbericht) ;

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

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

void-Schleife() {
    float winkel = randomFloat(-3.1416, 3.1416);
    TfLiteTensor* Eingabe = interpreter.input(0);
    input->data.f[0] = Winkel;
    if (interpreter.Invoke() != kTfLiteOk) {
        error_reporter->Report("Modell konnte nicht aufgerufen werden");
        zurückkehren;
    }
    TfLiteTensor* Ausgabe = interpreter.output(0);
    float Vorhersage = output->data.f[0];
    Serial.print("Winkel: ");
    Serial.print(Winkel);
    Serial.print(", Vorhergesagte Sinuskurve: ");
    Serial.println(Vorhersage);
    Verzögerung (1000);
}
  

• Hinweise: Die Funktion randomFloat erzeugt zufällige Winkel zum Testen, indem eine einfache Skalierungsmethode verwendet wird. Die Größe des Tensor-Areals (2000 Bytes) muss möglicherweise für größere Modelle angepasst werden, da der ESP32 über 520 KB SRAM verfügt.

Schritt 5: Code hochladen und ausführen

• Vorgehensweise: Stellen Sie sicher, dass das Board korrekt ausgewählt ist (z. B. ESP32 Dev Module), kompilieren Sie und laden Sie hoch. Öffnen Sie den Serial Monitor mit 115200 Baud, um Ausgaben zu sehen.

Überlegungen und potenzielle Herausforderungen

• Speicherbeschränkungen: Der ESP32 verfügt über 520 KB SRAM und begrenzten Flash-Speicher, daher muss sichergestellt werden, dass das Modell und der Tensorbereich innerhalb dieser Grenzen passen. Optimieren Sie, indem Sie die Modellkomplexität reduzieren oder die Größe des Tensorbereichs bei Bedarf erhöhen.
• Bibliothekskompatibilität: Stellen Sie sicher, dass die Version der tflite-micro-Bibliothek den Anforderungen des ESP32 entspricht, da Espressif spezifische Unterstützung bietet.
• Zufallszahlengenerierung: Die Funktion randomFloat verwendet eine einfache Skalierungsmethode, die möglicherweise nicht für alle Anwendungen präzise ist. Erwägen Sie die Verwendung eines robusteren Zufallszahlengenerators für die Produktion.

Unerwartete Beobachtung

Abschluss

Wichtige Zitate

• Einfaches TinyML auf ESP32 und Arduino
• TensorFlow Lite Micro für Espressif-Chipsätze
• Erste Schritte mit ESP32 und TensorFlow Lite für Mikrocontroller
• TensorFlow Lite TinyML für ESP32