You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1439 lines
63 KiB
1439 lines
63 KiB
# Copyright (c) 2020 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.
|
|
|
|
# TODO: define pooling functions
|
|
from ...fluid import core
|
|
from ...fluid.framework import in_dygraph_mode
|
|
from ...fluid.layers import utils, LayerHelper, unsqueeze, squeeze
|
|
from ...fluid.data_feeder import check_type, check_variable_and_dtype
|
|
|
|
__all__ = [
|
|
'avg_pool1d',
|
|
'avg_pool2d',
|
|
'avg_pool3d',
|
|
'max_pool1d',
|
|
'max_pool2d',
|
|
'max_pool3d',
|
|
'adaptive_avg_pool1d',
|
|
'adaptive_avg_pool2d',
|
|
'adaptive_avg_pool3d',
|
|
'adaptive_max_pool1d',
|
|
'adaptive_max_pool2d',
|
|
'adaptive_max_pool3d',
|
|
]
|
|
|
|
|
|
def _is_list_or_tuple(input):
|
|
return isinstance(input, (list, tuple))
|
|
|
|
|
|
def _check_input(x, dimension):
|
|
if len(x.shape) != dimension:
|
|
raise ValueError(
|
|
"Excepted Input X is {}-D tensor, but received {}-D {}".format(
|
|
dimension, len(x.shape), type(x)))
|
|
|
|
|
|
def _check_instance(x, x_name, types=(int, float)):
|
|
|
|
if not isinstance(x, types):
|
|
raise ValueError("Excepted {} type for {} but received type: {}. ".
|
|
format(types, x_name, type(x)))
|
|
|
|
|
|
def _zero_padding_in_batch_and_channel(padding, channel_last):
|
|
if channel_last:
|
|
return list(padding[0]) == [0, 0] and list(padding[-1]) == [0, 0]
|
|
else:
|
|
return list(padding[0]) == [0, 0] and list(padding[1]) == [0, 0]
|
|
|
|
|
|
def _exclude_padding_in_batch_and_channel(padding, channel_last):
|
|
padding_ = padding[1:-1] if channel_last else padding[2:]
|
|
padding_ = [elem for pad_a_dim in padding_ for elem in pad_a_dim]
|
|
return padding_
|
|
|
|
|
|
def _channel_last(data_format, num_dims):
|
|
if num_dims == 1:
|
|
if data_format not in ['NCL', 'NLC']:
|
|
raise ValueError(
|
|
"Attr(data_format) should be 'NCL' or 'NLC'. Received "
|
|
"Attr(data_format): %s" % str(data_format))
|
|
else:
|
|
return True if data_format == "NLC" else False
|
|
if num_dims == 2:
|
|
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))
|
|
else:
|
|
return True if data_format == "NHWC" else False
|
|
if num_dims == 3:
|
|
if data_format not in ['NCDHW', 'NDHWC']:
|
|
raise ValueError(
|
|
"Attr(data_format) should be 'NCDHW' or 'NDHWC'. Received "
|
|
"Attr(data_format): %s" % str(data_format))
|
|
else:
|
|
return True if data_format == "NDHWC" else False
|
|
|
|
|
|
def _update_padding_nd(padding, num_dims, channel_last=False, ceil_mode=False):
|
|
if isinstance(padding, str):
|
|
padding = padding.upper()
|
|
if padding not in ["SAME", "VALID"]:
|
|
raise ValueError(
|
|
"Unknown padding: '{}'. It can only be 'SAME' or 'VALID'.".
|
|
format(padding))
|
|
if padding == "VALID":
|
|
if ceil_mode != False:
|
|
raise ValueError(
|
|
"When Attr(padding) is \"VALID\", Attr(ceil_mode) must be False. "
|
|
"Received ceil_mode: True.")
|
|
|
|
padding_algorithm = "VALID"
|
|
padding = [0] * num_dims
|
|
else:
|
|
padding_algorithm = "SAME"
|
|
padding = [0] * num_dims
|
|
elif _is_list_or_tuple(padding):
|
|
# for padding like
|
|
# [(pad_before, pad_after), (pad_before, pad_after), ...]
|
|
# padding for batch_dim and channel_dim included
|
|
if len(padding) == 2 + num_dims and _is_list_or_tuple(padding[0]):
|
|
if not _zero_padding_in_batch_and_channel(padding, channel_last):
|
|
raise ValueError(
|
|
"Non-zero padding({}) in the batch or channel dimensions "
|
|
"is not supported.".format(padding))
|
|
padding_algorithm = "EXPLICIT"
|
|
padding = _exclude_padding_in_batch_and_channel(padding,
|
|
channel_last)
|
|
if utils._is_symmetric_padding(padding, num_dims):
|
|
padding = padding[0::2]
|
|
# for padding like [pad_before, pad_after, pad_before, pad_after, ...]
|
|
elif len(padding) == 2 * num_dims and isinstance(padding[0], int):
|
|
padding_algorithm = "EXPLICIT"
|
|
padding = utils.convert_to_list(padding, 2 * num_dims, 'padding')
|
|
if utils._is_symmetric_padding(padding, num_dims):
|
|
padding = padding[0::2]
|
|
# for padding like [pad_d1, pad_d2, ...]
|
|
elif len(padding) == num_dims and isinstance(padding[0], int):
|
|
padding_algorithm = "EXPLICIT"
|
|
padding = utils.convert_to_list(padding, num_dims, 'padding')
|
|
else:
|
|
raise ValueError("Invalid padding: {}".format(padding))
|
|
# for integer padding
|
|
else:
|
|
padding_algorithm = "EXPLICIT"
|
|
padding = utils.convert_to_list(padding, num_dims, 'padding')
|
|
return padding, padding_algorithm
|
|
|
|
|
|
def _expand_low_nd_padding(padding):
|
|
#1d to 2d fake input
|
|
if len(padding) == 2:
|
|
padding = [0] * 2 + padding
|
|
elif len(padding) == 1:
|
|
padding = [0] + padding
|
|
else:
|
|
raise ValueError(
|
|
"The size of padding's dimmention should be 1 or 2. But got padding={}".
|
|
format(padding))
|
|
return padding
|
|
|
|
|
|
def avg_pool1d(x,
|
|
kernel_size,
|
|
stride=None,
|
|
padding=0,
|
|
exclusive=True,
|
|
ceil_mode=False,
|
|
name=None):
|
|
"""
|
|
This API implements average pooling 1d operation,
|
|
See more details in :ref:`api_nn_pooling_AvgPool1d` .
|
|
|
|
Args:
|
|
x (Tensor): The input tensor of pooling operator which is a 3-D tensor with
|
|
shape [N, C, L]. where `N` is batch size, `C` is the number of channels,
|
|
`L` is the length of the feature. The data type is float32 or float64.
|
|
kernel_size (int|list|tuple): The pool kernel size. If pool kernel size is a tuple or list,
|
|
it must contain an integer.
|
|
stride (int|list|tuple): The pool stride size. If pool stride size is a tuple or list,
|
|
it must contain an integer.
|
|
padding (string|int|list|tuple): The padding size. Padding could be in one of the following forms.
|
|
1. A string in ['valid', 'same'].
|
|
2. An int, which means the feature map is zero padded by size of `padding` on every sides.
|
|
3. A list[int] or tuple(int) whose length is 1, which means the feature map is zero padded by the size of `padding[0]` on every sides.
|
|
4. A list[int] or tuple(int) whose length is 2. It has the form [pad_before, pad_after].
|
|
5. A list or tuple of pairs of integers. It has the form [[pad_before, pad_after], [pad_before, pad_after], ...]. Note that, the batch dimension and channel dimension should be [0,0] or (0,0).
|
|
The default value is 0.
|
|
exclusive (bool): Whether to exclude padding points in average pooling
|
|
mode, default is `True`.
|
|
ceil_mode (bool): ${ceil_mode_comment}Whether to use the ceil function to calculate output height and width.
|
|
If it is set to False, the floor function will be used. The default value is False.
|
|
name(str, optional): For detailed information, please refer
|
|
to :ref:`api_guide_Name`. Usually name is no need to set and
|
|
None by default.
|
|
Returns:
|
|
Tensor: The output tensor of pooling result. The data type is same as input tensor.
|
|
|
|
Raises:
|
|
ValueError: If `padding` is a string, but not "SAME" or "VALID".
|
|
ValueError: If `padding` is "VALID", but `ceil_mode` is True.
|
|
ValueError: If `padding` is a list or tuple but its length is greater than 1.
|
|
ShapeError: If the input is not a 3-D tensor.
|
|
ShapeError: If the output's shape calculated is not greater than 0.
|
|
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
import paddle
|
|
import paddle.nn.functional as F
|
|
import numpy as np
|
|
|
|
data = paddle.to_tensor(np.random.uniform(-1, 1, [1, 3, 32]).astype(np.float32))
|
|
out = F.avg_pool1d(data, kernel_size=2, stride=2, padding=0)
|
|
# out shape: [1, 3, 16]
|
|
"""
|
|
"""NCL to NCHW"""
|
|
data_format = "NCHW"
|
|
check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'avg_pool1d')
|
|
_check_input(x, 3)
|
|
x = unsqueeze(x, [2])
|
|
kernel_size = utils.convert_to_list(kernel_size, 1, 'kernel_size')
|
|
kernel_size = [1] + kernel_size
|
|
if stride is None:
|
|
stride = kernel_size
|
|
else:
|
|
stride = utils.convert_to_list(stride, 1, 'pool_stride')
|
|
stride = [1] + stride
|
|
|
|
channel_last = _channel_last("NCL", 1)
|
|
padding, padding_algorithm = _update_padding_nd(
|
|
padding, 1, channel_last=channel_last, ceil_mode=ceil_mode)
|
|
|
|
# use 2d to implenment 1d should expand padding in advance.
|
|
padding = _expand_low_nd_padding(padding)
|
|
|
|
if in_dygraph_mode():
|
|
output = core.ops.pool2d(
|
|
x, 'pooling_type', 'avg', 'ksize', kernel_size, 'global_pooling',
|
|
False, 'strides', stride, 'paddings', padding, 'padding_algorithm',
|
|
padding_algorithm, 'use_cudnn', True, 'ceil_mode', ceil_mode,
|
|
'use_mkldnn', False, 'exclusive', exclusive, 'data_format',
|
|
data_format)
|
|
return squeeze(output, [2])
|
|
|
|
op_type = 'pool2d'
|
|
helper = LayerHelper(op_type, **locals())
|
|
dtype = helper.input_dtype(input_param_name='x')
|
|
pool_out = helper.create_variable_for_type_inference(dtype)
|
|
|
|
helper.append_op(
|
|
type=op_type,
|
|
inputs={"X": x},
|
|
outputs={"Out": pool_out},
|
|
attrs={
|
|
"pooling_type": 'avg',
|
|
"ksize": kernel_size,
|
|
"global_pooling": False,
|
|
"strides": stride,
|
|
"paddings": padding,
|
|
"padding_algorithm": padding_algorithm,
|
|
"use_cudnn": True,
|
|
"ceil_mode": ceil_mode,
|
|
"use_mkldnn": False,
|
|
"exclusive": exclusive,
|
|
"data_format": data_format,
|
|
})
|
|
|
|
return squeeze(pool_out, [2])
|
|
|
|
|
|
def avg_pool2d(x,
|
|
kernel_size,
|
|
stride=None,
|
|
padding=0,
|
|
ceil_mode=False,
|
|
exclusive=True,
|
|
divisor_override=None,
|
|
data_format="NCHW",
|
|
name=None):
|
|
"""
|
|
This API implements average pooling 2d operation.
|
|
See more details in :ref:`api_nn_pooling_AvgPool2d` .
|
|
|
|
Args:
|
|
x (Tensor): 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.
|
|
kernel_size (int|list|tuple): The pool kernel size. If it is a tuple or list,
|
|
it must contain two integers, (kernel_size_Height, kernel_size_Width).
|
|
Otherwise, the pool kernel size will be a square of an int.
|
|
stride (int|list|tuple): The stride size. If it is a tuple or list,
|
|
it must contain two integers, (stride_Height, stride_Width).
|
|
Otherwise, the stride size will be a square of an int.
|
|
|
|
padding (string|int|list|tuple): The padding size. Padding could be in one of the following forms.
|
|
1. A string in ['valid', 'same'].
|
|
2. An int, which means the feature map is zero padded by size of `padding` on every sides.
|
|
3. A list[int] or tuple(int) whose length is 2, [pad_height, pad_weight] whose value means the padding size of each dimension.
|
|
4. A list[int] or tuple(int) whose length is 4. [pad_height_top, pad_height_bottom, pad_width_left, pad_width_right] whose value means the padding size of each side.
|
|
5. A list or tuple of pairs of integers. It has the form [[pad_before, pad_after], [pad_before, pad_after], ...]. Note that, the batch dimension and channel dimension should be [0,0] or (0,0).
|
|
The default value is 0.
|
|
ceil_mode (bool): when True, will use `ceil` instead of `floor` to compute the output shape
|
|
exclusive (bool): Whether to exclude padding points in average pooling
|
|
mode, default is `true`.
|
|
divisor_override (float): if specified, it will be used as divisor, otherwise kernel_size will be used. Default None.
|
|
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]`.
|
|
name(str, optional): For detailed information, please refer
|
|
to :ref:`api_guide_Name`. Usually name is no need to set and
|
|
None by default.
|
|
|
|
Returns:
|
|
Tensor: The output tensor of pooling result. The data type is same as input tensor.
|
|
|
|
Raises:
|
|
ValueError: If `padding` is a string, but not "SAME" or "VALID".
|
|
ValueError: If `padding` is "VALID", but `ceil_mode` is True.
|
|
ShapeError: If the output's shape calculated is not greater than 0.
|
|
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
import paddle
|
|
import paddle.nn.functional as F
|
|
import numpy as np
|
|
|
|
# avg pool2d
|
|
x = paddle.to_tensor(np.random.uniform(-1, 1, [1, 3, 32, 32]).astype(np.float32))
|
|
out = F.avg_pool2d(x,
|
|
kernel_size=2,
|
|
stride=2, padding=0)
|
|
# out.shape [1, 3, 16, 16]
|
|
"""
|
|
check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'avg_pool2d')
|
|
kernel_size = utils.convert_to_list(kernel_size, 2, 'pool_size')
|
|
if stride is None:
|
|
stride = kernel_size
|
|
else:
|
|
stride = utils.convert_to_list(stride, 2, 'pool_stride')
|
|
|
|
channel_last = _channel_last(data_format, 2)
|
|
padding, padding_algorithm = _update_padding_nd(
|
|
padding, 2, channel_last, ceil_mode=ceil_mode)
|
|
|
|
if in_dygraph_mode():
|
|
output = core.ops.pool2d(
|
|
x, 'pooling_type', 'avg', 'ksize', kernel_size, 'global_pooling',
|
|
False, 'padding_algorithm', padding_algorithm, 'strides', stride,
|
|
'paddings', padding, 'use_cudnn', True, 'ceil_mode', ceil_mode,
|
|
'use_mkldnn', False, 'exclusive', exclusive, 'data_format',
|
|
data_format)
|
|
if divisor_override is None:
|
|
return output
|
|
else:
|
|
_check_instance(divisor_override, "divisor_override")
|
|
return output * (kernel_size[0] * kernel_size[1]) / divisor_override
|
|
|
|
op_type = 'pool2d'
|
|
helper = LayerHelper(op_type, **locals())
|
|
dtype = helper.input_dtype(input_param_name='x')
|
|
pool_out = helper.create_variable_for_type_inference(dtype)
|
|
|
|
helper.append_op(
|
|
type=op_type,
|
|
inputs={"X": x},
|
|
outputs={"Out": pool_out},
|
|
attrs={
|
|
"pooling_type": "avg",
|
|
"ksize": kernel_size,
|
|
"global_pooling": False,
|
|
"strides": stride,
|
|
"paddings": padding,
|
|
"padding_algorithm": padding_algorithm,
|
|
"use_cudnn": True,
|
|
"ceil_mode": ceil_mode,
|
|
"use_mkldnn": False,
|
|
"exclusive": exclusive,
|
|
"data_format": data_format,
|
|
})
|
|
|
|
if divisor_override is None:
|
|
return pool_out
|
|
else:
|
|
_check_instance(divisor_override, "divisor_override")
|
|
return pool_out * (kernel_size[0] * kernel_size[1]) / divisor_override
|
|
|
|
|
|
def avg_pool3d(x,
|
|
kernel_size,
|
|
stride=None,
|
|
padding=0,
|
|
ceil_mode=False,
|
|
exclusive=True,
|
|
divisor_override=None,
|
|
data_format="NCDHW",
|
|
name=None):
|
|
"""
|
|
This API implements average pooling 3d operation.
|
|
See more details in :ref:`api_nn_pooling_AvgPool3d` .
|
|
|
|
Args:
|
|
x (Tensor): The input tensor of pooling operator, which is a 5-D tensor with
|
|
shape [N, C, D, H, W], where `N` represents the batch size, `C` represents
|
|
the number of channels, `D`, `H` and `W` represent the depth, height and width of the feature respectively.
|
|
kernel_size (int|list|tuple): The pool kernel size. If pool kernel size
|
|
is a tuple or list, it must contain three integers,
|
|
(kernel_size_Depth, kernel_size_Height, kernel_size_Width).
|
|
Otherwise, the pool kernel size will be the cube of an int.
|
|
stride (int|list|tuple): The pool stride size. If pool stride size is a tuple or list,
|
|
it must contain three integers, [stride_Depth, stride_Height, stride_Width).
|
|
Otherwise, the pool stride size will be a cube of an int.
|
|
padding (string|int|list|tuple): The padding size. Padding could be in one of the following forms.
|
|
1. A string in ['valid', 'same'].
|
|
2. An int, which means the feature map is zero padded by size of `padding` on every sides.
|
|
3. A list[int] or tuple(int) whose length is 3, [pad_depth, pad_height, pad_weight] whose value means the padding size of each dimension.
|
|
4. A list[int] or tuple(int) whose length is 6. [pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right] whose value means the padding size of each side.
|
|
5. A list or tuple of pairs of integers. It has the form [[pad_before, pad_after], [pad_before, pad_after], ...]. Note that, the batch dimension and channel dimension should be [0,0] or (0,0).
|
|
The default value is 0.
|
|
ceil_mode (bool): ${ceil_mode_comment}
|
|
exclusive (bool): Whether to exclude padding points in average pooling
|
|
mode, default is True.
|
|
divisor_override (int|float) if specified, it will be used as divisor, otherwise kernel_size will be used. Default None.
|
|
data_format (string): The data format of the input and output data. An optional string from: `"NCDHW"`, `"NDHWC"`.
|
|
The default is `"NCDHW"`. When it is `"NCDHW"`, the data is stored in the order of:
|
|
`[batch_size, input_channels, input_depth, input_height, input_width]`.
|
|
name(str, optional): For detailed information, please refer
|
|
to :ref:`api_guide_Name`. Usually name is no need to set and
|
|
None by default.
|
|
|
|
Returns:
|
|
Tensor: The output tensor of pooling result. The data type is same as input tensor.
|
|
|
|
Raises:
|
|
ValueError: If `padding` is a string, but not "SAME" or "VALID".
|
|
ValueError: If `padding` is "VALID", but `ceil_mode` is True.
|
|
ShapeError: If the output's shape calculated is not greater than 0.
|
|
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
import paddle
|
|
import numpy as np
|
|
|
|
x = paddle.to_tensor(np.random.uniform(-1, 1, [1, 3, 32, 32, 32]).astype(np.float32))
|
|
# avg pool3d
|
|
out = paddle.nn.functional.avg_pool3d(
|
|
x,
|
|
kernel_size = 2,
|
|
stride = 2,
|
|
padding=0)
|
|
# out.shape: [1, 3, 16, 16, 16]
|
|
"""
|
|
check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'max_pool3d')
|
|
kernel_size = utils.convert_to_list(kernel_size, 3, 'pool_size')
|
|
if stride is None:
|
|
stride = kernel_size
|
|
else:
|
|
stride = utils.convert_to_list(stride, 3, 'pool_stride')
|
|
|
|
channel_last = _channel_last(data_format, 3)
|
|
padding, padding_algorithm = _update_padding_nd(
|
|
padding, 3, channel_last=channel_last, ceil_mode=ceil_mode)
|
|
|
|
if in_dygraph_mode():
|
|
output = core.ops.pool3d(
|
|
x, 'pooling_type', 'avg', 'ksize', kernel_size, 'strides', stride,
|
|
'paddings', padding, 'global_pooling', False, 'padding_algorithm',
|
|
padding_algorithm, 'use_cudnn', True, 'ceil_mode', ceil_mode,
|
|
'use_mkldnn', False, 'exclusive', exclusive, 'data_format',
|
|
data_format)
|
|
if divisor_override is None:
|
|
return output
|
|
else:
|
|
_check_instance(divisor_override, "divisor_override")
|
|
return output * (kernel_size[0] * kernel_size[1] *
|
|
kernel_size[2]) / divisor_override
|
|
|
|
op_type = "pool3d"
|
|
helper = LayerHelper(op_type, **locals())
|
|
dtype = helper.input_dtype(input_param_name='x')
|
|
pool_out = helper.create_variable_for_type_inference(dtype)
|
|
outputs = {"Out": pool_out}
|
|
|
|
helper.append_op(
|
|
type=op_type,
|
|
inputs={"X": x},
|
|
outputs=outputs,
|
|
attrs={
|
|
"pooling_type": 'avg',
|
|
"ksize": kernel_size,
|
|
"global_pooling": False,
|
|
"strides": stride,
|
|
"paddings": padding,
|
|
"padding_algorithm": padding_algorithm,
|
|
"use_cudnn": True,
|
|
"ceil_mode": ceil_mode,
|
|
"use_mkldnn": False,
|
|
"exclusive": exclusive,
|
|
"data_format": data_format,
|
|
})
|
|
|
|
if divisor_override is None:
|
|
return pool_out
|
|
else:
|
|
_check_instance(divisor_override, "divisor_override")
|
|
return pool_out * (kernel_size[0] * kernel_size[1] *
|
|
kernel_size[2]) / divisor_override
|
|
|
|
|
|
def max_pool1d(x,
|
|
kernel_size,
|
|
stride=None,
|
|
padding=0,
|
|
return_mask=False,
|
|
ceil_mode=False,
|
|
name=None):
|
|
"""
|
|
This API implements max pooling 1d opereation.
|
|
See more details in :ref:`api_nn_pooling_MaxPool1d` .
|
|
|
|
Args:
|
|
x (Tensor): The input tensor of pooling operator which is a 3-D tensor with
|
|
shape [N, C, L], where `N` is batch size, `C` is the number of channels,
|
|
`L` is the length of the feature. The data type if float32 or float64.
|
|
kernel_size (int|list|tuple): The pool kernel size. If pool kernel size is a tuple or list,
|
|
it must contain an integer.
|
|
stride (int|list|tuple): The pool stride size. If pool stride size is a tuple or list,
|
|
it must contain an integer.
|
|
padding (string|int|list|tuple): The padding size. Padding could be in one of the following forms.
|
|
1. A string in ['valid', 'same'].
|
|
2. An integer, which means the feature map is zero padded by size of `padding` on every sides.
|
|
3. A list[int] or tuple(int) whose length is 1, which means the feature map is zero padded by the size of `padding[0]` on every sides.
|
|
4. A list[int] or tuple(int) whose length is 2. It has the form [pad_before, pad_after].
|
|
5. A list or tuple of pairs of integers. It has the form [[pad_before, pad_after], [pad_before, pad_after], ...]. Note that, the batch dimension and channel dimension should be [0,0] or (0,0).
|
|
The default value is 0.
|
|
return_mask (bool): Whether return the max indices along with the outputs. default is `False`.
|
|
ceil_mode (bool): Whether to use the ceil function to calculate output height and width. False is the default.
|
|
If it is set to False, the floor function will be used. Default False.
|
|
name(str, optional): For detailed information, please refer
|
|
to :ref:`api_guide_Name`. Usually name is no need to set and
|
|
None by default.
|
|
Returns:
|
|
Tensor: The output tensor of pooling result. The data type is same as input tensor.
|
|
|
|
Raises:
|
|
ValueError: If `padding` is a string, but not "SAME" or "VALID".
|
|
ValueError: If `padding` is "VALID", but `ceil_mode` is True.
|
|
ShapeError: If the input is not a 3-D tensor.
|
|
ShapeError: If the output's shape calculated is not greater than 0.
|
|
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
import paddle
|
|
import paddle.nn.functional as F
|
|
import numpy as np
|
|
|
|
data = paddle.to_tensor(np.random.uniform(-1, 1, [1, 3, 32]).astype(np.float32))
|
|
pool_out = F.max_pool1d(data, kernel_size=2, stride=2, padding=0)
|
|
# pool_out shape: [1, 3, 16]
|
|
pool_out, indices = F.max_pool1d(data, kernel_size=2, stride=2, padding=0, return_mask=True)
|
|
# pool_out shape: [1, 3, 16], indices shape: [1, 3, 16]
|
|
"""
|
|
"""NCL to NCHW"""
|
|
data_format = "NCHW"
|
|
check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'max_pool1d')
|
|
_check_input(x, 3)
|
|
x = unsqueeze(x, [2])
|
|
kernel_size = [1] + utils.convert_to_list(kernel_size, 1, 'pool_size')
|
|
if stride is None:
|
|
stride = kernel_size
|
|
else:
|
|
stride = [1] + utils.convert_to_list(stride, 1, 'pool_stride')
|
|
|
|
padding, padding_algorithm = _update_padding_nd(
|
|
padding, 1, ceil_mode=ceil_mode)
|
|
|
|
# use 2d to implenment 1d should expand padding in advance.
|
|
padding = _expand_low_nd_padding(padding)
|
|
|
|
if in_dygraph_mode():
|
|
if return_mask:
|
|
pool_out = core.ops.max_pool2d_with_index(
|
|
x, 'ksize', kernel_size, 'global_pooling', False, 'strides',
|
|
stride, 'paddings', padding, 'padding_algorithm',
|
|
padding_algorithm, 'use_cudnn', True, 'ceil_mode', ceil_mode,
|
|
'use_mkldnn', False, 'exclusive', True, 'data_format',
|
|
data_format)
|
|
return (squeeze(pool_out[0], [2]),
|
|
squeeze(pool_out[1],
|
|
[2])) if return_mask else squeeze(pool_out[0], [2])
|
|
else:
|
|
pool_out = core.ops.pool2d(
|
|
x, 'pooling_type', 'max', 'ksize', kernel_size,
|
|
'global_pooling', False, 'padding_algorithm', padding_algorithm,
|
|
'strides', stride, 'paddings', padding, 'use_cudnn', True,
|
|
'ceil_mode', ceil_mode, 'use_mkldnn', False, 'exclusive', True,
|
|
'data_format', data_format)
|
|
return squeeze(pool_out, [2])
|
|
|
|
op_type = 'max_pool2d_with_index' if return_mask else "pool2d"
|
|
helper = LayerHelper(op_type, **locals())
|
|
dtype = helper.input_dtype(input_param_name='x')
|
|
pool_out = helper.create_variable_for_type_inference(dtype)
|
|
mask = helper.create_variable_for_type_inference(dtype)
|
|
outputs = {"Out": pool_out, "Mask": mask}
|
|
|
|
helper.append_op(
|
|
type=op_type,
|
|
inputs={"X": x},
|
|
outputs=outputs,
|
|
attrs={
|
|
"pooling_type": 'max',
|
|
"ksize": kernel_size,
|
|
"global_pooling": False,
|
|
"strides": stride,
|
|
"paddings": padding,
|
|
"padding_algorithm": padding_algorithm,
|
|
"use_cudnn": True,
|
|
"ceil_mode": ceil_mode,
|
|
"use_mkldnn": False,
|
|
"exclusive": True,
|
|
"data_format": data_format,
|
|
})
|
|
|
|
return (squeeze(pool_out, [2]),
|
|
squeeze(mask, [2])) if return_mask else squeeze(pool_out, [2])
|
|
|
|
|
|
def max_pool2d(x,
|
|
kernel_size,
|
|
stride=None,
|
|
padding=0,
|
|
return_mask=False,
|
|
ceil_mode=False,
|
|
data_format="NCHW",
|
|
name=None):
|
|
"""
|
|
This API implements max pooling 2d operation.
|
|
See more details in :ref:`api_nn_pooling_MaxPool2d` .
|
|
|
|
Args:
|
|
x (Tensor): 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.
|
|
kernel_size (int|list|tuple): The pool kernel size. If pool kernel size is a tuple or list,
|
|
it must contain two integers, (kernel_size_Height, kernel_size_Width).
|
|
Otherwise, the pool kernel size will be a square of an int.
|
|
stride (int|list|tuple): The pool stride size. If pool stride size is a tuple or list,
|
|
it must contain two integers, (stride_Height, stride_Width).
|
|
Otherwise, the pool stride size will be a square of an int.
|
|
padding (string|int|list|tuple): The padding size. Padding could be in one of the following forms.
|
|
1. A string in ['valid', 'same'].
|
|
2. An int, which means the feature map is zero padded by size of `padding` on every sides.
|
|
3. A list[int] or tuple(int) whose length is 2, [pad_height, pad_weight] whose value means the padding size of each dimension.
|
|
4. A list[int] or tuple(int) whose length is 4. [pad_height_top, pad_height_bottom, pad_width_left, pad_width_right] whose value means the padding size of each side.
|
|
5. A list or tuple of pairs of integers. It has the form [[pad_before, pad_after], [pad_before, pad_after], ...]. Note that, the batch dimension and channel dimension should be [0,0] or (0,0).
|
|
The default value is 0.
|
|
ceil_mode (bool): when True, will use `ceil` instead of `floor` to compute the output shape
|
|
return_mask (bool): Whether to return the max indices along with the outputs. Default False, only support `"NCHW"` data format
|
|
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]`.
|
|
name(str, optional): For detailed information, please refer
|
|
to :ref:`api_guide_Name`. Usually name is no need to set and
|
|
None by default.
|
|
Returns:
|
|
Tensor: The output tensor of pooling result. The data type is same as input tensor.
|
|
|
|
Raises:
|
|
ValueError: If `padding` is a string, but not "SAME" or "VALID".
|
|
ValueError: If `padding` is "VALID", but `ceil_mode` is True.
|
|
ShapeError: If the output's shape calculated is not greater than 0.
|
|
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
import paddle
|
|
import paddle.nn.functional as F
|
|
import numpy as np
|
|
|
|
# max pool2d
|
|
x = paddle.to_tensor(np.random.uniform(-1, 1, [1, 3, 32, 32]).astype(np.float32))
|
|
out = F.max_pool2d(x,
|
|
kernel_size=2,
|
|
stride=2, padding=0)
|
|
# output.shape [1, 3, 16, 16]
|
|
# for return_mask=True
|
|
out, max_indices = F.max_pool2d(x,
|
|
kernel_size=2,
|
|
stride=2,
|
|
padding=0,
|
|
return_mask=True)
|
|
# out.shape [1, 3, 16, 16], max_indices.shape [1, 3, 16, 16],
|
|
"""
|
|
check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'],
|
|
'max_pool2d')
|
|
kernel_size = utils.convert_to_list(kernel_size, 2, 'pool_size')
|
|
if stride is None:
|
|
stride = kernel_size
|
|
else:
|
|
stride = utils.convert_to_list(stride, 2, 'pool_stride')
|
|
|
|
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))
|
|
|
|
channel_last = True if data_format == "NHWC" else False
|
|
|
|
padding, padding_algorithm = _update_padding_nd(
|
|
padding, num_dims=2, channel_last=channel_last, ceil_mode=ceil_mode)
|
|
|
|
if data_format == "NHWC" and return_mask:
|
|
raise ValueError(
|
|
"When setting return_mask to true, data_format must be set to NCHW in API:max_pool2d"
|
|
)
|
|
|
|
if in_dygraph_mode():
|
|
if return_mask:
|
|
output = core.ops.max_pool2d_with_index(
|
|
x, 'ksize', kernel_size, 'global_pooling', False, 'strides',
|
|
stride, 'paddings', padding, 'padding_algorithm',
|
|
padding_algorithm, 'use_cudnn', True, 'ceil_mode', ceil_mode,
|
|
'use_mkldnn', False, 'exclusive', True, 'data_format',
|
|
data_format)
|
|
return output if return_mask else output[0]
|
|
else:
|
|
output = core.ops.pool2d(
|
|
x, 'pooling_type', 'max', 'ksize', kernel_size,
|
|
'global_pooling', False, 'padding_algorithm', padding_algorithm,
|
|
'strides', stride, 'paddings', padding, 'use_cudnn', True,
|
|
'ceil_mode', ceil_mode, 'use_mkldnn', False, 'exclusive', True,
|
|
'data_format', data_format)
|
|
return output
|
|
|
|
op_type = 'max_pool2d_with_index' if return_mask else "pool2d"
|
|
helper = LayerHelper(op_type, **locals())
|
|
dtype = helper.input_dtype(input_param_name='x')
|
|
pool_out = helper.create_variable_for_type_inference(dtype)
|
|
mask = helper.create_variable_for_type_inference(dtype)
|
|
outputs = {"Out": pool_out, "Mask": mask}
|
|
|
|
helper.append_op(
|
|
type=op_type,
|
|
inputs={"X": x},
|
|
outputs=outputs,
|
|
attrs={
|
|
"pooling_type": 'max',
|
|
"ksize": kernel_size,
|
|
"global_pooling": False,
|
|
"strides": stride,
|
|
"paddings": padding,
|
|
"padding_algorithm": padding_algorithm,
|
|
"use_cudnn": True,
|
|
"ceil_mode": ceil_mode,
|
|
"use_mkldnn": False,
|
|
"exclusive": True,
|
|
"data_format": data_format,
|
|
})
|
|
|
|
return (pool_out, mask) if return_mask else pool_out
|
|
|
|
|
|
def max_pool3d(x,
|
|
kernel_size,
|
|
stride=None,
|
|
padding=0,
|
|
return_mask=False,
|
|
ceil_mode=False,
|
|
data_format="NCDHW",
|
|
name=None):
|
|
"""
|
|
This API implements max pooling 2d operation.
|
|
See more details in :ref:`api_nn_pooling_MaxPool3d` .
|
|
Args:
|
|
x (Tensor): The input tensor of pooling operator, which is a 5-D tensor with
|
|
shape [N, C, D, H, W]. The format of input tensor is `"NCDHW"` or `"NDHWC"`, where N represents batch size, C represents the number of channels, D, H and W represent the depth, height and width of the feature respectively.
|
|
kernel_size (int|list|tuple): The pool kernel size. If the kernel size
|
|
is a tuple or list, it must contain three integers,
|
|
(kernel_size_Depth, kernel_size_Height, kernel_size_Width).
|
|
Otherwise, the pool kernel size will be the cube of an int.
|
|
stride (int|list|tuple): The pool stride size. If pool stride size is a tuple or list,
|
|
it must contain three integers, [stride_Depth, stride_Height, stride_Width).
|
|
Otherwise, the pool stride size will be a cube of an int.
|
|
padding (string|int|list|tuple): The padding size. Padding could be in one of the following forms.
|
|
1. A string in ['valid', 'same'].
|
|
2. An int, which means the feature map is zero padded by size of `padding` on every sides.
|
|
3. A list[int] or tuple(int) whose length is 3, [pad_depth, pad_height, pad_weight] whose value means the padding size of each dimension.
|
|
4. A list[int] or tuple(int) whose length is 6. [pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right] whose value means the padding size of each side.
|
|
5. A list or tuple of pairs of integers. It has the form [[pad_before, pad_after], [pad_before, pad_after], ...]. Note that, the batch dimension and channel dimension should be [0,0] or (0,0).
|
|
The default value is 0.
|
|
ceil_mode (bool): ${ceil_mode_comment}
|
|
return_mask (bool): Whether to return the max indices along with the outputs. Default False. Only support "NDCHW" data_format.
|
|
data_format (string): The data format of the input and output data. An optional string from: `"NCDHW"`, `"NDHWC"`.
|
|
The default is `"NCDHW"`. When it is `"NCDHW"`, the data is stored in the order of:
|
|
`[batch_size, input_channels, input_depth, input_height, input_width]`.
|
|
name(str, optional): For detailed information, please refer
|
|
to :ref:`api_guide_Name`. Usually name is no need to set and
|
|
None by default.
|
|
|
|
Returns:
|
|
Tensor: The output tensor of pooling result. The data type is same as input tensor.
|
|
|
|
Raises:
|
|
ValueError: If `padding` is a string, but not "SAME" or "VALID".
|
|
ValueError: If `padding` is "VALID", but `ceil_mode` is True.
|
|
ShapeError: If the output's shape calculated is not greater than 0.
|
|
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
import paddle
|
|
import paddle.nn.functional as F
|
|
import numpy as np
|
|
|
|
# max pool3d
|
|
x = paddle.to_tensor(np.random.uniform(-1, 1, [1, 3, 32, 32, 32]).astype(np.float32))
|
|
output = F.max_pool2d(x,
|
|
kernel_size=2,
|
|
stride=2, padding=0)
|
|
output.shape [1, 3, 16, 16, 16]
|
|
# for return_mask=True
|
|
x = paddle.to_tensor(np.random.uniform(-1, 1, [1, 3, 32, 32, 32]).astype(np.float32))
|
|
output, max_indices = paddle.nn.functional.max_pool3d(x,
|
|
kernel_size = 2,
|
|
stride = 2,
|
|
padding=0,
|
|
return_mask=True)
|
|
# output.shape [None, 3, 16, 16, 16], max_indices.shape [None, 3, 16, 16, 16],
|
|
"""
|
|
check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'max_pool3d')
|
|
kernel_size = utils.convert_to_list(kernel_size, 3, 'pool_size')
|
|
if stride is None:
|
|
stride = kernel_size
|
|
else:
|
|
stride = utils.convert_to_list(stride, 3, 'pool_stride')
|
|
|
|
channel_last = _channel_last(data_format, 3)
|
|
|
|
padding, padding_algorithm = _update_padding_nd(
|
|
padding, 3, channel_last=channel_last, ceil_mode=ceil_mode)
|
|
|
|
if data_format == "NDHWC" and return_mask:
|
|
raise ValueError(
|
|
"When setting return_mask to true, data_format must be set to NCDHW in API:max_pool3d"
|
|
)
|
|
|
|
if in_dygraph_mode():
|
|
if return_mask:
|
|
output = core.ops.max_pool3d_with_index(
|
|
x, 'pooling_type', 'max', 'ksize', kernel_size, 'strides',
|
|
stride, 'paddings', padding, 'global_pooling', False,
|
|
'padding_algorithm', padding_algorithm, 'use_cudnn', True,
|
|
'ceil_mode', ceil_mode, 'use_mkldnn', False, 'exclusive', True,
|
|
'data_format', data_format)
|
|
return output if return_mask else output[0]
|
|
else:
|
|
output = core.ops.pool3d(
|
|
x, 'pooling_type', 'max', 'ksize', kernel_size,
|
|
'global_pooling', False, 'padding_algorithm', padding_algorithm,
|
|
'strides', stride, 'paddings', padding, 'use_cudnn', True,
|
|
'ceil_mode', ceil_mode, 'use_mkldnn', False, 'exclusive', True,
|
|
'data_format', data_format)
|
|
return output
|
|
|
|
op_type = "max_pool3d_with_index" if return_mask else "pool3d"
|
|
helper = LayerHelper(op_type, **locals())
|
|
dtype = helper.input_dtype(input_param_name='x')
|
|
pool_out = helper.create_variable_for_type_inference(dtype)
|
|
mask = helper.create_variable_for_type_inference(dtype)
|
|
outputs = {"Out": pool_out, "Mask": mask}
|
|
|
|
helper.append_op(
|
|
type=op_type,
|
|
inputs={"X": x},
|
|
outputs=outputs,
|
|
attrs={
|
|
"pooling_type": 'max',
|
|
"ksize": kernel_size,
|
|
"global_pooling": False,
|
|
"strides": stride,
|
|
"paddings": padding,
|
|
"padding_algorithm": padding_algorithm,
|
|
"use_cudnn": True,
|
|
"ceil_mode": ceil_mode,
|
|
"use_mkldnn": False,
|
|
"exclusive": False,
|
|
"data_format": data_format,
|
|
})
|
|
|
|
return (pool_out, mask) if return_mask else pool_out
|
|
|
|
|
|
def adaptive_avg_pool1d(x, output_size, name=None):
|
|
"""
|
|
This API implements adaptive average pooling 1d operation.
|
|
See more details in :ref:`api_nn_pooling_AdaptiveAvgPool1d` .
|
|
|
|
Args:
|
|
x (Tensor): The input tensor of pooling operator, which is a 3-D tensor
|
|
with shape [N, C, L]. The format of input tensor is NCL,
|
|
where N is batch size, C is the number of channels, L is the
|
|
length of the feature. The data type is float32 or float64.
|
|
output_size (int): The target output size. It must be an integer.
|
|
name(str, optional): For detailed information, please refer
|
|
to :ref:`api_guide_Name`. Usually name is no need to set and
|
|
None by default.
|
|
Returns:
|
|
Tensor: The output tensor of adaptive average pooling result. The data type is same
|
|
as input tensor.
|
|
Raises:
|
|
ValueError: 'output_size' should be an integer.
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
# average adaptive pool1d
|
|
# suppose input data in shape of [N, C, L], `output_size` is m or [m],
|
|
# output shape is [N, C, m], adaptive pool divide L dimension
|
|
# of input data into m grids averagely and performs poolings in each
|
|
# grid to get output.
|
|
# adaptive max pool performs calculations as follow:
|
|
#
|
|
# for i in range(m):
|
|
# lstart = floor(i * L / m)
|
|
# lend = ceil((i + 1) * L / m)
|
|
# output[:, :, i] = sum(input[:, :, lstart: lend])/(lstart - lend)
|
|
#
|
|
import paddle
|
|
import paddle.nn.functional as F
|
|
import numpy as np
|
|
|
|
data = paddle.to_tensor(np.random.uniform(-1, 1, [1, 3, 32]).astype(np.float32))
|
|
pool_out = F.adaptive_average_pool1d(data, output_size=16)
|
|
# pool_out shape: [1, 3, 16])
|
|
"""
|
|
pool_type = 'avg'
|
|
check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'],
|
|
'adaptive_pool2d')
|
|
_check_input(x, 3)
|
|
check_type(output_size, 'pool_size', (int), 'adaptive_pool1d')
|
|
|
|
pool_size = [1] + utils.convert_to_list(output_size, 1, 'pool_size')
|
|
|
|
l_type = "pool2d"
|
|
x = unsqueeze(x, [2])
|
|
if in_dygraph_mode():
|
|
pool_out = core.ops.pool2d(x, 'pooling_type', pool_type, 'ksize',
|
|
pool_size, 'adaptive', True)
|
|
return squeeze(pool_out, [2])
|
|
|
|
helper = LayerHelper(l_type, **locals())
|
|
dtype = helper.input_dtype(input_param_name='x')
|
|
pool_out = helper.create_variable_for_type_inference(dtype)
|
|
|
|
outputs = {"Out": pool_out}
|
|
helper.append_op(
|
|
type=l_type,
|
|
inputs={"X": x},
|
|
outputs=outputs,
|
|
attrs={
|
|
"pooling_type": pool_type,
|
|
"ksize": pool_size,
|
|
"adaptive": True,
|
|
})
|
|
|
|
return squeeze(pool_out, [2])
|
|
|
|
|
|
def adaptive_avg_pool2d(x, output_size, data_format='NCHW', name=None):
|
|
"""
|
|
This API implements adaptive average pooling 2d operation.
|
|
See more details in :ref:`api_nn_pooling_AdaptiveAvgPool2d` .
|
|
|
|
Args:
|
|
x (Tensor): The input tensor of adaptive avg pool2d operator, which is a 4-D tensor.
|
|
The data type can be float32 or float64.
|
|
output_size (int|list|tuple): The pool kernel size. If pool kernel size is a tuple or list,
|
|
it must contain two element, (H, W). H and W can be either a int, or None which means
|
|
the size will be the same as that of the input.
|
|
data_format (str): 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].
|
|
name(str, optional): For detailed information, please refer
|
|
to :ref:`api_guide_Name`. Usually name is no need to set and
|
|
None by default.
|
|
Returns:
|
|
Tensor: The output tensor of avg adaptive pool2d result. The data type is same as input tensor.
|
|
Raises:
|
|
ValueError: If `data_format` is not "NCHW" or "NHWC".
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
# adaptive avg pool2d
|
|
# suppose input data in shape of [N, C, H, W], `output_size` is [m, n],
|
|
# output shape is [N, C, m, n], adaptive pool divide H and W dimensions
|
|
# of input data into m * n grids averagely and performs poolings in each
|
|
# grid to get output.
|
|
# adaptive avg pool performs calculations as follow:
|
|
#
|
|
# for i in range(m):
|
|
# for j in range(n):
|
|
# hstart = floor(i * H / m)
|
|
# hend = ceil((i + 1) * H / m)
|
|
# wstart = floor(i * W / n)
|
|
# wend = ceil((i + 1) * W / n)
|
|
# output[:, :, i, j] = avg(input[:, :, hstart: hend, wstart: wend])
|
|
#
|
|
import paddle
|
|
import numpy as np
|
|
|
|
input_data = np.random.rand(2, 3, 32, 32)
|
|
x = paddle.to_tensor(input_data)
|
|
# x.shape is [2, 3, 32, 32]
|
|
out = paddle.nn.functional.adaptive_avg_pool2d(
|
|
x = x,
|
|
output_size=[3, 3])
|
|
# out.shape is [2, 3, 3, 3]
|
|
"""
|
|
if not in_dygraph_mode():
|
|
check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'],
|
|
'adaptive_avg_pool2d')
|
|
check_type(data_format, 'data_format', str, 'adaptive_avg_pool2d')
|
|
|
|
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))
|
|
|
|
if data_format == "NCHW":
|
|
in_h, in_w = x.shape[2:4]
|
|
else:
|
|
in_h, in_w = x.shape[1:3]
|
|
|
|
if isinstance(output_size, int):
|
|
output_size = utils.convert_to_list(output_size, 2, 'output_size')
|
|
else:
|
|
output_size = list(output_size)
|
|
if output_size[0] == None:
|
|
output_size[0] = in_h
|
|
if output_size[1] == None:
|
|
output_size[1] = in_w
|
|
|
|
if in_dygraph_mode():
|
|
output = core.ops.pool2d(x, 'pooling_type', 'avg', 'ksize', output_size,
|
|
'global_pooling', False, 'adaptive', True,
|
|
'data_format', data_format)
|
|
return output
|
|
|
|
l_type = 'pool2d'
|
|
|
|
helper = LayerHelper(l_type, **locals())
|
|
dtype = helper.input_dtype(input_param_name='x')
|
|
pool_out = helper.create_variable_for_type_inference(dtype)
|
|
|
|
outputs = {"Out": pool_out}
|
|
|
|
helper.append_op(
|
|
type=l_type,
|
|
inputs={"X": x},
|
|
outputs=outputs,
|
|
attrs={
|
|
"pooling_type": "avg",
|
|
"ksize": output_size,
|
|
"adaptive": True,
|
|
"data_format": data_format,
|
|
})
|
|
|
|
return pool_out
|
|
|
|
|
|
def adaptive_avg_pool3d(x, output_size, data_format='NCDHW', name=None):
|
|
"""
|
|
This API implements adaptive average pooling 3d operation.
|
|
See more details in :ref:`api_nn_pooling_AdaptiveAvgPool3d` .
|
|
|
|
Args:
|
|
x (Tensor): The input tensor of adaptive avg pool3d operator, which is a 5-D tensor.
|
|
The data type can be float32, float64.
|
|
output_size (int|list|tuple): The pool kernel size. If pool kernel size is a tuple or list,
|
|
it must contain three elements, (D, H, W). D, H and W can be either a int, or None which means
|
|
the size will be the same as that of the input.
|
|
data_format (str): The data format of the input and output data. An optional string
|
|
from: "NCDHW", "NDHWC". The default is "NCDHW". When it is "NCDHW", the data is stored in
|
|
the order of: [batch_size, input_channels, input_depth, input_height, input_width].
|
|
name(str, optional): For detailed information, please refer
|
|
to :ref:`api_guide_Name`. Usually name is no need to set and
|
|
None by default.
|
|
Returns:
|
|
Tensor: The output tensor of avg adaptive pool3d result. The data type is same as input tensor.
|
|
Raises:
|
|
ValueError: If `data_format` is not "NCDHW" or "NDHWC".
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
# adaptive avg pool3d
|
|
# suppose input data in shape of [N, C, D, H, W], `output_size` is [l, m, n],
|
|
# output shape is [N, C, l, m, n], adaptive pool divide D, H and W dimensions
|
|
# of input data into l * m * n grids averagely and performs poolings in each
|
|
# grid to get output.
|
|
# adaptive avg pool performs calculations as follow:
|
|
#
|
|
# for i in range(l):
|
|
# for j in range(m):
|
|
# for k in range(n):
|
|
# dstart = floor(i * D / l)
|
|
# dend = ceil((i + 1) * D / l)
|
|
# hstart = floor(j * H / m)
|
|
# hend = ceil((j + 1) * H / m)
|
|
# wstart = floor(k * W / n)
|
|
# wend = ceil((k + 1) * W / n)
|
|
# output[:, :, i, j, k] =
|
|
# avg(input[:, :, dstart:dend, hstart: hend, wstart: wend])
|
|
import paddle
|
|
import numpy as np
|
|
input_data = np.random.rand(2, 3, 8, 32, 32)
|
|
x = paddle.to_tensor(input_data)
|
|
# x.shape is [2, 3, 8, 32, 32]
|
|
out = paddle.nn.functional.adaptive_avg_pool3d(
|
|
x = x,
|
|
output_size=[3, 3, 3])
|
|
# out.shape is [2, 3, 3, 3, 3]
|
|
"""
|
|
if not in_dygraph_mode():
|
|
check_variable_and_dtype(x, 'x', ['float32', 'float64'],
|
|
'adaptive_avg_pool3d')
|
|
check_type(data_format, 'data_format', str, 'adaptive_avg_pool3d')
|
|
|
|
if data_format not in ["NCDHW", "NDHWC"]:
|
|
raise ValueError(
|
|
"Attr(data_format) should be 'NCDHW' or 'NDHWC'. Received "
|
|
"Attr(data_format): %s." % str(data_format))
|
|
|
|
if data_format == "NCDHW":
|
|
in_l, in_h, in_w = x.shape[2:5]
|
|
else:
|
|
in_l, in_h, in_w = x.shape[1:4]
|
|
|
|
if isinstance(output_size, int):
|
|
output_size = utils.convert_to_list(output_size, 3, 'output_size')
|
|
else:
|
|
output_size = list(output_size)
|
|
if output_size[0] == None:
|
|
output_size[0] = in_l
|
|
if output_size[1] == None:
|
|
output_size[1] = in_h
|
|
if output_size[2] == None:
|
|
output_size[2] = in_w
|
|
|
|
if in_dygraph_mode():
|
|
output = core.ops.pool3d(x, 'pooling_type', 'avg', 'ksize', output_size,
|
|
'global_pooling', False, 'adaptive', True,
|
|
'data_format', data_format)
|
|
return output
|
|
|
|
l_type = 'pool3d'
|
|
|
|
helper = LayerHelper(l_type, **locals())
|
|
dtype = helper.input_dtype(input_param_name='x')
|
|
pool_out = helper.create_variable_for_type_inference(dtype)
|
|
outputs = {"Out": pool_out}
|
|
|
|
helper.append_op(
|
|
type=l_type,
|
|
inputs={"X": x},
|
|
outputs=outputs,
|
|
attrs={
|
|
"pooling_type": "avg",
|
|
"ksize": output_size,
|
|
"adaptive": True,
|
|
"data_format": data_format,
|
|
})
|
|
|
|
return pool_out
|
|
|
|
|
|
def adaptive_max_pool1d(x, output_size, return_mask=False, name=None):
|
|
"""
|
|
This API implements adaptive max pooling 1d operation.
|
|
See more details in :ref:`api_nn_pooling_AdaptiveMaxPool1d` .
|
|
|
|
Args:
|
|
x (Tensor): The input tensor of pooling operator, which is a 3-D tensor
|
|
with shape [N, C, L]. The format of input tensor is NCL,
|
|
where N is batch size, C is the number of channels, L is the
|
|
length of the feature. The data type is float32 or float64.
|
|
output_size (int): The pool kernel size. The value should be an integer.
|
|
return_mask (bool): If true, the index of max pooling point will be returned along
|
|
with outputs. It cannot be set in average pooling type. Default False.
|
|
name(str, optional): For detailed information, please refer
|
|
to :ref:`api_guide_Name`. Usually name is no need to set and
|
|
None by default.
|
|
Returns:
|
|
Tensor: The output tensor of adaptive pooling result. The data type is same
|
|
as input tensor.
|
|
Raises:
|
|
ValueError: 'output_size' should be an integer.
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
# max adaptive pool1d
|
|
# suppose input data in shape of [N, C, L], `output_size` is m or [m],
|
|
# output shape is [N, C, m], adaptive pool divide L dimension
|
|
# of input data into m grids averagely and performs poolings in each
|
|
# grid to get output.
|
|
# adaptive max pool performs calculations as follow:
|
|
#
|
|
# for i in range(m):
|
|
# lstart = floor(i * L / m)
|
|
# lend = ceil((i + 1) * L / m)
|
|
# output[:, :, i] = max(input[:, :, lstart: lend])
|
|
#
|
|
import paddle
|
|
import paddle.nn.functional as F
|
|
import numpy as np
|
|
|
|
data = paddle.to_tensor(np.random.uniform(-1, 1, [1, 3, 32]).astype(np.float32))
|
|
pool_out = F.adaptive_max_pool1d(data, output_size=16)
|
|
# pool_out shape: [1, 3, 16])
|
|
pool_out, indices = F.adaptive_max_pool1d(data, output_size=16, return_mask=True)
|
|
# pool_out shape: [1, 3, 16] indices shape: [1, 3, 16]
|
|
"""
|
|
pool_type = 'max'
|
|
check_variable_and_dtype(x, 'x', ['float32', 'float64'],
|
|
'adaptive_max_pool1d')
|
|
_check_input(x, 3)
|
|
check_type(output_size, 'pool_size', int, 'adaptive_max_pool1d')
|
|
check_type(return_mask, 'return_mask', bool, 'adaptive_max_pool1d')
|
|
|
|
pool_size = [1] + utils.convert_to_list(output_size, 1, 'pool_size')
|
|
|
|
l_type = 'max_pool2d_with_index'
|
|
|
|
x = unsqueeze(x, [2])
|
|
if in_dygraph_mode():
|
|
pool_out = core.ops.max_pool2d_with_index(
|
|
x, 'pooling_type', pool_type, 'ksize', pool_size, 'adaptive', True)
|
|
return (squeeze(pool_out[0], [2]), squeeze(
|
|
pool_out[1], [2])) if return_mask else squeeze(pool_out[0], [2])
|
|
|
|
helper = LayerHelper(l_type, **locals())
|
|
dtype = helper.input_dtype(input_param_name='x')
|
|
pool_out = helper.create_variable_for_type_inference(dtype)
|
|
|
|
mask = helper.create_variable_for_type_inference(dtype)
|
|
outputs = {"Out": pool_out, "Mask": mask}
|
|
|
|
helper.append_op(
|
|
type=l_type,
|
|
inputs={"X": x},
|
|
outputs=outputs,
|
|
attrs={
|
|
"pooling_type": pool_type,
|
|
"ksize": pool_size,
|
|
"adaptive": True,
|
|
})
|
|
|
|
return (squeeze(pool_out, [2]),
|
|
squeeze(mask, [2])) if return_mask else squeeze(pool_out, [2])
|
|
|
|
|
|
def adaptive_max_pool2d(x, output_size, return_mask=False, name=None):
|
|
"""
|
|
This operation applies a 2D adaptive max pooling on input tensor.
|
|
See more details in :ref:`api_nn_pooling_AdaptiveMaxPool2d` .
|
|
|
|
Args:
|
|
x (Tensor): The input tensor of adaptive max pool2d operator, which is a 4-D tensor. The data type can be float16, float32, float64, int32 or int64.
|
|
output_size (int|list|tuple): The pool kernel size. If pool kernel size is a tuple or list, it must contain two elements, (H, W). H and W can be either a int, or None which means the size will be the same as that of the input.
|
|
return_mask (bool): If true, the index of max pooling point will be returned along with outputs. Default False.
|
|
name(str, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default.
|
|
|
|
Returns:
|
|
Tensor: The output tensor of adaptive max pool2d result. The data type is same as input tensor.
|
|
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
# max adaptive pool2d
|
|
# suppose input data in the shape of [N, C, H, W], `output_size` is [m, n]
|
|
# output shape is [N, C, m, n], adaptive pool divide H and W dimensions
|
|
# of input data into m*n grids averagely and performs poolings in each
|
|
# grid to get output.
|
|
# adaptive max pool performs calculations as follow:
|
|
#
|
|
# for i in range(m):
|
|
# for j in range(n):
|
|
# hstart = floor(i * H / m)
|
|
# hend = ceil((i + 1) * H / m)
|
|
# wstart = floor(i * W / n)
|
|
# wend = ceil((i + 1) * W / n)
|
|
# output[:, :, i, j] = max(input[:, :, hstart: hend, wstart: wend])
|
|
#
|
|
import paddle
|
|
import numpy as np
|
|
|
|
input_data = np.random.rand(2, 3, 32, 32)
|
|
x = paddle.to_tensor(input_data)
|
|
# x.shape is [2, 3, 32, 32]
|
|
out = paddle.nn.functional.adaptive_max_pool2d(
|
|
x = x,
|
|
output_size=[3, 3])
|
|
# out.shape is [2, 3, 3, 3]
|
|
"""
|
|
if not in_dygraph_mode():
|
|
check_variable_and_dtype(x, 'x', ['float32', 'float64'],
|
|
'adaptive_max_pool2d')
|
|
_check_input(x, 4)
|
|
#check_type(output_size, 'pool_size', (int), 'adaptive_max_pool2d')
|
|
check_type(return_mask, 'return_mask', bool, 'adaptive_max_pool2d')
|
|
|
|
in_h, in_w = x.shape[2:4]
|
|
if isinstance(output_size, int):
|
|
output_size = utils.convert_to_list(output_size, 2, 'output_size')
|
|
else:
|
|
output_size = list(output_size)
|
|
if output_size[0] == None:
|
|
output_size[0] = in_h
|
|
if output_size[1] == None:
|
|
output_size[1] = in_w
|
|
|
|
if in_dygraph_mode():
|
|
pool_out = core.ops.max_pool2d_with_index(
|
|
x, 'pooling_type', 'max', 'ksize', output_size, 'adaptive', True)
|
|
return pool_out if return_mask else pool_out[0]
|
|
|
|
l_type = 'max_pool2d_with_index'
|
|
|
|
helper = LayerHelper(l_type, **locals())
|
|
dtype = helper.input_dtype(input_param_name='x')
|
|
pool_out = helper.create_variable_for_type_inference(dtype)
|
|
|
|
mask = helper.create_variable_for_type_inference(dtype)
|
|
outputs = {"Out": pool_out, "Mask": mask}
|
|
|
|
helper.append_op(
|
|
type=l_type,
|
|
inputs={"X": x},
|
|
outputs=outputs,
|
|
attrs={
|
|
"pooling_type": 'max',
|
|
"ksize": output_size,
|
|
"adaptive": True,
|
|
})
|
|
#return (pool_out, mask) if return_mask else pool_out
|
|
return pool_out
|
|
|
|
|
|
def adaptive_max_pool3d(x, output_size, return_mask=False, name=None):
|
|
"""
|
|
This operation applies a 3D adaptive max pooling on input tensor.
|
|
See more details in :ref:`api_nn_pooling_AdaptiveMaxPool3d` .
|
|
|
|
Args:
|
|
x (Tensor): The input tensor of adaptive max pool3d operator, which is a 5-D tensor. The data type can be float32, float64.
|
|
output_size (int|list|tuple): The pool kernel size. If pool kernel size is a tuple or list, it must contain three elements, (D, H, W). D, H and W can be either a int, or None which means the size will be the same as that of the input.
|
|
return_mask (bool): If true, the index of max pooling point will be returned along with outputs. Default False.
|
|
name(str, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default.
|
|
|
|
Returns:
|
|
Tensor: The output tensor of adaptive max pool3d result. The data type is same as input tensor.
|
|
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
# adaptive max pool3d
|
|
# suppose input data in the shape of [N, C, D, H, W], `output_size` is [l, m, n]
|
|
# output shape is [N, C, l, m, n], adaptive pool divide D, H and W dimensions
|
|
# of input data into m*n grids averagely and performs poolings in each
|
|
# grid to get output.
|
|
# adaptive max pool performs calculations as follow:
|
|
#
|
|
# for i in range(l):
|
|
# for j in range(m):
|
|
# for k in range(n):
|
|
# dstart = floor(i * D / l)
|
|
# dend = ceil((i + 1) * D / l)
|
|
# hstart = floor(i * H / m)
|
|
# hend = ceil((i + 1) * H / m)
|
|
# wstart = floor(i * W / n)
|
|
# wend = ceil((i + 1) * W / n)
|
|
# output[:, :, i, j, k] = max(input[:, :, dstart: dend, hstart: hend, wstart: wend])
|
|
#
|
|
import paddle
|
|
import numpy as np
|
|
|
|
input_data = np.random.rand(2, 3, 8, 32, 32)
|
|
x = paddle.to_tensor(input_data)
|
|
# x.shape is [2, 3, 8, 32, 32]
|
|
out = paddle.nn.functional.adaptive_max_pool3d(
|
|
x = x,
|
|
output_size=[3, 3, 3])
|
|
# out.shape is [2, 3, 3, 3, 3]
|
|
"""
|
|
|
|
if not in_dygraph_mode():
|
|
check_variable_and_dtype(x, 'x', ['float32', 'float64'],
|
|
'adaptive_max_pool3d')
|
|
_check_input(x, 5)
|
|
#check_type(output_size, 'pool_size', (int), 'adaptive_max_pool3d')
|
|
check_type(return_mask, 'return_mask', bool, 'adaptive_max_pool3d')
|
|
|
|
in_l, in_h, in_w = x.shape[2:5]
|
|
if isinstance(output_size, int):
|
|
output_size = utils.convert_to_list(output_size, 3, 'output_size')
|
|
else:
|
|
output_size = list(output_size)
|
|
if output_size[0] == None:
|
|
output_size[0] = in_l
|
|
if output_size[1] == None:
|
|
output_size[1] = in_h
|
|
if output_size[2] == None:
|
|
output_size[2] = in_w
|
|
|
|
if in_dygraph_mode():
|
|
pool_out = core.ops.max_pool3d_with_index(
|
|
x, 'pooling_type', 'max', 'ksize', output_size, 'adaptive', True)
|
|
return pool_out if return_mask else pool_out[0]
|
|
|
|
l_type = 'max_pool3d_with_index'
|
|
|
|
helper = LayerHelper(l_type, **locals())
|
|
dtype = helper.input_dtype(input_param_name='x')
|
|
pool_out = helper.create_variable_for_type_inference(dtype)
|
|
|
|
mask = helper.create_variable_for_type_inference(dtype)
|
|
outputs = {"Out": pool_out, "Mask": mask}
|
|
|
|
helper.append_op(
|
|
type=l_type,
|
|
inputs={"X": x},
|
|
outputs=outputs,
|
|
attrs={
|
|
"pooling_type": 'max',
|
|
"ksize": output_size,
|
|
"adaptive": True,
|
|
})
|
|
|
|
return (pool_out, mask) if return_mask else pool_out
|