Implement PR feedback for Luka

Author: Xeratec

CHANGELOG.md

@@ -10,6 +10,7 @@ This file contains the changelog for the Deeploy project. The changelog is divid
 
 ### Added
 - Add manual type inference feature (CLI: `--input-type-map`/`--input-offset-map`) to resolve ambiguities when test inputs are not representative enough
+- Added a `testTypeInferenceDifferentTypes` test case to validate type inference for different input types
 - Added `_mangleNodeNames` function to avoid duplicate node mappings
 - Output Docker image digests per platform (`amd64`, `arm64`) after build, which is used to construct the multi-arch Docker manifest. This preventes registry clutter caused by unnecessary per-architecture Docker tags.
 
@@ -21,7 +22,7 @@ This file contains the changelog for the Deeploy project. The changelog is divid
 - Resolved issue with missing `id` in the `Build Cache for Docker` step, used in the `Inject build-cache` step.
 
 ### Removed
--
+- Delete outdated and unused `.gitlab-ci.yml` file
 
 ## Release v0.2.0 (2025-07-08) [#103](https://github.com/pulp-platform/Deeploy/pull/103)
 This release containing major architectural changes, new platform support, enhanced simulation workflows, floating-point kernel support, training infrastructure for CCT models, memory allocation strategies, and documentation improvements.

DeeployTest/generateNetwork.py

@@ -39,7 +39,7 @@
 from testUtils.typeMapping import inferInputType, parseDataType
 
 from Deeploy.AbstractDataTypes import PointerClass
-from Deeploy.CommonExtensions.DataTypes import int8_t
+from Deeploy.CommonExtensions.DataTypes import IntegerDataTypes
 from Deeploy.CommonExtensions.OptimizationPasses.TopologyOptimizationPasses.DebugPasses import EmulateCMSISRequantPass
 from Deeploy.DeeployTypes import _NoVerbosity
 from Deeploy.Targets.CortexM.Platform import CMSISPlatform
@@ -62,39 +62,38 @@ def generateNetwork(args):
     else:
         activations = None
 
-    tensors = graph.tensors()
-
     # build {name, type} and {name, offset} maps
     manual_types = {}
     manual_offsets = {}
     for kv in args.input_type_map:
         try:
             name, tstr = kv.split('=', 1)
-        except ValueError:
-            raise ValueError(f"Invalid --input-type-map entry '{kv}'. Expected NAME=TYPE.")
+        except ValueError as exc:
+            raise ValueError(f"Invalid --input-type-map entry '{kv}'. Expected NAME=TYPE.") from exc
         name, tstr = name.strip(), tstr.strip()
         try:
-            manual_types[name] = PointerClass(parseDataType(tstr))
-        except ValueError as e:
-            raise ValueError(f"Invalid --input-type-map entry '{kv}': {e}")
+            manual_types[name] = parseDataType(tstr)
+        except ValueError as exc:
+            raise ValueError(f"Invalid --input-type-map entry '{kv}': {e}") from exc
     for kv in args.input_offset_map:
         try:
             name, ostr = kv.split('=', 1)
-        except ValueError:
-            raise ValueError(f"Invalid --input-offset-map entry '{kv}'. Expected NAME=OFFSET.")
+        except ValueError as exc:
+            raise ValueError(f"Invalid --input-offset-map entry '{kv}'. Expected NAME=OFFSET.") from exc
         name, ostr = name.strip(), ostr.strip()
         try:
             manual_offsets[name] = int(ostr)
-        except ValueError:
-            raise ValueError(f"Invalid --input-offset-map entry '{kv}': OFFSET must be an integer.")
+        except ValueError as exc:
+            raise ValueError(f"Invalid --input-offset-map entry '{kv}': OFFSET must be an integer.") from exc
 
     # Sanity check for unknown input names
-    npz_names = set(inputs.files)
-    bad_names = (set(manual_types) | set(manual_offsets)) - npz_names
-    if bad_names:
-        raise ValueError(f"Unknown input names in overrides: {bad_names}")
-
-    manual_keys = set(manual_types) | set(manual_offsets)
+    manual_keys = set(manual_types)
+    assert manual_keys == set(
+        manual_offsets
+    ), f"Override inputs should have both type and offset specified. Inputs without both specified: {manual_keys ^ set(manual_types)}"
+    assert manual_keys <= set(
+        inputs.files
+    ), f"Unknown input names in overrides: {manual_keys - set(inputs.files)} (Valid names are: {set(inputs.files)})"
 
     if args.debug:
         test_inputs, test_outputs, graph = generateDebugConfig(inputs, outputs, activations, graph)
@@ -114,16 +113,29 @@ def generateNetwork(args):
     for index, (name, num) in enumerate(zip(inputs.files, test_inputs)):
         if np.prod(num.shape) == 0:
             continue
-        defaultType = manual_types.get(name, PointerClass(int8_t))
-        defaultOffset = manual_offsets.get(name, 0)
-        autoInfer = name not in manual_keys
-
-        _type, offset = inferInputType(num,
-                                       signProp,
-                                       defaultType = defaultType,
-                                       defaultOffset = defaultOffset,
-                                       autoInfer = autoInfer)[0]
-        inputTypes[f"input_{index}"] = _type
+
+        if name in manual_keys:
+            _type = manual_types[name]
+            offset = manual_offsets[name]
+
+            # Check if the provided values fit into the dereferenced type
+            vals = num.astype(np.int64) - offset
+            if not _type.checkPromotion(vals):
+                lo, hi = _type.typeMin, _type.typeMax
+                raise RuntimeError(f"Provided type '{_type.typeName}' with offset {offset} "
+                                   f"does not match input values in range [{vals.min()}, {vals.max()}] "
+                                   f"(expected range [{lo}, {hi}])")
+
+            # Suggest a smaller fitting type if possible
+            fitting_types = [t for t in sorted(IntegerDataTypes, key = lambda x: x.typeWidth) if t.checkPromotion(vals)]
+            if fitting_types and fitting_types[0] is not _type:
+                print(f"WARNING: Data spans [{int(vals.min())}, {int(vals.max())}], "
+                      f"which would fit in '{fitting_types[0].typeName}', "
+                      f"but user forced '{_type.typeName}'.")
+        else:
+            _type, offset = inferInputType(num, signProp)[0]
+
+        inputTypes[f"input_{index}"] = PointerClass(_type)
         inputOffsets[f"input_{index}"] = offset
 
     _DEEPLOYSTATEDIR = os.path.join(args.dumpdir, "deeployStates")
@@ -198,12 +210,14 @@ def generateNetwork(args):
     parser.add_argument('--input-type-map',
                         nargs = '*',
                         default = [],
+                        type = str,
                         help = '(Optional) mapping of input names to data types. '
                         'If not specified, types are inferred from the input data. '
                         'Example: --input-type-map input_0=int8_t input_1=float32_t ...')
     parser.add_argument('--input-offset-map',
                         nargs = '*',
                         default = [],
+                        type = str,
                         help = '(Optional) mapping of input names to offsets. '
                         'If not specified, offsets are set to 0. '
                         'Example: --input-offset-map input_0=0 input_1=128 ...')

DeeployTest/testUtils/codeGenerate.py

@@ -104,7 +104,7 @@ def generateTestInputsHeader(deployer: NetworkDeployer,
         print('Input:')
         for name in inputTypes.keys():
             buf = deployer.ctxt.lookup(name)
-            print(f" - '{name}': Type: {buf._type.typeName}, Offset: {inputOffsets[name]}")
+            print(f" - '{name}': Type: {buf._type.referencedType.typeName}, Offset: {inputOffsets[name]}")
 
     return retStr
 
@@ -172,10 +172,10 @@ def generateTestOutputsHeader(deployer: NetworkDeployer,
         if signProp:
             for (name, buf), (_, n_level), (_, signed) in zip(output_data_type.items(), output_n_levels.items(),
                                                               output_signed.items()):
-                print(f" - '{name}': Type: {buf.typeName}, nLevels: {n_level}, Signed: {signed}")
+                print(f" - '{name}': Type: {buf.referencedType.typeName}, nLevels: {n_level}, Signed: {signed}")
         else:
             for (name, buf) in output_data_type.items():
-                print(f" - '{name}': Type: {buf.typeName}")
+                print(f" - '{name}': Type: {buf.referencedType.typeName}")
 
     return retStr
 

DeeployTest/testUtils/testRunner.py

@@ -180,12 +180,14 @@ def __init__(self, tiling_arguments: bool, description = None):
         self.add_argument('--input-type-map',
                           nargs = '*',
                           default = [],
+                          type = str,
                           help = '(Optional) mapping of input names to data types. '
                           'If not specified, types are inferred from the input data. '
                           'Example: --input-type-map input_0=int8_t input_1=float32_t ...')
         self.add_argument('--input-offset-map',
                           nargs = '*',
                           default = [],
+                          type = str,
                           help = '(Optional) mapping of input names to offsets. '
                           'If not specified, offsets are set to 0. '
                           'Example: --input-offset-map input_0=0 input_1=128 ...')

DeeployTest/testUtils/typeMapping.py

@@ -24,11 +24,10 @@
 # limitations under the License.
 
 from collections import namedtuple
-from typing import List, Optional
+from typing import List
 
 import numpy as np
 
-from Deeploy.AbstractDataTypes import PointerClass
 from Deeploy.CommonExtensions.DataTypes import FloatDataTypes, IntegerDataTypes, int8_t
 
 offsetType = namedtuple("offsetType", ("type", "offset"))
@@ -84,69 +83,63 @@ def dataWidth(n):
     return ret
 
 
-def inferInputType(_input: np.ndarray,
-                   signProp: Optional[bool] = None,
-                   defaultType = PointerClass(int8_t),
-                   defaultOffset = 0,
-                   autoInfer: bool = True) -> List[offsetType]:
+def inferInputType(values: np.ndarray,
+                   signProp: bool = False,
+                   defaultType = int8_t,
+                   defaultOffset = 0) -> List[offsetType]:
+    """Infers the data type of the provided input array.
 
-    # WIESEP: We cannot do type inference for empty arrays.
-    if np.prod(_input.shape) == 0:
-        print(f"Warning: Empty input array for type inference for {_input}!")
-        return [(defaultType, defaultOffset)]
+    Parameters
+    ----------
+    values : np.ndarray
+        The input array for which to infer the data type.
 
-    # If the caller provided a manual override, skip all inference.
-    if not autoInfer:
-        rawType = defaultType.referencedType
-        vals = (_input.astype(np.int64) - defaultOffset)
-        if not rawType.checkPromotion(vals):
-            lo, hi = rawType.typeMin, rawType.typeMax
-            raise RuntimeError(f"Provided type {rawType.typeName} with offset {defaultOffset} "
-                               f"does not match input values in range [{vals.min()}, {vals.max()}] "
-                               f"(expected range [{lo}, {hi}])")
-
-        smallest = rawType
-        for t in sorted(IntegerDataTypes, key = lambda x: x.typeWidth):
-            if t.checkPromotion(vals):
-                smallest = t
-                break
-        if smallest is not rawType:
-            print(f"WARNING: Data spans [{int(vals.min())}, {int(vals.max())}], "
-                  f"which would fit in {smallest.typeName}, "
-                  f"but user forced {rawType.typeName}.")
-        return [(defaultType, defaultOffset)]
+    signProp : bool
+        Whether to consider signedness when inferring the data type.
+
+    defaultType : type
+        The default data type to use if inference fails.
+
+    defaultOffset : int
+        The default offset to use if inference fails.
 
-    if signProp is None:
-        signProp = False
+    Returns
+    -------
+    List[offsetType]
+        A list of inferred data types and their corresponding offsets.
+    """
+
+    # WIESEP: We cannot do type inference for empty arrays.
+    if np.prod(values.shape) == 0:
+        print(f"Warning: Empty input array for type inference for {values}!")
+        return [(defaultType, defaultOffset)]
 
     signedPlatformTypes = [_type for _type in IntegerDataTypes if _type.typeMin < 0]
 
     matchingTypes = []
 
-    # FIXME: this is okay for now (3 distinctions are fine), but there is implicit
-    # knowledge encoded in the order of the checks (i.e. first unsigned, signed
-    # and then float). It might be good to extract that implicit knowledge into an ordered list.
-    if signProp and isUnsigned(_input) and isInteger(_input):
+    # There is implicit knowledge encoded in the order of the checks (i.e. first unsigned, signed
+    # and then float).
+    if signProp and isUnsigned(values) and isInteger(values):
         for _type in sorted(signedPlatformTypes, key = lambda x: x.typeWidth):
             signPropOffset = (2**(_type.typeWidth - 1))
-            if _type.checkPromotion(_input - signPropOffset):
-                matchingTypes.append(offsetType(PointerClass(_type), signPropOffset))
-    elif isInteger(_input):
+            if _type.checkPromotion(values - signPropOffset):
+                matchingTypes.append(offsetType(_type, signPropOffset))
+    elif isInteger(values):
         sorted_types = sorted(
             IntegerDataTypes,
             key = lambda t: (t.typeWidth, t.typeMin < 0),
         )
 
-        matchingTypes = []
         for _type in sorted_types:
-            if _type.checkPromotion(_input):
-                matchingTypes.append(offsetType(PointerClass(_type), 0))
+            if _type.checkPromotion(values):
+                matchingTypes.append(offsetType(_type, 0))
     else:
         for _type in sorted(FloatDataTypes, key = lambda x: x.typeWidth):
-            if _type.checkPromotion(_input):
-                matchingTypes.append(offsetType(PointerClass(_type), 0))
+            if _type.checkPromotion(values):
+                matchingTypes.append(offsetType(_type, 0))
 
-    if matchingTypes == []:
-        raise Exception("Could not find a matching type!")
+    if not matchingTypes:
+        raise RuntimeError("Could not find a matching type!")
 
     return matchingTypes