first commit

Author: agrimagsrl

.gitignore

@@ -0,0 +1,2 @@
+cmake-build-debug
+.idea

examples/SineExample/SineExample.ino

@@ -0,0 +1,18 @@
+#include <EloquentTinyML.h>
+#include "sine_model.h"
+
+
+Eloquent::TinyML::TinyML<1, 1, 2048> ml(sine_model_quantized_tflite);
+
+
+void setup() {
+    Serial.begin(115200);
+}
+
+void loop() {
+    float input[1] = {random(10) > 5 ? 3.14/2 : 0};
+    float output = ml.predict(input);
+
+    Serial.println(output);
+    delay(1000);
+}

examples/SineExample/sine_model.h

@@ -0,0 +1,16 @@
+{
+  "name": "EloquentTinyML",
+  "keywords": "tinyml",
+  "description": "Eloquent interface to Tensorflow Lite for Microcontrollers",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eloquentarduino/EloquentTinyML"
+  },
+  "version": "0.0.1",
+  "authors": {
+    "name": "Simone Salerno",
+    "url": "https://github.com/eloquentarduino"
+  },
+  "frameworks": "arduino",
+  "platforms": "*"
+}

library.json

@@ -0,0 +1,9 @@
+name=EloquentTinyML
+version=0.0.1
+author=Simone Salerno <github.com/eloquentarduino>
+maintainer=Simone Salerno <github.com/eloquentarduino>
+sentence=An eloquent interface to Tensorflow Lite for Microcontrollers
+paragraph=
+category=Other
+url=https://github.com/eloquentarduino/EloquentTinyML
+architectures=*

library.properties

@@ -0,0 +1,104 @@
+#pragma once
+
+#include <Arduino.h>
+#include <math.h>
+#include "tensorflow/lite/version.h"
+#include "tensorflow/lite/micro/kernels/all_ops_resolver.h"
+#include "tensorflow/lite/micro/micro_error_reporter.h"
+#include "tensorflow/lite/micro/micro_interpreter.h"
+
+
+namespace Eloquent {
+    namespace TinyML {
+
+        /**
+         * Eloquent interface to Tensorflow Lite for Microcontrollers
+         *
+         * @tparam inputSize
+         * @tparam outputSize
+         * @tparam tensorArenaSize how much memory to allocate to the tensors
+         */
+        template<size_t inputSize, size_t outputSize, size_t tensorArenaSize>
+        class TinyML {
+        public:
+            /**
+             * Contructor
+             * @param modelData a model as exported by tinymlgen
+             */
+            TinyML(unsigned char *modelData) {
+                static tflite::MicroErrorReporter microReporter;
+                static tflite::ops::micro::AllOpsResolver resolver;
+
+                reporter = &microReporter;
+                model = tflite::GetModel(modelData);
+
+                // assert model version and runtime version match
+                if (model->version() != TFLITE_SCHEMA_VERSION) {
+                  failed = true;
+                  reporter->Report(
+                      "Model provided is schema version %d not equal "
+                      "to supported version %d.",
+                      model->version(), TFLITE_SCHEMA_VERSION);
+
+                  return;
+                }
+
+                static tflite::MicroInterpreter interpreter(model, resolver, tensorArena, tensorArenaSize, reporter);
+
+                if (interpreter.AllocateTensors() != kTfLiteOk) {
+                    failed = true;
+                    reporter->Report("AllocateTensors() failed");
+                    return;
+                }
+
+                input = interpreter.input(0);
+                output = interpreter.output(0);
+                this->interpreter = &interpreter;
+            }
+
+            /**
+             * Test if the initialization completed fine
+             */
+            bool initialized() {
+                return !failed;
+            }
+
+            /**
+             * Run inference
+             * @return output[0], so you can use it directly if it's the only output
+             */
+            float predict(float *input, float *output = NULL) {
+                // abort if initialization failed
+                if (failed)
+                    return sqrt(-1);
+
+                // copy input
+                for (size_t i = 0; i < inputSize; i++)
+                    this->input->data.f[i] = input[i];
+
+                if (interpreter->Invoke() != kTfLiteOk) {
+                    reporter->Report("Inference failed");
+
+                    return sqrt(-1);
+                }
+
+                // copy output
+                if (output != NULL) {
+                    for (size_t i = 0; i < outputSize; i++)
+                        output[i] = this->output->data.f[0];
+                }
+
+                return this->output->data.f[0];
+            }
+
+        protected:
+            bool failed;
+            uint8_t tensorArena[tensorArenaSize];
+            tflite::ErrorReporter *reporter;
+            tflite::MicroInterpreter *interpreter;
+            TfLiteTensor *input;
+            TfLiteTensor *output;
+            const tflite::Model *model;
+        };
+    }
+}