NXP backend: Improve target support checks. (#13367)

### Summary
Improve target specific checks for operator support on Neutron.

### Test plan
Almost all tests utilize the updated functionality, and some unit-tests
were updated to reflect the new implementation.

Author: MartinPavella

backends/nxp/backend/ir/converter/node_converter.py

@@ -1,11 +1,10 @@
-# Copyright 2024 NXP
+# Copyright 2024-2025 NXP
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import Collection
 
 import torch
 
@@ -53,7 +52,6 @@ class NodeConverter(ABC):
     """
 
     context: ConversionContext
-    supported_targets: Collection
 
     def __init__(self, context: ConversionContext):
         self.context = context
@@ -78,25 +76,23 @@ def _is_supported_in_IR(
             Classes which implement conversion for individual operators must overwrite this method.
 
         :param node: torch.Node to check.
+        :param parameters_mapping: Dictionary mapping tensor names to their static data (if they have it).
         """
         pass
 
-    @classmethod
-    def _is_supported_on_target(cls, target: Target) -> bool:
-        """Check if the node is supported on the target platform. It uses the 'supported_platform' attribute, which is
-             a list of supported target platforms, and it must be defined by the specific `NodeConverter`.
+    @staticmethod
+    def _is_supported_on_target(
+        node: Node, target: Target, parameters_mapping: dict[str, Parameter]
+    ) -> bool:
+        """Check if the node is supported on the target platform.
+            Child classes should overwrite this method to implement specific target checks. The default implementation
+            can be used by operators with no target specific requirements.
 
+        :param node: The node (edge operator) to check.
         :param target: Value of the `Target` enum representing the target platform to check for.
+        :param parameters_mapping: Dictionary mapping tensor names to their static data (if they have it).
         """
-        if not (
-            hasattr(cls, "supported_targets")
-            and isinstance(cls.supported_targets, Collection)
-        ):
-            raise NotImplementedError(
-                f"The NodeConverter `{cls}` does not define its `supported_targets` collection."
-            )
-
-        return target == Target.IGNORE or target in cls.supported_targets
+        return target == Target.RT700
 
     @classmethod
     def is_supported(
@@ -110,7 +106,7 @@ def is_supported(
         """
         return cls._is_supported_in_IR(
             node, parameters_mapping
-        ) and cls._is_supported_on_target(target)
+        ) and cls._is_supported_on_target(node, target, parameters_mapping)
 
     @staticmethod
     def _has_shared_q_params_if_quantized(node: Node) -> bool:

backends/nxp/backend/ir/converter/node_converters/ops_converters/abs_converter.py

@@ -1,14 +1,10 @@
-# Copyright (c) 2025 NXP
-# All rights reserved.
+# Copyright 2025 NXP
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
 
-from executorch.backends.nxp.backend.ir.converter.node_converter import (
-    NodeConverter,
-    Target,
-)
+from executorch.backends.nxp.backend.ir.converter.node_converter import NodeConverter
 from executorch.backends.nxp.backend.ir.tflite_generator.builtin_options import (
     abs_options,
 )
@@ -17,7 +13,6 @@
 
 
 class AbsConverter(NodeConverter):
-    supported_targets = [Target.RT700]
 
     @staticmethod
     def _is_supported_in_IR(

backends/nxp/backend/ir/converter/node_converters/ops_converters/adaptive_avg_pool_2d_converter.py

@@ -1,15 +1,11 @@
-# Copyright (c) 2025 NXP
-# All rights reserved.
+# Copyright 2025 NXP
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
 import executorch.backends.nxp.backend.ir.lib.tflite.Padding as tflPadding
 from executorch.backends.nxp.backend.ir.converter.conversion import common
-from executorch.backends.nxp.backend.ir.converter.node_converter import (
-    NodeConverter,
-    Target,
-)
+from executorch.backends.nxp.backend.ir.converter.node_converter import NodeConverter
 from executorch.backends.nxp.backend.ir.tflite_generator import tflite_model
 from executorch.backends.nxp.backend.ir.tflite_generator.builtin_options import (
     average_pool_2d_options,
@@ -20,7 +16,6 @@
 
 
 class AdaptiveAvgPool2dConverter(NodeConverter):
-    supported_targets = [Target.RT700]
 
     @staticmethod
     def _is_supported_in_IR(

backends/nxp/backend/ir/converter/node_converters/ops_converters/add_tensor_converter.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2025 NXP
-# All rights reserved.
+# Copyright 2025 NXP
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
@@ -19,7 +18,20 @@
 
 
 class AddTensorConverter(NodeConverter):
-    supported_targets = [Target.RT700]
+    @staticmethod
+    def _is_supported_on_target(
+        node: Node, target: Target, parameters_mapping: dict[str, Parameter]
+    ) -> bool:
+        match target:
+            case Target.RT700:
+                if node_uses_shape_broadcasting(node):
+                    # Shape broadcasting may require the addition of `Transpose` ops during conversion.
+                    return False
+
+                return True
+
+            case _:
+                return False
 
     @staticmethod
     def _is_supported_in_IR(
@@ -31,10 +43,6 @@ def _is_supported_in_IR(
         if hasattr(node.kwargs, "alpha"):
             return False
 
-        # Don't convert if broadcasting input tensors
-        if node_uses_shape_broadcasting(node):
-            return False
-
         return True
 
     # add.Tensor Node format: (Tensor self, Tensor other, *, Scalar alpha=1)

backends/nxp/backend/ir/converter/node_converters/ops_converters/addmm_converter.py

@@ -1,14 +1,11 @@
-# Copyright 2024 NXP
+# Copyright 2024-2025 NXP
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
 from executorch.backends.nxp.backend.edge_helper import input_rank
 from executorch.backends.nxp.backend.ir.converter.conversion.common import OpsList
-from executorch.backends.nxp.backend.ir.converter.node_converter import (
-    NodeConverter,
-    Target,
-)
+from executorch.backends.nxp.backend.ir.converter.node_converter import NodeConverter
 from executorch.backends.nxp.backend.ir.tflite_generator.builtin_options import (
     fully_connected_options,
 )
@@ -32,8 +29,6 @@ def _is_supported_in_IR(
 
         return True
 
-    supported_targets = [Target.RT700]
-
     def convert(self, node: Node):
         self.assert_convertible(node)
 

backends/nxp/backend/ir/converter/node_converters/ops_converters/avg_pool_2d_converter.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2025 NXP
-# All rights reserved.
+# Copyright 2025 NXP
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
@@ -9,10 +8,7 @@
     common,
 )
 from executorch.backends.nxp.backend.ir.converter.conversion.common import OpsList
-from executorch.backends.nxp.backend.ir.converter.node_converter import (
-    NodeConverter,
-    Target,
-)
+from executorch.backends.nxp.backend.ir.converter.node_converter import NodeConverter
 from executorch.backends.nxp.backend.ir.tflite_generator import tflite_model
 from executorch.backends.nxp.backend.ir.tflite_generator.builtin_options import (
     average_pool_2d_options,
@@ -22,7 +18,6 @@
 
 
 class AvgPool2dConverter(NodeConverter):
-    supported_targets = [Target.RT700]
 
     @staticmethod
     def _is_supported_in_IR(

backends/nxp/backend/ir/converter/node_converters/ops_converters/clone_converter.py

@@ -4,10 +4,8 @@
 # LICENSE file in the root directory of this source tree.
 
 import torch
-from executorch.backends.nxp.backend.ir.converter.node_converter import (
-    NodeConverter,
-    Target,
-)
+
+from executorch.backends.nxp.backend.ir.converter.node_converter import NodeConverter
 from torch.fx import Node
 from torch.nn import Parameter
 
@@ -20,7 +18,6 @@ def _has_supported_memory_format(node: Node) -> bool:
 
 
 class CloneConverter(NodeConverter):
-    supported_targets = [Target.RT700]
 
     @staticmethod
     def _is_supported_in_IR(

backends/nxp/backend/ir/converter/node_converters/ops_converters/constant_pad_nd_converter.py

@@ -1,4 +1,4 @@
-# Copyright 2024 NXP
+# Copyright 2024-2025 NXP
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
@@ -31,7 +31,22 @@
 
 
 class ConstantPadNDConverter(NodeConverter):
-    supported_targets = [Target.RT700]
+    @staticmethod
+    def _is_supported_on_target(
+        node: Node, target: Target, parameters_mapping: dict[str, Parameter]
+    ) -> bool:
+        match target:
+            case Target.RT700:
+                # TODO: Consider different tensor formats (dim-order)
+                paddings = node.args[1]
+                if len(paddings) > 4 and paddings[4:6] != [0, 0]:
+                    # Attempt to Pad channels dimension, which is not supported on Neutron.
+                    return False
+
+                return True
+
+            case _:
+                return False
 
     @staticmethod
     def _is_supported_in_IR(

backends/nxp/backend/ir/converter/node_converters/ops_converters/convolution_converter.py

@@ -1,4 +1,4 @@
-# Copyright 2024 NXP
+# Copyright 2024-2025 NXP
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
@@ -42,57 +42,64 @@
 
 
 class ConvolutionConverter(NodeConverter):
-    supported_targets = [Target.RT700]
+    @staticmethod
+    def _is_supported_on_target(
+        node: Node, target: Target, parameters_mapping: dict[str, Parameter]
+    ) -> bool:
+        match target:
+            case Target.RT700:
+                activations = node.args[0]
+                weights = node.args[1]
+                groups = node.args[8]
+
+                if activations.meta["val"].shape[0] != 1:
+                    # Only batch size 1 is supported on neutron.
+                    return False
+
+                if groups == 1:  # Regular convolution.
+                    pass
+                elif conv_utils.group_conv_convertible_as_depthwise(
+                    node, groups
+                ):  # Depthwise convolution.
+                    # Only supported if the weights are static, because TFLite `DepthwiseConv2D` uses permuted
+                    #  weights. In case the weights are dynamic, a Transpose operator would have to be added, which
+                    #  is not supported on Neutron.
+                    if not node_is_effectively_static_tensor(
+                        weights, parameters_mapping
+                    ):
+                        return False
+                elif conv_utils.group_conv_convertible_into_multiple_convolutions(
+                    node, groups
+                ):  # Separable conv.
+                    # Requires addition of `Split` and `Concatenation` operators, which are not supported on Neutron.
+                    return False
+                else:  # Unexpected case (should never happen).
+                    return False
+
+                return True
+
+            case _:
+                return False
 
     @staticmethod
     def _is_supported_in_IR(
         node: Node, parameters_mapping: dict[str, Parameter]
     ) -> bool:
         is_transposed = node.args[6]
         output_padding = node.args[7]
-        groups = node.args[8]
 
         if is_transposed:
             return False
 
         if output_padding != [0, 0]:
             return False
 
-        if groups == 1:
-            # Regular (pointwise) convolution.
-            pass
-
-        elif conv_utils.group_conv_convertible_as_depthwise(
-            node, groups
-        ) and node_is_effectively_static_tensor(node.args[1], parameters_mapping):
-            # Depthwise convolution.
-            # Only supported if the weights are static, because TFLite `DepthwiseConv2D` uses permuted weights. In case
-            #  the weights are dynamic, a Transpose operator would have to be added, which is not supported on Neutron.
-            pass
-
-        elif conv_utils.group_conv_convertible_into_multiple_convolutions(node, groups):
-            # Group Separable convolution.
-            # Not supported natively by the eIQ Neutron so Group Separable Convolution.
-            # In practice it can be computed by splitting the Group Separable Convolution into multiple Pointwise
-            # Convo it will use the Split and Concat operation. The Concat operation in Neutron Converter
-            # SDK  25.03 requires the # of channels to be multipy of # of MAC units in the eIQ Neutron.
-            # For this reason Group Separable Convolution is not delegated by default at this moment.
-            return False
-
-        else:
-            # All conversion options related to the `group` attribute have been checked and none of them can be used.
-            return False
-
         if input_tensor_safe(node, 2) is None:
             # No bias tensor.
             weight_tensor = input_tensor(node, 1)
             if weight_tensor.dtype not in [torch.float32, torch.int8, torch.uint8]:
                 return False
 
-        if node.args[0].meta["val"].shape[0] != 1:
-            # Only batch size 1 is supported on neutron.
-            return False
-
         return True
 
     Stride = Padding = Dilation = OutPadding = list[int]

backends/nxp/backend/ir/converter/node_converters/ops_converters/hardtanh_converter.py

@@ -1,13 +1,9 @@
-# Copyright (c) 2025 NXP
-# All rights reserved.
+# Copyright 2025 NXP
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-from executorch.backends.nxp.backend.ir.converter.node_converter import (
-    NodeConverter,
-    Target,
-)
+from executorch.backends.nxp.backend.ir.converter.node_converter import NodeConverter
 from executorch.backends.nxp.backend.ir.lib.tflite.BuiltinOperator import (
     BuiltinOperator,
 )
@@ -16,7 +12,6 @@
 
 
 class HardTanhConverter(NodeConverter):
-    supported_targets = [Target.RT700]
 
     # Maps possible input parameters of HardTanh to equivalent ReLU-based operators supported by TFLite.
     supported_modes_map = {