NXP backend: Add minimum support using new neutron flow (pytorch#20908)

roman-janik-nxp · web-flow · commit 5c9cd9161d74 · 2026-07-17T01:10:16.000+02:00
### Summary Enables support for `minimum` by the Neutron backend using the new Neutron MLIR flow, add tests verifying correct support. Only last commit applies. ### Test plan Unit tests provided. cc @robert-kalmar
diff --git a/backends/nxp/backend/edge_program_converter.py b/backends/nxp/backend/edge_program_converter.py
@@ -48,6 +48,7 @@
     exir_ops.edge.aten.max_pool2d_with_indices.default: MaxPool2DWithIndicesConverter,  # noqa F405
     exir_ops.edge.aten.maximum.default: MaximumConverter,  # noqa F405
     exir_ops.edge.aten.mean.dim: MeanDimConverter,  # noqa F405
+    exir_ops.edge.aten.minimum.default: MinimumConverter,  # noqa F405
     exir_ops.edge.aten.mm.default: MMConverter,  # noqa F405
     exir_ops.edge.aten.mul.Tensor: MulTensorConverter,  # noqa F405
     exir_ops.edge.aten.neg.default: NegConverter,  # noqa F405
diff --git a/backends/nxp/backend/ir/converter/node_converters/ops_converters/__init__.py b/backends/nxp/backend/ir/converter/node_converters/ops_converters/__init__.py
@@ -61,6 +61,9 @@
 from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.mean_dim_converter import (
     MeanDimConverter,
 )
+from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.minimum_converter import (
+    MinimumConverter,
+)
 from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.mm_converter import (
     MMConverter,
 )
@@ -114,6 +117,7 @@
     ViewCopyConverter,
 )
 
+
 __all__ = [
     "AbsConverter",
     "AdaptiveAvgPool2dConverter",
@@ -136,6 +140,7 @@
     "MaxPool2DWithIndicesConverter",
     "MaximumConverter",
     "MeanDimConverter",
+    "MinimumConverter",
     "MMConverter",
     "MulTensorConverter",
     "NegConverter",
diff --git a/backends/nxp/backend/ir/converter/node_converters/ops_converters/minimum_converter.py b/backends/nxp/backend/ir/converter/node_converters/ops_converters/minimum_converter.py
@@ -0,0 +1,68 @@
+# 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 torch
+
+from executorch.backends.nxp.backend.ir.converter.conversion.common import OpsList
+from executorch.backends.nxp.backend.ir.converter.node_converter import (
+    CustomDelegationOptions,
+    NodeConverter,
+)
+from executorch.backends.nxp.backend.ir.tflite_generator.builtin_options import (
+    minimum_options,
+)
+from executorch.backends.nxp.backend.neutron_target_spec import NeutronTargetSpec
+from torch.fx import Node
+from torch.nn import Parameter
+
+
+class MinimumConverter(NodeConverter):
+    @staticmethod
+    def _is_supported_on_target(
+        node: Node,
+        neutron_target_spec: NeutronTargetSpec,
+        parameters_mapping: dict[str, Parameter],
+        custom_delegation_options: CustomDelegationOptions,
+    ) -> bool:
+        if not NodeConverter.inputs_satisfy_broadcast_condition(node):
+            return False
+
+        supported_types = [torch.int8, torch.uint8]
+        if not NodeConverter.uses_quantization_type_for_io(
+            node, supported_types, [0, 1], [0]
+        ):
+            return False
+
+        return True
+
+    @staticmethod
+    def _is_supported_in_IR(
+        node: Node,
+        parameters_mapping: dict[str, Parameter],
+        custom_delegation_options: CustomDelegationOptions,
+    ) -> bool:
+        if len(node.args) != 2:
+            return False
+
+        if not NodeConverter._all_io_shares_quantization_parameters(node):
+            # The IR requires all inputs to have the same quantization parameters as the output.
+            # The quantizer should quantize the operator so that this case does not happen.
+            return False
+
+        return True
+
+    def convert(self, node: Node):
+        """Convert 'minimum' operator to NeutronIR 'Minimum'.
+        The ExecuTorch schema is:
+            minimum(Tensor input, Tensor other, *, Tensor out=None)
+        """
+        self.assert_convertible(node)
+        t_op = self._create_tflite_op_with_io_tensors(node)
+        t_op.builtin_options = minimum_options.Minimum()
+
+        ops = OpsList(middle_op=t_op)
+        # Create additional ops in case of shape broadcasting
+        ops.add_pre(self.builder.ensure_correct_broadcasting(t_op, t_op.tmp_outputs[0]))
+        self.builder.append_operators(ops.flatten())
diff --git a/backends/nxp/neutron_partitioner.py b/backends/nxp/neutron_partitioner.py
@@ -221,6 +221,7 @@ def tag_qdq_clusters(self, nodes: list[torch.fx.Node]):
     exir_ops.edge.aten.max_pool2d_with_indices.default: MaxPool2DWithIndicesConverter,  # noqa F405
     exir_ops.edge.aten.maximum.default: MaximumConverter,  # noqa F405
     exir_ops.edge.aten.mean.dim: MeanDimConverter,  # noqa F405
+    exir_ops.edge.aten.minimum.default: MinimumConverter,  # noqa F405
     exir_ops.edge.aten.mm.default: MMConverter,  # noqa F405
     exir_ops.edge.aten.mul.Tensor: MulTensorConverter,  # noqa F405
     exir_ops.edge.aten.neg.default: NegConverter,  # noqa F405
diff --git a/backends/nxp/quantizer/neutron_quantizer.py b/backends/nxp/quantizer/neutron_quantizer.py
@@ -39,6 +39,7 @@
     MaxPool1DPattern,
     MaxPool2DPattern,
     MeanDimPattern,
+    MinimumPattern,
     MmPattern,
     MulTensorPattern,
     NegPattern,
@@ -290,6 +291,7 @@ def __init__(self, neutron_target_spec: NeutronTargetSpec, is_qat: bool = False)
                 OpQuantizer(MaxPool1DPattern(is_qat=is_qat), static_qconfig),
                 OpQuantizer(MaxPool2DPattern(is_qat=is_qat), static_qconfig),
                 OpQuantizer(MeanDimPattern(is_qat=is_qat), static_qconfig),
+                OpQuantizer(MinimumPattern(is_qat=is_qat), static_qconfig),
                 OpQuantizer(MmPattern(self, is_qat=is_qat), static_qconfig),
                 OpQuantizer(MulTensorPattern(is_qat=is_qat), static_qconfig),
                 OpQuantizer(NegPattern(is_qat=is_qat), static_qconfig),
diff --git a/backends/nxp/quantizer/patterns.py b/backends/nxp/quantizer/patterns.py
@@ -965,6 +965,17 @@ def partition_types(self):
         return [torch.ops.aten.mean.dim]
 
 
+class MinimumPattern(SharedSpecMultipleInputPattern):
+    """
+    Quantization pattern for Minimum quantization. Accepts 1 or 2 input nodes.
+
+    Basic quantization for all inputs and output.
+    """
+
+    def partition_types(self) -> list[OpOverload]:
+        return [torch.ops.aten.minimum.default]
+
+
 class MmPattern(QuantizationPattern):
     def __init__(self, neutron_quantizer, is_qat: bool = False):
         super().__init__(is_qat=is_qat)
diff --git a/backends/nxp/tests/ir/converter/node_converter/test_minimum_converter.py b/backends/nxp/tests/ir/converter/node_converter/test_minimum_converter.py
@@ -0,0 +1,231 @@
+# 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
+
+# noinspection PyUnusedImports
+import pytest
+import torch
+
+from executorch.backends.nxp.tests.dataset_creator import RandomDatasetCreator
+from executorch.backends.nxp.tests.executorch_pipeline import (
+    ModelInputSpec,
+    to_quantized_edge_program,
+)
+from executorch.backends.nxp.tests.executors import graph_contains_any_of_ops
+from executorch.backends.nxp.tests.graph_verifier import DetailedGraphVerifier
+from executorch.backends.nxp.tests.model_output_comparator import (
+    AllCloseOutputComparator,
+)
+from executorch.backends.nxp.tests.models import MaxPoolMinimumModule, MinimumModule
+from executorch.backends.nxp.tests.nsys_testing import lower_run_compare
+from executorch.backends.nxp.tests.ops_aliases import (
+    ExecutorchDelegateCall,
+    GetItem,
+    MaxPool2DWithIndices,
+    Minimum,
+)
+from executorch.backends.nxp.tests.use_qat import *  # noqa F403
+
+
+@pytest.fixture(autouse=True)
+def reseed_model_per_test_run():
+    torch.manual_seed(23)
+    np.random.seed(23)
+
+
+class TestMinimum:
+    # noinspection PyMethodMayBeStatic
+    def assert_delegated(
+        self,
+        model,
+        input_spec,
+        mocker,
+        request,
+        expected_delegated_ops=None,
+        use_qat=False,
+    ):
+        graph_verifier = DetailedGraphVerifier(
+            mocker,
+            expected_delegated_ops=expected_delegated_ops or {Minimum: 1},
+            expected_non_delegated_ops={},
+        )
+        dataset_creator = RandomDatasetCreator(low=-1.0, high=1.0)
+
+        # Quantize the dataset and allow a single bit error.
+        remove_quant_io_ops = True
+        comparator = AllCloseOutputComparator(atol=1)
+
+        lower_run_compare(
+            model,
+            input_spec,
+            graph_verifier,
+            request,
+            dataset_creator,
+            comparator,
+            remove_quant_io_ops=remove_quant_io_ops,
+            use_qat=use_qat,
+        )
+
+    # noinspection PyMethodMayBeStatic
+    def assert_not_delegated(self, model, input_shape):
+        delegated_ep = to_quantized_edge_program(model, input_shape).exported_program()
+
+        # Make sure the `sum` was NOT delegated.
+        assert not graph_contains_any_of_ops(
+            delegated_ep.graph, [ExecutorchDelegateCall]
+        )
+        assert graph_contains_any_of_ops(delegated_ep.graph, [Minimum])
+
+    @pytest.mark.parametrize(
+        "x_input_shape",
+        [
+            pytest.param((1,), id="1D."),
+            pytest.param((6, 5), id="2D."),
+            pytest.param((6, 82), id="2D alt."),
+            pytest.param((1, 4, 7), id="3D."),
+            pytest.param((1, 68, 7), id="3D alt."),
+            pytest.param((2, 4, 3, 15), id="4D."),
+            pytest.param((1, 4, 9, 11, 4), id="5D."),
+        ],
+    )
+    def test__basic_nsys_inference(self, mocker, request, x_input_shape):
+        input_spec = [ModelInputSpec(x_input_shape), ModelInputSpec(x_input_shape)]
+        model = MinimumModule()
+
+        self.assert_delegated(model, input_spec, mocker, request)
+
+    def test__basic_nsys_inference_qat(self, mocker, request):
+        input_spec = [ModelInputSpec((1, 4, 7)), ModelInputSpec((1, 4, 7))]
+        model = MinimumModule()
+
+        self.assert_delegated(model, input_spec, mocker, request, use_qat=True)
+
+    @pytest.mark.parametrize(
+        "input_spec",
+        [
+            pytest.param(
+                [ModelInputSpec((4, 6)), ModelInputSpec((1, 6))], id="2 inputs 2D."
+            ),
+            pytest.param(
+                [ModelInputSpec((69, 73)), ModelInputSpec((1, 73))],
+                id="2 inputs 2D alt.",
+            ),
+            pytest.param(
+                [ModelInputSpec((5, 3, 4)), ModelInputSpec((1, 3, 1))],
+                id="2 inputs 3D.",
+            ),
+            pytest.param(
+                [ModelInputSpec((4,)), ModelInputSpec((4, 4))],
+                id="2 inputs 1D + 2D.",
+                marks=pytest.mark.xfail(
+                    reason="AIR-14864: conversion fails", strict=True
+                ),
+            ),
+            pytest.param(
+                [ModelInputSpec((1, 4, 8, 8)), ModelInputSpec((8, 8))],
+                id="2 inputs 4D + 2D.",
+            ),
+            pytest.param(
+                [ModelInputSpec((10,)), ModelInputSpec((1, 1))],
+                id="2 inputs 1D + 2D, num_elems of input == num_elems of output",
+            ),
+        ],
+    )
+    def test__broadcast(self, mocker, request, input_spec):
+        model = MinimumModule()
+
+        self.assert_delegated(model, input_spec, mocker, request)
+
+    @pytest.mark.parametrize(
+        "input_spec",
+        [
+            pytest.param(
+                [ModelInputSpec((4, 1)), ModelInputSpec((1, 6))], id="2 inputs 2D."
+            ),
+            pytest.param(
+                [ModelInputSpec((1, 3, 4)), ModelInputSpec((5, 3, 1))],
+                id="2 inputs 3D.",
+            ),
+            pytest.param(
+                [ModelInputSpec((6, 4)), ModelInputSpec((6, 6, 1))],
+                id="2 inputs 2D + 3D.",
+            ),
+        ],
+    )
+    def test__broadcast_unsupported(self, input_spec):
+        # Unsupported broadcasts: an input dimension differs from the output dimension
+        # and is not equal to 1 or not omitted.
+        model = MinimumModule()
+
+        self.assert_not_delegated(model, input_spec)
+
+    @pytest.mark.parametrize(
+        "input_spec",
+        [
+            pytest.param(
+                ModelInputSpec((1, 4, 5, 5)),
+                id="4D, product of dims is not a multiple of 8.",
+            ),
+        ],
+    )
+    def test__channels_first_input(self, mocker, request, input_spec):
+        model = MaxPoolMinimumModule()
+        expected_delegated_ops = {Minimum: 1, MaxPool2DWithIndices: 1, GetItem: 1}
+
+        self.assert_delegated(
+            model, [input_spec, input_spec], mocker, request, expected_delegated_ops
+        )
+
+    @pytest.mark.parametrize(
+        "input_spec",
+        [
+            pytest.param(
+                [ModelInputSpec((1, 8, 5, 5)), ModelInputSpec((1, 8, 5, 1))],
+                id="2 inputs 4D + 4D.",
+            ),
+            pytest.param(
+                [ModelInputSpec((1, 8, 1, 67)), ModelInputSpec((1, 8, 5, 67))],
+                id="2 inputs 4D + 4D same width.",
+                marks=pytest.mark.xfail(
+                    reason="AIR-14864: conversion fails", strict=True
+                ),
+            ),
+            pytest.param(
+                [ModelInputSpec((1, 8, 5, 5)), ModelInputSpec((1, 1))],
+                id="2 inputs 4D + 2D ones tensor.",
+            ),
+            pytest.param(
+                [ModelInputSpec((1, 8, 8, 8)), ModelInputSpec((8, 8))],
+                id="2 inputs 4D + 2D both dims 8.",
+            ),
+            pytest.param(
+                [ModelInputSpec((1, 8, 5, 5)), ModelInputSpec((1, 5))],
+                id="2 inputs 4D + 2D one dim 5.",
+            ),
+            pytest.param(
+                [ModelInputSpec((1, 8, 12, 10)), ModelInputSpec((8, 1, 10))],
+                id="2 inputs 4D + 3D channels dim 1.",
+            ),
+            pytest.param(
+                [ModelInputSpec((1, 8, 4, 10)), ModelInputSpec((1, 4, 1))],
+                id="2 inputs 4D + 3D channels dim 4.",
+            ),
+            pytest.param(
+                [ModelInputSpec((1, 8, 25, 18)), ModelInputSpec((4, 1, 8, 25, 18))],
+                id="2 inputs 4D + 5D conversion fails.",
+                marks=pytest.mark.xfail(
+                    reason="AIR-14864: conversion fails", strict=True
+                ),
+            ),
+        ],
+    )
+    def test__broadcast__channels_first_input(self, mocker, request, input_spec):
+        model = MaxPoolMinimumModule()
+        expected_delegated_ops = {Minimum: 1, MaxPool2DWithIndices: 1, GetItem: 1}
+
+        self.assert_delegated(
+            model, input_spec, mocker, request, expected_delegated_ops
+        )
diff --git a/backends/nxp/tests/models.py b/backends/nxp/tests/models.py
diff --git a/backends/nxp/tests/ops_aliases.py b/backends/nxp/tests/ops_aliases.py
diff --git a/docs/source/backends/nxp/op-support.csv b/docs/source/backends/nxp/op-support.csv
