Fix QLiteCNN, add support for Tiled Quant/Dequant nodes

Author: JanCSEM

Deeploy/Targets/GAP9/Bindings.py

@@ -21,8 +21,8 @@
 from Deeploy.Targets.GAP9.DMA.L3Dma import gap9L3DmaHack
 from Deeploy.Targets.GAP9.DMA.MchanDma import GAP9MchanDma
 # Import templates from PULPOpen and Generic
-from Deeploy.Targets.Generic.Templates import AddTemplate, ConcatTemplate, DequantTemplate, FloatReduceMeanTemplate, \
-    FloatReduceSumTemplate, GatherTemplate, QuantTemplate, RQSiGELUTemplate, SliceTemplate, iHardswishTemplate, DebugPrintTemplate
+from Deeploy.Targets.Generic.Templates import AddTemplate, ConcatTemplate, FloatReduceMeanTemplate, \
+    FloatReduceSumTemplate, GatherTemplate, RQSiGELUTemplate, SliceTemplate, iHardswishTemplate, DebugPrintTemplate
 from Deeploy.Targets.Generic.TypeCheckers import AddChecker, ConcatChecker, ConvChecker, DequantChecker, \
     GatherChecker, GELUChecker, GEMMChecker, HardswishChecker, LayerNormChecker, MatMulChecker, MulChecker, \
     QuantChecker, ReduceMeanChecker, ReluChecker, ReshapeChecker, RQAddChecker, RQHardswishChecker, SGDChecker, \
@@ -40,7 +40,7 @@
     FloatMulTemplate, FloatReluTemplate, FloatSoftmaxTemplate, GEMMTemplate, MatrixVectorTemplate, MaxPoolTemplate, \
     MulTemplate, ReduceMeanTemplate, RequantShiftTemplate, ReshapeTemplate, RQAddTemplate, RQSiHardswishTemplate, \
     SGDTemplate, SoftmaxCrossEntropyLossTemplate, TallGEMMTemplate, TransposeTemplate, UniformRequantShiftTemplate, \
-    iRMSNormTemplate, iSoftmaxTemplate, FloatInPlaceAccumulatorV2Template, \
+    iRMSNormTemplate, iSoftmaxTemplate, FloatInPlaceAccumulatorV2Template, QuantTemplate, DequantTemplate, \
     FloatPerturbEggrollTemplate, FloatPerturbUniformTemplate, FloatPerturbNormalTemplate, \
     FloatPerturbRademacherTemplate, FloatPerturbTriangleTemplate 
 from Deeploy.Targets.PULPOpen.TypeCheckers import PULPConvChecker, PULPLinearChecker, PULPMaxPoolChecker, \

Deeploy/Targets/GAP9/Platform.py

@@ -22,7 +22,8 @@
     GAP9RQSTallGEMMTilingReadyBindings, GAP9RQSTilingReadyBindings, GAP9SGDTilingReadyBindings, \
     GAP9SoftmaxCrossEntropyGradTilingReadyBindings, GAP9SoftmaxCrossEntropyTilingReadyBindings, \
     GAP9SoftmaxGradTilingReadyBindings, GAP9SoftmaxTilingReadyBindings, GAP9TransposeTilingReadyBindings, \
-    GAP9UniformRQSTilingReadyBindings, GAP9InPlaceAccumulatorV2TilingReadyBindings, GAP9PerturbNormalTilingReadyBindings, GAP9PerturbUniformTilingReadyBindings, \
+    GAP9UniformRQSTilingReadyBindings, GAP9InPlaceAccumulatorV2TilingReadyBindings, GAP9PerturbNormalTilingReadyBindings, \
+    GAP9PerturbUniformTilingReadyBindings, GAP9QuantTilingReadyBindings, GAP9DequantTilingReadyBindings, \
     GAP9PerturbEggrollTilingReadyBindings, GAP9PerturbRademacherTilingReadyBindings, GAP9PerturbTriangleTilingReadyBindings
 from Deeploy.Targets.Generic.Bindings import BasicGEMMBindings, BasicPad1DBindings, BasicPad2DBindings, \
     BasicRQIntegerDivBinding
@@ -41,12 +42,13 @@
     InPlaceAccumulatorV2Parser, GELUGradParser, ReluGradParser, DebugParser, \
     PerturbEggrollParser, PerturbNormalParser, PerturbRademacherParser, PerturbTriangleParser, PerturbUniformParser
 from Deeploy.Targets.Generic.Templates import AllocateTemplate as BasicAllocateTemplate
-from Deeploy.Targets.GAP9.Bindings import GAP9SoftmaxCrossEntropyLossDualOutputBindings, GAP9LayernormGradBinding, GAP9FloatGELUGradBinding, GAP9ReluGradBinding, GAP9BasicDebugPrintBindings
+from Deeploy.Targets.GAP9.Bindings import GAP9SoftmaxCrossEntropyLossDualOutputBindings, GAP9LayernormGradBinding, \
+                                            GAP9FloatGELUGradBinding, GAP9ReluGradBinding, GAP9BasicDebugPrintBindings
 from Deeploy.Targets.PULPOpen.Bindings import BasicDequantBindings, BasicQuantBindings, PULPDMASliceBindings, \
     PULPDWConv1DBinding, PULPReduceMeanBindings, PULPRQSConv1DBindings, PULPSliceBindings
 from Deeploy.Targets.PULPOpen.Layers import PULPRQSConvLayer, PULPRQSGEMMLayer
 from Deeploy.Targets.PULPOpen.Parsers import PULPConv1DParser, PULPConv2DParser, PULPDWConv1DParser, \
-    PULPDWConv2DParser, PULPFPConv2DParser, PULPFPDWConv2DParser, PULPGEMMParser, PULPMatrixVecParser, \
+    PULPDWConv2DParser, PULPFPConv2DParser, PULPFPDWConv2DParser, PULPGEMMParser, PULPIntConv2DParser, PULPMatrixVecParser, \
     PULPTallGEMMParser
 
 # Create GAP9-specific NodeMappers
@@ -96,8 +98,8 @@
 GAP9_SoftmaxCrossEntropyLossGradMapper = NodeMapper(SoftmaxCrossEntropyLossGradParser(),
                                                     GAP9SoftmaxCrossEntropyGradTilingReadyBindings)
 GAP9_SGDMapper = NodeMapper(SGDParser(), GAP9SGDTilingReadyBindings)
-GAP9_QuantMapper = NodeMapper(QuantParser(), BasicQuantBindings)
-GAP9_DequantMapper = NodeMapper(DequantParser(), BasicDequantBindings)
+GAP9_QuantMapper = NodeMapper(QuantParser(), GAP9QuantTilingReadyBindings)
+GAP9_DequantMapper = NodeMapper(DequantParser(), GAP9DequantTilingReadyBindings)
 GAP9_GEMMDequantMapper = NodeMapper(PULPGEMMParser(), BasicGEMMBindings)
 GAP9InPlaceAccumulatorV2Mapper = NodeMapper(InPlaceAccumulatorV2Parser(), GAP9InPlaceAccumulatorV2TilingReadyBindings)
 GAP9SoftmaxCrossEntropyLossDualOutputMapper = NodeMapper(SoftmaxCrossEntropyLossParser(),

Deeploy/Targets/GAP9/Tiler.py

@@ -18,7 +18,8 @@
     GAP9RQSiHardswishBindings, GAP9RQSMatrixVecBindings, GAP9RQSTallGEMMBindings, GAP9SGDBindings, \
     GAP9SoftmaxBindings, GAP9SoftmaxCrossEntropyLossBindings, GAP9SoftmaxCrossEntropyLossGradBindings, \
     GAP9SoftmaxGradBindings, GAP9TransposeBindings, GAP9UniformRQSBindings, GAP9InPlaceAccumulatorV2Bindings, GAP9PerturbNormalBindings, \
-    GAP9PerturbUniformBindings, GAP9PerturbEggrollBindings, GAP9PerturbRademacherBindings, GAP9PerturbTriangleBindings
+    GAP9PerturbUniformBindings, GAP9PerturbEggrollBindings, GAP9PerturbRademacherBindings, GAP9PerturbTriangleBindings, \
+    GAP9QuantBindings, GAP9DequantBindings
 from Deeploy.Targets.Generic.TileConstraints.AddTileConstraint import AddTileConstraint
 from Deeploy.Targets.Generic.TileConstraints.ConcatTileConstraint import ConcatTileConstraint
 from Deeploy.Targets.Generic.TileConstraints.iHardswishTileConstraint import iHardswishTileConstraint
@@ -93,6 +94,12 @@
 GAP9MaxPool2DTilingReadyBindings = TilingReadyNodeBindings(nodeBindings = GAP9MaxPool2DBindings,
                                                            tileConstraint = MaxPoolCTileConstraint())
 
+GAP9QuantTilingReadyBindings = TilingReadyNodeBindings(nodeBindings = GAP9QuantBindings,
+                                                        tileConstraint = UnaryTileConstraint())
+
+GAP9DequantTilingReadyBindings = TilingReadyNodeBindings(nodeBindings = GAP9DequantBindings,
+                                                        tileConstraint = UnaryTileConstraint())
+
 GAP9RQSTilingReadyBindings = TilingReadyNodeBindings(nodeBindings = GAP9RQSBindings,
                                                      tileConstraint = RequantShiftTileConstraint())
 

Deeploy/Targets/PULPOpen/Parsers.py

@@ -61,6 +61,38 @@ def parseNodeCtxt(self,
 
         return ctxt, False
 
+class PULPIntConv2DParser(Conv2DParser):
+
+    def __init__(self, noBiasHoisting = True):
+        super().__init__(noBiasHoisting)
+
+    def parseNode(self, node: gs.Node) -> (bool):
+
+        wellFormed = super().parseNode(node)
+        if wellFormed:
+            ret = all([
+                # Current PULP kernel only supports grouping of 1
+                self.operatorRepresentation['group'] == 1,
+
+                # Make sure padding is symmetric (left==right, top==bottom)
+                # but top/bottom can differ from left/right
+                self.operatorRepresentation['pads'][0] == self.operatorRepresentation['pads'][2],  # top == bottom
+                self.operatorRepresentation['pads'][1] == self.operatorRepresentation['pads'][3],  # left == right
+
+                # Check number of inputs
+                # 2 inputs if no bias, 3 if layer has bias
+                len(node.inputs) in [2, 3],
+            ])
+
+            # Extract additional attributes
+            self.operatorRepresentation['padding_y_top'] = int(self.operatorRepresentation['pads'][0])
+            self.operatorRepresentation['padding_x_left'] = int(self.operatorRepresentation['pads'][1])
+            self.operatorRepresentation['padding_y_bottom'] = int(self.operatorRepresentation['pads'][2])
+            self.operatorRepresentation['padding_x_right'] = int(self.operatorRepresentation['pads'][3])
+
+            return ret
+        return False
+
 
 class PULPFPConv2DParser(Conv2DParser):
 

Deeploy/Targets/PULPOpen/Templates/DequantTemplate.py

@@ -0,0 +1,30 @@
+# SPDX-FileCopyrightText: 2025 ETH Zurich and University of Bologna
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from Deeploy.DeeployTypes import NodeTemplate
+
+
+class PULPDequantTemplate(NodeTemplate):
+
+    def __init__(self, templateStr):
+        super().__init__(templateStr)
+
+
+referenceTemplate = PULPDequantTemplate("""
+// Dequantization (Name: ${nodeName}, Op: ${nodeOp})
+uint8_t ${nodeName}_core_id = (uint8_t) pi_core_id();
+uint8_t ${nodeName}_log2Core = (uint8_t) log2(NUM_CORES);
+uint32_t ${nodeName}_chunk = (${size} >> ${nodeName}_log2Core) + ((${size} & (NUM_CORES-1))!=0);
+uint32_t ${nodeName}_chunk_start = (uint32_t) MIN(${nodeName}_chunk*${nodeName}_core_id, (uint32_t) ${size});
+uint32_t ${nodeName}_chunk_stop = (uint32_t) MIN(${nodeName}_chunk_start + ${nodeName}_chunk, (uint32_t) ${size});
+
+
+for (uint32_t i=${nodeName}_chunk_start; i<${nodeName}_chunk_stop; i++) {
+    int32_t quantized = (int32_t)${data_in}[i];
+    float32_t shifted_val = quantized - ${zero_point};
+    float32_t dequantized = shifted_val * ${scale};
+
+    ${data_out}[i] = (${data_out_type.referencedType.typeName})dequantized;
+}
+""")

Deeploy/Targets/PULPOpen/Templates/QuantTemplate.py

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: 2025 ETH Zurich and University of Bologna
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from Deeploy.DeeployTypes import NodeTemplate
+
+
+class PULPQuantTemplate(NodeTemplate):
+
+    def __init__(self, templateStr):
+        super().__init__(templateStr)
+
+
+referenceTemplate = PULPQuantTemplate("""
+// Quantization (Name: ${nodeName}, Op: ${nodeOp})
+uint8_t ${nodeName}_core_id = (uint8_t) pi_core_id();
+uint8_t ${nodeName}_log2Core = (uint8_t) log2(NUM_CORES);
+uint32_t ${nodeName}_chunk = (${size} >> ${nodeName}_log2Core) + ((${size} & (NUM_CORES-1))!=0);
+uint32_t ${nodeName}_chunk_start = (uint32_t) MIN(${nodeName}_chunk*${nodeName}_core_id, (uint32_t) ${size});
+uint32_t ${nodeName}_chunk_stop = (uint32_t) MIN(${nodeName}_chunk_start + ${nodeName}_chunk, (uint32_t) ${size});
+
+for (uint32_t i=${nodeName}_chunk_start; i<${nodeName}_chunk_stop; i++) {
+    // quantization formula
+    float32_t input_val = ${data_in}[i];
+    float32_t scaled_val = input_val * ${scale};  // Multiply instead of divide
+    float32_t shifted_val = scaled_val + ${zero_point};
+
+    // Round to nearest integer
+    int32_t quantized = (int32_t)(shifted_val + 0.5f * (shifted_val >= 0 ? 1 : -1));
+
+    // Clamp the value
+    if (quantized < ${min_val}) quantized = ${min_val};
+    if (quantized > ${max_val}) quantized = ${max_val};
+
+    // Assign directly with explicit cast
+    ${data_out}[i] = (${data_out_type.referencedType.typeName})quantized;
+
+}
+""")

Deeploy/Targets/PULPOpen/TopologyOptimizationPasses/Passes.py

@@ -168,12 +168,17 @@ def _merge_conv_rq_fun(graph: gs.Graph, match: Match, name: str):
     conv = matched_nodes[0]
     rqs = matched_nodes[1]
 
-    totalShift = int(np.log2(rqs.attrs['div'].values))
+    div_val = rqs.attrs['div']
+    if hasattr(div_val, 'values'):
+        div_val = div_val.values.item()
 
+    totalShift = int(np.log2(div_val)) 
+    print(f"total shift: {totalShift}")
     # Artifically add half the shift division value to implement rounding
     rounding = 2**(totalShift - 1) if totalShift > 0 else 0
 
-    rqs.inputs[-1].values = copy.deepcopy(rqs.inputs[-1].values) + rounding
+    # JANSNO: this can't be right-commented.
+    #rqs.inputs[-1].values = copy.deepcopy(rqs.inputs[-1].values) + rounding
 
     _inputs = list(conv.inputs) + list(rqs.inputs[1:])
 
@@ -205,9 +210,14 @@ def _merge_gemm_rq_fun(graph: gs.Graph, match: Match, name: str):
     gemm = matched_nodes[0]
     rqs = matched_nodes[1]
 
-    totalShift = int(np.log2(rqs.attrs['div'].values))
+    div_val = rqs.attrs['div']
+    if hasattr(div_val, 'values'):
+        div_val = div_val.values.item()
 
-    rqs.inputs[-1].values = copy.deepcopy(rqs.inputs[-1].values) + 2**(totalShift - 1)
+    totalShift = int(np.log2(div_val))
+
+    # JANSNO: rounding here is not valid
+    #rqs.inputs[-1].values = copy.deepcopy(rqs.inputs[-1].values) + 2**(totalShift - 1)
 
     # GEMM has add
     if len(list(gemm.inputs)) == 3: