UT for TestAdaptivePool2dConvertGlobalPass (#37764)

* adaptive_pool2d

* timeout

* merge develop

* rename ut

* new test

* remove old file

python/paddle/fluid/tests/unittests/ir/inference/CMakeLists.txt

@@ -79,6 +79,7 @@ if (WITH_MKLDNN AND TENSORRT_FOUND AND WITH_GPU)
   set_tests_properties(test_emb_eltwise_layernorm_fuse_pass PROPERTIES TIMEOUT 120)
   set_tests_properties(test_fc_fuse_pass PROPERTIES TIMEOUT 240)
   set_tests_properties(test_simplify_with_basic_ops_pass_autoscan PROPERTIES TIMEOUT 60)
+  set_tests_properties(test_adaptive_pool2d_convert_global_pass_autoscan PROPERTIES TIMEOUT 60)
 endif()
 
 if (WITH_MKLDNN)

python/paddle/fluid/tests/unittests/ir/inference/test_adaptive_pool2d_convert_global_pass_autoscan.py

+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from auto_scan_test import PassAutoScanTest, IgnoreReasons
+from program_config import TensorConfig, ProgramConfig, OpConfig
+import numpy as np
+import paddle.inference as paddle_infer
+from functools import partial
+from typing import Optional, List, Callable, Dict, Any, Set
+import unittest
+
+import hypothesis
+from hypothesis import given, settings, seed, example, assume
+import hypothesis.strategies as st
+
+
+class TestAdaptivePool2dConvertGlobalPass(PassAutoScanTest):
+    def is_program_valid(self, program_config: ProgramConfig) -> bool:
+        return True
+
+    def sample_program_config(self, draw):
+        x_shape = draw(
+            st.lists(
+                st.integers(
+                    min_value=1, max_value=4), min_size=4, max_size=4))
+        pooling_type = draw(st.sampled_from(["max", "avg"]))
+
+        data_format = "NCHW"  #trt support this format only
+        strides = draw(
+            st.lists(
+                st.integers(
+                    min_value=1, max_value=4), min_size=2, max_size=2))
+
+        paddings = [0, 0]  # only 0 0 is right
+        ceil_mode = draw(st.booleans())
+        exclusive = draw(st.booleans())
+        global_pooling = False  #only false is right
+        padding_algorithm = draw(st.sampled_from(["EXPLICIT", "SAME", "VAILD"]))
+
+        pool_op = OpConfig(
+            "pool2d",
+            inputs={"X": ["input_data"]},
+            outputs={"Out": ["pool_output"]},
+            ksize=[1, 1],
+            adaptive=True,
+            pooling_type=pooling_type,
+            data_format=data_format,
+            strides=strides,
+            paddings=paddings,
+            ceil_mode=ceil_mode,
+            global_pooling=global_pooling,
+            padding_algorithm=padding_algorithm,
+            exclusive=exclusive)
+        ops = [pool_op]
+
+        program_config = ProgramConfig(
+            ops=ops,
+            weights={},
+            inputs={"input_data": TensorConfig(shape=x_shape), },
+            outputs=["pool_output"])
+
+        return program_config
+
+    def sample_predictor_configs(self, program_config):
+        config = self.create_trt_inference_config()
+        config.enable_tensorrt_engine(
+            max_batch_size=4,
+            workspace_size=102400,
+            min_subgraph_size=0,
+            precision_mode=paddle_infer.PrecisionType.Float32,
+            use_static=False,
+            use_calib_mode=False)
+        yield config, ['pool2d'], (1e-5, 1e-5)
+
+    def add_ignore_pass_case(self):
+        # Here we put some skip rules to avoid known bugs
+        def teller1(program_config, predictor_config):
+            if program_config.ops[0].attrs["pooling_type"] == "max":
+                x_shape = list(program_config.inputs["input_data"].shape)
+                if x_shape[-1] != 1 or x_shape[-2] != 1:
+                    return True
+            return False
+
+        def teller2(program_config, predictor_config):
+            if program_config.ops[0].attrs["padding_algorithm"] == "SAME":
+                return True
+            return False
+
+        self.add_ignore_check_case(
+            teller1,
+            IgnoreReasons.PASS_ACCURACY_ERROR,
+            "max pooling has diff if H or W is not equals to 1", )
+        self.add_ignore_check_case(
+            teller2,
+            IgnoreReasons.PASS_ACCURACY_ERROR,
+            "output has wrong result if padding_algorithm equals to SAME", )
+
+    def test(self):
+        self.run_and_statis(
+            quant=False,
+            max_examples=100,
+            passes=["adaptive_pool2d_convert_global_pass"],
+            min_success_num=40)
+
+
+if __name__ == "__main__":
+    unittest.main()