TensorFlow Lite Op ESP32

Wat is TensorFlow Lite?

Stappen om te implementeren op ESP32

Train een model

• Opdracht: pip install tensorflow
• Voorbeeldcode:

  importeer numpy als np
  import tensorflow as tf
  van tensorflow import keras
  
  hoeken = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(hoeken)
  model = keras.Sequential([keras.layers.Dense(1, input_shape=(1,))])
  model.compile(optimizer='adam', loss='mean_squared_error')
  model.fit(hoeken, sinussen, epochs=100, verbose=0)
  model.save('sine_model.h5')
  
  
  

  Kopieer code ✔ Gekopieerd!

Converteren naar TensorFlow Lite

• Installeer tool: pip install tflite
• Converteer: tflite_convert --keras_model_file sine_model.h5 --output_file sine_model.tflite

ESP32 instellen

• URL toevoegen: http://dl.espressif.com/dl/package_esp32_index.json in Voorkeuren.
• Installeer via Board Manager.
• Voeg de tflite-micro bibliotheek toe van GitHub-repository aan de Arduino-bibliotheken toe.

Integreren en uitvoeren

• 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 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;
  }
  
  lege instellingen() {
      Serial.begin(115200);
      interpreter.AllocateTensors();
  }
  
  lege lus() {
      float hoek = randomFloat(-3.1416, 3.1416);
      TfLiteTensor* input = interpreter.input(0);
      input->data.f[0] = hoek;
      if (interpreter.Invoke() != kTfLiteOk) {
          error_reporter->Report("Kon model niet aanroepen");
          opbrengst;
      }
      TfLiteTensor* output = interpreter.output(0);
      float voorspelling = output->data.f[0];
      Serial.print("Hoek: ");
      Serial.print(angle);
      Serial.print(", Voorspelde sinus: ");
      Serial.println(voorspelling);
      vertraging(1000);
  }
  
  
  

  Kopieer code ✔ Gekopieerd!

• Uploaden naar ESP32, open de Seriële Monitor om de resultaten te zien.

Onverwachte details

TensorFlow Lite implementeren op ESP32

Achtergrond en Context

Gedetailleerde Stappen voor Implementatie

Stap 1: Een Machine Learning Model Trainen

• Installatie: Installeer TensorFlow met de opdracht pip install tensorflow.
• Trainingscode: De volgende code genereert een dataset en traint het model:

  importeer numpy als np
  import tensorflow as tf
  van tensorflow import keras
  
  # Dataset genereren
  hoeken = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(hoeken)
  
  # Maak een eenvoudig neuraal netwerkmodel
  model = keras.Sequential([
      keras.layers.Dense(1, input_shape=(1,))
  ])
  
  # Compileer het model
  model.compile(optimizer='adam', loss='mean_squared_error')
  
  # Train het model
  model.fit(hoeken, sinussen, epochs=100, verbose=0)
  
  # Sla het model op
  model.save('sine_model.h5')
  
  
  

  Kopieer code ✔ Gekopieerd!

• Notities: Dit model is eenvoudig, met één dichte laag, geschikt voor de beperkte middelen van de ESP32. De dataset bestaat uit 1000 willekeurige hoeken en hun sinuswaarden, getraind voor 100 epochs met de Adam-optimizer en de mean squared error-verliesfunctie.

Stap 2: Het model omzetten naar TensorFlow Lite-indeling

• Installatie: Installeer de conversietool met pip install tflite.
• Conversieopdracht: Gebruik het volgende om te converteren:

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

• Details: Het .tflite-bestand is geoptimaliseerd voor grootte en prestaties, cruciaal voor microcontrollers zoals de ESP32 met beperkte flash en RAM.

Stap 3: Het instellen van de ESP32-ontwikkelomgeving

• ESP32 Bordondersteuning:
    Open Arduino IDE, ga naar Bestand > Voorkeuren, en voeg toe http://dl.espressif.com/dl/package_esp32_index.json naar aanvullende URL's van het bestuursbeheer.
    Ga naar Hulpmiddelen > Bord > Bordbeheer, zoek naar "esp32" en installeer de nieuwste versie.
• TensorFlow Lite Micro Bibliotheek:
    Download van GitHub-repository en voeg toe aan de Arduino-bibliotheekdirectory, of gebruik de Bibliotheekbeheerder als deze beschikbaar is.
    Zorg voor compatibiliteit met ESP32, aangezien Espressif specifieke ondersteuning biedt voor tflite-micro.

Stap 4: Het model integreren in ESP32-code

• Converteer naar C-array: Gebruik xxd -i sine_model.tflite > sine_model.h om een headerbestand te genereren dat de modelgegevens als een C-array bevat, typisch:

#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;
}

lege instellingen() {
    Serial.begin(115200);
    interpreter.AllocateTensors();
}

lege lus() {
    float hoek = randomFloat(-3.1416, 3.1416);
    TfLiteTensor* input = interpreter.input(0);
    input->data.f[0] = hoek;
    if (interpreter.Invoke() != kTfLiteOk) {
        error_reporter->Report("Kon model niet aanroepen");
        opbrengst;
    }
    TfLiteTensor* output = interpreter.output(0);
    float voorspelling = output->data.f[0];
    Serial.print("Hoek: ");
    Serial.print(angle);
    Serial.print(", Voorspelde sinus: ");
    Serial.println(voorspelling);
    vertraging(1000);
}

• Notities: De randomFloat functie genereert willekeurige hoeken voor testen, met behulp van een eenvoudige schaalmethode. De tensor arena grootte (2000 bytes) moet mogelijk worden aangepast voor grotere modellen, gezien de 520 KB SRAM van de ESP32.

Stap 5: Upload en voer de code uit

• Procedure: Zorg ervoor dat het bord correct is geselecteerd (bijv. ESP32 Dev Module), compileer en upload. Open de Seriële Monitor op 115200 baud om de uitvoer te zien.

Overwegingen en Potentiële Uitdagingen

• Geheugenbeperkingen: ESP32 heeft 520 KB SRAM en beperkte flash, dus zorg ervoor dat het model en de tensorarena binnen deze limieten passen. Optimaliseer door de modelcomplexiteit te verminderen of de grootte van de tensorarena te vergroten indien nodig.
• Bibliotheekcompatibiliteit: Zorg ervoor dat de tflite-micro bibliotheekversie overeenkomt met de vereisten van de ESP32, aangezien Espressif specifieke ondersteuning biedt.
• Willekeurige Getalgeneratie: De randomFloat functie gebruikt een eenvoudige schaalmethode, die mogelijk niet nauwkeurig is voor alle toepassingen. Overweeg om een robuustere willekeurige getalgenerator te gebruiken voor productie.

Onverwachte Waarneming

Conclusie

Belangrijkste citaten

• Eenvoudige TinyML op ESP32 en Arduino
• TensorFlow Lite Micro voor Espressif-chipsets
• Eerste stappen met ESP32 en TensorFlow Lite voor microcontrollers
• TensorFlow Lite TinyML voor ESP32