ёilSSKJr SSKJr SSKrSSKJrJr SSK J r J r J r SSK JrJrJr SSKJrJr SS KJr SS KJrJr SS KJrJrJrJr \(a&SS KJr SS KJ r SSK!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r) SSK*J+r+ /r,Sr-Sr.\/\044Sjr1S2Sjr2Sr3Sr4Sr5S3Sjr6Sr7S4S5Sjjr8S6S7Sjjr9S8S9Sjjr:S:S;Sjjr;S r<S<S=S!jjr=S>S?S"jjr>S@SAS#jjr?SBSCS$jjr@SDSES%jjrA\"SS&/5SFSGS'jj5rB\"SS&/5SHSIS(jj5rC\"SS&/5SJSKS)jj5rD\"SS&/SS*/5SLSMS+jj5rE\"SS&/SS*/5SLSNS,jj5rF\"SS&/SS*/5SLSOS-jj5rGSPSQS.jjrHSPSQS/jjrI\SRSSS0jj5rJ\STSUS1jj5rKg)V) annotations) TYPE_CHECKINGN)_C_opsin_dynamic_mode)Variablein_dygraph_modein_dynamic_or_pir_mode)lp_pool_function_decoratorparam_one_aliasparam_two_alias) check_typecheck_variable_and_dtype) LayerHelper)squeeze unsqueeze) _contain_var_convert_to_tensor_list_is_symmetric_paddingconvert_to_list)Sequence)Tensor) DataLayout1D DataLayout2D DataLayout3DSize1Size2Size3Size4Size6)_PaddingSizeModec.[U[[45$N) isinstancelisttuple)inputs \/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/nn/functional/pooling.py_is_list_or_tupler*As edE] ++c [UR5U:wa0[SUS[UR5S[U535eg)NzExcepted Input X is z-D tensor, but received z-D )lenshape ValueErrortype)x dimensions r) _check_inputr3EsL 177|y "9+-Ec!''l^SVW[\]W^V_ `  !r+c `[X5(d[SUSUS[U5S35eg)Nz Excepted z type for z but received type: . )r%r/r0)r1x_nametypess r)_check_instancer8Ls< a  wj0DT!WIR P   r+c0SSjnUH nU"XA5 M g)Nc l[U[5(aUbX:a[SUSUSUS35eggg)NzExcepted the input z to be greater than z but received x: r5)r%intr/)r1r6 min_limits r) _check_value-_check_value_limitation.._check_valueTsN a  )"7AM%fX-A)L]^_]``bc =J"7 r+MbP?)r1r6r<r=eles r)_check_value_limitationrCSs S!r+cU(a-[US5SS/:H=(a [US5SS/:H$[US5SS/:H=(a [US5SS/:H$)Nrr!)r&)padding channel_lasts r)"_zero_padding_in_batch_and_channelrH^scGAJAq6)Id72;.?Aq6.IIGAJAq6)Hd71:.>1a&.HHr+clU(aUSSOUSSnUVVs/sH o3HoDPM M nnnU$s snnf)Nr!rErA)rFrGpadding_ pad_a_dimelems r)%_exclude_padding_in_batch_and_channelrNes> ,wq}'!"+H&.Eh949hHE OFs0cUS:XaUS;a[SU35eUS:XaS$S$US:XaUS;a[S U35eUS :XaS$S$US :XaUS ;a[S U35eUS:XaS$S$g)Nr!)NCLNLCzHAttr(data_format) should be 'NCL' or 'NLC'. Received Attr(data_format): rQTFrJNCHWNHWCJAttr(data_format) should be 'NCHW' or 'NHWC'. Received Attr(data_format): rTr NCDHWNDHWCLAttr(data_format) should be 'NCDHW' or 'NDHWC'. Received Attr(data_format): rX)r/) data_formatnum_dimss r) _channel_lastr\ks1} n ,&&1]4  '%/4 :U :1} . .&&1]4  '&04 ;e ;1} 0 0&&1]4  ''14 >> import paddle >>> import paddle.nn as nn >>> data = paddle.uniform([1, 3, 32], paddle.float32) >>> AvgPool1D = nn.AvgPool1D(kernel_size=2, stride=2, padding=0) >>> pool_out = AvgPool1D(data) >>> print(pool_out.shape) paddle.Size([1, 3, 16]) rSr1float16float32float64 avg_pool1dr rJr! kernel_size pool_strider@r<striderPrGrcavgFpool2dinput_param_nameXOutT pooling_typeksizeglobal_poolingstridespaddingsrd use_cudnnrc exclusiverZr0inputsoutputsattrs)rrr3rrrCr\rergr rrtrrlocals input_dtype"create_variable_for_type_inference append_op)r1rnrqrFrrcnamerZrGrdoutputop_typehelperdtypepool_outs r)rmrmsdK    s5| A!aSA!+q-@K#{#K ~ M:fK$GFH= *L!3"G %W-G            vs##W11""C"8<>> import paddle >>> import paddle.nn.functional as F >>> # avg pool2d >>> x = paddle.uniform([1, 3, 32, 32], paddle.float32) >>> out = F.avg_pool2d(x, kernel_size=2, stride=2, padding=0) >>> print(out.shape) paddle.Size([1, 3, 16, 16]) rJ pool_sizerornr@rprqrcrsFdivisor_overriderr!rtr1rjuint16rkrl avg_pool2drurwrxTryr)rrCr\rer rrtr8rrrrrr)r1rnrqrFrcrrrZrrGrdrrrrrs r)rrAsz"+q+>K ~ M:K$GFH= a0L!3L"G              #M ,.@ A^k!n<=@PP PW11 s? ""C"8<>> import paddle >>> x = paddle.uniform([1, 3, 32, 32, 32], paddle.float32) >>> # avg pool3d >>> out = paddle.nn.functional.avg_pool3d(x, kernel_size=2, stride=2, padding=0) >>> print(out.shape) paddle.Size([1, 3, 16, 16, 16]) r rrorrrnr@rprqrsFpool3dr1r avg_pool3drurxrwTryrrrr!rJ)rr\rerCr rrrrrrrrr8)r1rnrqrFrcrrrZrrGrdrrrrrs r)rrst"+q+>K ~ M: a0L!3"GK$GFH===            W11 s? ""C"8<>> import paddle >>> import paddle.nn.functional as F >>> data = paddle.uniform([1, 3, 32], paddle.float32) >>> pool_out = F.max_pool1d(data, kernel_size=2, stride=2, padding=0) >>> print(pool_out.shape) paddle.Size([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, 16]) >>> print(indices.shape) paddle.Size([1, 3, 16]) rSr rJr!rrorFrTmaxr1rkrl max_pool1dmax_pool2d_with_indexrtruint32rxMaskrwryr)r3rrrergr rrrrtrrrrrr)r1rnrqrFrrcrrZrdrrrrmaskrs r)rr@sjKA!aSAD{A{CDK ~@ofa?@!3i"G %W-G 33yH !qc*GHQK!,EF Xa[1#.  }}! H8aS) ) !C)Y)?N-8)hW11""C"8<nXgX'- n XgX'-n XUs=:aU :aM&O [S US US U S U S3 5e U$)Nz6Required output_size is None|list|tuple, but received r!rJFTz,output_size should be a sequence containing z or z# elements, but it has a length of ''zinvalid output_size "z" (dim z must be between z and ))r%r&r'r.ranger-appendrrr enumeraternparrayitemr/) r1rnrqrF output_size input_size default_sizedhas_static_varivarmin_sizemax_sizes r)_unpool_output_sizers  *[4-"H"H @ N HJL 3{# $ [))A- . 2fi ?n '*n  %N k " "  !N1+>K#K0c8,,%'XXc]%7%7%9KN1 ;3{+a//!!"o  ;3{++ :; S%5%9$::]^abm^n]oop r   s;'(A#2H#2H1~88 +K=sBST\S]]bckbllmn ) r+c xUS;a[SUS35eSn[US/5n[US/5nS/[USS5QnUcUnOS/[USS 5Qn[US5upH[ U5nUb&USS[ U[ 5(aS/OS -USS-n[XX4U5n[5(a&[R"XX#XFU5n [U S/5$S n [U 40[5D6n U RS S 9n U RU 5n U R!U XS.SU 0SUUUUS.S9 [U S/5$)a 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. Args: x (Tensor): The input tensor of unpooling 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, float64 or int64. indices (Tensor): The indices given out by maxpooling1d 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 int32 or int64. 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: Tensor: The output tensor of unpooling result. 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]) >>> unpool_out = F.max_unpool1d(pool_out, indices, kernel_size=2, padding=0) >>> print(unpool_out.shape) paddle.Size([1, 3, 16]) )rPz?Attr(data_format) should be 'NCL'. Received Attr(data_format): .rSrJr!rNro)r!unpoolr1rurwIndicesrxrunpooling_typer{r}r~rr)r/rrrergr%r&rr rrrrrrrr)r1indicesrnrqrFrZrrrdrrrr unpool_outs r) max_unpool1drsJ'! ""-a 1  K!aSA!%GD{A{CDK ~@ofa?@!3GQ!?G$W-G O d33s ?!"o   & K W; vs##G  -FH -F     4E::5AJ  + ## &    :s ##r+c @URS:wa[SURS35eURS:wa[SURS35e[USS5nUcUnO [USS5n[USS5nUS ;a[S US35e[ XX4U5n[ 5(a[ R"XX#XFU5nU$S n [U 40[5D6n U RS S 9n U RU 5n U RU XS.SU 0SUUUUS.S9 U $)a@ This API implements max unpooling 2d operation. See more details in :ref:`api_paddle_nn_MaxUnPool2D` . Args: x (Tensor): The input tensor of unpooling operator which is a 4-D tensor with shape [N, C, H, W]. The format of input tensor is `"NCHW"`, 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 is float32, float64 or int64. indices (Tensor): The indices given out by maxpooling2d which is a 4-D tensor with shape [N, C, H, W]. The format of input tensor is `"NCHW"` , 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 is int32 or int64. 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, padding). 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: Tensor: The output tensor of unpooling result. Raises: ValueError: If the input is not a 4-D tensor. ValueError: If indices shape is not equal input shape. 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]) >>> unpool_out = F.max_unpool2d(pool_out, indices, kernel_size=2, padding=0) >>> print(unpool_out.shape) paddle.Size([1, 1, 6, 6]) >>> # specify a different output size than input size >>> unpool_out = F.max_unpool2d( ... pool_out, ... indices, ... kernel_size=2, ... padding=0, ... output_size=[7, 7], ... ) >>> print(unpool_out.shape) paddle.Size([1, 1, 7, 7]) z4The x should have [N, C, H, W] format, but received rz:The indices should have [N, C, H, W] format, but received rJrrorF)rSz@Attr(data_format) should be 'NCHW'. Received Attr(data_format): rr1rurrxrrr) ndimr/r.rrr rrrrrrr r1rrnrqrFrZrrrrrrrs r) max_unpool2drisjx vv{B177)1 M  ||qHWX Y  "+q+>K ~ M:gq)4G(" ""-a 1  & K W;  G  -FH -F     4E::5AJ  + ## &    r+c @URS:wa[SURS35eURS:wa[SURS35e[USS5nUcUnO [USS5n[USS5nUS ;a[S US35e[ XX4U5n[ 5(a[ R"XX#XFU5nU$S n [U 40[5D6n U RS S 9n U RU 5n U RU XS.SU 0SUUUUS.S9 U $)a 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 Args: x (Tensor): The input tensor of unpooling operator which is a 5-D tensor with shape [N, C, D, H, W]. The format of input tensor is `"NCDHW"`, where `N` is batch size, `C` is the number of channels, `D` is the depth of the feature, `H` is the height of the feature, and `W` is the width of the feature. The data type is float32, float64 or int64. indices (Tensor): The indices given out by maxpooling3d which is a 5-D tensor with shape [N, C, D, H, W]. The format of input tensor is `"NCDHW"` , where `N` is batch size, `C` is the number of channels, `D` is the depth of the feature, `H` is the height of the feature, and `W` is the width of the feature. The data type is int32 or int64. 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 `"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: Tensor: The output tensor of unpooling result. 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]) >>> unpool_out = F.max_unpool3d(pool_out, indices, kernel_size=2, padding=0) >>> print(unpool_out.shape) paddle.Size([1, 1, 4, 4, 6]) z7The x should have [N, C, D, H, W] format, but received rz=The indices should have [N, C, D, H, W] format, but received r rrorF)rWzAAttr(data_format) should be 'NCDHW'. Received Attr(data_format): unpool3dr1rurrxrrr) rr/r.rrr rrrrrrrrs r) max_unpool3drsjZ vv{EaggYa P  ||qKGMM?Z[ \  "+q+>K ~ M:gq)4G)# ""-a 1  & K W;  G  -FH -F     4E::5AJ  + ## &    r+c[USS5nUcUnO [USS5nUS;a[SUS35eUS:XaSOS n[USXS 9up9US:XaU(a [S 5e[5(aOU(a([R "XX#S S U5n U(aU $U S $[R "UUUUUSUS S S U 5 $U(aSOSn [U 40[5D6n [US/SQS5 U RSS9n U RU 5nU(a7U RS5nXS.nU RSSU0US US UUU SUSUS. S9 X4$SU0nU RSSU0US US UUU SUSUS. S9 U$)az This API implements max pooling 2d operation. See more details in :ref:`api_paddle_nn_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|None, 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. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn.functional as F >>> # max pool2d >>> x = paddle.uniform([1, 3, 32, 32], paddle.float32) >>> out = F.max_pool2d(x, kernel_size=2, stride=2, padding=0) >>> print(out.shape) paddle.Size([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) >>> print(out.shape) paddle.Size([1, 3, 16, 16]) >>> print(max_indices.shape) paddle.Size([1, 3, 16, 16]) rJrrorRrUrrTTF)r[rGrczSWhen setting return_mask to true, data_format must be set to NCHW in API:max_pool2drrrrtr1r max_pool2drurrrwryrrx) rr/rer rrrtrrrrrrr1rnrqrFrrcrZrrGrdrrrrrrrs r)rrzs~"+q+>K ~ M:** ""-a 1  '&04eL!3!,"Gf a   11yF)6 7fQi 7==!  .9)hW11 s? ""C"8<>> import paddle >>> import paddle.nn.functional as F >>> # max pool3d >>> x = paddle.uniform([1, 3, 32, 32, 32]) >>> output = F.max_pool3d(x, kernel_size=2, stride=2, padding=0) >>> print(output.shape) paddle.Size([1, 3, 16, 16, 16]) >>> # for return_mask=True >>> x = paddle.uniform([1, 3, 32, 32, 32]) >>> output, max_indices = paddle.nn.functional.max_pool3d(x, kernel_size=2, stride=2, padding=0, return_mask=True) >>> print(output.shape) paddle.Size([1, 3, 16, 16, 16]) >>> print(max_indices.shape) paddle.Size([1, 3, 16, 16, 16]) r rrorrrXzTWhen setting return_mask to true, data_format must be set to NCDHW in API:max_pool3dFrTrmax_pool3d_with_indexrr1r max_pool3drurrrwryr)rr\rer/r rrrrrrrrrrs r)rrs@"+q+>K ~ M: a0L!3"Gg+ b   11yF)6 7fQi 7==!  .9)hW11 s? ""C"8<>> # 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 >>> data = paddle.uniform([1, 3, 32]) >>> pool_out = F.adaptive_avg_pool1d(data, output_size=16) >>> print(pool_out.shape) paddle.Size([1, 3, 16]) rsr r!rrJFrTrSr`rtr1riadaptive_pool2dadaptive_pool1drurxrw)rzr{adaptiver)r3rrr r _use_gpudnnrrtrrrr;rrrrr) r1rr pool_typerrl_typerrrs r)adaptive_avg_pool1drsFTIAB_[![ABI!aSA    e$A==  F F         x!%% s57H  ; c4EFV0vx0""C"8<>> # 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]) >>> # x.shape is [2, 3, 32, 32] >>> out = paddle.nn.functional.adaptive_avg_pool2d(x = x, ... output_size=[3, 3]) >>> print(out.shape) paddle.Size([2, 3, 3, 3]) rRrUrrSrJrr!r rrFTrsr`rtr1riadaptive_avg_pool2drZrurxrwrzr{rrZr)r/r.r%r;rr&rrrrrrrr rrrrtrrrarrrrr) r1rrZrin_hin_wrrrrrrs r)rrs D** ""-a 1  fWWQq\ dWWQq\ +s##%k1mD ;' q> !!N q> !!N$ #'1x&@&@BHHTN   "d J#  k " "-k:     e$A}}  F F          s57L  ; s4IJV0vx0""C"8<>> # 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 >>> input_data = paddle.randn(shape=(2, 3, 8, 32, 32)) >>> out = paddle.nn.functional.adaptive_avg_pool3d(x = input_data, ... output_size=[3, 3, 3]) >>> print(out.shape) paddle.Size([2, 3, 3, 3, 3]) rVrYrrWrJrr!rr rrFr!r!r!rrrTrsr`rr1rirrZrurxrwrr)r/r.r%r;rr&r rrrrrrrarrrrr) r1rrZrin_lrrrrrrrs r)adaptive_avg_pool3drsL,, ""-a 1  g771Q<D771Q<D+s##%k1mD ;' q> !!N q> !!N q> !!N    e$A}}             s57L  ; s4IJV0vx0""C"8<>> # 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 >>> data = paddle.uniform([1, 3, 32], paddle.float32) >>> pool_out = F.adaptive_max_pool1d(data, output_size=16) >>> print(pool_out.shape) paddle.Size([1, 3, 16]) >>> pool_out, indices = F.adaptive_max_pool1d(data, output_size=16, return_mask=True) >>> print(pool_out.shape) paddle.Size([1, 3, 16]) >>> print(indices.shape) paddle.Size([1, 3, 16]) r r!rrJrFTrr1rkrladaptive_max_pool1drrurrrwrrzr{rrcr)r3rrr rrrrrr;boolrrrrr) r1rrrrrrrrrrs r)rr slAB_[![ABI!aSA// 1a&1a&%u  Xa[1# & aS(A B !qc* ) sY *,A  ; S2GH; t5JKV0vx0""C"8<>> # 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 >>> input_data = paddle.randn(shape=(2, 3, 32, 32)) >>> out = paddle.nn.functional.adaptive_max_pool2d(x=input_data, output_size=[3, 3]) >>> print(out.shape) paddle.Size([2, 3, 3, 3]) rrJrrr!FTrr1rkrladaptive_max_pool2drrurrrwrrr)r3r.r%r;rr&r rrrrrrrrrr) r1rrrrrrrrrrrs r)rrtsfZA1JD+s##%k1mD ;' q> !!N q> !!N// QFQFE4 'x7HQK7( sY *,A  ; t5JKV0vx0""C"8<>> # 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 >>> input_data = paddle.randn(shape=(2, 3, 8, 32, 32)) >>> out = paddle.nn.functional.adaptive_max_pool3d(x=input_data, output_size=[3, 3, 3]) >>> print(out.shape) paddle.Size([2, 3, 3, 3, 3]) rrJr rrr!rrFTrr1rkrladaptive_max_pool3drrurrrwrrr)r3r.r%r;rr&r rrrrrrrrrr) r1rrrrrrrrrrrrs r)rrsr`Awwq|D+s##%k1mD ;' q> !!N q> !!N q> !!N// Iy%u 'x7HQK7( sY *,A  ; t5JKV0vx0""C"8<>> # 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]) >>> # disjont: without `kernel_size` >>> pool_out = paddle.nn.functional.fractional_max_pool2d(x, output_size=3) >>> print(pool_out.shape) paddle.Size([2, 3, 3, 3]) >>> # overlapping: with `kernel_size` >>> pool_out = paddle.nn.functional.fractional_max_pool2d(x, kernel_size=2, output_size=3) >>> print(pool_out.shape) paddle.Size([2, 3, 3, 3]) >>> pool_out, indices = paddle.nn.functional.fractional_max_pool2d(x, output_size=[2, 3], return_mask=True) >>> print(pool_out.shape) paddle.Size([2, 3, 2, 3]) >>> print(indices.shape) paddle.Size([2, 3, 2, 3]) rrr!3The param `random_u` should be a `float` in (0, 1).rJrnrfractional_max_pool2dr1rrjrkrlrrandom_ururoutrrrnrrr)r3r/rr.r%r;r&r rrfloatrrrrrrrr)r1rrnrrrrrrrrrrrs r)rr2sfA q=HME   "  Q 6V 1JD+s##%k1mD ;' q> !!N q> !!N// Kx+ 'x7HQK7)  7 #  ; t5LM    #  V0vx0""C"8<>> # 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]) >>> # disjont: without `kernel_size` >>> pool_out = paddle.nn.functional.fractional_max_pool3d(x, output_size=3) >>> print(pool_out.shape) paddle.Size([2, 3, 3, 3, 3]) >>> # overlapping: with `kernel_size` >>> pool_out = paddle.nn.functional.fractional_max_pool3d(x, kernel_size=2, output_size=3) >>> print(pool_out.shape) paddle.Size([2, 3, 3, 3, 3]) >>> pool_out, indices = paddle.nn.functional.fractional_max_pool3d(x, output_size=[2, 3, 3], return_mask=True) >>> print(pool_out.shape) paddle.Size([2, 3, 2, 3, 3]) >>> print(indices.shape) paddle.Size([2, 3, 2, 3, 3]) rrrr!rr rnrrJrfractional_max_pool3dr1rrrrurrrr)r3r/rr.r%r;r&r rrrrrrrrrrr)r1rrnrrrrrrrrrrrrs r)rrsfA q=HME   "  Q 6  wwq|D+s##%k1mD ;' q> !!N q> !!N q> !!N//   (O   'x7HQK7)  7 #  ; t5LM    #  V0vx0""C"8<>> import paddle >>> import paddle.nn as nn >>> data = paddle.uniform([1, 3, 32], paddle.float32) >>> LPPool1D = nn.LPPool1D(norm_type=3, kernel_size=2, stride=2, padding=0) >>> pool_out = LPPool1D(data) >>> print(pool_out.shape) paddle.Size([1, 3, 16]) rPrSrJrTr!r1ri lp_pool1dr rnror@rprqrrTlpF lp_pool2drur rzrnr|r}r~rdrcrrZ norm_typer)rrr3rrrCr\rergr rrrrrrrr)r1rrnrqrFrcrZrori_data_formataxisrGrdrrrrrs r)rrn sp"Oe      s5{ A!VA!+q-@K#{#K ~ M:fK$GFH= !4L!3"G %W-G!!             vv&&W11""C"8<>> import paddle >>> import paddle.nn.functional as F >>> # lp pool2d >>> x = paddle.uniform([1, 3, 32, 32], paddle.float32) >>> out = F.lp_pool2d(x, norm_type=2, kernel_size=2, stride=2, padding=0) >>> print(out.shape) paddle.Size([1, 3, 16, 16]) rrz`norm_type` cannot be 0.rJrrornr@rprqrTrFrr1rrurrr)r3r/rrrCr\rer rrrrrrrr)r1rrnrqrFrcrZrrGrdrrrrrs r)rr slvAA~344i I!+q+>K ~ M:K$GFH= a0L!3L"G!!              W11 s? ""C"8<rs# *  E,5(   ) , '*5\ "I =63&l   01u& u&u& u&. u&  u&  u& u& u&v 01%) &  .     #  J 01%) 'z z  z . z  z  z #z z  z  z @ 01      .          D)` 01 %(,x$ x$ x$x$  x$ . x$  x$&x$ x$ x$~ 01 &(,M M MM  M . M  M&M M Mh 01 '(,~ ~ ~~  ~ . ~  ~&~ ~ ~H 01 &_ __ _. _  _  __ _ _J 01 'C= C=C= C=. C=  C=  C=C= C= C=L#w 48U& U&U&'1U& U&!U&p#w !' F FFF  F  F!FR#w !( D DDD  D  D!DN#w-1A!BC c  c c c   c  c Dc L#w-1A!BC W= W=W=W=  W=  W=DW=t#w-1A!BC _= _=_=_=  _=  _=D_=J!%! X= X=X=X= X=  X=  X= X=|!%! ^= ^=^=^= ^=  ^=  ^= ^=B  01 %@) @)@)@)  @) . @)  @)@) @) @)@)F  01 &x xxx  x . x  xx x xxr+