[refactor-parsing] New parsing procedure

.github/workflows/ci-deeploy.yml

@@ -61,9 +61,9 @@ jobs:
         run: |
           cd DeeployTest
           python testMVP.py -t Tests/CCT/CCT_1_16_16_8 -p Siracusa --defaultMemLevel=L2 --l1=64000 --l2=75000 --memAllocStrategy=MiniMalloc
-          python testMVP.py -t Tests/CCT/CCT_1_16_16_8 -p Siracusa --defaultMemLevel=L2 --l1=64000 --l2=60000 --memAllocStrategy=MiniMalloc --shouldFail
+          python testMVP.py -t Tests/CCT/CCT_1_16_16_8 -p Siracusa --defaultMemLevel=L2 --l1=64000 --l2=50000 --memAllocStrategy=MiniMalloc --shouldFail
           python testMVP.py -t Tests/CCT/CCT_1_16_16_8 -p Siracusa --defaultMemLevel=L2 --l1=64000 --l2=90000 --memAllocStrategy=TetrisRandom
-          python testMVP.py -t Tests/CCT/CCT_1_16_16_8 -p Siracusa --defaultMemLevel=L2 --l1=64000 --l2=75000 --memAllocStrategy=TetrisRandom --shouldFail
+          python testMVP.py -t Tests/CCT/CCT_1_16_16_8 -p Siracusa --defaultMemLevel=L2 --l1=64000 --l2=69000 --memAllocStrategy=TetrisRandom --shouldFail
 
   deeploy-state-serialization:
     needs: select-env

CHANGELOG.md

@@ -177,9 +177,9 @@ This release containing major architectural changes, new platform support, enhan
 
 
 ### Added
-- BatchNorm kernel 
-- ConvTranspose kernel 
-- MaxPool1D kernel 
+- BatchNorm kernel
+- ConvTranspose kernel
+- MaxPool1D kernel
 - Template for 1D Convolution
 - Support for float32 data type in the previous kernels
 - Float binding for Pad1D kernel
@@ -318,7 +318,7 @@ This release containing major architectural changes, new platform support, enhan
 
 ### Changed
 - FloatConvTemplate file
-- Platform.py file  
+- Platform.py file
 - Bump the CMake version to 3.24 as required for the chimera-sdk
 - Bump GVSoC's version and add chimera simulation target
 - Rename the generic source util to utils to avoid name collision with chimera-sdk

Deeploy/AbstractDataTypes.py

@@ -206,12 +206,20 @@ def checkValue(cls, value: Union[int, Iterable[int], np.ndarray], ctxt: Optional
 
         if isinstance(value, int):
             _max, _min = (value, value)
+        elif isinstance(value, np.number):
+            value = value.item()
+            if isinstance(value, float):
+                assert value.is_integer(), f"Floating-point value {value} is not an integer."
+                value = int(value)
+            _max, _min = (value, value)
         elif isinstance(value, np.ndarray):
             _max = value.max()
             _min = value.min()
         elif isinstance(value, Iterable):
             _max = max(value)
             _min = min(value)
+        else:
+            raise ValueError(f"Unsupported value of type {type(value)} with value {value}")
 
         if _max > cls.typeMax:
             return False

Deeploy/CommonExtensions/DataTypes.py

@@ -87,11 +87,11 @@ class float64_t(FloatImmediate):
 
 SignedIntegerDataTypes: Tuple[Type[IntegerImmediate], ...] = (int8_t, int16_t, int32_t, int64_t)
 UnsignedIntegerDataTypes: Tuple[Type[IntegerImmediate], ...] = (uint8_t, uint16_t, uint32_t, uint64_t)
-IntegerDataTypes: Tuple[Type[IntegerImmediate], ...] = (sorted((
-    *SignedIntegerDataTypes,
-    *UnsignedIntegerDataTypes,
-),
-                                                               key = lambda _type: _type.typeWidth))
+IntegerDataTypes: Tuple[Type[IntegerImmediate], ...] = tuple(
+    sorted((
+        *SignedIntegerDataTypes,
+        *UnsignedIntegerDataTypes,
+    ), key = lambda _type: _type.typeWidth))
 FloatDataTypes: Tuple[Type[FloatImmediate], ...] = (bfloat16_t, float16_t, float32_t, float64_t)
 
 

Deeploy/CommonExtensions/NetworkDeployers/NetworkDeployerWrapper.py

@@ -6,7 +6,7 @@
 
 import onnx_graphsurgeon as gs
 
-from Deeploy.DeeployTypes import CodeGenVerbosity, NetworkContext, NetworkDeployer, ONNXLayer, _NoVerbosity
+from Deeploy.DeeployTypes import CodeGenVerbosity, NetworkDeployer, ONNXLayer, _NoVerbosity
 
 
 class NetworkDeployerWrapper(NetworkDeployer):
@@ -48,8 +48,8 @@ def prepared(self):
     """
 
     # SignPropDeployer augment
-    def _createIOBindings(self, ctxt: NetworkContext, graph: gs.Graph):
-        return self._innerObject._createIOBindings(ctxt, graph)
+    def parse(self, default_channels_first: bool = True) -> bool:
+        return self._innerObject.parse(default_channels_first)
 
     # MemoryAwareDeployer, TilerAwareDeployer, and PULPDeployer augments
     def bind(self) -> bool:

Deeploy/CommonExtensions/NetworkDeployers/SignPropDeployer.py

@@ -6,8 +6,10 @@
 
 import onnx_graphsurgeon as gs
 
-from Deeploy.AbstractDataTypes import Pointer
-from Deeploy.DeeployTypes import DeploymentPlatform, NetworkDeployer, TopologyOptimizer
+from Deeploy.AbstractDataTypes import IntegerImmediate, Pointer
+from Deeploy.CommonExtensions.TypeCheckers.SignPropTypeChecker import SignPropTypeChecker
+from Deeploy.DeeployTypes import ConstantBuffer, DeploymentPlatform, NetworkDeployer, OperatorDescriptor, \
+    TopologyOptimizer, VariableBuffer
 from Deeploy.Logging import DEFAULT_LOGGER as log
 
 
@@ -18,12 +20,13 @@ def __init__(self,
                  deploymentPlatform: DeploymentPlatform,
                  inputTypes: Dict[str, Type[Pointer]],
                  loweringOptimizer: TopologyOptimizer,
+                 operatorDescriptors: Dict[str, OperatorDescriptor],
                  scheduler: Callable = lambda x: x,
                  name: str = 'DeeployNetwork',
                  default_channels_first: bool = True,
                  deeployStateDir: str = "DeeployState",
                  inputOffsets: Dict[str, int] = {}):
-        super().__init__(graph, deploymentPlatform, inputTypes, loweringOptimizer, scheduler, name,
+        super().__init__(graph, deploymentPlatform, inputTypes, loweringOptimizer, operatorDescriptors, scheduler, name,
                          default_channels_first, deeployStateDir)
 
         if inputOffsets == {}:
@@ -32,17 +35,6 @@ def __init__(self,
 
         self.inputOffsets = inputOffsets
 
-    def _createIOBindings(self, ctxt, graph):
-        ctxt = super()._createIOBindings(ctxt, graph)
-        for node in graph.inputs:
-            data_name = node.name
-            nb = ctxt.lookup(data_name)
-            data_type = self.inputTypes[data_name]
-            nb._signed = (self.inputOffsets[data_name] == 0)
-            nb.nLevels = (2**data_type.referencedType.typeWidth)
-
-        return ctxt
-
     def _printInputOutputSummary(self):
         log.info('Input:')
         for buf in self.inputs():
@@ -55,3 +47,39 @@ def _printInputOutputSummary(self):
             log.info(
                 f" - '{buf.name}': Type: {buf._type.referencedType.typeName}, nLevels: {buf.nLevels}, Signed: {buf._signed}"
             )
+
+    def parse(self, default_channels_first: bool = True) -> bool:
+        parsable = super().parse(default_channels_first)
+        if not parsable:
+            return False
+
+        # Annotate global buffers
+        for obj in self.ctxt.globalObjects.values():
+            assert isinstance(obj, VariableBuffer)
+            refTy = obj._type.referencedType
+            if isinstance(obj, ConstantBuffer):
+                assert refTy.checkPromotion(obj.values), f"Can't cast {obj} to {refTy}"
+                if issubclass(refTy, IntegerImmediate):
+                    obj.nLevels = obj.values.max() - obj.values.min()
+                    obj._signed = refTy.typeMin < 0
+            elif obj.name in self.inputOffsets:
+                obj._signed = (self.inputOffsets[obj.name] == 0)
+                obj.nLevels = (2**refTy.typeWidth)
+
+        # Annotate rest
+        for layer in self.layerBinding.values():
+            node = layer.node
+            opRepr = layer.mapper.parser.operatorRepresentation
+            typeChecker = layer.mapper.binder.typeChecker
+            outTy = self.ctxt.lookup(node.outputs[0].name)._type.referencedType
+            if issubclass(outTy, IntegerImmediate) and isinstance(typeChecker, SignPropTypeChecker):
+                inputs = [self.ctxt.lookup(t.name) for t in node.inputs]
+                outputNLevels = typeChecker._inferNumLevels(inputs, opRepr)
+                outputSigned = typeChecker._inferSignedness(inputs, opRepr)
+
+                outputs = [self.ctxt.lookup(t.name) for t in node.outputs]
+                for buffer, nLevels, signed in zip(outputs, outputNLevels, outputSigned):
+                    buffer.nLevels = nLevels
+                    buffer._signed = signed
+
+        return True

Deeploy/CommonExtensions/NodeTemplate.py

@@ -0,0 +1,84 @@
+# SPDX-FileCopyrightText: 2021 ETH Zurich and University of Bologna
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import List, Sequence, Tuple
+
+import numpy as np
+import onnx_graphsurgeon as gs
+
+from Deeploy.DeeployTypes import NodeTemplate
+
+
+class ElementwiseTemplate(NodeTemplate):
+
+    def alignShapes(self, node: gs.Node) -> Tuple[List[Sequence[int]], List[Sequence[int]]]:
+        assert len(node.outputs) == 1, f"Expected only one output. Received {len(node.outputs)}"
+        shape = tuple(np.broadcast_shapes(*[t.shape for t in node.inputs]))
+        return [shape] * len(node.inputs), [shape]
+
+
+class ElementwiseScalarTemplate(NodeTemplate):
+
+    def alignShapes(self, node: gs.Node) -> Tuple[List[Sequence[int]], List[Sequence[int]]]:
+        assert len(node.inputs) == 2, f"Expected only two inputs. Received {len(node.inputs)}"
+        assert len(node.outputs) == 1, f"Expected only one output. Received {len(node.outputs)}"
+        shape = tuple(node.inputs[0].shape)
+        return [shape, (1,)], [shape]
+
+
+class RequantShiftTemplate(NodeTemplate):
+
+    def alignShapes(self, node: gs.Node) -> Tuple[List[Sequence[int]], List[Sequence[int]]]:
+        inShapes, outShapes = [t.shape for t in node.inputs], [t.shape for t in node.outputs]
+        batch, ch = inShapes[0][:2]
+        # TODO: Copied from old computeShape. Should probably be investigated
+        inShapes[1] = (batch, ch, *inShapes[1][1:])
+        inShapes[2] = (batch, ch, *inShapes[2][1:])
+        return inShapes, outShapes
+
+
+class ConvTemplate(NodeTemplate):
+
+    @staticmethod
+    def minPerChannelTensorShape(node: gs.Node, channels: int) -> Tuple[int, ...]:
+        spatialDims = len(node.attrs["kernel_shape"])
+        if node.attrs["channels_first"]:
+            return (channels,) + (1,) * (spatialDims)
+        else:
+            return (channels,)
+
+    def alignShapes(self, node: gs.Node) -> Tuple[List[Sequence[int]], List[Sequence[int]]]:
+        inShapes, outShapes = [t.shape for t in node.inputs], [t.shape for t in node.outputs]
+        if len(node.inputs) == 3:
+            minBiasShape = self.minPerChannelTensorShape(node, inShapes[1][0])
+            inShapes[2] = minBiasShape
+        return inShapes, outShapes
+
+
+class RequantizedConvTemplate(ConvTemplate):
+
+    def alignShapes(self, node: gs.Node) -> Tuple[List[Sequence[int]], List[Sequence[int]]]:
+        inShapes, outShapes = [t.shape for t in node.inputs[:2]], [t.shape for t in node.outputs]
+        minRqsShape = self.minPerChannelTensorShape(node, inShapes[1][0])
+        rqsShapes = [minRqsShape] * len(node.inputs[2:])
+        return inShapes + rqsShapes, outShapes
+
+
+class GemmTemplate(NodeTemplate):
+
+    def alignShapes(self, node: gs.Node) -> Tuple[List[Sequence[int]], List[Sequence[int]]]:
+        biasShape = node.outputs[0].shape[-2:]
+        return [node.inputs[0].shape, node.inputs[1].shape, biasShape], [node.outputs[0].shape]
+
+
+class RequantizedGemmTemplate(NodeTemplate):
+
+    def alignShapes(self, node: gs.Node) -> Tuple[List[Sequence[int]], List[Sequence[int]]]:
+        inShapes, outShapes = [t.shape for t in node.inputs[:2]], [t.shape for t in node.outputs]
+        if node.attrs["transB"]:
+            N = inShapes[1][-2]
+        else:
+            N = inShapes[1][-1]
+        rqsShapes = [(N,)] * len(node.inputs[2:])
+        return inShapes + rqsShapes, outShapes

Deeploy/CommonExtensions/TypeCheckers/SignPropTypeChecker.py

@@ -2,7 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import List, Optional
+from abc import ABC, abstractmethod
+from typing import List
 
 import onnx_graphsurgeon as gs
 
@@ -11,27 +12,30 @@
 from Deeploy.Logging import DEFAULT_LOGGER as log
 
 
-class SignPropTypeChecker(NodeTypeChecker):
+class SignPropTypeChecker(NodeTypeChecker, ABC):
 
+    @abstractmethod
     def _inferNumLevels(self, inputs: List[VariableBuffer],
-                        operatorRepresentation: OperatorRepresentation) -> Optional[List[int]]:
-        return None
+                        operatorRepresentation: OperatorRepresentation) -> List[int]:
+        pass
 
+    @abstractmethod
     def _inferSignedness(self, inputs: List[VariableBuffer],
-                         operatorRepresentation: OperatorRepresentation) -> Optional[List[int]]:
-        return None
+                         operatorRepresentation: OperatorRepresentation) -> List[bool]:
+        pass
 
     def typeInferGlobalCtxt(self, ctxt: NetworkContext, node: gs.Node) -> NetworkContext:
         ctxt = super().typeInferGlobalCtxt(ctxt, node)
 
-        for inputNode, _type in zip(node.inputs, self.input_types):
-            if isinstance(ctxt.lookup(inputNode.name), ConstantBuffer):
-                reference = ctxt.lookup(inputNode.name)
-                if not _type.referencedType.checkPromotion(reference.values):
-                    raise Exception(f"Can't cast {reference} to {_type}!")
-
-                reference.nLevels = reference.values.max() - reference.values.min()
-                reference._signed = _type.referencedType.typeMin < 0
+        for tensor, _type in zip(node.inputs, self.input_types):
+            buffer = ctxt.lookup(tensor.name)
+            if isinstance(buffer, ConstantBuffer):
+                refTy = _type.referencedType
+                assert issubclass(refTy, IntegerImmediate)
+                if not refTy.checkPromotion(buffer.values):
+                    raise ValueError(f"Can't cast {buffer} to {refTy}!")
+                buffer.nLevels = buffer.values.max() - buffer.values.min()
+                buffer._signed = refTy.typeMin < 0
 
         return ctxt
 
@@ -42,21 +46,16 @@ def typeInferOutput(self, ctxt: NetworkContext, node: gs.Node,
         inputs = [ctxt.lookup(inputNode.name) for inputNode in node.inputs]
         outputs = [ctxt.lookup(outputNode.name) for outputNode in node.outputs]
 
-        signProp = all([hasattr(_input, "_signed") and hasattr(_input, "nLevels") for _input in inputs])
-
-        if signProp:
-            nLevels = self._inferNumLevels(inputs, operatorRepresentation)
-            signedness = self._inferSignedness(inputs, operatorRepresentation)
-
-            if nLevels is None or signedness is None:
-                return ctxt
-            for obj, nLevel, sign in zip(outputs, nLevels, signedness):
-                obj.nLevels = nLevel
-                obj._signed = sign
-
-                if issubclass(obj._type.referencedType, IntegerImmediate) and not obj._type.fitsNumLevels(nLevel):
-                    log.warning(
-                        f"{obj.name} has {nLevel} levels, but {obj._type.referencedType.typeName} only supports {obj._type.referencedType.nLevels} levels."
-                    )
+        nLevels = self._inferNumLevels(inputs, operatorRepresentation)
+        signedness = self._inferSignedness(inputs, operatorRepresentation)
+
+        for obj, nLevels, sign in zip(outputs, nLevels, signedness):
+            assert isinstance(obj, VariableBuffer)
+            obj.nLevels = nLevels
+            obj._signed = sign
+            refTy = obj._type.referencedType
+            if issubclass(refTy, IntegerImmediate) and not refTy.fitsNumLevels(nLevels):
+                log.warning(
+                    f"{obj.name} has {nLevels} levels, but {refTy.typeName} only supports {refTy.nLevels} levels.")
 
         return ctxt