esp32 hello-world-tensor — ESP32 simulation

An interactive ESP32 circuit simulation you can run free in your browser on Velxio, by aleenasrky.

Sketch code

#include <Arduino.h>
#include <math.h>

#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
#include "tensorflow/lite/schema/schema_generated.h"

#include "sine_model_data.h"

constexpr int kTensorArenaSize = 1100;

uint8_t tensor_arena[kTensorArenaSize];

const tflite::Model* model = nullptr;

tflite::MicroInterpreter* interpreter = nullptr;

TfLiteTensor* input = nullptr;
TfLiteTensor* output = nullptr;


void setup() {

  Serial.begin(115200);

  delay(1000);

  Serial.println();
  Serial.println("==============================");
  Serial.println("ESP32 TENSORFLOW LITE MICRO");
  Serial.println("HELLO WORLD");
  Serial.println("==============================");


  // 1. Load model

  model = tflite::GetModel(
    g_sine_model_data
  );

  if (model == nullptr) {

    Serial.println("MODEL LOAD: FAIL");

    return;
  }

  Serial.println("MODEL LOAD: PASS");


  // 2. Register operations

  static tflite::MicroMutableOpResolver<1> resolver;

  if (
    resolver.AddFullyConnected()
    != kTfLiteOk
  ) {

    Serial.println(
      "OPERATOR REGISTRATION: FAIL"
    );

    return;
  }

  Serial.println(
    "OPERATOR REGISTRATION: PASS"
  );


  // 3. Create interpreter

  static tflite::MicroInterpreter static_interpreter(
    model,
    resolver,
    tensor_arena,
    kTensorArenaSize
  );

  interpreter = &static_interpreter;


  // 4. Allocate tensors

  if (
    interpreter->AllocateTensors()
    != kTfLiteOk
  ) {

    Serial.println(
      "TENSOR ALLOCATION: FAIL"
    );

    return;
  }

  Serial.println(
    "TENSOR ALLOCATION: PASS"
  );


  // 5. Get input/output tensors

  input = interpreter->input(0);

  output = interpreter->output(0);

  Serial.println(
    "INPUT TENSOR: READY"
  );

  Serial.println(
    "OUTPUT TENSOR: READY"
  );

  Serial.println();

  Serial.println(
    "MODEL READY"
  );
}


void loop() {

  const float test_inputs[] = {
    0.0f,
    0.5f,
    1.0f,
    1.5f,
    3.0f
  };

  const int number_of_tests = 5;

  for (int i = 0; i < number_of_tests; i++) {

    float x = test_inputs[i];

    input->data.f[0] = x;

    unsigned long start = micros();

    TfLiteStatus status =
      interpreter->Invoke();

    unsigned long elapsed =
      micros() - start;

    if (status != kTfLiteOk) {

      Serial.println(
        "INFERENCE: FAIL"
      );

      continue;
    }

    float prediction =
      output->data.f[0];
    
    float expected = sin(x);
    float error = fabs(prediction - expected);

    Serial.println(
      "------------------------------"
    );

    Serial.print("Input: ");
    Serial.println(x, 4);

    Serial.print("Model prediction: ");
    Serial.println(prediction, 6);

    Serial.print("Expected sin(x): ");
    Serial.println(sin(x), 6);

    Serial.print("Inference time: ");
    Serial.print(elapsed);
    Serial.println(" microseconds");

    Serial.println(
      "INFERENCE: PASS"
    );

    delay(500);
  }

  Serial.pri

More projects by aleenasrky