add support for Exp operator for Generic target

Author: marchioa

Deeploy/Targets/Generic/Bindings.py

@@ -13,7 +13,7 @@
 from Deeploy.FutureExtension.CodeTransformationPasses.FutureCodeTransformation import FutureGeneration
 from Deeploy.Targets.Generic.Templates import AddTemplate, BatchNormalizationTemplate, ConcatTemplate, ConvTemplate, \
     ConvTransposeTemplate, DebugPrintTemplate, DequantTemplate, DummyTemplate, DWConvTemplate, FloatAddTemplate, \
-    FloatCeilTemplate, FloatClipTemplate, FloatConvTemplate, FloatDivTemplate, FloatDWConvTemplate, \
+    FloatCeilTemplate, FloatClipTemplate, FloatConvTemplate, FloatDivTemplate, FloatDWConvTemplate, FloatExpTemplate, \
     FloatFloorTemplate, FloatGELUTemplate, FloatGemmTemplate, FloatLayernormTemplate, FloatMatMulTemplate, \
     FloatMaxPoolTemplate, FloatMulTemplate, FloatPadTemplate, FloatPowTemplate, FloatReduceMeanTemplate, \
     FloatReluTemplate, FloatSoftmaxTemplate, FloatSqrtTemplate, FloatSubTemplate, GatherTemplate, GemmTemplate, \
@@ -357,3 +357,8 @@
              PointerClass(float32_t)], [PointerClass(float32_t)]), FloatClipTemplate.referenceTemplate,
         BasicTransformer),
 ]
+
+BasicExpBindings = [
+    NodeBinding(DummyChecker([PointerClass(float32_t)], [PointerClass(float32_t)]), FloatExpTemplate.referenceTemplate,
+                BasicTransformer),
+]

Deeploy/Targets/Generic/Layers.py

@@ -715,18 +715,16 @@ def computeOps(self):
 
 
 class CeilLayer(ONNXLayer):
-
-    def __init__(self, maps: List[NodeMapper]):
-        super().__init__(maps)
+    pass
 
 
 class FloorLayer(ONNXLayer):
-
-    def __init__(self, maps: List[NodeMapper]):
-        super().__init__(maps)
+    pass
 
 
 class ClipLayer(ONNXLayer):
+    pass
 
-    def __init__(self, maps: List[NodeMapper]):
-        super().__init__(maps)
+
+class ExpLayer(ONNXLayer):
+    pass

Deeploy/Targets/Generic/Parsers.py

@@ -11,6 +11,23 @@
 from Deeploy.DeeployTypes import ConstantBuffer, NetworkContext, NodeParser, VariableBuffer
 
 
+class UnaryElementWiseParser(NodeParser):
+
+    def parseNode(self, node: gs.Node) -> bool:
+        return len(node.inputs) == 1 and len(node.outputs) == 1
+
+    def parseNodeCtxt(self,
+                      ctxt: NetworkContext,
+                      node: gs.Node,
+                      channels_first: bool = True) -> Tuple[NetworkContext, bool]:
+        data_in = ctxt.lookup(node.inputs[0].name)
+        data_out = ctxt.lookup(node.outputs[0].name)
+        self.operatorRepresentation['data_in'] = data_in.name
+        self.operatorRepresentation['data_out'] = data_out.name
+        self.operatorRepresentation['size'] = int(np.prod(data_in.shape))
+        return ctxt, True
+
+
 class ConcatParser(NodeParser):
 
     def __init__(self):
@@ -1095,29 +1112,10 @@ def parseNodeCtxt(self,
         return ctxt, True
 
 
-class ReluParser(NodeParser):
-
-    def __init__(self):
-        super().__init__()
-
-    def parseNode(self, node: gs.Node) -> (bool):
-
-        ret = all([len(node.inputs) == 1, len(node.outputs) == 1])
-
-        return ret
-
-    def parseNodeCtxt(self,
-                      ctxt: NetworkContext,
-                      node: gs.Node,
-                      channels_first: bool = True) -> Tuple[NetworkContext, bool]:
-
-        data_in = ctxt.lookup(node.inputs[0].name)
-        data_out = ctxt.lookup(node.outputs[0].name)
-        self.operatorRepresentation['data_in'] = data_in.name
-        self.operatorRepresentation['data_out'] = data_out.name
-        self.operatorRepresentation['size'] = np.prod(data_in.shape)
+class ReluParser(UnaryElementWiseParser):
 
-        return ctxt, True
+    def parseNode(self, node: gs.Node) -> bool:
+        return super().parseNode(node) and node.op == 'Relu'
 
 
 class ReshapeParser(NodeParser):
@@ -2868,79 +2866,28 @@ def parseNodeCtxt(self,
         return ctxt, False
 
 
-class SqrtParser(NodeParser):
-
-    def __init__(self):
-        super().__init__()
+class SqrtParser(UnaryElementWiseParser):
 
     def parseNode(self, node: gs.Node) -> bool:
-        return node.op == 'Sqrt' and len(node.inputs) == 1 and len(node.outputs) == 1
-
-    def parseNodeCtxt(self,
-                      ctxt: NetworkContext,
-                      node: gs.Node,
-                      channels_first: bool = True) -> Tuple[NetworkContext, bool]:
+        return super().parseNode(node) and node.op == 'Sqrt'
 
-        data_in = ctxt.lookup(node.inputs[0].name)
-        data_out = ctxt.lookup(node.outputs[0].name)
 
-        self.operatorRepresentation['data_in'] = data_in.name
-        self.operatorRepresentation['data_out'] = data_out.name
-        self.operatorRepresentation['size'] = int(np.prod(data_in.shape))
-
-        return ctxt, True
-
-
-class CeilParser(NodeParser):
-
-    def __init__(self):
-        super().__init__()
+class CeilParser(UnaryElementWiseParser):
 
     def parseNode(self, node: gs.Node) -> bool:
-        return node.op == 'Ceil' and len(node.inputs) == 1 and len(node.outputs) == 1
+        return super().parseNode(node) and node.op == 'Ceil'
 
-    def parseNodeCtxt(self,
-                      ctxt: NetworkContext,
-                      node: gs.Node,
-                      channels_first: bool = True) -> Tuple[NetworkContext, bool]:
 
-        data_in = ctxt.lookup(node.inputs[0].name)
-        data_out = ctxt.lookup(node.outputs[0].name)
-
-        self.operatorRepresentation['data_in'] = data_in.name
-        self.operatorRepresentation['data_out'] = data_out.name
-        self.operatorRepresentation['size'] = int(np.prod(data_in.shape))
-        return ctxt, True
-
-
-class FloorParser(NodeParser):
-
-    def __init__(self):
-        super().__init__()
+class FloorParser(UnaryElementWiseParser):
 
     def parseNode(self, node: gs.Node) -> bool:
-        return node.op == 'Floor' and len(node.inputs) == 1 and len(node.outputs) == 1
+        return super().parseNode(node) and node.op == 'Floor'
 
-    def parseNodeCtxt(self,
-                      ctxt: NetworkContext,
-                      node: gs.Node,
-                      channels_first: bool = True) -> Tuple[NetworkContext, bool]:
-
-        data_in = ctxt.lookup(node.inputs[0].name)
-        data_out = ctxt.lookup(node.outputs[0].name)
-
-        self.operatorRepresentation['data_in'] = data_in.name
-        self.operatorRepresentation['data_out'] = data_out.name
-        self.operatorRepresentation['size'] = int(np.prod(data_in.shape))
-        return ctxt, True
-
-
-class ClipParser(NodeParser):
 
-    def __init__(self):
-        super().__init__()
+class ClipParser(UnaryElementWiseParser):
 
     def parseNode(self, node: gs.Node) -> bool:
+        # Clip allows 1–3 inputs (optional min/max constants), so we can't use super()
         if node.op != 'Clip' \
             or len(node.outputs) != 1 \
             or (not (1 <= len(node.inputs) <= 3)):
@@ -2952,11 +2899,9 @@ def parseNodeCtxt(self,
                       node: gs.Node,
                       channels_first: bool = True) -> Tuple[NetworkContext, bool]:
 
-        data_in = ctxt.lookup(node.inputs[0].name)
-        data_out = ctxt.lookup(node.outputs[0].name)
-        self.operatorRepresentation['data_in'] = data_in.name
-        self.operatorRepresentation['data_out'] = data_out.name
-        self.operatorRepresentation['size'] = int(np.prod(data_in.shape))
+        ctxt, ok = super().parseNodeCtxt(ctxt, node, channels_first)
+        if not ok:
+            return ctxt, False
 
         # min_val and max_val only handled as constants
         # Defaults: full float32 range
@@ -2969,3 +2914,9 @@ def parseNodeCtxt(self,
             self.operatorRepresentation['max_val'] = float(node.inputs[2].values.item())
 
         return ctxt, True
+
+
+class ExpParser(UnaryElementWiseParser):
+
+    def parseNode(self, node: gs.Node) -> bool:
+        return super().parseNode(node) and node.op == 'Exp'

Deeploy/Targets/Generic/Platform.py

@@ -9,19 +9,19 @@
 from Deeploy.Targets.Generic.Bindings import BasicAddBindings, BasicBatchNormBindings, BasicCeilBindings, \
     BasicClipBindings, BasicConcatBindings, BasicConv1DBindings, BasicConv2DBindings, BasicConvTransposeBindings, \
     BasicDebugPrintBindings, BasicDequantBindings, BasicDivBindings, BasicDWConv1DBinding, BasicDWConv2DBindings, \
-    BasicFloorBindings, BasicGatherBindings, BasicGELUBindings, BasicGEMMBindings, BasicITAPartialSoftmaxBinding, \
-    BasicITASoftmaxBinding, BasicLayerNormBindings, BasicMatMulBindings, BasicMaxPool1DBindings, \
-    BasicMaxPool2DBindings, BasicMulBindings, BasicPad1DBindings, BasicPad2DBindings, BasicPowBindings, \
-    BasicQuantBindings, BasicReduceMeanBindings, BasicReduceSumBindings, BasicReluBinding, BasicReshapeBindings, \
-    BasicRQIntegerDivBinding, BasicRQSBindings, BasicRQSGELUBinding, BasicSliceBindings, BasicSoftmaxBindings, \
-    BasicSqrtBindings, BasicSubBindings, BasicTransposeBindings, DummyBinding
+    BasicExpBindings, BasicFloorBindings, BasicGatherBindings, BasicGELUBindings, BasicGEMMBindings, \
+    BasicITAPartialSoftmaxBinding, BasicITASoftmaxBinding, BasicLayerNormBindings, BasicMatMulBindings, \
+    BasicMaxPool1DBindings, BasicMaxPool2DBindings, BasicMulBindings, BasicPad1DBindings, BasicPad2DBindings, \
+    BasicPowBindings, BasicQuantBindings, BasicReduceMeanBindings, BasicReduceSumBindings, BasicReluBinding, \
+    BasicReshapeBindings, BasicRQIntegerDivBinding, BasicRQSBindings, BasicRQSGELUBinding, BasicSliceBindings, \
+    BasicSoftmaxBindings, BasicSqrtBindings, BasicSubBindings, BasicTransposeBindings, DummyBinding
 from Deeploy.Targets.Generic.Layers import AddLayer, BatchNormalizationLayer, CeilLayer, ClipLayer, ConcatLayer, \
-    ConvLayer, ConvTransposeLayer, DebugPrintLayer, DequantLayer, DivLayer, FloorLayer, GatherLayer, GELULayer, \
-    GEMMLayer, ITAMaxLayer, LayerNormLayer, MatMulLayer, MaxPoolLayer, MulLayer, PadLayer, PowLayer, QuantLayer, \
-    ReduceMeanLayer, ReduceSumLayer, ReluLayer, RequantShiftLayer, ReshapeLayer, RQIntegerDivLayer, RQSiGELULayer, \
-    SliceLayer, SoftmaxLayer, SqrtLayer, SubLayer, TransposeLayer
+    ConvLayer, ConvTransposeLayer, DebugPrintLayer, DequantLayer, DivLayer, ExpLayer, FloorLayer, GatherLayer, \
+    GELULayer, GEMMLayer, ITAMaxLayer, LayerNormLayer, MatMulLayer, MaxPoolLayer, MulLayer, PadLayer, PowLayer, \
+    QuantLayer, ReduceMeanLayer, ReduceSumLayer, ReluLayer, RequantShiftLayer, ReshapeLayer, RQIntegerDivLayer, \
+    RQSiGELULayer, SliceLayer, SoftmaxLayer, SqrtLayer, SubLayer, TransposeLayer
 from Deeploy.Targets.Generic.Parsers import AddParser, BatchNormParser, CeilParser, ClipParser, ConcatParser, \
-    ConvTranspose1DParser, DebugParser, DequantParser, DivParser, DummyParser, FlattenParser, FloorParser, \
+    ConvTranspose1DParser, DebugParser, DequantParser, DivParser, DummyParser, ExpParser, FlattenParser, FloorParser, \
     GatherParser, GELUParser, GenericConv1DParser, GenericConv2DParser, GenericDWConv1DParser, GenericDWConv2DParser, \
     GenericGEMMParser, GenericMaxPool2DParser, IntegerDivParser, ITAMaxParser, ITAPartialMaxParser, LayerNormParser, \
     MatMulParser, MaxPool1DParser, MulParser, Pad1DParser, Pad2DParser, PowParser, QuantParser, ReduceMeanParser, \
@@ -77,6 +77,7 @@
 CeilMapper = NodeMapper(CeilParser(), BasicCeilBindings)
 FloorMapper = NodeMapper(FloorParser(), BasicFloorBindings)
 ClipMapper = NodeMapper(ClipParser(), BasicClipBindings)
+ExpMapper = NodeMapper(ExpParser(), BasicExpBindings)
 
 # Dummy nodes are intended for development purposes only!
 # They should always generate compiler errors to not accidentally end up in production code
@@ -127,6 +128,7 @@
     'Ceil': CeilLayer([CeilMapper]),
     'Floor': FloorLayer([FloorMapper]),
     'Clip': ClipLayer([ClipMapper]),
+    'Exp': ExpLayer([ExpMapper]),
     # # For example, you can use the DummpyMapper, in case you want to test
     # # deployment or optimizations with GlobalAveragePool nodes but did not yet
     # # implement the corresponding kernel

Deeploy/Targets/Generic/Templates/FloatExpTemplate.py

@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: 2021 ETH Zurich and University of Bologna
+#
+# SPDX-License-Identifier: Apache-2.0
+import numpy as np
+
+from Deeploy.DeeployTypes import NetworkContext, NodeTemplate, OperatorRepresentation
+
+
+class _ExpTemplate(NodeTemplate):
+
+    def alignToContext(self, ctxt: NetworkContext,
+                       operatorRepresentation: OperatorRepresentation) -> tuple[NetworkContext, dict, list[str]]:
+
+        data_in = ctxt.lookup(operatorRepresentation['data_in'])
+        operatorRepresentation['size'] = int(np.prod(data_in.shape))
+        operatorRepresentation['type_width'] = data_in._type.referencedType.typeWidth
+        return ctxt, operatorRepresentation, []
+
+
+referenceTemplate = _ExpTemplate("""
+// Exp (Name: ${nodeName}, Op: ${nodeOp})
+Exp_fp${type_width}_fp${type_width}(${data_in}, ${data_out}, ${size});
+""")

DeeployTest/Tests/Kernels/FP32/Exp/inputs.npz

@@ -39,6 +39,7 @@
 #include "kernel/Convolution.h"
 #include "kernel/DWConvolution.h"
 #include "kernel/Div.h"
+#include "kernel/Exp.h"
 #include "kernel/Floor.h"
 #include "kernel/GELU.h"
 #include "kernel/Gemm.h"

DeeployTest/Tests/Kernels/FP32/Exp/network.onnx

@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2020 ETH Zurich and University of Bologna
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef __DEEPLOY_BASIC_MATH_EXP_KERNEL_HEADER_
+#define __DEEPLOY_BASIC_MATH_EXP_KERNEL_HEADER_
+
+#include "DeeployBasicMath.h"
+
+/*
+ * element wise exponential
+ */
+
+/******************************************************************************/
+/*                              Exp                                          */
+/******************************************************************************/
+void Exp_fp32_fp32(float32_t *data_in, float32_t *data_out, int32_t size);
+
+#endif //__DEEPLOY_BASIC_MATH_EXP_KERNEL_HEADER_