Add support for conversion and quantization of Adaptive Average Pool operator

Author: roman-janik-nxp

backends/nxp/backend/edge_program_converter.py

@@ -22,6 +22,7 @@
 functions_converters = {
     exir_ops.edge.aten.addmm.default: AddMMConverter,
     exir_ops.edge.aten.avg_pool2d.default: AvgPool2dConverter,
+    exir_ops.edge.aten._adaptive_avg_pool2d.default: AdaptiveAvgPool2dConverter,
     exir_ops.edge.aten.constant_pad_nd.default: ConstantPadNDConverter,
     exir_ops.edge.aten.convolution.default: ConvolutionConverter,
     exir_ops.edge.aten.max_pool2d.default: MaxPool2dConverter,

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

@@ -20,12 +20,14 @@
     AvgPool2dConverter
 from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.add_tensor_converter import \
     AddTensorConverter
+from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.adaptive_avg_pool_2d_converter import \
+    AdaptiveAvgPool2dConverter
 from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.relu_converter import \
     ReLUConverter
 from executorch.backends.nxp.backend.ir.converter.node_converters.ops_converters.mean_dim_converter import \
     MeanDimConverter
 __all__ = [
     "AddMMConverter", "ConvolutionConverter", "MMConverter", "PermuteCopyConverter", "SoftmaxConverter",
     "ViewCopyConverter", "QDQDequantizeConverter", "QDQQuantizeConverter", "ConstantPadNDConverter", "ReLUConverter",
-    "MaxPool2dConverter", "AvgPool2dConverter", "AddTensorConverter", "MeanDimConverter"
+    "MaxPool2dConverter", "AvgPool2dConverter", "AddTensorConverter", "MeanDimConverter", "AdaptiveAvgPool2dConverter"
 ]

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

@@ -0,0 +1,55 @@
+# Copyright (c) 2025 NXP
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from torch import Size
+from torch.fx import Node
+from torch.nn import Parameter
+
+import executorch.backends.nxp.backend.ir.lib.tflite.Padding as tflPadding
+from executorch.backends.nxp.backend.ir.converter.conversion import common
+from executorch.backends.nxp.backend.ir.converter.node_converter import NodeConverter, Target
+from executorch.backends.nxp.backend.ir.tflite_generator import tflite_model
+from executorch.backends.nxp.backend.ir.tflite_generator.builtin_options import average_pool_2d_options
+
+
+class AdaptiveAvgPool2dConverter(NodeConverter):
+    supported_targets = [Target.RT700]
+
+    @staticmethod
+    def _is_supported_in_IR(node: Node, parameters_mapping: dict[str, Parameter]) -> bool:
+        input_size = node.args[0].meta['val'].shape
+        output_size = node.args[1]
+
+        if (input_size[-1] % output_size[-1] != 0) or (input_size[-2] % output_size[-2] != 0):
+            return False
+
+        if not NodeConverter._has_shared_q_params_if_quantized(node):
+            return False
+
+        return True
+
+    # noinspection PyMethodMayBeStatic
+    def _convert_adaptive_avg_pool_2d(self, input_size: Size, output_size: list[int], t_op: tflite_model.Operator):
+        t_op.builtin_options = average_pool_2d_options.AveragePool2D()
+        stride = [input_size[-2] // output_size[-2], input_size[-1] // output_size[-1]]
+        common.assign_2d_strides(t_op.builtin_options, stride)
+        t_op.builtin_options.filter_h = input_size[-2] - (output_size[-2] - 1) * stride[-2]
+        t_op.builtin_options.filter_w = input_size[-1] - (output_size[-1] - 1) * stride[-1]
+        t_op.builtin_options.padding = tflPadding.Padding.VALID
+
+    # AdaptiveAvgPool2d Node format: (Tensor self, SymInt[2] output_size)
+    def convert(self, node: Node):
+        """ Convert '_adaptive_avg_pool2d' operator to TFLite 'AveragePool2D'.
+        """
+        self.assert_convertible(node)
+
+        input_size = node.args[0].meta['val'].shape
+        output_size = node.args[1]
+
+        t_op = self._create_tflite_op_with_io_tensors(node)
+
+        self._convert_adaptive_avg_pool_2d(input_size, output_size, t_op)
+        self.builder.append_operators([t_op])

backends/nxp/neutron_partitioner.py

@@ -191,6 +191,7 @@ def tag_qdq_clusters(self, nodes: List[torch.fx.Node]):
     exir_ops.edge.aten.view_copy.default: ViewCopyConverter,
     exir_ops.edge.aten.add.Tensor: AddTensorConverter,
     exir_ops.edge.aten.mean.dim: MeanDimConverter,
+    exir_ops.edge.aten._adaptive_avg_pool2d.default: AdaptiveAvgPool2dConverter,
 }
 
 

backends/nxp/quantizer/neutron_quantizer.py

@@ -123,6 +123,15 @@ def partition_types(self):
         return [torch.ops.aten.avg_pool2d.default]
 
 
+class AdaptiveAvgPoolPattern(SharedSpecPattern):
+    """
+    Quantizer for AdaptiveAvgPool2D operator.
+    """
+
+    def partition_types(self):
+        return [torch.ops.aten.adaptive_avg_pool2d.default]
+
+
 class PadPattern(SharedSpecPattern):
     """
     Quantizer for Pad operator.
@@ -293,6 +302,7 @@ def __init__(self):
                 CadenceAtenQuantizer(ReluInPlacePattern(), static_qconfig),
                 CadenceAtenQuantizer(AvgPoolPattern(), static_qconfig),
                 CadenceAtenQuantizer(ViewPattern(), static_qconfig),
+                CadenceAtenQuantizer(AdaptiveAvgPoolPattern(), static_qconfig),
                 CadenceAtenQuantizer(MeanDimPattern(), static_qconfig),
                 CadenceAtenQuantizer(FlattenPattern(), static_qconfig),
             ]