Update export cpp to the new ExportLib object.

aidge_export_cpp/__init__.py

@@ -2,6 +2,7 @@ r"""
 Aidge Export for CPP standalone projects
 
 """
+from .export_registry import ExportLibCpp
 
 from .operators import *
 from collections import defaultdict

aidge_export_cpp/export.py

@@ -13,6 +13,7 @@ from aidge_core.export_utils.code_generation import *
 from aidge_export_cpp.utils import (ROOT, OPERATORS_REGISTRY, supported_operators)
 from aidge_export_cpp.utils.converter import numpy_dtype2ctype
 import aidge_export_cpp.operators
+from aidge_export_cpp import ExportLibCpp
 from aidge_export_cpp.utils.generation import *
 from aidge_export_cpp.memory import *
 
@@ -50,9 +51,8 @@ def export(export_folder_name, graphview, scheduler, mem_wrapping=False):
     list_forward_nodes = scheduler.get_static_scheduling()
 
     for node in list_forward_nodes:
-        if node.type() in supported_operators():
-            op = OPERATORS_REGISTRY[node.type()](node)
-
+        if ExportLibCpp.exportable(node):
+            op = ExportLibCpp.get_export_node(node)
             # For configuration files
             list_configs = op.export(dnn_folder, list_configs)
 

aidge_export_cpp/operators.py

@@ -3,39 +3,39 @@ import shutil
 import numpy as np
 from pathlib import Path
 from jinja2 import Environment, FileSystemLoader
-
-from aidge_core import ExportNode, ExportNodeCpp
-from aidge_core.export_utils.code_generation import *
-from aidge_export_cpp.utils import ROOT, operator_register
+from aidge_core.export_utils import ExportNode, ExportNodeCpp, operator_register, generate_str, generate_file
+from aidge_export_cpp.utils import ROOT
 from aidge_export_cpp.utils.converter import numpy_dtype2ctype
 from aidge_export_cpp.utils.generation import *
-
+from aidge_export_cpp import ExportLibCpp
 ##############################################
 ################### Utils ####################
 ##############################################
 
-def get_node_parents(node):
-    parents = []
-    for parent in node.get_parents():
-        if parent.type() != "Producer":
-            parents.append(parent)
-    return parents
 
-def get_producer_parents(node):
-    parents = []
-    for parent in node.get_parents():
-        if parent.type() == "Producer":
-            parents.append(parent)
-    return parents
+# def get_node_parents(node):
+#     parents = []
+#     for parent in node.get_parents():
+#         if parent.type() != "Producer":
+#             parents.append(parent)
+#     return parents
+
+
+# def get_producer_parents(node):
+#     parents = []
+#     for parent in node.get_parents():
+#         if parent.type() == "Producer":
+#             parents.append(parent)
+#     return parents
 
 
 ##############################################
 ############## Export functions ##############
 ##############################################
 
-def export_params(name:str,
+def export_params(name: str,
                   array: np.ndarray,
-                  filepath:str):
+                  filepath: str):
 
     # Get directory name of the file
     dirname = os.path.dirname(filepath)
@@ -47,9 +47,9 @@ def export_params(name:str,
     generate_file(
         filepath,
         str(ROOT / "templates" / "data" / "parameters.jinja"),
-        name = name,
-        data_t = numpy_dtype2ctype(array.dtype),
-        values = array.tolist()
+        name=name,
+        data_t=numpy_dtype2ctype(array.dtype),
+        values=array.tolist()
     )
 
 
@@ -58,17 +58,17 @@ def export_params(name:str,
 ##############################################
 
 
-@operator_register("Producer")
+@operator_register(ExportLibCpp, "Producer")
 class ProducerCPP(ExportNode):
 
     def __init__(self, node):
         super().__init__(node)
         self.values = np.array(self.operator.get_output(0))
 
-        if len(self.values.shape) == 4: # Note: export in HWC
+        if len(self.values.shape) == 4:  # Note: export in HWC
             self.values = np.transpose(self.values, (0, 2, 3, 1))
 
-    def export(self, export_folder:Path, list_configs:list):
+    def export(self, export_folder: Path, list_configs: list):
 
         list_configs.append(f"parameters/{self.attributes['name']}.h")
         export_params(
@@ -78,26 +78,36 @@ class ProducerCPP(ExportNode):
 
         return list_configs
 
-    def forward(self, list_actions:list):
+    def forward(self, list_actions: list):
         # A Producer does nothing during forward
         return list_actions
+    @classmethod
+    def exportable(cls, node):
+        return True # TODO add check i/o NCHW
 
-
-@operator_register("ReLU")
+@operator_register(ExportLibCpp, "ReLU")
 class ReLUCPP(ExportNodeCpp):
     def __init__(self, node):
         super().__init__(node)
         self.attributes["activation"] = "Rectifier"
         self.attributes["rescaling"] = "NoScaling"
-        self.config_template = str(ROOT / "templates" / "configuration" / "activation_config.jinja")
-        self.forward_template = str(ROOT / "templates" / "kernel_forward" / "activation_forward.jinja")
+        self.config_template = str(
+            ROOT / "templates" / "configuration" / "activation_config.jinja")
+        self.forward_template = str(
+            ROOT / "templates" / "kernel_forward" / "activation_forward.jinja")
         self.include_list = []
         self.kernels_to_copy = [
             str(ROOT / "kernels" / "activation.hpp"),
         ]
-
-
-@operator_register("Conv")
+    @staticmethod
+    def compatible(cls, node):
+        for idx, parent_node_in_id in node.inputs():
+            parent_node, _ = parent_node_in_id
+    @classmethod
+    def exportable(cls, node):
+        return True # TODO add check i/o NCHW
+
+@operator_register(ExportLibCpp, "Conv")
 class ConvCPP(ExportNodeCpp):
     def __init__(self, node):
         super().__init__(node)
@@ -106,84 +116,116 @@ class ConvCPP(ExportNodeCpp):
         self.attributes["padding"] = [0, 0]
         self.attributes["activation"] = "Linear"
         self.attributes["rescaling"] = "NoScaling"
-        self.config_template = str(ROOT / "templates" / "configuration" / "convolution_config.jinja")
-        self.forward_template = str(ROOT / "templates" / "kernel_forward" / "convolution_forward.jinja")
+        self.config_template = str(
+            ROOT / "templates" / "configuration" / "convolution_config.jinja")
+        self.forward_template = str(
+            ROOT / "templates" / "kernel_forward" / "convolution_forward.jinja")
         self.include_list = []
         self.kernels_to_copy = [
             str(ROOT / "kernels" / "convolution.hpp"),
             str(ROOT / "kernels" / "macs.hpp"),
             str(ROOT / "kernels" / "activation.hpp"),
         ]
+    @classmethod
+    def exportable(cls, node):
+        return True # TODO add check i/o NCHW
+
 
 
-@operator_register("PaddedConv")
+@operator_register(ExportLibCpp, "PaddedConv")
 class PaddedConvCPP(ExportNodeCpp):
     def __init__(self, node):
         super().__init__(node)
         # TODO find a way to retrive attr for meta op
         for n in self.operator.get_micro_graph().get_nodes():
             if n.type() == "Pad":
-                self.attributes["padding"] = n.get_operator().attr.begin_end_borders
+                self.attributes["padding"] = n.get_operator(
+                ).attr.begin_end_borders
             if n.type() == "Conv":
-                self.attributes["kernel_dims"]   = n.get_operator().attr.kernel_dims
-                self.attributes["stride_dims"]   = n.get_operator().attr.stride_dims
-                self.attributes["dilation_dims"] = n.get_operator().attr.dilation_dims
+                self.attributes["kernel_dims"] = n.get_operator(
+                ).attr.kernel_dims
+                self.attributes["stride_dims"] = n.get_operator(
+                ).attr.stride_dims
+                self.attributes["dilation_dims"] = n.get_operator(
+                ).attr.dilation_dims
         self.attributes["activation"] = "Linear"
         self.attributes["rescaling"] = "NoScaling"
-        self.config_template = str(ROOT / "templates" / "configuration" / "convolution_config.jinja")
-        self.forward_template = str(ROOT / "templates" / "kernel_forward" / "convolution_forward.jinja")
+        self.config_template = str(
+            ROOT / "templates" / "configuration" / "convolution_config.jinja")
+        self.forward_template = str(
+            ROOT / "templates" / "kernel_forward" / "convolution_forward.jinja")
         self.include_list = []
         self.kernels_to_copy = [
             str(ROOT / "kernels" / "convolution.hpp"),
             str(ROOT / "kernels" / "macs.hpp"),
             str(ROOT / "kernels" / "activation.hpp"),
         ]
-@operator_register("Add")
+    @classmethod
+    def exportable(cls, node):
+        return True # TODO add check i/o NCHW
+
+@operator_register(ExportLibCpp, "Add")
 class AddCPP(ExportNodeCpp):
     def __init__(self, node):
         super().__init__(node)
         self.attributes["elemwise_op"] = "Add"
         self.attributes["activation"] = "Linear"
         self.attributes["rescaling"] = "NoScaling"
-        self.config_template = str(ROOT / "templates" / "configuration" / "elemwise_config.jinja")
-        self.forward_template = str(ROOT / "templates" / "kernel_forward" / "elemwise_forward.jinja")
+        self.config_template = str(
+            ROOT / "templates" / "configuration" / "elemwise_config.jinja")
+        self.forward_template = str(
+            ROOT / "templates" / "kernel_forward" / "elemwise_forward.jinja")
         self.include_list = []
         self.kernels_to_copy = [
             str(ROOT / "kernels" / "elemwise.hpp"),
             str(ROOT / "kernels" / "activation.hpp"),
         ]
+    @classmethod
+    def exportable(cls, node):
+        return True # TODO add check i/o NCHW
 
-@operator_register("Sub")
+@operator_register(ExportLibCpp, "Sub")
 class SubCPP(ExportNodeCpp):
     def __init__(self, node):
         super().__init__(node)
         self.attributes["elemwise_op"] = "Sub"
         self.attributes["activation"] = "Linear"
         self.attributes["rescaling"] = "NoScaling"
-        self.config_template = str(ROOT / "templates" / "configuration" / "elemwise_config.jinja")
-        self.forward_template = str(ROOT / "templates" / "kernel_forward" / "elemwise_forward.jinja")
+        self.config_template = str(
+            ROOT / "templates" / "configuration" / "elemwise_config.jinja")
+        self.forward_template = str(
+            ROOT / "templates" / "kernel_forward" / "elemwise_forward.jinja")
         self.include_list = []
         self.kernels_to_copy = [
             str(ROOT / "kernels" / "elemwise.hpp"),
             str(ROOT / "kernels" / "activation.hpp"),
         ]
+    @classmethod
+    def exportable(cls, node):
+        return True # TODO add check i/o NCHW
 
-@operator_register("Mul")
+
+@operator_register(ExportLibCpp, "Mul")
 class MulCPP(ExportNodeCpp):
     def __init__(self, node):
         super().__init__(node)
         self.attributes["elemwise_op"] = "Mul"
         self.attributes["activation"] = "Linear"
         self.attributes["rescaling"] = "NoScaling"
-        self.config_template = str(ROOT / "templates" / "configuration" / "elemwise_config.jinja")
-        self.forward_template = str(ROOT / "templates" / "kernel_forward" / "elemwise_forward.jinja")
+        self.config_template = str(
+            ROOT / "templates" / "configuration" / "elemwise_config.jinja")
+        self.forward_template = str(
+            ROOT / "templates" / "kernel_forward" / "elemwise_forward.jinja")
         self.include_list = []
         self.kernels_to_copy = [
             str(ROOT / "kernels" / "elemwise.hpp"),
             str(ROOT / "kernels" / "activation.hpp"),
         ]
+    @classmethod
+    def exportable(cls, node):
+        return True # TODO add check i/o NCHW
 
-@operator_register("MaxPooling")
+@operator_register(ExportLibCpp, "MaxPooling")
 class MaxPoolCPP(ExportNodeCpp):
     def __init__(self, node):
         super().__init__(node)
@@ -194,37 +236,50 @@ class MaxPoolCPP(ExportNodeCpp):
         self.attributes["pool_type"] = "Max"
         self.attributes["activation"] = "Linear"
 
-        self.config_template = str(ROOT / "templates" / "configuration" / "pooling_config.jinja")
-        self.forward_template = str(ROOT / "templates" / "kernel_forward" / "pooling_forward.jinja")
+        self.config_template = str(
+            ROOT / "templates" / "configuration" / "pooling_config.jinja")
+        self.forward_template = str(
+            ROOT / "templates" / "kernel_forward" / "pooling_forward.jinja")
         self.include_list = []
         self.kernels_to_copy = [
             str(ROOT / "kernels" / "pooling.hpp"),
             str(ROOT / "kernels" / "activation.hpp"),
         ]
 
+    @classmethod
+    def exportable(cls, node):
+        return True # TODO add check i/o NCHW
 
-@operator_register("PaddedMaxPooling")
+@operator_register(ExportLibCpp, "PaddedMaxPooling")
 class PaddedMaxPoolCPP(ExportNodeCpp):
     def __init__(self, node):
         super().__init__(node)
         for n in self.operator.get_micro_graph().get_nodes():
             if n.type() == "Pad":
-                self.attributes["padding"] = n.get_operator().attr.begin_end_borders
+                self.attributes["padding"] = n.get_operator(
+                ).attr.begin_end_borders
             if n.type() == "MaxPooling":
-                self.attributes["kernel_dims"] = n.get_operator().attr.kernel_dims
-                self.attributes["stride_dims"] = n.get_operator().attr.stride_dims
+                self.attributes["kernel_dims"] = n.get_operator(
+                ).attr.kernel_dims
+                self.attributes["stride_dims"] = n.get_operator(
+                ).attr.stride_dims
         self.attributes["pool_type"] = "Max"
         self.attributes["activation"] = "Linear"
 
-        self.config_template = str(ROOT / "templates" / "configuration" / "pooling_config.jinja")
-        self.forward_template = str(ROOT / "templates" / "kernel_forward" / "pooling_forward.jinja")
+        self.config_template = str(
+            ROOT / "templates" / "configuration" / "pooling_config.jinja")
+        self.forward_template = str(
+            ROOT / "templates" / "kernel_forward" / "pooling_forward.jinja")
         self.include_list = []
         self.kernels_to_copy = [
             str(ROOT / "kernels" / "pooling.hpp"),
             str(ROOT / "kernels" / "activation.hpp"),
         ]
+    @classmethod
+    def exportable(cls, node):
+        return True # TODO add check i/o NCHW
 
-@operator_register("GlobalAveragePooling")
+@operator_register(ExportLibCpp, "GlobalAveragePooling")
 class GlobalAveragePoolCPP(ExportNodeCpp):
     def __init__(self, node):
         super().__init__(node)
@@ -240,26 +295,35 @@ class GlobalAveragePoolCPP(ExportNodeCpp):
         self.attributes["pool_type"] = "Average"
         self.attributes["activation"] = "Linear"
 
-        self.config_template = str(ROOT / "templates" / "configuration" / "pooling_config.jinja")
-        self.forward_template = str(ROOT / "templates" / "kernel_forward" / "pooling_forward.jinja")
+        self.config_template = str(
+            ROOT / "templates" / "configuration" / "pooling_config.jinja")
+        self.forward_template = str(
+            ROOT / "templates" / "kernel_forward" / "pooling_forward.jinja")
         self.include_list = []
         self.kernels_to_copy = [
             str(ROOT / "kernels" / "pooling.hpp"),
             str(ROOT / "kernels" / "activation.hpp"),
         ]
+    @classmethod
+    def exportable(cls, node):
+        return True # TODO add check i/o NCHW
 
-
-@operator_register("FC")
+@operator_register(ExportLibCpp, "FC")
 class FcCPP(ExportNodeCpp):
     def __init__(self, node):
         super().__init__(node)
         self.attributes["activation"] = "Linear"
         self.attributes["rescaling"] = "NoScaling"
-        self.config_template = str(ROOT / "templates" / "configuration" / "fullyconnected_config.jinja")
-        self.forward_template = str(ROOT / "templates" / "kernel_forward" / "fullyconnected_forward.jinja")
+        self.config_template = str(
+            ROOT / "templates" / "configuration" / "fullyconnected_config.jinja")
+        self.forward_template = str(
+            ROOT / "templates" / "kernel_forward" / "fullyconnected_forward.jinja")
         self.include_list = []
         self.kernels_to_copy = [
             str(ROOT / "kernels" / "fullyconnected.hpp"),
             str(ROOT / "kernels" / "macs.hpp"),
             str(ROOT / "kernels" / "activation.hpp"),
         ]
+    @classmethod
+    def exportable(cls, node):
+        return True # TODO add check i/o NCHW