NXP backend: Use standard (non-shared) quantization spec for HardTanh (#12893)

### Summary
Replaces shared quantization parameters specs for standard `QuantizationSpec` in HardTanh
operator.

### Test plan
Unit test files update to correspond to this change.

cc @skywall

Co-authored-by: Lukas Sztefek <[email protected]>

Author: StrycekSimon

backends/nxp/quantizer/patterns.py

@@ -279,7 +279,7 @@ def partition_types(self):
         return [torch.ops.aten.flatten.using_ints]
 
 
-class HardTanhPattern(SharedSpecPattern):
+class HardTanhPattern(QuantizationPattern):
     """
     Quantizer for HardTanh operator. Shared quantization spec is selected, as activation functions usually follows
     computation layer.
@@ -288,8 +288,23 @@ class HardTanhPattern(SharedSpecPattern):
     def partition_types(self):
         return [torch.ops.aten.hardtanh.default]
 
+    def get_anchors(
+        self, gm: fx.GraphModule, fused_partition: List[fx.GraphModule]
+    ) -> PartitionAnchors | None:
+        node = fused_partition[0].nodes[-1]
+
+        return PartitionAnchors(
+            inputs=[(node, 0)],
+            weights=[],
+            biases=[],
+            output=[(node,)],
+        )
+
+    def replacement_op(self):
+        raise AssertionError()
+
 
-class HardTanhInPlacePattern(SharedSpecPattern):
+class HardTanhInPlacePattern(QuantizationPattern):
     """
     Quantizer for HardTanh operator with param inplace=True. Shared quantization spec is selected, as activation
     functions usually follows computation layer.
@@ -298,6 +313,21 @@ class HardTanhInPlacePattern(SharedSpecPattern):
     def partition_types(self):
         return [torch.ops.aten.hardtanh_.default]
 
+    def get_anchors(
+        self, gm: fx.GraphModule, fused_partition: List[fx.GraphModule]
+    ) -> PartitionAnchors | None:
+        node = fused_partition[0].nodes[-1]
+
+        return PartitionAnchors(
+            inputs=[(node, 0)],
+            weights=[],
+            biases=[],
+            output=[(node,)],
+        )
+
+    def replacement_op(self):
+        raise AssertionError()
+
 
 class LinearPattern(QuantizationPattern):
     def partition_types(self) -> List[OpOverload]:

backends/nxp/tests/executorch_pipeline.py

@@ -34,6 +34,15 @@ def _quantize_model(model, calibration_inputs: list[tuple[torch.Tensor]]):
     return m
 
 
+def get_random_float_data(input_shapes: tuple[int] | list[tuple[int]]):
+    # TODO: Replace with something more robust.
+    return (
+        (torch.randn(input_shapes),)
+        if type(input_shapes) is tuple
+        else tuple(torch.randn(input_shape) for input_shape in input_shapes)
+    )
+
+
 def to_quantized_edge_program(
     model: torch.nn.Module,
     input_shapes: tuple[int] | list[tuple[int]],
@@ -47,12 +56,7 @@ def to_quantized_edge_program(
             "For multiple inputs, provide" " list[tuple[int]]."
         )
 
-    random_tensors = (
-        (torch.randn(input_shapes),)
-        if type(input_shapes) is tuple
-        else tuple(torch.randn(input_shape) for input_shape in input_shapes)
-    )
-    calibration_inputs = [random_tensors, random_tensors]
+    calibration_inputs = [get_random_float_data(input_shapes) for _ in range(4)]
     example_input = (
         (torch.ones(input_shapes),)
         if type(input_shapes) is tuple

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

@@ -39,7 +39,7 @@ def forward(self, x):
         return self.block(x)
 
 
-class CustomHardTanhBlock(torch.nn.Module):
+class ConvHardTanhBlock(torch.nn.Module):
     def __init__(
         self,
         conv_in_channels: int = 3,
@@ -89,16 +89,18 @@ def test_relu6_quant(mocker, input_shape: tuple[int], inplace: bool):
     )
 
 
-@pytest.mark.parametrize("input_shape", [(1, 3, 128, 128), (1, 3, 256, 256)])
+@pytest.mark.parametrize("input_shape", [(1, 3, 16, 16), (1, 3, 32, 32)])
 @pytest.mark.parametrize(
     "activation_range", list(HardTanhConverter.supported_modes_map.keys())
 )
 @pytest.mark.parametrize("inplace", [True, False])
 def test_custom_hardtanh_quant(
     mocker, input_shape: tuple[int], activation_range: tuple[int, int], inplace: bool
 ):
+    # TODO(13063): This test suffers from non-ideal testing random quantization, because we always use range <0,1>.
+    #  We should update (decrease atol) when the Conv/Linear + Activation fuse at quantization is in place.
     min_val, max_val = activation_range
-    model = CustomHardTanhBlock(
+    model = ConvHardTanhBlock(
         conv_in_channels=input_shape[1],
         min_act_val=min_val,
         max_act_val=max_val,
@@ -122,5 +124,5 @@ def test_custom_hardtanh_quant(
         tflite_input_preprocess=ToNHWCPreprocess(),
         tflite_output_preprocess=ToNCHWPreprocess(),
         input_data=input_data,
-        atol=1.0,
+        atol=2.0,
     )