TensorFlow Lite på ESP32

Vad är TensorFlow Lite?

Steg för att distribuera på ESP32

Träna en modell

• Kommando: pip install tensorflow
• Exempel på kod:

  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')
      
    

  Kopiera kod ✔ Kopierat!

Konvertera till TensorFlow Lite

• Installera verktyg: pip install tflite
• Konvertera: tflite_convert --keras_model_file sine_model.h5 --output_file sine_model.tflite

Ställ in ESP32

• Lägg till URL: http://dl.espressif.com/dl/package_esp32_index.json i Inställningar.
• Installera via Board Manager.
• Lägg till tflite-micro-biblioteket från GitHub-förråd till Arduino-biblioteken.

Integrera och kör

• Kod:

  #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 angle = 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);
  }
      
    

  Kopiera kod ✔ Kopierat!

• Ladda upp till ESP32, öppna Serial Monitor för att se resultat.

Oväntad detalj

Distribuera TensorFlow Lite på ESP32

Bakgrund och kontext

Detaljerade steg för distribution

Steg 1: Träna en maskininlärningsmodell

• Installation: Installera TensorFlow med kommandot pip install tensorflow.
• Träningskod: Följande kod genererar ett dataset och tränar modellen:

  import numpy as np
  import tensorflow as tf
  from tensorflow import keras
  
  # Generera dataset
  angles = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(angles)
  
  # Skapa en enkel neuralt nätverksmodell
  model = keras.Sequential([
      keras.layers.Dense(1, input_shape=(1,))
  ])
  
  # Kompilera modellen
  model.compile(optimizer='adam', loss='mean_squared_error')
  
  # Träna modellen
  model.fit(angles, sines, epochs=100, verbose=0)
  
  # Spara modellen
  model.save('sine_model.h5')
      
    

  Kopiera kod ✔ Kopierat!

• Noteringar: Denna modell är enkel, med ett dense-lager, lämplig för ESP32:s begränsade resurser. Datasetet består av 1000 slumpmässiga vinklar och deras sinusvärden, tränade i 100 epoker med Adam-optimeraren och medelkvadratfel som förlustfunktion.

Steg 2: Konvertera modellen till TensorFlow Lite-format

• Installation: Installera konverteringsverktyget med pip install tflite.
• Konverteringskommando: Använd följande för att konvertera:

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

• Detaljer: .tflite-filen är optimerad för storlek och prestanda, vilket är avgörande för mikrokontroller som ESP32 med begränsat flashminne och RAM.

Steg 3: Ställa in ESP32-utvecklingsmiljön

• ESP32-kortstöd:
    Öppna Arduino IDE, gå till Arkiv > Inställningar och lägg till http://dl.espressif.com/dl/package_esp32_index.json till Ytterligare URL:er för Korthanteraren.
    Gå till Verktyg > Kort > Korthanterare, sök efter "esp32" och installera den senaste versionen.
• TensorFlow Lite Micro-bibliotek:
    Ladda ner från GitHub-förråd och lägg till i Arduino-bibliotekskatalogen, eller använd Library Manager om det finns.
    Säkerställ kompatibilitet med ESP32, eftersom Espressif tillhandahåller specifikt stöd för tflite-micro.

Steg 4: Integrera modellen i ESP32-koden

• Konvertera till C-array: Använd xxd -i sine_model.tflite > sine_model.h för att generera en headerfil som innehåller modelldata som en C-array, vanligtvis:

#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 angle = 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);
}
  

• Noteringar: Funktionen randomFloat genererar slumpmässiga vinklar för testning, med en enkel skalningsmetod. Tensorarenans storlek (2000 byte) kan behöva justeras för större modeller, med tanke på ESP32:s 520 KB SRAM.

Steg 5: Ladda upp och kör koden

• Procedur: Säkerställ att kortet är korrekt valt (t.ex. ESP32 Dev Module), kompilera och ladda upp. Öppna Serial Monitor på 115200 baud för att se utskrifter.

Överväganden och potentiella utmaningar

• Minnesbegränsningar: ESP32 har 520 KB SRAM och begränsat flashminne, så se till att modellen och tensorarenan får plats inom dessa gränser. Optimera genom att minska modellens komplexitet eller öka tensorarenans storlek vid behov.
• Bibliotekskompatibilitet: Säkerställ att tflite-micro-bibliotekets version matchar ESP32-kraven, eftersom Espressif tillhandahåller specifikt stöd.
• Slumpgenerering: Funktionen randomFloat använder en enkel skalningsmetod, vilket kanske inte är exakt för alla tillämpningar. Överväg att använda en mer robust slumpgenerator för produktion.

Oväntad observation

Slutsats

Viktiga referenser

• Enkel TinyML på ESP32 och Arduino
• TensorFlow Lite Micro för Espressif-chipset
• Första stegen med ESP32 och TensorFlow Lite för mikrokontroller
• TensorFlow Lite TinyML för ESP32