Arduino_tensorFlowLite. Compilation error when running my sketch

Official Hardware Nano Family Nano 33 BLE Sense
1

I'm working with arduino nano 33 ble sense and trying to run mnist classification model on it. While trying to compile my arduino sketch I'm getting an error like this

Library Arduino_TensorFlowLite has been declared precompiled:
Using precompiled library in C:\Users\prane\Documents\Arduino\libraries\Arduino_TensorFlowLite-2.4.0-ALPHA-precompiled\src\cortex-m4\fpv4-sp-d16-softfp
C:\Users\prane\Documents\Arduino\libraries\Arduino_TensorFlowLite-2.4.0-ALPHA-precompiled\src\cortex-m4\fpv4-sp-d16-softfp\libtensorflowlite.a(micro_error_reporter.cpp.o): In function `tflite::MicroErrorReporter::Report(char const*, std::__va_list)':
/home/arduino/workspace/Libraries-Google-Tensorflow-scraper/Arduino/libraries/tensorflow_lite_mirror/src/tensorflow/lite/micro/micro_error_reporter.cpp:35: undefined reference to `DebugLog'
/home/arduino/workspace/Libraries-Google-Tensorflow-scraper/Arduino/libraries/tensorflow_lite_mirror/src/tensorflow/lite/micro/micro_error_reporter.cpp:36: undefined reference to `DebugLog'
collect2.exe: error: ld returned 1 exit status

exit status 1

Compilation error: exit status 1

I think it is somewhat related to the library. I have included the complete sketch. Can someone please guide me. Thanks

#include "TensorFlowLite.h"
#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "tensorflow/lite/micro/micro_error_reporter.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
//#include "tensorflow/lite/micro/system_setup.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "tensorflow/lite/version.h"
#include "image_data.h"
#include "model_data.h"  /* quantized model */

// Define the input shape and number of classes for the MNIST model
const int kInputTensorSize = 1 * 28 * 28 * 1;
const int kNumClasses = 10;
namespace{
tflite::ErrorReporter* error_reporter = nullptr;
const tflite::Model* model = nullptr;
tflite::MicroInterpreter* interpreter = nullptr;
TfLiteTensor* input = nullptr;
TfLiteTensor* output = nullptr;
int inference_count = 0;

constexpr int kTensorArenaSize = 2*1024;
uint8_t tensor_arena[kTensorArenaSize];
}

void setup() {
  Serial.begin(115200);
  // tflite::InitializeTarget();
  // memset(tensor_arena, 0, kTensorArenaSize*sizeof(uint8_t));
  
  // Set up logging. 
  static tflite::MicroErrorReporter micro_error_reporter;
  error_reporter = &micro_error_reporter;
  
  // Map the model into a usable data structure..
  model = tflite::GetModel(model_data);
  if (model->version() != TFLITE_SCHEMA_VERSION) {
    Serial.println("Model provided is schema version " 
                  + String(model->version()) + " not equal "
                  + "to supported version "
                  + String(TFLITE_SCHEMA_VERSION));
    return;
  } else {
    Serial.println("Model version: " + String(model->version()));
  }
  
  // This pulls in all the operation implementations we need.
  static tflite::AllOpsResolver resolver;
 

  // Build an interpreter to run the model with.
  static tflite::MicroInterpreter static_interpreter(
      model, resolver, tensor_arena, kTensorArenaSize, error_reporter);
  interpreter = &static_interpreter;

  // Build an interpreter to run the model with.
// tflite::MicroInterpreter* static_interpreter_ptr = new tflite::MicroInterpreter(
//     model, resolver, tensor_arena, kTensorArenaSize, error_reporter);
// interpreter = static_interpreter_ptr;




  
  // Allocate memory from the tensor_arena for the model's tensors.
  TfLiteStatus allocate_status = interpreter->AllocateTensors();
  if (allocate_status != kTfLiteOk) {
    Serial.println("AllocateTensors() failed");
    return;
  } else {
    Serial.println("AllocateTensor() Success");
  }

  size_t used_size = interpreter->arena_used_bytes();
  Serial.println("Area used bytes: " + String(used_size));
  input = interpreter->input(0);
  output = interpreter->output(0);

  /* check input */
  if (input->type != kTfLiteFloat32) {
    Serial.println("input type mismatch. expected input type is float32");
    return;
  } else {
    Serial.println("input type is float32");
  }

  Serial.println("Model input:");
  Serial.println("input->type: " + String(input->type));
  Serial.println("dims->size: " + String(input->dims->size));
  for (int n = 0; n < input->dims->size; ++n) {
    Serial.println("dims->data[n]: " + String(input->dims->data[n]));
  }

  Serial.println("Model output:");
  Serial.println("dims->size: " + String(output->dims->size));
  for (int n = 0; n < output->dims->size; ++n) {
    Serial.println("dims->data[n]: " + String(output->dims->data[n]));
  }  
  
}
void loop() {

 // Define the input image array
  const uint8_t* kImageDataPtr = kImageData;  // Pointer to start of image data
  uint8_t input_image[kInputTensorSize];
  for (int i = 0; i < kInputTensorSize; i++) {
    input_image[i] = *(kImageDataPtr++);
  }

for(int i=0; i<kInputTensorSize; i++){
  input->data.f[i] = (float)input_image[i] / 255.0;
}

// Run inference
interpreter->Invoke();

// Print the predicted class
int predicted_class = -1;
float max_score = -1;
for (int i = 0; i < kNumClasses; i++) {
  float score = output->data.f[i];
  if (score > max_score) {
    predicted_class = i;
    max_score = score;
  }
}
Serial.println(predicted_class);

 }
1 Like
2

I'm running into a similar compilation issue

micro_error_reporter.cpp:(.text._ZN6tflite18MicroErrorReporter6ReportEPKcSt9__va_list+0x1a): undefined reference to DebugLog'`

Any luck finding a solution?

3

Looking for the same solution.

4

Hi @mandoner. You might take a look at this to see if it will be useful:

The TensorFlow Lite Micro developers requested Arduino to remove from Library Manager the Arduino library package of TensorFlow Lite Micro the Arduino organization had been maintaining. The assumption was that they would take over the responsibility of maintaining such a library. That would make complete sense as they are most qualified and motivated to operate such a project. So we removed the library and discontinued the maintenance of Arduino's library.

Unfortunately the TensorFlow Lite Micro developers never actually did the work to make their Arduino library into something that was user friendly and then finally stopped maintaining the project:

So the best hope now is that the Arduino community has stepped up in maintaining a library to make TensorFlow Lite Micro accessible for use in Arduino projects.

5

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.