Add 2D Autoencoder and GMM Integration on Siracusa Target

.pre-commit-config.yaml

@@ -30,7 +30,7 @@ repos:
       - id: reuse
         name: Check SPDX License Headers
         entry: scripts/reuse_skip_wrapper.py
-        additional_dependencies: ["reuse==6.2.0"]
+        additional_dependencies: ["reuse[charset-normalizer]==6.2.0"]
         language: python
         stages: [pre-commit, pre-merge-commit, pre-push, manual]
         types: [text]

CHANGELOG.md

@@ -5,6 +5,7 @@ This file contains the changelog for the Deeploy project. The changelog is divid
 
 
 ### List of Pull Requests
+- Add 2D Autoencoder and GMM Integration on Siracusa Target [#190](https://github.com/pulp-platform/Deeploy/pull/190)
 - Fix Neureka [#188](https://github.com/pulp-platform/Deeploy/pull/188)
 - HOTFIX: XDNA2 Action Fix [#201](https://github.com/pulp-platform/Deeploy/pull/201)
 - XDNA2 Platform Support [#179](https://github.com/pulp-platform/Deeploy/pull/179)
@@ -67,6 +68,12 @@ This file contains the changelog for the Deeploy project. The changelog is divid
 - Skip emitting duplicate `testInputVector` data for inputs placed in L3 (loaded at runtime from the readfs hex instead), reducing test binary size
 
 ### Fixed
+- Reject non-finite outputs in the PULPOpen/Siracusa floating-point test comparison.
+- Preserve target-specific buffer initialization templates; keep NULL pointer initialization in the PULP allocation templates.
+- Preserve dynamic biases in MatMul/Add fusion and avoid fusing shapes or shared outputs incompatible with Gemm.
+- Restore PULPOpen floating-point Slice tiling with per-tile dimensions and local indices, including strided and reversed slices.
+- Support padding, dilation and grouped weights in the Generic FP32 ConvTranspose2D kernel.
+- Align PULPOpen FP32 MaxPool kernel and stride arguments with the parser's height/width order, and correct directional padding for MaxPool2D.
 - Fix Neureka's output-channels subtile size (in ConvTemplate) and Dense/DW/PW tile constraints
 - in `NetworkContainer._createIOBindings`, set `_live = True` on network input and output buffers so that any buffer aliasing a network I/O tensor is no longer deallocated while the I/O tensor is still in use.
 - Fix latent bug in `VariableBuffer.has_live_aliases` where `visited` variable was storing buffer names as a set of characters instead of strings.

Deeploy/DeeployTypes.py

@@ -960,12 +960,16 @@ def hoistConstant(self,
                       constant: gs.Constant,
                       name: Optional[str] = None,
                       _type: Optional[Type[Pointer]] = None) -> str:
-        """Register a ConstantBuffer extracted directly from a graphsurgeon Constant
+        """Register a ConstantBuffer extracted directly from a graphsurgeon Constant.
+
+        A constant tensor may be consumed by multiple nodes: ``constant.outputs``
+        lists its consumers, not separate tensor values. ``NodeParser.parseInputs``
+        registers the tensor once and records each consumer with ``addUser``.
 
         Parameters
         ----------
         constant : gs.Constant
-            graphsurgeon.Node containing a single constant output
+            graphsurgeon constant tensor to register
         name : str
             Name of the ConstantBuffer to be registered
         _type : Optional[Type[Pointer]]
@@ -977,8 +981,6 @@ def hoistConstant(self,
             Returns the name of the newly registed ConstantBuffer
 
         """
-        assert len(constant.outputs) <= 1, f"Constant {constant.name} has more than one output"
-
         name = name if name is not None else constant.name
 
         # LMACAN: The shape needs to be copied into a tuple for pickling to work. Don't ask me why..
@@ -2028,22 +2030,18 @@ def parse(self, ctxt: NetworkContext, default_channels_first: bool) -> Tuple[Net
 
     def _broadcastToNpType(self, ty: Type[BaseType]):
 
-        def _broadcastInteger(ty: Type[IntegerImmediate]):
-            if ty.signed:
-                return np.dtype(getattr(np, "int" + str(ty.typeWidth)))
-            else:
-                return np.dtype(getattr(np, "uint" + str(ty.typeWidth)))
+        def _broadcastInteger(immediateType: Type[IntegerImmediate]):
+            prefix = "int" if immediateType.signed else "uint"
+            return np.dtype(getattr(np, prefix + str(immediateType.typeWidth)))
 
-        def _broadcastFloat(ty: Type[FloatImmediate]):
-            return np.dtype(getattr(np, "double"))
+        def _broadcastFloat(immediateType: Type[FloatImmediate]):
+            return np.dtype(getattr(np, "float" + str(immediateType.typeWidth)))
 
-        if issubclass(ty, Pointer) and hasattr(ty, "referencedType"):
-            if issubclass(ty.referencedType, IntegerImmediate):
-                return _broadcastInteger(ty.referencedType)
-        elif issubclass(ty, IntegerImmediate):
-            return _broadcastInteger(ty)
-        elif issubclass(ty, FloatImmediate):
-            return _broadcastFloat(ty)
+        immediateType = ty.referencedType if issubclass(ty, Pointer) and hasattr(ty, "referencedType") else ty
+        if issubclass(immediateType, IntegerImmediate):
+            return _broadcastInteger(immediateType)
+        if issubclass(immediateType, FloatImmediate):
+            return _broadcastFloat(immediateType)
 
         return None
 
@@ -2106,8 +2104,9 @@ def bind(self, ctxt: NetworkContext) -> Tuple[NetworkContext, bool]:
                 elif ctxt.is_global(node.name):
                     npType = self._broadcastToNpType(ctxt.globalObjects[node.name]._type)
                     if isinstance(ctxt.globalObjects[node.name], ConstantBuffer):
-                        if isinstance(node, gs.Constant):
+                        if isinstance(node, gs.Constant) and npType is not None:
                             node.values = node.values.astype(npType)
+                            node.export_dtype = npType
                     else:
                         node.shape = ctxt.globalObjects[node.name].shape
                         if npType is not None:
@@ -2583,6 +2582,16 @@ def codeTransform(self, verbose: CodeGenVerbosity = _NoVerbosity):
         self.transformed = True
 
     def _selectEngine(self, node: gs.Node) -> DeploymentEngine:
+        if "engine" in node.attrs:
+            engineName = node.attrs["engine"]
+            for engine in self.Platform.engines:
+                if engine.name == engineName:
+                    if node.op not in engine.Mapping:
+                        raise RuntimeError(f"No mapping found for node {node.name} with op type {node.op} "
+                                           f"in explicitly selected engine {engineName}")
+                    return engine
+            raise RuntimeError(f"Node {node.name} has an unknown engine {engineName} assigned")
+
         for engine in self.Platform.engines:
             if node.op in engine.Mapping:
                 return engine
@@ -2863,6 +2872,7 @@ def generateInferenceInitializationCode(self) -> str:
 
             name = node.name
             node.name = self.ctxt._mangle(node.name)
+
             callStack += node.init()
             node.name = name
 

Deeploy/Targets/Generic/Bindings.py

@@ -17,17 +17,18 @@
     FloatDWConvTemplate, FloatExpTemplate, FloatFloorTemplate, FloatGELUTemplate, FloatGemmTemplate, \
     FloatGlobalAveragePoolTemplate, FloatGlobalMaxPoolTemplate, FloatGroupNormTemplate, FloatHardSigmoidTemplate, \
     FloatHardSwishTemplate, FloatInstanceNormTemplate, FloatLayernormTemplate, FloatMatMulTemplate, \
-    FloatMaxPoolTemplate, FloatMulTemplate, FloatPadTemplate, FloatPowTemplate, FloatReduceMeanTemplate, \
-    FloatReluTemplate, FloatSigmoidTemplate, FloatSoftmaxTemplate, FloatSqrtTemplate, FloatSubTemplate, \
-    FloatSwishTemplate, GatherTemplate, GemmTemplate, IntegerDivTemplate, ITAMaxTemplate, ITAPartialMaxTemplate, \
-    MatMulTemplate, MaxPoolTemplate, MulTemplate, PadTemplate, QuantTemplate, ReduceMeanTemplate, ReduceSumTemplate, \
-    RequantShiftTemplate, ReshapeTemplate, RQIntegerDivTemplate, RQSiGELUTemplate, SliceTemplate, SubTemplate, \
-    TransposeTemplate, iGELUTemplate, iLayernormTemplate, iRMSNormTemplate, iSoftmaxTemplate
+    FloatMaxPoolTemplate, FloatMulTemplate, FloatPadTemplate, FloatPowTemplate, FloatReduceLogSumExpTemplate, \
+    FloatReduceMeanTemplate, FloatReluTemplate, FloatSigmoidTemplate, FloatSoftmaxTemplate, FloatSqrtTemplate, \
+    FloatSubTemplate, FloatSwishTemplate, GatherTemplate, GemmTemplate, IntegerDivTemplate, ITAMaxTemplate, \
+    ITAPartialMaxTemplate, MatMulTemplate, MaxPoolTemplate, MulTemplate, PadTemplate, QuantTemplate, \
+    ReduceMeanTemplate, ReduceSumTemplate, RequantShiftTemplate, ReshapeTemplate, RQIntegerDivTemplate, \
+    RQSiGELUTemplate, SliceTemplate, SubTemplate, TransposeTemplate, iGELUTemplate, iLayernormTemplate, \
+    iRMSNormTemplate, iSoftmaxTemplate
 from Deeploy.Targets.Generic.TypeCheckers import AddChecker, BatchNormChecker, ConcatChecker, ConvChecker, \
     DebugPrintChecker, DequantChecker, DivChecker, DummyChecker, GatherChecker, GELUChecker, GEMMChecker, \
-    LayerNormChecker, MatMulChecker, MaxPoolChecker, MulChecker, PadChecker, QuantChecker, ReduceMeanChecker, \
-    ReduceSumChecker, ReluChecker, RequantShiftChecker, ReshapeChecker, RQIntegerDivChecker, SliceChecker, \
-    SoftmaxChecker, TransposeChecker
+    LayerNormChecker, MatMulChecker, MaxPoolChecker, MulChecker, PadChecker, QuantChecker, ReduceLogSumExpChecker, \
+    ReduceMeanChecker, ReduceSumChecker, ReluChecker, RequantShiftChecker, ReshapeChecker, RQIntegerDivChecker, \
+    SliceChecker, SoftmaxChecker, TransposeChecker
 
 BasicTransformer = CodeTransformation([ArgumentStructGeneration(), MemoryManagementGeneration(), FutureGeneration()])
 
@@ -241,6 +242,11 @@
                 BasicTransformer) for type in SignedIntegerDataTypes
 ]
 
+BasicReduceLogSumExpBindings = [
+    NodeBinding(ReduceLogSumExpChecker([PointerClass(float32_t)], [PointerClass(float32_t)]),
+                FloatReduceLogSumExpTemplate.referenceTemplate, BasicTransformer)
+]
+
 BasicReluBinding = NodeBinding(ReluChecker([PointerClass(float32_t)], [PointerClass(float32_t)]),
                                FloatReluTemplate.referenceTemplate, BasicTransformer)
 
@@ -329,19 +335,35 @@
     for type in FloatDataTypes
 ]
 
-BasicConvTransposeBindings = [
+BasicConvTranspose1DBindings = [
+    NodeBinding(
+        ConvChecker(
+            [PointerClass(type), PointerClass(type), PointerClass(type)],  # input, weight, bias
+            [PointerClass(type)]),
+        ConvTransposeTemplate.reference1DTemplate,
+        BasicTransformer) for type in FloatDataTypes
+] + [
+    NodeBinding(
+        ConvChecker(
+            [PointerClass(type), PointerClass(type)],  # input, weight
+            [PointerClass(type)]),
+        ConvTransposeTemplate.reference1DTemplate,
+        BasicTransformer) for type in FloatDataTypes
+]
+
+BasicConvTranspose2DBindings = [
     NodeBinding(
         ConvChecker(
             [PointerClass(type), PointerClass(type), PointerClass(type)],  # input, weight, bias
             [PointerClass(type)]),
-        ConvTransposeTemplate.referenceTemplate,
+        ConvTransposeTemplate.reference2DTemplate,
         BasicTransformer) for type in FloatDataTypes
 ] + [
     NodeBinding(
         ConvChecker(
             [PointerClass(type), PointerClass(type)],  # input, weight
             [PointerClass(type)]),
-        ConvTransposeTemplate.referenceTemplate,
+        ConvTransposeTemplate.reference2DTemplate,
         BasicTransformer) for type in FloatDataTypes
 ]
 

Deeploy/Targets/Generic/Layers.py

@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import copy
+from itertools import zip_longest
 from typing import List, Tuple
 
 import numpy as np
@@ -337,13 +338,18 @@ class MulLayer(SingleOperationPerElementLayer):
     def computeShapes(self, inputShapes: Shape, outputShapes: Shape, operatorRepresentation,
                       channels_first) -> Tuple[Shape, Shape]:
 
-        if inputShapes[1] == () or inputShapes[1] == []:
-            inputShapes[1] = (1,)
+        lhsShape = tuple(inputShapes[0])
+        rhsShape = tuple(inputShapes[1])
+        broadcastShape = []
 
-        if len(inputShapes[0]) > len(inputShapes[1]):
-            inputShapes[1] = inputShapes[0]
-        else:
-            inputShapes[0] = inputShapes[1]
+        for lhsDim, rhsDim in zip_longest(reversed(lhsShape), reversed(rhsShape), fillvalue = 1):
+            if lhsDim != rhsDim and lhsDim != 1 and rhsDim != 1:
+                raise ValueError(f"Cannot broadcast Mul input shapes {lhsShape} and {rhsShape}")
+            broadcastShape.append(rhsDim if lhsDim == 1 else lhsDim)
+
+        broadcastShape = tuple(reversed(broadcastShape))
+        inputShapes[0] = broadcastShape
+        inputShapes[1] = rhsShape if np.prod(rhsShape) == 1 else broadcastShape
         return (inputShapes, outputShapes)
 
 
@@ -355,7 +361,7 @@ def __init__(self, maps: List[NodeMapper]):
     def computeShapes(self, inputShapes: Shape, outputShapes: Shape, operatorRepresentation,
                       channels_first) -> Tuple[Shape, Shape]:
         if len(inputShapes) == 3:
-            inputShapes[2] = inputShapes[1][0]
+            inputShapes[2] = (inputShapes[1][0],)
         return (inputShapes, outputShapes)
 
     def computeOps(self):
@@ -435,6 +441,28 @@ def computeShapes(self, inputShapes: Shape, outputShapes: Shape, operatorReprese
         return (inputShapes, outputShapes)
 
 
+class ReduceLogSumExpLayer(ONNXLayer):
+
+    def __init__(self, maps: List[NodeMapper]):
+        super().__init__(maps)
+
+    def computeShapes(self, inputShapes: Shape, outputShapes: Shape, operatorRepresentation,
+                      channels_first) -> Tuple[Shape, Shape]:
+        axes = [int(axis) for axis in operatorRepresentation['axes']]
+        inputShape = list(inputShapes[0])
+
+        if operatorRepresentation['keepdims']:
+            outputShape = list(inputShape)
+            for axis in axes:
+                outputShape[axis] = 1
+        else:
+            outputShape = [dim for idx, dim in enumerate(inputShape) if idx not in axes]
+            if len(outputShape) == 0:
+                outputShape = [1]
+
+        return (inputShapes, [outputShape])
+
+
 class ReluLayer(SingleOperationPerElementLayer):
     pass