TensorFlow Lite på ESP32

Hvad er TensorFlow Lite?

Trin til implementering på ESP32

Træn en model

• Kommando: pip install tensorflow
• Eksempelkode:

  import numpy as np
  import tensorflow as tf
  from 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='mean_squared_error')
  model.fit(angles, sines, epochs=100, verbose=0)
  model.save('sine_model.h5')
      
    

  Kopier kode ✔ Kopieret!

Konverter til TensorFlow Lite

• Installer værktøj: pip install tflite
• Konverter: tflite_convert --keras_model_file sine_model.h5 --output_file sine_model.tflite

Opsæt ESP32

• Tilføj URL: http://dl.espressif.com/dl/package_esp32_index.json i Indstillinger.
• Installer via Board Manager.
• Tilføj tflite-micro biblioteket fra GitHub repository til Arduino-biblioteker.

Integrer og kør

• Kode:

  #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 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 loop() {
      float vinkel = randomFloat(-3.1416, 3.1416);
      TfLiteTensor* input = interpreter.input(0);
      input->data.f[0] = angle;
      if (interpreter.Invoke() != kTfLiteOk) {
          error_reporter->Report("Failed to invoke model");
          return;
      }
      TfLiteTensor* output = interpreter.output(0);
      float prediction = output->data.f[0];
      Serial.print("Angle: ");
      Serial.print(angle);
      Serial.print(", Predicted sine: ");
      Serial.println(prediction);
      delay(1000);
  }
      
    

  Kopier kode ✔ Kopieret!

• Upload til ESP32, åbn Serial Monitor for at se resultater.

Uventet detalje

Implementering af TensorFlow Lite på ESP32

Baggrund og kontekst

Detaljerede trin for implementering

Trin 1: Træning af en maskinlæringsmodel

• Installation: Installer TensorFlow med kommandoen pip install tensorflow.
• Træningskode: Følgende kode genererer et datasæt og træner modellen:

  import numpy as np
  import tensorflow as tf
  from tensorflow import keras
  
  # Generer datasæt
  angles = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(angles)
  
  # Opret en simpel neuralt netværksmodel
  model = keras.Sequential([
      keras.layers.Dense(1, input_shape=(1,))
  ])
  
  # Kompiler modellen
  model.compile(optimizer='adam', loss='mean_squared_error')
  
  # Træn modellen
  model.fit(angles, sines, epochs=100, verbose=0)
  
  # Gem modellen
  model.save('sine_model.h5')
      
    

  Kopier kode ✔ Kopieret!

• Bemærkninger: Denne model er simpel, med et enkelt dense lag, egnet til ESP32's begrænsede ressourcer. Datasættet består af 1000 tilfældige vinkler og deres sinusværdier, trænet i 100 epoker med Adam-optimering og middel kvadreret fejl som tab.

Trin 2: Konvertering af modellen til TensorFlow Lite-format

• Installation: Installer konverteringsværktøjet med pip install tflite.
• Konverteringskommando: Brug følgende til at konvertere:

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

• Detaljer: .tflite-filen er optimeret til størrelse og ydeevne, hvilket er afgørende for mikrokontrollere som ESP32 med begrænset flash og RAM.

Trin 3: Opsætning af ESP32-udviklingsmiljø

• ESP32 Board Support:
    Åbn Arduino IDE, gå til Filer > Indstillinger, og tilføj http://dl.espressif.com/dl/package_esp32_index.json til Yderligere Board Manager-URL'er.
    Gå til Værktøjer > Board > Board Manager, søg efter "esp32", og installer den nyeste version.
• TensorFlow Lite Micro-bibliotek:
    Download fra GitHub-repositoriet og tilføj til Arduino-biblioteksbiblioteket, eller brug Library Manager hvis tilgængelig.
    Sørg for kompatibilitet med ESP32, da Espressif tilbyder specifik support til tflite-micro.

Trin 4: Integrering af modellen i ESP32-kode

• Konverter til C-array: Brug xxd -i sine_model.tflite > sine_model.h for at generere en headerfil, der indeholder modeldata som et C-array, typisk:

#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 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 loop() {
    float vinkel = randomFloat(-3.1416, 3.1416);
    TfLiteTensor* input = interpreter.input(0);
    input->data.f[0] = angle;
    if (interpreter.Invoke() != kTfLiteOk) {
        error_reporter->Report("Failed to invoke model");
        return;
    }
    TfLiteTensor* output = interpreter.output(0);
    float prediction = output->data.f[0];
    Serial.print("Angle: ");
    Serial.print(angle);
    Serial.print(", Predicted sine: ");
    Serial.println(prediction);
    delay(1000);
}
  

• Noter: Funktionen randomFloat genererer tilfældige vinkler til test ved hjælp af en simpel skalering. Tensor arenaens størrelse (2000 bytes) kan kræve justering for større modeller, givet ESP32's 520 KB SRAM.

Trin 5: Upload og kør koden

• Fremgangsmåde: Sørg for, at boardet er valgt korrekt (f.eks. ESP32 Dev Module), kompiler og upload. Åbn Serial Monitor ved 115200 baud for at se output.

Overvejelser og potentielle udfordringer

• Hukommelsesbegrænsninger: ESP32 har 520 KB SRAM og begrænset flash, så sørg for, at modellen og tensor arenaen passer inden for disse grænser. Optimer ved at reducere modelkompleksiteten eller øge tensor arenaens størrelse, hvis det er nødvendigt.
• Bibliotekskompatibilitet: Sørg for, at tflite-micro bibliotekets version matcher ESP32-kravene, da Espressif leverer specifik support.
• Tilfældig talgenerering: Funktionen randomFloat bruger en simpel skalering, som måske ikke er præcis til alle anvendelser. Overvej at bruge en mere robust tilfældig talgenerator til produktion.

Uventet observation

Konklusion

Vigtige henvisninger

• Nem TinyML på ESP32 og Arduino
• TensorFlow Lite Micro til Espressif-chipsets
• Første skridt med ESP32 og TensorFlow Lite til mikrokontrollere
• TensorFlow Lite TinyML til ESP32