remove pool2d from fluid

python/paddle/fluid/contrib/slim/tests/test_quantization_pass.py

@@ -79,12 +79,12 @@ def conv_bn_layer(
     hidden = paddle.matmul(hidden, matmul_weight, True, True)
     if quant_skip_pattern:
         with fluid.name_scope(quant_skip_pattern):
-            pool = fluid.layers.pool2d(
-                input=hidden, pool_size=2, pool_type='avg', pool_stride=2
+            pool = paddle.nn.functional.avg_pool2d(
+                x=hidden, kernel_size=2, stride=2
             )
     else:
-        pool = fluid.layers.pool2d(
-            input=hidden, pool_size=2, pool_type='avg', pool_stride=2
+        pool = paddle.nn.functional.avg_pool2d(
+            x=hidden, kernel_size=2, stride=2
         )
     fc = fluid.layers.fc(input=pool, size=10)
     loss = fluid.layers.cross_entropy(input=fc, label=label)
@@ -727,32 +727,32 @@ def conv_bn_layer(
     hidden = paddle.matmul(hidden, data2, True, True)
     if isinstance(quant_skip_pattern, str):
         with fluid.name_scope(quant_skip_pattern):
-            pool1 = fluid.layers.pool2d(
-                input=hidden, pool_size=2, pool_type='avg', pool_stride=2
+            pool1 = paddle.nn.functional.avg_pool2d(
+                x=hidden, kernel_size=2, stride=2
             )
-            pool2 = fluid.layers.pool2d(
-                input=hidden, pool_size=2, pool_type='max', pool_stride=2
+            pool2 = paddle.nn.functional.max_pool2d(
+                x=hidden, kernel_size=2, stride=2
             )
             pool_add = paddle.nn.functional.relu(paddle.add(x=pool1, y=pool2))
     elif isinstance(quant_skip_pattern, list):
         assert (
             len(quant_skip_pattern) > 1
         ), 'test config error: the len of quant_skip_pattern list should be greater than 1.'
         with fluid.name_scope(quant_skip_pattern[0]):
-            pool1 = fluid.layers.pool2d(
-                input=hidden, pool_size=2, pool_type='avg', pool_stride=2
+            pool1 = paddle.nn.functional.avg_pool2d(
+                x=hidden, kernel_size=2, stride=2
             )
-            pool2 = fluid.layers.pool2d(
-                input=hidden, pool_size=2, pool_type='max', pool_stride=2
+            pool2 = paddle.nn.functional.max_pool2d(
+                x=hidden, kernel_size=2, stride=2
             )
         with fluid.name_scope(quant_skip_pattern[1]):
             pool_add = paddle.nn.functional.relu(paddle.add(x=pool1, y=pool2))
     else:
-        pool1 = fluid.layers.pool2d(
-            input=hidden, pool_size=2, pool_type='avg', pool_stride=2
+        pool1 = paddle.nn.functional.avg_pool2d(
+            x=hidden, kernel_size=2, stride=2
         )
-        pool2 = fluid.layers.pool2d(
-            input=hidden, pool_size=2, pool_type='max', pool_stride=2
+        pool2 = paddle.nn.functional.max_pool2d(
+            x=hidden, kernel_size=2, stride=2
         )
         pool_add = paddle.nn.functional.relu(paddle.add(x=pool1, y=pool2))
     fc = fluid.layers.fc(input=pool_add, size=10)

python/paddle/fluid/contrib/tests/test_image_classification_fp16.py

@@ -69,9 +69,7 @@ def layer_warp(block_func, input, ch_in, ch_out, count, stride):
     res1 = layer_warp(basicblock, conv1, 16, 16, n, 1)
     res2 = layer_warp(basicblock, res1, 16, 32, n, 2)
     res3 = layer_warp(basicblock, res2, 32, 64, n, 2)
-    pool = fluid.layers.pool2d(
-        input=res3, pool_size=8, pool_type='avg', pool_stride=1
-    )
+    pool = paddle.nn.functional.avg_pool2d(x=res3, kernel_size=8, stride=1)
     return pool
 
 

python/paddle/fluid/contrib/tests/test_multi_precision_fp16_train.py

@@ -88,9 +88,7 @@ def layer_warp(block_func, input, ch_in, ch_out, count, stride):
         res1 = layer_warp(basicblock, conv1, 16, 16, n, 1)
         res2 = layer_warp(basicblock, res1, 16, 32, n, 2)
         res3 = layer_warp(basicblock, res2, 32, 64, n, 2)
-    pool = fluid.layers.pool2d(
-        input=res3, pool_size=8, pool_type='avg', pool_stride=1
-    )
+    pool = paddle.nn.functional.avg_pool2d(x=res3, kernel_size=8, stride=1)
     return pool
 
 

python/paddle/fluid/layers/nn.py

@@ -68,7 +68,6 @@
     'linear_chain_crf',
     'crf_decoding',
     'conv2d',
-    'pool2d',
     'dropout',
     'split',
     'l2_normalize',
@@ -1437,249 +1436,6 @@ def _get_default_param_initializer():
     return helper.append_activation(pre_act)
 
 
-@templatedoc()
-def pool2d(
-    input,
-    pool_size=-1,
-    pool_type="max",
-    pool_stride=1,
-    pool_padding=0,
-    global_pooling=False,
-    use_cudnn=True,
-    ceil_mode=False,
-    name=None,
-    exclusive=True,
-    data_format="NCHW",
-):
-    """
-
-    ${comment}
-
-    Args:
-        input (Variable): The input tensor of pooling operator which is a 4-D tensor with
-                          shape [N, C, H, W]. The format of input tensor is `"NCHW"` or
-                          `"NHWC"`, where `N` is batch size, `C` is the number of channels,
-                          `H` is the height of the feature, and `W` is the width of the
-                          feature. The data type if float32 or float64.
-        pool_size (int|list|tuple): The pool kernel size. If pool kernel size is a tuple or list,
-            it must contain two integers, (pool_size_Height, pool_size_Width).
-            Otherwise, the pool kernel size will be a square of an int.
-        pool_type: ${pooling_type_comment}
-        pool_stride (int|list|tuple): The pool stride size. If pool stride size is a tuple or list,
-            it must contain two integers, (pool_stride_Height, pool_stride_Width).
-            Otherwise, the pool stride size will be a square of an int.
-        pool_padding (string|int|list|tuple): The pool padding. If `pool_padding` is a string, either 'VALID' or
-            'SAME' which is the padding algorithm. If pool padding size is a tuple or list,
-            it could be in three forms: `[pad_height, pad_width]` or
-            `[pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]`, and when `data_format` is `"NCHW"`,
-            `pool_padding` can be in the form `[[0,0], [0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
-            when `data_format` is `"NHWC"`, `pool_padding` can be in the form
-            `[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]`.
-            Otherwise, the pool padding size will be a square of an int.
-        global_pooling (bool): ${global_pooling_comment}
-        use_cudnn (bool): ${use_cudnn_comment}
-        ceil_mode (bool): ${ceil_mode_comment}
-        name(str, optional): For detailed information, please refer
-                             to :ref:`api_guide_Name`. Usually name is no need to set and
-                             None by default.
-        exclusive (bool): Whether to exclude padding points in average pooling
-                          mode, default is `true`.
-        data_format (string): The data format of the input and output data. An optional string from: `"NCHW"`, `"NHWC"`.
-                The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
-                `[batch_size, input_channels, input_height, input_width]`.
-
-    Returns:
-        Variable: The output tensor of pooling result. The data type is same as input tensor.
-
-    Raises:
-        ValueError: If `pool_type` is not "max" nor "avg".
-        ValueError: If `global_pooling` is False and `pool_size` is -1.
-        TypeError: If `use_cudnn` is not a bool value.
-        ValueError: If `data_format` is not "NCHW" or "NHWC".
-        ValueError: If `pool_padding` is a string, but not "SAME" or "VALID".
-        ValueError: If `pool_padding` is "VALID", but `ceil_mode` is True.
-        ValueError: If `pool_padding` is a list or tuple, but the elements in the batch or channel dimensions are non-zero.
-        ShapeError: If the input is not a 4-D or 5-D Tensor.
-        ShapeError: If the dimension of input minus the size of `pool_stride` is not 2.
-        ShapeError: If the size of `pool_size` and `pool_stride` is not equal.
-        ShapeError: If the output's shape calculated is not greater than 0.
-
-
-    Examples:
-
-        .. code-block:: python
-
-          import paddle.fluid as fluid
-          import paddle
-
-          paddle.enable_static()
-
-          data = fluid.data(name='data', shape=[None, 3, 32, 32], dtype='float32')
-
-          # max pool2d
-          pool2d = fluid.layers.pool2d(
-            input = data,
-            pool_size = 2,
-            pool_type = "max",
-            pool_stride = 1,
-            global_pooling=False)
-
-          # average pool2d
-          pool2d = fluid.layers.pool2d(
-            input = data,
-            pool_size = 2,
-            pool_type = "avg",
-            pool_stride = 1,
-            global_pooling=False)
-
-          # global average pool2d
-          pool2d = fluid.layers.pool2d(
-            input = data,
-            pool_size = 2,
-            pool_type = "avg",
-            pool_stride = 1,
-            global_pooling=True)
-
-          # Attr(pool_padding) is a list with 4 elements, Attr(data_format) is "NCHW".
-          out_1 = fluid.layers.pool2d(
-            input = data,
-            pool_size = 3,
-            pool_type = "avg",
-            pool_stride = 1,
-            pool_padding = [1, 2, 1, 0],
-            data_format = "NCHW")
-
-          # Attr(pool_padding) is a string, Attr(data_format) is "NCHW".
-          out_2 = fluid.layers.pool2d(
-            input = data,
-            pool_size = 3,
-            pool_type = "avg",
-            pool_stride = 1,
-            pool_padding = "VALID",
-            data_format = "NCHW")
-    """
-    if pool_type not in ["max", "avg"]:
-        raise ValueError(
-            "Unknown Attr(pool_type): '%s'. It can only be 'max' or 'avg'.",
-            str(pool_type),
-        )
-
-    if global_pooling is False and pool_size == -1:
-        raise ValueError(
-            "When Attr(global_pooling) is False, Attr(pool_size) must be passed "
-            "and be a valid value. Received pool_size: %s." % str(pool_size)
-        )
-
-    if not isinstance(use_cudnn, bool):
-        raise TypeError(
-            "Attr(use_cudnn) should be True or False. Received "
-            "Attr(use_cudnn): %s." % str(use_cudnn)
-        )
-
-    if data_format not in ["NCHW", "NHWC"]:
-        raise ValueError(
-            "Attr(data_format) should be 'NCHW' or 'NHWC'. Received "
-            "Attr(data_format): %s." % str(data_format)
-        )
-
-    pool_size = utils.convert_to_list(pool_size, 2, 'pool_size')
-    pool_stride = utils.convert_to_list(pool_stride, 2, 'pool_stride')
-
-    def update_padding(padding, data_format):
-        def is_list_or_tuple(ele):
-            if isinstance(ele, list) or isinstance(ele, tuple):
-                return True
-            return False
-
-        if is_list_or_tuple(padding) and len(padding) == 4:
-            if is_list_or_tuple(padding[0]) and (data_format == "NCHW"):
-                if not (padding[0] == [0, 0] and padding[1] == [0, 0]):
-                    raise ValueError(
-                        "Non-zero pool_padding(%s) in the batch or channel dimensions "
-                        "is not supported." % str(padding)
-                    )
-                padding = padding[2:4]
-                padding = [ele for a_list in padding for ele in a_list]
-            elif is_list_or_tuple(padding[0]) and (data_format == "NHWC"):
-                if not (padding[0] == [0, 0] and padding[3] == [0, 0]):
-                    raise ValueError(
-                        "Non-zero pool_padding(%s) in the batch or channel dimensions "
-                        "is not supported." % str(padding)
-                    )
-                padding = padding[1:3]
-                padding = [ele for a_list in padding for ele in a_list]
-            padding = utils.convert_to_list(padding, 4, 'padding')
-
-            if utils._is_symmetric_padding(padding, 2):
-                padding = [padding[0], padding[2]]
-        else:
-            padding = utils.convert_to_list(padding, 2, 'padding')
-
-        return padding
-
-    padding_algorithm = "EXPLICIT"
-    if isinstance(pool_padding, str):
-        pool_padding = pool_padding.upper()
-        if pool_padding not in ["SAME", "VALID"]:
-            raise ValueError(
-                "Unknown Attr(pool_padding): '%s'. It can only be 'SAME' or 'VALID'."
-                % str(pool_padding)
-            )
-        if pool_padding == "VALID":
-            padding_algorithm = "VALID"
-            pool_padding = [0, 0]
-            if ceil_mode is not False:
-                raise ValueError(
-                    "When Attr(pool_padding) is \"VALID\", Attr(ceil_mode) must be False. "
-                    "Received ceil_mode: True."
-                )
-        elif pool_padding == "SAME":
-            padding_algorithm = "SAME"
-            pool_padding = [0, 0]
-
-    pool_padding = update_padding(pool_padding, data_format)
-    if in_dygraph_mode():
-        input = input._use_gpudnn(use_cudnn)
-        return _C_ops.pool2d(
-            input,
-            pool_size,
-            pool_stride,
-            pool_padding,
-            ceil_mode,
-            exclusive,
-            data_format,
-            pool_type,
-            global_pooling,
-            False,
-            padding_algorithm,
-        )
-    op_type = 'pool2d'
-    helper = LayerHelper(op_type, **locals())
-    dtype = helper.input_dtype()
-    pool_out = helper.create_variable_for_type_inference(dtype)
-
-    helper.append_op(
-        type=op_type,
-        inputs={"X": input},
-        outputs={"Out": pool_out},
-        attrs={
-            "pooling_type": pool_type,
-            "ksize": pool_size,
-            "global_pooling": global_pooling,
-            "strides": pool_stride,
-            "paddings": pool_padding,
-            "padding_algorithm": padding_algorithm,
-            "use_cudnn": use_cudnn,
-            "ceil_mode": ceil_mode,
-            "use_mkldnn": False,
-            "exclusive": exclusive,
-            "data_format": data_format,
-        },
-    )
-
-    return pool_out
-
-
 @templatedoc()
 def layer_norm(
     input,

python/paddle/fluid/nets.py

@@ -132,16 +132,20 @@ def simple_img_conv_pool(
         act=act,
         use_cudnn=use_cudnn,
     )
-
-    pool_out = layers.pool2d(
-        input=conv_out,
-        pool_size=pool_size,
-        pool_type=pool_type,
-        pool_stride=pool_stride,
-        pool_padding=pool_padding,
-        global_pooling=global_pooling,
-        use_cudnn=use_cudnn,
-    )
+    if pool_type == 'max':
+        pool_out = paddle.nn.functional.max_pool2d(
+            x=conv_out,
+            kernel_size=pool_size,
+            stride=pool_stride,
+            padding=pool_padding,
+        )
+    else:
+        pool_out = paddle.nn.functional.avg_pool2d(
+            x=conv_out,
+            kernel_size=pool_size,
+            stride=pool_stride,
+            padding=pool_padding,
+        )
     return pool_out
 
 
@@ -258,13 +262,18 @@ def __extend_list__(obj):
             if abs(drop_rate) > 1e-5:
                 tmp = layers.dropout(x=tmp, dropout_prob=drop_rate)
 
-    pool_out = layers.pool2d(
-        input=tmp,
-        pool_size=pool_size,
-        pool_type=pool_type,
-        pool_stride=pool_stride,
-        use_cudnn=use_cudnn,
-    )
+    if pool_type == 'max':
+        pool_out = paddle.nn.functional.max_pool2d(
+            x=tmp,
+            kernel_size=pool_size,
+            stride=pool_stride,
+        )
+    else:
+        pool_out = paddle.nn.functional.avg_pool2d(
+            x=tmp,
+            kernel_size=pool_size,
+            stride=pool_stride,
+        )
     return pool_out