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
  import tensorflow as tf
  von tensorflow import keras
  
  winkel = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(Winkel)
  modell = 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')
  
  
  

  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 mikro_fehler_berichtserstatter;
  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 resolver;
  constexpr int kTensorArenaSize = 2000;
  uint8_t tensor_arena[kTensorArenaSize];
  tflite::MicroInterpreter interpreter(model, resolver, tensor_arena, kTensorArenaSize, error_reporter);
  
  float randomFloat(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* input = interpreter.input(0);
      input->data.f[0] = winkel;
      if (interpreter.Invoke() != kTfLiteOk) {
          error_reporter->Report("Modellaufruf fehlgeschlagen");
          zurückkehren;
      }
      TfLiteTensor* output = interpreter.output(0);
      float vorhersage = output->data.f[0];
      Serial.print("Winkel: ");
      Serial.print(Winkel);
      Serial.print(", Vorhergesagte Sinus: ");
      Serial.println(Vorhersage);
      Verzögerung (1000);
  }
  
  
  

  Code kopieren ✔ Kopiert!

• Laden Sie auf ESP32 hoch, öffnen Sie den Serial Monitor, um die Ergebnisse zu sehen.

Unerwartetes Detail

TensorFlow Lite auf ESP32 bereitstellen

Hintergrund und Kontext

Detaillierte Schritte für die Bereitstellung

Schritt 1: Ein Machine Learning Modell trainieren

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

  importiere Numpy als np
  import tensorflow as tf
  von tensorflow import keras
  
  # Datensatz generieren
  winkel = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(Winkel)
  
  # Erstelle ein einfaches neuronales Netzwerkmodell
  modell = 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(angles, sines, epochs=100, verbose=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 ihren Sinuswerten, trainiert über 100 Epochen mit dem Adam-Optimierer und dem Verlust der mittleren quadratischen Abweichung.

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

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

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-Speicher und RAM entscheidend ist.

Schritt 3: Einrichten 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 > Boardverwalter, suche nach "esp32" und installiere die neueste Version.
• TensorFlow Lite Micro-Bibliothek:
    Laden Sie von 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 C-Array umwandeln: Verwenden Sie xxd -i sine_model.tflite > sine_model.h, um eine Header-Datei zu generieren, die die Modelldaten als C-Array enthält, typischerweise:

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

tflite::MicroErrorReporter mikro_fehler_berichtserstatter;
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 resolver;
constexpr int kTensorArenaSize = 2000;
uint8_t tensor_arena[kTensorArenaSize];
tflite::MicroInterpreter interpreter(model, resolver, tensor_arena, kTensorArenaSize, error_reporter);

float randomFloat(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* input = interpreter.input(0);
    input->data.f[0] = winkel;
    if (interpreter.Invoke() != kTfLiteOk) {
        error_reporter->Report("Modellaufruf fehlgeschlagen");
        zurückkehren;
    }
    TfLiteTensor* output = interpreter.output(0);
    float vorhersage = output->data.f[0];
    Serial.print("Winkel: ");
    Serial.print(Winkel);
    Serial.print(", Vorhergesagte Sinus: ");
    Serial.println(Vorhersage);
    Verzögerung (1000);
}

• Hinweise: Die randomFloat-Funktion generiert zufällige Winkel für Tests, indem sie eine einfache Skalierungsmethode verwendet. Die Größe des Tensor-Arena (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

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

Überlegungen und potenzielle Herausforderungen

• Speicherbeschränkungen: Der ESP32 verfügt über 520 KB SRAM und begrenzten Flash-Speicher. Stellen Sie daher sicher, 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 randomFloat-Funktion verwendet eine einfache Skalierungsmethode, die möglicherweise nicht für alle Anwendungen präzise ist. Ziehen Sie in Betracht, einen robusteren Zufallszahlengenerator für die Produktion zu verwenden.

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