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 importar 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='error_cuadrático_medio')
  model.fit(ángulos, senos, 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 Tarjetas.
• 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* datos_modelo = sine_model;
  const size_t model_size = sine_model_len;
  const tflite::Model* modelo = tflite::GetModel(model_data);
  tflite::AllOpsResolver resolvedor;
  constexpr int kTensorArenaSize = 2000;
  uint8_t tensor_arena[kTensorArenaSize];
  tflite::MicroInterpreter intérprete(modelo, resolvedor, 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.AllocateTensors();
  }
  
  bucle vacío() {
      float angle = randomFloat(-3.1416, 3.1416);
      TfLiteTensor* entrada = interpreter.input(0);
      input->data.f[0] = ángulo;
      if (interpreter.Invoke() != kTfLiteOk) {
          error_reporter->Report("Error al invocar el modelo");
          devolver;
      }
      TfLiteTensor* salida = interpreter.output(0);
      float prediction = output->data.f[0];
      Serial.print("Ángulo: ");
      Serial.print(ángulo);
      Serial.print(", Seno predicho: ");
      Serial.println(predicción);
      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: Instale 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 importar 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='error_cuadrático_medio')
  
  # Entrenar el modelo
  model.fit(ángulos, senos, 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 consta de 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: Instale 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, crucial para microcontroladores como ESP32 con memoria flash y RAM limitadas.

Paso 3: Configuración del entorno de desarrollo ESP32

• Soporte para placa ESP32:
    Abre Arduino IDE, ve a Archivo > Preferencias, y añade http://dl.espressif.com/dl/package_esp32_index.json a URLs adicionales del Administrador de placas.
    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 añade al directorio de bibliotecas de Arduino, o usa el Gestor de Bibliotecas si está disponible.
    Asegure 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 matriz C: Use xxd -i sine_model.tflite > sine_model.h para generar un archivo de encabezado que contenga los datos del modelo como una matriz 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* datos_modelo = sine_model;
const size_t model_size = sine_model_len;
const tflite::Model* modelo = tflite::GetModel(model_data);
tflite::AllOpsResolver resolvedor;
constexpr int kTensorArenaSize = 2000;
uint8_t tensor_arena[kTensorArenaSize];
tflite::MicroInterpreter intérprete(modelo, resolvedor, 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.AllocateTensors();
}

bucle vacío() {
    float angle = randomFloat(-3.1416, 3.1416);
    TfLiteTensor* entrada = interpreter.input(0);
    input->data.f[0] = ángulo;
    if (interpreter.Invoke() != kTfLiteOk) {
        error_reporter->Report("Error al invocar el modelo");
        devolver;
    }
    TfLiteTensor* salida = interpreter.output(0);
    float prediction = output->data.f[0];
    Serial.print("Ángulo: ");
    Serial.print(ángulo);
    Serial.print(", Seno predicho: ");
    Serial.println(predicción);
    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 ajuste para modelos más grandes, dado que el ESP32 tiene 520 KB de SRAM.

Paso 5: Subir y Ejecutar el Código

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

Consideraciones y Desafíos Potenciales

• Restricciones de memoria: ESP32 tiene 520 KB de SRAM y flash limitado, así que asegúrate de que el modelo y el área de tensores quepan 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. Considere usar un generador de números aleatorios más robusto para producción.

Observación Inesperada

Conclusión

Citas clave

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