Étape 2 — Inférence TFLite Micro

#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "model_data.h"  // modèle converti en tableau C avec xxd

constexpr int kArenaSize = 80 * 1024;
uint8_t tensor_arena[kArenaSize];

const tflite::Model*        model       = nullptr;
tflite::MicroInterpreter*   interpreter = nullptr;

void setupModel() {
  model = tflite::GetModel(g_model_data);

  static tflite::MicroMutableOpResolver<6> resolver;
  resolver.AddConv2D();
  resolver.AddMaxPool2D();
  resolver.AddReshape();
  resolver.AddFullyConnected();
  resolver.AddSoftmax();
  resolver.AddRelu();

  static tflite::MicroInterpreter static_interpreter(
    model, resolver, tensor_arena, kArenaSize);
  interpreter = &static_interpreter;
  interpreter->AllocateTensors();  // appeler une seule fois
}

// Returns: 0=silence, 1=inconnu, 2=hey_zacus
int runInference(const int16_t* audio, int numSamples) {
  TfLiteTensor* input = interpreter->input(0);

  float features[49 * 40];
  compute_mel_features(audio, numSamples, features);

  // Quantize float features to INT8
  float scale    = input->params.scale;
  int   zero_point = input->params.zero_point;
  for (int i = 0; i < 49 * 40; i++) {
    int val = (int)(features[i] / scale + zero_point);
    if (val < -128) val = -128;
    if (val >  127) val =  127;
    input->data.int8[i] = (int8_t)val;
  }

  interpreter->Invoke();

  TfLiteTensor* output = interpreter->output(0);
  int maxIdx   = 0;
  int8_t maxVal = output->data.int8[0];
  for (int i = 1; i < 3; i++) {
    if (output->data.int8[i] > maxVal) {
      maxVal = output->data.int8[i];
      maxIdx = i;
    }
  }
  return maxIdx;
}