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]

.vscode/launch.json

@@ -88,4 +88,4 @@
       "default": "-v --doublebuffer"
     }
   ]
-}
+}

Deeploy/DeeployTypes.py

@@ -977,8 +977,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 +2026,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 +2100,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 +2578,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,7 +2868,17 @@ def generateInferenceInitializationCode(self) -> str:
 
             name = node.name
             node.name = self.ctxt._mangle(node.name)
-            callStack += node.init()
+
+            if ("TILING_CODEGEN" not in node.name and isinstance(node, VariableBuffer) and hasattr(node, "_type")
+                    and issubclass(node._type, Pointer)):
+                # Local inference buffers are late-bound by the generated layer code. Initializing them to NULL keeps
+                # clang from flagging false-positive uninitialized reads on paths where the assignment is emitted in a
+                # separate closure, and marking them unused avoids noise for scratch buffers that are reserved
+                # generically but optimized away for a specific layer instance.
+                typeName = node._instance.typeName if hasattr(node, "_instance") else node._type.typeName
+                callStack += f"{typeName} {node.name} __attribute__((unused)) = NULL;\n"
+            else:
+                callStack += node.init()
             node.name = name
 
         return callStack

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)
 
@@ -300,6 +306,9 @@
 BasicConcatBindings = [
     NodeBinding(ConcatChecker([PointerClass(type), PointerClass(type)], [PointerClass(type)]),
                 ConcatTemplate.referenceTemplate, BasicTransformer) for type in IntegerDataTypes
+] + [
+    NodeBinding(ConcatChecker([PointerClass(float32_t), PointerClass(float32_t)], [PointerClass(float32_t)]),
+                ConcatTemplate.referenceTemplate, BasicTransformer)
 ]
 
 BasicQuantBindings = [
@@ -326,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] = 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,8 +441,34 @@ def computeShapes(self, inputShapes: Shape, outputShapes: Shape, operatorReprese
         return (inputShapes, outputShapes)
 
 
-class ReluLayer(SingleOperationPerElementLayer):
-    pass
+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]:
+        axis = operatorRepresentation['axes'][0]
+        inputShape = list(copy.deepcopy(inputShapes[0]))
+
+        if operatorRepresentation['keepdims']:
+            outputShape = inputShape
+            outputShape[axis] = 1
+        else:
+            outputShape = inputShape[:axis] + inputShape[axis + 1:]
+            if len(outputShape) == 0:
+                outputShape = [1]
+
+        return (inputShapes, [outputShape])
+
+
+class ReluLayer(ONNXLayer):
+
+    def __init__(self, maps: List[NodeMapper]):
+        super().__init__(maps)
+
+    def computeOps(self):
+        return self.mapper.parser.operatorRepresentation['size']
 
 
 class LayerNormLayer(ONNXLayer):