TensorFlow Lite en ESP32

¿Qué es TensorFlow Lite?

Pasos para desplegar en ESP32

Entrenar un modelo

• Comando: pip install tensorflow
• Código de ejemplo:

  importar numpy como np
  importar tensorflow como tf
  de tensorflow import keras
  
  ángulos = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(ángulos)
  modelo = 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')
  
  
  

  Copiar código ✔ ¡Copiado!

Convertir a TensorFlow Lite

• Instalar herramienta: pip install tflite
• Convertir: tflite_convert --keras_model_file sine_model.h5 --output_file sine_model.tflite

Configurar ESP32

• Añadir URL: http://dl.espressif.com/dl/package_esp32_index.json en Preferencias.
• Instalar a través del Gestor de Placas.
• Agrega la biblioteca tflite-micro desde el repositorio de GitHub a las bibliotecas de Arduino.

Integrar y ejecutar

• Código:

  #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* modelo = tflite::GetModel(datos_del_modelo);
  tflite::AllOpsResolver resolver;
  constexpr int kTensorArenaSize = 2000;
  uint8_t tensor_arena[kTensorArenaSize];
  tflite::MicroInterpreter intérprete(modelo, resolutor, tensor_arena, kTensorArenaSize, reportero_de_errores);
  
  float randomFloat(float min, float max) {
      return min + (max - min) * (float)random(0, 10000) / 10000.0;
  }
  
  configuración vacía() {
      Serial.begin(115200);
      interpreter.AsignarTensores();
  }
  
  bucle vacío() {
      float angle = randomFloat(-3.1416, 3.1416);
      TfLiteTensor* input = interpreter.input(0);
      input->data.f[0] = ángulo;
      if (interpreter.Invoke() != kTfLiteOk) {
          error_reporter->Report("Error al invocar el modelo");
          devolver;
      }
      TfLiteTensor* output = interpreter.output(0);
      float predicción = output->data.f[0];
      Serial.print("Ángulo: ");
      Serial.print(angle);
      Serial.print(", Seno predicho: ");
      Serial.println(prediction);
      retraso(1000);
  }
  
  
  

  Copiar código ✔ ¡Copiado!

• Sube al ESP32, abre el Monitor Serial para ver los resultados.

Detalle inesperado

Desplegando TensorFlow Lite en ESP32

Antecedentes y Contexto

Pasos Detallados para el Despliegue

Paso 1: Entrenamiento de un Modelo de Aprendizaje Automático

• Instalación: Instala TensorFlow con el comando pip install tensorflow.
• Código de Entrenamiento: El siguiente código genera un conjunto de datos y entrena el modelo:

  importar numpy como np
  importar tensorflow como tf
  de tensorflow import keras
  
  # Generar conjunto de datos
  ángulos = np.random.uniform(low=-np.pi, high=np.pi, size=(1000, 1))
  sines = np.sin(ángulos)
  
  # Crear un modelo de red neuronal simple
  modelo = keras.Sequential([
      keras.layers.Dense(1, input_shape=(1,))
  ])
  
  # Compilar el modelo
  model.compile(optimizer='adam', loss='mean_squared_error')
  
  # Entrenar el modelo
  model.fit(angles, sines, epochs=100, verbose=0)
  
  # Guardar el modelo
  model.save('sine_model.h5')
  
  
  

  Copiar código ✔ ¡Copiado!

• Notas: Este modelo es simple, con una capa densa, adecuado para los recursos limitados del ESP32. El conjunto de datos consiste en 1000 ángulos aleatorios y sus valores de seno, entrenado durante 100 épocas con el optimizador Adam y la pérdida de error cuadrático medio.

Paso 2: Convertir el modelo al formato TensorFlow Lite

• Instalación: Instala la herramienta de conversión con pip install tflite.
• Comando de Conversión: Utilice lo siguiente para convertir:

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

• Detalles: El archivo .tflite está optimizado para tamaño y rendimiento, lo cual es crucial para microcontroladores como el ESP32 con memoria flash y RAM limitadas.

Paso 3: Configuración del Entorno de Desarrollo ESP32

• Soporte para la placa ESP32:
    Abre el IDE de Arduino, ve a Archivo > Preferencias, y añade http://dl.espressif.com/dl/package_esp32_index.json a las URL adicionales del administrador de la junta.
    Ve a Herramientas > Placa > Gestor de Placas, busca "esp32" e instala la última versión.
• Biblioteca TensorFlow Lite Micro:
    Descarga desde el repositorio de GitHub y agrégalo al directorio de bibliotecas de Arduino, o usa el Administrador de Bibliotecas si está disponible.
    Asegúrese de la compatibilidad con ESP32, ya que Espressif proporciona soporte específico para tflite-micro.

Paso 4: Integrando el Modelo en el Código ESP32

• Convertir a arreglo C: Usa xxd -i sine_model.tflite > sine_model.h para generar un archivo de encabezado que contenga los datos del modelo como un arreglo C, típicamente:

#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* modelo = tflite::GetModel(datos_del_modelo);
tflite::AllOpsResolver resolver;
constexpr int kTensorArenaSize = 2000;
uint8_t tensor_arena[kTensorArenaSize];
tflite::MicroInterpreter intérprete(modelo, resolutor, tensor_arena, kTensorArenaSize, reportero_de_errores);

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

configuración vacía() {
    Serial.begin(115200);
    interpreter.AsignarTensores();
}

bucle vacío() {
    float angle = randomFloat(-3.1416, 3.1416);
    TfLiteTensor* input = interpreter.input(0);
    input->data.f[0] = ángulo;
    if (interpreter.Invoke() != kTfLiteOk) {
        error_reporter->Report("Error al invocar el modelo");
        devolver;
    }
    TfLiteTensor* output = interpreter.output(0);
    float predicción = output->data.f[0];
    Serial.print("Ángulo: ");
    Serial.print(angle);
    Serial.print(", Seno predicho: ");
    Serial.println(prediction);
    retraso(1000);
}

• Notas: La función randomFloat genera ángulos aleatorios para pruebas, utilizando un método de escalado simple. El tamaño del área de tensores (2000 bytes) puede necesitar ajustes para modelos más grandes, dado que el ESP32 tiene 520 KB de SRAM.

Paso 5: Cargar y Ejecutar el Código

• Procedimiento: Asegúrese de que la placa esté seleccionada correctamente (por ejemplo, Módulo de Desarrollo ESP32), compile y cargue. Abra el Monitor Serial a 115200 baudios para ver las salidas.

Consideraciones y Desafíos Potenciales

• Restricciones de Memoria: El ESP32 tiene 520 KB de SRAM y flash limitado, así que asegúrate de que el modelo y el área de tensores se ajusten dentro de estos límites. Optimiza reduciendo la complejidad del modelo o aumentando el tamaño del área de tensores si es necesario.
• Compatibilidad de la biblioteca: Asegúrese de que la versión de la biblioteca tflite-micro coincida con los requisitos de ESP32, ya que Espressif proporciona soporte específico.
• Generación de Números Aleatorios: La función randomFloat utiliza un método de escalado simple, que puede no ser preciso para todas las aplicaciones. Considera usar un generador de números aleatorios más robusto para producción.

Observación Inesperada

Conclusión

Citas clave

• Fácil TinyML en ESP32 y Arduino
• TensorFlow Lite Micro para chipsets Espressif
• Primeros pasos con ESP32 y TensorFlow Lite para Microcontroladores
• TensorFlow Lite TinyML para ESP32