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 als tf
  van tensorflow importeer 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.
• Installeren via Board Manager.
• Voeg de tflite-micro bibliotheek toe van de GitHub repository aan de Arduino bibliotheken.

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 willekeurigeFloat(float min, float max) {
      return min + (max - min) * (float)random(0, 10000) / 10000.0;
  }
  
  lege setup() {
      Serial.begin(115200);
      interpreter.AllocateTensors();
  }
  
  lege lus() {
      float hoek = randomFloat(-3.1416, 3.1416);
      TfLiteTensor* invoer = interpreter.input(0);
      input->data.f[0] = hoek;
      if (interpreter.Invoke() != kTfLiteOk) {
          error_reporter->Report("Mislukt om model aan te roepen");
          opbrengst;
      }
      TfLiteTensor* output = interpreter.output(0);
      float voorspelling = output->data.f[0];
      Serial.print("Hoek: ");
      Serial.print(hoek);
      Serial.print(", Voorspelde sinus: ");
      Serial.println(voorspelling);
      vertraging(1000);
  }
      
    

  Kopieer code ✔ Gekopieerd!

• Upload 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: Het trainen van een machine learning-model

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

  importeer numpy als np
  import tensorflow als tf
  van tensorflow importeer 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!

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

Stap 2: Het model converteren naar TensorFlow Lite-formaat

• 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 ESP32 met beperkte flash en RAM.

Stap 3: Het opzetten van de ESP32-ontwikkelomgeving

• ESP32 Boardondersteuning:
    Open Arduino IDE, ga naar Bestand > Voorkeuren, en voeg toe http://dl.espressif.com/dl/package_esp32_index.json naar Extra Board Manager-URL's.
    Ga naar Gereedschappen > Bord > Bordbeheer, zoek naar "esp32" en installeer de nieuwste versie.
• TensorFlow Lite Micro Bibliotheek:
    Download van GitHub repository en voeg toe aan de Arduino bibliotheekmap, of gebruik Library Manager indien beschikbaar.
    Zorg voor compatibiliteit met ESP32, aangezien Espressif specifieke ondersteuning biedt voor tflite-micro.

Stap 4: Het integreren van het model in ESP32-code

• Converteren 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, meestal:

#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 willekeurigeFloat(float min, float max) {
    return min + (max - min) * (float)random(0, 10000) / 10000.0;
}

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

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

• Opmerkingen: De functie randomFloat 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 uitvoer te zien.

Overwegingen en potentiële uitdagingen

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

Onverwachte Observatie

Conclusie

Belangrijke citaten

• Gemakkelijke 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