ёiV| SSKJr SSKrSSKrSSKrSSKJrJr SSKr SSK r SSK J r SSK J r JrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJr SSK J!r! SSK"J#r#J$r$ SSK%J&r& SS K'J(r(J)r)J*r*J+r+ SS K,J-r- S S K.J/r/J0r0J1r1J2r2 S S K3J4r4 S SK5J6r6J7r7J8r8J9r9J:r:J;r; SSKJ?r? SSK@JArAJBrB SSKCJDrDJErEJFrFJGrGJHrHJIrIJJrJJKrKJLrLJMrMJNrNJOrOJPrPJQrQJRrRJSrSJTrTJUrUJVrVJWrWJXrXJYrYJZrZJ[r[J\r\J]r]J^r^J_r_J`r`JaraJbrbJcrcJdrdJereJfrfJgrgJhrhJiriJjrjJkrkJlrlJmrmJnrnJoroJprp \(aSSKqJrrr SSKJsrs SSK Jtrt SSKuJvrv SSK'Jwrw /rx\#RR\#RR\#RR\#RR\#RR/r\#RGR\#RGR/rSrSr\-SSSjj5rSSSjjrSSSjjrSSSjjr\-SSS jj5r\("S!/S"/S#.5SSS$.SS&jjj5r\-SSS'jj5rS(S)S*S+S,S-S.S/S0S1. rS2r\+"SS!/S%S3/5SSSS4.SS5jjj5r\+"SS!/S%S3/5\-SSS6.SS7jjj55rSSS8jjr\+"SS!/S%S3/5SSSS4.SS9jjj5r\+"SS!/S%S3/5\-SSS6.SS:jjj55r\+"SS!/S%S3/5SSSS;.SS<jjj5r\+"SS!/S%S3/5\-SSS=.SS>jjj55rSS$.SS?jjr\)"5SSS$.SS@jjj5r\-SSSAjj5r\+"SS!/S%S3/5SSS$.SSBjjj5r\-SSSCjj5r\r\r\rSD\l\rSE\l\+"SS!/S%S3/5SSS$.SSFjjj5r\+"SS!/S%S3/5\-SSSGjj55rSSHjrSSIjrSSJjrSSKjrSSLjrSSSMjjrSSSNjjrSSSOjjrSSSPjjr\-SSSQjj5rSSSSjjrSSSTjjrSSSUjjrSSSVjjrSSSWjjr\-SSSXjj5rSSSYjjrSSSZjjr\-SSS[jj5rSSS\jjr\-SSS]jj5rSS^jr\-SS_j5rSSS`jjr\("S!/Sa/S#.5SSS$.SSbjjj5rSSScjjr\w"1SdkSeSfSgSh9SSSijj5r\w"1SdkSjSkSlSh9SSSmjj5r\-SSSnjj5r\-SSSojj5r\-SSSpjj5r\*"SS!/5SSS$.SSqjjj5r\-SSSrjj5r\*"SS!/5SSSsjj5rSSStjjr\+"SS!/SRSu/5SSS$.SSvjjj5r\-SSSwjj5rSSSxjjrSSSyjjrSSSzjjr\*"SS!/5SSSSS{.SS|jjj5r\-SSS}jj5r\+"SS!/SRSu/5SSS~jj5r\-SSSjj5rGSGSSjjrGSSjrGSSjrSSSjjrSSSjjr\-SSSjj5rSSSjjr\-SSSjj5rSSSjjr\-SSSjj5rSSSjjr\-SSSjj5rSSSjjr\-SSSjj5rSGSSjjr\-SGSSjj5rSSSjjr\-SSSjj5rSSSjjrSSSjjrSSSjjrGSGSSjjr\-GSGSSjj5rSGSSjjr\-SGSSjj5rSSSjjr\-SSSjj5rSSSjjrSSSjjr\+"SS!/S%S3/5SSSjj5r\+"SS!/S%S3/5SSSjj5r\+"SS!/S%S3/5SSSjj5r\+"SS!/S%S3/5SSSjj5r\("S!/Su/S.5GSSS$.GS Sjjj5rSSSjjrSSSjjr\*"SS!/5SSS$.GS Sjjj5r\-SSSjj5rSSSjjrGS GS SjjrSGS SjjrGSGSSjjrGSGSSjjrGSGSSjjrSGSSjjrSSSjjrSSSjjr\-SSSjj5rSSSjjrSSSjjrSSSjjrSGSSjjGr\-SGSSjj5GrSSSjjGrSSSjjGrGSSjGrGSGSSjjGr\-GSGSSjj5GrGSGSSjjGr\-GSGSSjj5GrGSGSSjjGr GSGSSjjGr GSGSSjjGr GSGSSjjGr SGSSjjGr \-SSSjj5GrSSSjjGr\-SSSjj5GrGSGSSjjGrSSSjjGrSSSjjGrSSSjjGrSSSjjGrSSSjjGr\-SSSjj5Gr\+"SS/SS/5GSGSSjj5GrSGSSjjGrg() annotationsN) TYPE_CHECKINGLiteral)_C_ops)allamaxaminanyisfiniteisinfisnanloglog1plog2log10 logsumexpmaximumminimummultiplysignsinsumtanh)DataType)VarDesc dygraph_utils)Value)ParamAliasDecoratorfloor_divide_decoratorparam_one_aliasparam_two_alias)inplace_apis_in_dygraph_only) check_dtype check_typecheck_variable_and_dtype convert_dtype)Variable) LayerHelperconvert_np_dtype_to_dtype_corein_dynamic_modein_dynamic_or_pir_mode in_pir_mode)_complex_to_real_dtype)generate_layer_fn)castcast_)-absabs_acosacos_acoshacosh_asinasin_asinhasinh_atanatan_atanhatanh_ceilceil_coscos_coshcosh_erferf_expexp_expm1expm1_floorfloor_ reciprocal reciprocal_roundround_rsqrtrsqrt_sigmoidsigmoid_sin_sinhsinh_sqrtsqrt_squaresquare_tantan_)Sequence)Number)Tensor) DTypeLike)ForbidKeywordsDecoratorcNUbl[U[5(dW[U[[45(a [U5nO0[U[5(aU/nO[ S[ U535eUc/nU/:Xd"[U5[UR5:XaSnX 4$SnX 4$)zj Internal function for max, min, amax and amin. It computes the attribute reduce_all value based on axis. z:The type of axis must be int, list or tuple, but received TF) isinstancelisttuplerangeint TypeErrortypelenshapeaxisx reduce_alls R/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/tensor/math.py_get_reduce_axisrus   4 6 6 dUEN + +:D c " "6DLTRVZLY  | rzSY#agg,.     c[U[[RR45(aAUR /:wa+UR S[ UR 5:XaSnX 4$SnX 4$[X5up [RRU5(a[RRU5nX 4$)NrTF) rgr(paddlepirrrornruutils _contain_var_convert_to_tensor_listrps rt_get_reduce_axis_with_tensorr}s$6::#3#3455 ::  1 QWW =J   J  ,D4 << $ $T * *<<77=D  rvrrcN[5(a[R"U5$g)z} Inplace version of ``log`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_log`. N)r,rlog_rrnames rtrrs {{1~rvc[5(a[Uc![R"X[U5U5$[R"X[U5U5n[R "Xd5$[ 5(a@[R"X[U5U5n[RRXd5$[US/SQS5 SU/0n[U5US.n[U[5(aU/US'O[U5US'[S 0[5D6n U RUR S9nU R#SUSU0US 9 U R%U5$) a Scale operator. Putting scale and bias to the input Tensor as following: ``bias_after_scale`` is True: .. math:: Out=scale*X+bias ``bias_after_scale`` is False: .. math:: Out=scale*(X+bias) Args: x (Tensor): Input N-D Tensor of scale operator. Data type can be bfloat16, float16, float32, float64, int8, int16, int32, int64, uint8, complex64, complex128. scale (float|Tensor): The scale factor of the input, it should be a float number or a 0-D Tensor with shape [] and data type as float32. bias (float): The bias to be put on the input. bias_after_scale (bool): Apply bias addition after or before scaling. It is useful for numeric stability in some circumstances. act (str|None, optional): Activation applied to the output such as tanh, softmax, sigmoid, relu. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: Output Tensor of scale operator, with shape and data type same as input. Examples: .. code-block:: python >>> # scale as a float32 number >>> import paddle >>> data = paddle.arange(6).astype("float32").reshape([2, 3]) >>> print(data) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 1., 2.], [3., 4., 5.]]) >>> res = paddle.scale(data, scale=2.0, bias=1.0) >>> print(res) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1. , 3. , 5. ], [7. , 9. , 11.]]) .. code-block:: python >>> # scale with parameter scale as a Tensor >>> import paddle >>> data = paddle.arange(6).astype("float32").reshape([2, 3]) >>> print(data) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 1., 2.], [3., 4., 5.]]) >>> factor = paddle.to_tensor([2], dtype='float32') >>> res = paddle.scale(data, scale=factor, bias=1.0) >>> print(res) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1. , 3. , 5. ], [7. , 9. , 11.]]) rr) float16bfloat16uint16float32float64int8int16int32int64uint8 complex64 complex128scaleX)biasbias_after_scale ScaleTensordtypeOutrminputsoutputsattrsr)r,rrfloatr_append_activation_in_dygraphr.rx pir_utilsappend_activation_in_pirr&rgr(r)locals"create_variable_for_type_inferencer append_opappend_activation) rrrrractroutrrhelpers rtrrs?N ;<<%+7GH Hll1U4[2BC::3DD ll1U4[2BC88BB   # &s$K 0  eX & &%*GF= !"5\E'N1177agg7F%U  '',,rvc[5(a[R"XU5$[US/SQS5 [ S 0[ 5D6nUR URS9nURSSU0SU0XS.S9 U$) a stanh activation. .. math:: out = b * \frac{e^{a * x} - e^{-a * x}}{e^{a * x} + e^{-a * x}} Parameters: x (Tensor): The input Tensor with data type bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64. scale_a (float, optional): The scale factor a of the input. Default is 0.67. scale_b (float, optional): The scale factor b of the output. Default is 1.7159. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: A Tensor with the same shape and data type as ``x`` (integer types are autocasted into float32). Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1.0, 2.0, 3.0, 4.0]) >>> out = paddle.stanh(x, scale_a=0.67, scale_b=1.72) >>> print(out) Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [1.00616539, 1.49927628, 1.65933096, 1.70390463]) rr rrrrrrrrrstanhrrr)scale_ascale_br)r) r-rrr&r)rrrr)rrrrrrrs rtrr9sJ||A00    "1177agg7F8CL%:   rvc&[5(a[R"X5$[5(a&[ USSS/S5 [R"X5$[ S0[ 5D6n[US[S5 [U5S:a [S5e[U5H$upE[ US[U5-S -/S QS5 M& [ USSS/S5 URUS R5nURSXS .S U/0S9 U$)aJ Based on the given index parameter, the OP selects a specific row from each input Tensor to construct the output Tensor. If the input of this OP contains :math:`m` Tensors, where :math:`I_{i}` means the i-th input Tensor, :math:`i` between :math:`[0,m)` . And :math:`O` means the output, where :math:`O[i]` means the i-th row of the output, then the output satisfies that :math:`O[i] = I_{index[i]}[i]` . For Example: .. code-block:: text Given: inputs = [[[0,0,3,4], [0,1,3,4], [0,2,4,4], [0,3,3,4]], [[1,0,3,4], [1,1,7,8], [1,2,4,2], [1,3,3,4]], [[2,0,3,4], [2,1,7,8], [2,2,4,2], [2,3,3,4]], [[3,0,3,4], [3,1,7,8], [3,2,4,2], [3,3,3,4]]] index = [[3],[0],[1],[2]] out = [[3,0,3,4], # out[0] = inputs[index[0]][0] = inputs[3][0] = [3,0,3,4] [0,1,3,4], # out[1] = inputs[index[1]][1] = inputs[0][1] = [0,1,3,4] [1,2,4,2], # out[2] = inputs[index[2]][2] = inputs[1][2] = [1,2,4,2] [2,3,3,4]] # out[3] = inputs[index[3]][3] = inputs[2][3] = [2,3,3,4] Args: inputs (list[Tensor]|tuple[Tensor, ...]): The input Tensor list. The list elements are N-D Tensors of data types float32, float64, int32, int64, complex64, complex128. All input Tensor shapes should be the same and rank must be at least 2. index (Tensor): Used to select some rows in the input Tensor to construct an index of the output Tensor. It is a 2-D Tensor with data type int32 or int64 and shape [M, 1], where M is the number of input Tensors. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: Output of multiplex OP, with data type being float32, float64, int32, int64. Examples: .. code-block:: python >>> import paddle >>> img1 = paddle.to_tensor([[1, 2], [3, 4]], dtype=paddle.float32) >>> img2 = paddle.to_tensor([[5, 6], [7, 8]], dtype=paddle.float32) >>> inputs = [img1, img2] >>> index = paddle.to_tensor([[1], [0]], dtype=paddle.int32) >>> res = paddle.multiplex(inputs, index) >>> print(res) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[5., 6.], [3., 4.]]) indexrr multiplexrr#z8inputs should be a list object with at least 2 elements.zinput[])rrrrrrr)rIdsrrmrr)r)r,rrr.r&r)rr%rhrn ValueError enumeratestrrrr)rrrridrrrs rtrr}sn..  7Wg.  ..5FH568d[9 v;?J v&EB $3r7"S( ' ! 7Wg.  77q H.SEN   rvcd[5(a![R"X[U5U5$g)z Inplace version of ``scale`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_scale`. N)r,rscale_r)rrrrrrrs rtrrs*}}QuT{4DEErvinputexponentrryrrc&[5(a[U[[45(a[R "XUS9$[U[ R[[ RR45(a[R"XUS9$[S[U535e[U[[45(aJ[S 0[5D6nSU0nSU0nUR!UR"S9nUR%SUSU0US9 U$[U[ R[45(aH[S 0[5D6nUR!UR"S9n['[S 0[5D65$[S [U535e) a Compute the power of Tensor elements. The equation is: .. math:: out = x^{y} Note: ``paddle.pow`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, The parameter name ``exponent`` can be used as an alias for ``y``. For example, ``pow(input=2, exponent=1.1)`` is equivalent to ``pow(x=2, y=1.1)``. Args: x (Tensor): An N-D Tensor, the data type is bfloat16, float16, float32, float64, int32, int64, complex64 or complex128. input: An alias for ``x`` , with identical behavior. y (float|int|Tensor): If it is an N-D Tensor, its data type should be the same as `x`. exponent: An alias for ``y`` , with identical behavior. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. out (Tensor, optional): The output tensor. If set, the result will be stored in this tensor. Default is None. Returns: N-D Tensor. A location into which the result is stored. Its dimension and data type are the same as `x`. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 2, 3], dtype='float32') >>> # example 1: y is a float or int >>> res = paddle.pow(x, 2) >>> print(res) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [1., 4., 9.]) >>> res = paddle.pow(x, 2.5) >>> print(res) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [1. , 5.65685415 , 15.58845711]) >>> # example 2: y is a Tensor >>> y = paddle.to_tensor([2], dtype='float32') >>> res = paddle.pow(x, y) >>> print(res) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [1., 4., 9.]) rzLy must be scalar, Tensor(in dygraph mode), Value(in pir mode) but received: powrfactorrrrz/y must be scalar or tensor type, but received: )r)elementwise_pow)r-rgrkrrrrxrcr(ryrrrlrmr)rrrr_elementwise_op)rrrrrrrrs rtrrsb| a#u & &::a, , FMM8VZZ5E5EF G G))!C8 8^_cde_f^gh  a#u & & 3&(3F1XFqME;;!'';JC   6E3>> import paddle >>> x = paddle.to_tensor([2, 3, 4], 'float64') >>> y = paddle.to_tensor([1, 5, 2], 'float64') >>> z = paddle.add(x, y) >>> print(z) Tensor(shape=[3], dtype=float64, place=Place(cpu), stop_gradient=True, [3., 8., 6.]) r/rrrrrrrrrrqr)r)r-rrr)rrrrrrrrrrscaled_yroutputs rtrrsJ % 19zz!3//;&(;z  5 5agg >  A:   aSz + %s3  ::177C"*FO2,   rv)rc[URUR5nX@R:wa[SUSURS35eUS:waX-OUn[R"X5$)z} Inplace version of ``add`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_add`. The shape of broadcast output * is different from that of inplace tensor  in the Inplace operation.r/)broadcast_shaperorradd_rrrrr out_shapers rtrrsr 1IGG,YK7abcbibiajkE F  "QJqyAH ;;q ##rvcf[R"[R"[R"X- 5*55n[R"X5nUR [R :XdUR [R:XaURUR 5nX4-$)a Elementwise LogAddExp Operator. Add of exponentiations of the inputs The equation is: .. math:: Out=log(X.exp()+Y.exp()) $X$ the tensor of any dimension. $Y$ the tensor whose dimensions must be less than or equal to the dimensions of $X$. There are two cases for this operator: 1. The shape of $Y$ is the same with $X$. 2. The shape of $Y$ is a continuous subsequence of $X$. For case 2: 1. Broadcast $Y$ to match the shape of $X$, where axis is the start dimension index for broadcasting $Y$ onto $X$. 2. If $axis$ is -1 (default), $axis$=rank($X$)-rank($Y$). 3. The trailing dimensions of size 1 for $Y$ will be ignored for the consideration of subsequence, such as shape($Y$) = (2, 1) => (2). For example: .. code-block:: text shape(X) = (2, 3, 4, 5), shape(Y) = (,) shape(X) = (2, 3, 4, 5), shape(Y) = (5,) shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2 shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1 shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0 shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0 Args: x (Tensor): Tensor of any dimensions. Its dtype should be int32, int64, bfloat16, float16, float32, float64. y (Tensor): Tensor of any dimensions. Its dtype should be int32, int64, bfloat16, float16, float32, float64. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: N-D Tensor. A location into which the result is stored. It's dimension equals with x. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([-1, -2, -3], 'float64') >>> y = paddle.to_tensor([-1], 'float64') >>> z = paddle.logaddexp(x, y) >>> print(z) Tensor(shape=[3], dtype=float64, place=Place(cpu), stop_gradient=True, [-0.30685282, -0.68673831, -0.87307199]) ) rxrrJr4rrrrastype)rrrrlog_1p_maximums rt logaddexpr(srp\\&**fjj&7%78 9F~~a#H~~%6<<)G??6<<0  rvcz[5(a!US:waX-OUn[R"XUS9$[S 0[ 5D6nUS:waUR UR 5OUnUS:waURSSU/0SU/0USS.S 9 UR UR 5nURSXS .SU0S S 0S 9 U$)au Subtract two tensors element-wise. The equation is: .. math:: out = x - y Note: ``paddle.subtract`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): the input tensor, it's data type should be bfloat16, float16, float32, float64, int16, int32, int64, complex64, complex128. y (Tensor): the input tensor, it's data type should be bfloat16, float16, float32, float64, int16, int32, int64, complex64, complex128. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. alpha (Number, optional): Scaling factor for Y. Default: 1. out (Tensor, optional): The output tensor. Default: None. Returns: N-D Tensor. A location into which the result is stored. If x, y have different shapes and are "broadcastable", the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2], [7, 8]]) >>> y = paddle.to_tensor([[5, 6], [3, 4]]) >>> res = paddle.subtract(x, y) >>> print(res) Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[-4, -4], [ 4, 4]]) >>> x = paddle.to_tensor([[[1, 2, 3], [1, 2, 3]]]) >>> y = paddle.to_tensor([1, 0, 4]) >>> res = paddle.subtract(x, y) >>> print(res) Tensor(shape=[1, 2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[[ 0, 2, -1], [ 0, 2, -1]]]) >>> x = paddle.to_tensor([2, float('nan'), 5], dtype='float32') >>> y = paddle.to_tensor([1, 4, float('nan')], dtype='float32') >>> res = paddle.subtract(x, y) >>> print(res) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [1. , nan, nan]) >>> x = paddle.to_tensor([5, float('inf'), -float('inf')], dtype='float64') >>> y = paddle.to_tensor([1, 4, 5], dtype='float64') >>> res = paddle.subtract(x, y) >>> print(res) Tensor(shape=[3], dtype=float64, place=Place(cpu), stop_gradient=True, [ 4. , inf., -inf.]) r/rrrrrrrrrrqrr)r-rrr)rrrrrs rtrrgsD % 19q44;&(;z  5 5agg >  A:   aSz + %s3  ::177C"*FO2,   rvc[URUR5nX@R:wa[SUSURS35eUS:waX-OUn[R"X5$)z Inplace version of ``subtract`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_subtract`. rrrr/)rrorr subtract_rs rtrrst 1IGG,YK7abcbibiajkE F  "QJqyAH   A ((rv) rounding_modercUcD[5(a[R"XUS9nU$[[ S 0[ 5D65nU$US:Xa[5(a[R "XUS9nU$[[ S 0[ 5D65nSU0n0n[ S 0[ 5D6n [US/SQS5 U RURS9nU RSXxSU0S9 U$US:XaD[5(a[R"XUS9nU$[[ S 0[ 5D65nU$S US 3n [U 5e)a Divide two tensors element-wise. The equation is: .. math:: out = x / y Note: ``paddle.divide`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``other`` can be used as an alias for ``y``. For example, ``divide(input=tensor_x, other=tensor_y)`` is equivalent to ``divide(x=tensor_x, y=tensor_y)``. Args: x (Tensor): the input tensor, it's data type should be bool, bfloat16, float16, float32, float64, int8, int16, int32, int64, uint8, complex64, complex128. alias: ``input``. y (Tensor): the input tensor, it's data type should be bool, bfloat16, float16, float32, float64, int8, int16, int32, int64, uint8, complex64, complex128. alias: ``other``. rounding_mode (str|None, optional): The rounding mode. Can be None (default), "trunc" (truncate toward zero), or "floor" (round down toward negative infinity). out (Tensor, optional): The output tensor. Default: None. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: N-D Tensor. A location into which the result is stored. If x, y have different shapes and are "broadcastable", the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([2, 3, 4], dtype='float64') >>> y = paddle.to_tensor([1, 5, 2], dtype='float64') >>> z = paddle.divide(x, y) >>> print(z) Tensor(shape=[3], dtype=float64, place=Place(cpu), stop_gradient=True, [2. , 0.60000000, 2. ]) rtruncrrrrrrrrmrrrrNzLdiv expected rounding_mode to be one of None, 'trunc', or 'floor' but found .)rrr) r-rrrr)r trunc_divider&rrrrr) rrrrrrrestmprrrmsgs rtrrsXh ! # #--#.C "+"L68"LMC ' ! ! # #%%a4C "+"L68"LMC3ZFE 5FH5F $SBG ;;#));LC   V5#,   ' ! ! # #%%a4C  "?fh?C \]j\kklmorv)rch[URUR5nX@R:wa[SUSURS35eUc[R"X5nU$US:Xa[R "X5nU$US:Xa[R "X5nU$SUS3n[U5e)z Inplace version of ``divide`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_divide`. rrrrrNzMdiv_ expected rounding_mode to be one of None, 'trunc', or 'floor' but found r)rrorrdivide_ trunc_divide_ floor_divide_)rrrrrrrrs rtrr9s 1IGG,YK7abcbibiajkE F  nnQ" J ' !""1( J ' !""1( J^^k]llmnorvc[XUS9$)z\ Alias for paddle.divide with rounding_mode=None. Please refer to :ref:`api_paddle_divide`. r)r)rrrs rt true_divider Ys %C ((rvc[5(a^[U[R5(a*[R "U[ R"U5US9$[R "XUS9$[[S0[5D65$)u Floor divide two tensors element-wise and rounds the quotinents to the nearest integer toward negative infinite. The equation is: .. math:: out = floor(x / y) - :math:`x`: Multidimensional Tensor. - :math:`y`: Multidimensional Tensor. Note: ``paddle.floor_divide`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): the input tensor, it's data type should be uint8, int8, int32, int64, float32, float64, float16, bfloat16. alias: ``input``. y (Tensor｜Number): the input tensor or number, it's data type should be uint8, int8, int32, int64, float32, float64, float16, bfloat16. alias: ``other``. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. out (Tensor|None, optional): The output tensor. Default: None. Returns: N-D Tensor. A location into which the result is stored. It's dimension equals with $x$. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([2, 3, 8, 7]) >>> y = paddle.to_tensor([1, 5, 3, 3]) >>> z = paddle.floor_divide(x, y) >>> print(z) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [2, 0, 2, 2]) >>> x = paddle.to_tensor([2, 3, 8, 7]) >>> y = paddle.to_tensor([1, -5, -3, -3]) >>> z = paddle.floor_divide(x, y) >>> print(z) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [2, -1, -3, -3]) rr) r-rgnumbersrbrrrx to_tensorrr)rrrrrrs rtrrfsgl a ( (&&q&*:*:1*=3G G""1S11{NVXNOOrvc[URUR5nX0R:wa[SUSURS35e[R"X5$)z Inplace version of ``floor_divide`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_floor_divide`. rrr)rrorrr rrrrrs rtr r se  1IGG,YK7abcbibiajkE F      %%rvc[5(aO[U[[45(a[R "/XR S9n[R"XUS9$[[S0[5D65$)ay Mod two tensors element-wise. The equation is: .. math:: out = x \% y .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``other`` can be used as an alias for ``y``. Note: ``paddle.remainder`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor And `mod`, `floor_mod` are all functions with the same name Args: x (Tensor): the input tensor, it's data type should be bfloat16, float16, float32, float64, int32, int64. y (Tensor): the input tensor, it's data type should be bfloat16, float16, float32, float64, int32, int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. out (Tensor|None, optional): The output tensor. If set, the result will be stored in this tensor. Default is None. Returns: N-D Tensor. A location into which the result is stored. If x, y have different shapes and are "broadcastable", the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([2, 3, 8, 7]) >>> y = paddle.to_tensor([1, 5, 3, 3]) >>> z = paddle.remainder(x, y) >>> print(z) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 3, 2, 1]) >>> z = paddle.floor_mod(x, y) >>> print(z) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 3, 2, 1]) >>> z = paddle.mod(x, y) >>> print(z) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 3, 2, 1]) rr)r) r-rgrkrrxfullrrrrr)rrs rtrrs[l a#u & & B1A#..{IIJJrvc[URUR5nX0R:wa[SUSURS35e[R"X5$)z Inplace version of ``remainder`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_remainder`. rrr)rrorr remainder_rs rtrrse  1IGG,YK7abcbibiajkE F     Q ""rvz Inplace version of ``mod`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_mod`. z Inplace version of ``floor_mod_`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_floor_mod_`. c[5(a[R"XUS9$[[ S0[ 5D65$)a multiply two tensors element-wise. The equation is: .. math:: out = x * y Note: Supported shape of :attr:`x` and :attr:`y` for this operator: 1. `x.shape` == `y.shape`. 2. `x.shape` could be the continuous subsequence of `y.shape`. ``paddle.mul`` supports broadcasting. If you would like to know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): the input tensor, its data type should be one of bfloat16, float16, float32, float64, int32, int64, bool, complex64, complex128. y (Tensor): the input tensor, its data type should be one of bfloat16, float16, float32, float64, int32, int64, bool, complex64, complex128. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. out (Tensor|None, optional): The output tensor. If set, the result will be stored in this tensor. Default is None. Returns: N-D Tensor. A location into which the result is stored. If :attr:`x`, :attr:`y` have different shapes and are "broadcastable", the resulting tensor shape is the shape of :attr:`x` and :attr:`y` after broadcasting. If :attr:`x`, :attr:`y` have the same shape, its shape is the same as :attr:`x` and :attr:`y`. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2], [3, 4]]) >>> y = paddle.to_tensor([[5, 6], [7, 8]]) >>> res = paddle.mul(x, y) >>> print(res) Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[5 , 12], [21, 32]]) >>> x = paddle.to_tensor([[[1, 2, 3], [1, 2, 3]]]) >>> y = paddle.to_tensor([2]) >>> res = paddle.mul(x, y) >>> print(res) Tensor(shape=[1, 2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[[2, 4, 6], [2, 4, 6]]]) r)r)r-rrrr)rrs rtmulr s4bq--{IIJJrvc[URUR5nX0R:wa[SUSURS35e[R"X5$)z Inplace version of ``multiply`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_multiply`. rrr)rrorr multiply_rs rtrrCse 1IGG,YK7abcbibiajkE F     A !!rvcN[5(dS5eUS;d SUS35e[[U5n[UR5n[UR5nUS:Xd[ U5[ U5:XaU"X5$[ U5[ U5:a@[ U5[ U5- U- n[ R"US/U-U-S/U--5nO?[ U5[ U5- U- n[ R"US/U-U-S/U--5nU"X5$)NzTYou can only call `_elementwise_op_with_axis` function within in_dynamic_or_pir_mode)rrrrzzop_name input error! _elementwise_op_with_axis is an inner function to replace elementwise_add/sub/mul/div. Input op_name=z0, Expect op_name=[add|subtract|multiply|divide] rr/)r-getattrrrhrornrxreshape) rrrrqrropx_shapey_shapepaddings rt_elementwise_op_with_axisr!Ts4 ! # #^ #   EFMENN @    !B177mG177mG rzS\S\1!x 7|c'l"g,W-4 NN1qcDj72aS7]B Cg,W-4 NN1qcDj72aS7]B C a8Orvcx[5(a [XX#S5$Sn[[U40[ 5D65$)Nrrr-r!rr)rrrrrqrrs rt_add_with_axisr%ns6(t5AA#{7?fh?@@rvcx[5(a [XX#S5$Sn[[U40[ 5D65$)Nrrr#r$s rt_subtract_with_axisr'w6(t:FF#{7?fh?@@rvcx[5(a [XX#S5$Sn[[U40[ 5D65$)Nrrr#r$s rt_multiply_with_axisr*r(rvcx[5(a [XX#S5$Sn[[U40[ 5D65$)Nrrr#r$s rt_divide_with_axisr,s6(t8DD#{7?fh?@@rvc[5(a[R"X5$[[ S0[ 5D65$)a Compares the elements at the corresponding positions of the two tensors and returns a new tensor containing the maximum value of the element. If one of them is a nan value, the other value is directly returned, if both are nan values, then the first nan value is returned. The equation is: .. math:: out = fmax(x, y) Note: ``paddle.fmax`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): the input tensor, it's data type should be bfloat16, float16, float32, float64, int32, int64. y (Tensor): the input tensor, it's data type should be bfloat16, float16, float32, float64, int32, int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: N-D Tensor. A location into which the result is stored. If x, y have different shapes and are "broadcastable", the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2], [7, 8]]) >>> y = paddle.to_tensor([[3, 4], [5, 6]]) >>> res = paddle.fmax(x, y) >>> print(res) Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[3, 4], [7, 8]]) >>> x = paddle.to_tensor([[1, 2, 3], [1, 2, 3]]) >>> y = paddle.to_tensor([3, 0, 4]) >>> res = paddle.fmax(x, y) >>> print(res) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[3, 2, 4], [3, 2, 4]]) >>> x = paddle.to_tensor([2, 3, 5], dtype='float32') >>> y = paddle.to_tensor([1, float("nan"), float("nan")], dtype='float32') >>> res = paddle.fmax(x, y) >>> print(res) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [2., 3., 5.]) >>> x = paddle.to_tensor([5, 3, float("inf")], dtype='float32') >>> y = paddle.to_tensor([1, -float("inf"), 5], dtype='float32') >>> res = paddle.fmax(x, y) >>> print(res) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [5. , 3. , inf.]) )elementwise_fmax)r-rfmaxrr)rrs rtr/r/2t{{1  {JJKKrvc[5(a[R"X5$[[ S0[ 5D65$)a Compares the elements at the corresponding positions of the two tensors and returns a new tensor containing the minimum value of the element. If one of them is a nan value, the other value is directly returned, if both are nan values, then the first nan value is returned. The equation is: .. math:: out = fmin(x, y) Note: ``paddle.fmin`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): the input tensor, it's data type should be bfloat16, float16, float32, float64, int32, int64. y (Tensor): the input tensor, it's data type should be bfloat16, float16, float32, float64, int32, int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: N-D Tensor. A location into which the result is stored. If x, y have different shapes and are "broadcastable", the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2], [7, 8]]) >>> y = paddle.to_tensor([[3, 4], [5, 6]]) >>> res = paddle.fmin(x, y) >>> print(res) Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 2], [5, 6]]) >>> x = paddle.to_tensor([[[1, 2, 3], [1, 2, 3]]]) >>> y = paddle.to_tensor([3, 0, 4]) >>> res = paddle.fmin(x, y) >>> print(res) Tensor(shape=[1, 2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[[1, 0, 3], [1, 0, 3]]]) >>> x = paddle.to_tensor([2, 3, 5], dtype='float32') >>> y = paddle.to_tensor([1, float("nan"), float("nan")], dtype='float32') >>> res = paddle.fmin(x, y) >>> print(res) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [1., 3., 5.]) >>> x = paddle.to_tensor([5, 3, float("inf")], dtype='float64') >>> y = paddle.to_tensor([1, -float("inf"), 5], dtype='float64') >>> res = paddle.fmin(x, y) >>> print(res) Tensor(shape=[3], dtype=float64, place=Place(cpu), stop_gradient=True, [ 1. , -inf., 5. ]) )elementwise_fmin)r-rfminrr)rrs rtr3r3r0rvc[5(a[R"X5$[US/SQS5 [US/SQS5 [ S 0[ 5D6nUR URS9nURSXS.SU0S9 U$) a Computes the sum of tensor elements make the shape of its result equal to the shape of target. Args: x (Tensor): An N-D Tensor, the data type is bool, float16, float32, float64, int8, uint8, int16, uint16, int32, int64, complex64 or complex128. target (Tensor): An N-D Tensor, the length of x shape must greater than or equal to the length of target shape. The data type is bool, float16, float32, float64, int8, uint8, int16, uint16, int32, int64, complex64 or complex128. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: The sum of the input tensor x along some axis has the same shape as the shape of the input tensor target, if `x.dtype='bool'`, `x.dtype='int32'`, it's data type is `'int64'`, otherwise it's data type is the same as `x`. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2, 3, 4], [5, 6, 7, 8]]) >>> x Tensor(shape=[2, 4], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[1, 2, 3, 4], [5, 6, 7, 8]]) >>> target = paddle.to_tensor([1, 2, 3, 4]) >>> target Tensor(shape=[4], dtype=int64, place=Place(gpu:0), stop_gradient=True, [1, 2, 3, 4]) >>> res = paddle.reduce_as(x, target) >>> res Tensor(shape=[4], dtype=int64, place=Place(gpu:0), stop_gradient=True, [6 , 8 , 10, 12]) rr) rrrrrrrrrrrr reduce_astargetr)rrr6rr)r5) r-rr5r&r)rrrr)rrr6rrrs rtr5r5s@**   # & !    # (5FH577agg7F-CL   rvcv[R"U[S55n[R"U[S55n[R"X5nUR[R[R [R RRR[R RRR4;deUR[R:H=(d; UR[R RRR:HnUccU(a.[R"[R5RO-[R"[R 5Rn[R"X5nUccU(a.[R"[R5RO-[R"[R 5Rn[R"X5n[R"[R "U5X5n[R"[R""X5X 5n[R"[R""X5X05nU$)u Replaces NaN, positive infinity, and negative infinity values in input tensor. Args: x (Tensor): An N-D Tensor, the data type is float32, float64. nan (float, optional): the value to replace NaNs with. Default is 0. posinf (float|None, optional): if a Number, the value to replace positive infinity values with. If None, positive infinity values are replaced with the greatest finite value representable by input’s dtype. Default is None. neginf (float|None, optional): if a Number, the value to replace negative infinity values with. If None, negative infinity values are replaced with the lowest finite value representable by input’s dtype. Default is None. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: Results of nan_to_num operation input Tensor ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([float('nan'), 0.3, float('+inf'), float('-inf')], dtype='float32') >>> out1 = paddle.nan_to_num(x) >>> out1 Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [ 0. , 0.30000001 , 340282346638528859811704183484516925440., -340282346638528859811704183484516925440.]) >>> out2 = paddle.nan_to_num(x, nan=1) >>> out2 Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [ 1. , 0.30000001 , 340282346638528859811704183484516925440., -340282346638528859811704183484516925440.]) >>> out3 = paddle.nan_to_num(x, posinf=5) >>> out3 Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [ 0. , 0.30000001 , 5. , -340282346638528859811704183484516925440.]) >>> out4 = paddle.nan_to_num(x, nan=10, neginf=-99) >>> out4 Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [ 10. , 0.30000001 , 340282346638528859811704183484516925440., -99. ]) +inf-inf)rx full_likerrrrbaser+rFLOAT32FLOAT64npfinfomaxminwherer equal)rrnanposinfneginfr posinf_value neginf_value is_float32s rt nan_to_numrJfsr##AuV}5L##AuV}5L   1 "C 77 !!)) !!))    6>>! 8 77fkk&&//77 7~(2BHHRZZ $ $8L8P8P   a (F ~(2BHHRZZ $ $8L8P8P   a (F V\\!_c-A V\\!2F>A V\\!2F>A Hrvc"[R"U[S55n[R"U[S55n[R"X5nUR[R[R 4;deUR[R:HnUccU(a.[ R"[ R5RO-[ R"[ R 5Rn[R"X5nUccU(a.[ R"[ R5RO-[ R"[ R 5Rn[R"X5n[R"[R"U55n[R"XU5n[R"X:gX5n[R"X:gX5nU$)z Inplace version of ``nan_to_num`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_nan_to_num`. r8r9) rxr:rrrrr>r?r@rA logical_notr where_) rrrDrErFrrGrHrI x_not_nans rt nan_to_num_rOsV##AuV}5L##AuV}5L   1 "C 77v~~v~~6 66 6FNN*J ~(2BHHRZZ $ $8L8P8P   a (F ~(2BHHRZZ $ $8L8P8P   a (F""6<<?3I iC(A a'3A a'3A Hrvrqc [US/SQS5 [US[[[[ S54S5 [ R"U5n[ R"[U5XP5n[XaX#U5$)a Computes the sum of tensor elements over the given axis, treating Not a Numbers (NaNs) as zero. Args: x (Tensor): An N-D Tensor, the data type is bfloat16, float16, float32, float64, int32 or int64. axis (int|list|tuple, optional): The dimensions along which the nansum is performed. If :attr:`None`, nansum all elements of :attr:`x` and return a Tensor with a single element, otherwise must be in the range :math:`[-rank(x), rank(x))`. If :math:`axis[i] < 0`, the dimension to reduce is :math:`rank + axis[i]`. dtype (str|paddle.dtype|np.dtype, optional): The dtype of output Tensor. The default value is None, the dtype of output is the same as input Tensor `x`. keepdim (bool, optional): Whether to reserve the reduced dimension in the output Tensor. The result Tensor will have one fewer dimension than the :attr:`x` unless :attr:`keepdim` is true, default value is False. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: Results of summation operation on the specified axis of input Tensor `x`, Examples: .. code-block:: python >>> import paddle >>> # x is a Tensor with following elements: >>> # [[nan, 0.3, 0.5, 0.9] >>> # [0.1, 0.2, -nan, 0.7]] >>> # Each example is followed by the corresponding output tensor. >>> x = paddle.to_tensor([[float('nan'), 0.3, 0.5, 0.9], ... [0.1, 0.2, float('-nan'), 0.7]],dtype="float32") >>> out1 = paddle.nansum(x) >>> out1 Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 2.69999981) >>> out2 = paddle.nansum(x, axis=0) >>> out2 Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [0.10000000, 0.50000000, 0.50000000, 1.59999990]) >>> out3 = paddle.nansum(x, axis=-1) >>> out3 Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [1.70000005, 1. ]) >>> out4 = paddle.nansum(x, axis=1, keepdim=True) >>> out4 Tensor(shape=[2, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[1.70000005], [1. ]]) >>> # y is a Tensor with shape [2, 2, 2] and elements as below: >>> # [[[1, nan], [3, 4]], >>> # [[5, 6], [-nan, 8]]] >>> # Each example is followed by the corresponding output tensor. >>> y = paddle.to_tensor([[[1, float('nan')], [3, 4]], ... [[5, 6], [float('-nan'), 8]]]) >>> out5 = paddle.nansum(y, axis=[1, 2]) >>> out5 Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [8. , 19.]) >>> out6 = paddle.nansum(y, axis=[0, 1]) >>> out6 Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [9. , 18.]) rrrrrrrrnansumrqN) r&r%rkrhrirmrx zeros_likerBr r)rrrqrkeepdimr zero_tensor tmp_tensors rtrRrRsiP  E  tVc4T ;XF##A&KeAh 7J z 66rvc l[U[5(aU/n[US/SQS5 Ub[US[[[ 4S5 [ R"[ R"U5)XS9n[ R"[ R"XX#S9URUR55$)a Compute the arithmetic mean along the specified axis, ignoring NaNs. Args: x (Tensor): The input Tensor with data type uint16, float16, float32, float64. axis (int|list|tuple, optional):The axis along which to perform nanmean calculations. ``axis`` should be int, list(int) or tuple(int). If ``axis`` is a list/tuple of dimension(s), nanmean is calculated along all element(s) of ``axis`` . ``axis`` or element(s) of ``axis`` should be in range [-D, D), where D is the dimensions of ``x`` . If ``axis`` or element(s) of ``axis`` is less than 0, it works the same way as :math:`axis + D` . If ``axis`` is None, nanmean is calculated over all elements of ``x``. Default is None. keepdim (bool, optional): Whether to reserve the reduced dimension(s) in the output Tensor. If ``keepdim`` is True, the dimensions of the output Tensor is the same as ``x`` except in the reduced dimensions(it is of size 1 in this case). Otherwise, the shape of the output Tensor is squeezed in ``axis`` . Default is False. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, results of arithmetic mean along ``axis`` of ``x``, with the same data type as ``x``. Examples: .. code-block:: python >>> import paddle >>> # x is a 2-D Tensor: >>> x = paddle.to_tensor([[float('nan'), 0.3, 0.5, 0.9], ... [0.1, 0.2, float('-nan'), 0.7]]) >>> out1 = paddle.nanmean(x) >>> out1 Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 0.44999996) >>> out2 = paddle.nanmean(x, axis=0) >>> out2 Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [0.10000000, 0.25000000, 0.50000000, 0.79999995]) >>> out3 = paddle.nanmean(x, axis=0, keepdim=True) >>> out3 Tensor(shape=[1, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.10000000, 0.25000000, 0.50000000, 0.79999995]]) >>> out4 = paddle.nanmean(x, axis=1) >>> out4 Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [0.56666666, 0.33333334]) >>> out5 = paddle.nanmean(x, axis=1, keepdim=True) >>> out5 Tensor(shape=[2, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.56666666], [0.33333334]]) >>> # y is a 3-D Tensor: >>> y = paddle.to_tensor([[[1, float('nan')], [3, 4]], ... [[5, 6], [float('-nan'), 8]]]) >>> out6 = paddle.nanmean(y, axis=[1, 2]) >>> out6 Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [2.66666675, 6.33333349]) >>> out7 = paddle.nanmean(y, axis=[0, 1]) >>> out7 Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [3., 6.]) x/inputrrrrnanmeanzaxis/dim)rqrTrqrTr) rgrkr&r%rhrirxrr rrRrr)rrrqrTrcnts rtrZrZ5sR$v 9A9 4c4%7C **fll1o%D BC == aG? 177 rvc[U[5(aU/n[R"US5n[R"US5n[R"XQX#S9$)a3 Counts the number of non-zero values in the tensor x along the specified axis. Args: x (Tensor): An N-D Tensor, the data type is bool, float16, float32, float64, int32 or int64. axis (int|list|tuple, optional): The dimensions along which the sum is performed. If :attr:`None`, sum all elements of :attr:`x` and return a Tensor with a single element, otherwise must be in the range :math:`[-rank(x), rank(x))`. If :math:`axis[i] < 0`, the dimension to reduce is :math:`rank + axis[i]`. keepdim (bool, optional): Whether to reserve the reduced dimension in the output Tensor. The result Tensor will have one fewer dimension than the :attr:`x` unless :attr:`keepdim` is true, default value is False. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: Results of count operation on the specified axis of input Tensor `x`, it's data type is `'int64'`. Examples: .. code-block:: python >>> import paddle >>> # x is a 2-D Tensor: >>> x = paddle.to_tensor([[0., 1.1, 1.2], [0., 0., 1.3], [0., 0., 0.]]) >>> out1 = paddle.count_nonzero(x) >>> out1 Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 3) >>> out2 = paddle.count_nonzero(x, axis=0) >>> out2 Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 1, 2]) >>> out3 = paddle.count_nonzero(x, axis=0, keepdim=True) >>> out3 Tensor(shape=[1, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 1, 2]]) >>> out4 = paddle.count_nonzero(x, axis=1) >>> out4 Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [2, 1, 0]) >>> out5 = paddle.count_nonzero(x, axis=1, keepdim=True) >>> out5 Tensor(shape=[3, 1], dtype=int64, place=Place(cpu), stop_gradient=True, [[2], [1], [0]]) >>> # y is a 3-D Tensor: >>> y = paddle.to_tensor([[[0., 1.1, 1.2], [0., 0., 1.3], [0., 0., 0.]], ... [[0., 2.5, 2.6], [0., 0., 2.4], [2.1, 2.2, 2.3]]]) >>> out6 = paddle.count_nonzero(y, axis=[1, 2]) >>> out6 Tensor(shape=[2], dtype=int64, place=Place(cpu), stop_gradient=True, [3, 6]) >>> out7 = paddle.count_nonzero(y, axis=[0, 1]) >>> out7 Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 3, 5]) rrr[)rgrkrxr2r)rrrqrTr bool_tensor int_tensors rt count_nonzeror`sJH$v++a(K['2J ::jW HHrvc$[5(aH[U[[RR 45(aU/n[ R"U5$[S 0[5D6n[US[[[4S5 [U[[45(a)[U5S:aUHn[US/SQS5 M O[US/SQS5 URUR!S5S9nUR#SSU0SU00S 9 U$) a Sum one or more Tensor of the input. For example: .. code-block:: text Case 1: Input: input.shape = [2, 3] input = [[1, 2, 3], [4, 5, 6]] Output: output.shape = [2, 3] output = [[1, 2, 3], [4, 5, 6]] Case 2: Input: First input: input1.shape = [2, 3] Input1 = [[1, 2, 3], [4, 5, 6]] The second input: input2.shape = [2, 3] input2 = [[7, 8, 9], [10, 11, 12]] Output: output.shape = [2, 3] output = [[8, 10, 12], [14, 16, 18]] Args: inputs (Tensor|list[Tensor]|tuple[Tensor]): A Tensor or a list/tuple of Tensors. The shape and data type of the list/tuple elements should be consistent. Input can be multi-dimensional Tensor, and data types can be: bfloat16, float16, float32, float64, int32, int64, complex64, complex128. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, the sum of input :math:`inputs` , its shape and data types are consistent with :math:`inputs`. Examples: .. code-block:: python >>> import paddle >>> input0 = paddle.to_tensor([[1, 2, 3], [4, 5, 6]], dtype='float32') >>> input1 = paddle.to_tensor([[7, 8, 9], [10, 11, 12]], dtype='float32') >>> output = paddle.add_n([input0, input1]) >>> output Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[8. , 10., 12.], [14., 16., 18.]]) add_nrr)rrrrrrrrrrrrr)rb)r-rgr(rxryrrrbr)rr%rirhrnr&r input_dtyper)rrrrrs rtrbrbsv fx)9)9: ; ;XF||F##1168ht%>> import paddle >>> input = paddle.to_tensor([[0.1, 1.5], [-0.2, -2.4]], 'float32') >>> output = paddle.trunc(input) >>> output Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0., 1.], [-0., -2.]]) rrrrrrr) r-rrr)rr&rrr)rrrrrrs rtrrKs.||E""u11 3@' 77ekk7Jucl   rvcN[5(a[R"U5$g)z Inplace version of ``trunc`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_trunc`. N)r,rtrunc_)rrs rtrfrfts! }}U##rvc:[5(a[R"XSS5$SnU"X5 [5(a[R"XSS5$[ S0[ 5D6nUR URS9nURSXS.SU0S9 U$) a Applies matrix multiplication to two tensors. Currently, the input tensors' rank can be any, but when the rank of any inputs is bigger than 3, this two inputs' rank should be equal. Also note that if the raw tensor :math:`x` or :math:`mat2` is rank-1 and nontransposed, the prepended or appended dimension :math:`1` will be removed after matrix multiplication. Args: input (Tensor): The input tensor which is a Tensor. Support data types: bfloat16, float16, float32, float64, int8, int32, int64, complex64, complex128. mat2 (Tensor): The input tensor which is a Tensor. Support data types: bfloat16, float16, float32, float64, int8, int32, int64, complex64, complex128. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: The product Tensor, with same data type of the input Tensor. :: * example 1: input: [B, ..., M, K], mat2: [B, ..., K, N] out: [B, ..., M, N] * example 2: input: [B, M, K], mat2: [B, K, N] out: [B, M, N] * example 3: input: [B, M, K], mat2: [K, N] out: [B, M, N] * example 4: input: [M, K], mat2: [K, N] out: [M, N] * example 5: input: [B, M, K], mat2: [K] out: [B, M] * example 6: input: [K], mat2: [K] out: [1] Examples: .. code-block:: python >>> import paddle >>> input = paddle.arange(1, 7).reshape((3, 2)).astype('float32') >>> mat2 = paddle.arange(1, 9).reshape((2, 4)).astype('float32') >>> out = paddle.mm(input, mat2) >>> out Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[11., 14., 17., 20.], [23., 30., 37., 44.], [35., 46., 57., 68.]]) Fc 0XS.nUR5Hup4[XC/SQS5 M [UR5n[UR5n[ U5S:XaS/UQn[ U5S:Xa/UQSPnUSUS:wa$USS:XdUSS:Xd[ SUSUS 35e[ U5S :aX[ U5S :aH[ USS5H5upxUS :dXgS :aMXU:wdM[ S US USUSUS3 5e ggg)Nrrrrmmr/rzAfter performing an optional transpose, Input X's width should be equal to Y's width for multiplication prerequisites. But received X's shape: , Y's shape:  r#rzWhen the matrix is larger than 2 dimensions, the higher dimensional values of the two matrices need to be equal. But received x_shape[z ] != y_shape[z]. X's shape: . )itemsr&rhrornrr) rrr var_namesrvalrridim_xs rt __check_inputmm..__check_inputsU$ "*ID $>EYmT[S\\^` w>> import paddle >>> x = paddle.ones([2, 2]) >>> y = paddle.ones([2, 2]) >>> input = paddle.ones([2, 2]) >>> out = paddle.addmm(input=input, x=x, y=y, beta=0.5, alpha=5.0) >>> print(out) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[10.50000000, 10.50000000], [10.50000000, 10.50000000]]) r#9The dimension of x, y should be 2 but receive x's shape: , y's shape: r/r]The input Variable x's width must be equal with Variable y' height. But received x's shape = , y's shape = reWhen x's dimension[0] is not equal with input's dimension[0], input's dimension[0] must be 1 but got eWhen y's dimension[1] is not equal with input's dimension[1], input's dimension[1] must be 1 but got The input's shape: 6 is not broadcastable with [x.shape[0], y.shape[1]]: [,rCThe dimension of input should be 2 or 1 but receive input's shape: InputrrAlphaBetaaddmmrrrrrrrrrr)r) rornrr-rrr)rr&rrr rrrrbetarr input_shaperrrrrrs rtrrs^++KggGggG w<3w< ,1 ,GyP]^e]f g  qzWQZklsktuCDKCLLM N   ;1 q>WQZ '1~" {}HIJ}K|LM1~+ A!0C {}HIJ}K|LM q>WQZ '1~" {}HIJ}K|LM [ Q  q>'!*a 0%k]2hipqrishttuv}~wAvBBCD  1 QR]Q^ _  ||Eau55 q1.11 7G  ! s?  ! s? 77agg7Fucl   rvc URnURnURn[U5[U5s=:XaS:XdO [SUSU35eUSUS:wa[SUSUS35e[U5S:XasUSUS:wa@USS:wa[S US35eUSUS:waUSS:wa[S US35eUSUS:waUSS:wa[S US35eOG[U5S:Xa*USUSS4;a[S US USS USS35eO[SU35e[5(a[R "XX#U5$g)z Inplace version of ``addmm`` API, the output Tensor will be inplaced with input ``input``. Please refer to :ref:`api_paddle_addmm`. r#rzr{r/rr|r}rr~rrrrrrN)rornrr,raddmm_ rrrrrrrrrrs rtrrc sH++KggGggG w<3w< ,1 ,GyP]^e]f g  qzWQZklsktuCDKCLLM N   ;1 q>WQZ '1~" {}HIJ}K|LM1~+ A!0C {}HIJ}K|LM q>WQZ '1~" {}HIJ}K|LM [ Q  q>'!*a 0%k]2hipqrishttuv}~wAvBBCD  1 QR]Q^ _  }}Uq66rvc .URnURnURn[U5[U5s=:XaS:XdO [SUSU35eUSUS:wa[SUSUS35e[U5S:XGaUS US :wa^US S:wa[S US S US 35eUSUS:Xd USS:XaUSUS:XdUSS:Xd[S US USU35eUSUS:wa^USS:wa[SUSSUS35eUS US :Xd US S:XaUSUS:XdUSS:Xd[SUS USU35eUSUS:wa USS:wa[SUSSUS35eOp[U5S:XaSUS US :wa[SUS SUS 35eUSUSS4;a![SUSUS SUSSUSS3 5eO[SU35e[5(a[R "XX#U5$XUS.n XCS.n [ S$0[5D6n [US/SQS5 [US/SQS5 [US /SQS5 U RURS!9n U RSXS"U 0S#9 U $)%au **baddbmm** Perform batch matrix multiplication for input $x$ and $y$. $input$ is added to the final result. The equation is: .. math:: Out = alpha * x * y + beta * input $Input$, $x$ and $y$ can carry the LoD (Level of Details) information, or not. But the output only shares the LoD information with input $input$. Args: input (Tensor): The input Tensor to be added to the final result. x (Tensor): The first input Tensor for batch matrix multiplication. y (Tensor): The second input Tensor for batch matrix multiplication. beta (float, optional): Coefficient of $input$, default is 1. alpha (float, optional): Coefficient of $x*y$, default is 1. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: The output Tensor of baddbmm. Examples: .. code-block:: python >>> import paddle >>> x = paddle.ones([2, 2, 2]) >>> y = paddle.ones([2, 2, 2]) >>> input = paddle.ones([2, 2, 2]) >>> out = paddle.baddbmm(input=input, x=x, y=y, beta=0.5, alpha=5.0) >>> out Tensor(shape=[2, 2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[10.50000000, 10.50000000], [10.50000000, 10.50000000]], [[10.50000000, 10.50000000], [10.50000000, 10.50000000]]]) 9The dimension of x, y should be 3 but receive x's shape: r{r#r/^The input Variable x's width must be equal with Variable y's height. But received x's shape = r}rr~If input's dimension[0] is not equal to x's dimension[0], input's dimension[0] must be 1. But received input's dimension[0] = , x's dimension[0] = If input's dimension[0] is 1, input's dimension[1] and dimension[2] must be equal to x's dimension[1] and y's dimension[2] respectively, or they must be 1. But received input's shape = , x's shape = ~If input's dimension[1] is not equal to x's dimension[1], input's dimension[1] must be 1. But received input's dimension[1] = , x's dimension[1] = If input's dimension[1] is 1, input's dimension[0] and dimension[2] must be equal to x's dimension[0] and y's dimension[2] respectively, or they must be 1. But received input's shape = ~If input's dimension[2] is not equal to y's dimension[2], input's dimension[2] must be 1. But received input's dimension[2] = , y's dimension[2] = `The batch size of input must be equal to the batch size of x. But received input's batch size = , x's batch size = rB is not broadcastable with [x.shape[0], x.shape[1], y.shape[2]]: [rrDThe dimension of input should be 3 or 2 but received input's shape: rrbaddbmmrrrrrrr)r) rornrr-rrr)rr&rrrrs rtrr sb++KggGggG w<3w< ,1 ,GyP]^e]f g  qzWQZlmtluvDELDMMN O   ;1 q>WQZ '1~" UVabcVdUeez{BCD{EzFG  Ngaj0KNa4G%a.GAJ6+a.A:M$TU`TaaopwoxxFGNFOP q>WQZ '1~" UVabcVdUeez{BCD{EzFG  Ngaj0KNa4G%a.GAJ6+a.A:M$TU`TaaopwoxxFGNFOP q>WQZ '1~" UVabcVdUeez{BCD{EzFG [ Q  q>WQZ 'rs~@AtBsCCVW^_`WaVbc  q>'!*a 0%k]2tu|}~uuAABCJKLCMBNNOPWXYPZO[[\]  1 RS^R_ `  ~~e77 q1.3&(3   7   ! s?  ! s? 77agg7F6    rvc <URnURnURn[U5[U5s=:XaS:XdO [SUSU35eUSUS:wa[SUSUS35e[U5S:XGaUS US :wa^US S:wa[S US S US 35eUSUS:Xd USS:XaUSUS:XdUSS:Xd[S US USU35eUSUS:wa^USS:wa[SUSSUS35eUS US :Xd US S:XaUSUS:XdUSS:Xd[SUS USU35eUSUS:wa USS:wa[SUSSUS35eOp[U5S:XaSUS US :wa[SUS SUS 35eUSUSS4;a![SUSUS SUSSUSS3 5eO[SU35e[5(a[R "XX#U5$g)z Inplace version of ``baddbmm`` API, the output Tensor will be inplaced with input ``input``. Please refer to :ref:`api_paddle_baddbmm`. rrr{r#r/rr}rrrrrrrrrrrrrrrrrrN)rornrr,rbaddbmm_rs rtrr sc++KggGggG w<3w< ,1 ,GyP]^e]f g  qzWQZlmtluvDELDMMN O   ;1 q>WQZ '1~" UVabcVdUeez{BCD{EzFG  Ngaj0KNa4G%a.GAJ6+a.A:M$TU`TaaopwoxxFGNFOP q>WQZ '1~" UVabcVdUeez{BCD{EzFG  Ngaj0KNa4G%a.GAJ6+a.A:M$TU`TaaopwoxxFGNFOP q>WQZ '1~" UVabcVdUeez{BCD{EzFG [ Q  q>WQZ 'rs~@AtBsCCVW^_`WaVbc  q>'!*a 0%k]2tu|}~uuAABCJKLCMBNNOPWXYPZO[[\]  1 RS^R_ `  u%88rvc URnU[U5:d[SUS[U5SU35eUS:d=US[U5-:d[SUSS[U5-35eU[U5-n[5(a[R "XX#5nU$[ USSS /S 5 S U0nXUS .n[S0[5D6nURURS 9nURS XgSU0S9 U$)a **renorm** This operator is used to calculate the p-norm along the axis, suppose the input-shape on axis dimension has the value of T, then the tensor is split into T parts, the p-norm should be calculated for each part, if the p-norm for part i is larger than max-norm, then each element in part i should be re-normalized at the same scale so that part-i' p-norm equals max-norm exactly, otherwise part-i stays unchanged. Args: x (Tensor): The input Tensor p (float): The power of the norm operation. axis (int): the dimension to slice the tensor. max-norm (float): the maximal norm limit. Returns: Tensor: the renorm Tensor. Examples: .. code-block:: python >>> import paddle >>> input = [[[2.0, 2.0, -2.0], [3.0, 0.3, 3.0]], ... [[2.0, -8.0, 2.0], [3.1, 3.7, 3.0]]] >>> x = paddle.to_tensor(input,dtype='float32') >>> y = paddle.renorm(x, 1.0, 2, 2.05) >>> print(y) Tensor(shape=[2, 2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[[ 0.40594056, 0.29285714, -0.41000000], [ 0.60891086, 0.04392857, 0.61500001]], [[ 0.40594056, -1.17142856, 0.41000000], [ 0.62920785, 0.54178572, 0.61500001]]]) the axis:& should be less then the shape's size :rr4 should not be less than -1 * length of input_shape:rrrrrenormr)prqmax_normrrr)r) rornrr-rrr&r)rrrr) rrrrqrrrrrrs rtrri s/H''K #k" "vCC DTCUUVWbVc d   19rC ,,,D6!UVX[^_j[kVkUlm c+&&mmA$1  C)Y)?Jq8<2277agg7F&s|   rvc JURnU[U5:d[SUS[U5SU35eUS:d=US[U5-:d[SUSS[U5-35eU[U5-n[5(a[R "XX#5nU$g)z Inplace version of ``renorm`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_renorm`. rrrrrrN)rornrr,rrenorm_)rrrrqrrrs rtrr s ''K #k" "vCC DTCUUVWbVc d   19rC ,,,D6!UVX[^_j[kVkUlm c+&&nnQ42 rvc^ ^ URm URm [5(a+URS:XdURS:Xa [X5$[ T SS5[ T SS5-nT SS:XaL[ T 5S:XaUR S5nOAUR [R"T SS5S45nOUR ST S45nT SS:XaL[ T 5S:XaUR S5nOAUR [R"T SS5S45nOUR ST S45nU U 4SjnU"XE5 [5(a'[R"XESS5R U5$[S0[5D6nURURS 9nUR!S XER"S .S U0S 9 UR U5$)a Inner product of two input Tensor. Ordinary inner product for 1-D Tensors, in higher dimensions a sum product over the last axes. Args: x (Tensor): An N-D Tensor or a Scalar Tensor. If its not a scalar Tensor, its last dimensions must match y's. y (Tensor): An N-D Tensor or a Scalar Tensor. If its not a scalar Tensor, its last dimensions must match x's. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: The inner-product Tensor, the output shape is x.shape[:-1] + y.shape[:-1]. Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(1, 7).reshape((2, 3)).astype('float32') >>> y = paddle.arange(1, 10).reshape((3, 3)).astype('float32') >>> out = paddle.inner(x, y) >>> print(out) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[14. , 32. , 50. ], [32. , 77. , 122.]]) r/Nrrr/rc>XS.nUR5Hup4[XC/SQS5 M [T5n[T5nUSUS:wa&USS:XdUSS:Xd[SUSUS35eggg)NrriinnerrzAfter performing an optional transpose, Input X's last dim should be equal to Y's last dim for multiplication prerequisites. But received X's shape: rlrm)ror&rhr) rrrrprrqrrxshapeyshapes rtrtinner..__check_input s(I&__. (@'/6lG6lGr{gbk) * r0A$BBI-X_W``bd1B**rvFTrrvrrr)r)ror,sizerrhrnrmathprodr-rrwr)rrrrT) rrrrdstshapenxnyrtrrrrs @@rtrr s:WWF WWFaffkQVVq[~s $tF3BK'88 ":?6{aYYv&YY &"+ 6:;Br +,B ":?6{aYYv&YY &"+ 6:;Br +,B $ b ! # #==5==hG G 5FH5F;;"((;KC    dd+    ;;x( (rvvec2cURnURn[R"U5S:XaURS5nOURS5n[R"U5S:XaURS5nOURS5n[ 5(a[ R "XgUS9$[S 0[5D6nURURS9nURSXgS .S U0S 9 U$) a Outer product of two Tensors. Input is flattened if not already 1-dimensional. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``vec2`` can be used as an alias for ``y``. For example, ``outer(input=tensor_x, vec2=tensor_y, ...)`` is equivalent to ``outer(x=tensor_x, y=tensor_y, ...)``. Args: x (Tensor): An N-D Tensor or a Scalar Tensor. alias: ``input``. y (Tensor): An N-D Tensor or a Scalar Tensor. alias: ``vec2``. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. out (Tensor|None, optional): The output Tensor. If set, the result will be stored in this Tensor. Returns: Tensor: The outer-product Tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(1, 4).astype('float32') >>> y = paddle.arange(1, 6).astype('float32') >>> out = paddle.outer(x, y) >>> print(out) Tensor(shape=[3, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[1. , 2. , 3. , 4. , 5. ], [2. , 4. , 6. , 8. , 10.], [3. , 6. , 9. , 12., 15.]]) r)rr/)rr/r)r/rrrrvrrr)outer) rorrrr-rrr)rrrr) rrrrrrrrrrs rtrr sXWWF WWF yyA YYv  YYw  yyA YYv  YYw r3//1177bhh7G2%7%   rvc[5(a[R"U5$SnU"U5 [S0[ 5D6nUR UR S9nURSSU/0SU/0S9 U$)a$ Takes the inverse of the square matrix. A square matrix is a matrix with the same number of rows and columns. The input can be a square matrix (2-D Tensor) or batches of square matrices. Args: x (Tensor): The input tensor. The last two dimensions should be equal. When the number of dimensions is greater than 2, it is treated as batches of square matrix. The data type can be float32, float64, complex64, complex128. 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 holds the inverse of x. The shape and data type is the same as x. Examples: .. code-block:: python >>> import paddle >>> mat = paddle.to_tensor([[2, 0], [0, 2]], dtype='float32') >>> inv = paddle.inverse(mat) >>> print(inv) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.50000000, 0. ], [0. , 0.50000000]]) c[US/SQS5 [UR5S:a/[S[UR5SURS35eg)Nrr)rrrrinverser#zlThe input of inverse is expected to be a Tensor whose number of dimensions is no less than 2. But received: z , x's shape: r)r&rnror)rrs rt _check_inputinverse.._check_inputv sc $A   177|a FFI!''l^T""#''!- rvrrrOutputr)r)r-rrr)rrrr)rrrrrrs rtrrT s~<~~a    Q3&(377agg7FGaS>Hse;L   rv>dimrrz paddle.maxzpaddle.compat.maxz torch.max) illegal_keys func_name correct_name url_suffixc [5(a[R"XU5$[X5upA[ 5(a[R"XU5$[ S 0[ 5D6n[US/SQS5 [U[5(dC[RRU5(a[RRU5nURURS9nUR!SSU0SU0UUUS.S 9 U$) a Computes the maximum of tensor elements over the given axis. Note: The difference between max and amax is: If there are multiple maximum elements, amax evenly distributes gradient between these equal values, while max propagates gradient to all of them. Args: x (Tensor): A tensor, the data type is float8_e4m3fn, float8_e5m2, bfloat16, float16, float32, float64, int32, int64. axis (int|list|tuple|None, optional): The axis along which the maximum is computed. If :attr:`None`, compute the maximum over all elements of `x` and return a Tensor with a single element, otherwise must be in the range :math:`[-x.ndim(x), x.ndim(x))`. If :math:`axis[i] < 0`, the axis to reduce is :math:`x.ndim + axis[i]`. keepdim (bool, optional): Whether to reserve the reduced dimension in the output Tensor. The result tensor will have one fewer dimension than the `x` unless :attr:`keepdim` is true, default value is False. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, results of maximum on the specified axis of input tensor, it's data type is the same as `x`. Examples: .. code-block:: python >>> import paddle >>> # data_x is a Tensor with shape [2, 4] >>> # the axis is a int element >>> x = paddle.to_tensor([[0.2, 0.3, 0.5, 0.9], ... [0.1, 0.2, 0.6, 0.7]], ... dtype='float64', stop_gradient=False) >>> result1 = paddle.max(x) >>> result1.backward() >>> result1 Tensor(shape=[], dtype=float64, place=Place(cpu), stop_gradient=False, 0.90000000) >>> x.grad Tensor(shape=[2, 4], dtype=float64, place=Place(cpu), stop_gradient=False, [[0., 0., 0., 1.], [0., 0., 0., 0.]]) >>> x.clear_grad() >>> result2 = paddle.max(x, axis=0) >>> result2.backward() >>> result2 Tensor(shape=[4], dtype=float64, place=Place(cpu), stop_gradient=False, [0.20000000, 0.30000000, 0.60000000, 0.90000000]) >>> x.grad Tensor(shape=[2, 4], dtype=float64, place=Place(cpu), stop_gradient=False, [[1., 1., 0., 1.], [0., 0., 1., 0.]]) >>> x.clear_grad() >>> result3 = paddle.max(x, axis=-1) >>> result3.backward() >>> result3 Tensor(shape=[2], dtype=float64, place=Place(cpu), stop_gradient=False, [0.90000000, 0.70000000]) >>> x.grad Tensor(shape=[2, 4], dtype=float64, place=Place(cpu), stop_gradient=False, [[0., 0., 0., 1.], [0., 0., 0., 1.]]) >>> x.clear_grad() >>> result4 = paddle.max(x, axis=1, keepdim=True) >>> result4.backward() >>> result4 Tensor(shape=[2, 1], dtype=float64, place=Place(cpu), stop_gradient=False, [[0.90000000], [0.70000000]]) >>> x.grad Tensor(shape=[2, 4], dtype=float64, place=Place(cpu), stop_gradient=False, [[0., 0., 0., 1.], [0., 0., 0., 1.]]) >>> # data_y is a Tensor with shape [2, 2, 2] >>> # the axis is list >>> y = paddle.to_tensor([[[1.0, 2.0], [3.0, 4.0]], ... [[5.0, 6.0], [7.0, 8.0]]], ... dtype='float64', stop_gradient=False) >>> result5 = paddle.max(y, axis=[1, 2]) >>> result5.backward() >>> result5 Tensor(shape=[2], dtype=float64, place=Place(cpu), stop_gradient=False, [4., 8.]) >>> y.grad Tensor(shape=[2, 2, 2], dtype=float64, place=Place(cpu), stop_gradient=False, [[[0., 0.], [0., 1.]], [[0., 0.], [0., 1.]]]) >>> y.clear_grad() >>> result6 = paddle.max(y, axis=[0, 1]) >>> result6.backward() >>> result6 Tensor(shape=[2], dtype=float64, place=Place(cpu), stop_gradient=False, [7., 8.]) >>> y.grad Tensor(shape=[2, 2, 2], dtype=float64, place=Place(cpu), stop_gradient=False, [[[0., 0.], [0., 0.]], [[0., 0.], [1., 1.]]]) r@rr)rrrrrr float8_e4m3fn float8_e5m2r reduce_maxrrrkeep_dimrsr)r@)r,rr@r}r.r)rr&rgr(rxrzr{r|rrrrrrqrTrrsrrs rtr@r@ svzz!7++7@ ==::aw/ / 3&(3F $  dH--&,,2K2K33||;;DA;;!'';JC   !Qx  '",  Jrvz paddle.minzpaddle.compat.minz torch.minc d[5(a[R"XU5$[X5upA[ 5(a[R"XU5$[ S 0[ 5D6n[US/SQS5 URURS9nURSSU0SU0UUUS.S 9 U$) a Computes the minimum of tensor elements over the given axis Note: The difference between min and amin is: If there are multiple minimum elements, amin evenly distributes gradient between these equal values, while min propagates gradient to all of them. Args: x (Tensor): A tensor, the data type is bfloat16, float16, float32, float64, int32, int64. axis (int|list|tuple|None, optional): The axis along which the minimum is computed. If :attr:`None`, compute the minimum over all elements of `x` and return a Tensor with a single element, otherwise must be in the range :math:`[-x.ndim, x.ndim)`. If :math:`axis[i] < 0`, the axis to reduce is :math:`x.ndim + axis[i]`. keepdim (bool, optional): Whether to reserve the reduced dimension in the output Tensor. The result tensor will have one fewer dimension than the `x` unless :attr:`keepdim` is true, default value is False. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, results of minimum on the specified axis of input tensor, it's data type is the same as input's Tensor. Examples: .. code-block:: python >>> import paddle >>> # data_x is a Tensor with shape [2, 4] >>> # the axis is a int element >>> x = paddle.to_tensor([[0.2, 0.3, 0.5, 0.9], ... [0.1, 0.2, 0.6, 0.7]], ... dtype='float64', stop_gradient=False) >>> result1 = paddle.min(x) >>> result1.backward() >>> result1 Tensor(shape=[], dtype=float64, place=Place(cpu), stop_gradient=False, 0.10000000) >>> x.grad Tensor(shape=[2, 4], dtype=float64, place=Place(cpu), stop_gradient=False, [[0., 0., 0., 0.], [1., 0., 0., 0.]]) >>> x.clear_grad() >>> result2 = paddle.min(x, axis=0) >>> result2.backward() >>> result2 Tensor(shape=[4], dtype=float64, place=Place(cpu), stop_gradient=False, [0.10000000, 0.20000000, 0.50000000, 0.70000000]) >>> x.grad Tensor(shape=[2, 4], dtype=float64, place=Place(cpu), stop_gradient=False, [[0., 0., 1., 0.], [1., 1., 0., 1.]]) >>> x.clear_grad() >>> result3 = paddle.min(x, axis=-1) >>> result3.backward() >>> result3 Tensor(shape=[2], dtype=float64, place=Place(cpu), stop_gradient=False, [0.20000000, 0.10000000]) >>> x.grad Tensor(shape=[2, 4], dtype=float64, place=Place(cpu), stop_gradient=False, [[1., 0., 0., 0.], [1., 0., 0., 0.]]) >>> x.clear_grad() >>> result4 = paddle.min(x, axis=1, keepdim=True) >>> result4.backward() >>> result4 Tensor(shape=[2, 1], dtype=float64, place=Place(cpu), stop_gradient=False, [[0.20000000], [0.10000000]]) >>> x.grad Tensor(shape=[2, 4], dtype=float64, place=Place(cpu), stop_gradient=False, [[1., 0., 0., 0.], [1., 0., 0., 0.]]) >>> # data_y is a Tensor with shape [2, 2, 2] >>> # the axis is list >>> y = paddle.to_tensor([[[1.0, 2.0], [3.0, 4.0]], ... [[5.0, 6.0], [7.0, 8.0]]], ... dtype='float64', stop_gradient=False) >>> result5 = paddle.min(y, axis=[1, 2]) >>> result5.backward() >>> result5 Tensor(shape=[2], dtype=float64, place=Place(cpu), stop_gradient=False, [1., 5.]) >>> y.grad Tensor(shape=[2, 2, 2], dtype=float64, place=Place(cpu), stop_gradient=False, [[[1., 0.], [0., 0.]], [[1., 0.], [0., 0.]]]) >>> y.clear_grad() >>> result6 = paddle.min(y, axis=[0, 1]) >>> result6.backward() >>> result6 Tensor(shape=[2], dtype=float64, place=Place(cpu), stop_gradient=False, [1., 2.]) >>> y.grad Tensor(shape=[2, 2, 2], dtype=float64, place=Place(cpu), stop_gradient=False, [[[1., 1.], [0., 0.]], [[0., 0.], [0., 0.]]]) rArr)rrrrrrr reduce_minrrrr)rA) r,rrAr}r.r)rr&rrrrs rtrArA2 stzz!7++7@ ==::aw/ / 3&(3F $M  ;;!'';JC   !Qx  '",  JrvcN[5(a[R"U5$g)z Inplace version of ``log1p`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_log1p`. N)r,rlog1p_rs rtrr !}}QrvcN[5(a[R"U5$g)z Inplace version of ``log2`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_log2`. N)r,rlog2_rs rtrr s ||ArvcN[5(a[R"U5$g)z Inplace version of ``log10`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_log10`. N)r,rlog10_rs rtrr rrvc6 [UR5nUS:Xaa[R"[R5R n[R"[R5R S- nGOUS:Xaa[R"[R5R n[R"[R5R S- nGOXUS:Xao[[R"[R5R 5n[[R"[R5R 5nOUS:Xao[[R"[R5R 5n[[R"[R5R 5nOn[[R"[R5R 5n[[R"[R5R 5nUcUOUnUcUOUn[5(aUS;a[U[R 5(aUR#S5n[U[R 5(aUR#S5n[U[5(d[U[5(a%[R$"U[R5n[&R("XX$S 9$[+5(GaUS;a[U[5(d[U[5(d[U[R,R.5(a.UR[R[R4;dW[U[R,R.5(aSUR[R[R4;a%[R$"U[R5n[&R("XX$S 9$UbM[1US [[2[44S 5 [U[45(aRS /S QS S 5 UbM[1US[[2[44S 5 [U[45(aRS/S QS S5 [9US/SQS 5 SU0nXgS.n [U[45(a SUlXS'OUbXS '[U[45(a SUlX(S'OUbX)S'[=S0[?5D6n U RAU RCS5S9n U RES USU /0U S9 U $)a This operator clip all elements in input into the range [ min, max ] and return a resulting tensor as the following equation: .. math:: Out = MIN(MAX(x, min), max) .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``. For example, ``clip(input=tensor_x)`` is equivalent to ``clip(x=tensor_x)``. Args: x (Tensor): An N-D Tensor with data type bfloat16, float16, float32, float64, int32 or int64. alias: ``input``. min (float|int|Tensor, optional): The lower bound with type ``float`` , ``int`` or a ``0-D Tensor`` with shape [] and type ``bfloat16``, ``float16``, ``float32``, ``float64``, ``int32``. max (float|int|Tensor, optional): The upper bound with type ``float``, ``int`` or a ``0-D Tensor`` with shape [] and type ``bfloat16``, ``float16``, ``float32``, ``float64``, ``int32``. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. out (Tensor, optional): The output Tensor. If set, the result will be stored in this Tensor. Default: None. Returns: Tensor: A Tensor with the same data shape as input. If either min or max is a floating-point value/Tensor, the output tensor will have a data type of ``float32``. Otherwise, the output tensor will inherit the same data type as the input. Examples: .. code-block:: python >>> import paddle >>> x1 = paddle.to_tensor([[1.2, 3.5], [4.5, 6.4]], 'float32') >>> out1 = paddle.clip(x1, min=3.5, max=5.0) >>> out1 Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[3.50000000, 3.50000000], [4.50000000, 5. ]]) >>> out2 = paddle.clip(x1, min=2.5) >>> out2 Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[2.50000000, 3.50000000], [4.50000000, 6.40000010]]) paddle.int32 paddle.int64lzpaddle.float16zpaddle.float64)rrrrrAclip)rrrrrz+(When the type of min in clip is Variable.)r@z+(When the type of max in clip is Variable.)rrrQr)rAr@TMinMaxrrr)r)#rrr>iinforrAr@rrr?rrrr,rgrxrcitemr2rrr.ryrr%rkr(r$r& stop_gradientr)rrrcr) rrrAr@rrx_dtypemin_max_rrrrs rtrr sj!''lG. xx!%%xx!%%, N "xx!%%xx!%%- $ $RXXbjj)--.RXXbjj)--. $ $RXXbjj)--.RXXbjj)--.RXXbjj)--.RXXbjj)--.+$3C+$3C 6 6#v}}--hhqk#v}}--hhqk#u%%C)?)?KK6>>2{{1300  6 63&&c5))sFJJ$4$455 fnnfnn%EEsFJJ$4$455 fnnfnn%EEKK6>>2{{1300 ? sEE3#96 B#x((IIHA  ? sEE3#96 B#x((IIHA  !  I   q* c8 $ $ $C 5M _%L c8 $ $ $C 5M _%L0vx0::$$S);  0A   rvc[[R"[R5R5n[[R"[R5R 5n[ U[5(aURS5n[ U[5(aURS5nUcUOUnUcUOUn[5(a[R"XU5$g)z Inplace version of ``clip`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_clip`. rN) rr>r?rrAr@rgr(rr,rclip_)rrrAr@rr3r/s rtrr s "**%)) *D "**%)) *D#x  hhqk#x  hhqk+$3C+$3C||AC((rvcSn[5(a[R"XX#5$U"XX#5 [S0[ 5D6nUR UR S9nURSSU/0XUS.SU/0S9 U$) a Computes the sum along diagonals of the input tensor x. If ``x`` is 2D, returns the sum of diagonal. If ``x`` has larger dimensions, then returns an tensor of diagonals sum, diagonals be taken from the 2D planes specified by axis1 and axis2. By default, the 2D planes formed by the first and second axes of the input tensor x. The argument ``offset`` determines where diagonals are taken from input tensor x: - If offset = 0, it is the main diagonal. - If offset > 0, it is above the main diagonal. - If offset < 0, it is below the main diagonal. - Note that if offset is out of input's shape indicated by axis1 and axis2, 0 will be returned. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``. For example, ``trace(input=x)`` is equivalent to ``trace(x=x)``. Args: x (Tensor): The input tensor x. Must be at least 2-dimensional. The input data type should be float16, float32, float64, int32, int64. alias: ``input``. offset (int, optional): Which diagonals in input tensor x will be taken. Default: 0 (main diagonals). axis1 (int, optional): The first axis with respect to take diagonal. Default: 0. axis2 (int, optional): The second axis with respect to take diagonal. Default: 1. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: the output data type is the same as input data type. Examples: .. code-block:: pycon >>> import paddle >>> case1 = paddle.randn([2, 3]) >>> case2 = paddle.randn([3, 10, 10]) >>> case3 = paddle.randn([3, 10, 5, 10]) >>> data1 = paddle.trace(case1) >>> data1.shape paddle.Size([]) >>> data2 = paddle.trace(case2, offset=1, axis1=1, axis2=2) >>> data2.shape paddle.Size([3]) >>> data3 = paddle.trace(case3, offset=-3, axis1=1, axis2=-1) >>> data3.shape paddle.Size([3, 5]) c[URS/SQS5 [UR5n[ U5S:dS[ U5S35eUS:aUO [ U5U-nUS:aUO [ U5U-nSU::aU[ U5:d'S[ U5*S [ U5S - S US 35eSU::aU[ U5:d'S [ U5*S [ U5S - S US 35eXV:wdSUSUS35eg)Nrrrrrrtracer#zJThe x must be at least 2-dimensional, But received Input x's dimensional: rnrz@The argument axis1 is out of range (expected to be in range of [z, r/z ], but got z). z@The argument axis2 is out of range (expected to be in range of [z=axis1 and axis2 cannot be the same axis.But received axis1 = z , axis2 = rm)r$rrhrorn)rroffsetaxis1axis2raxis1_axis2_s rtrttrace..__check_input s GG  ?   177m ;1$  336{3C2DC I $  1*#k*:U*B1*#k*:U*BV &3{+;"; NQTU`QaObNccefijufvyzfze{|GHMGNNR S <V &3{+;"; NQTU`QaObNccefijufvyzfze{|GHMGNNR S <  $$)7*UG2 ? rvrrr)rrrrr)r)r-rrr)rrrr)rrrrrrrtrrs rtrr sr <||Au44a.1177agg7FaS>#eDSEN   rvc[5(a[R"X5$[S 0[ 5D6n[ US/SQS5 [ US/SQS5 UR URS9nURSXS.SU0S9 U$) a Compute the Kronecker product of two tensors, a composite tensor made of blocks of the second tensor scaled by the first. Assume that the rank of the two tensors, $X$ and $Y$ are the same, if necessary prepending the smallest with ones. If the shape of $X$ is [$r_0$, $r_1$, ..., $r_N$] and the shape of $Y$ is [$s_0$, $s_1$, ..., $s_N$], then the shape of the output tensor is [$r_{0}s_{0}$, $r_{1}s_{1}$, ..., $r_{N}s_{N}$]. The elements are products of elements from $X$ and $Y$. The equation is: $$ output[k_{0}, k_{1}, ..., k_{N}] = X[i_{0}, i_{1}, ..., i_{N}] * Y[j_{0}, j_{1}, ..., j_{N}] $$ where $$ k_{t} = i_{t} * s_{t} + j_{t}, t = 0, 1, ..., N $$ Args: x (Tensor): the first operand of kron op, data type: bfloat16, float16, float32, float64, int32 or int64. y (Tensor): the second operand of kron op, data type: bfloat16, float16, float32, float64, int32 or int64. Its data type should be the same with x. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: The output of kron, data type: bfloat16, float16, float32, float64, int32 or int64. Its data is the same with x. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2], [3, 4]], dtype='int64') >>> y = paddle.to_tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype='int64') >>> out = paddle.kron(x, y) >>> out Tensor(shape=[6, 6], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 3 , 2 , 4 , 6 ], [4 , 5 , 6 , 8 , 10, 12], [7 , 8 , 9 , 14, 16, 18], [3 , 6 , 9 , 4 , 8 , 12], [12, 15, 18, 16, 20, 24], [21, 24, 27, 28, 32, 36]]) kronrrrQrrrrr)r) r-rrr)rr&rrrrrrrrrs rtrrsZ{{1  0vx0  I   !  I   77agg7Fa 05#,   rvrc PUcSnOSnUcYUR[R[R[R[R 4;a [ US5nO&[U5nURU:wa [ X5n[5(aUcSn[R"XUSSUS9$[US/SQS5 [US[S5 [5R5n0nUR!5Hup8UcM XU'M [#S5n U "S 0UD6$) a The cumulative sum of the elements along a given axis. Note: The first element of the result is the same as the first element of the input. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``dim`` can be used as an alias for ``axis``. For example, ``cumsum(input=tensor_x, dim=1, ...)`` is equivalent to ``cumsum(x=tensor_x, axis=1, ...)``. Args: x (Tensor): The input tensor needed to be cumsumed. alias: ``input``. axis (int, optional): The dimension to accumulate along. -1 means the last dimension. The default (None) is to compute the cumsum over the flattened array. alias: ``dim``. dtype (str|paddle.dtype|np.dtype|None, optional): The data type of the output tensor, can be bfloat16, float16, float32, float64, int32, int64, complex64, complex128. By default, it is int64 if the input x is int8/int16/int32; otherwise, it is None. If it is not None, the input tensor is casted to dtype before the operation is performed. This is useful for preventing data type overflows. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. out (Tensor, optional): The output tensor. If provided, the result will be stored in this tensor. Returns: Tensor, the result of cumsum operator. Examples: .. code-block:: python >>> import paddle >>> data = paddle.arange(12) >>> data = paddle.reshape(data, (3, 4)) >>> y = paddle.cumsum(data) >>> y Tensor(shape=[12], dtype=int64, place=Place(cpu), stop_gradient=True, [0 , 1 , 3 , 6 , 10, 15, 21, 28, 36, 45, 55, 66]) >>> y = paddle.cumsum(data, axis=0) >>> y Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0 , 1 , 2 , 3 ], [4 , 6 , 8 , 10], [12, 15, 18, 21]]) >>> y = paddle.cumsum(data, axis=-1) >>> y Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0 , 1 , 3 , 6 ], [4 , 9 , 15, 22], [8 , 17, 27, 38]]) >>> y = paddle.cumsum(data, dtype='float64') >>> assert y.dtype == paddle.float64 TFrrrrr)rrrrrrrrcumsum)rrxrrrrr2r*r-rrr&r%r(rcopyror1) rrrqrrrflatten locals_varrrq _cum_sum_s rtrrGsz | } 77 LL KK LL LL   Q A*51 77e QA <D}}QgueEE     1cHx0X]]_ #))+ID"t ,&h/ "6""rvc2UcSnOSnUb_[U[RR[R45(d [ U5nUR U:wa [X5n[5(aUcSn[R"XUSS5$g) Inplace version of ``cumprod`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_cumprod`. NTFr) rgr+rVarTyperr*rr3r,rcumsum_)rrrqrrrs rtrrs | %$,,"6"6 !FGG.u5E 77e aA <D~~awu==rvcDUc*SnURS[UR5S- 5n[USSS/S5 [ U[ R R[ R45(d [U5n[5(a[R"XU5$[US/S QS5 [US[S5 [!S0[#5D6nUR%UR&5nUR%SS 9nUR)SSU0XVS .XS .S 9 XV4$)aA The cumulative max of the elements along a given axis. Note: The first element of the result is the same as the first element of the input. Args: x (Tensor): The input tensor needed to be cummaxed. axis (int, optional): The dimension to accumulate along. -1 means the last dimension. The default (None) is to compute the cummax over the flattened array. dtype (str|paddle.dtype|np.dtype, optional): The data type of the indices tensor, can be int32, int64. The default value is int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor), The result of cummax operation. The dtype of cummax result is same with input x. indices (Tensor), The corresponding index results of cummax operation. Examples: .. code-block:: python >>> import paddle >>> data = paddle.to_tensor([-1, 5, 0, -2, -3, 2]) >>> data = paddle.reshape(data, (2, 3)) >>> value, indices = paddle.cummax(data) >>> value Tensor(shape=[6], dtype=int64, place=Place(cpu), stop_gradient=True, [-1, 5, 5, 5, 5, 5]) >>> indices Tensor(shape=[6], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 1, 1, 1, 1, 1]) >>> value, indices = paddle.cummax(data, axis=0) >>> value Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[-1, 5, 0], [-1, 5, 2]]) >>> indices Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 0], [0, 0, 1]]) >>> value, indices = paddle.cummax(data, axis=-1) >>> value Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[-1, 5, 5], [-2, -2, 2]]) >>> indices Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 1, 1], [0, 0, 2]]) >>> value, indices = paddle.cummax(data, dtype='int64') >>> assert indices.dtype == paddle.int64 rrr/rrrcummaxrrrrrrrrindicesrqrr)r)rrnror$rgr+rrrr*r-rrr&r%r(r)rrrrrrrqrrrrrs rtrrs| | IIaQWW) *w' 2H= edll22DMMB C C*51}}Qe,,  4   1cHx02277@;;';J840  |rvcDUc*SnURS[UR5S- 5n[USSS/S5 [ U[ R R[ R45(d [U5n[5(a[R"XU5$[US/S QS5 [US[S5 [!S0[#5D6nUR%UR&5nUR%SS 9nUR)SSU0XVS .XS .S 9 XV4$)a@ The cumulative min of the elements along a given axis. Note: The first element of the result is the same as the first element of the input. Args: x (Tensor): The input tensor needed to be cummined. axis (int, optional): The dimension to accumulate along. -1 means the last dimension. The default (None) is to compute the cummin over the flattened array. dtype (str|paddle.dtype|np.dtype, optional): The data type of the indices tensor, can be int32, int64. The default value is int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor), The result of cummin operation. The dtype of cummin result is same with input x. indices (Tensor), The corresponding index results of cummin operation. Examples: .. code-block:: python >>> import paddle >>> data = paddle.to_tensor([-1, 5, 0, -2, -3, 2]) >>> data = paddle.reshape(data, (2, 3)) >>> value, indices = paddle.cummin(data) >>> value Tensor(shape=[6], dtype=int64, place=Place(cpu), stop_gradient=True, [-1, -1, -1, -2, -3, -3]) >>> indices Tensor(shape=[6], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 0, 0, 3, 4, 4]) >>> value, indices = paddle.cummin(data, axis=0) >>> value Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[-1, 5, 0], [-2, -3, 0]]) >>> indices Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 0], [1, 1, 0]]) >>> value, indices = paddle.cummin(data, axis=-1) >>> value Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[-1, -1, -1], [-2, -3, -3]]) >>> indices Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 0], [0, 1, 1]]) >>> value, indices = paddle.cummin(data, dtype='int64') >>> assert indices.dtype == paddle.int64 rrr/rrrcumminrrrrrrr)r )rrnror$rgr+rrrr*r-rr r&r%r(r)rrrrrs rtr r +sz | IIaQWW) *w' 2H= edll22DMMB C C*51}}Qe,,  4   1cHx02277@;;';J840  |rvcjUcSnOSnUb$UR[U5:wa [X5n[5(aUcSn[R "XUSS5$[ US/SQS5 [S 0[5D6nURUR5nURSSU0SU0XS .S 9 U$) a The logarithm of the cumulative summation of the exponentiation of the elements along a given axis. For summation index j given by `axis` and other indices i, the result is .. math:: logcumsumexp(x)_{ij} = log \sum_{i=0}^{j}exp(x_{ij}) Note: The first element of the result is the same as the first element of the input. Args: x (Tensor): The input tensor, with data type float32, float64, float16, bfloat16, uint8, int8, int16, int32, int64 axis (int, optional): The dimension to do the operation along. -1 means the last dimension. The default (None) is to compute the cumsum over the flattened array. dtype (str|core.VarDesc.VarType|core.DataType|np.dtype, optional): The data type of the output tensor, can be float16, float32, float64. If specified, the input tensor is casted to dtype before the operation is performed. This is useful for preventing data type overflows. The default value is None. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, the result of logcumsumexp operator (integer input types are autocasted into float32). Examples: .. code-block:: python >>> import paddle >>> data = paddle.arange(12, dtype='float64') >>> data = paddle.reshape(data, (3, 4)) >>> y = paddle.logcumsumexp(data) >>> y Tensor(shape=[12], dtype=float64, place=Place(cpu), stop_gradient=True, [0. , 1.31326169 , 2.40760596 , 3.44018970 , 4.45191440 , 5.45619332 , 6.45776285 , 7.45833963 , 8.45855173 , 9.45862974 , 10.45865844, 11.45866900]) >>> y = paddle.logcumsumexp(data, axis=0) >>> y Tensor(shape=[3, 4], dtype=float64, place=Place(cpu), stop_gradient=True, [[0. , 1. , 2. , 3. ], [4.01814993 , 5.01814993 , 6.01814993 , 7.01814993 ], [8.01847930 , 9.01847930 , 10.01847930, 11.01847930]]) >>> y = paddle.logcumsumexp(data, axis=-1) >>> y Tensor(shape=[3, 4], dtype=float64, place=Place(cpu), stop_gradient=True, [[0. , 1.31326169 , 2.40760596 , 3.44018970 ], [4. , 5.31326169 , 6.40760596 , 7.44018970 ], [8. , 9.31326169 , 10.40760596, 11.44018970]]) >>> y = paddle.logcumsumexp(data, dtype='float64') >>> assert y.dtype == paddle.float64 TFrrr rrrrrrrrr logcumsumexprr)rqrr)r ) rr*r2r-rr r&r)rrr)rrrqrrrrrs rtr r sx | QWW(B5(II N <D""1GUEBB    "8vx877@8CL4   rv)rrrc@Uc*SnURS[UR5S- 5nUb_[U[R R [R45(d [U5nURU:wa [X5n[5(a[R"XSSUS9$[US/SQS5 [US [ S5 [#S 0[%5D6nUR'UR5nUR)SS U0S U0S U0S 9 U$)a Compute the cumulative product of the input tensor x along a given dimension dim. .. note:: The first element of the result is the same as the first element of the input. Alias Support: The parameter name ``input`` can be used as an alias for ``x``. Args: x (Tensor): the input tensor need to be cumproded. dim (int|None, optional): the dimension along which the input tensor will be accumulated. It need to be in the range of [-x.rank, x.rank) or None, where x.rank means the dimensions of the input tensor x and -1 means the last dimension. The default (None) is to compute the cumprod over the flattened array. dtype (str|core.VarDesc.VarType|core.DataType|np.dtype, optional): The data type of the output tensor, can be bfloat16, float16, float32, float64, int32, int64, complex64, complex128. If specified, the input tensor is casted to dtype before the operation is performed. This is useful for preventing data type overflows. The default value is None. out (Tensor|None, optional): The output tensor. Default: None. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, the result of cumprod operator. Examples: .. code-block:: python >>> import paddle >>> data = paddle.arange(12) >>> data = paddle.reshape(data, (3, 4)) >>> data Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0 , 1 , 2 , 3 ], [4 , 5 , 6 , 7 ], [8 , 9 , 10, 11]]) >>> y = paddle.cumprod(data, dim=0) >>> y Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0 , 1 , 2 , 3 ], [0 , 5 , 12 , 21 ], [0 , 45 , 120, 231]]) >>> y = paddle.cumprod(data, dim=-1) >>> y Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0 , 0 , 0 , 0 ], [4 , 20 , 120 , 840 ], [8 , 72 , 720 , 7920]]) >>> y = paddle.cumprod(data, dim=1, dtype='float64') >>> y Tensor(shape=[3, 4], dtype=float64, place=Place(cpu), stop_gradient=True, [[0. , 0. , 0. , 0. ], [4. , 20. , 120. , 840. ], [8. , 72. , 720. , 7920.]]) >>> assert y.dtype == paddle.float64 rrr/Frrrrrrrrrrrcumprodrrrr)r)rrnrorgr+rrrr*rr2r-rrr&r%rkr)rrr)rrrrrrrs rtrrs F { IIaQWW) * %$,,"6"6 !FGG.u5E 77e QA~~aeU<<     3sI.3&(377@8CL#,   rvc|Uc0Sn[R"US[UR5S- 5nUb_[ U[ R R[ R45(d [U5nURU:wa [X5n[5(a[R"XSS5$g)rNrrr/F)rflatten_rnrorgr+rrrr*rr3r,cumprod_)rrrrrs rtrrVs { OOAq#agg,"2 3 %$,,"6"6 !FGG.u5E 77e aAque44rvc Ub4[US/SQS5 UR[U5:wa [X5n[R "U5(aUR S/:XaU$[X5upa[5(a[R"XX&US9$[S 0[5D6n[US/SQS5 URUR5S9nUR!SS U0S U0XUS .S 9 U$)a Compute the product of tensor elements over the given axis. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``dim`` can be used as an alias for ``axis``. For example, ``prod(input=tensor_x, dim=1, ...)`` is equivalent to ``prod(x=tensor_x, axis=1, ...)``. Args: x (Tensor): The input tensor, its data type should be bfloat16, float16, float32, float64, int32, int64, complex64, complex128. alias: ``input``. axis (int|list|tuple|None, optional): The axis along which the product is computed. If :attr:`None`, multiply all elements of `x` and return a Tensor with a single element, otherwise must be in the range :math:`[-x.ndim, x.ndim)`. If :math:`axis[i]<0`, the axis to reduce is :math:`x.ndim + axis[i]`. Default is None. alias: ``dim``. keepdim (bool, optional): Whether to reserve the reduced dimension in the output Tensor. The result tensor will have one fewer dimension than the input unless `keepdim` is true. Default is False. dtype (str|core.VarDesc.VarType|core.DataType|np.dtype, optional): The desired date type of returned tensor, can be bfloat16, float16, float32, float64, int32, int64. If specified, the input tensor is casted to dtype before operator performed. This is very useful for avoiding data type overflows. The default value is None, the dtype of output is the same as input Tensor `x`. out (Tensor|None, optional): The output tensor. Default: None. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, result of product on the specified dim of input tensor. Examples: .. code-block:: python >>> import paddle >>> # the axis is a int element >>> x = paddle.to_tensor([[0.2, 0.3, 0.5, 0.9], ... [0.1, 0.2, 0.6, 0.7]]) >>> out1 = paddle.prod(x) >>> out1 Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 0.00022680) >>> out2 = paddle.prod(x, -1) >>> out2 Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [0.02700000, 0.00840000]) >>> out3 = paddle.prod(x, 0) >>> out3 Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [0.02000000, 0.06000000, 0.30000001, 0.63000000]) >>> out4 = paddle.prod(x, 0, keepdim=True) >>> out4 Tensor(shape=[1, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.02000000, 0.06000000, 0.30000001, 0.63000000]]) >>> out5 = paddle.prod(x, 0, dtype='int64') >>> out5 Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 0, 0, 0]) >>> # the axis is list >>> y = paddle.to_tensor([[[1.0, 2.0], [3.0, 4.0]], ... [[5.0, 6.0], [7.0, 8.0]]]) >>> out6 = paddle.prod(y, [0, 1]) >>> out6 Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [105., 384.]) >>> out7 = paddle.prod(y, (1, 2)) >>> out7 Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [24. , 1680.]) r)rrrrrrrrrrr reduce_prodrXrrrrr)r)r$rr*r2rx is_tensorror}r-rrr)rr&rrcr)rrrqrTrrrrsrs rtrrns f       7707 7QA$**"33D<J{{1GSAA7fh7    77$$&8  8CL:N   rvc.[R"U5$)z Inplace version of ``tanh`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_tanh`. )rtanh_rs rtrrs <<?rvc *[5(a[R"X5$[US/SQS5 [ 5(a[R"X5 U$[ S0[ 5D6nURSSU/0SU/0S[U50S9 U$) a The API is usually used for control flow to increment the data of :attr:`x` by an amount :attr:`value`. Notice that the number of elements in :attr:`x` must be equal to 1. Args: x (Tensor): A tensor that must always contain only one element, its data type supports float32, float64, int32 and int64. value (float, optional): The amount to increment the data of :attr:`x`. Default: 1.0. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, the elementwise-incremented tensor with the same shape and data type as :attr:`x`. Examples: .. code-block:: python >>> import paddle >>> data = paddle.zeros(shape=[1], dtype='float32') >>> counter = paddle.increment(data) >>> counter Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, [1.]) rrr incrementrrstepr)r) r,r increment_r&r.r)rrr)rrvaluerrs rtrrs2  ** 38+}}!#5FH5!:QCL5<(  rvc[U5S:Xa/$[U5S:Xa[US5$[US5nUSSHn[X5nM U$)a The function returns the shape of doing operation with broadcasting on tensors of shape list. Note: If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: *shapes (list[int]|tuple[int]): A shape list of multiple tensors. Returns: list[int], the result shape. Examples: .. code-block:: python >>> import paddle >>> shape = paddle.broadcast_shapes([2, 1, 3], [1, 3, 1]) >>> shape [2, 3, 3] >>> # shape = paddle.broadcast_shapes([2, 1, 3], [3, 3, 1]) >>> # ValueError (terminated with error message). >>> shape = paddle.broadcast_shapes([5, 1, 3], [1, 4, 1], [1, 1, 3]) >>> shape [5, 4, 3] >>> # shape = paddle.broadcast_shapes([5, 1, 3], [1, 4, 1], [1, 2, 3]) >>> # ValueError (terminated with error message). rr/N)rnrhr)shapes current_shape next_shapes rtbroadcast_shapesr".s]H 6{a V F1IVAY  *J+MFM%rvc.[R"X5$)a The function returns the shape of doing operation with broadcasting on tensors of x_shape and y_shape. Note: If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x_shape (list[int]|tuple[int]): A shape of tensor. y_shape (list[int]|tuple[int]): A shape of tensor. Returns: list[int], the result shape. Examples: .. code-block:: python >>> import paddle >>> shape = paddle.broadcast_shape([2, 1, 3], [1, 3, 1]) >>> shape [2, 3, 3] >>> # shape = paddle.broadcast_shape([2, 1, 3], [3, 3, 1]) >>> # ValueError (terminated with error message). )r+r)rrs rtrr]sB    11rvc[5(a[R"U5$[US/SQS5 [ S0[ 5D6nUR UR5S9nURSSU0SU/0S9 U$) av This function computes the conjugate of the Tensor elementwisely. Args: x (Tensor): The input Tensor which hold the complex numbers. Optional data types are: bfloat16, float16, complex64, complex128, float32, float64, int32 or int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor): The conjugate of input. The shape and data type is the same with input. If the elements of tensor is real type such as float32, float64, int32 or int64, the out is the same with input. Examples: .. code-block:: python >>> import paddle >>> data = paddle.to_tensor([[1+1j, 2+2j, 3+3j], [4+4j, 5+5j, 6+6j]]) >>> data Tensor(shape=[2, 3], dtype=complex64, place=Place(cpu), stop_gradient=True, [[(1+1j), (2+2j), (3+3j)], [(4+4j), (5+5j), (6+6j)]]) >>> conj_data = paddle.conj(data) >>> conj_data Tensor(shape=[2, 3], dtype=complex64, place=Place(cpu), stop_gradient=True, [[(1-1j), (2-2j), (3-3j)], [(4-4j), (5-5j), (6-6j)]]) rrrconjrrrr)r%) r-rr%r&r)rrrcrrrrrrs rtr%r%s<{{1~    0vx077$$&8  fc1Xu~N rvc[5(a[R"U5$[US/SQS5 [ S0[ 5D6nUR UR5nURSSU0SU0S9 U$)a# Calculates the logarithm of the absolute value of the gamma function elementwisely. Args: x (Tensor): Input Tensor. Must be one of the following types: float16, float32, float64, bfloat16. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, The values of the logarithm of the absolute value of the gamma at the given tensor x. Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(1.5, 4.5, 0.5) >>> out = paddle.gammaln(x) >>> print(out) Tensor(shape=[6], dtype=float32, place=Place(cpu), stop_gradient=True, [-0.12078224, 0. , 0.28468287, 0.69314718, 1.20097363, 1.79175949]) rr)rrrrgammalnrr)r() r-rr(r&r)rrrrr&s rtr(r(su.~~a   sA9 3&(377@ia5#,O rvcN[5(a[R"U5$g)z Inplace version of ``gammaln`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_gammaln`. N)r,rgammaln_rs rtr*r*! q!!rvc[5(a[R"U5$[US/SQS5 [ S0[ 5D6nUR UR5nURSSU0SU0S9 U$)a Calculates the digamma of the given input tensor, element-wise. .. math:: Out = \Psi(x) = \frac{ \Gamma^{'}(x) }{ \Gamma(x) } Args: x (Tensor): Input Tensor. Must be one of the following types: bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, the digamma of the input Tensor, the shape and data type is the same with input (integer types are autocasted into float32). Examples: .. code-block:: python >>> import paddle >>> data = paddle.to_tensor([[1, 1.5], [0, -2.2]], dtype='float32') >>> res = paddle.digamma(data) >>> res Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.57721591, 0.03648996], [ nan , 5.32286835]]) rrr digammarrr)r-) r-rr-r&r)rrrrr&s rtr-r-s{8~~a      3&(377@ia5#,O rvcN[5(a[R"U5$g)z Inplace version of ``digamma`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_digamma`. N)r,rdigamma_rs rtr/r/r+rvc[U[5(dO[R"[R"U[R "U555(d [ S5e[U[5(dO[R"[R"U[R "U555(d [ S5e[5(a[R"X5$[USSS/S5 [USSS/S5 [S 0[5D6nURUR5nURSXS.S U0S 9 U$) a Computes the regularized upper incomplete gamma function. .. math:: Q(x, y) = \frac{1}{\Gamma(x)} \int_{y}^{\infty} t^{x-1} e^{-t} dt Args: x (Tensor): The non-negative argument Tensor. Must be one of the following types: float32, float64. y (Tensor): The positive parameter Tensor. Must be one of the following types: float32, float64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, the gammaincc of the input Tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([0.5, 0.5, 0.5, 0.5, 0.5], dtype="float32") >>> y = paddle.to_tensor([0, 1, 10, 100, 1000], dtype="float32") >>> out = paddle.gammaincc(x, y) >>> print(out) Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [1. , 0.15729916, 0.00000774, 0. , 0. ]) z8The input argument x must be greater than or equal to 0.z8The input argument y must be greater than or equal to 0.rrrr gammainccrrrr)r1)rgrrxr greater_equalrSrr-rr1r&r)rrrrrs rtr1r1's'4 a   Q 1 1! 45)) F   a   Q 1 1! 45)) F  %% C)Y)?M C)Y)?M5FH577@1%5s|   rvcN[5(a[R"X5$g)z Inplace version of ``gammaincc`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_gammaincc`. N)r,r gammaincc_rs rtr4r4Zs#   &&rvc4S[R"X5- $)a Computes the regularized lower incomplete gamma function. .. math:: P(x, y) = \frac{1}{\Gamma(x)} \int_{0}^{y} t^{x-1} e^{-t} dt Args: x (Tensor): The non-negative argument Tensor. Must be one of the following types: float32, float64. y (Tensor): The positive parameter Tensor. Must be one of the following types: float32, float64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, the gammainc of the input Tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([0.5, 0.5, 0.5, 0.5, 0.5], dtype="float32") >>> y = paddle.to_tensor([0, 1, 10, 100, 1000], dtype="float32") >>> out = paddle.gammainc(x, y) >>> print(out) Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [0. , 0.84270084, 0.99999225, 1. , 1. ]) r/)rxr1rs rtgammaincr6ds4 v% %%rvc[R"X5R[R"US55R [R"US55$)z Inplace version of ``gammainc`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_gammainc`. ?)rxr4rr:rrs rt gammainc_r:sE ! 6##At, - fq#& 'rvc[5(a[R"U5$[US/SQS5 [ S0[ 5D6nUR UR5nURSSU0SU0S9 U$)a Calculates the lgamma of the given input tensor, element-wise. This operator performs elementwise lgamma for input $X$. :math:`out = log\Gamma(x)` Args: x (Tensor): Input Tensor. Must be one of the following types: bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, the lgamma of the input Tensor, the shape and data type is the same with input (integer types are autocasted into float32). Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) >>> out = paddle.lgamma(x) >>> out Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [1.31452453, 1.76149762, 2.25271273, 1.09579790]) rrr lgammarrr)r<) r-rr<r&r)rrrrr&s rtr<r<s{8}}Q    2277@hQx%N rvcN[5(a[R"U5$g)z Inplace version of ``lgamma`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_lgamma`. N)r,rlgamma_rs rtr>r>s! ~~a  rvcNUS:d SUS35eSU-US- -[R"[R5-nS[R"SU- SSUR S9-n[R "[R"URS5U-5SS9U-$) a This function computes the log of multivariate gamma, also sometimes called the generalized gamma. Args: x (Tensor): Input Tensor. Must be one of the following types: float16, float32, float64, uint16. p (int): The dimension of the space of integration. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor): The values of the log multivariate gamma at the given tensor x. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([2.5, 3.5, 4, 6.5, 7.8, 10.23, 34.25]) >>> p = 2 >>> out = paddle.multigammaln(x, p) >>> print(out) Tensor(shape=[7], dtype=float32, place=Place(cpu), stop_gradient=True, [0.85704780 , 2.46648574 , 3.56509781 , 11.02241898 , 15.84497833 , 26.09257698 , 170.68318176]) r/rrrJs rt multigammaln_rPs 6 FqcM6 qAETXXdgg..A''*A fmm1q5qqHHA MM1;;r?Q&//155b9>>qA1E Hrvc [USSSSUS9$)a. This function computes the negative of the Tensor elementwisely. Args: x (Tensor): Input of neg operator, an N-D Tensor, with data type bfloat16, float16, float32, float64, int8, int16, int32, int64, uint8, complex64, complex128. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor): The negative of input Tensor. The shape and data type are the same with input Tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3]) >>> out = paddle.neg(x) >>> out Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [ 0.40000001, 0.20000000, -0.10000000, -0.30000001]) r8rTNrrrrrrrs rtnegrSs0  C$Dt rvc(URSSSSUS9$)z} Inplace version of ``neg`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_neg`. r8rTNrR)rrs rtneg_rUs% 88tD  rvcXUR[R:Xa [S5eU$)a Returns the input Tensor as it is. This is used in `Tensor.__pos__`, applying the unary `+` operator to the tensor. .. math:: Out = +X Args: x (Tensor): The input tensor. The tensor cannot be of type bool. 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 with the same shape and data type as the input tensor. The returned tensor is the same. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([-1, 0, 1]) >>> out = paddle.positive(x) >>> print(out) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [-1, 0, 1]) z4The `+` operator, on a bool tensor is not supported.rrxrrlrs rtpositiverX&s%8 ww&++NOO HrvcZUR[R:Xa [S5eU*$)a  Returns the negated version of the input Tensor. This is used in `Tensor.__neg__`, applying the unary `-` operator to the tensor. .. math:: Out = -X Args: x (Tensor): The input tensor. The tensor cannot be of type bool. 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 with the same shape and data type as the input tensor. The returned tensor is the negative. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([-1, 0, 1]) >>> out = paddle.negative(x) >>> print(out) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 0, -1]) z4The `-` operator, on a bool tensor is not supported.rWrs rtnegativerZGs'8 ww&++NOO 2Irvc[UR5n[UR5n[5(aaUnUnX4:waB[R"X45n[R "XW5n[R "Xg5n[ R"XV5$[US/SQS5 [US/SQS5 [S 0[5D6nXS.n URURS9n URSU SU 0S9 U $) a Element-wise arctangent of x/y with consideration of the quadrant. Equation: .. math:: atan2(x,y)=\left\{\begin{matrix} & tan^{-1}(\frac{x}{y}) & y > 0 \\ & tan^{-1}(\frac{x}{y}) + \pi & x>=0, y < 0 \\ & tan^{-1}(\frac{x}{y}) - \pi & x<0, y < 0 \\ & +\frac{\pi}{2} & x>0, y = 0 \\ & -\frac{\pi}{2} & x<0, y = 0 \\ &\text{undefined} & x=0, y = 0 \end{matrix}\right. Args: x (Tensor): An N-D Tensor, the data type is int32, int64, float16, float32, float64. y (Tensor): An N-D Tensor, must have the same type as `x`. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor): An N-D Tensor, the shape and data type is the same with input (The output data type is float64 when the input data type is int). Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([-1, +1, +1, -1]).astype('float32') >>> x Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [-1, 1, 1, -1]) >>> y = paddle.to_tensor([-1, -1, +1, +1]).astype('float32') >>> y Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [-1, -1, 1, 1]) >>> out = paddle.atan2(x, y) >>> out Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [-2.35619450, 2.35619450, 0.78539819, -0.78539819]) rrratan2r)X1X2rrr)r\)rhror-rxr broadcast_torr\r&r)rrrr) rrrrrr broadcast_x broadcast_yrrrrs rtr\r\hs\177mG177mG   $44WFO --kKK --kKK||K55  ?   !  ?   11#77agg7FgfuclK rvcUcSn[5(a[R"X5$[US/SQS5 [ S 0[ 5D6nUR UR5nURSSU0SU0SU0S9 U$) a^ This function generates a new tensor with the logit of the elements of input x. x is clamped to [eps, 1-eps] when eps is not zero. When eps is zero and x < 0 or x > 1, the function will yields NaN. .. math:: logit(x) = ln(\frac{x}{1 - x}) where .. math:: x_i= \left\{\begin{array}{rcl} x_i & &\text{if } eps == Default \\ eps & &\text{if } x_i < eps \\ x_i & &\text{if } eps <= x_i <= 1-eps \\ 1-eps & &\text{if } x_i > 1-eps \end{array}\right. Args: x (Tensor): The input Tensor with data type bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64. eps (float|None, optional): the epsilon for input clamp bound. Default is None. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out(Tensor): A Tensor with the same data type and shape as ``x`` (integer types are autocasted into float32). Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([0.2635, 0.0106, 0.2780, 0.2097, 0.8095]) >>> out1 = paddle.logit(x) >>> out1 Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [-1.02785587, -4.53624487, -0.95440406, -1.32673466, 1.44676447]) rrrrlogitrrepsr)rc) r-rrcr&r)rrrr)rrrdrrrs rtrcrcsZ {||A##    1177@8CL#,   rvcXUcSn[5(a[R"X5$g)z Inplace version of ``logit`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_logit`. Nr)r,rlogit_)rrrdrs rtrfrfs+ {}}Q$$rvc[U[5(a[R"/X RS9n[ 5(a[ R"XU5$[US/SQS5 [US/SQS5 [US/SQS5 [S 0[5D6nXUS.nURURS9nURSUS U0S 9 U$) ah Does a linear interpolation between x and y based on weight. Equation: .. math:: lerp(x, y, weight) = x + weight * (y - x). Args: x (Tensor): An N-D Tensor with starting points, the data type is bfloat16, float16, float32, float64. y (Tensor): An N-D Tensor with ending points, the data type is bfloat16, float16, float32, float64. weight (float|Tensor): The weight for the interpolation formula. When weight is Tensor, the data type is bfloat16, float16, float32, float64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor): An N-D Tensor, the shape and data type is the same with input. Example: .. code-block:: python >>> import paddle >>> x = paddle.arange(1., 5., dtype='float32') >>> y = paddle.empty([4], dtype='float32') >>> y.fill_(10.) >>> out = paddle.lerp(x, y, 0.5) >>> out Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [5.50000000, 6. , 6.50000000, 7. ]) )ro fill_valuerrrrYlerprweight)rrWeightrrr)ri) rgrrxrrr-rrir&r)rrr)rrrrjrrrrs rtririsD&%  2&H{{1(( s?  ! s?  !   7   0vx0F377agg7FfVeS\J rvc[URUR5n[US[[R [ 4S5 [U[5(a![R"U/URS9nO:[U[R [ 45(a[XBR5nX@R:wa[SUSURS35e[R"XU5$)z Inplace version of ``lerp`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_lerp`. rjrirrrr) rror%rrxrcr(rgrrrrlerp_)rrrrjrrs rtrmrmMs 1Ivx%!A6J&%  !!6(!'': FV]]H5 6 6#I||< GG,YK7abcbibiajkE F   <<f %%rvc[5(a[R"U5$[US/SQS5 [ S0[ 5D6nUR URS9nURSSU0SU0S9 U$) aL The inverse error function of x. Please refer to :ref:`api_paddle_erf` .. math:: erfinv(erf(x)) = x. Args: x (Tensor): An N-D Tensor, the data type is float16, bfloat16, float32, float64, uint8, int8, int16, int32, int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor), an N-D Tensor, the shape and data type is the same with input (integer types are autocasted into float32). Example: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([0, 0.5, -1.], dtype="float32") >>> out = paddle.erfinv(x) >>> out Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [ 0. , 0.47693631, -inf. ]) rr) rrrrrrrrrerfinvrrrr)ro) r-rror&r)rrrrr&s rtrorobs~:}}Q    2277agg7FhQx%N rvcr[US[R[4S5 [R "U5$)z Inplace version of ``erfinv`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_erfinv`. rrro)r%rxrcr(rerfinv_rs rtrqrqs* q# x0(; >>! rvc:S[R- n[5(a;[UR5S;a [ USS9n[ R"XSS5$[US/SQS 5 [S0[5D6nUn[UR5S;aNUR[RS9nURS S U0S U0UR[RS .S9 URURS9nURSS U0S U0SU0S9 U$)a: Convert each of the elements of input x from angles in radians to degrees. Equation: .. math:: rad2deg(x)=180/ \pi * x Args: x (Tensor): An N-D Tensor, the data type is float32, float64, int32, int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor): An N-D Tensor, the shape and data type is the same with input (The output data type is float32 when the input data type is int). Examples: .. code-block:: python >>> import paddle >>> import math >>> x1 = paddle.to_tensor([3.142, -3.142, 6.283, -6.283, 1.570, -1.570]) >>> result1 = paddle.rad2deg(x1) >>> result1 Tensor(shape=[6], dtype=float32, place=Place(cpu), stop_gradient=True, [ 180.02334595, -180.02334595, 359.98937988, -359.98937988, 89.95437622 , -89.95437622 ]) >>> x2 = paddle.to_tensor(math.pi/2) >>> result2 = paddle.rad2deg(x2) >>> result2 Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 90.) >>> x3 = paddle.to_tensor(1) >>> result3 = paddle.rad2deg(x3) >>> result3 Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 57.29578018) rrrrrTrrrrad2degr2rrin_dtype out_dtyperr)rur>rGr-r'rr2rrr&r)rrrxrr)rrr rad2deg_scalerout_castrs rtrurus&R"%%KM  !%7 7Qi(A||Ac488 s>> import paddle >>> x1 = paddle.to_tensor([180.0, -180.0, 360.0, -360.0, 90.0, -90.0]) >>> result1 = paddle.deg2rad(x1) >>> result1 Tensor(shape=[6], dtype=float32, place=Place(cpu), stop_gradient=True, [3.14159274, -3.14159274, 6.28318548, -6.28318548, 1.57079637, -1.57079637]) >>> x2 = paddle.to_tensor(180) >>> result2 = paddle.deg2rad(x2) >>> result2 Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 3.14159274) gf@rtrrrTrrrdeg2radr2rrrvrr)r}ry)rrr deg2rad_scalerr{rs rtr}r}s&BEEEMM  !%7 7Qi(A||Ac488 s>> import paddle >>> x1 = paddle.to_tensor(12) >>> x2 = paddle.to_tensor(20) >>> paddle.gcd(x1, x2) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 4) >>> x3 = paddle.arange(6) >>> paddle.gcd(x3, x2) Tensor(shape=[6], dtype=int64, place=Place(cpu), stop_gradient=True, [20, 1 , 2 , 1 , 4 , 5]) >>> x4 = paddle.to_tensor(0) >>> paddle.gcd(x4, x2) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 20) >>> paddle.gcd(x4, x4) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 0) >>> x5 = paddle.to_tensor(-20) >>> paddle.gcd(x1, x5) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 4) c4[R"US:g5$Nrrxr rs rt _gcd_cond_fngcd.._gcd_cond_fnazz!q&!!rvc US:gn[R"X![R"URUR55n[R"X!U5[R"U[R "X5[R "URUR55p[R"X:X5[R"X:X54$r)rxrBonesrormodzeros)rrr y_not_equal_0y_safes rt _gcd_body_fngcd.._gcd_body_fndsQ m AGGQWW0MN LL1 - LL 1% QWWagg.   QUA)6<<q+DEErvrrrrgcdr) rxrror_r4r,r&staticnn while_loop)rrrrrorrr_s rtrr*sb  " "177AGG 4EA%AA%A 1 A 1 A"F 1  %DA1   C'7);UC C'7);UC!!,,\!P rvc[R"URUR5nX0R:wa[SUSURS35e[R"X5n[R "U5n[R "U5nSnSn[5(a(U"X5(aU"X5upU"X5(aMU$g)z} Inplace version of ``gcd`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_gcd`. rrrc4[R"US:g5$rrrs rtrgcd_.._gcd_cond_fnrrvcUS:Hn[R"U[R"URUR5U5n[R"U[R "URUR5[R "X55[R"X U5p[R"X:X5[R"X:X54$r)rxrBrrorrrrM)rrr y_equal_0rs rtrgcd_.._gcd_body_fnsF iQWWagg)FJ LL QWWagg. 1%  MM) *  LL % MM!&! '  rvN)rxrrorr_r5r4r,)rrrrrorrs rtgcd_rs  " "177AGG 4E ,UG3]^_^e^e]fgA B   A%A AA 1 A" &1  %DA1   rvc[R"X5n[R"US5n[R"U[R"UR UR 5U5n[R"U[R"UR UR 5[R"X-5U-5nU$)a Computes the element-wise least common multiple (LCM) of input |x| and |y|. Both x and y must have integer types. Note: lcm(0,0)=0, lcm(0, y)=0 If x.shape != y.shape, they must be broadcastable to a common shape (which becomes the shape of the output). Args: x (Tensor): An N-D Tensor, the data type is int32, int64. y (Tensor): An N-D Tensor, the data type is int32, int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor): An N-D Tensor, the data type is the same with input. Examples: .. code-block:: python >>> import paddle >>> x1 = paddle.to_tensor(12) >>> x2 = paddle.to_tensor(20) >>> paddle.lcm(x1, x2) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 60) >>> x3 = paddle.arange(6) >>> paddle.lcm(x3, x2) Tensor(shape=[6], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 20, 20, 60, 20, 20]) >>> x4 = paddle.to_tensor(0) >>> paddle.lcm(x4, x2) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 0) >>> paddle.lcm(x4, x4) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 0) >>> x5 = paddle.to_tensor(-20) >>> paddle.lcm(x1, x5) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 60) r) rxrrCrBrrorrr4)rrrrd d_equal_0d_safers rtlcmrsb  1A Q"I \\)V[[!''%BA FF ,,6<<16::ae3D3N C Jrvc[R"X5nUS:gn[R"XC[R"URUR 55n[R "U[R"URU55RU5[R"URUR 55nU$)z} Inplace version of ``lcm`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_lcm`. r) rxrrBrrorrMr5rr r)rrrrr d_not_equal_0rrs rtlcm_rs  1AFM \\-FKK,I JF -- AKKN#11&9 QWWagg& C Jrv)rrrqc US:a[SU35eSSjnU"USUUUUUS:XaUOSS9nUS:a,[US- 5Hn U"USUSSUS9nM U"USUSSUUS9nU$) a Computes the n-th forward difference along the given axis. The first-order differences is computed by using the following formula: .. math:: out[i] = x[i+1] - x[i] Higher-order differences are computed by using paddle.diff() recursively. The number of n supports any positive integer value. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``dim`` can be used as an alias for ``axis``. For example, ``diff(input=tensor_x, dim=1, ...)`` is equivalent to ``diff(x=tensor_x, axis=1, ...)``. Args: x (Tensor): The input tensor to compute the forward difference on, the data type is float16, float32, float64, bool, int32, int64. alias: ``input``. n (int, optional): The number of times to recursively compute the difference. Supports any positive integer value. Default:1 axis (int, optional): The axis to compute the difference along. Default:-1 alias: ``dim``. prepend (Tensor|None, optional): The tensor to prepend to input along axis before computing the difference. It's dimensions must be equivalent to that of x, and its shapes must match x's shape except on axis. append (Tensor|None, optional): The tensor to append to input along axis before computing the difference, It's dimensions must be equivalent to that of x, and its shapes must match x's shape except on axis. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. out (Tensor, optional): The output tensor. If provided, the result will be stored in this tensor. Returns: Tensor: The output tensor with same dtype with x. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 4, 5, 2]) >>> out = paddle.diff(x) >>> out Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [ 3, 1, -3]) >>> x_2 = paddle.to_tensor([1, 4, 5, 2]) >>> out = paddle.diff(x_2, n=2) >>> out Tensor(shape=[2], dtype=int64, place=Place(cpu), stop_gradient=True, [ -2, -4]) >>> y = paddle.to_tensor([7, 9]) >>> out = paddle.diff(x, append=y) >>> out Tensor(shape=[5], dtype=int64, place=Place(cpu), stop_gradient=True, [ 3, 1, -3, 5, 2]) >>> out = paddle.diff(x, n=2, append=y) >>> out Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [-2, -4, 8, -3]) >>> out = paddle.diff(x, n=3, append=y) >>> out Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [-2 , 12, -11]) >>> z = paddle.to_tensor([[1, 2, 3], [4, 5, 6]]) >>> out = paddle.diff(z, axis=0) >>> out Tensor(shape=[1, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[3, 3, 3]]) >>> out = paddle.diff(z, axis=1) >>> out Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 1], [1, 1]]) r/z:Diff expects input to be at least one-dimensional but got NcUS:aU[UR5-nU[UR5:a[UR5nUS:aSnURnU/n[[U55V s/sHn SPM n n [ 5(GaESn /n Ub UbX0U/n Sn OUbX0/n Sn OUbX/n Sn U (a[ R "X5n OUn SnSnU RUnUS:a[R"U 5UnS/nUSU4- nUS- /nUSU4- n[ R"XUUU /5nS/nUSU4- nU/nUSU4- n[ R"XUUU /5nUR[R:Xd(UR[RR:Xa[ R"UUUS9$[ R"UUUS9$[US /S QS 5 [!US ["S 5 [%S0['5D6nSn /n Ub UbX0U/n Sn OUbX0/n Sn OUbX/n Sn U (a+UR)U5n UR+S SU 0SU /0S U0S9 OUn U RUnSU0nS/nUS- /nUUS'UUS'UR)U5nUR+SSU 0USU0S9 SU0nS/nU/nUUS'UUS'UR)U5nUR+SSU 0USU0S9 U[R:Xa)UR)U5nUR+SUUS.SU0S9 U$[R,R.RUU5nU$s sn f)Nrr/FTrstartsendsrrr)rrrrrrdiffrqconcatrrraxesslicerr logical_xorrr)r)rnrorrjr-rrrxrrr+rBOOLrrr&r%rkr)rrrtensorr)rrnrqprependappendrrrrrr infer_flagshas_pend input_list new_inputattrs_1attrs_2dim_lenstarts_1ends_1 input_frontstarts_2ends_2 input_backrs rt _diff_handlerdiff.._diff_handler[s !8#agg,&D #agg, qww"CL!Jmm((11*kJJ_4s: M)rrqrrrrr#)rrqrrr)r/rNNNN)rrj) rrrrqrrrrrlast_outrs rtrrsr 1uH L  DHzx  6CtH 1uq1uA$AD$t$H!   Orvc[5(a[R"U5$[US/SQS5 Sn[ U40[ 5D6nSU0nUR [UR5S9nSU0nURX$US9 U$)a' Element-wise angle of complex numbers. For non-negative real numbers, the angle is 0 while for negative real numbers, the angle is :math:`\pi`, and NaNs are propagated.. Equation: .. math:: angle(x)=arctan2(x.imag, x.real) Args: x (Tensor): An N-D Tensor, the data type is complex64, complex128, or float32, float64 . name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: An N-D Tensor of real data type with the same precision as that of x's data type. Examples: .. code-block:: pycon >>> import paddle >>> x = paddle.to_tensor([-2, -1, 0, 1]).unsqueeze(-1).astype('float32') >>> y = paddle.to_tensor([-2, -1, 0, 1]).astype('float32') >>> z = x + 1j * y >>> z Tensor(shape=[4, 4], dtype=complex64, place=Place(cpu), stop_gradient=True, [[(-2.00000000-2.00000000j), (-2.00000000-1.00000000j), (-2.00000000+0.00000000j), (-2.00000000+1.00000000j)], [(-1.00000000-2.00000000j), (-1.00000000-1.00000000j), (-1.00000000+0.00000000j), (-1.00000000+1.00000000j)], [(0.00000000-2.00000000j) , (0.00000000-1.00000000j) , (0.00000000+0.00000000j), (0.00000000+1.00000000j)], [ (1.00000000-2.00000000j), (1.00000000-1.00000000j), (1.00000000+0.00000000j), (1.00000000+1.00000000j)]]) >>> theta = paddle.angle(z) >>> theta Tensor(shape=[4, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[-2.35619450, -2.67794514, 3.14159274, 2.67794514], [-2.03444386, -2.35619450, 3.14159274, 2.35619450], [-1.57079637, -1.57079637, 0. , 1.57079637], [-1.10714877, -0.78539819, 0. , 0.78539819]]) rr)rrrrrranglerrrr) r-rrr&r)rrr0rr)rrrrrrrrs rtrrsZ||A    W11q77(18 #,ggF rvc[5(a[R"X5$Sn[[ U40[ 5D65$)a Computes the Heaviside step function determined by corresponding element in y for each element in x. The equation is .. math:: heaviside(x, y)= \left\{ \begin{array}{lcl} 0,& &\text{if} \ x < 0, \\ y,& &\text{if} \ x = 0, \\ 1,& &\text{if} \ x > 0. \end{array} \right. Note: ``paddle.heaviside`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): The input tensor of Heaviside step function, it's data type should be bfloat16, float16, float32, float64, int32 or int64. y (Tensor): The tensor that determines a Heaviside step function, it's data type should be bfloat16, float16, float32, float64, int32 or int64. name (str|None, optional): Name for the operation (optional, default is None). Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: N-D Tensor. A location into which the result is stored. If x and y have different shapes and are broadcastable, the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([-0.5, 0, 0.5]) >>> y = paddle.to_tensor([0.1]) >>> paddle.heaviside(x, y) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [0. , 0.10000000, 1. ]) >>> x = paddle.to_tensor([[-0.5, 0, 0.5], [-0.5, 0.5, 0]]) >>> y = paddle.to_tensor([0.1, 0.2, 0.3]) >>> paddle.heaviside(x, y) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0. , 0.20000000, 1. ], [0. , 1. , 0.30000001]]) elementwise_heaviside)r-r heavisiderr)r)rrrrrs rtrr9s;V%%){7?fh?@@rvc UR[R[R[R[R [R [R[R[R[R[R4 ;a[SUR35e[5(a+[R "U5n[R""XUS9$SU0n0n[%S 0['5D6n[)US/SQS5 UR+URS9nUR-SXESU0S9 [/[%S 0['5D65$) aM This API is used to return the fractional portion of each element in input. Args: x (Tensor): The input tensor, which data type should be int32, int64, float32, float64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. out (Tensor, optional): The output tensor. Default: None. Returns: Tensor: The output Tensor of frac. Examples: .. code-block:: python >>> import paddle >>> input = paddle.to_tensor([[12.22000003, -1.02999997], ... [-0.54999995, 0.66000003]]) >>> output = paddle.frac(input) >>> output Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.22000003, -0.02999997], [-0.54999995, 0.66000003]]) cThe data type of input must be one of ['int32', 'int64', 'float32', 'float64', 'float16'], but got rrr)rrrrrrrrrr)rrxrrrrrrINT32INT64r<r=FLOAT16rlr-rrrr)rr&rrr)rrrrrrrrs rtfracrks(8 ww    qrsryryqz {   LLOq--q11 sG   5 5AGG 5 Duaj  {IIJJrvc`UR[R[R[R[R [R 4;a[SUR35e[5(a,[R"U5n[R"X5$g)z Inplace version of ``frac`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_frac`. rN) rrxrrrrrrlr,rrr)rrrrs rtfrac_rs ww   qrsryryqz {   LLO%%rvc UR[R[R[R[R [R [R[R[R[R[R4 ;a[SUR35e[R"U5(a[R"U5n[R "U5n[R""USS9nX#- n[R$"U5n[R&"[R("U5XT5n[R*"U5$[R,"U5$)a For complex tensor, this API returns a new tensor whose elements have the same angles as the corresponding elements of input and absolute values of one. For other float dtype tensor, this API returns sign of every element in `x`: 1 for positive, -1 for negative and 0 for zero, same as paddle.sign. Args: x (Tensor): The input tensor, which data type should be float16, float32, float64, complex64, complex128. 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 sign Tensor for real input, or normalized Tensor for complex input, shape and data type are same as input. Examples: .. code-block:: pycon >>> import paddle >>> x = paddle.to_tensor([[3 + 4j, 7 - 24j, 0, 1 + 2j], [6 + 8j, 3, 0, -2]]) >>> paddle.sgn(x) Tensor(shape=[2, 4], dtype=complex64, place=Place(cpu), stop_gradient=True, [[ (0.60000002+0.80000001j), (0.28000000-0.95999998j), (0.00000000+0.00000000j), (0.44721359+0.89442718j)], [ (0.60000002+0.80000001j), (1.00000000+0.00000000j), (0.00000000+0.00000000j), (-1.00000000+0.00000000j)]]) zlThe data type of input must be one of ['float16', 'float32', 'float64', 'complex64', 'complex128'], but got rrF)rrxrrrrrrrr<r= COMPLEX64 COMPLEX128rl is_complexas_realr4rIrSrBr as_complexr)rrrexpand_xx_absrrs rtsgnrs)8 ww  z{||C|C{D E  >>!$ 1   R0!!!&)fll62EB  (({{1~rvcUS;a[SUS35e[5(a[U[R[ [R R45(d[S[U535eUR[R[R[R[R4;a[SUR35eO[!USSS/S 5 UR#5nUR#5nUR$S nUS :Xa[R&"US :XV-U5nO\US :Xa:[R&"US :XV-U5n[R&"XV:XV-U5nOUS:XaUS :a[)US US- 5nUR+U5R-UR$5nU$)a Returns a new tensor with the elements of input tensor x at the given index. The input tensor is treated as if it were viewed as a 1-D tensor. The result takes the same shape as the index. Args: x (Tensor): An N-D Tensor, its data type should be int32, int64, float32, float64. index (Tensor): An N-D Tensor, its data type should be int32, int64. mode (str, optional): Specifies how out-of-bounds index will behave. the candidates are ``'raise'``, ``'wrap'`` and ``'clip'``. - ``'raise'``: raise an error (default); - ``'wrap'``: wrap around; - ``'clip'``: clip to the range. ``'clip'`` mode means that all indices that are too large are replaced by the index that addresses the last element. Note that this disables indexing with negative numbers. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, Tensor with the same shape as index, the data type is the same with input. Examples: .. code-block:: python >>> import paddle >>> x_int = paddle.arange(0, 12).reshape([3, 4]) >>> x_float = x_int.astype(paddle.float64) >>> idx_pos = paddle.arange(4, 10).reshape([2, 3]) # positive index >>> idx_neg = paddle.arange(-2, 4).reshape([2, 3]) # negative index >>> idx_err = paddle.arange(-2, 13).reshape([3, 5]) # index out of range >>> paddle.take(x_int, idx_pos) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[4, 5, 6], [7, 8, 9]]) >>> paddle.take(x_int, idx_neg) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[10, 11, 0 ], [1 , 2 , 3 ]]) >>> paddle.take(x_float, idx_pos) Tensor(shape=[2, 3], dtype=float64, place=Place(cpu), stop_gradient=True, [[4., 5., 6.], [7., 8., 9.]]) >>> x_int.take(idx_pos) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[4, 5, 6], [7, 8, 9]]) >>> paddle.take(x_int, idx_err, mode='wrap') Tensor(shape=[3, 5], dtype=int64, place=Place(cpu), stop_gradient=True, [[10, 11, 0 , 1 , 2 ], [3 , 4 , 5 , 6 , 7 ], [8 , 9 , 10, 11, 0 ]]) >>> paddle.take(x_int, idx_err, mode='clip') Tensor(shape=[3, 5], dtype=int64, place=Place(cpu), stop_gradient=True, [[0 , 0 , 0 , 1 , 2 ], [3 , 4 , 5 , 6 , 7 ], [8 , 9 , 10, 11, 11]]) )raisewraprzA'mode' in 'take' should be 'raise', 'wrap', 'clip', but received rz,The type of 'index' must be Tensor, but got zDThe data type of 'index' must be one of ['int32', 'int64'], but got rrrtakerrrrrr/)rr-rgrxrcr(ryrrlrmrrrrrrr&rrorBr index_selectr)rrrmoderinput_1dindex_1d max_indexrs rtrrsL ,,OPTvUV W  %&--6::;K;K!LMM>tE{mL  ;; LL LL NN NN   VW\WbWbVcd    !'71CVLyy{H}}Hr"I w<<1 h.BHM <<1 h.BHM<<  !8#7   q=HaQ7H    ) 1 1%++ >C Jrvc XUR[R[R[R [R 4;a[SUR35e[R"U5n[R"[R"U55n[R"[R"U5[R"US5U5n[R"USU-5n[R"US:[R"U[R "U55U5n[R"US:[R"US[R "U5-5U5n[R"US:US-U5nXC4$)aL The function used to decompose a floating point number into mantissa and exponent. Args: x (Tensor): The input tensor, it's data type should be float32, float64. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: - mantissa (Tensor), A mantissa Tensor. The shape and data type of mantissa tensor and exponential tensor are the same as those of input. - exponent (Tensor), A exponent Tensor. The shape and data type of mantissa tensor and exponential tensor are the same as those of input. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2, 3, 4]], dtype="float32") >>> mantissa, exponent = paddle.tensor.math.frexp(x) >>> mantissa Tensor(shape=[1, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.50000000, 0.50000000, 0.75000000, 0.50000000]]) >>> exponent Tensor(shape=[1, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 2., 2., 3.]]) zFThe data type of input must be one of ['float32', 'float64'], but got rr#r/r)rrxrrrr<r=rlr4rNrrBr r:rr ones_like)rrrinput_xrmantissas rtfrexprjsK< ww  TUVU\U\T] ^  jjmG||FKK01H|| X 0 01 =xH }}Wak2H|| Q 8V--h78H || Q hV%5%5h%? ?@H ||QUX]H=H  rvc vUS:Xa[RnOUS:Xa[RnUbUb [S5eUR[R [R [R[RRRR[RRRR[RRRR4;a[SUR35eURnXcnUS:aX0R!5- nUc?UcSn[R""U5nUR!5S:a[SU35eGOQUR[R [R [R[RRRR[RRRR[RRRR4;a[SUR35eUR!5S:XaM[R$"U5nS/UR!5-nURSX'UR'U5nO[R$"XS 9nS W"[R("U[R*"SU5US 9[R("U[R*"SUS- 5US 9-U-US 9-$) a Integrate along the given axis using the composite trapezoidal rule. Args: y (Tensor): Input tensor to integrate. It's data type should be float16, float32, float64. x (Tensor|None, optional): The sample points corresponding to the :attr:`y` values, the same type as :attr:`y`. It is known that the size of :attr:`y` is `[d_1, d_2, ... , d_n]` and :math:`axis=k`, then the size of :attr:`x` can only be `[d_k]` or `[d_1, d_2, ... , d_n ]`. If :attr:`x` is None, the sample points are assumed to be evenly spaced :attr:`dx` apart. The default is None. dx (float|None, optional): The spacing between sample points when :attr:`x` is None. If neither :attr:`x` nor :attr:`dx` is provided then the default is :math:`dx = 1`. axis (int, optional): The axis along which to integrate. The default is -1. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. sum_mode (str): use a different summation. The default is `sum`. Returns: Tensor, Definite integral of :attr:`y` is N-D tensor as approximated along a single axis by the trapezoidal rule. rrz2Not permitted to specify both x and dx input args.zThe data type of input must be Tensor, and dtype should be one of ['paddle.float16', 'paddle.float32', 'paddle.float64', 'paddle.base.core.DataType.FLOAT16', 'paddle.base.core.DataType.FLOAT32', 'paddle.base.core.DataType.FLOAT64'], but got rr9r/z#Expected dx to be a scalar, got dx=rFrB)rxrrrrrrrr;r+rrr<r=rlrorrrrgatherrH) rrrdxrqrsum_moderlengthros rt _trapezoidrs. u}::  == IMNNww !!)) !!)) !!)) @ABAHAH@I J  ggG ]F ax y :B   b ! 668a<B2$GH H  77 NN NN NN KK   % % - - KK   % % - - KK   % % - -   DEFELELDMN  557a<QBC!%%'ME((1+EKE"BQ*B  MM!V]]1f5D AmmAv}}Q ;$G H    rvc[XX#SS9$)a Integrate along the given axis using the composite trapezoidal rule. Use the sum method. Args: y (Tensor): Input tensor to integrate. It's data type should be float16, float32, float64. x (Tensor|None, optional): The sample points corresponding to the :attr:`y` values, the same type as :attr:`y`. It is known that the size of :attr:`y` is `[d_1, d_2, ... , d_n]` and :math:`axis=k`, then the size of :attr:`x` can only be `[d_k]` or `[d_1, d_2, ... , d_n ]`. If :attr:`x` is None, the sample points are assumed to be evenly spaced :attr:`dx` apart. The default is None. dx (float|None, optional): The spacing between sample points when :attr:`x` is None. If neither :attr:`x` nor :attr:`dx` is provided then the default is :math:`dx = 1`. axis (int, optional): The axis along which to integrate. The default is -1. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, Definite integral of :attr:`y` is N-D tensor as approximated along a single axis by the trapezoidal rule. If :attr:`y` is a 1D tensor, then the result is a float. If N is greater than 1, then the result is an (N-1)-D tensor. Examples: .. code-block:: python >>> import paddle >>> y = paddle.to_tensor([4, 5, 6], dtype='float32') >>> paddle.trapezoid(y) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 10.) >>> paddle.trapezoid(y, dx=2.) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 20.) >>> y = paddle.to_tensor([4, 5, 6], dtype='float32') >>> x = paddle.to_tensor([1, 2, 3], dtype='float32') >>> paddle.trapezoid(y, x) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 10.) >>> y = paddle.to_tensor([1, 2, 3], dtype='float64') >>> x = paddle.to_tensor([8, 6, 4], dtype='float64') >>> paddle.trapezoid(y, x) Tensor(shape=[], dtype=float64, place=Place(cpu), stop_gradient=True, -8.) >>> y = paddle.arange(6).reshape((2, 3)).astype('float32') >>> paddle.trapezoid(y, axis=0) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [1.50000000, 2.50000000, 3.50000000]) >>> paddle.trapezoid(y, axis=1) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [2., 8.]) rrrrrrrrqrs rt trapezoidrsx aB5 11rvc[XX#SS9$)a8 Integrate along the given axis using the composite trapezoidal rule. Use the cumsum method Args: y (Tensor): Input tensor to integrate. It's data type should be float16, float32, float64. x (Tensor|None, optional): The sample points corresponding to the :attr:`y` values, the same type as :attr:`y`. It is known that the size of :attr:`y` is `[d_1, d_2, ... , d_n]` and :math:`axis=k`, then the size of :attr:`x` can only be `[d_k]` or `[d_1, d_2, ... , d_n ]`. If :attr:`x` is None, the sample points are assumed to be evenly spaced :attr:`dx` apart. The default is None. dx (float|None, optional): The spacing between sample points when :attr:`x` is None. If neither :attr:`x` nor :attr:`dx` is provided then the default is :math:`dx = 1`. axis (int, optional): The axis along which to integrate. The default is -1. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, Definite integral of :attr:`y` is N-D tensor as approximated along a single axis by the trapezoidal rule. The result is an N-D tensor. Examples: .. code-block:: python >>> import paddle >>> y = paddle.to_tensor([4, 5, 6], dtype='float32') >>> paddle.cumulative_trapezoid(y) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [4.50000000, 10. ]) >>> paddle.cumulative_trapezoid(y, dx=2.) >>> # Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, >>> # [9. , 20.]) >>> y = paddle.to_tensor([4, 5, 6], dtype='float32') >>> x = paddle.to_tensor([1, 2, 3], dtype='float32') >>> paddle.cumulative_trapezoid(y, x) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [4.50000000, 10. ]) >>> y = paddle.to_tensor([1, 2, 3], dtype='float64') >>> x = paddle.to_tensor([8, 6, 4], dtype='float64') >>> paddle.cumulative_trapezoid(y, x) Tensor(shape=[2], dtype=float64, place=Place(cpu), stop_gradient=True, [-3., -8.]) >>> y = paddle.arange(6).reshape((2, 3)).astype('float32') >>> paddle.cumulative_trapezoid(y, axis=0) Tensor(shape=[1, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1.50000000, 2.50000000, 3.50000000]]) >>> paddle.cumulative_trapezoid(y, axis=1) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.50000000, 2. ], [3.50000000, 8. ]]) rrrrs rtcumulative_trapezoidr:s| aB8 44rvc 0[US/SQS5 UR5S:wa[SUR5S35eUcURSnUS:a [S 5e[R "URSU/UR S 9n[R"5(amUS:a'[R"S/UR S 9USS2S4'US:a9USS2S4USS2SS24'[R"USS2SS24S S 9USS2SS24'OUS:aJ[RRU[S5S4[R"S/UR S 95nUS:a[RRU[S5[SS54USS2S45n[RRU[S5[SS54[R"USS2SS24S S 95nU(dUSS2SSS 24nU$UnU$) a# Generate a Vandermonde matrix. The columns of the output matrix are powers of the input vector. Order of the powers is determined by the increasing Boolean parameter. Specifically, when the increment is "false", the ith output column is a step-up in the order of the elements of the input vector to the N - i - 1 power. Such a matrix with a geometric progression in each row is named after Alexandre-Theophile Vandermonde. Args: x (Tensor): The input tensor, it must be 1-D Tensor, and it's data type should be ['complex64', 'complex128', 'float32', 'float64', 'int32', 'int64']. n (int|None): Number of columns in the output. If n is not specified, a square array is returned (n = len(x)). increasing(bool): Order of the powers of the columns. If True, the powers increase from left to right, if False (the default) they are reversed. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, A vandermonde matrix with shape (len(x), N). If increasing is False, the first column is :math:`x^{(N-1)}`, the second :math:`x^{(N-2)}` and so forth. If increasing is True, the columns are :math:`x^0`, :math:`x^1`, ..., :math:`x^{(N-1)}`. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1., 2., 3.], dtype="float32") >>> out = paddle.vander(x) >>> out Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 1., 1.], [4., 2., 1.], [9., 3., 1.]]) >>> out1 = paddle.vander(x,2) >>> out1 Tensor(shape=[3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 1.], [2., 1.], [3., 1.]]) >>> out2 = paddle.vander(x, increasing = True) >>> out2 Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 1., 1.], [1., 2., 4.], [1., 3., 9.]]) >>> real = paddle.to_tensor([2., 4.]) >>> imag = paddle.to_tensor([1., 3.]) >>> complex = paddle.complex(real, imag) >>> out3 = paddle.vander(complex) >>> out3 Tensor(shape=[2, 2], dtype=complex64, place=Place(cpu), stop_gradient=True, [[(2+1j), (1+0j)], [(4+3j), (1+0j)]]) rr)rrrrrrvanderr/zNThe input of x is expected to be a 1-D Tensor.But now the dims of Input(X) is rNrzN must be non-negative.rr)r) r&rrrorxemptyrr,rrrsetitemr)rrr increasingrrs rtrr{sp  K   uuw!| //0uuwiq :   y GGAJ1u233 ,, Aagg 6C  q5((!AGG2AagJC--''teAtn-s1ab5zr2C )#a2g,C J/2C Jrvc&[5(a[R"X5$[USSS/S5 [USSS/S5 Sn[ U40[ 5D6nXS.nUR [RS9nSU0nURX5US 9 U$) a Return the next floating-point value after input towards other, elementwise. The shapes of input and other must be broadcastable. Args: x (Tensor): An N-D Tensor, the data type is float32, float64. y (Tensor): An N-D Tensor, the data type is float32, float64. name(str, optional):Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor): An N-D Tensor, the shape and data type is the same with input. Examples: .. code-block:: python >>> import paddle >>> out = paddle.nextafter(paddle.to_tensor([1.0,2.0]),paddle.to_tensor([2.0,1.0])) >>> out Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [1.00000012, 1.99999988]) rrrr nextafterrrrrr) r-rrr&r)rrrxrr)rrrrrrrrrs rtrrs,%% C)Y)?M C)Y)?MW11!77fnn7M#,ggF Jrvc[5(a[R"U5$[US/SQS5 [ S0[ 5D6nUR URS9nURSSU0SU0S9 U$)ao The function used to calculate modified bessel function of order 0. Equation: .. math:: I_0(x) = \sum^{\infty}_{k=0}\frac{(x^2/4)^k}{(k!)^2} Args: x (Tensor): The input tensor, it's data type should be float32, float64, uint8, int8, int16, int32, int64. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: - out (Tensor), A Tensor. the value of the modified bessel function of order 0 at x (integer types are autocasted into float32). Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([0, 1, 2, 3, 4], dtype="float32") >>> paddle.i0(x) Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [0.99999994 , 1.26606596 , 2.27958512 , 4.88079262 , 11.30192089]) rrrrrrrrri0rrr)r) r-rrr&r)rrrrr&s rtrrsy8yy|  N   .VX.77agg7FdC8eS\J JrvcN[5(a[R"U5$g)z{ Inplace version of ``i0`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_i0`. N)r,ri0_rs rtrr/s zz!}rvc[5(a[R"U5$[US/SQS5 [ S0[ 5D6nUR URS9nURSSU0SU0S9 U$)a The function used to calculate exponentially scaled modified Bessel function of order 0. Equation: .. math:: I_0(x) = \sum^{\infty}_{k=0}\frac{(x^2/4)^k}{(k!)^2} \\ I_{0e}(x) = e^{-|x|}I_0(x) Args: x (Tensor): The input tensor, it's data type should be float32, float64, uint8, int8, int16, int32, int64. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: - out (Tensor), A Tensor. the value of the exponentially scaled modified Bessel function of order 0 at x (integer types are autocasted into float32). Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([0, 1, 2, 3, 4], dtype="float32") >>> print(paddle.i0e(x)) Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [0.99999994, 0.46575963, 0.30850831, 0.24300036, 0.20700191]) rrri0errr)r) r-rrr&r)rrrrr&s rtrr:sy:zz!}  N   /fh/77agg7FeS!HuclK Jrvc[5(a[R"U5$[US/SQS5 [ S0[ 5D6nUR URS9nURSSU0SU00S9 U$)a The function is used to calculate modified bessel function of order 1. Args: x (Tensor): The input tensor, it's data type should be float32, float64, uint8, int8, int16, int32, int64. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: - out (Tensor), A Tensor. the value of the modified bessel function of order 1 at x (integer types are autocasted into float32). Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([0, 1, 2, 3, 4], dtype="float32") >>> print(paddle.i1(x)) Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [0. , 0.56515908, 1.59063685, 3.95337057, 9.75946712]) rrri1rrr)r) r-rrr&r)rrrrr&s rtrrgs.yy|  N   .VX.77agg7FsAh B   Jrvc[5(a[R"U5$[US/SQS5 [ S0[ 5D6nUR URS9nURSSU0SU00S9 U$)aH The function is used to calculate exponentially scaled modified Bessel function of order 1. Args: x (Tensor): The input tensor, it's data type should be float32, float64, uint8, int8, int16, int32, int64. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: - out (Tensor), A Tensor. the value of the exponentially scaled modified Bessel function of order 1 at x (integer types are autocasted into float32). Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([0, 1, 2, 3, 4], dtype="float32") >>> print(paddle.i1e(x)) Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [0. , 0.20791042, 0.21526928, 0.19682673, 0.17875087]) rrri1errr)r) r-rrr&r)rrrrr&s rtrrs0zz!}  N   /fh/77agg7FQx%R   Jrvc[U[5(d[S[U5S35eUS:a[ SU35eUS:Xa [ U5$[ 5(a[R"X5$[US/SQS5 [S 0[5D6nURURS9nURSSU0S U0S U0S 9 U$) a Calculates the polygamma of the given input tensor, element-wise. The equation is: .. math:: \Phi^n(x) = \frac{d^n}{dx^n} [\ln(\Gamma(x))] Args: x (Tensor): Input Tensor. Must be one of the following types: float32, float64, uint8, int8, int16, int32, int64. n (int): Order of the derivative. Must be integral. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: - out (Tensor), A Tensor. the polygamma of the input Tensor, the shape and data type is the same with input (integer types are autocasted into float32). Examples: .. code-block:: python >>> import paddle >>> data = paddle.to_tensor([2, 3, 25.5], dtype='float32') >>> res = paddle.polygamma(data, 1) >>> print(res) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [0.64493412, 0.39493406, 0.03999467]) /The input of n must be int type, but received: rrDThe input of n must be greater than or equal to 0. But received n = rrr polygammarrrr)r)rgrkrlrmrr-r-rrr&r)rrrr)rrrrrrs rtrrs< a  =d1gYa H   1uRSTRU V   Avqz ! # ###A) ) $ !99F;;!'';JC    Qx Ah    rvc[U[5(d[S[U5S35eUS:a[ SU35eUS:Xa [ U5$[ 5(a[R"X5$g) Inplace version of ``polygamma`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_polygamma`. rrrrN) rgrkrlrmrr/r,r polygamma_)rrrrs rtr r s a  =d1gYa H   1uRSTRU V   Av{   $$Q* * rvcp[U[R[[RR 45(d[ S[U535e[U[R[[RR 45(d[ S[U535eUR[R:XdUR[R:Xa[RnObUR[R:XdUR[R:Xa[RnO[R"5nURUS9nURUS9n[R"SUS9n[R"U[R "XA55$)aJ Compute the result of multiplying x by 2 to the power of y. The equation is: .. math:: out = x * 2^{y} Args: x (Tensor): The input Tensor, the data type is float32, float64, int32 or int64. y (Tensor): A Tensor of exponents, typically integers. name (str|None, optional): Name for the operation (optional, default is None).For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor): An N-D Tensor. If x, y have different shapes and are "broadcastable", the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y. And the data type is float32 or float64. Examples: .. code-block:: python >>> import paddle >>> # example1 >>> x = paddle.to_tensor([1, 2, 3], dtype='float32') >>> y = paddle.to_tensor([2, 3, 4], dtype='int32') >>> res = paddle.ldexp(x, y) >>> print(res) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [4. , 16., 48.]) >>> # example2 >>> x = paddle.to_tensor([1, 2, 3], dtype='float32') >>> y = paddle.to_tensor([2], dtype='int32') >>> res = paddle.ldexp(x, y) >>> print(res) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [4. , 8. , 12.]) x must be tensor type, but got y must be tensor type, but got rr#)rgrxrcr(ryrrlrmrrrr=get_default_dtyperrrrrrrrrxtwos rtldexprs'L a&--6::3C3CD E E9$q'CDD a&--6::3C3CD E E9$q'CDDww&.. AGGv~~$=NN H$$ $83C3C(C$$ ,,.  y!A y!A   1I .C ??1fjj0 11rvcj[U[R[45(d[ S[ U535e[U[R[45(d[ S[ U535eUR [R:XdUR [R:XaSnO[R"5n[R"XS9n[R"XS9n[R"SUS9n[R"U[R"XA55$)rr r rrr#)rgrxrcr(rlrmrrr r3r2rrrrs rtldexp_rKs a&--2 3 39$q'CDD a&--2 3 39$q'CDDww&.. AGGv~~$= ,,.  Q(A A'A   1I .C   Avzz#1 22rvc[US/SQU5 Ub[US/SQU5 [U40[5D6nURUR:XdeUR URS9nUR UXS.SU0SU0S9 U$) Nrr)rrrrrrrrr is_arithmeticr)r&r)rrrr)op_namerrrrrrrs rt _bitwise_opr^s  4   }  8    -FH -F 77agg    3 3!'' 3 BC    .  Jrvc p[5(aUc[R"XU5$[SUUUUUS9$)a  Apply ``bitwise_left_shift`` on Tensor ``X`` and ``Y`` . .. math:: Out = X \ll Y .. note:: ``paddle.bitwise_left_shift`` supports broadcasting. If you want know more about broadcasting, please refer to please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): Input Tensor of ``bitwise_left_shift`` . It is a N-D Tensor of uint8, int8, int16, int32, int64. y (Tensor): Input Tensor of ``bitwise_left_shift`` . It is a N-D Tensor of uint8, int8, int16, int32, int64. is_arithmetic (bool, optional): A boolean indicating whether to choose arithmetic shift, if False, means logic shift. Default True. out (Tensor|None, optional): Result of ``bitwise_left_shift`` . It is a N-D Tensor with the same data type of input Tensor. Default: None. name (str|None, 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: Result of ``bitwise_left_shift`` . It is a N-D Tensor with the same data type of input Tensor. Examples: .. code-block:: python :name: bitwise_left_shift_example1 >>> import paddle >>> x = paddle.to_tensor([[1,2,4,8],[16,17,32,65]]) >>> y = paddle.to_tensor([[1,2,3,4,], [2,3,2,1]]) >>> paddle.bitwise_left_shift(x, y, is_arithmetic=True) Tensor(shape=[2, 4], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[2 , 8 , 32 , 128], [64 , 136, 128, 130]]) .. code-block:: python :name: bitwise_left_shift_example2 >>> import paddle >>> x = paddle.to_tensor([[1,2,4,8],[16,17,32,65]]) >>> y = paddle.to_tensor([[1,2,3,4,], [2,3,2,1]]) >>> paddle.bitwise_left_shift(x, y, is_arithmetic=False) Tensor(shape=[2, 4], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[2 , 8 , 32 , 128], [64 , 136, 128, 130]]) bitwise_left_shiftrrrrrrr)r-rrrrrrrrrs rtrr|sDlCK((}== $ #    rvc[URUR5nXPR:wa[SUSURS35e[5(a[R "XU5$g)z Inplace version of ``bitwise_left_shift`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_bitwise_left_shift`. rrrN)rrorr-rbitwise_left_shift_rrrrrrrs rtrrsu 1IGG,YK7abcbibiajkE F  ))! >> rvc p[5(aUc[R"XU5$[SUUUUUS9$)aP Apply ``bitwise_right_shift`` on Tensor ``X`` and ``Y`` . .. math:: Out = X \gg Y .. note:: ``paddle.bitwise_right_shift`` supports broadcasting. If you want know more about broadcasting, please refer to please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): Input Tensor of ``bitwise_right_shift`` . It is a N-D Tensor of uint8, int8, int16, int32, int64. y (Tensor): Input Tensor of ``bitwise_right_shift`` . It is a N-D Tensor of uint8, int8, int16, int32, int64. is_arithmetic (bool, optional): A boolean indicating whether to choose arithmetic shift, if False, means logic shift. Default True. out (Tensor|None, optional): Result of ``bitwise_right_shift`` . It is a N-D Tensor with the same data type of input Tensor. Default: None. name (str|None, 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: Result of ``bitwise_right_shift`` . It is a N-D Tensor with the same data type of input Tensor. Examples: .. code-block:: python :name: bitwise_right_shift_example1 >>> import paddle >>> x = paddle.to_tensor([[10,20,40,80],[16,17,32,65]]) >>> y = paddle.to_tensor([[1,2,3,4,], [2,3,2,1]]) >>> paddle.bitwise_right_shift(x, y, is_arithmetic=True) Tensor(shape=[2, 4], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[5 , 5 , 5 , 5 ], [4 , 2 , 8 , 32]]) .. code-block:: python :name: bitwise_right_shift_example2 >>> import paddle >>> x = paddle.to_tensor([[-10,-20,-40,-80],[-16,-17,-32,-65]], dtype=paddle.int8) >>> y = paddle.to_tensor([[1,2,3,4,], [2,3,2,1]], dtype=paddle.int8) >>> paddle.bitwise_right_shift(x, y, is_arithmetic=False) # logic shift Tensor(shape=[2, 4], dtype=int8, place=Place(gpu:0), stop_gradient=True, [[123, 59 , 27 , 11 ], [60 , 29 , 56 , 95 ]]) bitwise_right_shiftr)r-rrrrs rtrrsDlCK))! >> % #    rvc[URUR5nXPR:wa[SUSURS35e[5(a[R "XU5$g)z Inplace version of ``bitwise_right_shift`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_bitwise_left_shift`. rrrN)rrorr-rbitwise_right_shift_rs rtr!r!su 1IGG,YK7abcbibiajkE F  **1?? rvc[U[5(a[R"XRS9nO [U[ 5(a [ S5e[XUSS5$Nrz8unsupported operand type(s) for <<: 'Tensor' and 'float'rgrkrxrrrrlrrrrrs rt __lshift__r&,U !S   Qgg . Au   F   aM4 >>rvc[U[5(a[R"XRS9nO [U[ 5(a [ S5e[XUSS5$r#rgrkrxrrrrlrr%s rt __rshift__r*:U !S   Qgg . Au   F   q]D$ ??rvc[U[5(a[R"XRS9nO [U[ 5(a [ S5e[XUSS5$Nrz8unsupported operand type(s) for <<: 'float' and 'Tensor'r$r%s rt __rlshift__r.Hr'rvc[U[5(a[R"XRS9nO [U[ 5(a [ S5e[XUSS5$r-r)r%s rt __rrshift__r0Vr+rvc[U[[45(a[R"XR S9n[ URUR5nU[UR5:wa'[R"SUSURS35 [5(a[R"X5$[S 0[5D6nUR!UR S9nUR#SXS.SU0S9 U$) a Create a new floating-point tensor with the magnitude of input ``x`` and the sign of ``y``, elementwise. Equation: .. math:: copysign(x_{i},y_{i})=\left\{\begin{matrix} & -|x_{i}| & if \space y_{i} <= -0.0\\ & |x_{i}| & if \space y_{i} >= 0.0 \end{matrix}\right. Args: x (Tensor): The input Tensor, magnitudes, the data type is bool, uint8, int8, int16, int32, int64, bfloat16, float16, float32, float64. y (Tensor|float): contains value(s) whose signbit(s) are applied to the magnitudes in input. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor), the output tensor. The data type is the same as the input tensor. Examples: .. code-block:: python :name: example1 >>> import paddle >>> x = paddle.to_tensor([1, 2, 3], dtype='float64') >>> y = paddle.to_tensor([-1, 1, -1], dtype='float64') >>> out = paddle.copysign(x, y) >>> print(out) Tensor(shape=[3], dtype=float64, place=Place(gpu:0), stop_gradient=True, [-1., 2., -3.]) .. code-block:: python :name: example2 >>> import paddle >>> x = paddle.to_tensor([1, 2, 3], dtype='float64') >>> y = paddle.to_tensor([-2], dtype='float64') >>> res = paddle.copysign(x, y) >>> print(res) Tensor(shape=[3], dtype=float64, place=Place(gpu:0), stop_gradient=True, [-1., -2., -3.]) .. code-block:: python :name: example_zero1 >>> import paddle >>> x = paddle.to_tensor([1, 2, 3], dtype='float64') >>> y = paddle.to_tensor([0.0], dtype='float64') >>> out = paddle.copysign(x, y) >>> print(out) Tensor(shape=[3], dtype=float64, place=Place(gpu:0), stop_gradient=True, [1., 2., 3.]) .. code-block:: python :name: example_zero2 >>> import paddle >>> x = paddle.to_tensor([1, 2, 3], dtype='float64') >>> y = paddle.to_tensor([-0.0], dtype='float64') >>> out = paddle.copysign(x, y) >>> print(out) Tensor(shape=[3], dtype=float64, place=Place(gpu:0), stop_gradient=True, [-1., -2., -3.]) rrz2 is different from the input tensor x with shape: z8, please make sure you are using copysign api correctly.copysignrrr)r2)rgrrkrxrrrrorhwarningswarnr-rr2r)rrr)rrrrrrrs rtr2r2dsB!eS\""   Qgg .1IDM! ,YK7ijkjqjqirsk l q$$468477agg7F!$4ucl   rvc6[U[[45(a[R"XR S9n[ URUR5nX0R:wa[SUSURS35e[R"X5$)z Inplace version of ``copysign`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_copysign`. rrrr) rgrrkrxrrrrorr copysign_rs rtr6r6s !eS\""   Qgg .1IGG,YK7abcbibiajkE F     A !!rvc[U[R[[RR 45(d[ S[U535e[U[R[[RR 45(d[ S[U535e[R"US5[R"US5-R5nU$)a Calculate the length of the hypotenuse of a right-angle triangle. The equation is: .. math:: out = {\sqrt{x^2 + y^2}} Args: x (Tensor): The input Tensor, the data type is float32, float64, int32 or int64. y (Tensor): The input Tensor, the data type is float32, float64, int32 or int64. name (str|None, optional): Name for the operation (optional, default is None).For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor): An N-D Tensor. If x, y have different shapes and are "broadcastable", the resulting tensor shape is the shape of x and y after broadcasting. If x, y have the same shape, its shape is the same as x and y. And the data type is float32 or float64. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([3], dtype='float32') >>> y = paddle.to_tensor([4], dtype='float32') >>> res = paddle.hypot(x, y) >>> print(res) Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, [5.]) r r r#) rgrxrcr(ryrrlrmrr[rs rthypotr8s: a&--6::3C3CD E E9$q'CDD a&--6::3C3CD E E9$q'CDD ::a fjjA. . 4 4 6C Jrvcp[U[R[45(d[ S[ U535e[U[R[45(d[ S[ U535eUR S5RURS55R5nU$)z Inplace version of ``hypot`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_hypot`. r r r#) rgrxrcr(rlrmrrrr\rs rthypot_r:s a&--2 3 39$q'CDD a&--2 3 39$q'CDD &&)..q " ( ( *C Jrvc[UR5S:wa[SUR35e[U[5(aUS:a[ SU35eUS:Xa [ R"S/URS9$US:a1[U5Vs/sHo@PM nn[ R"U5nOU/nUR5n[ R"USS9nUS:a1[U5Vs/sHoHPM nn[ R"U5n OU/n [ R"URU-SS S9n U(a%[US- 5HnXUXS-:*-n M O$[US- 5HnXUXS-:-n M [U5HnXdRU 5Xd'M [ R"US5$s snfs snf) aD Compute combinations of length r of the given tensor. The behavior is similar to python's itertools.combinations when with_replacement is set to False, and itertools.combinations_with_replacement when with_replacement is set to True. Args: x (Tensor): 1-D input Tensor, the data type is float16, float32, float64, int32 or int64. r (int, optional): number of elements to combine, default value is 2. with_replacement (bool, optional): whether to allow duplication in combination, default value is False. name (str|None, optional): Name for the operation (optional, default is None).For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor). Tensor concatenated by combinations, same dtype with x. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 2, 3], dtype='int32') >>> res = paddle.combinations(x) >>> print(res) Tensor(shape=[3, 2], dtype=int32, place=Place(gpu:0), stop_gradient=True, [[1, 2], [1, 3], [2, 3]]) r/z%Expect a 1-D vector, but got x shape rz%Expect a non-negative int, but got r=)rorrrTr)rnrorlrgrkrrxrrrjmeshgridnumelrHr masked_selectstack) rrrwith_replacementrrrt_lgrids num_elementst_range index_gridsmasks rt combinationsrHsB 177|q?yIJJ a  Q@DEEAv||1#QWW551u(#(Qq(#$779LmmL8G1u %a)1w)ooc* i ;;qww{D 7Dq1uA Nka%&88 8Dq1uA N[Q%77 7D 1X8))$/ <<q !!+$*s  G 3 Gc[U[R[[RR 45(d[ S[U535e[US/SQS5 S/[R"UR5-n[R"X R5RUR5n[R"X 5n[R "U5n[R""US:SS9nU$) a Tests if each element of input has its sign bit set or not. Args: x (Tensor): The input Tensor. Must be one of the following types: float16, float32, float64, bfloat16, uint8, int8, int16, int32, int64. name (str|None, optional): Name for the operation (optional, default is None).For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor): The output Tensor. The sign bit of the corresponding element of the input tensor, True means negative, False means positive. Examples: .. code-block:: python :name: signbit-example-1 >>> import paddle >>> paddle.set_device('cpu') >>> x = paddle.to_tensor([-0., 1.1, -2.1, 0., 2.5], dtype='float32') >>> res = paddle.signbit(x) >>> print(res) Tensor(shape=[5], dtype=bool, place=Place(cpu), stop_gradient=True, [True, False, True, False, False]) .. code-block:: python :name: signbit-example-2 >>> import paddle >>> paddle.set_device('cpu') >>> x = paddle.to_tensor([-5, -2, 3], dtype='int32') >>> res = paddle.signbit(x) >>> print(res) Tensor(shape=[3], dtype=bool, place=Place(cpu), stop_gradient=True, [True , True , False]) r rr) rrrrrrrrrsignbitr9rrr)rgrxrcr(ryrrlrmr&rrrorrrr2rr2)rrrr neg_zero_xrs rtrJrJ?sD a&--6::3C3CD E E9$q'CDD     5499QWW% %D   D'' * 2 2177 ;D)J JA ++a!e6 *C JrvcR[U[R[[RR 45(d[ S[U535e[US/SQS5 [R"U5n[R"U5)n[R"X#5$)ad Tests if each element of input is positive infinity or not. Args: x (Tensor): The input Tensor. Must be one of the following types: bfloat16, float16, float32, float64, int8, int16, int32, int64, uint8. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor), The output Tensor. Each element of output indicates whether the input element is positive infinity or not. Examples: .. code-block:: python >>> import paddle >>> paddle.set_device('cpu') >>> x = paddle.to_tensor([-0., float('inf'), -2.1, -float('inf'), 2.5], dtype='float32') >>> res = paddle.isposinf(x) >>> print(res) Tensor(shape=[5], dtype=bool, place=Place(cpu), stop_gradient=True, [False, True, False, False, False]) r rr rrrrrrrrrisposinf rgrxrcr(ryrrlrmr&r rJ logical_andrrris_infrJs rtrNrN|s. a&--6::3C3CD E E9$q'CDD     \\!_F~~a  G   f ..rvcP[U[R[[RR 45(d[ S[U535e[US/SQS5 [R"U5n[R"U5n[R"X#5$)ad Tests if each element of input is negative infinity or not. Args: x (Tensor): The input Tensor. Must be one of the following types: bfloat16, float16, float32, float64, int8, int16, int32, int64, uint8. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor), The output Tensor. Each element of output indicates whether the input element is negative infinity or not. Examples: .. code-block:: python >>> import paddle >>> paddle.set_device('cpu') >>> x = paddle.to_tensor([-0., float('inf'), -2.1, -float('inf'), 2.5], dtype='float32') >>> res = paddle.isneginf(x) >>> print(res) Tensor(shape=[5], dtype=bool, place=Place(cpu), stop_gradient=True, [False, False, False, True, False]) r rrrMisneginfrOrQs rtrTrTs. a&--6::3C3CD E E9$q'CDD     \\!_FnnQG   f ..rvc[U[R[[RR 45(d[ S[U535eURnU[RRR:H=(do U[RRR:H=(dA U[RR:H=(d U[RR:H(+nU(a[R"USS9$[R "[R""U5S5$)a Tests if each element of input is a real number or not. Args: x (Tensor): The input Tensor. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor), The output Tensor. Each element of output indicates whether the input element is a real number or not. Examples: .. code-block:: python >>> import paddle >>> paddle.set_device('cpu') >>> x = paddle.to_tensor([-0., -2.1, 2.5], dtype='float32') >>> res = paddle.isreal(x) >>> print(res) Tensor(shape=[3], dtype=bool, place=Place(cpu), stop_gradient=True, [True, True, True]) >>> x = paddle.to_tensor([(-0.+1j), (-2.1+0.2j), (2.5-3.1j)]) >>> res = paddle.isreal(x) >>> print(res) Tensor(shape=[3], dtype=bool, place=Place(cpu), stop_gradient=True, [False, False, False]) >>> x = paddle.to_tensor([(-0.+1j), (-2.1+0j), (2.5-0j)]) >>> res = paddle.isreal(x) >>> print(res) Tensor(shape=[3], dtype=bool, place=Place(cpu), stop_gradient=True, [False, True, True]) r rrr)rgrxrcr(ryrrlrmrr+rrrrrrrCimag)rrrr is_real_dtypes rtisrealrXsD a&--6::3C3CD E E9$q'CDD GGE %%/// - DLL((33 3 - DMM++ + - DMM,, , M 00 << A **rvc~[U[R[[RR 45(d[ S[U535e[US/SQS5 [R"US:gU[R"US55n[R"U[R"[RURS95n[R "UR#5U5n[R"[R$"U5)U[R"US55$) a Calculate the normalized sinc of ``x`` elementwise. .. math:: out_i = \left\{ \begin{aligned} &1 & \text{ if $x_i = 0$} \\ &\frac{\sin(\pi x_i)}{\pi x_i} & \text{ otherwise} \end{aligned} \right. Args: x (Tensor): The input Tensor. Must be one of the following types: bfloat16, float16, float32, float64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor), The Tensor of elementwise-computed normalized sinc result. Examples: .. code-block:: python >>> import paddle >>> paddle.set_device('cpu') >>> paddle.seed(100) >>> x = paddle.rand([2,3], dtype='float32') >>> res = paddle.sinc(x) >>> print(res) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.56691176, 0.93089867, 0.99977750], [0.61639023, 0.79618412, 0.89171958]]) r rrrYsincr#B ;rr9)rgrxrcr(ryrrlrmr&rBr:rrrrGrrrr rrrrs rtrZrZ sD a&--6::3C3CD E E9$q'CDD     ,,qAvq&"2"21g"> ?C //#v//qwwG HC -- 3 'C <<c**C1A1A!S1I JJrvc[U[R[45(d[ S[ U535e[ US/SQS5 [R"US:gU[R"US55 [R"U[R"[RURS95 [R"U5n[R"U5 [R "X5 [R""[R$"U5)U[R"US55$) z Inplace version of ``sinc`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_sinc`. r rrrYsinc_rr[rr9)rgrxrcr(rlrmr&rMr:rrrrGrclonerXrrBr r\s rtr^r^Bs a&--2 3 39$q'CDD     MM!q&!V--a9: Q((@A ,,q/C KKN NN1 <<a(!V-=-=a-E FFrvelementstest_x test_elementscR[U[R[[RR 45(d[ S[U535e[U[R[[RR 45(d[ S[U535e[US/SQS5 [US/SQS5 Sn[UR5S:XaURS/5nS n[R"UR5n[R"UR5nU[R"US 5S -:a[UR5S:Xa[R"/S S 9$UR[!UR5SUR"--5nX:Hn [![%SUR"*S- S55n U R'U S9n U(aU )n GOUR)5n UR)5n U(GaC[R*"X/5n [R,"U S S9nXn[R."USS S 9n[15(dP[R2R5U[R6"UR95S- 5USSUSS:H5nOUSSUSS:HUSS&U(aUR;5n[R<"U5n[?5(d"[R2R5UUU5nOUUU'USUR95RUR5n O[R@"U 5n[RB"UU 5n[RD"UUR95:U[RF"US55nUUU :Hn U(aU R;5OU n U RUR5n U(aU R/5$U $)a" Tests if each element of `x` is in `test_x`. .. note:: Alias Support: The parameter name ``elements`` can be used as an alias for ``x``, and the parameter name ``test_elements`` can be used as an alias for ``test_x``. For example, ``isin(elements=tensor1, test_elements=tensor2)`` is equivalent to ``isin(x=tensor1, test_x=tensor2)``. Args: x (Tensor): The input Tensor. Supported data type: 'bfloat16', 'float16', 'float32', 'float64', 'int32', 'int64'. alias: ``elements``. test_x (Tensor): Tensor values against which to test for each input element. Supported data type: 'bfloat16', 'float16', 'float32', 'float64', 'int32', 'int64'. alias: ``test_elements``. assume_unique (bool, optional): If True, indicates both `x` and `test_x` contain unique elements, which could make the calculation faster. Default: False. invert (bool, optional): Indicate whether to invert the boolean return tensor. If True, invert the results. Default: False. name (str|None, optional): Name for the operation (optional, default is None).For more information, please refer to :ref:`api_guide_Name`. Returns: out (Tensor), The output Tensor with the same shape as `x`. Examples: .. code-block:: python >>> import paddle >>> paddle.set_device('cpu') >>> x = paddle.to_tensor([-0., -2.1, 2.5, 1.0, -2.1], dtype='float32') >>> test_x = paddle.to_tensor([-2.1, 2.5], dtype='float32') >>> res = paddle.isin(x, test_x) >>> print(res) Tensor(shape=[5], dtype=bool, place=Place(cpu), stop_gradient=True, [False, True, True, False, True]) >>> x = paddle.to_tensor([-0., -2.1, 2.5, 1.0, -2.1], dtype='float32') >>> test_x = paddle.to_tensor([-2.1, 2.5], dtype='float32') >>> res = paddle.isin(x, test_x, invert=True) >>> print(res) Tensor(shape=[5], dtype=bool, place=Place(cpu), stop_gradient=True, [True, False, False, True, False]) >>> # Set `assume_unique` to True only when `x` and `test_x` contain unique values, otherwise the result may be incorrect. >>> x = paddle.to_tensor([0., 1., 2.]*20).reshape([20, 3]) >>> test_x = paddle.to_tensor([0., 1.]*20) >>> correct_result = paddle.isin(x, test_x, assume_unique=False) >>> print(correct_result) Tensor(shape=[20, 3], dtype=bool, place=Place(cpu), stop_gradient=True, [[True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False], [True , True , False]]) >>> incorrect_result = paddle.isin(x, test_x, assume_unique=True) >>> print(incorrect_result) Tensor(shape=[20, 3], dtype=bool, place=Place(gpu:0), stop_gradient=True, [[True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , True ], [True , True , False]]) r rr)rrrrrrisinraFrr/Tg(\?g$@rr)r/rrF)stableNr)$rgrxrcr(ryrrlrmr&rnrorrrrrrindimrjr rrargsortr:r,rrrHr=rL empty_liker-sort searchsortedrBrS)rrra assume_uniqueinvertr x_zero_dimsize_xsize_trcmprx_flat test_x_flat all_elements sorted_indexsorted_xduplicate_maskrG sorted_test_xidxtest_idxs rtrdrd_sc@ a&--6::3C3CD E E9$q'CDD fv}}h 8H8HI J J9$v,HII        J 177|q IIqcN YYqww F YYv|| $F '$.. qww<1 <<&1 1iiagg$*<=>mE"v{{lQ.34gg3g $Cnn& !==&)>?L!>>,tDL#1H#--lEPN"$$!'!6!6"MM."6"6"81"<=QRLHSbM1" '/qrlhsm&Cs#!/!;!;!=$$^4D)++}},,T<P%3\"q1779%--agg6C#KK 4M%%mV>> import paddle >>> a = paddle.to_tensor([1, 2, 3], dtype='int32') >>> b = paddle.to_tensor([5, 6], dtype='int32') >>> res = paddle.cartesian_prod([a, b]) >>> print(res) Tensor(shape=[6, 2], dtype=int32, place=Place(cpu), stop_gradient=True, [[1, 5], [1, 6], [2, 5], [2, 6], [3, 5], [3, 6]]) >>> c = paddle.to_tensor([7, 8, 9], dtype='float32') >>> res = paddle.cartesian_prod([c]) >>> print(res) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [7., 8., 9.]) >>> d = paddle.empty([0], dtype='float64') >>> e = paddle.to_tensor([1, 2], dtype='float64') >>> f = paddle.to_tensor([3, 4, 5, 6, 7], dtype='float64') >>> res = paddle.cartesian_prod([d, e, f]) >>> print(res) Tensor(shape=[0, 3], dtype=float64, place=Place(cpu), stop_gradient=True, []) r/z"Expect a 1D vector, but got shape rrrF)rnrorrxr?r<r)rrrr coordinatess rtcartesian_prodr|"sV v||  !4V\\NC   1v{t ,,vq1;K >>+CF| 44rv)N)rrrcr str | Nonereturnrc)r9rTNN)rrrcrfloat | Tensorrrrrrr}rr}r~rc)gq= ףp?gjMSt?N) rrrcrrrrrr}r~rc)rSequence[Tensor]rrcrr}r~rc)rrrcrrrrrrrr}rr}r~rc) rrrcrrrr}r Tensor | Noner~rc)rrrcrrrr}r~rc) rrrcrrcrr}rrbrrr~rc) rrrcrrcrr}rrbr~rc)rrrcrrcrr}r~rc) rrrcrrcrr}rr}rrr~rc) rrrcrrcrr}rr}r~rc)rrcrrcrrr~rc) rrrcrzNumber | Tensorrr}rrr~rc) rrrcrrcrr}rrr~rc)rN Undefined)rN)rrrcr6rcrr}r~rc)rNNN) rrrcrDrrE float | NonerFrrr}r~rc)NNFN) rrrcrqint | Sequence[int] | NonerDTypeLike | NonerTrrr}r~rc)NFN) rrrcrqrrTrrr}r~rc)rzTensor | Sequence[Tensor]rr}r~rc)rrcrr}r~rc)rrcrxrcrr}r~rc)r9r9N)rrcrrrcrrcrrrrrr}r~rc) rrrcrrrqrkrrr~rc)rrrcrr}r~None)NNN) rrrcrArr@rrr}rrr~rc) rrrcrArr@rrr}r~rc)rrr/N) rrrcrrkrrkrrkrr}r~rc) rrrcrq int | Nonerrrr}rrr~rc) rrrcrqrrrrr}r~rc)NrN) rrrcrqrrrdrr}r~tuple[Tensor, Tensor]) rrrcrrrrrrrr}r~rc) rrrcrrrrrr}r~rc)NFNNN)rrrcrqrrTrrrrrrr}r~rc)r9N)rrrcrrrr}r~rc)r Sequence[int]r~ list[int])rrrrr~r)rrrcrrkrr}r~rc)NN)rrrcrdrrr}r~rc) rrrcrrcrjrrr}r~rc)r/rNNN)rrrcrrkrqrkrrrrrr}rrr~rc)rrrcrr}rrr~rc)rN) rrrcrrcrz Literal['raise', 'wrap', 'clip']rr}r~rc)rrrcrr}r~r)NNrr) rrcrrrrrrqrkrzLiteral['sum', 'cumsum']r~rc)NNrN) rrcrrrrrrqrkrr}r~rc) rrrcrrrrrr}r~rc)rrrcrrkrr}r~rc)TNN) rrrcrrcrrrrrr}r~rc)T)rrrcr Tensor | intrrr~rc)rrrcrrrr)rrrcrzTensor | floatrr}r~rc)r#FN) rrrcr@rkrArrr}r~rc)FFN) rrrcrarcrkrrlrrr}r~rc)rrrrr}r~rc( __future__rrr r3typingrrnumpyr>rxr paddle._C_opsrrr r r r r rrrrrrrrrrrrpaddle.base.libpaddlerpaddle.common_ops_importrr paddle.pirrpaddle.utils.decorator_utilsrrr r!paddle.utils.inplace_utilsr"base.data_feederr$r%r&r'common_ops_importr( frameworkr)r*r+r,r-r.creationr0layer_function_generatorr1 manipulationr2r3opsr4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`collections.abcrarbrcpaddle._typingrdre__all__rUINT8INT8INT16rr_supported_int_dtype_FP32FP64_supported_float_dtype_rur}rrrrrrrOP_NAMEMAPPINGrrrrrrrrr rr rrr floor_modmod___doc__ floor_mod_rrr!r%r'r*r,r/r3r5rJrOrRrZr`rbrrfrjrrrrrrrrrr@rArrrrrrrrrrr r rrrrrr"rr%r(r*r-r/r1r4r6r:r<r>rMrPrSrUrXrZr\rcrfrirmrorqrur}rrrrrrrrrrrrrrrrrrrrrrrr rrrrrrr!r&r*r.r0r2r6r8r:rHrJrNrTrXrZr^rdr|rrvrtrsx# ) *+; D )-7%............`((@  OO OO OO OO OO  OO OO .  ! r- r- r- r- r-  r-  r- r-n A A AA  A  AJAE^ ^%+^3=^ ^B! F  F  F  F F  F  F  F F G9J<89Y  Y YY Y  Y  Y:YxLL! (*!!" F)R#w#w0^  ^ ^ ^ ^  ^  ^ ^1^B#w#w0$  $ $ $ $  $  $1$,<~#w#w0[  [ [ [ [  [  [ [1[|#w#w0)  ) ) ) )  )  )1),#w#w0W !% W W W W  W  W W1Wt#w#w0 !%        1D )  )  )  )  ):P  :P :P:P :P  :P  :P:Pz & &#w#w0-1:KKO:K :K:K *:K;H:K :K1:Kz # #      #w#w0-13KKO3K 3K3K *3K;H3K 3K13Kl#w#w0 "1 "4AAAA=L@=L@Ql S  S S  S   S  S  S l                   J(," R7 R7 $R7 R7 R7  R7  R7n(, U U $UU  U  Ut(, II II $IIII  II  IIXod&R$$w| h h hh  h  h  h hV  17 17 1717  17  17  17 1717p C C CC  C  C  C CL  G9 G9 G9G9  G9  G9  G9 G9G9T=@*P)fG9F845>  > > > >  >  >6>B6r*$ (, \ \ $\\  \  \  \~*$ (, N N $NN  N  N  Nb    #w  T  T T T T  T  T T!Tn ) ) ) )  )  )).#w  d d d d  d  d  d!dNBJ#w&%1" i#  i# i# i# i#  i#  i# i#2i#X" > > > >  >  >>8 Y Y Y Y  Y  Y| X X X X  X  Xz" a a a a  a  aH#w h# h h h  h  h  h h!hV" 5 5 5 5  5  55.#w&%1(," F F $FF  F  F  F F2FR**Z,^!2 !2%2!2!2H7t F""2j""0f''&:  2j!!GB    : BBK^=AJ J J/9J JZ<@ %  %  %/9 %  % %FJ9 99"098B9 9xEI& &&"0&8B& &&(3lEP=@#w#w0R1Rj#w#w0(1(V#w#w0919x#w#w01&G9ug67!  pp p p p p  p  p p p8pfEP/Ad#w "&9K@D9K 9K9K0=9K 9K!9Kx&&*5v.5 q q q +q  q  qh<B%* O OO O  O # O  Oh <2 <2<2 <2  <2  <2  <2B >5 >5>5 >5  >5  >5  >5F a aaa  a  aH!H)X*Z&R'TCCL++(32l3&B ? ? ??  ?  ?  ?D ? ? ??  ?  ?  ??. @ @ @@  @  @  @F @ @ @@  @  @  @@0 ?  ? ? ? ?" @  @ @ @ @" ?  ? ? ?" @  @ @ @QQh " "#L   " ?" ?" ?"?"  ?"  ?"D:z,/^,/^.+b4KnGG8#z"X$?@          AD5555rv