ёig V%SSKJr SSKrSSKrSSKrSSKJrJrJr SSK r SSK J r SSK r SSK J r Jr SSKJr SSKJrJr SSKJrJrJrJr SS KJr SS KJr SS KJrJr SS K J!r! S SK"J#r#J$r$J%r% S SK&J'r'J(r(J)r)J*r* S SK+J,r, S SK-J.r.J/r/ \(aRSSK0J1r1 SSK J2r2 SSK J3r3 SSK4J5r5J6r6J7r7J8r8J9r9J:r:J;r; SSKS\?S'\Sr@S\?S'\SrAS\?S'\SrBS\?S'/rCSDSES"jjrD\ SFSGS$jj5rE\ SHSIS%jj5rESJS&jrESKSLS'jjrF\R"\F5\ElHSMSNS(jjrISOSPS)jjrJ\"S!S#/5SQSRS+jj5rKSSSTS,jjrLSUSVS-jjrMSWSXS.jjrNSYSZS/jjrOS[S\S0jjrPS[S\S1jjrQ\"S!S#/05S]S^S2jj5rR\"S3S4S S5S69S_S`S8jj5rS\"S*S9/5SaSbS:jj5rTSOScS;jjrUSdSeS<jjrVSfSgS=jjrW\"S#/S>/S?/S@/S7/SA/SB.5SDShSCjj5rXg)i) annotationsN) TYPE_CHECKINGAnyLiteral)overload)_C_opspir) LayerHelper)Variabledefault_main_program)corein_dynamic_modein_dynamic_or_pir_mode in_pir_mode)full) deprecated)ParamAliasDecoratorparam_one_alias)NotSupportedTensorArgumentError) check_dtype check_typecheck_variable_and_dtype)clipconcatsqrtsum)zeros)squeeze unsqueeze)Sequence) TypeAlias)Tensor)DataLayout1DVariant DataLayout2D DataLayout3D DataLayoutND ShapeLikeSize2Size4)Group)linearareanearestbilinearbicubic trilinearr"_InterpolateMode)upscale_in_traindownscale_in_infer _DropoutMode)rconstantreflect replicatecircular_PaddingTensorMode)validsameVALIDSAME_PaddingSizeModexc Z[S0[5D6n[US/SQS5 [UR5S:XdS5e[ U[ 5(aX/nOA[ U[[45(a[U5S:Xd [SS5e[U5n[ U[ 5(aX"/nOA[ U[[45(a[U5S:Xd [S S 5e[U5n[ U[ 5(aXD/nOA[ U[[45(a[U5S:Xd [S S 5e[U5n[ U[ 5(aU/S-nOb[ U[[45(a;[U5n[U5S:XaUS-nO'[U5S:XaO[S 5e[SS5e[5(a[R"XX#U5$URURS9nUR!SSU0SU0UUUUS.S9 U$)a Return a col buffer of sliding local blocks of input x, also known as im2col for batched 2D image tensors. For each block under the convolution filter, all element will be rearranged as a column. While the convolution filter sliding over the input feature map, a series of such columns will be formed. For each input :math:`x` with shape [N, C, H, W], the output shape [N, Cout, Lout] can be calculated as following. .. math:: dkernel[0] &= dilations[0] \times (kernel\_sizes[0] - 1) + 1 dkernel[1] &= dilations[1] \times (kernel\_sizes[1] - 1) + 1 hout &= \frac{H + paddings[0] + paddings[2] - dkernel[0]}{strides[0]} + 1 wout &= \frac{W + paddings[1] + paddings[3] - dkernel[1]}{strides[1]} + 1 Cout &= C \times kernel\_sizes[0] \times kernel\_sizes[1] Lout &= hout \times wout Parameters: x(Tensor): 4-D Tensor, input tensor of format [N, C, H, W], data type can be float32 or float64 kernel_sizes(int|list|tuple): The size of convolution kernel, should be [k_h, k_w] or an integer k treated as [k, k]. strides(int|list|tuple, optional): The strides, should be [stride_h, stride_w] or an integer stride treated as [stride, stride]. For default, strides will be [1, 1]. paddings(int|list|tuple, optional): The paddings of each dimension, should be [padding_top, padding_left, padding_bottom, padding_right] or [padding_h, padding_w] or an integer padding. If [padding_h, padding_w] was given, it will expanded to [padding_h, padding_w, padding_h, padding_w]. If an integer padding was given, [padding, padding, padding, padding] will be used. For default, paddings will be [0, 0, 0, 0] dilations(int|list|tuple, optional): the dilations of convolution kernel, should be [dilation_h, dilation_w], or an integer dilation treated as [dilation, dilation]. For default, it will be [1, 1]. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` Returns: Tensor, The tensor corresponding to the sliding local blocks. The output shape is [N, Cout, Lout] as described above. Cout is the total number of values within each block, and Lout is the total number of such blocks. The data type of output is the same as the input :math:`x` Examples: .. code-block:: python >>> import paddle >>> import paddle.nn.functional as F >>> x = paddle.randn((100,3,224,224)) >>> y = F.unfold(x, [3, 3], 1, 1, 1) unfoldrAuint16float16float32float64z*input should be the format of [N, C, H, W]Hkernel_sizes should either be an integer or a list/tuple of two integers kernel_sizesCstrides should either be an integer or a list/tuple of two integersstridesEdilations should either be an integer or a list/tuple of two integers dilationszGpaddings should either be an integer or a list/tuple of 2 or 4 integersz^Unexpected type of paddings, it should be either an integer or a list/tuple of 2 or 4 integerspaddingsdtypeXY)rLrNrQrPtypeinputsoutputsattrs)rC)r localsrlenshape isinstanceintlisttupler ValueErrorrrrC"create_variable_for_type_inferencerS append_op)rArLrNrQrPnamehelperouts [/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/nn/functional/common.pyrCrCRs#T .VX .F 3;X qww<1 JJJ ,$$$3  |dE] 3 3\9Ja9O1Z L) '3$7T5M22G 8I1U w-)S!!* 9tUm44#i.A:M1W O (C  :> HtUm , ,> x=A !|H ]a  Y . !   }}QgKK  3 3!'' 3 BC  Qxc ( "    JinputcgN)rjsize scale_factormode align_cornersrecompute_scale_factor antialiass rh interpolatertsric grlrm) rArnrorprq align_mode data_formatrrres rhrtrtsricF^[U5nS U4SjjnST;aU"STRS55 [U5S:aV[US5[LaASS/n[ [ US- [U555HnU"XEXS-5 M USSn[ U0TD6$) aJ) This function has two functionalities, depending on the parameters passed: 1. ``interpolate(input, size, scale_factor, mode, align_corners, recompute_scale_factor, antialias)``: PyTorch compatible interpolate. 2. ``interpolate(x, size, scale_factor, mode, align_corners, align_mode, data_format, recompute_scale_factor, name)`` The original PaddlePaddle implementation of interpolate, see the following docs. This API resizes a batch of images. The input must be a 3-D Tensor of the shape (num_batches, channels, in_w) or (num_batches, in_w, channels), or 4-D (num_batches, channels, in_h, in_w) or (num_batches, in_h, in_w, channels), or a 5-D Tensor of the shape (num_batches, channels, in_d, in_h, in_w) or (num_batches, in_d, in_h, in_w, channels), Where in_w is width of the input tensor, in_h is the height of the input tensor, in_d is the depth of the input tensor. and the resizing only applies on the three dimensions(depth, height and width). Supporting resample methods: - 'linear' : Linear interpolation - 'bilinear' : Bilinear interpolation - 'trilinear' : Trilinear interpolation - 'nearest' : Nearest neighbor interpolation - 'bicubic' : Bicubic interpolation - 'area': Area interpolation Linear interpolation is the method of using a line connecting two known quantities to determine the value of an unknown quantity between the two known quantities. Nearest neighbor interpolation is to perform nearest neighbor interpolation in both the 3rd dimension(in height direction) and the 4th dimension(in width direction) on input tensor. Bilinear interpolation is an extension of linear interpolation for interpolating functions of two variables (e.g. H-direction and W-direction in this op) on a rectilinear 2D grid. The key idea is to perform linear interpolation first in one direction, and then again in the other direction. Trilinear interpolation is an extension of linear interpolation for interpolating functions of three variables (e.g. D-direction, H-direction and W-direction in this op) on a rectilinear 3D grid. The linear interpolation is performed on three directions. align_corners and align_mode are optional parameters,the calculation method of interpolation can be selected by them. Bicubic interpolation is an extension of cubic interpolation for interpolating data points on a two-dimensional regular grid. The interpolated surface is smoother than corresponding surfaces obtained by bilinear interpolation or nearest-neighbor interpolation. Area interpolation is to perform area interpolation in both the 3rd dimension(in height direction) , the 4th dimension(in width direction) and the 5th dimension(in depth direction) on input tensor. Set to area will directly call `paddle.nn.functional.adaptive_avg_pool1d` or `paddle.nn.functional.adaptive_avg_pool2d` or `paddle.nn.functional.adaptive_avg_pool3d`. Example: .. code-block:: text # For scale_factor: if align_corners = True && out_size > 1 : scale_factor = (in_size-1.0)/(out_size-1.0) else: scale_factor = float(in_size/out_size) # Linear interpolation: if: align_corners = False , align_mode = 0 input : (N,C,W_in) output: (N,C,W_out) where: W_out = (W_{in}+0.5) * scale_{factor} - 0.5 else: input : (N,C,W_in) output: (N,C,W_out) where: W_out = W_{in} * scale_{factor} # Nearest neighbor interpolation: align_corners = False input : (N,C,H_in,W_in) output: (N,C,H_out,W_out) where: H_out = floor (H_{in} * scale_{factor}) W_out = floor (W_{in} * scale_{factor}) # Bilinear interpolation: if: align_corners = False , align_mode = 0 input : (N,C,H_in,W_in) output: (N,C,H_out,W_out) where: H_out = (H_{in}+0.5) * scale_{factor} - 0.5 W_out = (W_{in}+0.5) * scale_{factor} - 0.5 else: input : (N,C,H_in,W_in) output: (N,C,H_out,W_out) where: H_out = H_{in} * scale_{factor} W_out = W_{in} * scale_{factor} # Bicubic interpolation: if: align_corners = False input : (N,C,H_in,W_in) output: (N,C,H_out,W_out) where: H_out = (H_{in}+0.5) * scale_{factor} - 0.5 W_out = (W_{in}+0.5) * scale_{factor} - 0.5 else: input : (N,C,H_in,W_in) output: (N,C,H_out,W_out) where: H_out = H_{in} * scale_{factor} W_out = W_{in} * scale_{factor} # Trilinear interpolation: if: align_corners = False , align_mode = 0 input : (N,C,D_in,H_in,W_in) output: (N,C,D_out,H_out,W_out) where: D_out = (D_{in}+0.5) * scale_{factor} - 0.5 H_out = (H_{in}+0.5) * scale_{factor} - 0.5 W_out = (W_{in}+0.5) * scale_{factor} - 0.5 else: input : (N,C,D_in,H_in,W_in) output: (N,C,D_out,H_out,W_out) where: D_out = D_{in} * scale_{factor} H_out = H_{in} * scale_{factor} W_out = W_{in} * scale_{factor} For details of linear interpolation, please refer to Wikipedia: https://en.wikipedia.org/wiki/Linear_interpolation. For details of nearest neighbor interpolation, please refer to Wikipedia: https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation. For details of bilinear interpolation, please refer to Wikipedia: https://en.wikipedia.org/wiki/Bilinear_interpolation. For details of trilinear interpolation, please refer to Wikipedia: https://en.wikipedia.org/wiki/Trilinear_interpolation. For details of bicubic interpolation, please refer to Wikipedia: https://en.wikipedia.org/wiki/Bicubic_interpolation Parameters: x (Tensor): 3-D, 4-D or 5-D Tensor, its data type is float32, float64, or uint8, its data format is specified by :attr:`data_format`. If :attr:`data_format` is not provided, the data format will be presumed according to its dimension. See details in :attr:`data_format`. alias: ``input``. size (list|tuple|Tensor|None): Output shape of image resize layer, the shape is (out_w, ) when input is a 3-D Tensor, the shape is (out_h, out_w) when input is a 4-D Tensor and is (out_d, out_h, out_w) when input is a 5-D Tensor. Default: None. If a list/tuple, each element can be an integer or a Tensor of shape: [1] or []. If a Tensor, its dimensions size should be a 1. scale_factor (float|Tensor|list|tuple|None): The multiplier for the input height or width. At least one of :attr:`size` or :attr:`scale_factor` must be set. And :attr:`size` has a higher priority than :attr:`scale_factor`.Has to match input size if it is either a list or a tuple or a Tensor. If a list/tuple, each element can be an integer or a Tensor of shape: [1] or []. Default: None. mode (str): The resample method. It supports 'linear', 'area', 'nearest', 'bilinear', 'bicubic' and 'trilinear' currently. Default: 'nearest' align_corners(bool) : An optional bool, If True, the centers of the 4 corner pixels of the input and output tensors are aligned, preserving the values at the corner pixels.This only has an effect when 'linear', 'bilinear', 'bicubic' or 'trilinear'. Default: False antialias(bool) : Flag to apply anti-aliasing. Default: False. Using anti-alias option together with align_corners=False, interpolation result would match Pillow result for downsampling operation. Supported modes: 'bilinear', 'bicubic'. align_mode(int) : An optional for linear/bilinear/trilinear interpolation. Refer to the formula in the example above, it can be '0' for src_idx = scale_factor*(dst_index+0.5)-0.5 , can be '1' for src_idx = scale_factor*dst_index. data_format (str, optional): Specify the data format of the input, and the data format of the output will be consistent with that of the input. An optional string from:`"NCW"`, `"NWC"`, `"NCHW"`, `"NHWC"`, `"NCDHW"`, `"NDHWC"`. The default value is None. When :attr:`data_format` is not specified, it will be automatically inferred from the input dimension of :attr:`x`. When :attr:`x` is a 3-D Tensor, :attr:`data_format` will be set to `"NCW"`; When :attr:`x` is a 4-D Tensor, :attr:`data_format` will be set to `"NCHW"`; When :attr:`x` is a 5-D Tensor, :attr:`data_format` will be set to `"NCDHW"`. When it is `"NCHW"`, the data should be stored in the order of: `[batch_size, input_channels, input_height, input_width]`. When it is `"NCDHW"`, the data should be stored in the order of: `[batch_size, input_channels, input_depth, input_height, input_width]`. recompute_scale_factor (bool, optional): Whether to recompute the scaling factor for interpolation calculation. When set to `True`, the `scale_factor` parameter must be provided, and the function will use it along with the input tensor shape to calculate the output tensor shape, then recalculate the scaling factor based on the output and input tensor shapes. This parameter is particularly useful when `scale_factor` is a floating-point value. When set to `False`, either `size` or `scale_factor` will be used directly for interpolation without recalculation. Default: None. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` Returns: A 3-D, 4-D or 5-D Tensor, with the same data format of the input :attr:`x`. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn.functional as F >>> input_data = paddle.randn(shape=(2, 3, 6, 10)).astype(paddle.float32) >>> output_1 = F.interpolate(x=input_data, size=[12, 12]) >>> print(output_1.shape) paddle.Size([2, 3, 12, 12]) >>> # given scale >>> output_2 = F.interpolate(x=input_data, scale_factor=[2, 1]) >>> print(output_2.shape) paddle.Size([2, 3, 12, 10]) >>> # bilinear interp >>> output_3 = F.interpolate(x=input_data, scale_factor=[2, 1], mode="bilinear") >>> print(output_2.shape) paddle.Size([2, 3, 12, 10]) c:>UT;a[SUS35eUTU'g)Nz"got multiple values for argument '') TypeError)keyvaluekwargss rhsafe_set_param#interpolate..safe_set_params( &=@QGH Hs rirjrArrrsN)r|strr}r)r\poprWr_rangemin_interpolate_wrapper)argsr~len_argsr param_keysidxs ` rhrtrtsp4yH &sFJJw/0 4yA~$tAw-s2. < X\3z?;RAS/SUS6S:9nO3URCS5n[R>RAS/SUS6US;9 UR9U5 UR9U5 M UUS<'[UR5S:XaK[U5S:wa [S=5eU(a WSUS>'O![[E[:U55nUSUS>'[UR5S:Xa[[U5S:wa [S?5eU(aWSUS@'USUS>'O)[[E[:U55nUSUS@'USUS>'[UR5S:Xal[U5S:wa [SA5eU(aWSUSB'USUS@'USUS>'GO[[E[:U55nUSUSB'USUS@'USUS>'GO_UGb[URnUS:XaUSm)OUS/:XaUSm)OUS:Xa'[GURSURS5m)OUS-:Xa'[GURSURS5m)OxUS:Xa5[GURSURSURS5m)O=US.:Xa5[GURSURSURS5m)OSm)U)4SCjnU(Ga[/5(aJ[ U[5(a5UR/:Xa [IU5nO[UR355n[UR5S- n[ U[H[:[2RJ45(a[IU5/U-nOt[ U[[ 45(aN[U5U:wa%[SDUSE[UR5SF35e[[E[HU55nO [SG5e/n[MU5HTnURUS-n[;[2RN"[IU5UU-55n UR9U 5 MV [UR5S:Xa USUS>'O[[UR5S:XaUSUS@'USUS>'O1[UR5S:XaUSUSB'USUS@'USUS>'SnGORS0n![/5(aS6n!U!(aJ[ U[5(a5UR/:Xa [IU5nO[UR355n[ U[[RR45(aS6UlUUSH'GO[ U[H[:[2RJ45(aUS::a [SI5e/n[M[UR5S- 5HnUR9U5 M U!(a*URPS:Xa[[EUU55USJ'GO [[E[HU55USJ'O[ U[[ 45(a[U5[UR5S- :wa;[SD[UR5S- SE[UR5SF35eUHn"U"S::dM [SI5e U!(a)URPS:Xa[[EUU55USJ'O([[E[HU55USJ'O [SG5e[S5(Ga/n#URU5H(un$n%U#R9U$5 U#R9U%5 M* [ U#5n&U(ad[VRX"US7U;aUS7OSSSJU;aUSJO/USLUSMUSN5 n'U'$U SO:Xad[VRZ"US7U;aUS7OSSSJU;aUSJO/USLUSMUSN5 n'U'$U SP:Xad[VR\"US7U;aUS7OSSSJU;aUSJO/USLUSMUSN5 n'U'$U SQ:Xad[VR^"US7U;aUS7OSSSJU;aUSJO/USLUSMUSN5 n'U'$U SR:Xad[VR`"US7U;aUS7OSSSJU;aUSJO/USLUSMUSN5 n'U'$U SS:Xab[VRb"US7U;aUS7OSSSJU;aUSJO/USLUSMUSN5 n'W'$UReSTSU9n(URCU(5n'URgU S$3USVU'0USW9 U'$)XNrNCWrINCHWrNCDHWz`The dimension of the input tensor should only be 3-D, 4-D or 5-D, but the received dimension is .)LINEARBILINEAR TRILINEARNEARESTBICUBICAREAzxThe 'resample' of image_resize can only be 'area', 'linear', 'bilinear', 'trilinear', 'bicubic' or 'nearest' currently.)rz!'linear' only support 3-D tensor.)rz*'NEAREST' only support 4-D or 5-D tensor.)rrz1'bilinear' and 'bicubic' only support 4-D tensor.rz#'trilinear'only support 5-D tensor.z.One of size and scale_factor must not be None.rJz7The x and size should satisfy rank(x) - 2 == len(size).int32r@z7If size is a tensor, it's rank must be 1, but received rz;The x and size should satisfy rank(x) - 2 == size.shape[0].z)Attr align_corners should be a bool valuez%Attr antialias should be a bool valuezalign_mode can only be 0 or 1rzjalign_corners option can only be set with the interpolating modes: linear | bilinear | bicubic | trilinearzBAnti-alias option is only supported for bilinear and bicubic modesrzoutput size can not be emptyz(output size can not be None in AREA mode _interp_v2)rNWCz)Got wrong value for param `data_format`: z: received but only `NCW` or `NWC` supported for 3-D input.rNHWCz< received but only `NCHW` or `NHWC` supported for 4-D input.rNDHWCz> received but only `NCDHW` or `NDHWC` supported for 5-D input.c.[U[[45$rlr^r`radatas rh_is_list_or_tuple_0_interpolate_wrapper.._is_list_or_tuple_k$u ..rirrrFrT)out_dout_hout_w interp_methodrqrv data_layoutz3Only one of size or scale_factor should be defined.z?recompute_scale_factor is not meaningful with an explicit size.TOutSizez+size should be a list or tuple or Variable.z>Each dimension size given in out_shape must be greater than 0.) force_cpu)rrg SizeTensorz,size length should be 2 for input 3-D tensorrz-size length should be 2 for input 4-D tensor.rz-size length should be 3 for input 5-D tensor.rc>[[U55S::aU$[R"[ UT-5T- 5$)N )r\rnumpyrGr_)r}max_dims rh_scale_to_float32/_interpolate_wrapper.._scale_to_float32s53u:"$ ==UW_!5!?@ @rizscale_shape length should be z for input z -D tensor.z@Attr(scale)'s type should be float, int, list, tuple, or Tensor.Scalez(Attr(scale) should be greater than zero.scalerrrqrvr,r/r1r.r0rAinput_param_nameOutrV)4r\r]rbupperlowerr^rar`ndimr paddler Valuecastboolr{nn functionaladaptive_avg_pool1dadaptive_avg_pool2dadaptive_avg_pool3dr r[r stop_gradientr enumerateitemappendr_rtensor fill_constantrcmapmaxfloatndarrayrfloorrnritemsrinterp_antialias linear_interpbilinear_interptrilinear_interpnearest_interpbicubic_interp input_dtyperd)*rArnrorprqrvrwrrrsredim_sizeresample resample_typeresample_methodsrfrrrXrZ out_shaperidim contain_vardim_idxnew_size_tensor size_listtemp_outx_shaper scale_list input_size output_size dynamic_moder} attr_listkvdy_attrrgrSrs* @rhrrsqww< q=K ] K ]!Krs{r||}~ ##%Kzz|HJJLM' 1  :#agg,!"3<==;3qww<1#4QWW9JEFF**s177|q/@LMM;3qww<1#4>?? | ,IJJ$ &&CI!,C E  $6::#3#3455yy! 99>I$))TUV  ::a=AFFQJ &M  mT * *CDD i & &?@@Q:?899h)3 x  X%<< P  6 dT5(FJJ4D4DE F F4yA~ !?@@ <GH H qww<1 99'';;AD D \Q 99'';;AD D \Q 99'';;AD D M?*5 B BF 177|q[> 7 J K  QWW {2BB 7 L M  QWW {2DD 7 N O  /f w 6+:N f w 6+:N 9 1XF&& " EI E!2NOO !Q  y8VZZ-=-="> ? ?#%%&*I # )F9   i22 $Y__U%; Q&$F%.q\E'N $Si%8 9I%.q\E'N177|q y>Q&$G%.q\E'N%.q\E'N $Si%8 9I%.q\E'N%.q\E'N177|q y>Q&$G%.q\E'N%.q\E'N%.q\E'N $Si%8 9I%.q\E'N%.q\E'N%.q\E'N  '' % ajG E !ajG F "!''!*aggaj1G F "!''!*aggaj1G G #!''!*aggaj!''!*=G G #!''!*aggaj!''!*=GG A "  Zx%@%@;;"$!%LE /Eagg,"C%%emm!<==#El^c1 ED%=11u:$$7u=!!$QWWj:"#eU"34 VI3ZWWQU^ !KKj 1JqM AB   -  177|q !*1gQWW"!*1g!*1gQWW"!*1g!*1g!*1gE L  #  5( ; ;;;"$!%LE /E%(FJJ,<,>&*#"'wEE3 #>??A:$%OPP s177|a/0A%%e,1AFFaK%)#.?*L%ME'N%)#eZ*@%AE'NED%=11u:QWW!11$7AGG q8H7IJ!!$QWWj:#Ez(F#  AFFaK%)#.?*G%HE'N%)#eU*;%|$D#*f#4w$m$ggg")U"2go&o&l# Cr Wh &&&%.&%8y!d(4(>|$D#*f#4w$m$ggg")U"2go&o&l# CT yj (((%.&%8y!d(4(>|$D#*f#4w$m$ggg")U"2go&o&l# Cv [k )))%.&%8y!d(4(>|$D#*f#4w$m$ggg")U"2go&o&l# CX =i '''%.&%8y!d(4(>|$D#*f#4w$m$ggg")U"2go&o&l# C: i '''%.&%8y!d(4(>|$D#*f#4w$m$ggg")U"2go&o&l# C      4E  3 3E :C j )   Jric [XX#XEU5$)a$ This API resizes a batch of images. The input must be a 3-D Tensor of the shape (num_batches, channels, in_w) or (num_batches, in_w, channels), or 4-D (num_batches, channels, in_h, in_w) or (num_batches, in_h, in_w, channels), or a 5-D Tensor of the shape (num_batches, channels, in_d, in_h, in_w) or (num_batches, in_d, in_h, in_w, channels), Where in_w is width of the input tensor, in_h is the height of the input tensor, in_d is the depth of the input tensor. and the resizing only applies on the three dimensions(depth, height and width). Supporting resample methods: - 'linear' : Linear interpolation - 'bilinear' : Bilinear interpolation - 'trilinear' : Trilinear interpolation - 'nearest' : Nearest neighbor interpolation - 'bicubic' : Bicubic interpolation - 'area': Area interpolation Linear interpolation is the method of using a line connecting two known quantities to determine the value of an unknown quantity between the two known quantities. Nearest neighbor interpolation is to perform nearest neighbor interpolation in both the 3rd dimension(in height direction) and the 4th dimension(in width direction) on input tensor. Bilinear interpolation is an extension of linear interpolation for interpolating functions of two variables (e.g. H-direction and W-direction in this op) on a rectilinear 2D grid. The key idea is to perform linear interpolation first in one direction, and then again in the other direction. Bicubic interpolation is an extension of cubic interpolation for interpolating data points on a two-dimensional regular grid. The interpolated surface is smoother than corresponding surfaces obtained by bilinear interpolation or nearest-neighbor interpolation. Trilinear interpolation is an extension of linear interpolation for interpolating functions of three variables (e.g. D-direction, H-direction and W-direction in this op) on a rectilinear 3D grid. The linear interpolation is performed on three directions. align_corners and align_mode are optional parameters,the calculation method of interpolation can be selected by them. Area interpolation is to perform area interpolation in both the 3rd dimension(in height direction) , the 4th dimension(in width direction) and the 5th dimension(in depth direction) on input tensor. Set to area will directly call `paddle.nn.functional.adaptive_avg_pool1d` or `paddle.nn.functional.adaptive_avg_pool2d` or `paddle.nn.functional.adaptive_avg_pool3d`. Example: .. code-block:: text For scale_factor: if align_corners = True && out_size > 1 : scale_factor = (in_size-1.0)/(out_size-1.0) else: scale_factor = float(in_size/out_size) Linear interpolation: if: align_corners = False , align_mode = 0 input : (N,C,W_in) output: (N,C,W_out) where: W_out = (W_{in}+0.5) * scale_{factor} - 0.5 else: input : (N,C,W_in) output: (N,C,W_out) where: W_out = W_{in} * scale_{factor} Nearest neighbor interpolation: if: align_corners = False input : (N,C,H_in,W_in) output: (N,C,H_out,W_out) where: H_out = floor (H_{in} * scale_{factor}) W_out = floor (W_{in} * scale_{factor}) else: align_corners = True input : (N,C,H_in,W_in) output: (N,C,H_out,W_out) where: H_out = round(H_{in} * scale_{factor}) W_out = round(W_{in} * scale_{factor}) Bilinear interpolation: if: align_corners = False , align_mode = 0 input : (N,C,H_in,W_in) output: (N,C,H_out,W_out) where: H_out = (H_{in}+0.5) * scale_{factor} - 0.5 W_out = (W_{in}+0.5) * scale_{factor} - 0.5 else: input : (N,C,H_in,W_in) output: (N,C,H_out,W_out) where: H_out = H_{in} * scale_{factor} W_out = W_{in} * scale_{factor} Bicubic interpolation: if: align_corners = False input : (N,C,H_in,W_in) output: (N,C,H_out,W_out) where: H_out = (H_{in}+0.5) * scale_{factor} - 0.5 W_out = (W_{in}+0.5) * scale_{factor} - 0.5 else: input : (N,C,H_in,W_in) output: (N,C,H_out,W_out) where: H_out = H_{in} * scale_{factor} W_out = W_{in} * scale_{factor} Trilinear interpolation: if: align_corners = False , align_mode = 0 input : (N,C,D_in,H_in,W_in) output: (N,C,D_out,H_out,W_out) where: D_out = (D_{in}+0.5) * scale_{factor} - 0.5 H_out = (H_{in}+0.5) * scale_{factor} - 0.5 W_out = (W_{in}+0.5) * scale_{factor} - 0.5 else: input : (N,C,D_in,H_in,W_in) output: (N,C,D_out,H_out,W_out) where: D_out = D_{in} * scale_{factor} H_out = H_{in} * scale_{factor} W_out = W_{in} * scale_{factor} For details of linear interpolation, please refer to Wikipedia: https://en.wikipedia.org/wiki/Linear_interpolation. For details of nearest neighbor interpolation, please refer to Wikipedia: https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation. For details of bilinear interpolation, please refer to Wikipedia: https://en.wikipedia.org/wiki/Bilinear_interpolation. For details of bicubic interpolation, please refer to Wikipedia: https://en.wikipedia.org/wiki/Bicubic_interpolation For details of trilinear interpolation, please refer to Wikipedia: https://en.wikipedia.org/wiki/Trilinear_interpolation. Parameters: x (Tensor): 3-D, 4-D or 5-D Tensor, its data type is float32, float64, or uint8, its data format is specified by :attr:`data_format`. If :attr:`data_format` is not provided, the data format will be presumed according to its dimension. See details in :attr:`data_format`. size (list|tuple|Tensor|None, optional): Output shape of image resize layer, the shape is (out_w, ) when input is a 3-D Tensor, the shape is (out_h, out_w) when input is a 4-D Tensor and is (out_d, out_h, out_w) when input is a 5-D Tensor. Default: None. If a list/tuple, each element can be an integer or a Tensor of shape: [1] or []. If a Tensor , its dimensions size should be a 1. scale_factor (float|Tensor|list|tuple|None, optional): The multiplier for the input height or width. At least one of :attr:`size` or :attr:`scale_factor` must be set. And :attr:`size` has a higher priority than :attr:`scale_factor`.Has to match input size if it is either a list or a tuple or a Tensor. If a list/tuple, each element can be an integer or a Tensor of shape: [1] or []. Default: None. mode (str, optional): The resample method. It supports 'linear', 'nearest', 'bilinear', 'area', 'bicubic' and 'trilinear' currently. Default: 'nearest' align_corners(bool, optional) : An optional bool, If True, the centers of the 4 corner pixels of the input and output tensors are aligned, preserving the values at the corner pixels. Default: False align_mode(int, optional) : An optional for linear/bilinear/trilinear interpolation. Refer to the formula in the example above, it can be '0' for src_idx = scale_factor*(dst_index+0.5)-0.5 , can be '1' for src_idx = scale_factor*dst_index. data_format (str, optional): Specify the data format of the input, and the data format of the output will be consistent with that of the input. An optional string from:`"NCW"`, `"NWC"`, `"NCHW"`, `"NHWC"`, `"NCDHW"`, `"NDHWC"`. The default value is None. When :attr:`data_format` is not specified, it will be automatically inferred from the input dimension of :attr:`x`. When :attr:`x` is a 3-D Tensor, :attr:`data_format` will be set to `"NCW"`; When :attr:`x` is a 4-D Tensor, :attr:`data_format` will be set to `"NCHW"`; When :attr:`x` is a 5-D Tensor, :attr:`data_format` will be set to `"NCDHW"`. When it is `"NCHW"`, the data should be stored in the order of: `[batch_size, input_channels, input_height, input_width]`. When it is `"NCDHW"`, the data should be stored in the order of: `[batch_size, input_channels, input_depth, input_height, input_width]`. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` Returns: A 3-D, 4-D or 5-D Tensor, with the same data format of the input :attr:`x`. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn as nn >>> input_data = paddle.randn(shape=(2, 3, 6, 10)).astype(paddle.float32) >>> upsample_out = paddle.nn.Upsample(size=[12, 12]) >>> output = upsample_out(x=input_data) >>> print(output.shape) paddle.Size([2, 3, 12, 12]) )rt)rArnrorprqrvrwres rhupsamplersV  ]  ric([5(a[R"XX#5$[USSS/S5 [USSS/S5 XUS.nUbX5S'[ S 0[ 5D6nUR URS9nURS US U0S 9 U$) a0 This layer performs bilinear on two inputs. See :ref:`api_paddle_nn_Bilinear` for details and output shape. Parameters: x1 (Tensor): the first input tensor, it's data type should be float32, float64. x2 (Tensor): the second input tensor, it's data type should be float32, float64. weight (Tensor): The learnable weights of this layer, shape is [out_features, in1_features, in2_features]. bias (Tensor, optional): The learnable bias(Bias) of this layer, shape is [1, out_features]. If it is set to None, no bias will be added to the output units. The default value is None. name (str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Default: None. Returns: Tensor: A 2-D Tensor of shape [batch_size, out_features]. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn.functional as F >>> x1 = paddle.randn((5, 5)).astype(paddle.float32) >>> x2 = paddle.randn((5, 4)).astype(paddle.float32) >>> w = paddle.randn((1000, 5, 4)).astype(paddle.float32) >>> b = paddle.randn((1, 1000)).astype(paddle.float32) >>> result = F.bilinear(x1, x2, w, b) >>> print(result.shape) paddle.Size([5, 1000]) x1rGrHr/x2)rTrUWeightBiasrRbilinear_tensor_productr)rWrXrY)r/) rrr/rr r[rcrSrd)rrweightbiasrerXrfrgs rhr/r/sLrv44 TIy+A:N TIy+A:Nf5  !6N468477bhh7G*6E3<   riaxisc  ^^[T[[[[R 45(d [ S5e[T[[45(aTS:XaU$TS:dTS:a [S5eTS;a [S5eU(a+[U[[[45(d [ S5eUGcqSnTS :XaS OTm[5(a[RR5RS:wa([RR5RnU(a([R "USTU(+TUbUOSUSL5$[R""USTU(+TUbUOSUSL5$[%S#0['5D6n[)US /S QS 5 UR+UR,S9n UR+[.R0R2R4SS9n UU4Sjn U "UR6TU(+U5n UR9S SU/0U /U /S.U S9 U $U(a [;S5e[=5(d[)US /S QS 5 UR,n ST- nU(Ga,[=5(aTS:Xa[R>"USS9$[A5(a6[T[[45(aTS:Xa[R>"USS9$TS:Xa[R>"USU- S9OUnURBn[=5(d[RB"U5n[U[5(aU/O [U5n[EU5S:dU5[IU5S- :a$[S[IU5SU5S35e[IU5[IU5:a#[S[IU5S[IU535eS/[IU5-n[=5(dUH nWUUU'M OUH nUUUU'M [RJ"USSSS 9n[MS/TSS!9m[RN"UT5n[RP"X5n[RP"UU 5n[RR"UUUS"9nU$TS :Xa[R>"XS9nU$UnU$)$a Dropout is a regularization technique for reducing overfitting by preventing neuron co-adaption during training. The dropout operator randomly sets the outputs of some units to zero, while upscale others according to the given dropout probability. Args: x (Tensor): The input tensor. The data type is float16, float32 or float64. p (float|int, optional): Probability of setting units to zero. Default: 0.5. axis (int|list|tuple, optional): The axis along which the dropout is performed. Default: None. training (bool, optional): A flag indicating whether it is in train phrase or not. Default: True. inplace (bool, optional): If set to ``True``, will do this operation in-place. Default: ``False`` mode(str, optional): ['upscale_in_train'(default) | 'downscale_in_infer']. 1. upscale_in_train (default), upscale the output at training time - train: :math:`out = input \times \frac{mask}{(1.0 - dropout\_prob)}` - inference: :math:`out = input` 2. downscale_in_infer, downscale the output at inference - train: :math:`out = input \times mask` - inference: :math:`out = input \times (1.0 - dropout\_prob)` name (str, optional): Name for the operation, Default: None. For more information, please refer to :ref:`api_guide_Name`. Returns: A Tensor representing the dropout, has same shape and data type as `x` . Examples: We use ``p=0.5`` in the following description for simplicity. 1. When ``axis=None`` , this is commonly used dropout, which dropout each element of x randomly. .. code-block:: text Let's see a simple case when x is a 2d tensor with shape 2*3: [[1 2 3] [4 5 6]] we generate mask with the same shape as x, which is 2*3. The value of mask is sampled from a Bernoulli distribution randomly. For example, we may get such mask: [[0 1 0] [1 0 1]] So the output is obtained from elementwise multiply of x and mask: [[0 2 0] [4 0 6]] Using default setting, i.e. ``mode='upscale_in_train'`` , if in training phase, the final upscale output is: [[0 4 0 ] [8 0 12]] if in test phase, the output is the same as input: [[1 2 3] [4 5 6]] we can also set ``mode='downscale_in_infer'`` , then if in training phase, the final output is: [[0 2 0] [4 0 6]] if in test phase, the scale output is: [[0.5 1. 1.5] [2. 2.5 3. ]] 2. When ``axis!=None`` , this is useful for dropping whole channels from an image or sequence. .. code-block:: text Let's see the simple case when x is a 2d tensor with shape 2*3 again: [[1 2 3] [4 5 6]] (1) If ``axis=0`` , this means the dropout is only performed in axis `0` . we generate mask with the shape 2*1. Only in axis `0` the value is randomly selected. For example, we may get such mask: [[1] [0]] The output is obtained from elementwise multiply of x and mask. Doing that the mask will be broadcast from 2*1 to 2*3: [[1 1 1] [0 0 0]] and the result after elementwise multiply is: [[1 2 3] [0 0 0]] then we can do upscale or downscale according to the setting of other arguments. (2) If ``axis=1`` , this means the dropout is only performed in axis `1` . we generate mask with the shape 1*3. Only in axis `1` the value is randomly selected. For example, we may get such mask: [[1 0 1]] Doing elementwise multiply the mask will be broadcast from 1*3 to 2*3: [[1 0 1] [1 0 1]] and the result after elementwise multiply is: [[1 0 3] [4 0 6]] (3) What about ``axis=[0, 1]`` ? This means the dropout is performed in all axes of x, which is the same case as default setting ``axis=None`` . (4) You may note that logically `axis=None` means the dropout is performed in none axis of x, We generate mask with the shape 1*1. Whole input is randomly selected or dropped. For example, we may get such mask: [[0]] Doing elementwise multiply the mask will be broadcast from 1*1 to 2*3: [[0 0 0] [0 0 0]] and the result after elementwise multiply is: [[0 0 0] [0 0 0]] Actually this is not what we want because all elements may set to zero~ When x is a 4d tensor with shape `NCHW`, where `N` is batch size, `C` is the number of channels, H and W are the height and width of the feature, we can set ``axis=[0,1]`` and the dropout will be performed in channel `N` and `C`, `H` and `W` is tied, i.e. paddle.nn.dropout(x, p, axis=[0,1]) . Please refer to ``paddle.nn.functional.dropout2d`` for more details. Similarly, when x is a 5d tensor with shape `NCDHW`, where `D` is the depth of the feature, we can set ``axis=[0,1]`` to perform dropout3d. Please refer to ``paddle.nn.functional.dropout3d`` for more details. .. code-block:: python >>> import paddle >>> paddle.seed(2023) >>> x = paddle.to_tensor([[1,2,3], [4,5,6]]).astype(paddle.float32) >>> y_train = paddle.nn.functional.dropout(x, 0.5) >>> y_test = paddle.nn.functional.dropout(x, 0.5, training=False) >>> y_0 = paddle.nn.functional.dropout(x, axis=0) >>> y_1 = paddle.nn.functional.dropout(x, axis=1) >>> y_01 = paddle.nn.functional.dropout(x, axis=[0,1]) >>> print(x) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 2., 3.], [4., 5., 6.]]) >>> print(y_train) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[2., 4., 0.], [8., 0., 0.]]) >>> print(y_test) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 2., 3.], [4., 5., 6.]]) >>> print(y_0) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[2., 4., 6.], [8. , 10., 12.]]) >>> print(y_1) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[2. , 4. , 6. ], [8. , 10., 12.]]) >>> print(y_01) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 0., 6.], [0., 0., 0.]]) z)p argument should be a number or Variablerr@!p argument should between 0 and 1)r4r3zBmode argument should be 'downscale_in_infer' or 'upscale_in_train'z/datatype of axis argument should be int or listNr4downgrade_in_inferdropoutrArFrErGrHrRT)rSrc>UbUS:XaURS:wa URn[U[5(a)URS/:wa[ STR35eUUUSLUbUOSTS.nU$)Nrr@zGRequired p.shape == [1] if type(p) is Variable, but received p.shape = ) dropout_probis_testfix_seedseeddropout_implementation) random_seedr^r r]r{)progrrrrZrpps rh get_attrsdropout..get_attrssLDAI43C3Cq3H++D ("((QC/#abcbibiajk%1& $D 0$($4D!.2  rirT)rMaskrVz(inplace not supported for dropout_nd yet?rr3zNaxis value should be greater than or equal to 0 and less than dimensions of x:z, but get axis value: z:length of axis should not be greater than dimensions of x:z, but get length of axis: rGrSrrr] fill_valuerSre)r)*r^rr_r r rr{rbr`rarrstaticr rrdropout_rr r[rrcrSr VarDescVarTypeUINT8 main_programrdNotImplementedErrorrrrr]rrr\uniformr greater_equalrmultiply)rArrtraininginplacerprerrfrgmaskrrZrS keep_prob scale_input input_shapeinput_shape_tensor drop_axes mask_shaper random_tensor keep_maskrets ` ` rhrrsx a%h : ; ;CDD!c5\"" 6H Ua!e@A A == P   Jtc4%788IJJ |$(,@$@ d  " # #}}113??1D}}99;GG L ,D!$>> (aD  !7fh7F $3CY ;;!'';JC<<ll**00=D &f111(lDIE   aSz!$v6   J %:   $3CY E   Q#X||AS11:a%#>#>18||AS11-- Qa)m4 ''K"$$%+\\!_"",T3"7"7T$ZI9~!S^c+6F6J%J dehiteudvwLMPQZM[L\\]^9~K 00 PQTU`QaPbb|~ABK~L}MNs;//J"$$"A$6q$9JqM##A$/NJqM##NN)#MA31I>A,,]A>I ++k9K Iu5I//+ytDCJ// Q0  J  Jric6US:dUS:a[SU35eURnUS;a[SUS35eU(a[R"S5 US:HnU(aUR S5n[ XSUS 9nU(aURS5nU$) a Randomly zero out entire 1D channels (feature maps) during training. Args: input: Input tensor of shape [C, L] (2D) or [N, C, L] (3D) p: Probability of a channel being zeroed. Default: 0.5 training: If False, returns input unchanged. Default: True inplace: If True, modifies input tensor in-place. Default: False WARNING: Currently not implemented (will behave as False). TODO: Implement in-place operation in future versions. Default: False Returns: Tensor with the same shape as input, where entire channels are zeroed with probability p Examples: .. code-block:: python >>> import paddle # Case 1: 3D input (batched) >>> x = paddle.randn([2, 3, 10]) # [N, C, L] >>> y_train = paddle.nn.functional.dropout1d(x, p=0.2) # Training mode >>> y_test = paddle.nn.functional.dropout1d(x, p=0.2, training=False) # Test mode >>> print("Original first channel:", x[0, 0, :]) >>> print("Train output (may be zeroed):", y_train[0, 0, :]) >>> print("Test output (always unchanged):", y_test[0, 0, :]) # Case 2: 2D input (single sample) >>> x = paddle.randn([3, 8]) # [C, L] >>> y = paddle.nn.functional.dropout1d(x, p=0.5) >>> print("Input shape:", x.shape) >>> print("Output shape:", y.shape) >>> print("Zeroed channels count:", paddle.sum(y == 0).item()) rr@z+dropout probability must be in [0, 1], got )rJrz&dropout1d expects 2D or 3D input, got Dzinplace=True is currently not supported in dropout1d and will be ignored. This parameter is reserved for future implementation.rJ)rrr)rbr RuntimeErrorwarningswarnr rr)rjrrrr need_squeezeresults rh dropout1dr.sR 1uAFqcJKK ::D 6CD6KLL  D 19L"Ua( ;F" Mric URn[U5S:wa[S[U5S35eUS;a[SUS35e[UUUS:XaSS /OSS /US US 9$) al Randomly zero out entire channels (in the batched input 4d tensor with the shape `NCHW` , a channel is a 2D feature map with the shape `HW` ). Each channel will be zeroed out independently on every forward call with probability `p` using samples from a Bernoulli distribution. See :ref:`api_paddle_nn_functional_dropout` for more details. Args: x (Tensor): The input is 4-D Tensor with shape [N, C, H, W] or [N, H, W, C]. The data type is float16, float32 or float64. p (float, optional): Probability of setting units to zero. Default: 0.5. training (bool, optional): A flag indicating whether it is in train phrase or not. Default: True. data_format (str, optional): Specify the data format of the input, and the data format of the output will be consistent with that of the input. An optional string from `NCHW` or `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): Name for the operation, Default: None. For more information, please refer to :ref:`api_guide_Name`. Returns: A Tensor representing the dropout2d, has same shape and data type as `x` . Examples: .. code-block:: python >>> import paddle >>> paddle.seed(1) >>> x = paddle.randn(shape=(2, 3, 4, 5)).astype(paddle.float32) >>> y_train = paddle.nn.functional.dropout2d(x) #train >>> y_test = paddle.nn.functional.dropout2d(x, training=False) #test >>> for i in range(2): ... for j in range(3): ... print(x[i,j,:,:]) ... print(y_train[i,j,:,:]) # may all 0 ... print(y_test[i,j,:,:]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.30557564, 0.11855337, 0.41220093, -0.09968963, 1.50014710], [ 1.24004936, -0.92485696, 0.08612321, 1.15149164, -0.09276631], [ 1.22873247, -1.46587241, -1.30802727, 0.19496460, 1.73776841], [ 0.40092674, 0.67630458, 0.72265440, 1.31720388, -1.41899264]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.61115128, 0.23710674, 0.82440186, -0.19937925, 3.00029421], [ 2.48009872, -1.84971392, 0.17224643, 2.30298328, -0.18553263], [ 2.45746493, -2.93174481, -2.61605453, 0.38992921, 3.47553682], [ 0.80185348, 1.35260916, 1.44530880, 2.63440776, -2.83798528]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.30557564, 0.11855337, 0.41220093, -0.09968963, 1.50014710], [ 1.24004936, -0.92485696, 0.08612321, 1.15149164, -0.09276631], [ 1.22873247, -1.46587241, -1.30802727, 0.19496460, 1.73776841], [ 0.40092674, 0.67630458, 0.72265440, 1.31720388, -1.41899264]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.88350385, -1.14767575, 0.51043051, -0.10051888, -0.61305630], [-0.12084112, 0.48506257, -1.13189507, 0.62806708, -0.80003673], [ 0.51513153, -0.08890446, 0.22753835, 0.11557858, 0.78117645], [ 1.47505593, 0.84618902, -0.38528305, -1.05887091, 0.16592593]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 1.76700771, -2.29535151, 1.02086103, -0.20103776, -1.22611260], [-0.24168225, 0.97012514, -2.26379013, 1.25613415, -1.60007346], [ 1.03026307, -0.17780893, 0.45507669, 0.23115715, 1.56235290], [ 2.95011187, 1.69237804, -0.77056611, -2.11774182, 0.33185187]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.88350385, -1.14767575, 0.51043051, -0.10051888, -0.61305630], [-0.12084112, 0.48506257, -1.13189507, 0.62806708, -0.80003673], [ 0.51513153, -0.08890446, 0.22753835, 0.11557858, 0.78117645], [ 1.47505593, 0.84618902, -0.38528305, -1.05887091, 0.16592593]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[-1.46668839, -0.38117948, 1.18678427, 0.38740095, 0.29117522], [-0.13538910, -0.14527084, -0.04912176, -0.26063353, 0.23640174], [ 0.45643106, 0.60587281, -1.03242552, -0.45319262, -1.57911122], [-0.08732958, -0.75898546, 0.14563090, -1.73751652, -0.89109969]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0., -0., 0. , 0. , 0. ], [-0., -0., -0., -0., 0. ], [0. , 0. , -0., -0., -0.], [-0., -0., 0. , -0., -0.]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[-1.46668839, -0.38117948, 1.18678427, 0.38740095, 0.29117522], [-0.13538910, -0.14527084, -0.04912176, -0.26063353, 0.23640174], [ 0.45643106, 0.60587281, -1.03242552, -0.45319262, -1.57911122], [-0.08732958, -0.75898546, 0.14563090, -1.73751652, -0.89109969]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.32110816, -0.76044011, 0.34456784, -0.39410326, 0.37896338], [ 0.52747023, 0.72711533, 0.29204839, 0.72493637, 0.31128070], [ 0.58046782, -1.78499067, -1.67504823, -0.38590902, -0.26243693], [ 0.96669912, 0.43670532, -0.38109761, 0.78405094, -2.17882323]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0., -0., 0. , -0., 0. ], [0. , 0. , 0. , 0. , 0. ], [0. , -0., -0., -0., -0.], [0. , 0. , -0., 0. , -0.]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.32110816, -0.76044011, 0.34456784, -0.39410326, 0.37896338], [ 0.52747023, 0.72711533, 0.29204839, 0.72493637, 0.31128070], [ 0.58046782, -1.78499067, -1.67504823, -0.38590902, -0.26243693], [ 0.96669912, 0.43670532, -0.38109761, 0.78405094, -2.17882323]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.17168395, 0.45112833, 0.63307828, 2.38763475, -1.27247131], [ 0.56171960, -1.09584677, 0.38300961, -0.57512099, 0.31011426], [-0.95336407, -1.04852903, -0.21312937, -0.53549880, -0.00074209], [ 2.22819090, 1.12403083, -0.04198794, -1.51167727, -0.42699185]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[0. , 0. , 0. , 0. , -0.], [0. , -0., 0. , -0., 0. ], [-0., -0., -0., -0., -0.], [0. , 0. , -0., -0., -0.]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.17168395, 0.45112833, 0.63307828, 2.38763475, -1.27247131], [ 0.56171960, -1.09584677, 0.38300961, -0.57512099, 0.31011426], [-0.95336407, -1.04852903, -0.21312937, -0.53549880, -0.00074209], [ 2.22819090, 1.12403083, -0.04198794, -1.51167727, -0.42699185]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.62503546, -0.20989063, -0.22046235, -0.38679042, -1.02590704], [ 1.04561794, 1.08428383, -0.52219963, -1.56003857, 0.89213932], [-0.16578521, 0.14524542, -0.45563069, 0.48180851, 1.35843253], [ 1.07669640, -0.84535235, -1.18651557, 0.79144061, -0.45565742]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[0. , -0., -0., -0., -0.], [0. , 0. , -0., -0., 0. ], [-0., 0. , -0., 0. , 0. ], [0. , -0., -0., 0. , -0.]]) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.62503546, -0.20989063, -0.22046235, -0.38679042, -1.02590704], [ 1.04561794, 1.08428383, -0.52219963, -1.56003857, 0.89213932], [-0.16578521, 0.14524542, -0.45563069, 0.48180851, 1.35843253], [ 1.07669640, -0.84535235, -1.18651557, 0.79144061, -0.45565742]]) rIz*dimensions of x should be 4, but received z != 4rzJAttr(data_format) should be 'NCHW' or 'NHWC'. Received Attr(data_format): rrrr@rr3rrrrprer]r\rbrrArrrwrer s rh dropout2dr3EsD''K ;18[9I8J% P  ** ""-a 1   "f,aV1a&    ric URn[U5S:wa[S[U5S35eUS;a[SUS35e[UUUS:XaSS /OSS /US US 9$) ae Randomly zero out entire channels (in the batched input 5d tensor with the shape `NCDHW` , a channel is a 3D feature map with the shape `DHW` ). Each channel will be zeroed out independently on every forward call with probability `p` using samples from a Bernoulli distribution. See :ref:`api_paddle_nn_functional_dropout` for more details. Args: x (Tensor): The input is 5-D Tensor with shape [N, C, D, H, W] or [N, D, H, W, C]. The data type is float32 or float64. p (float, optional): Probability of setting units to zero. Default: 0.5. training (bool, optional): A flag indicating whether it is in train phrase or not. Default: True. data_format (str, optional): Specify the data format of the input, and the data format of the output will be consistent with that of the input. An optional string from ``NCDHW`` or ``NDHWC``. When it is ``NCDHW`` , the data is stored in the order of: [batch_size, input_channels, input_depth, input_height, input_width]. Default: ``NCDHW`` . name (str, optional): Name for the operation, Default: None. For more information, please refer to :ref:`api_guide_Name`. Returns: A Tensor representing the dropout3d, has same shape and data type with `x` . Examples: .. code-block:: python >>> import paddle >>> x = paddle.randn(shape=(2, 3, 4, 5, 6)).astype(paddle.float32) >>> y_train = paddle.nn.functional.dropout3d(x) #train >>> y_test = paddle.nn.functional.dropout3d(x, training=False) #test >>> print(x[0,0,:,:,:]) >>> print(y_train[0,0,:,:,:]) # may all 0 >>> print(y_test[0,0,:,:,:]) rz*dimensions of x should be 5, but received z != 5rzLAttr(data_format) should be 'NCDHW' or 'NDHWC'. Received Attr(data_format): rrrr@rIr3r0r1r2s rh dropout3dr5sP''K ;18[9I8J% P  ,, ""-a 1   "g-aVAq6    ric[U[[45(d [S5eUS:dUS:a [ S5e[ 5(d[ US/SQS5 U(GaUS:Xa[R"USS 9$S nS nU*U-nSU- SX'S ----S -nU*U-U-n URn U(d URn OPURS :a [ S5e[URSS 5S/[URS S5--n [R"U SSSS9n [XSS9n[R "X5n [R""X5n [R$"[U SU S9U 5n[XU S9n [R&"[R("X 5[R"XS 95n[R&"[R"XS 9XS9nU$U$)Nz#p argument should be a float or intrr@rrAr alpha_dropoutr r g,x?g2֫?rJgz.Feature alpha dropout needs at least 2D input.rGr r rr)r^rr_r{rbrrrrrSr]rr`r\rrrrsubtractaddr)rAfeature_dropoutrrrealpharalpha_pabrSr r$r% drop_maskyress rh_feature_alpha_dropout_implrBs a% & &=>>1uA<==    s?  6<<- -11&5.!eA N* + 4 BL1 ''Kvvz Dqwwr{+qcC 4D.DDK ycs  { B((: KK 1 OO {s% @) { > JJ OOA ) LL 2 jja11@ ric[USXUS9$)a Alpha Dropout is a type of Dropout that maintains the self-normalizing property. For an input with zero mean and unit standard deviation, the output of Alpha Dropout maintains the original mean and standard deviation of the input. Alpha Dropout fits well to SELU activate function by randomly setting activations to the negative saturation value. Args: x (Tensor): The input tensor. The data type is bfloat16, float16, float32 or float64. p (float | int, optional): Probability of setting units to zero. Default 0.5. training (bool, optional): A flag indicating whether it is in train phrase or not. Default True. name (str | None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: A Tensor representing the dropout, has same shape and data type as `x`. Examples: .. code-block:: python >>> import paddle >>> paddle.seed(1) >>> x = paddle.to_tensor([[-1, 1], [-1, 1]]).astype(paddle.float32) >>> y_train = paddle.nn.functional.alpha_dropout(x, 0.5) >>> y_test = paddle.nn.functional.alpha_dropout(x, 0.5, training=False) >>> print(y_train) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.77919382, 1.66559887], [-0.10721093, -0.77919382]]) >>> print(y_test) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[-1., 1.], [-1., 1.]]) Fr:rrrerBrArrres rhr7r7WsL ' 5At ric[USXUS9$)aP A channel is a feature map, Feature Alpha Dropout randomly masks out entire channels. Alpha Dropout is a type of Dropout that maintains the self-normalizing property. For an input with zero mean and unit standard deviation, the output of Alpha Dropout maintains the original mean and standard deviation of the input. Alpha Dropout fits well to SELU activate function by randomly setting activations to the negative saturation value. Args: x (Tensor): The input tensor. The data type is bfloat16, float16, float32 or float64. p (float | int, optional): Probability of setting units to zero. Default 0.5. training (bool, optional): A flag indicating whether it is in train phrase or not. Default True. name (str | None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: A Tensor representing the dropout, has same shape and data type as `x`. Examples: .. code-block:: python >>> import paddle >>> paddle.seed(1) >>> x = paddle.to_tensor([[-1, 1], [-1, 1]]).astype(paddle.float32) >>> y_train = paddle.nn.functional.feature_alpha_dropout(x, 0.5) >>> y_test = paddle.nn.functional.feature_alpha_dropout(x, 0.5, training=False) >>> print(y_train) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.77919382, 1.66559887], [-0.10721093, -0.77919382]]) >>> print(y_test) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[-1., 1.], [-1., 1.]]) TrDrErFs rhfeature_alpha_dropoutrHsN ' 41d ric| US;d SUS35e[UR5n[5(aE[U[[ R 45(a URS:XaUR5$US:XGa[U[[45(Ga[U5US- S-:wGaUnUn [U5n U SU-:a(SU-U - n U[U[5(aS/OSU --n[U5US-:XaU(d8[SU-S- S S 5V s/sHn U S-S:XaXS- OXS-PM nn [5(a"[R"X[U 55n U $[5(a`[U [ R R"5(a[R"XU 5$[R"X[U 55$[%US /S QS 5 ['U S [[([4S 5 [U [(5(a [U 5n [+S/0[-5D6nUR/S S9nUR1U5n UR3S SU0SU 0XS.S9 U $US;d SU35eUcUS:XaSnOUS:XaSnOUS:XaSnUR55nUS;d SU35eSS/SS/SS/S.nUUU;dS US!UUS"U35e/n[U[[ R"45(aUS#;aTSnUS:Xa$[7[9S$S%S&9U/SS'9nSS/n[;UUS'9nGO US:Xa![7U[9S(S%S&9/SS'9nS/n[;UUS'9nOUS);aRSnUS:Xa#[7[9S$S%S&9U/SS'9nSS/n[;UUS'9nOUS:Xa![7U[9S(S%S&9/SS'9nS/n[;UUS'9nO[U5nUS#;a;SnUS:XaSSSS/UQnSS/n[;UUS'9nO\US:Xa/UQSPSPnS/n[;UUS'9nO@US);a:SnUS:XaSSSS/UQnSS/n[;UUS'9nOUS:Xa/UQSPSPnS/n[;UUS'9n[=5(a>[U[5(aUR?5n[R@"XX#U5n OwX#US*.nSU/0n[U[5(a U/US+'/US,'OUUS,'[+S00[-5D6nUR/S.S9nUR1U5n UR3S-USU 0US9 [U5S:wa [CU US'9n U $s sn f)1a)# Pad tensor according to ``'pad'`` and ``'mode'``. Note: 1. Denote ``'x'``'s dimension as N (same in the following). If mode is ``'constant'``, the length of ``'pad'`` can be any even number less than or equal to 2*N. 2. When mode is ``'constant'``, and ``'pad'`` is a list or tuple, and the length of ``'pad'`` is not equal to 2*(N - 2): 2.1. If the length of ``'pad'`` is 2*N, the order of padding can be customized by ``'pad_from_left_axis'``. if ``'pad_from_left_axis'`` is True, then the padding order will be started from the first dimension of ``'x'`` and moving backward according to ``'pad'``; else if ``'pad_from_left_axis'`` is False, then the padding order will be started from the last dimension of ``'x'`` and moving forward according to ``'pad'``. 2.2. Otherwise, the padding will be started from the last dimension. 3. When mode is any of ``'reflect'``, ``'replicate'``, ``'circular'``, or ``'pad'`` is a tensor, or the length of ``'pad'`` is 2*(N - 2), and the dimension of ``'x'`` only supports 3-D, 4-D and 5-D. In these cases, input ``'x'`` will be padded on [D, H, W] axes according to ``'data_format'``. It will pad from the last dimension to the first dimension of [D, H, W] axes. Specifically, if N = 3, then the pad has the form (pad_left, pad_right); if N = 4, then the pad has the form (pad_left, pad_right, pad_top, pad_bottom); if N = 5, then the pad has the form (pad_left, pad_right, pad_top, pad_bottom, pad_front, pad_back). 4. If mode is ``'reflect'``, pad[0] and pad[1] must be no greater than width-1. The height and depth dimension has the same condition. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``. For example, ``input=tensor_x`` is equivalent to ``x=tensor_x``. Args: x (Tensor): The input tensor with data type float32, float64, int32, int64, complex64 or complex128. input: An alias for ``x`` , with identical behavior. pad (Tensor|list[int]|tuple[int]): The padding size with data type int. Refer to Note for details. mode (str, optional): Four modes: ``'constant'`` (default), ``'reflect'``, ``'replicate'``, ``'circular'``. Default is ``'constant'``. - 'constant' mode, uses a constant value to pad the input tensor. - 'reflect' mode, uses reflection of the input boundaries to pad the input tensor. - 'replicate' mode, uses input boundaries to pad the input tensor. - 'circular' mode, uses circular input to pad the input tensor. value (float, optional): The value to fill the padded areas in 'constant' mode . Default is :math:`0.0`. data_format (str, optional): An string from: ``'NCL'``, ``'NLC'``, ``'NHWC'``, ``'NCHW'``, ``'NCDHW'``, ``'NDHWC'``. Specify the data format of the input data when: 1. mode is any of ``'reflect'``, ``'replicate'`` or ``'circular'``; or 2. the input ``'pad'`` is a tensor; or 3. the length of ``'pad'`` is ``2*(x.ndim - 2)``. The default value is None, which means it will be automatically inferred from the input dimension of ``'x'``. When ``'x'`` is a 3-D Tensor, data_format will be set to ``'NCL'``; When ``'x'`` is a 4-D Tensor, data_format will be set to ``'NCHW'``; When ``'x'`` is a 5-D Tensor, data_format will be set to ``'NCDHW'``. pad_from_left_axis (bool, optional): The parameter is only valid when mode is ``'constant'`` and the input ``'pad'`` is length of ``'pad'`` is ``2*x.ndim``, the order of padding can be customized. If True, the padding will be started from the first axis of ``'x'``; if False, it will be started from the last axis of ``'x'``. Default: True. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: ``'None'``. Returns: Tensor, a Tensor padded according to pad and mode and data type is same as input. Example: .. code-block:: text x = [[[[[1., 2., 3.], [4., 5., 6.]]]]] Case 0: pad = [0, 0, 0, 0, 0, 0, 1, 1, 0, 0], mode = 'constant' value = 0 pad_from_left_axis = True Out = [[[[[0., 0., 0.], [1., 2., 3.], [4., 5., 6.], [0., 0., 0.]]]]] Out.shape = [1, 1, 1, 4, 3] Case 1: pad = [0, 0, 0, 0, 0, 0, 1, 1, 0, 0], mode = 'constant' value = 0 pad_from_left_axis = False Out = [[[[[0., 0., 0.], [0., 0., 0.]]], [[[1., 2., 3.], [4., 5., 6.]]], [[[0., 0., 0.], [0., 0., 0.]]]]] Out.shape = [1, 3, 1, 2, 3] Case 3: pad = [1, 0, 0, 1], mode = 'constant' value = 0 Out = [[[[[0., 1., 2., 3.], [0., 4., 5., 6.], [0., 0., 0., 0.]]]]] Out.shape = [1, 1, 1, 3, 4] Case 4: pad = [2, 2, 1, 1, 0, 0], mode = 'constant' value = 0 Out = [[[[[0. 0. 0. 0. 0. 0. 0.] [0. 0. 1. 2. 3. 0. 0.] [0. 0. 4. 5. 6. 0. 0.] [0. 0. 0. 0. 0. 0. 0.]]]]] Out.shape = [1, 1, 1, 4, 7] Case 5: pad = [2, 2, 1, 1, 0, 0], mode = 'reflect' Out = [[[[[6. 5. 4. 5. 6. 5. 4.] [3. 2. 1. 2. 3. 2. 1.] [6. 5. 4. 5. 6. 5. 4.] [3. 2. 1. 2. 3. 2. 1.]]]]] Out.shape = [1, 1, 1, 4, 7] Case 6: pad = [2, 2, 1, 1, 0, 0], mode = 'replicate' Out = [[[[[1. 1. 1. 2. 3. 3. 3.] [1. 1. 1. 2. 3. 3. 3.] [4. 4. 4. 5. 6. 6. 6.] [4. 4. 4. 5. 6. 6. 6.]]]]] Out.shape = [1, 1, 1, 4, 7] Case 7: pad = [2, 2, 1, 1, 0, 0], mode = 'circular' Out = [[[[[5. 6. 4. 5. 6. 4. 5.] [2. 3. 1. 2. 3. 1. 2.] [5. 6. 4. 5. 6. 4. 5.] [2. 3. 1. 2. 3. 1. 2.]]]]] Out.shape = [1, 1, 1, 4, 7] Examples: .. code-block:: python >>> import paddle >>> import paddle.nn.functional as F >>> # example 1 >>> x_shape = (1, 1, 3) >>> x = paddle.arange(paddle.prod(paddle.to_tensor(x_shape)), dtype="float32").reshape(x_shape) + 1 >>> y = F.pad(x, [0, 0, 0, 0, 2, 3], value=1, mode='constant', data_format="NCL") >>> print(y) Tensor(shape=[1, 1, 8], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1., 1., 1., 2., 3., 1., 1., 1.]]]) >>> # example 2 >>> x_shape = (1, 1, 3) >>> x = paddle.arange(paddle.prod(paddle.to_tensor(x_shape)), dtype="float32").reshape(x_shape) + 1 >>> y = F.pad(x, [2, 3], value=1, mode='constant', data_format="NCL") >>> print(y) Tensor(shape=[1, 1, 8], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1., 1., 1., 2., 3., 1., 1., 1.]]]) >>> # example 3 >>> x_shape = (1, 1, 2, 3) >>> x = paddle.arange(paddle.prod(paddle.to_tensor(x_shape)), dtype="float32").reshape(x_shape) + 1 >>> y = F.pad(x, [1, 2, 1, 1], value=1, mode='circular') >>> print(y) Tensor(shape=[1, 1, 4, 6], dtype=float32, place=Place(cpu), stop_gradient=True, [[[[6., 4., 5., 6., 4., 5.], [3., 1., 2., 3., 1., 2.], [6., 4., 5., 6., 4., 5.], [3., 1., 2., 3., 1., 2.]]]]) >>> # example 4 >>> x_shape = (1, 1, 3) >>> x = paddle.arange(paddle.prod(paddle.to_tensor(x_shape)), dtype="float32").reshape(x_shape) + 1 >>> y = F.pad(x, [1, 0, 0, 1, 0, 0], value=0, mode='constant', pad_from_left_axis=True) >>> print(y) Tensor(shape=[2, 2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[[0., 0., 0.], [0., 0., 0.]], [[1., 2., 3.], [0., 0., 0.]]]) >>> # example 5 >>> x_shape = (1, 1, 3) >>> x = paddle.arange(paddle.prod(paddle.to_tensor(x_shape)), dtype="float32").reshape(x_shape) + 1 >>> y = F.pad(x, [1, 0, 0, 1, 0, 0], value=0, mode='constant', pad_from_left_axis=False) >>> print(y) Tensor(shape=[1, 2, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[[0., 1., 2., 3.], [0., 0., 0., 0.]]]) >>> # example 6 >>> x_shape = (1, 1, 3) >>> x = paddle.arange(paddle.prod(paddle.to_tensor(x_shape)), dtype="float32").reshape(x_shape) + 1 >>> y = F.pad(x, [1, 0, 0, 1], value=0, mode='constant') >>> print(y) Tensor(shape=[1, 2, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[[0., 1., 2., 3.], [0., 0., 0., 0.]]]) )r7r8r6r9zFmode should be one of constant, reflect, replicate, circular, but got rrr6rJ)rr@rrA)rFrGrHrint64 complex64 complex128rEpad pad_valuerrTr)rQrNrV)rrIrz4input tensor dimension must be in [3, 4, 5] but got rNCLrIrrr)rOrrNLCrrzNdata_format should be in one of [NCL, NCHW, NCDHW, NLC, NHWC, NDHWC], but got rPrrzinput tensor dimension is z , it's data format should be in z but got )rOrr)rIrrRr)rJ)rPrr)rpr}rwPaddingsrQpad3drjrM)rS)"r\r]rr^r rr#rncloner`rarrrMrrr rrrr_r r[rrcrdrrrr rtolistrSr)rArMrpr}rwpad_from_left_axisrex_dimrQrN padding_lenpad_len_for_paddingsrrgrfrSsupported_format_mapunsqueezed_dimrZrXs rhrMrMs#Z   QQUPVVWX   LE cHfmm4 5 5#((a-779   sT5M * * Ha ' (m U "#$u9{#: *S$*?*?A3T$#H CEAI%*<q5y1}b"55A$%q5A:Q8E?B5    **Q% *:;CJ ==)VZZ%5%566zz!y99zz!uY/?@@    9kE3+A5I i % %i(I/fh/""C"877>8CL'@    F >eWE F   A:K aZ K aZ!K##%K J J - ! J 5> F  W  .u5 5 $UG+KL`afLgKhhqr}q~ 5N##)),-- 2 2!KzeD8#>QG"#Qan5!c5W#=>QG"#an5 4 4!KzeD8#>QG"#Qan5!c5W#=>QG"#an53i 2 2!Kz!Q(C("#Qan5!"lQll"#an5 4 4!Kz!Q(C("#Qan5!"lQll"#an5 c8 $ $**,Cll14 <kJs c8 $ $"%F:  "E*  #E* 11""G"<77>%U   >ac/ Jas"!T9z3.0.0zpaddle.nn.ZeroPad2DzPlease use class ZeroPad2D)since update_tolevelreasonpaddingc [UUSSUUS9$)a Pads the input tensor boundaries with zero according to 'pad'. Args: x(Tensor): The input tensor with data type float16/float32/float64/int32/int64. padding(int | Tensor | List[int] | Tuple[int]): The padding size with data type int. The input dimension should be 4 and pad has the form (pad_left, pad_right, pad_top, pad_bottom). data_format(str, optional): An string from: "NHWC", "NCHW". Specify the data format of the input data. Default: "NCHW". name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, padded with 0 according to pad and data type is same as input. Examples: .. code-block:: python >>> import paddle >>> import paddle.nn.functional as F >>> x_shape = paddle.to_tensor([1, 1, 2, 3]) >>> x = paddle.arange(paddle.prod(x_shape), dtype="float32").reshape(x_shape) + 1 >>> y = F.zeropad2d(x, [1, 2, 1, 1]) >>> print(y) Tensor(shape=[1, 1, 4, 6], dtype=float32, place=Place(cpu), stop_gradient=True, [[[[0., 0., 0., 0., 0., 0.], [0., 1., 2., 3., 0., 0.], [0., 4., 5., 6., 0., 0.], [0., 0., 0., 0., 0., 0.]]]]) r6r)rMrpr}rwrerT)rArarwres rh zeropad2drc- s$Z      rircXURUS:XdURUS:Xa[[R"X5US9$[R"URU/URU/5n[[R"X5US9n[[R"X5US9n[[R"X5US9nUSURU- USURU- pUS:waXh-nU S:waXy-n[ [ Xg-X3-S95n XZ- n U $)a  Compute cosine similarity between x1 and x2 along axis. Parameters: x1 (Tensor): First input. float32/double. x2 (Tensor): Second input. float32/double. axis (int, optional): Dimension of vectors to compute cosine similarity. Default is 1. eps(float, optional): Small value to avoid division by zero. Default is 1e-8. Returns: Tensor, a Tensor representing cosine similarity between x1 and x2 along axis. Examples: .. code-block:: text Case 0: x1 = [[0.8024077 0.9927354 0.27238318 0.8344984 ] [0.48949873 0.5797396 0.65444374 0.66510963] [0.1031398 0.9614342 0.08365563 0.6796464 ] [0.10760343 0.7461209 0.7726148 0.5801006 ]] x2 = [[0.62913156 0.1536727 0.9847992 0.04591406] [0.9098952 0.15715368 0.8671125 0.3156102 ] [0.4427798 0.54136837 0.5276275 0.32394758] [0.3769419 0.8535014 0.48041078 0.9256797 ]] axis = 1 eps = 1e-8 Out: [0.5275037 0.8368967 0.75037485 0.9245899] Code Examples: .. code-block:: python >>> import paddle >>> import paddle.nn as nn >>> paddle.seed(1) >>> x1 = paddle.randn(shape=[2, 3]) >>> x2 = paddle.randn(shape=[2, 3]) >>> result = paddle.nn.functional.cosine_similarity(x1, x2, axis=0) >>> print(result) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [ 0.97689527, 0.99996042, -0.55138415]) rrQr@)r)r]rrrbroadcast_shaperr) rrrepsbsw12w1w2m1m2n12cos_sims rhcosine_similarityrod s` xx~bhhtn16??2*66   $ 0288D>2B CB foob%D 1C V__R $4 0B V__R $4 0B URXXd^ #RURXXd^%; Qw W Qw W tBG+ ,CiG Nric[5(a[R"XU5$[5(a3[R"XSS5nUb[R "XB5$U$[ S0[5D6nURn[US/SQS5 [US/SQS5 U/U/S.nSSS.nURU5n URSUS U 0US 9 Ub/URU5n URS U /U/S.S U /0S S 0S 9 U $U n U $)a2 Fully-connected linear transformation operator. For each input :math:`X` , the equation is: .. math:: Out = XW + b where :math:`W` is the weight and :math:`b` is the bias. If the weight is a 2-D tensor of shape :math:`[in\_features, out\_features]` , input should be a multi-dimensional tensor of shape :math:`[batch\_size, *, in\_features]` , where :math:`*` means any number of additional dimensions. The linear operator multiplies input tensor with weight and produces an output tensor of shape :math:`[batch\_size, *, out\_features]` , If :math:`bias` is not None, the bias should be a 1-D tensor of shape :math:`[out\_features]` and will be added to the output. Parameters: x (Tensor): Input tensor. The data type should be bfloat16, float16, float32 or float64. weight (Tensor): Weight tensor. The data type should be float16, float32 or float64. bias (Tensor, optional): Bias tensor. The data type should be float16, float32 or float64. If it is set to None, no bias will be added to the output units. name (str, optional): Normally there is no need for user to set this parameter. For detailed information, please refer to :ref:`api_guide_Name` . Returns: Tensor, the shape is :math:`[batch\_size, *, out\_features]` and the data type is the same with input :math:`x` . Examples: .. code-block:: python >>> import paddle >>> paddle.seed(2023) >>> x = paddle.randn((3, 2), dtype="float32") >>> print(x) Tensor(shape=[3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.06132207, 1.11349595], [ 0.41906244, -0.24858207], [-1.85169315, -1.50370061]]) >>> weight = paddle.full(shape=[2, 4], fill_value=0.5, dtype="float32", name="weight") >>> print(weight) Tensor(shape=[2, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.50000000, 0.50000000, 0.50000000, 0.50000000], [0.50000000, 0.50000000, 0.50000000, 0.50000000]]) >>> bias = paddle.ones(shape=[4], dtype="float32", name="bias") >>> print(bias) Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [1., 1., 1., 1.]) >>> y = paddle.nn.functional.linear(x, weight, bias) >>> print(y) Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 1.58740902, 1.58740902, 1.58740902, 1.58740902], [ 1.08524013, 1.08524013, 1.08524013, 1.08524013], [-0.67769694, -0.67769694, -0.67769694, -0.67769694]]) Fr,rArDrS)rTrU)trans_xtrans_y matmul_v2rrVelementwise_addrr)r,) rrr,rmatmulr9r r[rSrrrcrd) rArrrergrfrSrXrZtmprAs rhr,r, s<@}}Q-- mmAue4  ::c( (J22 s?     7   s&*!e477>CL   ;;EBC   &!U$0rl   C ric tUS:dUS:a [S5e[5(a [R"X[ U55$[ US/SQS5 [ S 0[5D6nSUlURUR5nURSU(aXS.OS U0S U0S [ U50S 9 U$)ap Label smoothing is a mechanism to regularize the classifier layer and is called label-smoothing regularization (LSR).Label smoothing is proposed to encourage the model to be less confident, since optimizing the log-likelihood of the correct label directly may cause overfitting and reduce the ability of the model to adapt. Label smoothing replaces the ground-truth label :math:`y` with the weighted sum of itself and some fixed distribution :math:`\mu`. For class :math:`k`, i.e. .. math:: \\tilde{y_k} = (1 - \epsilon) * y_k + \epsilon * \mu_k, where :math:`1 - \epsilon` and :math:`\epsilon` are the weights respectively, and :math:`\\tilde{y}_k` is the smoothed label. Usually uniform distribution is used for :math:`\mu`. See more details about label smoothing in https://arxiv.org/abs/1512.00567. Parameters: label(Tensor): The input variable containing the label data. The label data should use one-hot representation. It's a multidimensional tensor with a shape of :math:`[N_1, ..., Depth]`, where Depth is class number. The dtype can be "float16" "float32" and "float64". prior_dist(Tensor, optional): The prior distribution to be used to smooth labels. If not provided, an uniform distribution is used. It's a multidimensional tensor with a shape of :math:`[1, class\_num]` . The default value is None. epsilon(float, optional): The weight used to mix up the original ground-truth distribution and the fixed distribution. The default value is 0.1. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: The tensor containing the smoothed labels. Examples: .. code-block:: python >>> import paddle >>> paddle.disable_static() >>> x = paddle.to_tensor([[[0, 1, 0], >>> [ 1, 0, 1]]], dtype="float32", stop_gradient=False) >>> output = paddle.nn.functional.label_smooth(x) >>> print(output) Tensor(shape=[1, 2, 3], dtype=float32, place=Place(cpu), stop_gradient=False, [[[0.03333334, 0.93333334, 0.03333334], [0.93333334, 0.03333334, 0.93333334]]]) r r z-The value of epsilon must be between 0 and 1.labelrD label_smoothT)rT PriorDistrTrepsilonrV)ry) rbrrryrrr r[rrcrSrd)rx prior_distr{rerf smooth_labels rhryry sz}# HII""5eGnEE 3  468 4FE<>> # CPU or single GPU >>> import paddle >>> num_classes = 20 >>> batch_size = 10 >>> num_samples = 6 >>> paddle.seed(2023) >>> label = paddle.randint(low=0, high=num_classes, shape=[batch_size], dtype='int64') >>> remapped_label, sampled_class_index = paddle.nn.functional.class_center_sample(label, num_classes, num_samples) >>> print(label) Tensor(shape=[10], dtype=int64, place=Place(cpu), stop_gradient=True, [17, 10, 5 , 18, 8 , 8 , 19, 14, 10, 14]) >>> print(remapped_label) Tensor(shape=[10], dtype=int64, place=Place(cpu), stop_gradient=True, [4, 2, 0, 5, 1, 1, 6, 3, 2, 3]) >>> print(sampled_class_index) Tensor(shape=[7], dtype=int64, place=Place(cpu), stop_gradient=True, [5 , 8 , 10, 14, 17, 18, 19]) .. code-block:: python :name: code-example2 >>> # doctest: +REQUIRES(env:DISTRIBUTED) >>> # Multi GPU, test_class_center_sample.py >>> import paddle >>> import paddle.distributed as dist >>> strategy = dist.fleet.DistributedStrategy() >>> dist.fleet.init(is_collective=True, strategy=strategy) >>> batch_size = 10 >>> num_samples = 6 >>> rank_id = dist.get_rank() >>> # num_classes of each GPU can be different, e.g num_classes_list = [10, 8] >>> num_classes_list = [10, 10] >>> num_classes = paddle.sum(paddle.to_tensor(num_classes_list)) >>> label = paddle.randint(low=0, high=num_classes.item(), shape=[batch_size], dtype='int64') # type: ignore[arg-type] >>> label_list = [] # type: ignore >>> dist.all_gather(label_list, label) >>> label = paddle.concat(label_list, axis=0) >>> remapped_label, sampled_class_index = paddle.nn.functional.class_center_sample(label, num_classes_list[rank_id], num_samples) >>> print(label) >>> print(remapped_label) >>> print(sampled_class_index) >>> #python -m paddle.distributed.launch --gpus=0,1 test_class_center_sample.py >>> # rank 0 output: Tensor(shape=[20], dtype=int64, place=CUDAPlace(0), stop_gradient=True, [10, 17, 15, 11, 9 , 12, 18, 18, 17, 18, 19, 2 , 8 , 13, 11, 13, 9 , 10, 0 , 4 ]) Tensor(shape=[20], dtype=int64, place=CUDAPlace(0), stop_gradient=True, [6 , 11, 10, 7 , 4 , 8 , 12, 12, 11, 12, 13, 1 , 3 , 9 , 7 , 9 , 4 , 6 , 0 , 2 ]) Tensor(shape=[6], dtype=int64, place=CUDAPlace(0), stop_gradient=True, [0, 2, 4, 8, 9, 3]) >>> # rank 1 output: Tensor(shape=[20], dtype=int64, place=CUDAPlace(1), stop_gradient=True, [10, 17, 15, 11, 9 , 12, 18, 18, 17, 18, 19, 2 , 8 , 13, 11, 13, 9 , 10, 0 , 4 ]) Tensor(shape=[20], dtype=int64, place=CUDAPlace(1), stop_gradient=True, [6 , 11, 10, 7 , 4 , 8 , 12, 12, 11, 12, 13, 1 , 3 , 9 , 7 , 9 , 4 , 6 , 0 , 2 ]) Tensor(shape=[7], dtype=int64, place=CUDAPlace(1), stop_gradient=True, [0, 1, 2, 3, 5, 7, 8]) FN is_memberzjExpected group is False, None or instance of paddle.distributed.collective.Group (got group: )rr@z+Expected num_samples less than or equal to z, got num_samples rz6Expected label_size > 0 (got label_size: z7Expected label_dims == 1 (got label_dims: rxrJrclass_center_samplerRLabel) RemappedLabelSampledLocalClassCenter) num_classes num_samplesring_idnranksrankrrrV)hasattrrbrr is_compiled_with_distr distributed ParallelEnvrget_group_rank world_sizerr`r]r\r rrrrrr r[rcrSrd)rxrrgrouprrr parallel_env global_rank label_sizer label_dimsrop_typerfremapped_labelsampled_class_centers rhrrl sR UNemwuk/J/J #  uk""5??+<+<G D F E  % % ' '!--99;L&++K=))+6  16 \,,5<>kk?N"DDkkE  +'; '&D( ,D! " / //rir kernel_sizestridedilation)rA output_sizesrLrNrQrPc h[S0[5D6n[US/SQS5 [UR5S:XdS5e[ R "UR5S:dS5eSn[U[5(aX/nO#U"U5(a[U5S :XdS 5e[U[5(aX"/nO#U"U5(a[U5S :XdS 5e[U[5(aX3/nO#U"U5(a[U5S :XdS 5e[U[5(aXU/nO#U"U5(a[U5S :XdS 5e[U[5(aU/S-nOV[U[[45(a0[U5S :XaUS -nO&[U5S:XaO[S5e[S5e[5(a[R"XX#XE5n U $URUR S9n UR#SSU0SU 0UUUUUS.S9 U $)aJ Combines an array of sliding local blocks into a large containing tensor. also known as col2im when operated on batched 2D image tensor. Fold calculates each combined value in the resulting large tensor by summing all values from all containing blocks. For each input :math:`x` with shape [N, C_in , L], the output shape [N, C_out, H_out, W_out] can be calculated as following. .. math:: H_{out} &= output\_size[0] \\ W_{out} &= output\_size[1] \\ C_{out} &= \frac{C_{in}}{kernel\_sizes[0]\times kernel\_sizes[1]} \\ Parameters: x(Tensor): 3-D Tensor, input tensor of format [N, C, L], data type can be float32, float64, complex64 or complex128 output_sizes(int|list|tuple): The size of output size, should be [output_size_h, output_size_w] or an integer o treated as [o, o]. kernel_sizes(int|list|tuple): The size of convolution kernel, should be [k_h, k_w] or an integer k treated as [k, k]. strides(int|list|tuple, optional): The strides, should be [stride_h, stride_w] or an integer stride treated as [stride, stride]. For default, strides will be [1, 1]. paddings(int|list|tuple, optional): The paddings of each dimension, should be [padding_top, padding_left, padding_bottom, padding_right] or [padding_h, padding_w] or an integer padding. If [padding_h, padding_w] was given, it will expanded to [padding_h, padding_w, padding_h, padding_w]. If an integer padding was given, [padding, padding, padding, padding] will be used. For default, paddings will be [0, 0, 0, 0] dilations(int|list|tuple, optional): the dilations of convolution kernel, should be [dilation_h, dilation_w], or an integer dilation treated as [dilation, dilation]. For default, it will be [1, 1]. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` Returns: The tensor formed by combining a group of sliding local blocks The output shape is [N, Cout, H, W] as described above. Examples: .. code-block:: pycon >>> import paddle >>> import paddle.nn.functional as F >>> x = paddle.randn([2,3*2*2,12]) >>> y = F.fold(x, output_sizes=[4, 5], kernel_sizes=2) >>> x = paddle.randn([2,3*2*2,12]) >>> y = F.fold(x, output_sizes=[4, 5], kernel_sizes=2) >>> print(y.shape) paddle.Size([2, 3, 4, 5]) foldrA)rGrHrKrLrz'input should be the format of [N, C, L]rz7The number of elements must greater or equal than zero.c.[U[[45$rlrrs rhr fold.._is_list_or_tuple_ rrirJzHoutput_sizes should either be an integer or a list/tuple of two integersrKrMrOrIzApaddings should either be an integer or a list of 2 or 4 integerszWUnexpected type of paddings, it should be either an integer or a listof 2 or 4 integersrRrTrU)rrLrNrQrPrV)r)r r[rr\r]mathprodr^r_r`rarbrrrrcrSrd) rArrLrNrQrPrerfrrgs rhrr1 sV` ,68 ,F 3A6 qww<1 GGG  99QWW  "A "/,$$$3 !,//S5F!5K V L,$$$3 !,//S5F!5K V L'3$!'**G 0A Q B)S!!* !),,#i.A2E S F(C  :> HtUm , , x=A !|H ]a  S  !  kk \H " J77agg7F8#J , ,"$&    Jri)r@rr@N)rAr#rLr)rNr)rQ Size2 | Size4rPr)re str | Nonereturnr#)NNr.FNF)rjr#rnShapeLike | NoneroShapeLike | float | Nonerpr2rqrrr bool | Nonersrrr#)NNr.FrNNN)rAr#rnrrorrpr2rqrrvr_rw8DataLayout1DVariant | DataLayout2D | DataLayout3D | Nonerrrrerrr#)rrr~rrr#) NNr.FrNNFN)rAr#rnrrorrpr2rqrrvr_rwrrrrrsrrerrr#)NNr.FrNN)rAr#rnrrorrpr2rqrrvr_rwrrerrr#)NN) rr#rr#rr#r Tensor | Nonererrr#)?NTFr3N)rAr#rrrzint | Sequence[int] | Nonerrrrrpr5rerrr#)rTF) rj paddle.Tensorrrrrrrrr)rTrN) rAr#rrrrrwr%rerrr#)rTrN) rAr#rrrrrwr&rerrr#)TN) rAr#r:rrrrrrerrr#)rTN) rAr#rrrrrerrr#)r6r NTN)rAr#rMr(rpr:r}rrwzDataLayoutND | NonerWrrerrr#)rN) rAr#rar(rwr%rerrr#)r@g:0yE>) rr#rr#rr_rfrrr#) rAr#rr#rrrerrr#)Ng?N) rxr#r|rr{rrerrr#rl) rxr#rr_rr_rzGroup | bool | Nonerztuple[Tensor, Tensor])rAr#rr)rLr)rNr)rQrrPr)rerrr#)Y __future__rinspectrr*typingrrrrtyping_extensionsrrrr paddle.base.layer_helperr paddle.common_ops_importr r paddle.frameworkr rrrpaddle.tensor.creationr paddle.utilsrpaddle.utils.decorator_utilsrrpaddle.utils.layers_utilsrbase.data_feederrrrrrrrrtensor.creationrtensor.manipulationrr collections.abcr!r"r#paddle._typingr$r%r&r'r(r)r*&paddle.distributed.communication.groupr+r2__annotations__r5r:r?__all__rCrtr signature __signature__rr/rr.r3r5rBr7rHrMrcror,ryrrrmrirhrs|# .. & 0C (#ME .-$6(+=")G#i&&NOL)O$+?% #*(#i   T TTT T  T  T Tn "-1&*.  +     (    "-1& *.     +        A (       g1X"-1& *.S S S+S  S  S  S AS(SS S Sl$--.BC  "%)& M M M#M  M  M  M AM M Mh 777 7  7  7  7t#w '++k k k %k k  k  k k k!k`  A A AA A  AL & U U UU U  U  Ut ' ; ; ;; ;  ;  ;D 9 99 9 9  9  9| ( ( ((  (  (Z ) ) ))  )  )XcG9%& *'+#{ { { {  { % {  { { {'{|  # ' !' . . ..  .  .  .b&%!8<<<<"%<05< <"<D k k k k  k  k`!% W WWW  W  W|"& B0 B0B0B0  B0  B0JY&&:K \  S SSS S  S  S S S Sri