ёi}FLSSKJr SSKrSSKJr SSKJrJr SSKJ r SSK J r \(a&SS K Jr SS KJr SS KJrJrJrJrJrJrJrJr SS KJr /r"S S\ 5r"SS\ 5r"SS\ 5r"SS\ 5r "SS\ 5r!"SS\ 5r""SS\ 5r#"SS\ 5r$"SS\ 5r%"SS \ 5r&"S!S"\ 5r'"S#S$\ 5r("S%S&\ 5r)"S'S(\ 5r*"S)S*\ 5r+"S+S,\ 5r,"S-S.\ 5r-"S/S0\ 5r."S1S2\ 5r/g)3) annotationsN) TYPE_CHECKING)lp_pool_layer_decoratorparam_one_alias) functional)Layer)Sequence)Tensor) DataLayout1D DataLayout2D DataLayout3DSize1Size2Size3Size4Size6)_PaddingSizeModec^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S 'SSU4SjjjrSSjrSSjrSr U=r $) AvgPool1D1a This operation applies a 1D average pooling over an input signal composed of several input planes, based on the input, output_size, return_mask parameters. Input(X) and output(Out) are in NCL format, where N is batch size, C is the number of channels, L is the length of the feature. The output tensor shape will be [N, C, output_size]. The output value of the layer with input size (N, C, L), output (N, C, :math:`L_{out}`) and kernel_size ksize can be precisely described as For average pool1d: .. math:: Output(N_i, C_i, l) = \frac{Input[N_i, C_i, stride \times l:stride \times l+k]}{ksize} Parameters: 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|None, optional): The pool stride size. If pool stride size is a tuple or list, it must contain an integer. Default None, then stride will be equal to the kernel_size. padding(str|int|list|tuple, optional): 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, optional): Whether to exclude padding points in average pooling mode, default is `True`. ceil_mode(bool, optional): ${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|None, optional): For eed to detailed information, please refer to :ref:`api_guide_Name`. Usually name is no nset and None by default. Shape: - x(Tensor): The input tensor of avg pool1d operator, which is a 3-D tensor. The data type can be float32, float64. - output(Tensor): The output tensor of avg pool1d operator, which is a 3-D tensor. The data type is same as input x. Returns: A callable object of AvgPool1D. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn as nn >>> data = paddle.uniform([1, 3, 32], dtype="float32", min=-1, max=1) >>> AvgPool1D = nn.AvgPool1D(kernel_size=2, stride=2, padding=0) >>> pool_out = AvgPool1D(data) >>> print(pool_out.shape) paddle.Size([1, 3, 16]) r kernel_size Size1 | Nonestride _PaddingSizeMode | Size1 | Size2paddingbool exclusive ceil_mode str | Nonenamecj>[TU]5 XlX lX0lXPlX@lX`lgN)super__init__rrrr rr")selfrrrrr r" __class__s W/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/nn/layer/pooling.pyr&AvgPool1D.__init__rs/ &  "" c [R"UURURURUR UR UR5nU$r$)F avg_pool1drrrrr r"r'xouts r)forwardAvgPool1D.forwardsFll    KK LL NN NN II  r+c:SR"S0URD6$Nz=kernel_size={kernel_size}, stride={stride}, padding={padding}format__dict__r's r) extra_reprAvgPool1D.extra_repr!NUU mm  r+)r rrr"rr)NrTFN)rrrrrrrrr rr"r!returnNoner0r r>r r>str __name__ __module__ __qualname____firstlineno____doc____annotations__r&r2r;__static_attributes__ __classcell__r(s@r)rr1s7r  --OO  $452      "   r+rc^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S 'S\S'S\S'SSU4SjjjrSrSSjrSr U=r $) AvgPool2Da This operation applies 2D average pooling over input features based on the input, and kernel_size, stride, padding parameters. Input(X) and Output(Out) are in NCHW format, 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. Example: Input: X shape: :math:`(N, C, :math:`H_{in}`, :math:`W_{in}`)` Attr: kernel_size: ksize Output: Out shape: :math:`(N, C, :math:`H_{out}`, :math:`W_{out}`)` .. math:: Output(N_i, C_j, h, w) = \frac{\sum_{m=0}^{ksize[0]-1} \sum_{n=0}^{ksize[1]-1} Input(N_i, C_j, stride[0] \times h + m, stride[1] \times w + n)}{ksize[0] * ksize[1]} Parameters: kernel_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. stride(int|list|tuple|None, optional): 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. Default None, then stride will be equal to the kernel_size. padding(str|int|list|tuple, optional): 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, optional): When True, will use `ceil` instead of `floor` to compute the output shape. exclusive(bool, optional): Whether to exclude padding points in average pooling mode, default is `true`. divisor_override(float, optional): If specified, it will be used as divisor, otherwise kernel_size will be used. Default None. data_format(str, optional): 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|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Shape: - x(Tensor): The input tensor of avg pool2d operator, which is a 4-D tensor. The data type can be float32, float64. - output(Tensor): The output tensor of avg pool2d operator, which is a 4-D tensor. The data type is same as input x. Returns: A callable object of AvgPool2D. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn as nn >>> # max pool2d >>> input = paddle.uniform([1, 3, 32, 32], dtype="float32", min=-1, max=1) >>> AvgPool2D = nn.AvgPool2D(kernel_size=2, stride=2, padding=0) >>> output = AvgPool2D(input) >>> print(output.shape) paddle.Size([1, 3, 16, 16]) rr Size2 | Noner _PaddingSizeMode | Size2 | Size4rrr r float | Nonedivisorr data_formatr!r"c >[T U]5 XlX lX0lX@lXPlX`lXplXl gr$ r%r&ksizerrr rrSrTr" r'rrrr rdivisor_overriderTr"r(s r)r&AvgPool2D.__init__9    ""' & r+c [R"UURURURUR UR URURURS9 $N)rrrr rrYrTr") r- avg_pool2drWrrr rrSrTr"r'r0s r)r2AvgPool2D.forwardP||  ;;LLnnnn!\\((  r+c:SR"S0URD6$Nz7kernel_size={ksize}, stride={stride}, padding={padding}r6r7r:s r)r;AvgPool2D.extra_repr!HOO mm  r+r rTrSrrWr"rr)NrFTNNCHWN)rrrrPrrQr rrrrYrRrTrr"r!r>r?rArCrLs@r)rNrNsEN  --OO   $45)-$*2     '" *    r+rNc^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S 'S\S'S\S'SSU4SjjjrSSjrSSjrSr U=r $) AvgPool3Dia This operation applies 3D max pooling over input features based on the input, and kernel_size, stride, padding parameters. Input(X) and Output(Out) are in NCDHW format, where N is batch size, C is the number of channels, H is the height of the feature, D is the depth of the feature, and W is the width of the feature. Parameters: 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|None, optional): 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. Default None, then stride will be equal to the kernel_size. padding(str|int|list|tuple, optional): 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, optional): ${ceil_mode_comment} exclusive(bool, optional): Whether to exclude padding points in average pooling mode, default is True. divisor_override(int|float, optional): if specified, it will be used as divisor, otherwise kernel_size will be used. Default None. data_format(str, optional): 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|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Returns: A callable object of AvgPool3D. Shape: - x(Tensor): The input tensor of avg pool3d operator, which is a 5-D tensor. The data type can be float16, float32, float64. - output(Tensor): The output tensor of avg pool3d operator, which is a 5-D tensor. The data type is same as input x. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn as nn >>> # avg pool3d >>> input = paddle.uniform([1, 2, 3, 32, 32], dtype="float32", min=-1, max=1) >>> AvgPool3D = nn.AvgPool3D(kernel_size=2, stride=2, padding=0) >>> output = AvgPool3D(input) >>> print(output.shape) paddle.Size([1, 2, 1, 16, 16]) rr Size3 | Noner _PaddingSizeMode | Size3 | Size6rrr rrRrSrrTr!r"c >[T U]5 XlX lX0lX@lXPlX`lXplXl gr$rVrXs r)r&AvgPool3D.__init__Tr[r+c [R"UURURURUR UR URURURS9 $r]) r- avg_pool3drWrrr rrSrTr"r_s r)r2AvgPool3D.forwardirar+c:SR"S0URD6$rcr7r:s r)r;AvgPool3D.extra_reprvrer+rf)NrFTNNCDHWN)rrrrjrrkr rrrrYrRrTrr"r!r>r?r@rArCrLs@r)riris:x  --OO   $45)-$+2     '" *    r+ric^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S'S\S'\SSU4Sjjj5r\"SS/5SSj5r SSjr Sr U=r $)LPPool1Di|a Performing a 1D power-average pooling over an input signal composed of several input planes, based on the input, output_size, return_mask parameters. Input(X) and output(Out) are in NCL format, where N is batch size, C is the number of channels, L is the length of the feature. The output tensor shape will be [N, C, output_size]. The output value of the layer with input size (N, C, L), output (N, C, :math:`L_{out}`) and kernel_size ksize can be precisely described as For average pool1d: .. math:: Output(N_i, C_i, l) = sum(Input[N_i, C_i, stride \times l:stride \times l+k]^{norm\_type})^{1/norm\_type} Parameters: norm_type(int|float): The number the power operation. 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|None, optional): The pool stride size. If pool stride size is a tuple or list, it must contain an integer. Default None, then stride will be equal to the kernel_size. padding(str|int|list|tuple, optional): 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. ceil_mode(bool, optional): When True, it will use `ceil` instead of `floor` to compute the output shape. Default: False. data_format(str, optional): The data format of the input and output data. An optional string from: `"NCL"`, `"NLC"`. When it is `"NCL"`, the data is stored in the order of: `[batch_size, input_channels, input_length]`. Default: "NCL" name(str|None, optional): For eed to detailed information, please refer to :ref:`api_guide_Name`. Usually name is no nset and None by default. Shape: - x(Tensor): The input tensor of lp pool1d operator, which is a 3-D tensor. The data type can be float32, float64. - output(Tensor): The output tensor of lp pool1d operator, which is a 3-D tensor. The data type is same as input x. Returns: A callable object of LPPool1D. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn as nn >>> data = paddle.uniform([1, 3, 32], dtype="float32", min=-1, max=1) >>> LPPool1D = nn.LPPool1D(norm_type=2, kernel_size=2, stride=2, padding=0) >>> pool_out = LPPool1D(data) >>> print(pool_out.shape) paddle.Size([1, 3, 16]) float norm_typerrrrrrrr r rTr!r"c>[TU]5 [U5UlX lX0lX@lXPlX`lXpl gr$) r%r&rvrwrrrr rTr" r'rwrrrr rTr"r(s r)r&LPPool1D.__init__s< y)&  "& r+r0inputc [R"UURURURUR UR URUR5nU$r$) r- lp_pool1drwrrrr rTr"r/s r)r2LPPool1D.forwardsOkk NN    KK LL NN    II   r+c:SR"S0URD6$)NzTnorm_type={norm_type}, kernel_size={kernel_size}, stride={stride}, padding={padding}r6r7r:s r)r;LPPool1D.extra_reprs!ell mm  r+)r rTrr"rwrr)NrFNCLN)rwrvrrrrrrr rrTr r"r!r>r?r@rA rDrErFrGrHrIrr&rr2r;rJrKrLs@r)ruru|s9v  --O  $45$)  2   " &c7^$ %   r+ruc^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S'S\S'\SSU4Sjjj5r\"SS/5SSj5r SSjr Sr U=r $)LPPool2Dia7 Performing 2D power-average pooling over input features based on the input, and kernel_size, stride, padding parameters. Input(X) and Output(Out) are in NCHW format, 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. Example: Input: X shape: :math:`(N, C, H_{in}, W_{in})` Attr: - kernel_size: kernel_size - norm_type: norm_type Output: Out shape: :math:`(N, C, H_{out}, W_{out})` .. math:: Output(N_i, C_j, h, w) = (\sum_{m=0}^{ksize[0]-1} \sum_{n=0}^{ksize[1]-1} Input(N_i, C_j, stride[0] \times h + m, stride[1] \times w + n)^{norm\_type})^{1 / norm\_type} Parameters: norm_type(int|float): The number the power operation. kernel_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. stride(int|list|tuple, optional): 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. Default None, then stride will be equal to the kernel_size. padding(str|int|list|tuple, optional): 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, optional): When True, it will use `ceil` instead of `floor` to compute the output shape. Default: False. data_format(str, optional): The data format of the input and output data. An optional string from: `"NCHW"`, `"NHWC"`. When it is `"NCHW"`, the data is stored in the order of: `[batch_size, input_channels, input_height, input_width]`. Default: "NCHW". name(str, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Shape: - x(Tensor): The input tensor of lp pool2d operator, which is a 4-D tensor. The data type can be float32, float64. - output(Tensor): The output tensor of lp pool2d operator, which is a 4-D tensor. The data type is same as input x. Returns: A callable object of LPPool2D. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn as nn >>> # lp pool2d >>> input = paddle.uniform([1, 3, 32, 32], dtype="float32", min=-1, max=1) >>> LPPool2D = nn.LPPool2D(norm_type=2, kernel_size=2, stride=2, padding=0) >>> output = LPPool2D(input) >>> print(output.shape) paddle.Size([1, 3, 16, 16]) rvrwrrrPrrQrrr rrTr!r"c>[TU]5 [U5UlX lUcUOUUlX@lXPlX`lXpl gr$) r%r&rvrwrWrrr rTr"rys r)r&LPPool2D.__init__5sC y) %+^k  "& r+r0r{c [R"UURURURUR UR URURS9$)N)rwrrrr rTr") r- lp_pool2drwrWrrr rTr"r_s r)r2LPPool2D.forwardIsI{{ nn ;;LLnn((  r+c:SR"S0URD6$)NzNnorm_type={norm_type}, kernel_size={ksize}, stride={stride}, padding={padding}r6r7r:s r)r;LPPool2D.extra_reprVs!_ff mm  r+)r rTrWr"rwrr)NrFrgN)rwrvrrrrPrrQr rrTrr"r!r>r?r@rArrLs@r)rrsBH  --O  $45$*  2   " &c7^$  %    r+rc^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S 'SSU4SjjjrSSjrSSjrSr U=r $) MaxPool1Di\a This operation applies 1D max pooling over input signal composed of several input planes based on the input, and kernel_size, stride, padding parameters. Input(X) and Output(Out) are in NCL format, where N is batch size, C is the number of channels, L is the length of the feature. The output value of the layer with input size (N, C, L), output (N, C, L_{out}) and kernel_size k can be precisely described as For average pool1d: .. math:: Output(N_i, C_i, l) = max(Input[N_i, C_i, stride imes l:stride imes l+k]) Parameters: 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|None, optional): The pool stride size. If pool stride size is a tuple or list, it must contain an integer. Default None, then stride will be equal to the kernel_size. padding(str|int|list|tuple, optional): 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, optional): Whether return the max indices along with the outputs. default is `False`. ceil_mode(bool, optional): 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|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Returns: A callable object of MaxPool1D. Shape: - x(Tensor): The input tensor of max pool1d operator, which is a 3-D tensor. The data type can be float32, float64. - output(Tensor): The output tensor of max pool1d operator, which is a 3-D tensor. The data type is same as input x. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn as nn >>> data = paddle.uniform([1, 3, 32], dtype="float32", min=-1, max=1) >>> MaxPool1D = nn.MaxPool1D(kernel_size=2, stride=2, padding=0) >>> pool_out = MaxPool1D(data) >>> print(pool_out.shape) paddle.Size([1, 3, 16]) >>> MaxPool1D = nn.MaxPool1D(kernel_size=2, stride=2, padding=0, return_mask=True) >>> pool_out, indices = MaxPool1D(data) >>> print(pool_out.shape) paddle.Size([1, 3, 16]) >>> print(indices.shape) paddle.Size([1, 3, 16]) rrrrrrr return_maskr r!r"cj>[TU]5 XlX lX0lXPlX@lX`lgr$)r%r&rrrr rr")r'rrrrr r"r(s r)r&MaxPool1D.__init__s0 &  "& r+c [R"UURURURUR UR UR5nU$r$)r- max_pool1drrrrr r")r'r{r1s r)r2MaxPool1D.forwardsHll     KK LL    NN II  r+c:SR"S0URD6$r5r7r:s r)r;MaxPool1D.extra_reprr=r+)r rr"rrr)NrFFN)rrrrrrrrr rr"r!r>r?r{r r>r rArCrLs@r)rr\s=~  --O  $45!2      "   r+rc^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S 'S\S'SSU4SjjjrSSjrSSjrSr U=r $) MaxPool2DiaN This operation applies 2D max pooling over input feature based on the input, and kernel_size, stride, padding parameters. Input(X) and Output(Out) are in NCHW format, 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. Example: - Input: X shape: :math:`(N, C, H_{in}, W_{in})` - Attr: kernel_size: ksize - Output: Out shape: :math:`(N, C, H_{out}, W_{out})` .. math:: Output(N_i, C_j, h, w) = \max_{m=0, \ldots, ksize[0] -1} \max_{n=0, \ldots, ksize[1]-1} Input(N_i, C_j, stride[0] \times h + m, stride[1] \times w + n) Parameters: kernel_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. stride(int|list|tuple|None, optional): 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. Default None, then stride will be equal to the kernel_size. padding(str|int|list|tuple, optional): 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, optional): when True, will use `ceil` instead of `floor` to compute the output shape return_mask(bool, optional): Whether to return the max indices along with the outputs. data_format(str, optional): 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|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Returns: A callable object of MaxPool2D. Shape: - x(Tensor): The input tensor of max pool2d operator, which is a 4-D tensor. The data type can be float32, float64. - output(Tensor): The output tensor of max pool2d operator, which is a 4-D tensor. The data type is same as input x. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn as nn >>> # max pool2d >>> input = paddle.uniform([1, 3, 32, 32], dtype="float32", min=-1, max=1) >>> MaxPool2D = nn.MaxPool2D(kernel_size=2, stride=2, padding=0) >>> output = MaxPool2D(input) >>> print(output.shape) paddle.Size([1, 3, 16, 16]) >>> # for return_mask=True >>> MaxPool2D = nn.MaxPool2D(kernel_size=2, stride=2, padding=0, return_mask=True) >>> output, max_indices = MaxPool2D(input) >>> print(output.shape) paddle.Size([1, 3, 16, 16]) >>> print(max_indices.shape) paddle.Size([1, 3, 16, 16]) rrrPrrQrrrr rrTr!r"cv>[TU]5 XlX lX0lX@lXPlX`lXplgr$ r%r&rWrrrr rTr" r'rrrrr rTr"r(s r)r&MaxPool2D.__init__5    &"& r+c [R"UURURURUR UR URURS9$N)rrrrr rTr") r- max_pool2drWrrrr rTr"r_s r)r2MaxPool2D.forward,K||  ;;LL((nn((  r+c:SR"S0URD6$rcr7r:s r)r;MaxPool2D.extra_repr8rer+r rTrWr"rrr)NrFFrgN)rrrrPrrQrrr rrTrr"r!r>r?r@rArCrLs@r)rrsHT  --O  $45!$*2     " &    r+rc^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S 'S\S'SSU4SjjjrSSjrSSjrSr U=r $) MaxPool3Di>a: This operation applies 3D max pooling over input features based on the input, and kernel_size, stride, padding parameters. Input(X) and Output(Out) are in NCDHW format, where N is batch size, C is the number of channels, H is the height of the feature, D is the depth of the feature, and W is the width of the feature. Parameters: 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|None, optional): 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. Default None, then stride will be equal to the kernel_size. padding(str|int|list|tuple, optional): 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 . [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, optional): ${ceil_mode_comment} return_mask(bool, optional): Whether to return the max indices along with the outputs. data_format(str, optional): 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|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Returns: A callable object of MaxPool3D. Shape: - x(Tensor): The input tensor of max pool3d operator, which is a 5-D tensor. The data type can be float32, float64. - output(Tensor): The output tensor of max pool3d operator, which is a 5-D tensor. The data type is same as input x. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn as nn >>> # max pool3d >>> input = paddle.uniform([1, 2, 3, 32, 32], dtype="float32", min=-1, max=1) >>> MaxPool3D = nn.MaxPool3D(kernel_size=2, stride=2, padding=0) >>> output = MaxPool3D(input) >>> print(output.shape) paddle.Size([1, 2, 1, 16, 16]) >>> # for return_mask=True >>> MaxPool3D = nn.MaxPool3D(kernel_size=2, stride=2, padding=0, return_mask=True) >>> output, max_indices = MaxPool3D(input) >>> print(output.shape) paddle.Size([1, 2, 1, 16, 16]) >>> print(max_indices.shape) paddle.Size([1, 2, 1, 16, 16]) rrrjrrkrrrr rrTr!r"cv>[TU]5 XlX lX0lX@lXPlX`lXplgr$rrs r)r&MaxPool3D.__init__rr+c [R"UURURURUR UR URURS9$r) r- max_pool3drWrrrr rTr"r_s r)r2MaxPool3D.forwardrr+c:SR"S0URD6$rcr7r:s r)r;MaxPool3D.extra_reprrer+r)NrFFrsN)rrrrjrrkrrr rrTrr"r!r>r?r@rArCrLs@r)rr>s<|  --O  $45!$+2     " &    r+rc^^\rSrSr%SrS\S'S\S'S S U4SjjjrS SjrSS jrS r U=r $)AdaptiveAvgPool1Dia A 1D adaptive average pooling over an input signal composed of several input planes, based on :attr:`output_size`. Input and output are in NCL format, where N is batch size, C is the number of channels and L is the length of the feature. The shape of output will be :math:`[N, C, output\_size]`. The formulation for average adaptive pool1d is .. math:: lstart &= \lfloor i * L_{in} / L_{out}\rfloor, lend &= \lceil(i + 1) * L_{in} / L_{out}\rceil, Output(i) &= \frac{\sum Input[lstart:lend]}{lend - lstart}. Parameters: output_size(int): The target output size. Its data type must be int. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: A callable object for computing 1D adaptive average pooling. Examples: .. code-block:: pycon >>> # 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])/(lend - lstart) >>> # >>> import paddle >>> import paddle.nn as nn >>> data = paddle.uniform([1, 3, 32], dtype="float32", min=-1, max=1) >>> AdaptiveAvgPool1D = nn.AdaptiveAvgPool1D(output_size=16) >>> pool_out = AdaptiveAvgPool1D(data) >>> print(pool_out.shape) paddle.Size([1, 3, 16]) int output_sizer!r"c:>[TU]5 XlX lgr$)r%r&rr")r'rr"r(s r)r&AdaptiveAvgPool1D.__init__s & r+cX[R"XRUR5$r$)r-adaptive_avg_pool1drr"r'r{s r)r2AdaptiveAvgPool1D.forwards$$U,<,r?rrArCrLs@r)rrs10d  I11r+rc^\rSrSrSrS S U4Sjjjr\"SS/5S Sj5rSSjr\ SSj5r \ RSS j5r S r U=r $)AdaptiveAvgPool2Dia This operation applies 2D adaptive avg pooling on input tensor. The h and w dimensions of the output tensor are determined by the parameter output_size. For avg adaptive pool2d: .. math:: hstart &= floor(i * H_{in} / H_{out}) hend &= ceil((i + 1) * H_{in} / H_{out}) wstart &= floor(j * W_{in} / W_{out}) wend &= ceil((j + 1) * W_{in} / W_{out}) Output(i ,j) &= \frac{\sum Input[hstart:hend, wstart:wend]}{(hend - hstart) * (wend - wstart)} Parameters: 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, optional): 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|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Shape: - x(Tensor): The input tensor of adaptive avg pool2d operator, which is a 4-D tensor. The data type can be float32, float64. - output(Tensor): The output tensor of adaptive avg pool2d operator, which is a 4-D tensor. The data type is same as input x. Returns: A callable object of AdaptiveAvgPool2D. Examples: .. code-block:: pycon >>> # 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 >>> x = paddle.rand([2, 3, 32, 32]) >>> adaptive_avg_pool = paddle.nn.AdaptiveAvgPool2D(output_size=3) >>> pool_out = adaptive_avg_pool(x=x) >>> print(pool_out.shape) paddle.Size([2, 3, 3, 3]) cF>[TU]5 XlX lX0lgr$r%r& _output_size _data_format_namer'rrTr"r(s r)r&AdaptiveAvgPool2D.__init__0! '' r+r0r{cl[R"UURURURS9$N)rrTr")r-adaptive_avg_pool2drrrr_s r)r2AdaptiveAvgPool2D.forward;1$$ ))))   r+c SUR3$rrr:s r)r;AdaptiveAvgPool2D.extra_reprDd//011r+cUR$r$rr:s r)rAdaptiveAvgPool2D.output_sizeG   r+cXlgr$rr'values r)rrK!r+rrr)rgN)rrrTrr"r!r>r?r@rA)r>r)rrr>r?rDrErFrGrHr&rr2r;propertyrsetterrJrKrLs@r)rrsAL%+  "     c7^$ % 2!!""r+rc^\rSrSrSrS S U4Sjjjr\"SS/5S Sj5rSSjr\ SSj5r \ RSS j5r S r U=r $)AdaptiveAvgPool3DiPa This operation applies 3D adaptive avg pooling on input tensor. The h and w dimensions of the output tensor are determined by the parameter output_size. For avg adaptive pool3d: .. math:: dstart &= floor(i * D_{in} / D_{out}) dend &= ceil((i + 1) * D_{in} / D_{out}) hstart &= floor(j * H_{in} / H_{out}) hend &= ceil((j + 1) * H_{in} / H_{out}) wstart &= floor(k * W_{in} / W_{out}) wend &= ceil((k + 1) * W_{in} / W_{out}) Output(i ,j, k) &= \frac{\sum Input[dstart:dend, hstart:hend, wstart:wend]} {(dend - dstart) * (hend - hstart) * (wend - wstart)} Parameters: 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, optional): 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|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Shape: - x(Tensor): The input tensor of adaptive avg pool3d operator, which is a 5-D tensor. The data type can be float32, float64\. - output(Tensor): The output tensor of adaptive avg pool3d operator, which is a 5-D tensor. The data type is same as input x. Returns: A callable object of AdaptiveAvgPool3D. Examples: .. code-block:: pycon >>> # 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 >>> x = paddle.rand([2, 3, 8, 32, 32]) >>> adaptive_avg_pool = paddle.nn.AdaptiveAvgPool3D(output_size=3) >>> pool_out = adaptive_avg_pool(x=x) >>> print(pool_out.shape) paddle.Size([2, 3, 3, 3, 3]) cF>[TU]5 XlX lX0lgr$rrs r)r&AdaptiveAvgPool3D.__init__rr+r0r{cl[R"UURURURS9$r)r-adaptive_avg_pool3drrrr_s r)r2AdaptiveAvgPool3D.forwardrr+c SUR3$rrr:s r)r;AdaptiveAvgPool3D.extra_reprrr+cUR$r$rr:s r)rAdaptiveAvgPool3D.output_sizerr+cXlgr$rrs r)rrrr+r)rsN)rrrTrr"r!r>r?r@rA)r>r)rrr>r?rrLs@r)rrPsHZ%,  "     c7^$ % 2!!""r+rc^\rSrSr%SrS\S'S\S'S\S'\"SS /5SSU4S jjj5rSS jrSS jr \ SS j5r \ RSSj5r Sr U=r$)AdaptiveMaxPool1Dia This operation applies a 1D adaptive max pooling over an input signal composed of several input planes, based on the input, output_size, return_mask parameters. Input(X) and output(Out) are in NCL format, where N is batch size, C is the number of channels, L is the length of the feature. The output tensor shape will be [N, C, output_size]. For max adaptive pool1d: .. math:: lstart &= floor(i * L_{in} / L_{out}) lend &= ceil((i + 1) * L_{in} / L_{out}) Output(i) &= max(Input[lstart:lend]) Parameters: output_size(int|list|tuple): The pool kernel size. It can be an integer, or a list or tuple containing a single integer. return_mask(bool, optional): 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|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Returns: A callable object of AdaptiveMaxPool1D. Shape: - x(Tensor): The input tensor of adaptive max pool1d operator, which is a 3-D tensor. The data type can be float32, float64. - output(Tensor): The output tensor of adaptive max pool1d operator, which is a 3-D tensor. The data type is same as input x. Examples: .. code-block:: pycon >>> # 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 as nn >>> data = paddle.uniform([1, 3, 32], dtype="float32", min=-1, max=1) >>> AdaptiveMaxPool1D = nn.AdaptiveMaxPool1D(output_size=16) >>> pool_out = AdaptiveMaxPool1D(data) >>> print(pool_out.shape) paddle.Size([1, 3, 16]) >>> # for return_mask = true >>> AdaptiveMaxPool1D = nn.AdaptiveMaxPool1D(output_size=16, return_mask=True) >>> pool_out, indices = AdaptiveMaxPool1D(data) >>> print(pool_out.shape) paddle.Size([1, 3, 16]) >>> print(indices.shape) paddle.Size([1, 3, 16]) rrrrr!r"return_indicescF>[TU]5 XlX lX0lgr$)r%r&rrr"r'rrr"r(s r)r&AdaptiveMaxPool1D.__init__s! && r+cn[R"XRURUR5$r$)r-adaptive_max_pool1drrr"rs r)r2AdaptiveMaxPool1D.forwards,$$ ##T%5%5tyy  r+c:SURSUR3$Nrz, return_mask=)rrr:s r)r;AdaptiveMaxPool1D.extra_reprs#d../~d>N>N=OPPr+cUR$r$rr:s r)r AdaptiveMaxPool1D.return_indicessr+cXlgr$rrs r)rrs r+)r"rrFN)rrrrr"r!r>r?rrAr>rrrr>r?)rDrErFrGrHrIrr&r2r;rrrrJrKrLs@r)rrsAF m%567"      8  Q  !!r+rc^\rSrSrSr\"SS/5S SU4Sjjj5r\"SS/5SSj5rSS jr\ SS j5r \ RSS j5r S r U=r $)AdaptiveMaxPool2Di aH This operation applies 2D adaptive max pooling on input tensor. The h and w dimensions of the output tensor are determined by the parameter output_size. The difference between adaptive pooling and pooling is adaptive one focus on the output size. For adaptive max pool2d: .. math:: hstart &= floor(i * H_{in} / H_{out}) hend &= ceil((i + 1) * H_{in} / H_{out}) wstart &= floor(j * W_{in} / W_{out}) wend &= ceil((j + 1) * W_{in} / W_{out}) Output(i ,j) &= max(Input[hstart:hend, wstart:wend]) Parameters: 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. return_mask(bool, optional): 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|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Shape: - x(Tensor): The input tensor of adaptive max pool2d operator, which is a 4-D tensor. The data type can be float32, float64. - output(Tensor): The output tensor of adaptive max pool2d operator, which is a 4-D tensor. The data type is same as input x. Returns: A callable object of AdaptiveMaxPool2D. Examples: .. code-block:: pycon >>> # adaptive max 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 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 >>> x = paddle.rand([2, 3, 32, 32]) >>> adaptive_max_pool = paddle.nn.AdaptiveMaxPool2D(output_size=3, return_mask=True) >>> pool_out, indices = adaptive_max_pool(x=x) >>> print(pool_out.shape) paddle.Size([2, 3, 3, 3]) >>> print(indices.shape) paddle.Size([2, 3, 3, 3]) rrcF>[TU]5 XlX lX0lgr$r%r&r _return_maskrrs r)r&AdaptiveMaxPool2D.__init__b! '' r+r0r{cl[R"UURURURS9$N)rrr")r-adaptive_max_pool2drrrr_s r)r2AdaptiveMaxPool2D.forwardnrr+c:SURSUR3$rrrr:s r)r;AdaptiveMaxPool2D.extra_reprw%4,,-^Dr?r@rArrrDrErFrGrHrr&r2r;rrrrJrKrLs@r)rr s?Bm%567"      8 c7^$ %  !!""r+rc^\rSrSrSr\"SS/5S SU4Sjjj5r\"SS/5SSj5rSS jr\ SS j5r \ RSS j5r S r U=r $)AdaptiveMaxPool3Dia This operation applies 3D adaptive max pooling on input tensor. The h and w dimensions of the output tensor are determined by the parameter output_size. The difference between adaptive pooling and pooling is adaptive one focus on the output size. For adaptive max pool3d: .. math:: dstart &= floor(i * D_{in} / D_{out}) dend &= ceil((i + 1) * D_{in} / D_{out}) hstart &= floor(j * H_{in} / H_{out}) hend &= ceil((j + 1) * H_{in} / H_{out}) wstart &= floor(k * W_{in} / W_{out}) wend &= ceil((k + 1) * W_{in} / W_{out}) Output(i ,j, k) &= max(Input[dstart:dend, hstart:hend, wstart:wend]) Parameters: 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, optional): If true, the index of max pooling point will be returned along with outputs. Default False. name(str|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Shape: - x(Tensor): The input tensor of adaptive max pool3d operator, which is a 5-D tensor. The data type can be float32, float64. - output(Tensor): The output tensor of adaptive max pool3d operator, which is a 5-D tensor. The data type is same as input x. Returns: A callable object of AdaptiveMaxPool3D. Examples: .. code-block:: pycon >>> # adaptive max 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 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(j * H / m) >>> # hend = ceil((j + 1) * H / m) >>> # wstart = floor(k * W / n) >>> # wend = ceil((k + 1) * W / n) >>> # output[:, :, i, j, k] = >>> # max(input[:, :, dstart:dend, hstart: hend, wstart: wend]) >>> import paddle >>> x = paddle.rand([2, 3, 8, 32, 32]) >>> pool = paddle.nn.AdaptiveMaxPool3D(output_size=4) >>> out = pool(x) >>> print(out.shape) paddle.Size([2, 3, 4, 4, 4]) >>> pool = paddle.nn.AdaptiveMaxPool3D(output_size=3, return_mask=True) >>> out, indices = pool(x) >>> print(out.shape) paddle.Size([2, 3, 3, 3, 3]) >>> print(indices.shape) paddle.Size([2, 3, 3, 3, 3]) rrcF>[TU]5 XlX lX0lgr$rrs r)r&AdaptiveMaxPool3D.__init__rr+r0r{cl[R"UURURURS9$r)r-adaptive_max_pool3drrrr_s r)r2AdaptiveMaxPool3D.forwardrr+c:SURSUR3$rrr:s r)r;AdaptiveMaxPool3D.extra_reprr r+cUR$r$r r:s r)r AdaptiveMaxPool3D.return_indicesrr+cXlgr$r rs r)rrrr+rr)rrrrr"r!r>r?r@rArrrrLs@r)rrsJXm%567"      8 c7^$ %  !!""r+rc^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S'SSU4Sjjjr\"SS/5SSSjj5rSSjr Sr U=r $) MaxUnPool1Dia1 This API implements max unpooling 1d operation. `max_unpool1d` accepts the output of `max_pool1d` as input, including the indices of the maximum value and calculate the partial inverse. All non-maximum values are set to zero. - Input: :math:`(N, C, L_{in})` - Output: :math:`(N, C, L_{out})`, where .. math:: L_{out} = (L_{in} - 1) * stride - 2 * padding + kernel\_size or as given by :attr:`output_size` in the call operator. Parameters: kernel_size (int|list|tuple): The unpool kernel size. If unpool kernel size is a tuple or list, it must contain an integer. stride (int|list|tuple): The unpool stride size. If unpool stride size is a tuple or list, it must contain an integer. padding (int | tuple): Padding that was added to the input. output_size(list|tuple, optional): The target output size. If output_size is not specified, the actual output shape will be automatically calculated by (input_shape, kernel_size, stride, padding). data_format (string): The data format of the input and output data. The default is `"NCL"`. When it is `"NCL"`, the data is stored in the order of: `[batch_size, input_channels, input_length]`. name(str|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Returns: A callable object of MaxUnPool1D. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn.functional as F >>> data = paddle.rand(shape=[1, 3, 16]) >>> pool_out, indices = F.max_pool1d(data, kernel_size=2, stride=2, padding=0, return_mask=True) >>> print(pool_out.shape) paddle.Size([1, 3, 8]) >>> print(indices.shape) paddle.Size([1, 3, 8]) >>> Unpool1D = paddle.nn.MaxUnPool1D(kernel_size=2, padding=0) >>> unpool_out = Unpool1D(pool_out, indices) >>> print(unpool_out.shape) paddle.Size([1, 3, 16]) rrrrrrr rTSequence[int] | Nonerr!r"cj>[TU]5 XlX lX0lX@lXPlX`lgr$r%r&rWrrrTrr"r'rrrrTrr"r(s r)r&MaxUnPool1D.__init__30    && r+r0r{c U(a[R"SSS9 UnO URn[R"UUUR UR URURUURS9$Nzsoutput_size in forward overrides output_size in __init__. The output_size parameter in forward has higher priority.r) stacklevel)rrrrTrr") warningswarnrr- max_unpool1drWrrrTr"r'r0indicesrvalid_output_sizes r)r2MaxUnPool1D.forwardDo  MML  !,  $ 0 0 ~~  ;;LL(()  r+c SUR3$rrr:s r)r;MaxUnPool1D.extra_repr_rr+rTrWr"rrr)NrrNN)rrrrrrrTr rrr"r!r>r?r$r0r r,r rrr>r rA rDrErFrGrHrIr&rr2r;rJrKrLs@r)rrs4l  --%%  $45$),02  "  *  "c7^$ -1    *    % 411r+rc^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S'SSU4Sjjjr\"SS/5SSSjj5rSSjr Sr U=r $) MaxUnPool2DicaC This API implements max unpooling 2d operation. 'max_unpool2d' accepts the output of 'max_unpool2d' as input Including the indices of the maximum value and calculating the partial inverse All non-maximum values are set to zero. Parameters: kernel_size (int|list|tuple): The unpool kernel size. If unpool kernel size is a tuple or list, it must contain an integer. stride (int|list|tuple): The unpool stride size. If unpool stride size is a tuple or list, it must contain an integer. kernel_size (int|tuple): Size of the max unpooling window. padding (int|tuple): Padding that was added to the input. output_size(list|tuple, optional): The target output size. If output_size is not specified, the actual output shape will be automatically calculated by (input_shape, kernel_size, padding). data_format (string): The data format of the input and output data. The default is `"NCL"`. When it is `"NCL"`, the data is stored in the order of: `[batch_size, input_channels, input_length]`. name(str|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. - Input: :math:`(N, C, H_{in}, W_{in})` - Output: :math:`(N, C, H_{out}, W_{out})`, where .. math:: H_{out} = (H_{in} - 1) \times \text{stride[0]} - 2 \times \text{padding[0]} + \text{kernel\_size[0]} .. math:: W_{out} = (W_{in} - 1) \times \text{stride[1]} - 2 \times \text{padding[1]} + \text{kernel\_size[1]} or as given by :attr:`output_size` in the call operator Returns: A callable object of MaxUnPool2D. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn.functional as F >>> data = paddle.rand(shape=[1, 1, 6, 6]) >>> pool_out, indices = F.max_pool2d(data, kernel_size=2, stride=2, padding=0, return_mask=True) >>> print(pool_out.shape) paddle.Size([1, 1, 3, 3]) >>> print(indices.shape) paddle.Size([1, 1, 3, 3]) >>> Unpool2D = paddle.nn.MaxUnPool2D(kernel_size=2, padding=0) >>> unpool_out = Unpool2D(pool_out, indices) >>> print(unpool_out.shape) paddle.Size([1, 1, 6, 6]) rrrPrrQrrrTrrr!r"cj>[TU]5 XlX lX0lX@lXPlX`lgr$r!r"s r)r&MaxUnPool2D.__init__r$r+r0r{c U(a[R"SSS9 UnO URn[R"UUUR UR URURUURS9$r&) r(r)rr- max_unpool2drWrrrTr"r+s r)r2MaxUnPool2D.forwardso  MML  !,  $ 0 0 ~~  ;;LL(()  r+c SUR3$rrr:s r)r;MaxUnPool2D.extra_reprrr+r2)NrrgNN)rrrrPrrQrTrrrr"r!r>r?r$r3rAr4rLs@r)r6r6cs;z  --%%  $45$*,02  "  *  "c7^$ -1    *    % 611r+r6c^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S'SSU4Sjjjr\"SS/5SSSjj5rSSjr Sr U=r $) MaxUnPool3Dia? This API implements max unpooling 3d operation. `max_unpool3d` accepts the output of `max_pool3d` as input, including the indices of the maximum value and calculate the partial inverse. All non-maximum values are set to zero. - Input: :math:`(N, C, D_{in}, H_{in}, W_{in})` - Output: :math:`(N, C, D_{out}, H_{out}, W_{out})`, where .. math:: D_{out} = (D_{in} - 1) * stride[0] - 2 * padding[0] + kernel\_size[0] .. math:: H_{out} = (H_{in} - 1) * stride[1] - 2 * padding[1] + kernel\_size[1] .. math:: W_{out} = (W_{in} - 1) * stride[2] - 2 * padding[2] + kernel\_size[2] or as given by :attr:`output_size` in the call operator Parameters: kernel_size (int|list|tuple): The unpool kernel size. If unpool kernel size is a tuple or list, it must contain an integer. stride (int|list|tuple|None): The unpool stride size. If unpool stride size is a tuple or list, it must contain an integer. padding (int | tuple): Padding that was added to the input. output_size(list|tuple, optional): The target output size. If output_size is not specified, the actual output shape will be automatically calculated by (input_shape, kernel_size, stride, padding). data_format (string): The data format of the input and output data. 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|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Returns: A callable object of MaxUnPool3D. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn.functional as F >>> data = paddle.rand(shape=[1, 1, 4, 4, 6]) >>> pool_out, indices = F.max_pool3d(data, kernel_size=2, stride=2, padding=0, return_mask=True) >>> print(pool_out.shape) paddle.Size([1, 1, 2, 2, 3]) >>> print(indices.shape) paddle.Size([1, 1, 2, 2, 3]) >>> Unpool3D = paddle.nn.MaxUnPool3D(kernel_size=2, padding=0) >>> unpool_out = Unpool3D(pool_out, indices) >>> print(unpool_out.shape) paddle.Size([1, 1, 4, 4, 6]) rrrjrrkrrrTrrr!r"cj>[TU]5 XlX lX0lX@lXPlX`lgr$r!r"s r)r&MaxUnPool3D.__init__r$r+r0r{c U(a[R"SSS9 UnO URn[R"UUUR UR URURUURS9$r&) r(r)rr- max_unpool3drWrrrTr"r+s r)r2MaxUnPool3D.forward/r/r+c SUR3$rrr:s r)r;MaxUnPool3D.extra_reprJrr+r2)NrrsNN)rrrrjrrkrTrrrr"r!r>r?r$r3rAr4rLs@r)r?r?s;z  --%%  $45$+,02  "  *  "c7^$ -1    *    % 411r+r?cb^\rSrSrSrSSU4SjjjrS SjrS SjrSrU=r $) FractionalMaxPool2DiNa This operation applies 2D fractional max pooling on input tensor, which is described in the paper: [1] Ben Graham, Fractional Max-Pooling. 2015. http://arxiv.org/abs/1412.6071 The h and w dimensions of the output tensor are determined by the parameter output_size. For each dimension, the fractional max pooling: .. math:: \alpha &= size_{input} / size_{output} index_{start} &= ceil( \alpha * (i + u) - 1) index_{end} &= ceil( \alpha * (i + 1 + u) - 1) Output &= max(Input[index_{start}:index_{end}]) where, u \in (0, 1), i = 0,1,2...size_{output} The ``u`` from the formula is the parameter ``random_u``, and subtract ``1`` for the index starts from ``0`` instead of ``1`` where ``ceil`` works. For instance, giving a sequence of length ``7`` is ``[2, 4, 3, 1, 5, 2, 3]``, ``output_size`` is ``5`` and ``random_u`` is ``0.3``. The ``alpha = 7/5 = 1.4``, the starts of index is ``[0, 1, 3, 4, 6]``, the ends of index is ``[1, 3, 4, 6, 7]`` and makes the random sequence in the paper is ``index_end - index_start = [1, 2, 1, 2, 1]``. The strides and kernel_sizes are both equal to the random sequence, giving the final pooling output is ``[2, 4, 1, 5, 3]``. Parameters: output_size(int|list|tuple): The output size. If output 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. kernel_size (int|list|tuple|None, optional): The pool kernel size. If the 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 the square of an int. Default is None, means using the non-overlapping mode. random_u(float|None, optional): A random float number in range (0, 1) for the fractional pooling. Default None, means randomly generated by framework which can be fixed by ``paddle.seed``. return_mask(bool, optional): If true, the index of max pooling point will be returned along with outputs. Default False. name(str|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default. Shape: - x(Tensor): The input tensor of fractional max pool2d operator, which is a 4-D tensor. The data type can be float16, bfloat16, float32, float64. - output(Tensor): The output tensor of fractional max pool2d operator, which is a 4-D tensor. The data type is same as input x. Returns: A callable object of FractionalMaxPool2D. Examples: .. code-block:: pycon >>> # fractional max pool2d >>> # suppose input data in shape of [N, C, H, W], `output_size` is [m, n], >>> # output shape is [N, C, m, n], fractional pool divide H and W dimensions >>> # of input data into m * n grids and performs poolings in each >>> # grid to get output. >>> import paddle >>> x = paddle.rand([2, 3, 32, 32]) >>> # disjoint: without `kernel_size` >>> fractional_max_pool = paddle.nn.FractionalMaxPool2D(output_size=3) >>> pool_out = fractional_max_pool(x=x) >>> print(pool_out.shape) paddle.Size([2, 3, 3, 3]) >>> # overlapping: with `kernel_size` >>> fractional_max_pool = paddle.nn.FractionalMaxPool2D(kernel_size=2, output_size=3) >>> pool_out = fractional_max_pool(x=x) >>> print(pool_out.shape) paddle.Size([2, 3, 3, 3]) >>> fractional_max_pool = paddle.nn.FractionalMaxPool2D(output_size=[2, 3], return_mask=True) >>> pool_out, indices = fractional_max_pool(x=x) >>> print(pool_out.shape) paddle.Size([2, 3, 2, 3]) >>> print(indices.shape) paddle.Size([2, 3, 2, 3]) c^>[TU]5 XlX lX0lX@lXPlgr$r%r&r _kernel_size _random_urrr'rrrandom_urr"r(s r)r&FractionalMaxPool2D.__init__, ''!' r+c [R"UURURURUR UR S9$N)rrrNrr")r-fractional_max_pool2drrKrLrrr_s r)r2FractionalMaxPool2D.forwardA&& ))))^^))   r+c:SURSUR3$rrr:s r)r;FractionalMaxPool2D.extra_reprr r+rKrrrLrNNFN rrrrPrNrRrrr"r!r@)r>r rDrErFrGrHr&r2r;rJrKrLs@r)rHrHNaRn%)!%!  "          r+rHcb^\rSrSrSrSSU4SjjjrS SjrS SjrSrU=r $) FractionalMaxPool3Dia This operation applies 3D fractional max pooling on input tensor, which is described in the paper: [1] Ben Graham, Fractional Max-Pooling. 2015. http://arxiv.org/abs/1412.6071 The d, h and w dimensions of the output tensor are determined by the parameter output_size. For each dimension, the fractional max pooling: .. math:: \alpha &= size_{input} / size_{output} index_{start} &= ceil( \alpha * (i + u) - 1) index_{end} &= ceil( \alpha * (i + 1 + u) - 1) Output &= max(Input[index_{start}:index_{end}]) where, u \in (0, 1), i = 0,1,2...size_{output} The ``u`` from the formula is the parameter ``random_u``, and subtract ``1`` for the index starts from ``0`` instead of ``1`` where ``ceil`` works. For instance, giving a sequence of length ``7`` is ``[2, 4, 3, 1, 5, 2, 3]``, ``output_size`` is ``5`` and ``random_u`` is ``0.3``. The ``alpha = 7/5 = 1.4``, the starts of index is ``[0, 1, 3, 4, 6]``, the ends of index is ``[1, 3, 4, 6, 7]`` and makes the random sequence in the paper is ``index_end - index_start = [1, 2, 1, 2, 1]``. The strides and kernel_sizes are both equal to the random sequence, giving the final pooling output is ``[2, 4, 1, 5, 3]``. Parameters: output_size(int|list|tuple): The output size. If output size is a tuple or list, it must contain three element, (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. kernel_size (int|list|tuple|None): 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. Default is None, means using the non-overlapping mode. random_u(float|None, optional): A random float number in range (0, 1) for the fractional pooling. Default None, means randomly generated by framework which can be fixed by ``paddle.seed``. return_mask(bool, optional): 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. Shape: - x(Tensor): The input tensor of fractional max pool3d operator, which is a 5-D tensor. The data type can be float16, bfloat16, float32, float64. - output(Tensor): The output tensor of fractional max pool3d operator, which is a 5-D tensor. The data type is same as input x. Returns: A callable object of FractionalMaxPool3D. Examples: .. code-block:: pycon >>> # fractional max 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], fractional pool divide D, H and W dimensions >>> # of input data into l * m * n grids and performs poolings in each >>> # grid to get output. >>> import paddle >>> x = paddle.rand([2, 3, 8, 32, 32]) >>> # disjoint: without `kernel_size` >>> fractional_max_pool = paddle.nn.FractionalMaxPool3D(output_size=3) >>> pool_out = fractional_max_pool(x=x) >>> print(pool_out.shape) paddle.Size([2, 3, 3, 3, 3]) >>> # overlapping: with `kernel_size` >>> fractional_max_pool = paddle.nn.FractionalMaxPool3D(kernel_size=2, output_size=3) >>> pool_out = fractional_max_pool(x=x) >>> print(pool_out.shape) paddle.Size([2, 3, 3, 3, 3]) >>> fractional_max_pool = paddle.nn.FractionalMaxPool3D(output_size=[2, 3, 3], return_mask=True) >>> pool_out, indices = fractional_max_pool(x=x) >>> print(pool_out.shape) paddle.Size([2, 3, 2, 3, 3]) >>> print(indices.shape) paddle.Size([2, 3, 2, 3, 3]) c^>[TU]5 XlX lX0lX@lXPlgr$rJrMs r)r&FractionalMaxPool3D.__init__rPr+c [R"UURURURUR UR S9$rR)r-fractional_max_pool3drrKrLrrr_s r)r2FractionalMaxPool3D.forward&rUr+c:SURSUR3$rrr:s r)r;FractionalMaxPool3D.extra_repr0r r+rXrYrZr@rAr[rLs@r)r^r^r\r+r^)0 __future__rr(typingrpaddle.utils.decorator_utilsrrrr-layersr collections.abcr paddler paddle._typingr rrrrrrrfunctional.commonr__all__rrNrirurrrrrrrrrrrr6r?rHr^r6r+r)rpsY #  (   5 a a Hv v rk k \i ui Xq uq hg g Tu u pi i X?1?1Da"a"Hh"h"Vb!b!Jb"b"Jm"m"`k1%k1\s1%s1lr1%r1jq %q hq %q r+