qualia-codegen-core 2.2.0__tar.gz → 2.3.0__tar.gz

{qualia_codegen_core-2.2.0 → qualia_codegen_core-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qualia-codegen-core
-Version: 2.2.0
+Version: 2.3.0
 Summary: Generate portable C inference code from Keras or PyTorch model
 Home-page: https://github.com/LEAT-EDGE/qualia-codegen-core
 Author-Email: Pierre-Emmanuel Novac <penovac@unice.fr>
@@ -10,12 +10,12 @@ Classifier: License :: OSI Approved :: GNU Affero General Public License v3
 Classifier: Operating System :: OS Independent
 Project-URL: Homepage, https://github.com/LEAT-EDGE/qualia-codegen-core
 Project-URL: Documentation, https://leat-edge.github.io/qualia-codegen-core
-Requires-Python: <3.12,>=3.9
-Requires-Dist: numpy
+Requires-Python: <3.13,>=3.9
+Requires-Dist: numpy>=1.22.0
 Requires-Dist: jinja2
-Requires-Dist: typing_extensions
-Requires-Dist: tensorflow<2.16.0,>=2.6.0; extra == "tensorflow"
-Requires-Dist: keras<3.0.0,>=2.6.0; extra == "tensorflow"
+Requires-Dist: typing_extensions; python_version < "3.12"
+Requires-Dist: tensorflow>=2.6.0; extra == "tensorflow"
+Requires-Dist: keras>=2.6.0; extra == "tensorflow"
 Requires-Dist: torch>=1.8.0; extra == "pytorch"
 Requires-Dist: tabulate; extra == "pytorch"
 Requires-Dist: graphviz; extra == "graph"

{qualia_codegen_core-2.2.0 → qualia_codegen_core-2.3.0}/pyproject.toml

@@ -11,19 +11,19 @@ authors = [
 ]
 description = "Generate portable C inference code from Keras or PyTorch model"
 readme = "README.md"
-requires-python = ">=3.9,<3.12"
+requires-python = ">=3.9,<3.13"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: GNU Affero General Public License v3",
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "numpy",
+    "numpy >= 1.22.0",
     "jinja2",
-    "typing_extensions",
+    "typing_extensions; python_version < \"3.12\"",
 ]
 dynamic = []
-version = "2.2.0"
+version = "2.3.0"
 
 [project.license]
 text = "AGPL-3.0-or-later"
@@ -34,8 +34,8 @@ documentation = "https://leat-edge.github.io/qualia-codegen-core"
 
 [project.optional-dependencies]
 tensorflow = [
-    "tensorflow >= 2.6.0, < 2.16.0",
-    "keras >= 2.6.0, < 3.0.0",
+    "tensorflow>=2.6.0",
+    "keras >= 2.6.0",
 ]
 pytorch = [
     "torch>=1.8.0",
@@ -72,6 +72,10 @@ source = "scm"
 extend-exclude = [
     "third_party",
 ]
+line-length = 131
+target-version = "py39"
+
+[tool.ruff.lint]
 select = [
     "ALL",
 ]
@@ -83,10 +87,8 @@ ignore = [
     "D203",
     "D213",
 ]
-line-length = 131
-target-version = "py39"
 
-[tool.ruff.flake8-quotes]
+[tool.ruff.lint.flake8-quotes]
 inline-quotes = "single"
 
 [tool.mypy]

{qualia_codegen_core-2.2.0 → qualia_codegen_core-2.3.0}/src/qualia_codegen_core/Converter.py

@@ -204,14 +204,14 @@ class Converter:
         return self.combine_relu(modelgraph_combined_zeropadding)
 
     def preprocess_modelgraph(self, modelgraph: ModelGraph) -> ModelGraph | None:
-        logger.info('ModelGraph: %s', modelgraph)
+        logger.info('ModelGraph:\n%s', modelgraph)
 
         optimized_modelgraph = self.optimize_modelgraph(modelgraph)
         if optimized_modelgraph is None:
             logger.error('Could not optimize ModelGraph')
             return None
 
-        logger.info('ModelGraph after optimization: %s', optimized_modelgraph)
+        logger.info('ModelGraph after optimization:\n%s', optimized_modelgraph)
         graphviz = optimized_modelgraph.graphviz()
         if graphviz:
             logger.info('Graphviz: %s', graphviz)

qualia_codegen_core-2.3.0/src/qualia_codegen_core/graph/KerasModelGraph.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import dataclasses
+import logging
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Literal, cast
+
+from keras.activations import linear, relu, softmax  # type: ignore[import-untyped] # No stubs for keras package
+from keras.layers import (  # type: ignore[import-untyped] # No stubs for keras package
+    Activation,
+    Add,
+    AveragePooling1D,
+    AveragePooling2D,
+    BatchNormalization,
+    Conv1D,
+    Conv2D,
+    Dense,
+    Dropout,
+    Flatten,
+    Layer,
+    MaxPooling1D,
+    MaxPooling2D,
+    ZeroPadding1D,
+    ZeroPadding2D,
+)
+
+from qualia_codegen_core.typing import DTypes, NDArrayFloatOrInt, Shape, ShapeOptional, Shapes
+
+from .layers import (
+    TActivationLayer,
+    TAddLayer,
+    TAvgPooling1DLayer,
+    TAvgPooling2DLayer,
+    TBaseLayer,
+    TBatchNormalization1DLayer,
+    TBatchNormalization2DLayer,
+    TConv1DLayer,
+    TConv2DLayer,
+    TDenseLayer,
+    TDropoutLayer,
+    TFlattenLayer,
+    TInputLayer,
+    TMaxPooling1DLayer,
+    TMaxPooling2DLayer,
+    TZeroPadding1DLayer,
+    TZeroPadding2DLayer,
+)
+from .layers.TActivationLayer import TActivation
+from .ModelGraph import ModelGraph
+
+try:
+    # Keras 3.x
+    from keras.layers import InputLayer
+    from keras.src.ops.node import Node  # type: ignore[import-untyped]
+except ImportError:
+    try:
+        # Keras >= 2.13.1
+        from keras.src.engine.input_layer import InputLayer  # type: ignore[import-untyped] # No stubs for keras package
+    except ImportError:
+        # Keras < 2.13.0
+        from keras.engine.input_layer import InputLayer  # type: ignore[import-untyped] # No stubs for keras package
+    from keras.src.engine.node import Node  # type: ignore[import-untyped]
+
+if TYPE_CHECKING:
+    import numpy.typing
+    import tensorflow as tf  # type: ignore[import-untyped]
+    from keras import Model  # type: ignore[import-untyped]
+
+logger = logging.getLogger(__name__)
+
+
+class KerasModelGraph(ModelGraph):
+    MAPPING: ClassVar[dict[type[Layer], Callable[[Layer, TBaseLayer], tuple[type[TBaseLayer], list[Any]]]]] = {
+        InputLayer: lambda *_: (TInputLayer, []),
+        ZeroPadding1D: lambda layer, _: (TZeroPadding1DLayer, [layer.padding]),
+        ZeroPadding2D: lambda layer, _: (TZeroPadding2DLayer, [layer.padding]),
+        BatchNormalization: lambda layer, _: (TBatchNormalization1DLayer if len(KerasModelGraph.__get_input_shape(layer)) == 3  # noqa: PLR2004
+                                           else TBatchNormalization2DLayer,
+                                           [TActivation.LINEAR,
+                                            layer.moving_mean.numpy(),
+                                            layer.moving_variance.numpy(),
+                                            layer.gamma.numpy(),
+                                            layer.beta.numpy(),
+                                            layer.epsilon]),
+        Conv1D: lambda layer, args: (TConv1DLayer, [KerasModelGraph.ACTIVATION_MAPPING[layer.activation],
+                                              KerasModelGraph.__transpose(layer.kernel.numpy()),
+                                              layer.kernel_size,
+                                              layer.strides,
+                                              layer.filters,
+                                              layer.use_bias,
+                                              layer.bias.numpy(),
+                                              layer.groups,
+                                              KerasModelGraph.__compute_padding1d(layer.padding,
+                                                                                  layer.kernel_size,
+                                                                                  layer.strides,
+                                                                                  args.input_shape)]),
+        Conv2D: lambda layer, args: (TConv2DLayer, [KerasModelGraph.ACTIVATION_MAPPING[layer.activation],
+                                              KerasModelGraph.__transpose(layer.kernel.numpy()),
+                                              layer.kernel_size,
+                                              layer.strides,
+                                              layer.filters,
+                                              layer.use_bias,
+                                              layer.bias.numpy(),
+                                              layer.groups,
+                                              KerasModelGraph.__compute_padding2d(layer.padding,
+                                                                                  layer.kernel_size,
+                                                                                  layer.strides,
+                                                                                  args.input_shape)]),
+        Dropout: lambda layer, _: (TDropoutLayer, [layer.rate]),
+        MaxPooling1D: lambda layer, _: (TMaxPooling1DLayer, [TActivation.LINEAR, layer.pool_size, layer.strides]),
+        MaxPooling2D: lambda layer, _: (TMaxPooling2DLayer, [TActivation.LINEAR, layer.pool_size, layer.strides]),
+        AveragePooling1D: lambda layer, _: (TAvgPooling1DLayer, [TActivation.LINEAR, layer.pool_size, layer.strides]),
+        AveragePooling2D: lambda layer, _: (TAvgPooling2DLayer, [TActivation.LINEAR, layer.pool_size, layer.strides]),
+        Activation: lambda layer, _: (TActivationLayer, [KerasModelGraph.ACTIVATION_MAPPING[layer.activation]]),
+        Add: lambda *_: (TAddLayer, []),
+        Flatten: lambda *_: (TFlattenLayer, []),
+        Dense: lambda layer, _: (TDenseLayer, [KerasModelGraph.ACTIVATION_MAPPING[layer.activation],
+                                            KerasModelGraph.__transpose(layer.kernel.numpy()),
+                                            layer.units,
+                                            layer.use_bias,
+                                            layer.bias.numpy()]),
+    }
+
+    ACTIVATION_MAPPING: ClassVar[dict[Callable[[tf.Tensor], tf.Tensor], TActivation]] = {
+        relu: TActivation.RELU,
+        softmax: TActivation.SOFTMAX,
+        linear: TActivation.LINEAR,
+    }
+
+    def __init__(self, model: Model) -> None:
+        super().__init__()
+        self.__model = model
+        self.__layer_cache: dict[Layer, TBaseLayer] = {}
+
+    def convert(self) -> ModelGraph | None:
+        for layer in self.__model.layers:
+            conv = self.__convert(layer)
+            if conv is False: # Conversion failure
+                return None
+            inlayers = self.__get_layer_input_layers(layer)
+            if inlayers is False:
+                return None # Conversion failure
+            self.add_layer(conv, inlayers=inlayers)
+        return self
+
+    def __none_to_one_shape(self, shape: ShapeOptional) -> Shape:
+        return Shape(s if s is not None else 1 for s in shape)
+
+    def __convert_shapes(self, shapes: tuple[int | None, ...] | list[tuple[int | None, ...]]) -> Shapes:
+        """Convert shape or list of shapes to Shapes object.
+
+        Some layers (e.g. InputLayer) may have an unneeded list of shape.
+        """
+        if isinstance(shapes, list):
+            return Shapes(Shape(self.__none_to_one_shape(ShapeOptional(s))) for s in shapes)
+        return Shapes((Shape(self.__none_to_one_shape(ShapeOptional(shapes))),))
+
+    def __convert_dtypes(self, dtypes: numpy.typing.DTypeLike | list[numpy.typing.DTypeLike]) -> DTypes:
+        """Convert dtype or list of dtypes to DTypes object."""
+        if isinstance(dtypes, list):
+            return DTypes(t for t in dtypes)
+        return DTypes((dtypes,))
+
+    def __convert(self, layer: Layer) -> Literal[False] | TBaseLayer:
+        existing = self.__layer_cache.get(layer, None)
+        if existing is not None:
+            return existing
+
+        # Not the final layer type, just used to collect the common args
+        args = TBaseLayer(input_shape=self.__convert_shapes(self.__get_input_shape(layer)),
+                output_shape=self.__convert_shapes(self.__get_output_shape(layer)),
+                output_dtype=self.__convert_dtypes(layer.dtype),
+                name=layer.name)
+
+        options = KerasModelGraph.MAPPING.get(type(layer), None)
+
+        if options is None:
+            logger.error('Unsupported Keras layer type: %s', type(layer))
+            return False
+
+        cls, params = options(layer, args)
+
+        self.__layer_cache[layer] = res = cls(*dataclasses.astuple(args), *params)
+        return res
+
+    def __get_layer_input_layers(self, layer: Layer) -> Literal[False] | list[Layer]:
+        inlayers = []
+        for n in self.__get_inbound_nodes(layer):
+            # Keras 3.x compatibility
+            if hasattr(n, 'operation'):
+                inlayer = self.__convert(n.operation)
+                if inlayer is False:
+                    return False
+                inlayers.append(inlayer)
+            else:
+                for inb in n.iterate_inbound():
+                    inlayer = self.__convert(inb[0])
+                    if inlayer is False:
+                        return False
+                    inlayers.append(inlayer)
+        return inlayers
+
+    @classmethod
+    def __transpose(cls, weights: NDArrayFloatOrInt) -> NDArrayFloatOrInt:
+        # Shape requirement for CMSIS-NN, also used without CMSIS-NN for compatibility
+        if len(weights.shape) == 4: # noqa: PLR2004
+            return weights.transpose(3, 0, 1, 2)
+        if len(weights.shape) == 3: # noqa: PLR2004
+            return weights.transpose(2, 0, 1)
+        if len(weights.shape) == 2: # noqa: PLR2004
+            return weights.swapaxes(0, 1)
+        raise NotImplementedError
+
+    @classmethod
+    def __compute_padding1d(cls,
+                            padding: str,
+                            kernel_size: tuple[int],
+                            strides: tuple[int],
+                            input_shape: Shapes) -> tuple[int, int]:
+        if padding == 'valid':
+            return (0, 0)
+
+        if padding == 'same':
+            # Inspired from tensorflow/core/framework/kernel_shape_util.cc:GetWindowedOutputSizeVerbose()
+            output_size = (input_shape[0][-2] + strides[0] - 1) // strides[0]
+            padding_needed = max(0, (output_size - 1) * strides[0] + kernel_size[0] - input_shape[0][-2])
+            padding_before = padding_needed // 2
+            padding_after = padding_needed - padding_before
+            return (padding_before, padding_after)
+
+        logger.error('Unsupported padding mode %s', padding)
+        raise ValueError
+
+    @classmethod
+    def __compute_padding2d(cls,
+                            padding: str,
+                            kernel_size: tuple[int, int],
+                            strides: tuple[int, int],
+                            input_shape: Shapes) -> tuple[tuple[int, int], tuple[int, int]]:
+        if padding == 'valid':
+            return ((0, 0), (0, 0))
+
+        if padding == 'same':
+            # Inspired from tensorflow/core/framework/kernel_shape_util.cc:GetWindowedOutputSizeVerbose()
+            output_size_x = (input_shape[0][-2] + strides[1] - 1) // strides[1]
+            output_size_y = (input_shape[0][-3] + strides[0] - 1) // strides[0]
+            padding_x_needed = max(0, (output_size_x - 1) * strides[1] + kernel_size[1] - input_shape[0][-2])
+            padding_y_needed = max(0, (output_size_y - 1) * strides[0] + kernel_size[0] - input_shape[0][-3])
+            padding_x_before = padding_x_needed // 2
+            padding_y_before = padding_y_needed // 2
+            padding_x_after = padding_x_needed - padding_x_before
+            padding_y_after = padding_y_needed - padding_y_before
+            return ((padding_y_before, padding_y_after), (padding_x_before, padding_x_after))
+
+        logger.error('Unsupported padding mode %s', padding)
+        raise ValueError
+
+    @classmethod
+    def __get_input_shape(cls, layer: Layer) -> tuple[int, ...]:
+        # Keras 3.x compatibility
+        if not hasattr(layer, 'input_shape'):
+            if isinstance(layer, InputLayer): # get_build_config() returns None for InputLayer
+                return cast(tuple[int, ...], layer.batch_shape)
+            return cast(tuple[int, ...], layer.get_build_config()['input_shape'])
+        return cast(tuple[int, ...], layer.input_shape)
+
+    @classmethod
+    def __get_output_shape(cls, layer: Layer) -> tuple[int, ...]:
+        # Keras 3.x compatibility
+        if not hasattr(layer, 'output_shape'):
+            if isinstance(layer, InputLayer): # compute_output_shape not implemented for InputLayer
+                return cast(tuple[int, ...], layer.batch_shape)
+            return cast(tuple[int, ...], layer.compute_output_shape(cls.__get_input_shape(layer)))
+        return cast(tuple[int, ...], layer.output_shape)
+
+    @classmethod
+    def __get_inbound_nodes(cls, layer: Layer) -> list[Node]:
+        if hasattr(layer, 'inbound_nodes'):
+            return cast(list[Node], layer.inbound_nodes)
+        # Keras 3.x compatibility, no public API
+        return [n for inbound_node in layer._inbound_nodes for n in inbound_node.parent_nodes]  # noqa: SLF001

{qualia_codegen_core-2.2.0 → qualia_codegen_core-2.3.0}/src/qualia_codegen_core/graph/ModelGraph.py

@@ -120,11 +120,11 @@ class ModelGraph:
 
         innodes = self.get_nodes_for_layers(inlayers)
         if not self.no_none_in_nodes(innodes):
-            logger.error('Input node for layer not found')
+            logger.error('Input node for layer %s not found', layer.name)
             return
         outnodes = self.get_nodes_for_layers(outlayers)
         if not self.no_none_in_nodes(outnodes):
-            logger.error('Output node for layer not found')
+            logger.error('Output node for layer %s not found', layer.name)
             return
 
         self.add_node(LayerNode(layer), innodes, outnodes)

{qualia_codegen_core-2.2.0 → qualia_codegen_core-2.3.0}/src/qualia_codegen_core/graph/TorchModelGraph.py

@@ -288,7 +288,7 @@ class TorchModelGraph(ModelGraph):
     def __generate_dummy_inputs(self, shapes: Shapes,
                                 dtypes: DTypes) -> tuple[Tensor, ...]:
         def generate_input(shape: Shape, dtype: numpy.typing.DTypeLike) -> Tensor:
-            return torch.from_numpy(np.zeros((1,
+            return torch.from_numpy(np.zeros((shape[0],
                                               *self.__shape_channels_last_to_first(Shape(shape[1:]))),
                                              dtype=dtype))
         return tuple(generate_input(shape, dtype) for shape, dtype in zip(shapes, dtypes))
@@ -384,8 +384,9 @@ class TorchModelGraph(ModelGraph):
         # kwargs are the methods's keyword arguments
         method_kwargs = self.__load_arg(layer.kwargs)
         method = getattr(self_obj, layer.target)
-        dummy_outputs = method(*method_args, **method_kwargs)
-        self.__layer_outputs[layer.name] = dummy_outputs
+        module_outputs = method(*method_args, **method_kwargs)
+        self.__layer_outputs[layer.name] = module_outputs
+        dummy_outputs = (module_outputs,) if isinstance(module_outputs, Tensor) else tuple(module_outputs)
 
         if not hasattr(self_obj, 'shape') or not isinstance(self_obj.shape, tuple):
             logger.error('No or invalid input_shape found for %s', layer.target)

{qualia_codegen_core-2.2.0 → qualia_codegen_core-2.3.0}/src/qualia_codegen_core/graph/layers/TConv1DLayer.py

@@ -5,4 +5,4 @@ from .TConvLayer import TConvLayer
 
 @dataclass
 class TConv1DLayer(TConvLayer):
-    padding: tuple[int]
+    padding: tuple[int, int]

{qualia_codegen_core-2.2.0 → qualia_codegen_core-2.3.0}/src/qualia_codegen_core/graph/layers/TConv2DLayer.py

@@ -5,4 +5,4 @@ from .TConvLayer import TConvLayer
 
 @dataclass
 class TConv2DLayer(TConvLayer):
-    padding: tuple[tuple[int]]
+    padding: tuple[tuple[int, int], tuple[int, int]]

{qualia_codegen_core-2.2.0 → qualia_codegen_core-2.3.0}/src/qualia_codegen_core/graph/layers/TConvLayer.py

@@ -21,8 +21,8 @@ else:
 class TConvLayer(TBaseLayer):
     activation: TActivation
     kernel: NDArrayFloatOrInt
-    kernel_size: tuple[int]
-    strides: tuple[int]
+    kernel_size: tuple[int, ...]
+    strides: tuple[int, ...]
     filters: int
     use_bias: bool
     bias: NDArrayFloatOrInt

qualia_codegen_core-2.2.0/src/qualia_codegen_core/graph/KerasModelGraph.py

@@ -1,190 +0,0 @@
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Literal
-
-from keras.activations import linear, relu, softmax  # type: ignore[import-untyped] # No stubs for keras package
-from keras.layers import (  # type: ignore[import-untyped] # No stubs for keras package
-    Activation,
-    Add,
-    AveragePooling1D,
-    AveragePooling2D,
-    BatchNormalization,
-    Conv1D,
-    Conv2D,
-    Dense,
-    Dropout,
-    Flatten,
-    Layer,
-    MaxPooling1D,
-    MaxPooling2D,
-    ZeroPadding1D,
-    ZeroPadding2D,
-)
-
-from qualia_codegen_core.typing import DTypes, NDArrayFloatOrInt, Shape, ShapeOptional, Shapes
-
-from .layers import (
-    TActivationLayer,
-    TAddLayer,
-    TAvgPooling1DLayer,
-    TAvgPooling2DLayer,
-    TBaseLayer,
-    TBatchNormalization1DLayer,
-    TBatchNormalization2DLayer,
-    TConv1DLayer,
-    TConv2DLayer,
-    TDenseLayer,
-    TDropoutLayer,
-    TFlattenLayer,
-    TInputLayer,
-    TMaxPooling1DLayer,
-    TMaxPooling2DLayer,
-    TZeroPadding1DLayer,
-    TZeroPadding2DLayer,
-)
-from .layers.TActivationLayer import TActivation
-from .ModelGraph import ModelGraph
-
-try:
-    # Keras >= 2.13.1
-    from keras.src.engine.input_layer import InputLayer  # type: ignore[import-untyped] # No stubs for keras package
-except ImportError:
-    # Keras < 2.13.0
-    from keras.engine.input_layer import InputLayer  # type: ignore[import-untyped] # No stubs for keras package
-
-if TYPE_CHECKING:
-    import numpy.typing
-    import tensorflow as tf  # type: ignore[import-untyped]
-    from keras import Model  # type: ignore[import-untyped]
-
-logger = logging.getLogger(__name__)
-
-
-class KerasModelGraph(ModelGraph):
-    MAPPING: ClassVar[dict[type[Layer], Callable[[Layer], tuple[type[TBaseLayer], list[Any]]]]] = {
-        InputLayer: lambda _: (TInputLayer, []),
-        ZeroPadding1D: lambda layer: (TZeroPadding1DLayer, [layer.padding]),
-        ZeroPadding2D: lambda layer: (TZeroPadding2DLayer, [layer.padding]),
-        BatchNormalization: lambda layer: (TBatchNormalization1DLayer if len(layer.input_shape) == 3 # noqa: PLR2004
-                                           else TBatchNormalization2DLayer,
-                                           [TActivation.LINEAR,
-                                            layer.moving_mean.numpy(),
-                                            layer.moving_variance.numpy(),
-                                            layer.gamma.numpy(),
-                                            layer.beta.numpy(),
-                                            layer.epsilon]),
-        Conv1D: lambda layer: (TConv1DLayer, [KerasModelGraph.ACTIVATION_MAPPING[layer.activation],
-                                              KerasModelGraph.__transpose(layer.kernel.numpy()),
-                                              layer.kernel_size,
-                                              layer.strides,
-                                              layer.filters,
-                                              layer.use_bias,
-                                              layer.bias.numpy(),
-                                              layer.groups,
-                                              layer.padding]),
-        Conv2D: lambda layer: (TConv2DLayer, [KerasModelGraph.ACTIVATION_MAPPING[layer.activation],
-                                              KerasModelGraph.__transpose(layer.kernel.numpy()),
-                                              layer.kernel_size,
-                                              layer.strides,
-                                              layer.filters,
-                                              layer.use_bias,
-                                              layer.bias.numpy(),
-                                              layer.groups,
-                                              layer.padding]),
-        Dropout: lambda layer: (TDropoutLayer, [layer.rate]),
-        MaxPooling1D: lambda layer: (TMaxPooling1DLayer, [TActivation.LINEAR, layer.pool_size, layer.strides]),
-        MaxPooling2D: lambda layer: (TMaxPooling2DLayer, [TActivation.LINEAR, layer.pool_size, layer.strides]),
-        AveragePooling1D: lambda layer: (TAvgPooling1DLayer, [TActivation.LINEAR, layer.pool_size, layer.strides]),
-        AveragePooling2D: lambda layer: (TAvgPooling2DLayer, [TActivation.LINEAR, layer.pool_size, layer.strides]),
-        Activation: lambda layer: (TActivationLayer, [KerasModelGraph.ACTIVATION_MAPPING[layer.activation]]),
-        Add: lambda _: (TAddLayer, []),
-        Flatten: lambda _: (TFlattenLayer, []),
-        Dense: lambda layer: (TDenseLayer, [KerasModelGraph.ACTIVATION_MAPPING[layer.activation],
-                                            KerasModelGraph.__transpose(layer.kernel.numpy()),
-                                            layer.units,
-                                            layer.use_bias,
-                                            layer.bias.numpy()]),
-    }
-
-    ACTIVATION_MAPPING: ClassVar[dict[Callable[[tf.Tensor], tf.Tensor], TActivation]] = {
-        relu: TActivation.RELU,
-        softmax: TActivation.SOFTMAX,
-        linear: TActivation.LINEAR,
-    }
-
-    def __init__(self, model: Model) -> None:
-        super().__init__()
-        self.__model = model
-        self.__layer_cache: dict[Layer, TBaseLayer] = {}
-
-    def convert(self) -> ModelGraph | None:
-        for layer in self.__model.layers:
-            conv = self.__convert(layer)
-            if conv is False: # Conversion failure
-                return None
-            inlayers = self.__get_layer_input_layers(layer)
-            if inlayers is False:
-                return None # Conversion failure
-            self.add_layer(conv, inlayers=inlayers)
-        return self
-
-    def __none_to_one_shape(self, shape: ShapeOptional) -> Shape:
-        return Shape(s if s is not None else 1 for s in shape)
-
-    def __convert_shapes(self, shapes: tuple[int | None, ...] | list[tuple[int | None, ...]]) -> Shapes:
-        """Convert shape or list of shapes to Shapes object.
-
-        Some layers (e.g. InputLayer) may have an unneeded list of shape.
-        """
-        if isinstance(shapes, list):
-            return Shapes(Shape(self.__none_to_one_shape(ShapeOptional(s))) for s in shapes)
-        return Shapes((Shape(self.__none_to_one_shape(ShapeOptional(shapes))),))
-
-    def __convert_dtypes(self, dtypes: numpy.typing.DTypeLike | list[numpy.typing.DTypeLike]) -> DTypes:
-        """Convert dtype or list of dtypes to DTypes object."""
-        if isinstance(dtypes, list):
-            return DTypes(t for t in dtypes)
-        return DTypes((dtypes,))
-
-    def __convert(self, layer: Layer) -> Literal[False] | TBaseLayer:
-        existing = self.__layer_cache.get(layer, None)
-        if existing is not None:
-            return existing
-
-        args = [self.__convert_shapes(layer.input_shape),
-                self.__convert_shapes(layer.output_shape),
-                self.__convert_dtypes(layer.dtype),
-                layer.name]
-
-        options = KerasModelGraph.MAPPING.get(type(layer), None)
-
-        if options is None:
-            logger.error('Unsupported Keras layer type: %s', type(layer))
-            return False
-
-        cls, params = options(layer)
-
-        self.__layer_cache[layer] = res = cls(*args, *params)
-        return res
-
-    def __get_layer_input_layers(self, layer: Layer) -> Literal[False] | list[Layer]:
-        inlayers = []
-        for n in layer.inbound_nodes:
-            for inb in n.iterate_inbound():
-                inlayer = self.__convert(inb[0])
-                if inlayer is False:
-                    return False
-                inlayers.append(inlayer)
-        return inlayers
-
-    @classmethod
-    def __transpose(cls, weights: NDArrayFloatOrInt) -> NDArrayFloatOrInt:
-        # Shape requirement for CMSIS-NN, also used without CMSIS-NN for compatibility
-        if len(weights.shape) == 4: # noqa: PLR2004
-            return weights.transpose(3, 0, 1, 2)
-        if len(weights.shape) == 3: # noqa: PLR2004
-            return weights.transpose(2, 0, 1)
-        if len(weights.shape) == 2: # noqa: PLR2004
-            return weights.swapaxes(0, 1)
-        raise NotImplementedError