NXP backend: Add support for aten.leaky_relu.default. (#17305)

### Summary
Add support for `aten.leaky_relu.default` to the NXP backend.

### Test plan
Unit-tests provided.


cc @robert-kalmar @JakeStevens @digantdesai

Author: MartinPavella

backends/nxp/backend/edge_program_converter.py

@@ -37,6 +37,7 @@
     exir_ops.edge.aten.constant_pad_nd.default: ConstantPadNDConverter,  # noqa F405
     exir_ops.edge.aten.convolution.default: ConvolutionConverter,  # noqa F405
     exir_ops.edge.aten.hardtanh.default: HardTanhConverter,  # noqa F405
+    exir_ops.edge.aten.leaky_relu.default: LeakyReluConverter,  # noqa F405
     exir_ops.edge.aten.max_pool2d.default: MaxPool2dConverter,  # noqa F405
     exir_ops.edge.aten.mean.dim: MeanDimConverter,  # noqa F405
     exir_ops.edge.aten.mm.default: MMConverter,  # noqa F405

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

@@ -31,6 +31,9 @@
 from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.hardtanh_converter import (
     HardTanhConverter,
 )
+from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.leaky_relu_converter import (
+    LeakyReluConverter,
+)
 from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.max_pool_2d_converter import (
     MaxPool2dConverter,
 )
@@ -99,6 +102,7 @@
     "ConstantPadNDConverter",
     "ConvolutionConverter",
     "HardTanhConverter",
+    "LeakyReluConverter",
     "MaxPool2dConverter",
     "MeanDimConverter",
     "MMConverter",

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

@@ -0,0 +1,42 @@
+# 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.ir.converter.node_converter import (
+    CustomDelegationOptions,
+    NodeConverter,
+)
+from executorch.backends.nxp.backend.ir.tflite_generator.builtin_options.leaky_relu_options import (
+    LeakyRelu,
+)
+from torch.fx import Node
+from torch.nn import Parameter
+
+
+class LeakyReluConverter(NodeConverter):
+
+    @staticmethod
+    def _is_supported_in_IR(
+        node: Node,
+        parameters_mapping: dict[str, Parameter],
+        custom_delegation_options: CustomDelegationOptions,
+    ) -> bool:
+        return True
+
+    def convert(self, node: Node):
+        """Convert the `aten.leaky_relu.default` operator to Neutron IR `LeakyRelu`.
+        The schema is:
+            aten::leaky_relu(
+                Tensor self,
+                Scalar negative_slope=0.01
+            ) -> Tensor
+        """
+        self.assert_convertible(node)
+
+        alpha = node.args[1] if len(node.args) > 1 else 0.01
+
+        t_op = self._create_tflite_op_with_io_tensors(node)
+        t_op.builtin_options = LeakyRelu(alpha)
+
+        self.builder.append_operators([t_op])

backends/nxp/neutron_partitioner.py

@@ -210,6 +210,7 @@ def tag_qdq_clusters(self, nodes: list[torch.fx.Node]):
     exir_ops.edge.aten.constant_pad_nd.default: ConstantPadNDConverter,  # noqa F405
     exir_ops.edge.aten.convolution.default: ConvolutionConverter,  # noqa F405
     exir_ops.edge.aten.hardtanh.default: HardTanhConverter,  # noqa F405
+    exir_ops.edge.aten.leaky_relu.default: LeakyReluConverter,  # noqa F405
     exir_ops.edge.aten.max_pool2d.default: MaxPool2dConverter,  # noqa F405
     exir_ops.edge.aten.max_pool2d_with_indices.default: MaxPool2dConverter,  # noqa F405
     exir_ops.edge.aten.mean.dim: MeanDimConverter,  # noqa F405

backends/nxp/quantizer/neutron_quantizer.py

@@ -28,6 +28,8 @@
     FlattenPattern,
     HardTanhInPlacePattern,
     HardTanhPattern,
+    LeakyReluInPlacePattern,
+    LeakyReluPattern,
     LinearPattern,
     MaxPoolPattern,
     MeanDimPattern,
@@ -262,6 +264,8 @@ def __init__(self, neutron_target_spec: NeutronTargetSpec, is_qat: bool = False)
                 OpQuantizer(FlattenPattern(is_qat=is_qat), static_qconfig),
                 OpQuantizer(HardTanhPattern(is_qat=is_qat), static_qconfig),
                 OpQuantizer(HardTanhInPlacePattern(is_qat=is_qat), static_qconfig),
+                OpQuantizer(LeakyReluPattern(is_qat=is_qat), static_fc_qconfig),
+                OpQuantizer(LeakyReluInPlacePattern(is_qat=is_qat), static_fc_qconfig),
                 OpQuantizer(LinearPattern(self, is_qat=is_qat), static_fc_qconfig),
                 OpQuantizer(MaxPoolPattern(is_qat=is_qat), static_qconfig),
                 OpQuantizer(MeanDimPattern(is_qat=is_qat), static_qconfig),

backends/nxp/quantizer/patterns.py

@@ -25,7 +25,6 @@
     QuantizationSpec,
     SharedQuantizationSpec,
 )
-
 from torchao.quantization.pt2e.quantizer.quantizer import Q_ANNOTATION_KEY
 
 
@@ -648,6 +647,20 @@ def replacement_op(self):
         raise AssertionError()
 
 
+class LeakyReluPattern(SingleInputBasicPattern):
+    """Quantizer for the `aten.leaky_relu.default` operator."""
+
+    def partition_types(self):
+        return [torch.ops.aten.leaky_relu.default]
+
+
+class LeakyReluInPlacePattern(SingleInputBasicPattern):
+    """Quantizer for the `aten.leaky_relu.default` operator, with the parameter `inplace=True`."""
+
+    def partition_types(self):
+        return [torch.ops.aten.leaky_relu_.default]
+
+
 class LinearPattern(QuantizationPattern):
     def __init__(self, neutron_quantizer, is_qat: bool = False):
         super().__init__(is_qat=is_qat)

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

@@ -0,0 +1,123 @@
+# 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)
+
+
+ExecutorchDelegateCall = torch.ops.higher_order.executorch_call_delegate
+LeakyRelu2D = exir_ops.edge.aten.leaky_relu.default
+
+
+def _assert_successful_delegation(model, input_shape, mocker, atol=0):
+    converter_spy = mocker.spy(EdgeProgramToIRConverter, "convert_program")
+    delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
+
+    # Make sure the `leaky_relu` was delegated.
+    assert graph_contains_any_of_ops(delegated_ep.graph, [ExecutorchDelegateCall])
+    assert not graph_contains_any_of_ops(delegated_ep.graph, [LeakyRelu2D])
+
+    # 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 `leaky_relu`.
+    assert graph_contains_any_of_ops(intermediate_ep.graph, [LeakyRelu2D])
+
+    convert_run_compare(
+        intermediate_ep, tfl_model=neutron_ir_model, input_data=input_data, atol=atol
+    )
+
+
+class LeakyReluModule(torch.nn.Module):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self.leaky_relu = torch.nn.LeakyReLU(*args, **kwargs)
+
+    def forward(self, x):
+        return self.leaky_relu(x)
+
+
+@pytest.mark.parametrize(
+    "alpha",
+    [
+        0.01,  # Default value.
+        0.1,
+        3.14159,
+        0.0,
+        1.0,
+    ],
+    ids=lambda alpha: f"alpha = {alpha}",
+)
+def test_convert_leaky_relu__alpha(mocker, alpha):
+    _assert_successful_delegation(
+        LeakyReluModule(negative_slope=alpha),
+        (23,),
+        mocker,
+        atol=1,  # Common quantization rounding error.
+    )
+
+
+def test_convert_leaky_relu__default_alpha(mocker):
+    _assert_successful_delegation(
+        LeakyReluModule(),  # Leave the default alpha.
+        (23,),
+        mocker,
+    )
+
+
+@pytest.mark.parametrize(
+    "inplace",
+    [False, True],
+    ids=lambda inplace: f"inplace = {inplace}",
+)
+def test_convert_leaky_relu__inplace(mocker, inplace):
+    _assert_successful_delegation(
+        LeakyReluModule(inplace=inplace),
+        (23,),
+        mocker,
+    )
+
+
+@pytest.mark.parametrize(
+    "input_shape",
+    [
+        (5,),
+        (4, 5),
+        (3, 4, 5),
+        (2, 3, 4, 5),
+        (1, 2, 3, 4, 5),
+    ],
+    ids=lambda input_shape: f"{len(input_shape)}D",
+)
+def test_convert_leaky_relu__ranks(mocker, input_shape: tuple[int, ...]):
+    _assert_successful_delegation(
+        LeakyReluModule(),
+        input_shape,
+        mocker,
+        atol=1,  # Common quantization rounding error.
+    )

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

@@ -10,6 +10,7 @@ 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)"
 aten.hardtanh.default,int8,static int8,"supported ranges: <0,6>, <-1, 1>, <0,1>, <0,inf>"
+aten.leaky_relu.default,int8,static int8,
 aten.max_pool2d.default,int8,static int8,"dilation=1, ceil_mode=False"
 aten.max_pool2d_with_indices.default,int8,static int8,"dilation=1, ceil_mode=False"
 aten.mean.dim,int8,static int8,"4D tensor only, dims = [-1,-2] or [-2,-1]"