NXP backend: Add implementation of Tanh operator converter

Author: MartinPavella

backends/nxp/backend/edge_program_converter.py

@@ -38,6 +38,7 @@
     exir_ops.edge.aten.permute_copy.default: PermuteCopyConverter,  # noqa F405
     exir_ops.edge.aten.relu.default: ReLUConverter,  # noqa F405
     exir_ops.edge.aten._softmax.default: SoftmaxConverter,  # noqa F405
+    exir_ops.edge.aten.tanh.default: TanhConverter,  # noqa F405
     exir_ops.edge.aten.view_copy.default: ViewCopyConverter,  # noqa F405
     exir_ops.edge.aten.sigmoid.default: SigmoidConverter,  # noqa F405
 }

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

@@ -52,6 +52,9 @@
 from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.softmax_converter import (
     SoftmaxConverter,
 )
+from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.tanh_converter import (
+    TanhConverter,
+)
 from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.view_copy_converter import (
     ViewCopyConverter,
 )
@@ -76,4 +79,5 @@
     "AdaptiveAvgPool2dConverter",
     "HardTanhConverter",
     "SigmoidConverter",
+    "TanhConverter",
 ]

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

@@ -0,0 +1,29 @@
+# Copyright 2025 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 NodeConverter
+from executorch.backends.nxp.backend.ir.lib.tflite.BuiltinOperator import (
+    BuiltinOperator,
+)
+from torch.fx import Node
+from torch.nn import Parameter
+
+
+class TanhConverter(NodeConverter):
+
+    @staticmethod
+    def _is_supported_in_IR(
+        node: Node,
+        parameters_mapping: dict[str, Parameter],
+    ) -> bool:
+        return True
+
+    def convert(self, node: Node):
+        self.assert_convertible(node)
+
+        t_op = self._create_tflite_op_with_io_tensors(node)
+        t_op.opcode_index = self.builder.op_code_index_for_op_type(BuiltinOperator.TANH)
+
+        self.builder.append_operators([t_op])

backends/nxp/neutron_partitioner.py

@@ -202,6 +202,7 @@ def tag_qdq_clusters(self, nodes: List[torch.fx.Node]):
     exir_ops.edge.aten.mm.default: MMConverter,  # noqa F405
     exir_ops.edge.aten.relu.default: ReLUConverter,  # noqa F405
     exir_ops.edge.aten._softmax.default: SoftmaxConverter,  # noqa F405
+    exir_ops.edge.aten.tanh.default: TanhConverter,  # noqa F405
     exir_ops.edge.aten.view_copy.default: ViewCopyConverter,  # noqa F405
     exir_ops.edge.aten.sigmoid.default: SigmoidConverter,  # noqa F405
 }

backends/nxp/quantizer/neutron_quantizer.py

@@ -34,6 +34,8 @@
     SharedSpecPattern,
     SigmoidPattern,
     SoftMaxPattern,
+    TanhInPlacePattern,
+    TanhPattern,
     ViewPattern,
 )
 from executorch.backends.nxp.quantizer.utils import (
@@ -221,6 +223,8 @@ def __init__(self):
                 NeutronAtenQuantizer(ReshapePattern(), static_qconfig),
                 NeutronAtenQuantizer(SigmoidPattern(), static_qconfig),
                 NeutronAtenQuantizer(SoftMaxPattern(), static_qconfig),
+                NeutronAtenQuantizer(TanhPattern(), static_qconfig),
+                NeutronAtenQuantizer(TanhInPlacePattern(), static_qconfig),
                 NeutronAtenQuantizer(ViewPattern(), static_qconfig),
             ]
         )

backends/nxp/quantizer/patterns.py

@@ -106,6 +106,35 @@ def get_anchors(
         )
 
 
+def get_anchors_for_fixed_quant_specs(
+    fused_partition: list[fx.GraphModule],
+    scale: float,
+    zero_point: int,
+    quant_min: int = -128,
+    quant_max: int = 127,
+) -> PartitionAnchors:
+    node = fused_partition[0].nodes[-1]
+    assert len(fused_partition[0].input_nodes) == 1
+
+    qspec = FixedQParamsQuantizationSpec(
+        dtype=torch.int8,
+        scale=scale,
+        zero_point=zero_point,
+        quant_min=quant_min,
+        quant_max=quant_max,
+        qscheme=torch.per_tensor_affine,
+    )
+
+    return PartitionAnchors(
+        inputs=[(node, 0)],
+        weights=[],
+        biases=[],
+        output=[
+            (node, qspec),
+        ],
+    )
+
+
 class AbsPattern(SharedSpecPattern):
     """
     Quantizer for Abs operator.
@@ -438,31 +467,6 @@ def partition_types(self):
         return [torch.ops.aten.view.default]
 
 
-def get_anchors_for_softmax_like_operators(
-    fused_partition: List[fx.GraphModule],
-) -> PartitionAnchors:
-    node = fused_partition[0].nodes[-1]
-    assert len(fused_partition[0].input_nodes) == 1
-
-    qspec = FixedQParamsQuantizationSpec(
-        dtype=torch.int8,
-        scale=1.0 / 256.0,
-        zero_point=-128,
-        quant_min=-128,
-        quant_max=127,
-        qscheme=torch.per_tensor_affine,
-    )
-
-    return PartitionAnchors(
-        inputs=[(node, 0)],
-        weights=[],
-        biases=[],
-        output=[
-            (node, qspec),
-        ],
-    )
-
-
 class SoftMaxPattern(QuantizationPattern):
     """
     Quantizer for Softmax operator.
@@ -474,9 +478,47 @@ def partition_types(self) -> List[OpOverload]:
         return [torch.ops.aten.softmax.int]
 
     def get_anchors(
-        self, gm: fx.GraphModule, fused_partition: List[fx.GraphModule]
+        self, gm: fx.GraphModule, fused_partition: list[fx.GraphModule]
     ) -> PartitionAnchors:
-        return get_anchors_for_softmax_like_operators(fused_partition)
+        return get_anchors_for_fixed_quant_specs(
+            fused_partition, scale=1.0 / 256.0, zero_point=-128
+        )
+
+
+class TanhPattern(QuantizationPattern):
+    """
+    Quantizer for Tanh operator.
+
+    The quantization of Tanh output is fixed to scale 1/128, zero point 0, dtype int8.
+    """
+
+    def partition_types(self):
+        return [torch.ops.aten.tanh.default]
+
+    def get_anchors(
+        self, gm: fx.GraphModule, fused_partition: list[fx.GraphModule]
+    ) -> PartitionAnchors:
+        return get_anchors_for_fixed_quant_specs(
+            fused_partition, scale=1.0 / 128.0, zero_point=0
+        )
+
+
+class TanhInPlacePattern(QuantizationPattern):
+    """
+    Quantizer for inplace version of Tanh operator (torch.tanh_).
+
+    The quantization of Tanh output is fixed to scale 1/128, zero point 0, dtype int8.
+    """
+
+    def partition_types(self):
+        return [torch.ops.aten.tanh_.default]
+
+    def get_anchors(
+        self, gm: fx.GraphModule, fused_partition: list[fx.GraphModule]
+    ) -> PartitionAnchors:
+        return get_anchors_for_fixed_quant_specs(
+            fused_partition, scale=1.0 / 128.0, zero_point=0
+        )
 
 
 class SigmoidPattern(QuantizationPattern):
@@ -492,4 +534,6 @@ def partition_types(self) -> List[OpOverload]:
     def get_anchors(
         self, gm: fx.GraphModule, fused_partition: List[fx.GraphModule]
     ) -> PartitionAnchors:
-        return get_anchors_for_softmax_like_operators(fused_partition)
+        return get_anchors_for_fixed_quant_specs(
+            fused_partition, scale=1.0 / 256.0, zero_point=-128
+        )

backends/nxp/run_unittests.sh

@@ -12,3 +12,5 @@ cd $EXECUTORCH_DIR
 
 # '-c /dev/null' is used to ignore root level pytest.ini.
 pytest -c /dev/null backends/nxp/tests/
+
+python -m unittest discover -s backends/nxp/tests/ -v