added Neural Network as alternative for TensorFlow Lite for Microcontrollers

Author: mkaliberda

src/server/codegen/knowledgepack_codegen_mixin.py

@@ -206,20 +206,19 @@ def create_tensorflow_build_flags(self, models):
         for model in models:
             if self.is_tensorflow(model["classifier_config"]["classifier"]):
                 if self.nn_inference_engine == "nnom":
-                    #TODO: NNoM
+                    # TODO: NNoM
                     pass
 
                 if self.nn_inference_engine == "tf_micro":
                     return tf_micro_cflags
 
-
         return ""
 
     def create_kb_model_tf_micro_binary(self, models):
         for model in models:
             if self.is_tensorflow(model["classifier_config"]["classifier"]):
                 if self.nn_inference_engine == "nnom":
-                    #TODO: NNoM
+                    # TODO: NNoM
                     pass
 
                 if self.nn_inference_engine == "tf_micro":
@@ -233,6 +232,9 @@ def create_sml_classification_result_info(self, models_data):
         model_fill["TensorFlow Lite for Microcontrollers"] = (
             "{\n\ttf_micro_model_results_object(kb_models[model_index].classifier_id, (model_results_t *)model_results);\n}"
         )
+        model_fill["Neural Network"] = (
+            "{\n\ttf_micro_model_results_object(kb_models[model_index].classifier_id, (model_results_t *)model_results);\n}"
+        )
 
         model_fill["Decision Tree Ensemble"] = (
             "{\n\ttree_ensemble_model_results_object(kb_models[model_index].classifier_id, (model_results_t *)model_results);\n}"
@@ -256,6 +258,20 @@ def create_sml_classification_result_print_info(self, models_data):
 
             """
 
+        model_fill[
+            "Neural Network"
+        ] = """{
+               sml_classification_result_info(model_index, &model_result);\n
+               pbuf += sprintf(pbuf, ",\\"ModelDebug\\":[");
+               for (int32_t i=0; i<model_result.num_outputs; i++)
+               {
+                 pbuf += sprintf(pbuf, "%f, ", model_result.output_tensor[i]);
+               }
+               pbuf += sprintf(pbuf, "]");
+                }
+
+            """
+
         return self.create_case_fill_template_classifier_type(models_data, model_fill)
 
     def create_classifier_structures(self, classifier_types, kb_models):
@@ -264,16 +280,17 @@ def create_classifier_structures(self, classifier_types, kb_models):
         formated_classifier_types = [
             x.lower().replace(" ", "_") for x in classifier_types
         ]
-        
+
         def is_neural_netwrok(classifier_type):
-            return (classifier_type == "tensorflow_lite_for_microcontrollers" or classifier_type == 'neural_network')
+            return (
+                classifier_type == "tensorflow_lite_for_microcontrollers"
+                or classifier_type == "neural_network"
+            )
 
         formated_classifier_types = [
             x if not is_neural_netwrok(x) else self.nn_inference_engine
             for x in formated_classifier_types
         ]
-        
-        
 
         logger.info(
             {
@@ -313,12 +330,18 @@ def get_classifier_type_map(self, classifier_config):
             return 3
         elif classifier_type in ["Bonsai"]:
             return 4
-        elif classifier_type in ["TF Micro", "TensorFlow Lite for Microcontrollers", "Neural Network"]:
+        elif classifier_type in [
+            "TF Micro",
+            "TensorFlow Lite for Microcontrollers",
+            "Neural Network",
+        ]:
             return 5
         elif classifier_type in ["Linear Regression"]:
             return 6
         else:
-            raise Exception(f"{classifier_type} not supported Classifier Type for code generation")
+            raise Exception(
+                f"{classifier_type} not supported Classifier Type for code generation"
+            )
 
     def create_debug_flagging(self):
         ret = []
@@ -354,7 +377,7 @@ def create_kb_classifier_headers(self, classifier_types):
             output.append('#include "bonsai_trained_models.h"')
 
         if self.is_tensorflow(classifier_types):
-            if self.nn_inference_engine == "nnom":                
+            if self.nn_inference_engine == "nnom":
                 output.append('#include "nnom_trained_models.h"')
                 output.append('#include "nnom_middleware.h"')
 
@@ -385,7 +408,7 @@ def create_kb_classifier_header_calls_only(self, classifier_types):
 
         if self.is_tensorflow(classifier_types):
             if self.nn_inference_engine == "nnom":
-                #TODO: NNoM
+                # TODO: NNoM
                 pass
 
             if self.nn_inference_engine == "tf_micro":
@@ -424,7 +447,7 @@ def create_kb_classifier_init(self, classifier_types):
 
         if self.is_tensorflow(classifier_types):
             if self.nn_inference_engine == "nnom":
-                output.append(c_line(1, "nnom_init(nnom_classifier_rows, 0);"))                
+                output.append(c_line(1, "nnom_init(nnom_classifier_rows, 0);"))
 
             if self.nn_inference_engine == "tf_micro":
                 output.append(c_line(1, "tf_micro_init(tf_micro_classifier_rows, 0);"))
@@ -482,15 +505,15 @@ def create_classifier_calls(self, models_data):
             elif model["classifier_config"]["classifier"] in [
                 "TF Micro",
                 "TensorFlow Lite for Microcontrollers",
-                "Neural Network"
+                "Neural Network",
             ]:
-                if self.nn_inference_engine=='tf_micro':
+                if self.nn_inference_engine == "tf_micro":
                     output_str += c_line(
                         1,
                         "ret = tf_micro_simple_submit(kb_model->classifier_id, kb_model->pfeature_vector, kb_model->pmodel_results);",
                     )
-                if self.nn_inference_engine=='nnom':
-                        output_str += c_line(
+                if self.nn_inference_engine == "nnom":
+                    output_str += c_line(
                         1,
                         "ret = nnom_simple_submit(kb_model->classifier_id, kb_model->pfeature_vector, kb_model->pmodel_results);",
                     )

src/server/codegen/model_gen/nnom.py

@@ -23,7 +23,7 @@
 
 
 def create_classifier_arrays(model_index, model):
-   
+
     pass
 
 
@@ -32,42 +32,40 @@ def create_classifier_struct(model_index, model):
 
 
 def create_classifier_structures(models):
-    """ typedef struct nnom_classifier_rows
-        {
-            uint16_t num_inputs;
-            uint8_t num_outputs;
-            float threshold;
-            uint8_t estimator_type;
-            nnom_model_t* model;
-        } nnom_classifier_rows_t;
+    """typedef struct nnom_classifier_rows
+    {
+        uint16_t num_inputs;
+        uint8_t num_outputs;
+        float threshold;
+        uint8_t estimator_type;
+        nnom_model_t* model;
+    } nnom_classifier_rows_t;
     """
-    
+
     outputs = []
 
     iterations = 0
     for model in models:
         if model["classifier_config"].get("classifier", "PME") in [
             "TF Micro",
             "TensorFlow Lite for Microcontrollers",
-            "Neural Network"
+            "Neural Network",
         ]:
-            #outputs.extend(
+            # outputs.extend(
             #    create_tf_micro_classifier_arrays(iterations, model["model_arrays"])
-            #)
+            # )
             iterations += 1
 
     iterations = 0
 
     outputs.append(
         (
             "nnom_classifier_rows_t nnom_classifier_rows[{}] = ".format(
-                utils.get_number_classifiers(
-                    models, "TF Micro"
-                )+utils.get_number_classifiers(
+                utils.get_number_classifiers(models, "TF Micro")
+                + utils.get_number_classifiers(
                     models, "TensorFlow Lite for Microcontrollers"
-                )+utils.get_number_classifiers(
-                    models, "Neural Network"
                 )
+                + utils.get_number_classifiers(models, "Neural Network")
             )
             + "{"
         )
@@ -77,7 +75,7 @@ def create_classifier_structures(models):
         if model["classifier_config"].get("classifier", "PME") in [
             "TF Micro",
             "TensorFlow Lite for Microcontrollers",
-             "Neural Network"
+            "Neural Network",
         ]:
             outputs.append("\n\t{")
             outputs.append(
@@ -111,13 +109,14 @@ def create_classifier_structures(models):
     return outputs
 
 
-
 def create_max_tmp_parameters(kb_models):
-   return []
+    return []
+
 
 def validate_model_parameters(data):
     pass
 
+
 def validate_model_configuration(data):
     return data
 

src/server/codegen/model_gen/tf_micro.py

@@ -88,7 +88,7 @@ def create_classifier_structures(models):
         if model["classifier_config"].get("classifier", "PME") in [
             "TF Micro",
             "TensorFlow Lite for Microcontrollers",
-            "Neural Network"
+            "Neural Network",
         ]:
             outputs.extend(
                 create_tf_micro_classifier_arrays(iterations, model["model_arrays"])
@@ -112,6 +112,7 @@ def create_classifier_structures(models):
         if model["classifier_config"].get("classifier", "PME") in [
             "TF Micro",
             "TensorFlow Lite for Microcontrollers",
+            "Neural Network",
         ]:
             outputs.append("\n\t{")
             outputs.append(

src/server/engine/recognitionengine.py

@@ -136,6 +136,7 @@ def initialize_classifier(self, config):
         elif self.classifier_type in [
             "TF Micro",
             "TensorFlow Lite for Microcontrollers",
+            "Neural Network",
         ]:
             self.classifier = TensorFlowMicro()
             self.classifier.load_model(self.neuron_array)
@@ -435,7 +436,7 @@ def reco_kb_pipeline(self, kb_description):
             "target_compiler": CompilerDescription.objects.get(
                 uuid="62aabe7e-4f5d-4167-a786-072e4a8dc158"
             ),
-            "nn_inference_engine":'nnom'
+            "nn_inference_engine": "nnom",
         }
 
         logger.userlog(

src/server/library/classifiers/classifiers.py

@@ -39,6 +39,7 @@ def get_classifier(config, save_model_parameters=True):
         "Boosted Tree Ensemble": BoostedTreeEnsemble,
         "TF Micro": TensorFlowMicro,
         "TensorFlow Lite for Microcontrollers": TensorFlowMicro,
+        "Neural Network": TensorFlowMicro,
         "Linear Regression": LinearRegression,
     }
     try:

src/server/library/fixtures/functions_prod.yml

@@ -848,6 +848,22 @@
     automl_available: False
   model: library.transform
 
+- fields:
+    core: True
+    name: Load Model Neural Network
+    version: 1
+    type: Training Algorithm
+    subtype: Load
+    path: core_functions/mg_contracts.py
+    function_in_file: load_model_tensorflow_micro
+    has_c_version: False
+    c_file_name:
+    c_function_name:
+    deprecated: False
+    dcl_executable: False
+    automl_available: False
+  model: library.transform
+
 - fields:
     core: True
     name: Bonsai Tree Optimizer