TensorFlow Lite na ESP32

Co je TensorFlow Lite?

Kroky k nasazení na ESP32

Trénování modelu

• Příkaz: pip install tensorflow
• Příklad kódu:

  importovat numpy jako np
  import tensorflow as tf
  z tensorflow import keras
  
  úhly = 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')
      
    

  Kopírovat kód ✔ Zkopírováno!

Převést na TensorFlow Lite

• Nainstalujte nástroj: pip install tflite
• Převést: tflite_convert --keras_model_file sine_model.h5 --output_file sine_model.tflite

Nastavení ESP32

• Přidat URL: http://dl.espressif.com/dl/package_esp32_index.json v Předvolbách.
• Nainstalujte přes Správce desek.
• Přidejte knihovnu tflite-micro z GitHub repozitáře do knihoven Arduino.

Integrovat a spustit

• Kód:

  #include 
  #include "tflite-micro.h"
  #include "sine_model.h"
  
  tflite::MicroErrorReporter mikro_chybový_reportér;
  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 řešič;
  constexpr int kTensorArenaSize = 2000;
  uint8_t tensor_arena[kTensorArenaSize];
  tflite::MicroInterpreter interpreter(model, resolver, tensor_arena, kTensorArenaSize, error_reporter);
  
  float náhodnéFloat(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* vstup = interpreter.input(0);
      input->data.f[0] = úhel;
      if (interpreter.Invoke() != kTfLiteOk) {
          error_reporter->Report("Nepodařilo se vyvolat model");
          návrat;
      }
      TfLiteTensor* output = interpreter.output(0);
      float predikce = output->data.f[0];
      Serial.print("Úhel: ");
      Serial.print(úhel);
      Serial.print(", Predikovaný sinus: ");
      Serial.println(předpověď);
      zpoždění(1000);
  }
      
    

  Kopírovat kód ✔ Zkopírováno!

• Nahrajte do ESP32, otevřete Serial Monitor pro zobrazení výsledků.

Neočekávaný detail

Nasazení TensorFlow Lite na ESP32

Pozadí a kontext

Podrobné kroky pro nasazení

Krok 1: Trénink modelu strojového učení

• Instalace: Nainstalujte TensorFlow příkazem pip install tensorflow.
• Kód pro trénink: Následující kód generuje datovou sadu a trénuje model:

  importovat numpy jako np
  import tensorflow as tf
  z tensorflow import keras
  
  # Generování datové sady
  úhly = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(angles)
  
  # Vytvořit jednoduchý model neuronové sítě
  model = keras.Sequential([
      keras.layers.Dense(1, input_shape=(1,))
  ])
  
  # Zkompilujte model
  model.compile(optimizer='adam', loss='mean_squared_error')
  
  # Trénování modelu
  model.fit(angles, sines, epochs=100, verbose=0)
  
  # Uložit model
  model.save('sine_model.h5')
      
    

  Kopírovat kód ✔ Zkopírováno!

• Poznámky: Tento model je jednoduchý, s jednou hustou vrstvou, vhodný pro omezené zdroje ESP32. Datová sada se skládá z 1000 náhodných úhlů a jejich hodnot sinusů, trénovaných po dobu 100 epoch s optimalizátorem Adam a ztrátovou funkcí střední kvadratické chyby.

Krok 2: Převod modelu do formátu TensorFlow Lite

• Instalace: Nainstalujte konverzní nástroj pomocí pip install tflite.
• Příkaz pro převod: Použijte následující k převodu:

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

• Detaily: Soubor .tflite je optimalizován pro velikost a výkon, což je zásadní pro mikrokontroléry jako ESP32 s omezenou flash pamětí a RAM.

Krok 3: Nastavení vývojového prostředí ESP32

• Podpora desky ESP32:
    Otevřete Arduino IDE, přejděte na Soubor > Předvolby a přidejte http://dl.espressif.com/dl/package_esp32_index.json na další URL adresy Správce desek.
    Přejděte na Nástroje > Deska > Správce desek, vyhledejte "esp32" a nainstalujte nejnovější verzi.
• Knihovna TensorFlow Lite Micro:
    Stáhněte z GitHub repozitáře a přidejte do adresáře knihoven Arduino, nebo použijte Správce knihoven, pokud je k dispozici.
    Zajistěte kompatibilitu s ESP32, protože Espressif poskytuje specifickou podporu pro tflite-micro.

Krok 4: Integrace modelu do kódu ESP32

• Převést na C pole: Použijte xxd -i sine_model.tflite > sine_model.h k vygenerování hlavičkového souboru obsahujícího data modelu jako C pole, obvykle:

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

tflite::MicroErrorReporter mikro_chybový_reportér;
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 řešič;
constexpr int kTensorArenaSize = 2000;
uint8_t tensor_arena[kTensorArenaSize];
tflite::MicroInterpreter interpreter(model, resolver, tensor_arena, kTensorArenaSize, error_reporter);

float náhodnéFloat(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* vstup = interpreter.input(0);
    input->data.f[0] = úhel;
    if (interpreter.Invoke() != kTfLiteOk) {
        error_reporter->Report("Nepodařilo se vyvolat model");
        návrat;
    }
    TfLiteTensor* output = interpreter.output(0);
    float predikce = output->data.f[0];
    Serial.print("Úhel: ");
    Serial.print(úhel);
    Serial.print(", Predikovaný sinus: ");
    Serial.println(předpověď);
    zpoždění(1000);
}
  

• Poznámky: Funkce randomFloat generuje náhodné úhly pro testování pomocí jednoduché metody škálování. Velikost tensor arény (2000 bajtů) může vyžadovat úpravu pro větší modely, vzhledem k 520 KB SRAM u ESP32.

Krok 5: Nahrajte a spusťte kód

• Postup: Ujistěte se, že je deska správně vybrána (např. ESP32 Dev Module), zkompilujte a nahrajte. Otevřete Serial Monitor na 115200 baudů pro zobrazení výstupů.

Úvahy a potenciální výzvy

• Paměťová omezení: ESP32 má 520 KB SRAM a omezenou flash paměť, proto zajistěte, aby model a tensor arena byly v těchto limitech. Optimalizujte snížením složitosti modelu nebo zvětšením velikosti tensor areny, pokud je to potřeba.
• Kompatibilita knihovny: Ujistěte se, že verze knihovny tflite-micro odpovídá požadavkům ESP32, protože Espressif poskytuje specifickou podporu.
• Generování náhodných čísel: Funkce randomFloat používá jednoduchou metodu škálování, která nemusí být přesná pro všechny aplikace. Zvažte použití robustnějšího generátoru náhodných čísel pro produkční prostředí.

Neočekávané pozorování

Závěr

Klíčové citace

• Snadné TinyML na ESP32 a Arduino
• TensorFlow Lite Micro pro čipsety Espressif
• První kroky s ESP32 a TensorFlow Lite pro mikrokontroléry
• TensorFlow Lite TinyML pro ESP32