add predictClass + python scripts to generate nn

Author: agrimagsrl

examples/DigitsExample/DigitsExample.ino

@@ -28,8 +28,11 @@ void loop() {
     int y_test = 8;
 
     uint32_t start = micros();
+
     ml.predict(x_test, y_pred);
+
     uint32_t timeit = micros() - start;
+
     Serial.print("It took ");
     Serial.print(timeit);
     Serial.println(" micros to run inference");
@@ -43,18 +46,10 @@ void loop() {
         Serial.print(i == 9 ? '\n' : ',');
     }
 
-    uint8_t pred_class = 0;
-    float max_proba = y_pred[0];
-
-    for (int i = 1; i < 10; i++) {
-        if (y_pred[i] > max_proba) {
-            pred_class = i;
-            max_proba = y_pred[i];
-        }
-    }
-
-    Serial.print("Predicted output is: ");
-    Serial.println(pred_class);
+    Serial.print("Predicted class is: ");
+    Serial.println(ml.probaToClass(y_pred));
+    Serial.print("Sanity check: ");
+    Serial.println(ml.predictClass(x_test));
 
     delay(1000);
 }

examples/DigitsExample/digits_model.py

@@ -0,0 +1,55 @@
+import math
+import numpy as np
+from sklearn.datasets import load_digits
+import tensorflow as tf
+from tensorflow.keras import layers
+from tinymlgen import port
+
+
+def get_data():
+    np.random.seed(1337)
+    x_values, y_values = load_digits(return_X_y=True)
+    x_values /= x_values.max()
+    # reshape to (8 x 8 x 1)
+    x_values = x_values.reshape((len(x_values), 8, 8, 1))
+
+    # split into train, validation, test
+    TRAIN_SPLIT = int(0.6 * len(x_values))
+    TEST_SPLIT = int(0.2 * len(x_values) + TRAIN_SPLIT)
+    x_train, x_test, x_validate = np.split(x_values, [TRAIN_SPLIT, TEST_SPLIT])
+    y_train, y_test, y_validate = np.split(y_values, [TRAIN_SPLIT, TEST_SPLIT])
+
+    return x_train, x_test, x_validate, y_train, y_test, y_validate
+
+def get_model():
+    x_train, x_test, x_validate, y_train, y_test, y_validate = get_data()
+
+    # create a CNN
+    model = tf.keras.Sequential()
+    model.add(layers.Conv2D(8, (3, 3), activation='relu', input_shape=(8, 8, 1)))
+    # model.add(layers.MaxPooling2D((2, 2)))
+    # model.add(layers.Conv2D(64, (3, 3), activation='relu'))
+    # model.add(layers.MaxPooling2D((2, 2)))
+    # model.add(layers.Conv2D(64, (3, 3), activation='relu'))
+    model.add(layers.Flatten())
+    # model.add(layers.Dense(16, activation='relu'))
+    model.add(layers.Dense(len(np.unique(y_train))))
+
+    model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy'])
+    model.fit(x_train, y_train, epochs=50, batch_size=16,
+              validation_data=(x_validate, y_validate))
+    return Exp
+
+
+def test_model(model, x_test, y_test):
+    x_test = (x_test / x_test.max()).reshape((len(x_test), 8, 8, 1))
+    y_pred = model.predict(x_test).argmax(axis=1)
+    print('ACCURACY', (y_pred == y_test).sum() / len(y_test))
+    exit()
+
+
+if __name__ == '__main__':
+    model, x_test, y_test = get_model()
+    test_model(model, x_test, y_test)
+    c_code = port(model, variable_name='digits_model', pretty_print=True)
+    print(c_code)

examples/SineCosineExample/sine_cosine_model.py

@@ -0,0 +1,47 @@
+import math
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras import layers
+from tinymlgen import port
+
+
+def get_model():
+    SAMPLES = 1000
+    np.random.seed(1337)
+    x_values = np.random.uniform(low=0, high=2*math.pi, size=SAMPLES)
+    # shuffle and add noise
+    np.random.shuffle(x_values)
+    y_values = np.vstack((np.sin(x_values), np.cos(x_values))).T
+    y_values += 0.1 * np.random.randn(*y_values.shape)
+
+    # split into train, validation, test
+    TRAIN_SPLIT =  int(0.6 * SAMPLES)
+    TEST_SPLIT = int(0.2 * SAMPLES + TRAIN_SPLIT)
+    x_train, x_test, x_validate = np.split(x_values, [TRAIN_SPLIT, TEST_SPLIT])
+    y_train, y_test, y_validate = np.split(y_values, [TRAIN_SPLIT, TEST_SPLIT])
+
+    # create a NN with 2 layers of 16 neurons
+    model = tf.keras.Sequential()
+    model.add(layers.Dense(16, activation='relu', input_shape=(1,)))
+    model.add(layers.Dense(16, activation='relu'))
+    model.add(layers.Dense(2))
+    model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
+    model.fit(x_train, y_train, epochs=100, batch_size=16,
+                        validation_data=(x_validate, y_validate))
+    return model
+
+
+def test_model(model, verbose=False):
+    x_test = np.random.uniform(low=0, high=2*math.pi, size=100)
+    y_test = np.vstack((np.sin(x_test), np.cos(x_test))).T
+    y_pred = model.predict(x_test)
+    if verbose:
+        for i in range(y_pred.shape[1]):
+            print('MAE[%d] = %.3f' % (i, np.abs(y_pred[:, i] - y_test[:, i]).mean()))
+
+
+if __name__ == '__main__':
+    model = get_model()
+    test_model(model, verbose=True)
+    c_code = port(model, pretty_print=True)
+    print(c_code)

examples/SineExample/sine_model.py

@@ -0,0 +1,45 @@
+import math
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras import layers
+from tinymlgen import port
+
+
+def get_model():
+    SAMPLES = 1000
+    np.random.seed(1337)
+    x_values = np.random.uniform(low=0, high=2*math.pi, size=SAMPLES)
+    # shuffle and add noise
+    np.random.shuffle(x_values)
+    y_values = np.sin(x_values)
+    y_values += 0.1 * np.random.randn(*y_values.shape)
+
+    # split into train, validation, test
+    TRAIN_SPLIT =  int(0.6 * SAMPLES)
+    TEST_SPLIT = int(0.2 * SAMPLES + TRAIN_SPLIT)
+    x_train, x_test, x_validate = np.split(x_values, [TRAIN_SPLIT, TEST_SPLIT])
+    y_train, y_test, y_validate = np.split(y_values, [TRAIN_SPLIT, TEST_SPLIT])
+
+    # create a NN with 2 layers of 16 neurons
+    model = tf.keras.Sequential()
+    model.add(layers.Dense(8, activation='relu', input_shape=(1,)))
+    model.add(layers.Dense(16, activation='relu'))
+    model.add(layers.Dense(1))
+    model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
+    model.fit(x_train, y_train, epochs=200, batch_size=16,
+                        validation_data=(x_validate, y_validate))
+    return model
+
+
+def test_model(model, verbose=False):
+    x_test = np.random.uniform(low=0, high=2*math.pi, size=100)
+    y_test = np.sin(x_test)
+    y_pred = model.predict(x_test)
+    print('MAE', np.abs(y_pred - y_test).mean())
+
+
+if __name__ == '__main__':
+    model = get_model()
+    test_model(model, verbose=True)
+    c_code = port(model, pretty_print=True)
+    print(c_code)

library.json

@@ -6,7 +6,7 @@
     "type": "git",
     "url": "https://github.com/eloquentarduino/EloquentTinyML"
   },
-  "version": "0.0.4",
+  "version": "0.0.5",
   "authors": {
     "name": "Simone Salerno",
     "url": "https://github.com/eloquentarduino"

library.properties

@@ -1,5 +1,5 @@
 name=EloquentTinyML
-version=0.0.4
+version=0.0.5
 author=Simone Salerno,eloquentarduino@gmail.com
 maintainer=Simone Salerno,eloquentarduino@gmail.com
 sentence=An eloquent interface to Tensorflow Lite for Microcontrollers

src/EloquentTinyML.h

@@ -89,6 +89,12 @@ namespace Eloquent {
                 return !failed;
             }
 
+            /**
+             *
+             * @param input
+             * @param output
+             * @return
+             */
             uint8_t predict(uint8_t *input, uint8_t *output = NULL) {
                 // abort if initialization failed
                 if (!initialized())
@@ -141,6 +147,38 @@ namespace Eloquent {
                 return this->output->data.f[0];
             }
 
+            /**
+             * Predict class
+             * @param input
+             * @return
+             */
+            uint8_t predictClass(float *input) {
+                float output[outputSize];
+
+                predict(input, output);
+
+                return probaToClass(output);
+            }
+
+            /**
+             * Get class with highest probability
+             * @param output
+             * @return
+             */
+            uint8_t probaToClass(float *output) {
+                uint8_t classIdx = 0;
+                float maxProba = output[0];
+
+                for (uint8_t i = 1; i < outputSize; i++) {
+                    if (output[i] > maxProba) {
+                        classIdx = i;
+                        maxProba = output[i];
+                    }
+                }
+
+                return classIdx;
+            }
+
         protected:
             bool failed;
             uint8_t tensorArena[tensorArenaSize];