NXP backend: Add support for aten.clamp.default. (#17327)

### Summary
This PR adds support for the `aten.clamp.default` operator no NXP
backend.

### Test plan
Unit-tests provided.

Author: MartinPavella

backends/nxp/backend/edge_helper.py

@@ -9,6 +9,7 @@
 
 from executorch.exir.dialects._ops import ops as exir_ops
 from torch.fx import GraphModule, Node
+from torch.fx.node import Argument
 from torch.nn import Parameter
 
 QUANTIZE_OPERATORS = [
@@ -362,3 +363,7 @@ def node_has_well_defined_shape(node: Node) -> bool:
         return False
 
     return all(isinstance(dim, int) and dim > 0 for dim in val.shape)
+
+
+def try_get_arg(node: Node, idx: int) -> Argument | None:
+    return node.args[idx] if idx < len(node.args) else None

backends/nxp/backend/edge_program_converter.py

@@ -31,6 +31,7 @@
     exir_ops.edge.aten.add.Tensor: AddTensorConverter,  # noqa F405
     exir_ops.edge.aten.avg_pool2d.default: AvgPool2dConverter,  # noqa F405
     exir_ops.edge.aten.cat.default: CatConverter,  # noqa F405
+    exir_ops.edge.aten.clamp.default: ClampConverter,  # noqa F405
     exir_ops.edge.aten.clone.default: CloneConverter,  # noqa F405
     exir_ops.edge.dim_order_ops._clone_dim_order.default: CloneConverter,  # noqa F405
     exir_ops.edge.aten.constant_pad_nd.default: ConstantPadNDConverter,  # noqa F405

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

@@ -16,6 +16,9 @@
 from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.cat_converter import (
     CatConverter,
 )
+from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.clamp_converter import (
+    ClampConverter,
+)
 from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.clone_converter import (
     CloneConverter,
 )
@@ -88,6 +91,7 @@
     "AddTensorConverter",
     "AvgPool2dConverter",
     "CatConverter",
+    "ClampConverter",
     "CloneConverter",
     "ConstantPadNDConverter",
     "ConvolutionConverter",

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

@@ -0,0 +1,112 @@
+# Copyright 2026 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 try_get_arg
+from executorch.backends.nxp.backend.ir.converter.node_converter import (
+    CustomDelegationOptions,
+    is_not_qdq_node,
+    NodeConverter,
+)
+from executorch.backends.nxp.backend.neutron_target_spec import NeutronTargetSpec
+from tflite import BuiltinOperator
+from torch.fx import Node
+from torch.fx.passes.infra.partitioner import Partition
+from torch.nn import Parameter
+
+
+class ClampConverter(NodeConverter):
+    SUPPORTED_BOUNDS = {
+        "ReluN1To1": (-1, 1),
+        "Relu0To1": (0, 1),
+        "Relu6": (0, 6),
+        "Relu": (0, None),
+    }
+
+    BOUNDS_TO_NEUTRON_IR_OP = {
+        (-1, 1): BuiltinOperator.RELU_N1_TO_1,
+        (0, 1): BuiltinOperator.RELU_0_TO_1,
+        (0, 6): BuiltinOperator.RELU6,
+        (0, None): BuiltinOperator.RELU,
+    }
+
+    # noinspection PyShadowingBuiltins
+    @staticmethod
+    def _get_clamp_bounds(clamp_node: Node) -> tuple[float | None, float | None]:
+        """Extract min and max bounds from `aten.clamp.default` node."""
+        min = try_get_arg(clamp_node, 1)
+        max = try_get_arg(clamp_node, 2)
+        return min, max
+
+    @staticmethod
+    def _is_supported_in_IR(
+        node: Node,
+        parameters_mapping: dict[str, Parameter],
+        custom_delegation_options: CustomDelegationOptions,
+    ) -> bool:
+        # No NeutronIR-specific restrictions.
+        return True
+
+    @staticmethod
+    def _is_supported_on_target(
+        node: Node,
+        neutron_target_spec: NeutronTargetSpec,
+        parameters_mapping: dict[str, Parameter],
+        custom_delegation_options: CustomDelegationOptions,
+    ) -> bool:
+        bounds = ClampConverter._get_clamp_bounds(node)
+
+        # Only some specific bounds are supported on the target hardware.
+        if bounds not in ClampConverter.SUPPORTED_BOUNDS.values():
+            return False
+
+        return True
+
+    @classmethod
+    def supports_partitioning_result(
+        cls,
+        node: Node,
+        partition_list: list[Partition],
+        custom_delegation_options: CustomDelegationOptions,
+        neutron_target_spec: NeutronTargetSpec,
+        parameters_mapping: dict[str, Parameter],
+    ) -> bool:
+        bounds = cls._get_clamp_bounds(node)
+
+        if bounds in [cls.SUPPORTED_BOUNDS["Relu"], cls.SUPPORTED_BOUNDS["Relu6"]]:
+            # If this is the only operator in the partition, NeutronConverter will not create a NeutronNode for some
+            #  reason.
+            clamp_partitions = [p for p in partition_list if node in p.nodes]
+            if len(clamp_partitions) != 1:
+                return False  # Should never happen
+
+            clamp_partition = clamp_partitions[0]
+            non_q_dq_partition_nodes = list(
+                filter(is_not_qdq_node, clamp_partition.nodes)
+            )
+            if len(non_q_dq_partition_nodes) <= 1:
+                return False  # This would be the only node in the partition, which would cause a crash later on.
+
+        return True
+
+    def convert(self, node: Node):
+        """Convert the `aten.clamp.default` operator to Neutron IR `Relu*` operators.
+        The schema is:
+            aten::clamp(
+                Tensor self,
+                Scalar? min=None,
+                Scalar? max=None
+            ) -> Tensor
+        """
+        self.assert_convertible(node)
+
+        bounds = self._get_clamp_bounds(node)
+
+        t_op = self._create_tflite_op_with_io_tensors(node)
+
+        # noinspection PyTypeChecker,PyUnboundLocalVariable
+        t_op.opcode_index = self.builder.op_code_index_for_op_type(
+            self.BOUNDS_TO_NEUTRON_IR_OP[bounds]
+        )
+        self.builder.append_operators([t_op])

backends/nxp/neutron_partitioner.py

@@ -203,6 +203,7 @@ def tag_qdq_clusters(self, nodes: list[torch.fx.Node]):
     exir_ops.edge.aten.add.Tensor: AddTensorConverter,  # noqa F405
     exir_ops.edge.aten.avg_pool2d.default: AvgPool2dConverter,  # noqa F405
     exir_ops.edge.aten.cat.default: CatConverter,  # noqa F405
+    exir_ops.edge.aten.clamp.default: ClampConverter,  # noqa F405
     exir_ops.edge.aten.clone.default: CloneConverter,  # noqa F405
     exir_ops.edge.dim_order_ops._clone_dim_order.default: CloneConverter,  # noqa F405
     exir_ops.edge.aten.constant_pad_nd.default: ConstantPadNDConverter,  # noqa F405

backends/nxp/quantizer/neutron_quantizer.py

@@ -20,6 +20,7 @@
     AvgPoolPattern,
     BatchNormPattern,
     CatPattern,
+    ClampPattern,
     Conv1dPattern,
     Conv2dPattern,
     ConvTranspose2dPattern,
@@ -252,6 +253,7 @@ def __init__(self, neutron_target_spec: NeutronTargetSpec, is_qat: bool = False)
                 OpQuantizer(AvgPoolPattern(is_qat=is_qat), static_qconfig),
                 OpQuantizer(BatchNormPattern(is_qat=is_qat), static_qconfig),
                 OpQuantizer(CatPattern(is_qat=is_qat), static_qconfig),
+                OpQuantizer(ClampPattern(is_qat=is_qat), static_qconfig),
                 OpQuantizer(Conv1dPattern(is_qat=is_qat), static_qconfig),
                 OpQuantizer(Conv2dPattern(self, is_qat=is_qat), static_qconfig),
                 OpQuantizer(ConvTranspose2dPattern(is_qat=is_qat), static_qconfig),

backends/nxp/quantizer/patterns.py

@@ -377,6 +377,13 @@ def get_anchors(
         )
 
 
+class ClampPattern(SingleInputBasicPattern):
+    """Quantizer for the `aten.clamp.default` operator."""
+
+    def partition_types(self):
+        return [torch.ops.aten.clamp.default]
+
+
 def _is_batch_norm(node_: Node) -> bool:
     return node_.op == "call_function" and node_.target in [
         torch.ops.aten.batch_norm.default,

backends/nxp/tests/ir/converter/node_converter/test_clamp_converter.py

@@ -0,0 +1,175 @@
+# Copyright 2026 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 numpy as np
+import pytest
+import torch
+
+from executorch.backends.nxp.backend.edge_program_converter import (
+    EdgeProgramToIRConverter,
+)
+from executorch.backends.nxp.tests.executorch_pipeline import to_quantized_edge_program
+from executorch.backends.nxp.tests.executors import (
+    convert_run_compare,
+    graph_contains_any_of_ops,
+)
+from executorch.exir.dialects._ops import ops as exir_ops
+
+
+@pytest.fixture(autouse=True)
+def reseed_model_per_test_run():
+    torch.manual_seed(42)
+    np.random.seed(23)
+
+
+# noinspection PyProtectedMember
+ExecutorchDelegateCall = torch.ops.higher_order.executorch_call_delegate
+Clamp = exir_ops.edge.aten.clamp.default
+
+
+class ClampModule(torch.nn.Module):
+
+    # noinspection PyShadowingBuiltins
+    def __init__(self, min=None, max=None):
+        super().__init__()
+        self.min = min
+        self.max = max
+
+    # noinspection PyMethodMayBeStatic
+    def forward(self, x):
+        return torch.clamp(x, self.min, self.max)
+
+
+class AddClampModule(torch.nn.Module):
+
+    # noinspection PyShadowingBuiltins
+    def __init__(self, min=None, max=None):
+        super().__init__()
+        self.clamp = ClampModule(min, max)
+
+    def forward(self, x):
+        x = x + x
+        return self.clamp(x)
+
+
+# noinspection PyShadowingBuiltins
+@pytest.mark.parametrize(
+    "min, max",
+    [
+        pytest.param(0, 6, id="min = 0, max = 6 (Relu6)"),
+        pytest.param(0, 1, id="min = 0, max = 1 (Relu0To1)"),
+        pytest.param(-1, 1, id="min = -1, max = 1 (ReluN1To1)"),
+        pytest.param(0, None, id="min = 0, max = None (Relu)"),
+        # float bounds.
+        pytest.param(0.0, 6.0, id="min = 0.0, max = 6.0 (Relu6)"),
+        pytest.param(0.0, 1.0, id="min = 0.0, max = 1.0 (Relu0To1)"),
+        pytest.param(-1.0, 1.0, id="min = -1.0, max = 1.0 (ReluN1To1)"),
+        pytest.param(0.0, None, id="min = 0.0, max = None (Relu)"),
+    ],
+)
+def test_convert_clamp__supported(mocker, min, max):
+    input_shape = (23,)
+    model = AddClampModule(min, max)
+
+    converter_spy = mocker.spy(EdgeProgramToIRConverter, "convert_program")
+    delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
+
+    # Make sure the `clamp` was delegated.
+    assert graph_contains_any_of_ops(delegated_ep.graph, [ExecutorchDelegateCall])
+    assert not graph_contains_any_of_ops(delegated_ep.graph, [Clamp])
+
+    # Verify correct behavior of the converted NeutronIR model.
+    intermediate_ep = converter_spy.call_args.args[1]
+    neutron_ir_model, _ = converter_spy.spy_return
+
+    input_data = (
+        np.random.random(input_shape).astype(np.float32) * 256.0 - 128.0
+    ).astype(np.int8)
+
+    # Make sure the tested program contains the `clamp`.
+    assert graph_contains_any_of_ops(intermediate_ep.graph, [Clamp])
+
+    convert_run_compare(
+        intermediate_ep,
+        tfl_model=neutron_ir_model,
+        input_data=input_data,
+    )
+
+
+# noinspection PyShadowingBuiltins
+@pytest.mark.parametrize(
+    "min, max",
+    [
+        pytest.param(0, 6, id="min = 0, max = 6 (Relu6)"),
+        pytest.param(0, None, id="min = 0, max = None (Relu)"),
+    ],
+)
+def test_convert_clamp__single_op__not_delegated_variants(min, max):
+    # Test that Clamp representable as Relu6 or Relu is NOT delegated, because it is a single op model which is not
+    #  supported by Neutron.
+    input_shape = (23,)
+    model = ClampModule(min, max)
+
+    delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
+
+    # Make sure the `clamp` was NOT delegated (single op model).
+    assert not graph_contains_any_of_ops(delegated_ep.graph, [ExecutorchDelegateCall])
+    assert graph_contains_any_of_ops(delegated_ep.graph, [Clamp])
+
+
+# noinspection PyShadowingBuiltins
+@pytest.mark.parametrize(
+    "min, max",
+    [
+        pytest.param(0, 1, id="min = 0, max = 1 (Relu0To1)"),
+        pytest.param(-1, 1, id="min = -1, max = 1 (ReluN1To1)"),
+    ],
+)
+def test_convert_clamp__single_op__delegated_variants(mocker, min, max):
+    # Test that Clamp representable as Relu0To1 or ReluN1To1 is delegated, even though it is a single op model.
+    input_shape = (23,)
+    model = ClampModule(min, max)
+
+    converter_spy = mocker.spy(EdgeProgramToIRConverter, "convert_program")
+    delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
+
+    # Make sure the `clamp` was delegated.
+    assert graph_contains_any_of_ops(delegated_ep.graph, [ExecutorchDelegateCall])
+    assert not graph_contains_any_of_ops(delegated_ep.graph, [Clamp])
+
+    # Verify correct behavior of the converted NeutronIR model.
+    intermediate_ep = converter_spy.call_args.args[1]
+    neutron_ir_model, _ = converter_spy.spy_return
+
+    input_data = (
+        np.random.random(input_shape).astype(np.float32) * 256.0 - 128.0
+    ).astype(np.int8)
+
+    # Make sure the tested program contains the `clamp`.
+    assert graph_contains_any_of_ops(intermediate_ep.graph, [Clamp])
+
+    convert_run_compare(
+        intermediate_ep,
+        tfl_model=neutron_ir_model,
+        input_data=input_data,
+    )
+
+
+# noinspection PyShadowingBuiltins
+@pytest.mark.parametrize(
+    "min, max",
+    [
+        pytest.param(-3, 3, id="min = -3, max = 3"),
+        pytest.param(None, 5, id="min = None, max = 5"),
+    ],
+)
+def test_convert_clamp__no_delegation__unsupported_bounds(min, max):
+    input_shape = (23,)
+    model = AddClampModule(min, max)
+
+    delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
+
+    # Make sure the `clamp` was NOT delegated.
+    assert graph_contains_any_of_ops(delegated_ep.graph, [Clamp])

docs/source/backends/nxp/op-support.csv

@@ -2,9 +2,10 @@ Operator,Compute DType,Quantization,Constraints
 aten.abs.default,int8,static int8,
 aten._adaptive_avg_pool2d.default,int8,static int8,"ceil_mode=False, count_include_pad=False, divisor_override=False"
 aten.addmm.default,int8,static int8,2D tensor only
-aten.add.Tensor,int8,static int8,"alpha = 1, input tensor of rame rank"
+aten.add.Tensor,int8,static int8,"alpha = 1, input tensor of name rank"
 aten.avg_pool2d.default,int8,static int8,"ceil_mode=False, count_include_pad=False, divisor_override=False"
 aten.cat.default,int8,static int8,"input_channels % 8 = 0, output_channels %8 = 0"
+aten.clamp.default,int8,static int8,"Bounds = (-1, 1) or (0, 1) or (0, 6) or (0, None)"
 aten.clone.default,int8,static int8,
 aten.constant_pad_nd.default,int8,static int8,"H or W padding only"
 aten.convolution.default,int8,static int8,"1D or 2D convolution, constant weights, groups=1 or groups=channels_count (depthwise)"