Post-rebase fixes

Author: diaconuccalin

Deeploy/CommonExtensions/CodeTransformationPasses/Closure.py

@@ -155,7 +155,7 @@ def apply(self,
               executionBlock: ExecutionBlock,
               name: str,
               verbose: CodeGenVerbosity = _NoVerbosity) -> Tuple[NetworkContext, ExecutionBlock]:
-        # Add underscore to avoid name issues when beginning with problematic characters (like numbers)
+        # Prepend underscore to avoid name issues when beginning with problematic characters (like numbers)
         self.closureName = "_" + name + self.closureSuffix
         self.functionCall = executionBlock.generate(ctxt)
         self._generateClosureStruct(ctxt, executionBlock)

Deeploy/CommonExtensions/OptimizationPasses/TopologyOptimizationPasses/LoweringOptimizationPasses.py

@@ -124,11 +124,8 @@ def _transformLayoutPermutation(dims: int, spatialDims: int, targetChannelsFirst
 
 
 # Calculate permutation q = p^(-1) s.t. q(p(i)) = i
-def _invertPermutation(permutation: List[int]) -> List[int]:
-    inverse = [0] * len(permutation)
-    for idx, permIdx in enumerate(permutation):
-        inverse[permIdx] = idx
-    return inverse
+def _invertPermutation(permutation: Sequence[int]) -> List[int]:
+    return [permutation.index(i) for i in range(len(permutation))]
 
 
 T = TypeVar('T')
@@ -283,31 +280,10 @@ def __init__(self, default_channels_first: bool = True):
         super().__init__(graph, partial(_NCHWtoNHWC_fun, default_channels_first = default_channels_first), name)
 
 
-@contextagnostic
-class NCHWtoNHWCPass(SequentialPass):
-
-    def __init__(self, default_channels_first: bool = True):
-        passes = [
-            NCHWtoNHWCPadPass(default_channels_first),
-            NCHWtoNHWCMaxPoolPass(default_channels_first),
-            NCHWtoNHWCConvPass(default_channels_first),
-            NCHWtoNHWCRequantizedConvPass(default_channels_first),
-        ]
-        super().__init__(*passes)
-
-
-def _PULPDWNCHWtoNHWC_fun(graph: gs.Graph, match: Match, name: str, default_channels_first: bool = True):
-
-    matched_nodes = [m for k, m in match.nodes_map.items()]
-    opNode = matched_nodes[0]
-    node_op = opNode.op
-
-    if 'group' in opNode.attrs and opNode.attrs['group'] == 1:
 def _NCWHtoNHWC_dw_fun(graph: gs.Graph, match: Match, name: str, default_channels_first: bool) -> gs.Graph:
     node = next(iter((match.nodes_map.values())))
 
     if not _isDepthwise(node):
-    if opNode.attrs.get('group', 1) == 1:
         return graph
 
     channels_first = node.attrs.get("channels_first", True)
@@ -340,47 +316,10 @@ def _NCWHtoNHWC_dw_fun(graph: gs.Graph, match: Match, name: str, default_channel
 class NCHWtoNHWCDwConvPass(ReplaceSequentialPatternPass):
 
     def __init__(self, default_channels_first: bool = True):
-        # Define pattern graph
-        graph = gs.Graph()
-
-        _input = gs.Variable(name = 'input_1')
-        output = graph.layer(inputs = [_input], outputs = ['convOut'], op = 'RequantizedConv', name = 'requantizedConv')
-
-        graph.outputs.append(output)
-        graph.inputs.append(_input)
-
-        # Define name
+        graph = _singleNodePattern(op = "Conv|RequantizedConv")
         name = "_NCHW_TO_NHWC_DW_CONV_PASS"
-
-        # Initialize Pass
-        super().__init__(pattern = graph,
-                         replacement_fn = partial(_PULPDWNCHWtoNHWC_fun,
-                                                  default_channels_first = default_channels_first),
-                         name = name)
-
-
-# Float DW Conv
-@contextagnostic
-class PULPFPDWConvPass(ReplaceSequentialPatternPass):
-
-    def __init__(self, default_channels_first: bool = True):
-        # Define pattern graph
-        graph = gs.Graph()
-
-        _input = gs.Variable(name = 'input_1')
-        output = graph.layer(inputs = [_input], outputs = ['convOut'], op = 'Conv', name = 'conv')
-
-        graph.outputs.append(output)
-        graph.inputs.append(_input)
-
-        # Define name
-        name = "_NCHW_TO_NHWC_FP_DW_CONV_PASS"
-
-        # Initialize Pass
-        super().__init__(pattern = graph,
-                         replacement_fn = partial(_PULPDWNCHWtoNHWC_fun,
-                                                  default_channels_first = default_channels_first),
-                         name = name)
+        super().__init__(graph, partial(_NCWHtoNHWC_dw_fun, default_channels_first = default_channels_first), name,
+                         NonBranchingMatcher(regex_op = True))
 
 
 def _PULP_NCHWtoNHWC_dw_fun(graph: gs.Graph, match: Match, name: str, default_channels_first: bool = True):
@@ -425,10 +364,8 @@ def __init__(self, default_channels_first: bool = True):
         passes = [
             NCHWtoNHWCPadPass(default_channels_first),
             NCHWtoNHWCMaxPoolPass(default_channels_first),
-            PULPDWConvPass(default_channels_first),
-            PULPFPDWConvPass(default_channels_first),
-            PULPNCHWtoNHWCDenseConvPass(default_channels_first),
-            PULPNCHWtoNHWCDenseRequantizedConvPass(default_channels_first),
+            NCHWtoNHWCDwConvPass(default_channels_first),
+            NCHWtoNHWCConvPass(default_channels_first),
         ]
         super().__init__(*passes)
 
@@ -494,11 +431,6 @@ def _requantized_gemm_to_pw_fun(graph: gs.Graph, match: Match, name: str):
     matrixAExpandDimsNode, pwIn = _appendExpandDims(matrixA, name, axis = expandAxis)
     graph.nodes.append(matrixAExpandDimsNode)
 
-    # If transB is set then the matrix is of shape [N x K] and it doesn't need to be transposed, otherwise its shape is [K x N] and it has to be transposed
-    if not 'transB' in requantizedGemm.attrs or requantizedGemm.attrs['transB'] == 0:
-        # matrixBTransposed, shape [N x K]
-        matrixBTransposeNode, matrixB = _appendTransposeNode(matrixB, name, _permutationLastTwoDims(len(matrixB.shape)))
-        graph.nodes.append(matrixBTransposeNode)
     # pwWeight, shape [N x 1 x 1 x K]
     matrixBExpandDimsNode, pwWeight = _appendExpandDims(matrixB, name, axis = (1, 2))
     graph.nodes.append(matrixBExpandDimsNode)

Deeploy/DeeployTypes.py

@@ -398,17 +398,6 @@ def sizeInBytes(self) -> int:
         """
         return (math.prod(self.shape) * (self._type.referencedType.typeWidth)) // 8
 
-    def sizeInBytes(self) -> int:
-        """Returns the size of this VariableBuffer in bytes
-
-        Returns
-        -------
-        int
-            Size of this VariableBuffer in bytes
-
-        """
-        return (math.prod(self.shape) * (self._type.referencedType.typeWidth)) // 8
-
 
 class TransientBuffer(VariableBuffer):
     """Class to represent memory space required by kernels that is not covered by input and output tensors, e.g. im2col buffers in convolutions
@@ -444,9 +433,6 @@ def __repr__(self) -> str:
     def sizeInBytes(self) -> int:
         return int(self.size)
 
-    def sizeInBytes(self) -> int:
-        return int(self.size)
-
 
 class ConstantBuffer(VariableBuffer):
     """Class to represent compile-time constant tensors (weights, biases, other parameters) within Deeploy.
@@ -890,7 +876,7 @@ def is_buffer(self, value: Any) -> bool:
         obj = self.lookup(value)
         return isinstance(obj, VariableBuffer)
 
-    def hoistTransientBuffer(self, name: str, size: Union[int, str]) -> str:
+    def hoistTransientBuffer(self, name: str, size: int) -> str:
         """Registers a new TransientBuffer in the local context
 
         Parameters

Deeploy/MemoryLevelExtension/NetworkDeployers/MemoryLevelDeployer.py

@@ -128,18 +128,6 @@ def getTargetMemoryLevelMapping(self) -> TargetMemoryLevelMapping:
             f"Platform should be a MemoryPlatform or MemoryPlatformWrapper! Got {type(self.Platform).__name__}"
         return TargetMemoryLevelMapping(self.graph, self.Platform, self.ctxt)
 
-    def _parseNode(self, node: ONNXLayer, ctxt: NetworkContext,
-                   default_channels_first: bool) -> Tuple[NetworkContext, bool]:
-
-        newCtxt, parsePass = super()._parseNode(node, ctxt, default_channels_first)
-
-        if not parsePass:
-            return ctxt, False
-
-        newCtxt, self.graph = self.memoryLevelAnnotationOptimizer.optimize(newCtxt, self.graph)
-
-        return newCtxt, parsePass
-
     def bind(self):
         log.info("- Perform Memory Level Annotation")
         # LMACAN: Annotate before bind because during binding (specifically alignToContext) templates
@@ -150,7 +138,6 @@ def bind(self):
         if not ret:
             return False
 
-        log.info("- Perform Memory Level Annotation")
         # SCHEREMO: There might be hoisting; reassign memoryLevel preferences
         self.ctxt, self.graph = self.memoryLevelAnnotationOptimizer.optimize(self.ctxt, self.graph)
 
@@ -195,7 +182,6 @@ def bind(self):
         if not ret:
             return False
 
-        log.info("- Perform Memory Level Annotation")
         # SCHEREMO: There might be hoisting; reassign memoryLevel preferences
         self.ctxt, self.graph = self.memoryLevelAnnotationOptimizer.optimize(self.ctxt, self.graph)
 
@@ -231,7 +217,6 @@ def bind(self):
         if not ret:
             return False
 
-        log.info("- Perform Memory Level Annotation")
         # SCHEREMO: There might be hoisting; reassign memoryLevel preferences
         self.ctxt, self.graph = self.memoryLevelAnnotationOptimizer.optimize(self.ctxt, self.graph)
 

Deeploy/Targets/Generic/Parsers.py

@@ -1068,36 +1068,10 @@ def parseNodeCtxt(self,
                       node: gs.Node,
                       channels_first: bool = True) -> Tuple[NetworkContext, bool]:
 
-        # Define names of node inputs and outputs, according to the ONNX standard
-        inputs = ['data_in', 'shape']
-        outputs = ['data_out']
-
-        # Map inputs and outputs to their corresponding names in the operator representation
-        for idx, inputNode in enumerate(node.inputs):
-            self.operatorRepresentation[inputs[idx]] = ctxt.lookup(inputNode.name).name
-        for idx, outputNode in enumerate(node.outputs):
-            self.operatorRepresentation[outputs[idx]] = ctxt.lookup(outputNode.name).name
-
-        # Update alias_of parameter for the output node
-        output_node = ctxt.lookup(node.outputs[outputs.index("data_out")].name)
-        input_node = ctxt.lookup(node.inputs[inputs.index("data_in")].name)
-
-        # Prepare new aliases
-        new_output_node_aliases = input_node.get_aliases_of()
-        new_output_node_aliases.append(input_node.name)
-
-        # Add new aliases to output node
-        output_node.add_aliases(aliases_to_add = new_output_node_aliases)
-
-        # Add output node as alias to its aliases (alias relationship is symmetric)
-        for alias in output_node.get_aliases_of():
-            alias_node = ctxt.lookup(alias)
-            alias_node.add_aliases(aliases_to_add = [
-                output_node.name,
-            ])
-
-        # Compute data size
-        self.operatorRepresentation['size'] = np.prod(ctxt.lookup(node.inputs[0].name).shape)
+        for tensor, symName in zip(node.inputs, ['data_in', 'shape']):
+            self.operatorRepresentation[symName] = ctxt.lookup(tensor.name).name
+        for tensor, symName in zip(node.outputs, ['data_out']):
+            self.operatorRepresentation[symName] = ctxt.lookup(tensor.name).name
 
         return ctxt, True