TensorFlow Lite na ESP32

Czym jest TensorFlow Lite?

Kroki do wdrożenia na ESP32

Trenuj model

• Polecenie: pip install tensorflow
• Przykładowy kod:

  import numpy as np
  import tensorflow as tf
  z tensorflow importuj keras
  
  angles = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(kąty)
  model = keras.Sequential([keras.layers.Dense(1, input_shape=(1,))])
  model.compile(optimizer='adam', loss='mean_squared_error')
  model.fit(kąty, sinusy, epoki=100, verbose=0)
  model.save('sine_model.h5')
      
    

  Kopiuj kod ✔ Skopiowano!

Konwertuj na TensorFlow Lite

• Zainstaluj narzędzie: pip install tflite
• Konwertuj: tflite_convert --keras_model_file sine_model.h5 --output_file sine_model.tflite

Skonfiguruj ESP32

• Dodaj URL: http://dl.espressif.com/dl/package_esp32_index.json w Preferencjach.
• Zainstaluj przez Menedżera Płytek.
• Dodaj bibliotekę tflite-micro z repozytorium GitHub do bibliotek Arduino.

Integruj i uruchom

• Kod:

  #include 
  #include "tflite-micro.h"
  #include "sine_model.h"
  
  tflite::MicroErrorReporter mikro_raportujący_błędy;
  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 rozwiązywacz;
  constexpr int kTensorArenaSize = 2000;
  uint8_t tensor_arena[kTensorArenaSize];
  tflite::MicroInterpreter interpreter(model, resolver, tensor_arena, kTensorArenaSize, error_reporter);
  
  float losowaLiczbaZmiennoprzecinkowa(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;
      jeśli (interpreter.Invoke() != kTfLiteOk) {
          error_reporter->Report("Nie udało się wywołać modelu");
          return;
      }
      TfLiteTensor* output = interpreter.output(0);
      float prediction = output->data.f[0];
      Serial.print("Kąt: ");
      Serial.print(kąt);
      Serial.print(", Przewidywana sinusoida: ");
      Serial.println(prediction);
      opóźnienie(1000);
  }
      
    

  Kopiuj kod ✔ Skopiowano!

• Prześlij do ESP32, otwórz Monitor Szeregowy, aby zobaczyć wyniki.

Nieoczekiwany szczegół

Wdrażanie TensorFlow Lite na ESP32

Tło i kontekst

Szczegółowe kroki wdrożenia

Krok 1: Trenowanie modelu uczenia maszynowego

• Instalacja: Zainstaluj TensorFlow za pomocą polecenia pip install tensorflow.
• Kod szkoleniowy: Poniższy kod generuje zestaw danych i trenuje model:

  import numpy as np
  import tensorflow as tf
  z tensorflow importuj keras
  
  # Generuj zestaw danych
  angles = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(kąty)
  
  # Utwórz prosty model sieci neuronowej
  model = keras.Sequential([
      keras.layers.Dense(1, input_shape=(1,))
  ])
  
  # Kompiluj model
  model.compile(optimizer='adam', loss='mean_squared_error')
  
  # Trenuj model
  model.fit(kąty, sinusy, epoki=100, verbose=0)
  
  # Zapisz model
  model.save('sine_model.h5')
      
    

  Kopiuj kod ✔ Skopiowano!

• Uwagi: Ten model jest prosty, z jedną gęstą warstwą, odpowiedni dla ograniczonych zasobów ESP32. Zbiór danych składa się z 1000 losowych kątów i ich wartości sinusów, trenowany przez 100 epok z optymalizatorem Adam i stratą średniego błędu kwadratowego.

Krok 2: Konwersja modelu do formatu TensorFlow Lite

• Instalacja: Zainstaluj narzędzie konwersji za pomocą pip install tflite.
• Polecenie konwersji: Użyj następującego do konwersji:

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

• Szczegóły: Plik .tflite jest zoptymalizowany pod kątem rozmiaru i wydajności, co jest kluczowe dla mikrokontrolerów takich jak ESP32 z ograniczoną pamięcią flash i RAM.

Krok 3: Konfigurowanie środowiska programistycznego ESP32

• Wsparcie płyty ESP32:
    Otwórz Arduino IDE, przejdź do Plik > Preferencje i dodaj http://dl.espressif.com/dl/package_esp32_index.json do dodatkowych adresów URL Menedżera Płyt.
    Przejdź do Narzędzia > Płytka > Menedżer płytek, wyszukaj "esp32" i zainstaluj najnowszą wersję.
• Biblioteka TensorFlow Lite Micro:
    Pobierz z repozytorium GitHub i dodaj do katalogu bibliotek Arduino, lub użyj Menedżera Bibliotek, jeśli jest dostępny.
    Zapewnij kompatybilność z ESP32, ponieważ Espressif oferuje specjalne wsparcie dla tflite-micro.

Krok 4: Integracja modelu z kodem ESP32

• Konwertuj na tablicę C: Użyj xxd -i sine_model.tflite > sine_model.h, aby wygenerować plik nagłówkowy zawierający dane modelu jako tablicę C, zazwyczaj:

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

tflite::MicroErrorReporter mikro_raportujący_błędy;
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 rozwiązywacz;
constexpr int kTensorArenaSize = 2000;
uint8_t tensor_arena[kTensorArenaSize];
tflite::MicroInterpreter interpreter(model, resolver, tensor_arena, kTensorArenaSize, error_reporter);

float losowaLiczbaZmiennoprzecinkowa(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;
    jeśli (interpreter.Invoke() != kTfLiteOk) {
        error_reporter->Report("Nie udało się wywołać modelu");
        return;
    }
    TfLiteTensor* output = interpreter.output(0);
    float prediction = output->data.f[0];
    Serial.print("Kąt: ");
    Serial.print(kąt);
    Serial.print(", Przewidywana sinusoida: ");
    Serial.println(prediction);
    opóźnienie(1000);
}
  

• Uwagi: Funkcja randomFloat generuje losowe kąty do testów, używając prostej metody skalowania. Rozmiar obszaru tensorowego (2000 bajtów) może wymagać dostosowania dla większych modeli, biorąc pod uwagę 520 KB SRAM ESP32.

Krok 5: Prześlij i uruchom kod

• Procedura: Upewnij się, że wybrana jest odpowiednia płytka (np. ESP32 Dev Module), skompiluj i wgraj. Otwórz Monitor Szeregowy z prędkością 115200 bodów, aby zobaczyć wyniki.

Rozważania i potencjalne wyzwania

• Ograniczenia pamięci: ESP32 ma 520 KB SRAM i ograniczoną pamięć flash, więc upewnij się, że model i arena tensorów mieszczą się w tych limitach. Optymalizuj, zmniejszając złożoność modelu lub zwiększając rozmiar areny tensorów, jeśli to konieczne.
• Kompatybilność biblioteki: Upewnij się, że wersja biblioteki tflite-micro odpowiada wymaganiom ESP32, ponieważ Espressif zapewnia specyficzne wsparcie.
• Generowanie liczb losowych: funkcja randomFloat używa prostej metody skalowania, która może nie być precyzyjna dla wszystkich zastosowań. Rozważ użycie bardziej zaawansowanego generatora liczb losowych do produkcji.

Nieoczekiwana obserwacja

Wniosek

Kluczowe cytowania

• Łatwe TinyML na ESP32 i Arduino
• TensorFlow Lite Micro dla chipsetów Espressif
• Pierwsze kroki z ESP32 i TensorFlow Lite dla mikrokontrolerów
• TensorFlow Lite TinyML dla ESP32