TensorFlow Lite su ESP32

Che cos'è TensorFlow Lite?

Passaggi per il deployment su ESP32

Addestrare un modello

• Comando: pip install tensorflow
• Codice di esempio:

  importa numpy come np
  importa tensorflow come tf
  da tensorflow import keras
  
  angoli = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(angoli)
  modello = 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')
  
  
  

  Copia il codice ✔ Copiato!

Converti in TensorFlow Lite

• Installa strumento: pip install tflite
• Converti: tflite_convert --keras_model_file sine_model.h5 --output_file sine_model.tflite

Imposta ESP32

• Aggiungi URL: http://dl.espressif.com/dl/package_esp32_index.json nelle Preferenze.
• Installa tramite il Gestore schede.
• Aggiungi la libreria tflite-micro dal repository GitHub alle librerie di Arduino.

Integrare ed eseguire

• Codice:

  #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 risolutore;
  constexpr int kTensorArenaSize = 2000;
  uint8_t tensor_arena[kTensorArenaSize];
  tflite::MicroInterpreter interprete(model, risolutore, tensor_arena, kTensorArenaSize, error_reporter);
  
  float randomFloat(float min, float max) {
      ritorna min + (max - min) * (float)random(0, 10000) / 10000.0;
  }
  
  impostazione nulla() {
      Inizio seriale(115200);
      interpreter.AllocateTensors();
  }
  
  ciclo vuoto() {
      float angolo = randomFloat(-3.1416, 3.1416);
      TfLiteTensor* input = interpreter.input(0);
      input->data.f[0] = angolo;
      if (interpreter.Invoke() != kTfLiteOk) {
          error_reporter->Report("Impossibile invocare il modello");
          ritorno;
      }
      TfLiteTensor* output = interpreter.output(0);
      float previsione = output->data.f[0];
      Serial.print("Angolo: ");
      Serial.print(angle);
      Serial.print(", Seno previsto: ");
      Serial.println(prediction);
      ritardo(1000);
  }
  
  
  

  Copia il codice ✔ Copiato!

• Carica su ESP32, apri il Monitor Seriale per vedere i risultati.

Dettaglio inaspettato

Distribuire TensorFlow Lite su ESP32

Contesto e Sfondo

Passaggi Dettagliati per il Deployment

Passo 1: Addestrare un Modello di Apprendimento Automatico

• Installazione: Installa TensorFlow con il comando pip install tensorflow.
• Codice di Addestramento: Il seguente codice genera un dataset e addestra il modello:

  importa numpy come np
  importa tensorflow come tf
  da tensorflow import keras
  
  # Genera set di dati
  angoli = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(angoli)
  
  # Crea un semplice modello di rete neurale
  modello = keras.Sequential([
      keras.layers.Dense(1, input_shape=(1,))
  ])
  
  # Compila il modello
  model.compile(optimizer='adam', loss='mean_squared_error')
  
  # Addestrare il modello
  model.fit(angles, sines, epochs=100, verbose=0)
  
  # Salva il modello
  model.save('sine_model.h5')
  
  
  

  Copia il codice ✔ Copiato!

• Note: Questo modello è semplice, con un unico strato denso, adatto alle risorse limitate dell'ESP32. Il dataset consiste in 1000 angoli casuali e i loro valori di seno, addestrato per 100 epoche con l'ottimizzatore Adam e la perdita di errore quadratico medio.

Passo 2: Conversione del Modello nel Formato TensorFlow Lite

• Installazione: Installa lo strumento di conversione con pip install tflite.
• Comando di Conversione: Usa il seguente per convertire:

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

• Dettagli: Il file .tflite è ottimizzato per dimensioni e prestazioni, fondamentale per microcontrollori come l'ESP32 con memoria flash e RAM limitate.

Passo 3: Configurazione dell'ambiente di sviluppo ESP32

• Supporto per la scheda ESP32:
    Apri l'IDE di Arduino, vai su File > Preferenze e aggiungi http://dl.espressif.com/dl/package_esp32_index.json a URL aggiuntivi del Board Manager.
    Vai su Strumenti > Scheda > Gestore schede, cerca "esp32" e installa l'ultima versione.
• Libreria TensorFlow Lite Micro:
    Scarica da repository GitHub e aggiungi alla directory delle librerie di Arduino, oppure utilizza il Gestore delle librerie se disponibile.
    Assicurati della compatibilità con ESP32, poiché Espressif fornisce supporto specifico per tflite-micro.

Passo 4: Integrazione del Modello nel Codice ESP32

• Converti in array C: Usa xxd -i sine_model.tflite > sine_model.h per generare un file di intestazione contenente i dati del modello come un array C, tipicamente:

#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 risolutore;
constexpr int kTensorArenaSize = 2000;
uint8_t tensor_arena[kTensorArenaSize];
tflite::MicroInterpreter interprete(model, risolutore, tensor_arena, kTensorArenaSize, error_reporter);

float randomFloat(float min, float max) {
    ritorna min + (max - min) * (float)random(0, 10000) / 10000.0;
}

impostazione nulla() {
    Inizio seriale(115200);
    interpreter.AllocateTensors();
}

ciclo vuoto() {
    float angolo = randomFloat(-3.1416, 3.1416);
    TfLiteTensor* input = interpreter.input(0);
    input->data.f[0] = angolo;
    if (interpreter.Invoke() != kTfLiteOk) {
        error_reporter->Report("Impossibile invocare il modello");
        ritorno;
    }
    TfLiteTensor* output = interpreter.output(0);
    float previsione = output->data.f[0];
    Serial.print("Angolo: ");
    Serial.print(angle);
    Serial.print(", Seno previsto: ");
    Serial.println(prediction);
    ritardo(1000);
}

• Note: La funzione randomFloat genera angoli casuali per i test, utilizzando un semplice metodo di scaling. La dimensione dell'arena del tensore (2000 byte) potrebbe necessitare di un aggiustamento per modelli più grandi, dato che l'ESP32 ha 520 KB di SRAM.

Passo 5: Carica ed Esegui il Codice

• Procedura: Assicurati che la scheda sia selezionata correttamente (ad es., ESP32 Dev Module), compila e carica. Apri il Monitor Seriale a 115200 baud per vedere le uscite.

Considerazioni e Potenziali Sfide

• Vincoli di Memoria: ESP32 ha 520 KB di SRAM e flash limitata, quindi assicurati che il modello e l'area dei tensori rientrino in questi limiti. Ottimizza riducendo la complessità del modello o aumentando la dimensione dell'area dei tensori se necessario.
• Compatibilità della libreria: Assicurati che la versione della libreria tflite-micro corrisponda ai requisiti dell'ESP32, poiché Espressif fornisce supporto specifico.
• Generazione di Numeri Casuali: La funzione randomFloat utilizza un semplice metodo di scaling, che potrebbe non essere preciso per tutte le applicazioni. Considera di utilizzare un generatore di numeri casuali più robusto per la produzione.

Osservazione Inaspettata

Conclusione

Citazioni chiave

• Easy TinyML su ESP32 e Arduino
• TensorFlow Lite Micro per chipset Espressif
• Primi passi con ESP32 e TensorFlow Lite per Microcontrollori
• TensorFlow Lite TinyML per ESP32