NXP backend: New Neutron-C flow support for ReLU (#19275)

### Summary

Removes unnecessary checks for ReLU conversion when using new Neutron-C
flow.

### Test plan
New unit test cases were added.


cc @digantdesai  @robert-kalmar @JakeStevens

Author: StrycekSimon

backends/nxp/backend/graph_utils.py

@@ -3,7 +3,13 @@
 # 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 torch
+from executorch.backends.nxp.backend.ir.converter.conversion.translator import (
+    torch_type_to_numpy_type,
+)
+from executorch.backends.nxp.backend.ir.converter.node_converter import _is_dequant_node
+from executorch.backends.nxp.backend.ir.converter.quantization_utils import quantize
 from executorch.exir.dialects._ops import ops as exir_ops
 from torch.fx import Node
 
@@ -47,3 +53,77 @@ def get_output_shape(node: Node) -> tuple[torch.Size] | torch.Size | None:
         return tuple([v.shape for v in val])
 
     return None
+
+
+def is_clamp_preserved_under_quantization(
+    node: Node, min_val: int = 0, max_val: int | None = None
+) -> bool:
+    """
+    Checks if Clamp/ReLU/HardTanh is preserved under quantization and did
+    not collapse into either identity or constant.
+
+     Valid quant. bounds -                Quant. bounds -
+    one hinge is preserved             Collapse to identity
+            │   │                           │ │
+            │   ▼/¯¯¯¯¯ ReLU6(x)            │ ▼/¯¯¯¯¯ ReLU6(x)
+            │   /                           │ /
+            │  /                            ▼/
+            ▼ /                             /
+        ¯¯¯¯¯ Hinge                   ¯¯¯¯¯ Hinge
+
+        Args:
+        node: Node to check whether is preserved
+        min_val: Lower bound (hinge) of the operator (eg. 0 for ReLU)
+        max_val: Upper bound of the operator (eg. 6 for ReLU6 or None for ReLU)
+    """
+
+    q_node = node.args[0]
+
+    if not _is_dequant_node(q_node):
+        return False
+
+    if len(q_node.args) == 6:
+        # per-tensor
+        _, scale, zp, quant_min, quant_max, q_type = q_node.args
+    else:
+        # per-channel
+        _, scale, zp, quant_min, quant_max, _, q_type = q_node.args
+
+    quant_min = np.iinfo(q_type).min if quant_min is None else quant_min
+    quant_max = np.iinfo(q_type).max if quant_max is None else quant_max
+
+    q_type = torch_type_to_numpy_type(q_type).type
+    quantized_min_val = quantize(
+        value=min_val,
+        zero_point=zp,
+        scale=scale,
+        quant_min=quant_min,
+        quant_max=quant_max,
+        dtype=q_type,
+    )
+
+    if max_val is not None:
+        quantized_max_val = quantize(
+            value=max_val,
+            zero_point=zp,
+            scale=scale,
+            quant_min=quant_min,
+            quant_max=quant_max,
+            dtype=q_type,
+        )
+        return (
+            # If at least one bound is inside the quantization range
+            # the hinge of the ReLU/HardTanh is preserved and therefore does not
+            # collapse to identity or constant.
+            (
+                np.all(quant_min < quantized_min_val)
+                or np.all(quantized_max_val < quant_max)
+            )
+            # When both operator bounds are outside the quantization range
+            # the operator collapses into constant value (eg. 0 or 6 for ReLU6).
+            and not np.all(quant_max < quantized_min_val)
+            and not np.all(quant_min > quantized_max_val)
+        )
+
+    # Ensure ReLU/HardTanh hinge is preserved.
+    return quant_min < quantized_min_val < quant_max

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

@@ -8,6 +8,9 @@
 import numpy as np
 import torch
 from executorch.backends.nxp.backend.edge_helper import try_get_arg
+from executorch.backends.nxp.backend.graph_utils import (
+    is_clamp_preserved_under_quantization,
+)
 from executorch.backends.nxp.backend.ir.converter.conversion.translator import (
     torch_type_to_numpy_type,
 )
@@ -20,6 +23,7 @@
 )
 from executorch.backends.nxp.backend.ir.converter.quantization_utils import (
     propagate_quantization,
+    quantize,
 )
 from executorch.backends.nxp.backend.ir.lib.tflite.BuiltinOperator import (
     BuiltinOperator,
@@ -117,17 +121,20 @@ def _is_supported_on_target(
             output_indices=[0],
         )
 
-        # We either convert to ReLU -> SingleInputQuantization pattern
-        # or we convert to Min/Max, which requires same quantization on
-        # both input and output.
-        return (relu_compatible | io_quant_consistent) and quant_supported
+        if relu_compatible and activation_supported_on_target(
+            node,
+        ):
+            return True
+
+        # We convert to Min/Max, which requires same quantization for both input and output.
+        return io_quant_consistent and quant_supported
 
     @classmethod
     def supports_partitioning_result(
         cls,
         node: Node,
         partition_list: list[Partition],
-        _: CustomDelegationOptions,
+        custom_delegation_options: CustomDelegationOptions,
         neutron_target_spec: NeutronTargetSpec,
         parameters_mapping: dict[str, Parameter],
     ) -> bool:
@@ -136,30 +143,19 @@ def supports_partitioning_result(
         # Neutron cannot delegate a partition where ReLU or ReLU6 is the only operator
         # and at the same time the node does not satisfy delegation requirements.
         # In contrast, ReLUN1To1 and ReLU0To1 are supported and delegated successfuly.
-        if bounds in [
-            cls.RELU_COMPATIBLE_BOUNDS["Relu"],
-            cls.RELU_COMPATIBLE_BOUNDS["Relu6"],
-        ]:
+        if bounds in cls.RELU_COMPATIBLE_BOUNDS.values():
             is_alone_in_partition = cls.is_node_alone_in_partition(
                 node, partition_list, filter_fn=is_not_qdq_node
             )
             if is_alone_in_partition:
-                return activation_supported_on_target(node, neutron_target_spec)
+                return is_clamp_preserved_under_quantization(
+                    node,
+                    min_val=bounds[0],
+                    max_val=bounds[1],
+                )
 
         return True
 
-    @staticmethod
-    def _quantize_value(
-        value: int,
-        zp: int,
-        scale: float,
-        quant_min: int,
-        quant_max: int,
-        dtype: type = np.int8,
-    ) -> np.integer:
-        rescaled_value = round(value / scale) + zp
-        return dtype(np.clip(rescaled_value, quant_min, quant_max))
-
     def convert(self, node: Node):
         """Convert the `aten.clamp.default` operator to either
         Neutron IR `Relu*` operator or combination of `Min` and `Max`.
@@ -202,9 +198,9 @@ def convert(self, node: Node):
         min_value, max_value = bounds
 
         if min_value is not None:
-            min_value = self._quantize_value(
+            min_value = quantize(
                 value=min_value,
-                zp=zp,
+                zero_point=zp,
                 scale=scale,
                 quant_min=quant_min,
                 quant_max=quant_max,
@@ -216,9 +212,9 @@ def convert(self, node: Node):
             propagate_quantization(x, min_tensor)
 
         if max_value is not None:
-            max_value = self._quantize_value(
+            max_value = quantize(
                 value=max_value,
-                zp=zp,
+                zero_point=zp,
                 scale=scale,
                 quant_min=quant_min,
                 quant_max=quant_max,

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

@@ -94,7 +94,7 @@ def supports_partitioning_result(
                 node, partition_list, filter_fn=is_not_qdq_node
             )
             if is_alone_in_partition:
-                return activation_supported_on_target(node, neutron_target_spec)
+                return activation_supported_on_target(node)
 
         return True
 

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

@@ -3,6 +3,10 @@
 # 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.graph_utils import (
+    is_clamp_preserved_under_quantization,
+)
 from executorch.backends.nxp.backend.ir.converter.node_converter import (
     CustomDelegationOptions,
     is_not_qdq_node,
@@ -30,6 +34,15 @@ def _is_supported_in_IR(
     ) -> bool:
         return True
 
+    @staticmethod
+    def _is_supported_on_target(
+        node: Node,
+        neutron_target_spec: NeutronTargetSpec,
+        parameters_mapping: dict[str, Parameter],
+        custom_delegation_options: CustomDelegationOptions,
+    ) -> bool:
+        return activation_supported_on_target(node)
+
     @classmethod
     def supports_partitioning_result(
         cls,
@@ -43,7 +56,7 @@ def supports_partitioning_result(
             node, partition_list, filter_fn=is_not_qdq_node
         )
         if is_alone_in_partition:
-            return activation_supported_on_target(node, neutron_target_spec)
+            return is_clamp_preserved_under_quantization(node)
 
         return True
 

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

@@ -135,8 +135,19 @@ def set_quantization_parameters_to_tensor(
 def quantize_int8(
     data: np.ndarray, scale: List[float], zero_point: List[int]
 ) -> np.ndarray:
-    new_data = np.add(np.round(np.divide(data, scale)), zero_point)
-    return np.clip(new_data, -128, 127).astype(np.int8)
+    return quantize(data, zero_point=zero_point, scale=scale)
+
+
+def quantize(
+    value: np.ndarray | int,
+    zero_point: List[int] | int,
+    scale: List[float] | float,
+    quant_min: int = -128,
+    quant_max: int = 127,
+    dtype: type = np.int8,
+) -> np.ndarray | np.integer:
+    rescaled_value = np.add(np.round(np.divide(value, scale)), zero_point)
+    return dtype(np.clip(rescaled_value, quant_min, quant_max))
 
 
 def dequantize(

backends/nxp/backend/neutron_operator_support.py

@@ -3,11 +3,7 @@
 # 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.data_format import NXP_NODE_FORMAT
-from executorch.backends.nxp.backend.edge_helper import input_tensor
-from executorch.backends.nxp.backend.ir.converter.conversion.translator import (
-    dims_to_channels_last,
-)
+import torch
 from executorch.backends.nxp.backend.neutron_target_spec import NeutronTargetSpec
 from torch.fx import Node
 
@@ -42,20 +38,20 @@ def transposition_is_supported_on_neutron(
 
 
 def activation_supported_on_target(
-    node: Node, neutron_target_spec: NeutronTargetSpec
+    node: Node,
 ) -> bool:
     """This function determines if the current NeutronSoftware properly supports an activation operator represented by the given node.
 
     :param node: The node representing the activation operator.
-    :param neutron_target_spec: Object for querying the target platform to retrieve its properties.
     """
-    input_shape = list(input_tensor(node, 0).shape)
-    if node.args[0].meta[NXP_NODE_FORMAT].is_channels_first():
-        input_shape = dims_to_channels_last(input_shape)
-
-    c = input_shape[-1]
-    num_macs = neutron_target_spec.get_num_macs()
-
-    # activations in Neutron are delegable only
-    # if `num_channels` % `num_macs` == 0
-    return c % num_macs == 0
+    # Prevent circular import
+    from executorch.backends.nxp.backend.ir.converter.node_converter import (
+        NodeConverter,
+    )
+
+    return NodeConverter.uses_quantization_type_for_io(
+        node,
+        supported_types=[torch.int8, torch.uint8],
+        input_indices=[0],
+        output_indices=[0],
+    )

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

@@ -8,13 +8,12 @@
 # noinspection PyUnusedImports
 import pytest
 import torch
-
 from executorch.backends.nxp.tests.graph_verifier import DetailedGraphVerifier
 from executorch.backends.nxp.tests.nsys_testing import (
     lower_run_compare,
     RandomDatasetCreator,
 )
-from executorch.backends.nxp.tests.ops_aliases import Abs, Convolution, Relu
+from executorch.backends.nxp.tests.ops_aliases import Abs
 from executorch.backends.nxp.tests.use_qat import *  # noqa F403
 
 
@@ -99,23 +98,3 @@ def test__basic_nsys_inference__big(self, mocker):
             graph_verifier,
             dataset_creator,
         )
-
-    def test_basic_nsys_inference__with_conv(self, mocker):
-        input_shape = (2, 3, 6, 7)
-        in_channels = input_shape[1]
-        model = ConvBlocksWithAbsModule(conv_in_channels=in_channels)
-
-        # one `relu` ends up in the same delegated partition as `abs`
-        graph_verifier = DetailedGraphVerifier(
-            mocker,
-            expected_delegated_ops={Abs: 1, Relu: 1},
-            expected_non_delegated_ops={Relu: 1, Convolution: 2},
-        )
-
-        dataset_creator = self._get_dataset_creator()
-        lower_run_compare(
-            model,
-            input_shape,
-            graph_verifier,
-            dataset_creator,
-        )

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

@@ -17,7 +17,7 @@
     ToChannelFirstPreprocess,
     ToChannelLastPreprocess,
 )
-from executorch.backends.nxp.tests.models import Conv2dWithActivation, HardTanhModule
+from executorch.backends.nxp.tests.models import Conv2dWithActivation
 from executorch.exir.dialects._ops import ops as exir_ops
 from torch.export import ExportedProgram
 from executorch.backends.nxp.tests.use_qat import *  # noqa F403
@@ -117,34 +117,3 @@ def test_custom_hardtanh_quant(
         input_data=input_data,
         atol=2.0,
     )
-
-
-@pytest.mark.parametrize(
-    "input_shape, activation_range",
-    [
-        pytest.param(
-            (3, 7, 15, 7),
-            (0, float("inf")),
-            id="activation range: Relu, num_channels not divisible by NUM_MACS, alone in partition",
-        ),
-        pytest.param(
-            (3, 7, 15, 7),
-            (0, 6),
-            id="activation range: Relu6, num_channels not divisible by NUM_MACS, alone in partition",
-        ),
-    ],
-)
-def test_hardtanh__unsupported(
-    input_shape: tuple[int],
-    activation_range: tuple[float, float],
-    use_qat: bool,
-):
-    min_val, max_val = activation_range
-    model = HardTanhModule(min_val, max_val)
-    delegated_ep = to_quantized_edge_program(
-        model, input_shape, use_qat=use_qat
-    ).exported_program()
-
-    # Make sure the `hardtanh` was NOT delegated.
-    assert not graph_contains_any_of_ops(delegated_ep.graph, [ExecutorchDelegateCall])
-    assert graph_contains_any_of_ops(delegated_ep.graph, [HardTanh, HardTanh_])