ёiNN %SSKJr SSKrSSKJrJr SSKrSSKJ r J r SSK r SSK J r SSK JrJrJrJr SSKJr SSKJr SS KJr SS KJrJrJrJr SS KJr S S KJ r J!r!J"r"J#r# S SK$J%r% S SK&J'r'J(r(J)r)J*r* SSK+J,r, SSK-J.r. SSKJ/r/ \(aSSK0J1r1 SSK J2r2 \Sr3S\4S'/r5Sr6\"5SqSrSjj5r7\SqSj5r8\"S5SsSj5r9SqStS jjr:SuS"jr;\"S#/S$/S%.5SvSSS&.SwS(jjj5rS{S|S1jjr?S}S~S2jjr@SSS3jjrASSS4jjrBSqSS5jjrC\SqS6j5rD\"S'S$/05SSS7jj5rESSS8jjrFSSS9jjrGSSS:jjrHSSS;jjrISSS<jjrJSqSS=jjrKSqSS>jjrLSqSS?jjrMSSS@.SSAjjjrNSqSSBjjrOSCrPSDrQSErRS{SFjrSSSSGjjrTSSSHjjrUSqSSIjjrV\ SSSJjj5rW\ SSSKjj5rWSSSLjjrW\ SSSMjj5rX\ SSSNjj5rX\ SSSOjj5rXSSSPjjrXSSSQjjrYSSSRjjrZSqSSSjjr[SqSSTjjr\SqSSUjjr]SSSVjjr^SSSWjjr_SXr`SYra\"SS-/S0SZ/5SSS@.SS[jjj5rbSSS\jjrcSSS]jjrdSSS^jjreSSS_jjrfSSS`jjrgSSSajjrhSqSSbjjriS}SSc.SdjjrjSSSc.SejjrkSSSc.SfjjrlSSSc.SgjjrmSSSc.ShjjrnSiroSjrpSkrqSlrrSqSSmjjrsSSSnjjrtSSSojjruSSSpjjrvg)) annotationsN) TYPE_CHECKINGLiteral) TypeAliasoverload)_C_ops)bmmdiagonaldotmatmul)DataType)VarDesc)broadcast_shape)ParamAliasDecoratorVariableArgsDecoratorparam_two_aliastranspose_decorator)inplace_apis_in_dygraph_only) check_dtype check_typecheck_variable_and_dtype convert_dtype)Variable) LayerHelperin_dynamic_modein_dynamic_or_pir_mode in_pir_mode)full)cast)_get_reduce_axis)Sequence)Tensor)fronucr_POrder xc [5(a[R"X5$[US/SQS5 [ US[ [ 4S5 [U[ 5(a [ U5n[U5[UR5:wa.[S[UR5S[U5S35e[U5HHup4U[UR5:dM [SUS XS [UR5S35e [S0[5D6nURUR5nURUR5nUR!S S U/0U/U/S .SU0S9 U$)aE Permute the data dimensions of `input` according to `perm`. The `i`-th dimension of the returned tensor will correspond to the perm[i]-th dimension of `input`. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``dim0`` & ``dim1`` can replace ``perm``. For example, ``transpose(input=x, dim0=0, dim1=1)`` is equivalent to ``transpose(x=x, perm=[1, 0, 2])``. Args: x (Tensor): The input Tensor. It is a N-D Tensor of data types bool, float16, bfloat16, float32, float64, int8, int16, int32, int64, uint8, uint16, complex64, complex128. alias: ``input``. perm (list|tuple): Permute the input according to the data of perm. name (str|None, optional): The name of this layer. For more information, please refer to :ref:`api_guide_Name`. Default is None. Returns: Tensor: A transposed n-D Tensor, with data type being bool, float32, float64, int32, int64. Examples: .. code-block:: text # The following codes in this code block are pseudocode, designed to show the execution logic and results of the function. x = to_tensor([[[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]] [[13 14 15 16] [17 18 19 20] [21 22 23 24]]]) shape(x): return [2,3,4] # Example 1 perm0 = [1,0,2] y_perm0 = transpose(x, perm0) # Permute x by perm0 # dim:0 of y_perm0 is dim:1 of x # dim:1 of y_perm0 is dim:0 of x # dim:2 of y_perm0 is dim:2 of x # The above two lines can also be understood as exchanging the zeroth and first dimensions of x y_perm0.data = [[[ 1 2 3 4] [13 14 15 16]] [[ 5 6 7 8] [17 18 19 20]] [[ 9 10 11 12] [21 22 23 24]]] shape(y_perm0): return [3,2,4] # Example 2 perm1 = [2,1,0] y_perm1 = transpose(x, perm1) # Permute x by perm1 # dim:0 of y_perm1 is dim:2 of x # dim:1 of y_perm1 is dim:1 of x # dim:2 of y_perm1 is dim:0 of x # The above two lines can also be understood as exchanging the zeroth and second dimensions of x y_perm1.data = [[[ 1 13] [ 5 17] [ 9 21]] [[ 2 14] [ 6 18] [10 22]] [[ 3 15] [ 7 19] [11 23]] [[ 4 16] [ 8 20] [12 24]]] shape(y_perm1): return [4,3,2] Examples: .. code-block:: pycon >>> import paddle >>> x = paddle.randn([2, 3, 4]) >>> x_transposed = paddle.transpose(x, perm=[1, 0, 2]) >>> print(x_transposed.shape) paddle.Size([3, 2, 4]) r))boolfloat16bfloat16float32float64int8uint8int16int32int64uint16 complex64 complex128 float8_e5m2 float8_e4m3fn transposepermzInput(perm) is the permutation of dimensions of Input(x), its length should be equal to dimensions of Input(x), but received dimension of Input(x) is z, the length of Input(perm) is .zJEach element in Input(perm) should be less than Input(x)'s dimension, but z-th element in Input(perm) is z$ which exceeds Input(x)'s dimension transpose2XOutXShapeaxistypeinputsoutputsattrsr:)rrr:rrlisttuple isinstancelenshape ValueError enumeraterlocals"create_variable_for_type_inferencedtype append_op)r)r;nameidxdimhelperoutx_shapes T/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/tensor/linalg.pyr:r:CsxT((  " ) , 4$ < dE " ":D t9AGG $99>> import paddle >>> x = paddle.randn([2, 3, 4]) >>> y = paddle.permute(x, (1, 0, 2)) >>> print(y.shape) paddle.Size([3, 2, 4]) >>> y = x.permute([1, 0, 2]) >>> print(y.shape) paddle.Size([3, 2, 4]) )r)r;rH)r_r^s rZpermuteras6 u ((r[cUR$)a3 Transpose the last two dimensions of the input tensor `x`. Note: If `n` is the number of dimensions of `x`, `paddle.matrix_transpose(x)` is equivalent to `x.transpose([0, 1, ..., n-2, n-1])`. Args: x (Tensor): The input tensor to be transposed. `x` must be an N-dimensional tensor (N >= 2) of any data type supported by Paddle. name (str|None, optional): The name of this layer. For more information, please refer to :ref:`api_guide_Name`. Default is None. Returns: Tensor: A new tensor with the same shape as `x`, except that the last two dimensions are transposed. Examples: .. code-block:: pycon >>> import paddle >>> x = paddle.ones(shape=[2, 3, 5]) >>> x_transposed = paddle.matrix_transpose(x) >>> print(x_transposed.shape) paddle.Size([2, 5, 3]) )mTr)rTs rZmatrix_transposeres 4 44Kr[Fc [5(a[R"XXBX5Xg5$UUUUUS.n UcmSn U "X5 [S0[ 5D6n US:XaU R SS9n O!US:XaU R SS9n O [ S5eU RSXS.S U 0U S 9 U $S n U "X5 US:Xa[US S/S5 O!US:Xa[US S/S5 O [ S5e[S0[ 5D6n US:XaU R SS9n O!US:XaU R SS9n O [ S5eU RSXUS .S U 0U S 9 U $)N) transpose_x transpose_yscale output_dtypeactc^XS.nUR5Hup4[UUSS/S5 M gNr)yr8r9fp8_fp8_half_gemm_fuseditemsrr)ro var_namesrTvals rZ __check_input.fp8_fp8_half_gemm_fused..__check_input";"#, !*!2ID,)+2"3r[rpr,rRr-z,The output_dtype must be float16 or bfloat16rnrXrCc^XS.nUR5Hup4[UUSS/S5 M grmrqrss rZrvrwDrxr[bias)r)ror{)rp) rrrprrPrQrNrSr) r)rorgrhr{rirjrkrTrGrvrWrXs rZrprp s-- $[  '&(   <  !  GfhGFy(??i?P+??$@!!OPP   .'    J  ! y((&9+/H+(&:,0I!!OPP GfhGFy(??i?P+??$@!!OPP   .5    Jr[ordrVprB)rRrXrBc ^SUSSS4SjnSUSSS4U4SjjnSU4Sjjn SSjn [U[[45(d[S[ U535eUbTR U5mSn UcSnS n [U[ 5(a [U5n[U[5(a[U5S :XaUS n[R"T5(a[R"T5n OTn [U[5(a U "U UUUU US 9n O^[U[5(aIU[R:XdU[R*:Xa U"XX#US 9n OUS :Xa U"XX#US 9n OU "XX#US 9n Ub[R"W US9 W $)a Calculate the p-order vector norm for certain dimension of Tensor `input`. Returns the vector norm (the 1-norm, the Euclidean or 2-norm, and in general the p-norm) of a given tensor. Args: x (Tensor): Tensor, data type float32, float64. p (int|float, optional): None for porder=2.0. Default None. axis (int|list|tuple, optional): None for last dimension. Default None. keepdim (bool, optional): Whether keep the dimensions as the `input`, Default False. 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`. dtype (paddle._typing.DTypeLike, optional): It may be used to perform the computation in a more precise dtype. It is semantically equivalent to calling linalg.vector_norm(x.to(dtype)) but it is faster in some cases. Default None. out (Tensor| None, optional): output tensor. Ignored if None. Default: None. Returns: Tensor: results of vector_norm operation on the specified axis of input tensor, it's data type is the same as input's Tensor. Examples: .. code-block:: python >>> import paddle >>> import numpy as np >>> x = paddle.arange(24, dtype="float32").reshape([2, 3, 4]) - 12 >>> print(x) Tensor(shape=[2, 3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[[-12., -11., -10., -9. ], [-8. , -7. , -6. , -5. ], [-4. , -3. , -2. , -1. ]], [[ 0. , 1. , 2. , 3. ], [ 4. , 5. , 6. , 7. ], [ 8. , 9. , 10., 11.]]]) >>> out_vector_norm = paddle.linalg.vector_norm(x=x,p=2,axis=None,keepdim=False) >>> print(out_vector_norm) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 34.) >>> out_vector_norm = paddle.linalg.vector_norm(x=x,p=0,axis=[0,1],keepdim=False) >>> print(out_vector_norm) Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [5., 6., 6., 6.]) >>> out_vector_norm = paddle.linalg.vector_norm(x=x,p=float("inf"),axis=[1,2],keepdim=False) >>> print(out_vector_norm) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [12., 11.]) >>> out_vector_norm = paddle.linalg.vector_norm(x=x,p=1,axis=1,keepdim=False) >>> print(out_vector_norm) Tensor(shape=[2, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[24., 21., 18., 15.], [12., 15., 18., 21.]]) NFc^[R"XX5S9RUR5$)NrBkeepdimrT)paddle count_nonzeroastyperR)r_porderrBrasvectorrTs rZ zero_normvector_norm..zero_norms*## g &  r[c 2>[5(a^[R"U5nU[R"S5:Xa[R "XbU5$[R "XbU5$[S 0[5D6nURUR5S9nURSSU0SU0S9 URUR5S9n[UT 5upU[R"S5:XaSOSn URU SU0SU0UUU S .S 9 U$) Ninfryabsr>r@rDrErF reduce_max reduce_minrVkeep_dim reduce_allrC)inf_norm) rrrnpr/maxminrrPrQ input_dtyperSr") r_rrBrrrTrXrW reduce_outr reduce_typer)s rZrvector_norm..inf_norms/ " # #**U#CE**zz#W55zz#W55 8vx8F;;((*<C   C<%   BB((*CJ 0a8 J &"**U*; ;      Sz + '",   r[c >[5(ai[R"U5n[R"Xa5n[R"XrSU5n[R"U[ SU- 55n U $[ S 0[5D6n U RU R5S9n U RU R5S9nU RSSU0SU0S9 U RU R5S9nU RSSU0SU0S U0S 9 U RU R5S9n[UT 5upU RS SU0SU0UUU S .S 9 U RSSU0SU 0S [ SU- 50S 9 U $)zB NOTE: This function calculates the vector norm for dim >= 2. N?ryrr>r@rpowfactorrC reduce_sumrnorm) rrrrsumfloatrrPrQrrSr") r_rrBrrrTabs_outpow_outsum_outrXblockrr)s rZvector_norm_axis_tuple+vector_norm..vector_norm_axis_tuples " # #jj'Gjj1Gjjg>G**WeC&L&9:CJ/fh/66##%7 ::##%;  U|eW5E  ::##%;  >G$V$  ::##%; ,D!4  >G$#(   >CLU3<01   r[c[5(aUcSn[R"XUSX45$Ub[US[[ 4S5 Ub[US[ S5 [ US/SQS5 UbUOSUb [ U5OSUUSS .n[S0[5D6nURUR5S 9nURSS U0S U0US 9 U$)zH NOTE: This function calculates the vector norm for len(axis) == 1. -q=rp_normrBr_r,r5r.r/@rBrrrepsilonryr>r@rC)r) rrrrrintrrrPrQrrS) r_rrBrrrTrGrWrXs rZvector_norm_axis_int)vector_norm..vector_norm_axis_ints " # #|==eWO O!68eS\8D4#9 $;  !% 0b+1+=%-3"$ E!6VX6F;;((*<C   U|    Jr[z*only valid p type is int and float, found rTrr)rBrrrrTrrBrrToutput)rNFFN)rKrrrNrDrrJrIrLr is_complexrrrassign)r)r~rBrrTrRrXrrrrrabs_xtensors` rZ vector_normrqs@uu4uu4#LIM6rIM)V a#u & &Ed1gYOPP  HHUOH |$Dz$#d)q.Aw  1 $%    D$   ;!w,d$F!Vd$F,d$F  fS) Mr[r%rc:^^^ SmSm SSSjjnUSS4SUU 4SjjjnSUSS4SUU U4Sjjjn[U[5(a [U5n[U[5(a[U5S :XasUS :XaU"TX#US 9$US :XaU"TX#US 9$U[R :Xd-U[R *:XdUS:XdUS:Xd US :XdUS:XaU"TXX4S9$[ SU35e[ S[U535e)a Calculate the p-order matrix norm for certain dimension of Tensor `input`. Args: x (Tensor): Tensor, data type float32, float64. p (int|float|string, optional): Default 'fro'. axis (int|list|tuple, optional): The axis is a list(int)/tuple(int) with two elements. Default last two dimensions. keepdim (bool, optional): Whether keep the dimensions as the `input`, Default False. 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: results of matrix_norm operation on the specified axis of input tensor, it's data type is the same as input's Tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(24, dtype="float32").reshape([2, 3, 4]) - 12 >>> print(x) Tensor(shape=[2, 3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[[-12., -11., -10., -9. ], [-8. , -7. , -6. , -5. ], [-4. , -3. , -2. , -1. ]], [[ 0. , 1. , 2. , 3. ], [ 4. , 5. , 6. , 7. ], [ 8. , 9. , 10., 11.]]]) >>> out_matrix_norm = paddle.linalg.matrix_norm(x=x,p=2,axis=[0,1],keepdim=False) >>> print(out_matrix_norm) Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [15.75857544, 14.97978878, 14.69693947, 14.97978973]) >>> out_matrix_norm = paddle.linalg.matrix_norm(x=x,p='fro',axis=[0,1],keepdim=False) >>> print(out_matrix_norm) Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [17.43559647, 16.91153526, 16.73320007, 16.91153526]) >>> out_matrix_norm = paddle.linalg.matrix_norm(x=x,p=float('inf'),axis=[1,2],keepdim=False) >>> print(out_matrix_norm) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [42., 38.]) >>> out_matrix_norm = paddle.linalg.matrix_norm(x=x,p=-1,axis=[0,1],keepdim=False) >>> print(out_matrix_norm) Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [12., 12., 12., 12.]) >>> out_matrix_norm = paddle.linalg.matrix_norm(x=x,p='nuc',axis=[0,1],keepdim=False) >>> print(out_matrix_norm) Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [23.21962357, 22.82873154, 22.69693947, 22.82873154]) cX-nX-n[U5Vs/sHoUU:wdM XT:wdMUPM nnURX445 U$s snf)zm Auxiliary function for matrix_norm Computes the permutation that moves the two given dimensions to the back )rangeextend)dim0dim1dimnpos_dim0pos_dim1irets rZ_backshift_permutation+matrix_norm.._backshift_permutationsN ;;+I+Qhq1=q+I H'( Js AAAc`[[U5SS9VVs/sHupUPM snn$s snnf)zR Given a permutation, returns its inverse. It's equivalent to argsort on an array c US$Nr)ijs rZ;matrix_norm.._inverse_permutation..sRUr[)key)sortedrO)r;rjs rZ_inverse_permutation)matrix_norm.._inverse_permutations,%Yt_:JKLKdaKLLLs*NFcUb/[U[5(a[U5S:Xd [S5e[ 5(a4Uc[ R "U/US5$[ R "XUS5$XSS.nUcSUS'[USSS /S 5 [S0[5D6nURUR5S 9nURS S U0S U0US9 U$)a The frobenius norm OP is to calculate the frobenius norm of certain two dimensions of Tensor `input`. Args: input (Variable): Tensor, data type float32, float64, complex64, complex128. dim (list, optional): None for last two dimensions. Default None. keepdim (bool, optional): Whether keep the dimensions as the `input`, Default False. name (str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. rzAThe dim of frobenius norm op should be None or two elements list!TFrrr_r.r/frobenius_normryr>r@rC)r) rKrIrLrNrrrrrrPrQrrS)r_rVrrTrGrWrXs rZr#matrix_norm..frobenius_norms ?JsD$9$9c#h!mS  " # #{,,UBFF((WeD DEJE{&*l# $wI 68H !>VX>F;;((*<C   %U|    Jr[c >T"USUS[UR55nT"U5n[5(a~[R"X5n[R "US5upxn [R "USSU5n U(a,[R"[R"U S5U5n U $XS.n [USSS /S 5 [S0[5D6n U RU R5S 9n U RU R5S 9nU RU R5S 9nU RS S U/0U/U/S.SU0S9 U RU R5S 9nU RU R5S 9nU RU R5S 9nU RSS U/0UUUS.SS0S9 [SU5unnU RSS U0SU 0UUUS.S9 U(aVU RU R5S 9nU RSS U /0U/U/S.SS/0S9 U RS S U/0U /U/S.SU0S9 U $)a The nuclear norm OP is to calculate the nuclear norm of certain two dimensions of Tensor `input`. Args: input (Variable): Tensor, data type float32, float64. axis (list): Two dimensions. keepdim (bool, optional): Whether keep the dimensions as the `input`, Default False. 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`. rrFrNrBrr_r.r/ nuclear_normryr=r>r?rBrCsvdUVHS full_matricesrr@r unsqueeze2axes)r)rLrMrrr:rr unsqueezerrrPrQrrSr")r_rBrrTr;inv_perm transposedusvhresultrGrrX transpose_out input_shapevtrsum_axis unsqueeze_outrrs rZr!matrix_norm..nuclear_norms &d1gtAwEKK8HI'- ! # #))%6Jzz*e4HA"ZZ2tW5F))$$VR0(M2 7Y 2N 7fh766##%7 @@##%A >>##%?  %>*O }E4.    4 45;L;L;N 4 O  4 45;L;L;N 4 O  5 5E^T"USUS[UR55nT"U5n[5(Ga [U5nUS:a[R O[R nUS:Xao[R"X5n [R"U S5upn U"U SU5n U(a,[R"[R"U S5U5n U $[TR5mU4SjU5upU[R"S5:XaXpU(d X:aUS-nU"[US XS 9UU5$[US /S QS 5 [S!0[5D6nUR!UR#5S9n[U5nUS:XGayUR!UR#5S9n UR!UR#5S9nUR%SSU/0U /U/S.SU0S9 UR!UR#5S9n UR!UR#5S9n UR!UR#5S9nUR%SSU /0U UU S.SS0S9 US:aSOSnUR!UR#5S9n['SU 5unnUR%USU 0SU0UUUS.S9 U(aXUR!UR#5S9nUR%SSU/0U/U/S.SS/0S9 UR%SSU/0U/U/S.SU0S9 U$U$[TR5mU4SjU5upU[R"S5:XaXpU(d X:aUS-nUR!UR#5S9nUSUSSS.nUR%S SU0SU0US9 US:aSOSnUR!UR#5S9n['UU5unnUR%USU0SU0UUUS.S9 U$)"u Calculate the p-order matrix norm for certain dimension of Tensor `input`. Args: input (Variable): Tensor, data type float32, float64. porder (int|float,str): p in ['fro', 'nuc', ±1, ±2, ±inf] Default 1. axis (list): Two dimensions. keepdim (bool, optional): Whether keep the dimensions as the `input`, Default False. name (str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. rrrFrc3,># UH oT-v M g7fNr.0dranks rZ 5matrix_norm..p_matrix_norm..us51$hrrrr_r p_matrix_normryr=r>r?rBrCrrrrrr@rrrc3,># UH oT-v M g7frrrs rZrrs1Dqd(Drrrr)r)rLrMrrrrrr:rrrr/rrrrPrQrrSr")r_rrBrrTr;rabs_ordmax_minrrrrrrrrrXrrrrr max_min_axisr vector_outrGrrrr)s @rZr"matrix_norm..p_matrix_normPs$&d1gtAwEKK8HI'- ! # #&kG$*SLfjjfjjG#~ & 0 0 = !::mU;b B0#--((4hF 177|55 bjj//!%$DKAIDsG !   7   8vx866##%7 f+ c>!DD'')EM BB'')CK OO!eW~!.K=Itn  88'')9A88'')9A99''):B OOm_-r2&.  +11*,,KAA'')BJ(8A'> $J OO Qx +' '",   % H H++-!I! %*.%2O }M!B4.  %-1%(Ek]C!8,     qww>> import paddle >>> x = paddle.arange(24, dtype="float32").reshape([2, 3, 4]) - 12 >>> print(x) Tensor(shape=[2, 3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[[-12., -11., -10., -9. ], [-8. , -7. , -6. , -5. ], [-4. , -3. , -2. , -1. ]], [[ 0. , 1. , 2. , 3. ], [ 4. , 5. , 6. , 7. ], [ 8. , 9. , 10., 11.]]]) >>> # compute frobenius norm along last two dimensions. >>> out_fro = paddle.linalg.norm(x, p='fro', axis=[0,1]) >>> print(out_fro) Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [17.43559647, 16.91153526, 16.73320007, 16.91153526]) >>> # compute 2-order vector norm along last dimension. >>> out_pnorm = paddle.linalg.norm(x, p=2, axis=-1) >>> print(out_pnorm) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[21.11871147, 13.19090557, 5.47722578 ], [3.74165750 , 11.22497177, 19.13112640]]) >>> # compute 2-order norm along [0,1] dimension. >>> out_pnorm = paddle.linalg.norm(x, p=2, axis=[0,1]) >>> print(out_pnorm) Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [15.75857544, 14.97978878, 14.69693947, 14.97978973]) >>> # compute inf-order norm >>> out_pnorm = paddle.linalg.norm(x, p=float("inf")) >>> print(out_pnorm) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 12.) >>> out_pnorm = paddle.linalg.norm(x, p=float("inf"), axis=0) >>> print(out_pnorm) Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[12., 11., 10., 9. ], [8. , 7. , 6. , 7. ], [8. , 9. , 10., 11.]]) >>> # compute -inf-order norm >>> out_pnorm = paddle.linalg.norm(x, p=-float("inf")) >>> print(out_pnorm) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 0.) >>> out_pnorm = paddle.linalg.norm(x, p=-float("inf"), axis=0) >>> print(out_pnorm) Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 1., 2., 3.], [4., 5., 6., 5.], [4., 3., 2., 1.]]) rrr%r)r~rBrrT)r)r~rBrrTrr) rKrJrIrLrstrrrrndimr rr)r)r~rBrrXrRrTrs rZrrs`$Dz D$  CINAw  HHUO!S :4<:dC+@+@  F|E!&&M* t4F9C! dD ! !c$i1n t4F! F  f) Mr[rocx[5(a[R"XU5$[US/SQS5 [US/SQS5 [ US[ [ 4S5 [S0[5D6nURUR5nU/U/S.nSU/0nS[ U50nURSUSU0US9 U$) aH Returns the p-norm of (x - y). It is not a norm in a strict sense, only as a measure of distance. The shapes of x and y must be broadcastable. The definition is as follows, for details, please refer to the `Introduction to Tensor <../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor>`_: - Each input has at least one dimension. - Match the two input dimensions from back to front, the dimension sizes must either be equal, one of them is 1, or one of them does not exist. Where, z = x - y, the shapes of x and y are broadcastable, then the shape of z can be obtained as follows: 1. If the number of dimensions of x and y are not equal, prepend 1 to the dimensions of the tensor with fewer dimensions. For example, The shape of x is [8, 1, 6, 1], the shape of y is [7, 1, 5], prepend 1 to the dimension of y. x (4-D Tensor): 8 x 1 x 6 x 1 y (4-D Tensor): 1 x 7 x 1 x 5 2. Determine the size of each dimension of the output z: choose the maximum value from the two input dimensions. z (4-D Tensor): 8 x 7 x 6 x 5 If the number of dimensions of the two inputs are the same, the size of the output can be directly determined in step 2. When p takes different values, the norm formula is as follows: When p = 0, defining $0^0=0$, the zero-norm of z is simply the number of non-zero elements of z. .. math:: ||z||_{0}=\lim_{p \\rightarrow 0}\sum_{i=1}^{m}|z_i|^{p} When p = inf, the inf-norm of z is the maximum element of the absolute value of z. .. math:: ||z||_\infty=\max_i |z_i| When p = -inf, the negative-inf-norm of z is the minimum element of the absolute value of z. .. math:: ||z||_{-\infty}=\min_i |z_i| Otherwise, the p-norm of z follows the formula, .. math:: ||z||_{p}=(\sum_{i=1}^{m}|z_i|^p)^{\\frac{1}{p}} Args: x (Tensor): 1-D to 6-D Tensor, its data type is bfloat16, float16, float32 or float64. y (Tensor): 1-D to 6-D Tensor, its data type is bfloat16, float16, float32 or float64. p (float, optional): The norm to be computed, its data type is float32 or float64. Default: 2. 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: Tensor that is the p-norm of (x - y). Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[3, 3],[3, 3]], dtype="float32") >>> y = paddle.to_tensor([[3, 3],[3, 1]], dtype="float32") >>> out = paddle.dist(x, y, 0) >>> print(out) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 1.) >>> out = paddle.dist(x, y, 2) >>> print(out) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 2.) >>> out = paddle.dist(x, y, float("inf")) >>> print(out) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 2.) >>> out = paddle.dist(x, y, float("-inf")) >>> print(out) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 0.) rR)r-r,r.r/distr~r>Yr@rC)r) rrrrrrrrrPrQrRrS) r)ror~rTrWrXrErFrGs rZrrsx{{1## 7A6 7A6q#s|V,  ,68 ,F  3 3AGG >> import paddle >>> paddle.seed(2023) >>> x = paddle.to_tensor([[1., 0, -1], [0, 1, 0], [1, 0, 1]]) >>> # compute conditional number when p is None >>> out = paddle.linalg.cond(x) >>> print(out) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 1.41421378) >>> # compute conditional number when order of the norm is 'fro' >>> out_fro = paddle.linalg.cond(x, p='fro') >>> print(out_fro) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 3.16227770) >>> # compute conditional number when order of the norm is 'nuc' >>> out_nuc = paddle.linalg.cond(x, p='nuc') >>> print(out_nuc) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 9.24264145) >>> # compute conditional number when order of the norm is 1 >>> out_1 = paddle.linalg.cond(x, p=1) >>> print(out_1) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 2.) >>> # compute conditional number when order of the norm is -1 >>> out_minus_1 = paddle.linalg.cond(x, p=-1) >>> print(out_minus_1) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 1.) >>> # compute conditional number when order of the norm is 2 >>> out_2 = paddle.linalg.cond(x, p=2) >>> print(out_2) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 1.41421378) >>> # compute conditional number when order of the norm is -1 >>> out_minus_2 = paddle.linalg.cond(x, p=-2) >>> print(out_minus_2) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 0.70710671) >>> # compute conditional number when order of the norm is inf >>> out_inf = paddle.linalg.cond(x, p=float("inf")) >>> print(out_inf) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 2.) >>> # compute conditional number when order of the norm is -inf >>> out_minus_inf = paddle.linalg.cond(x, p=-float("inf")) >>> print(out_minus_inf) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 1.) >>> a = paddle.randn([2, 4, 4]) >>> print(a) Tensor(shape=[2, 4, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[[ 0.06132207, 1.11349595, 0.41906244, -0.24858207], [-1.85169315, -1.50370061, 1.73954511, 0.13331604], [ 1.66359663, -0.55764782, -0.59911072, -0.57773495], [-1.03176904, -0.33741450, -0.29695082, -1.50258386]], [[ 0.67233968, -1.07747352, 0.80170447, -0.06695852], [-1.85003340, -0.23008066, 0.65083790, 0.75387722], [ 0.61212337, -0.52664012, 0.19209868, -0.18707706], [-0.00711021, 0.35236868, -0.40404350, 1.28656745]]]) >>> a_cond_fro = paddle.linalg.cond(a, p='fro') >>> print(a_cond_fro) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [6.37173700 , 35.15114594]) >>> b = paddle.randn([2, 3, 4]) >>> print(b) Tensor(shape=[2, 3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[[ 0.03306439, 0.70149767, 0.77064633, -0.55978841], [-0.84461296, 0.99335045, -1.23486686, 0.59551388], [-0.63035583, -0.98797107, 0.09410731, 0.47007179]], [[ 0.85850012, -0.98949534, -1.63086998, 1.07340240], [-0.05492965, 1.04750168, -2.33754158, 1.16518629], [ 0.66847134, -1.05326962, -0.05703246, -0.48190674]]]) >>> b_cond_2 = paddle.linalg.cond(b, p=2) >>> print(b_cond_2) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [2.86566353, 6.85834455]) Nc v>[5(a[R"U5n[R"X2SS5nUS:XdU[R :Xa[R "US/S5$US:XdU[R *:Xa[R"US/S5$g[S0[5D6nURUR5S9nURUR5S9nURUR5S9nURSSU0SU0S 9 [UT5uprURS SU0SU0USUS .S 9 US:XdU[R :XaURS SU0SU0S/SUS .S 9 US:XdU[R *:XaURSSU0SU0S/SUS .S 9 U$)z NOTE: Calculate the matrix norm of a square matrix or batches of square matrices, when porder is in (1, -1, inf, -inf) NFrrryrr>r@rrrrCrrr)rrrrrrrrrrPrQrrSr") r_rrBrrrrXrr)s rZmat_normcond..mat_norms " # #jj'Gjje>'')?G>>'')?G::'');C OOC<%9I   0a8 J OO!W~( %",  {f.%>"CL "t$)&0  |v"&&0%>"CL "t$)&0  Jr[rrc >[5(ai[R"X5n[R"X2SS5n[R"XBSS5n[R"U[ SU- 55$[ S 0[ 5D6nURUR5S9nURUR5S9nURUR5S9nURUR5S9nURSSU0SU0SU0S 9 [UT 5upURS SU0SU0USUS .S 9 URS SU0SU0USUS .S 9 URSSU0SU0S[ SU- 50S 9 U$) zZ NOTE: Calculate the frobenius norm of a square matrix or batches of square matrices. NFrryrr>r@rrCrrr) rrrrrrrPrQrrSr") r_rrBr sum_out_1 sum_out_2rrXrr)s rZfro_normcond..fro_norms " # #jj/G 7$>I 9D%@I::isV|)<= =3&(3E>>'')?G@@'')AI@@'')AI::'');C OOU|((   0a8 J OO!W~ * %",   OO!Y' * %",   OOY' sV|!45   Jr[c d>[USS9up4n[5(aUS:Xa[R"XBSS5$[R"XBS5n[R "XBS5nUS:Xa[R "Xg5$US:Xa[R "Xv5$g[UT 5up[S0[5D6n U RU R5S9n US:XaU RSS U0S U 0USUS .S 9 U $U RU R5S9nU RU R5S9nU RS S U0S U0USUS .S 9 U RSS U0S U0USUS .S 9 US:XaU RSXgS.S U 0SS0S 9 U $US:XaU RSXvS.S U 0SS0S 9 U $g)z NOTE: Calculate the matrix norm, which is related to singular values, of a matrix or batches of matrices, including nuclear norm, 2-norm and (-2)-norm. Frr&Nrrryrr>r@rrCrrelementwise_divrrBrr) rrrrrrdivider"rrPrQrrS) r_rrBrrrmax_outmin_outrrrXr)s rZsvd_normcond..svd_norm;s'uE2b ! # #zz!477jj%0Gjj%0G{}}W66|}}W66 0a8 J3&(3E::'');C%8"CL#$)&0   >>'')?G>>'')?G OO!Qx( %",   OO!Qx( %",  {*!(7"CL!2,    |*!(7"CL!2,    r[c[5(a[5(a [S5eUR5n[ U5S:Xa&US:Xa UR S/5R 5$[R"U5nUS:a[US:XaU[R"UR5[R"U/URS9/5nUR U5$UR U5$[S5e)Nz6only support x is nonempty tensor in static graph moderry)rrrNnumelrLreshapermathprodrconcatflattenzerosrR)r_rMold_sizenew_sizetmps rZ empty_tensorcond..empty_tensors ! # #}} L {{}H5zQ8q=}}aS)--//yy'H!|A mm  hZu{{C {{5))==' ' D  r[z1input should be a matrix or batches of matrices, z'but the dimension of received input is rrr%r&rrr)rrBzonly support p is z when input is a z+square matrix or batches of square matrices)rr)rz unsupported z' for p, only supporting ('fro', 'nuc', z 1, -1, 2, -2, inf, -inf) or none)rN)r_r$rrrBrrr$)r_r$rrrBz list[int]rr$)rIrMrLrNrrinverse) r)r~rTrrr!r.rYx_sizex_invs ` rZcondr4GsjFJ@@$@2B@ @@F()RD<<$<09< <<~:<NN$N,5N NN` 4177mG w<1  ?7G ~F G   y >> import paddle >>> x = paddle.to_tensor([[1, 2, 3], [4, 5, 6]], dtype='float32') >>> y = paddle.to_tensor([[1, 2, 3], [4, 5, 6]], dtype='float32') >>> result = paddle.linalg.vecdot(x, y, axis=1) >>> print(result) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [14.0, 77.0]) rB)conjr)r)rorBrTrXs rZvecdotr8s'@ 668a<  $  'C Jr[cSn[UR5S:d[UR5S:a"[S[UR5S35e[USSS/S5 Un[UR5S:XaUR S 5nU(d#URS S:waUR 5nS nURSn UGbUR UR5n[UR5S:a"[S [UR5S35eURS U :wa[S U SURS S35eUR5S :a[SUR5S35e[R"U[R"UR S55R UR5:H5(d [S5eUbUR UR5n [U R5S:a"[S[UR5S35e[USSS/S5 URS U :wa[SU SURS S35eUR5S :a[SUR5S35eUbX-nOU n[R"XRS9n UcUb/UR5n U R5S :Xa [S5eUbXx-n U RSS9U - n OURSS9U - n Un Ub<Ub9U(a2XUR UR5-R5U - - nOX- n[R"US S9nX}R!S5- n[R""X|R 5R%55n[R&"X5R)5nU$)u Estimate the covariance matrix of the input variables, given data and weights. A covariance matrix is a square matrix, indicate the covariance of each pair variables in the input matrix. For example, for an N-dimensional samples X=[x1,x2,…xN]T, then the covariance matrix element Cij is the covariance of xi and xj. The element Cii is the variance of xi itself. Parameters: x (Tensor): A N-D(N<=2) Tensor containing multiple variables and observations. By default, each row of x represents a variable. Also see rowvar below. rowvar (bool, optional): If rowvar is True (default), then each row represents a variable, with observations in the columns. Default: True. ddof (bool, optional): If ddof=True will return the unbiased estimate, and ddof=False will return the simple average. Default: True. fweights (Tensor, optional): 1-D Tensor of integer frequency weights; The number of times each observation vector should be repeated. Default: None. aweights (Tensor, optional): 1-D Tensor of observation vector weights. How important of the observation vector, larger data means this element is more important. Default: None. name (str|None, optional): Name of the output. Default is None. It's used to print debug info for developers. Details: :ref:`api_guide_Name` . Returns: Tensor: The covariance matrix Tensor of the variables. Examples: .. code-block:: python >>> import paddle >>> paddle.seed(2023) >>> xt = paddle.rand((3, 4)) >>> paddle.linalg.cov(xt) >>> print(xt) Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.86583614, 0.52014720, 0.25960937, 0.90525323], [0.42400089, 0.40641287, 0.97020894, 0.74437362], [0.51785129, 0.73292869, 0.97786582, 0.04315904]]) covrrzZInput(x) only support N-D (1<=N<=2) tensor in cov, but received length of Input(input) is r<rRr.r/r0rNz]Input(fweights) only support N-D (N<=1) tensor in cov, but received shape of Input(input) is z:The number of Input(fweights) should equal to x's dim[1]: z*, but received size of Input(fweights) is zXThe value of Input(fweights) cannot be negative, but received min of Input(fweights) is z Input(fweights) must be integer z^Input(aweights) only support N-D (N<=1) tensor in cov, but received length of Input(input) is z:The number of Input(aweights) should equal to x's dim[1]: z*, but received size of Input(aweights) is zXThe value of Input(aweights) cannot be negative, but received min of Input(aweights) is ryz0The sum of weights is zero, can't be normalized.r6r)rLrMrNrr%trrRrrallround to_tensorritemcliprmmr7rsqueeze)r)rowvarddoffweightsaweightsrTop_typenxwobservation_numaww_sumnx_wavg norm_factorxxtr:s rZr:r:sRG 177|a3qww>!  /L_L]^..6nnQ.?-@C  <<>A --5\\^,>x~~N O  ?@ @ __RXX & rxx=1 --0-@,AD  ! g 95u  >>!  /L_L]^..6nnQ.?-@C  <<>A --5\\^,>> import paddle >>> # Example 1 (0-D tensor) >>> x = paddle.to_tensor([0.79]) >>> out = paddle.t(x) >>> print(out) Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, [0.79000002]) >>> # Example 2 (1-D tensor) >>> x = paddle.to_tensor([0.79, 0.84, 0.32]) >>> out2 = paddle.t(x) >>> print(out2) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [0.79000002, 0.83999997, 0.31999999]) >>> print(paddle.t(x).shape) paddle.Size([3]) >>> # Example 3 (2-D tensor) >>> x = paddle.to_tensor([[0.79, 0.84, 0.32], [0.64, 0.14, 0.57]]) >>> print(x.shape) paddle.Size([2, 3]) >>> out3 = paddle.t(x) >>> print(out3) Tensor(shape=[3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.79000002, 0.63999999], [0.83999997, 0.14000000], [0.31999999, 0.56999999]]) >>> print(paddle.t(x).shape) paddle.Size([3, 2]) rTInput(input) only support N-D (N<=2) tensor, but received length of Input(input) is 8. Perhaps you can use paddle.tensor.transpose() instead.rrr_)r,r.r/r3r4r5r:r=r>r?rBrC)r<) rLrMrNrrr:rrrPrQrRrS)r_rTr;rXrWrs rZr<r<rs*f 5;;! )),U[[)9(:;* *   u{{ q L1vu+    I   -FH-77 D?? L u{{ q C   !eW~!$+?1v&    r[c[UR5S:a"[S[UR5S35e[5(a7[UR5S::aU$SS/n[R "X5nU$g)z} Inplace version of ``t`` API, the output Tensor will be inplaced with input ``input``. Please refer to :ref:`api_paddle_t`. rrSrTrrN)rLrMrNrrr])r_rTr;rXs rZt_rVs  5;;! )),U[[)9(:;* *   u{{ q L1v, r[c<[5(a"Uc[OUn[R"XU5$[ US/SQS5 [ US/SQS5 [ S 0[ 5D6nURUR5n0nX&S'URSXS.SU0US9 U$) a Computes the cross product between two tensors along an axis. Inputs must have the same shape, and the length of their axes should be equal to 3. If `axis` is not given, it defaults to the first axis found with the length 3. Args: x (Tensor): The first input tensor, the data type is float16, float32, float64, int32, int64, complex64, complex128. y (Tensor): The second input tensor, the data type is float16, float32, float64, int32, int64, complex64, complex128. axis (int, optional): The axis along which to compute the cross product. It defaults to be 9 which indicates using the first axis found with the length 3. 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 same data type as `x`. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1.0, 1.0, 1.0], ... [2.0, 2.0, 2.0], ... [3.0, 3.0, 3.0]]) >>> y = paddle.to_tensor([[1.0, 1.0, 1.0], ... [1.0, 1.0, 1.0], ... [1.0, 1.0, 1.0]]) ... >>> z1 = paddle.cross(x, y) >>> print(z1) Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[-1., -1., -1.], [ 2., 2., 2.], [-1., -1., -1.]]) >>> z2 = paddle.cross(x, y, axis=1) >>> print(z2) Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]]) r))r,r5r.r/r3r4r6r7crossrorVrr@rC)rX) r K_DEFAULT_DIMrrXrrrPrQrRrS)r)rorBrTrWrXrGs rZrXrXs` $ }$||A$''     !    1177@e #CL   r[cz[5(aDURn[U5S:a USUS:XdS5e[R"X5$[ USSS/S5 [ US [S5 [S0[5D6nURURS 9nURSS U/0S U0S U0S 9 U$)aS Computes the Cholesky decomposition of one symmetric positive-definite matrix or batches of symmetric positive-definite matrices. If `upper` is `True`, the decomposition has the form :math:`A = U^{T}U` , and the returned matrix :math:`U` is upper-triangular. Otherwise, the decomposition has the form :math:`A = LL^{T}` , and the returned matrix :math:`L` is lower-triangular. Args: x (Tensor): The input tensor. Its shape should be `[*, M, M]`, where * is zero or more batch dimensions, and matrices on the inner-most 2 dimensions all should be symmetric positive-definite. Its data type should be float32 or float64. upper (bool, optional): The flag indicating whether to return upper or lower triangular matrices. 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: Tensor, A Tensor with same shape and data type as `x`. It represents triangular matrices generated by Cholesky decomposition. Examples: .. code-block:: python >>> import paddle >>> paddle.seed(2023) >>> a = paddle.rand([3, 3], dtype="float32") >>> a_t = paddle.transpose(a, [1, 0]) >>> x = paddle.matmul(a, a_t) + 1e-03 >>> out = paddle.linalg.cholesky(x, upper=False) >>> print(out) Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1.04337072, 0. , 0. ], [1.06467664, 0.17859250, 0. ], [1.30602181, 0.08326444, 0.22790681]]) rrrzLShape must have at least 2 dimensions and last two dimensions must be equal.rRr.r/choleskyupperryr>r@rC)r[) rrMrLrr[rrr+rrPrQrRrS)r)r\rTrYrWrXs rZr[r[>sR''7|q WR[GBK%? Z ?q(( Gi-CZP5'44468477agg7F!:CLE"   r[clUR[R:Xa[RO9UR[R:Xa[R O URnSnUcUbUb [ S5eSnU(GaDUc [/SU5n[U[[45(a [/X65nURU:wa [X65nUb[[U[[45(a [/XF5nURU:wa [XF5n[R"X4/5up4[5(a[R"XXB5$0n0n [!US/SQS5 XS'X8S'XHS '[#US [$S5 X)S '['S0[)5D6n U R+S S 9n U R-SUS U 0U S9 U $[5(a[U[.[R0R245(a7URU:wa [X5n OUn Sn [R4"X X5$UcSnSn O [U5nSn [R6"XX5$0n0n [!US/SQS5 XS'UcSU S'OY[U[.5(a)SU S'URU:wa[X5US'O XS'O[#US[S5 SU S'XS'[#US [$S5 X)S '['S0[)5D6n U R+S S 9n U R-SUSU 0U S9 U $)a Computes the rank of a matrix. Notes: 1. Support the use of attribute `tol` alone or the use of attributes `atol` and `rtol` together without `tol`. 2. When `tol` is used alone, it will return the rank of a matrix is the number of singular values that are greater than the specified `tol` threshold when hermitian=False, or the number of eigenvalues in absolute value that are greater than the specified `tol` threshold when hermitian=True. It is compatible with numpy API. 3. When `atol` and `rtol` are used, the tolerance value is computed as `max(atol, sigma_1 * rtol)`, where sigma_1 is largest singular value (or eigenvalues in absolute value). 4. When `atol` and `rtol` are used: If `rtol` is not specified, then it is set to be `max(m,n) * eps`, where `x` has dimension(m, n) and `eps` is the epsilon value for the dtype of `x`; If `rtol` is not specified and `atol` is specified to be greater than 0, then it is set to be 0. Args: x (Tensor): The input tensor. Its shape should be `[..., m, n]`, where `...` is zero or more batch dimensions. If `x` is a batch of matrices then the output has the same batch dimensions. The data type of `x` should be float32, float64, complex64 or complex128. tol (float|Tensor, optional): The tolerance value. If `tol` is not specified, and `sigma` is the largest singular value (or eigenvalues in absolute value), and `eps` is the epsilon value for the dtype of `x`, then `tol` is computed with formula `tol=sigma * max(m,n) * eps`. Note that if `x` is a batch of matrices, `tol` is computed this way for every batch. Default: None. hermitian (bool, optional): Indicates whether `x` is Hermitian. Default: False. When hermitian=True, `x` is assumed to be Hermitian, enabling a more efficient method for finding eigenvalues, but `x` is not checked inside the function. Instead, We just use the lower triangular of the matrix to compute. Default: False. atol (float|Tensor, optional): The absolute tolerance value. When None it is considered to be 0. Default: None. rtol (float|Tensor, optional): The relative tolerance value. See above Notes for the value it takes when None. 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: Rank of tensor x. Examples: .. code-block:: pycon >>> import paddle >>> a = paddle.eye(10) >>> b = paddle.linalg.matrix_rank(a) >>> print(b) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 10) >>> c = paddle.ones(shape=[3, 4, 5, 5]) >>> d = paddle.linalg.matrix_rank(c, tol=0.01, hermitian=True) >>> print(d) Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]) Fz?Only support to use tol alone or use atol and rtol without tol.Trr)r.r/r6r7matrix_rank_atol_rtolatolrtol hermitianr3ryrXrC matrix_rankr>use_default_tol TolTensortolr@)r_)rc)rRrr6r.r7r/rNr rKrrr!broadcast_tensorsrrr_rrr+rrPrQrSrpirValuematrix_rank_tolrc)r)rfrbr`rarT target_dtype use_atol_rtolrErGrWrX tol_tensorrdtol_attrs rZrcrc{s>~ 77f&& &  !6+<+< >> import paddle >>> inputs = paddle.to_tensor([1, 2, 1]) >>> result = paddle.histogram(inputs, bins=4, min=0, max=3) >>> print(result) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 2, 1, 0]) histogramr>r3r4r.r/Weightry)r>rrr@)binsrrdensityrC)rp)rKrrrrrprrPrrQrVarTypeFP32INT64rS) r_rsrrweightrtrTrWrXs rZrprp' sN#sCj#sCjt#GG5FH5 3@+  W(<  ;;oo**<C;;oo++<C 1CL"    r[c[U[5(a [U5n[U[5(a [U5n[US[S5 [ UR S/SQS5 [US[S5 US:Xa3US:Xa-[R"U5n[R"U5nOX2:a [S5eX#- S:Xa US-nUS- n[R"X#US-US 9$) a Computes only the edges of the bins used by the histogram function. If min and max are both zero, the minimum and maximum values of the data are used. Args: input (Tensor): The data type of the input Tensor should be float32, float64, int32, int64. bins (int, optional): number of histogram bins. min (float, optional): lower end of the range (inclusive). Default: 0.0. max (float, optional): upper end of the range (inclusive). Default: 0.0. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, the values of the bin edges. The output data type will be float32. Examples: .. code-block:: python >>> import paddle >>> inputs = paddle.to_tensor([1, 2, 1]) >>> result = paddle.histogram_bin_edges(inputs, bins=4, min=0, max=3) >>> print(result) Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [0. , 0.75000000, 1.50000000, 2.25000000, 3. ]) r_histogram_bin_edges)r.r/r3r4rsrz.max must be larger than min in range parameterg?r)rT) rKrrrrrrRrrrrNlinspace)r_rsrrrTs rZrzrzy s@#sCj#sCjug+@A 0  tVS"78 czcSjjjjj 9MN N cCiCi ??3TAXD 99r[cUR[R[R[R [R 4;a [S5e[5(a[R"XU5$[S 0[5D6n[USSS/S5 Ub*[US/SQS5 URURS9nOURURS9nURSXS .S U0S U0S 9 U$)a Computes frequency of each value in the input tensor. Args: x (Tensor): A Tensor with non-negative integer. Should be 1-D tensor. weights (Tensor, optional): Weight for each value in the input tensor. Should have the same shape as input. Default is None. minlength (int, optional): Minimum number of bins. Should be non-negative integer. Default is 0. name (str|None, optional): Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Default is None. Returns: Tensor: The tensor of frequency. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 2, 1, 4, 5]) >>> result1 = paddle.bincount(x) >>> print(result1) Tensor(shape=[6], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 2, 1, 0, 1, 1]) >>> w = paddle.to_tensor([2.1, 0.4, 0.1, 0.5, 0.5]) >>> result2 = paddle.bincount(x, weights=w) >>> print(result2) Tensor(shape=[6], dtype=float32, place=Place(cpu), stop_gradient=True, [0. , 2.19999981, 0.40000001, 0. , 0.50000000, 0.50000000]) z+Elements in Input(x) should all be integersbincountr>r3r4Weightsrqry)r>r~r@ minlengthrC)r})rRrr3r4r INT32rw TypeErrorrrr}rrPrrQrS)r)weightsrrTrWrXs rZr}r} sH ww    EFFq9554684 C'7);ZH   $8   ;;'--;PC;;!'';JC/CL *   r[c[5(a[R"X5$SnU"X5 [S0[ 5D6nUR UR S9nURSXS.SU0S9 U$)a Performs a matrix-vector product of the matrix x and the vector vec. Args: x (Tensor): A tensor with shape :math:`[M, N]` , The data type of the input Tensor x should be one of float32, float64. vec (Tensor): A tensor with shape :math:`[N]` , The data type of the input Tensor x should be one of float32, float64. name (str|None, optional): Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Default is None. Returns: Tensor: The tensor which is produced by x and vec. Examples: .. code-block:: python >>> # x: [M, N], vec: [N] >>> # paddle.mv(x, vec) # out: [M] >>> import paddle >>> x = paddle.to_tensor([[2, 1, 3], [3, 0, 1]]).astype("float64") >>> vec = paddle.to_tensor([3, 5, 1]).astype("float64") >>> out = paddle.mv(x, vec) >>> print(out) Tensor(shape=[2], dtype=float64, place=Place(cpu), stop_gradient=True, [14., 10.]) c$XS.nUR5Hup4[XCSS/S5 M [UR5n[UR5n[ U5S:wa[ SU35e[ U5S:wa[ SU35eg) N)r)vecr.r/mvrz7x should be 2-dimensional. But received x's dimension: rz;vec should be 1-dimensional. But received vec's dimension: )rrrrIrMrLrN)r)rrtrTrurY vec_shapes rZrvmv..__check_input s,I&__. ( 95t/177mGSYYI7|q  MgYW9~" QR[Q\]#r[rry)r>Vecr@r)r)rrrrrPrQrRrS)r)rrTrvrWrXs rZrr sy<yy   " a.VX.77agg7FA2UCL   r[c[5(a[R"U5$[URS/SQS5 [ UR 5n[U5S:dS[U5S35eUSUS:XdS USS USS 35e[S0[5D6nURURS 9nURS SU/0SU/0S9 U$)a+ Calculates determinant value of a square matrix or batches of square matrices. Args: x (Tensor): the input matrix of size `(n, n)` or the batch of matrices of size `(*, n, n)` where `*` is one or more batch dimensions. name (str|None, optional): Name of the output.It's used to print debug info for developers. Details: :ref:`api_guide_Name`. Default is None. Returns: Tensor, the determinant value of a square matrix or batches of square matrices. Examples: .. code-block:: python >>> import paddle >>> paddle.seed(2023) >>> x = paddle.randn([3,3,3]) >>> A = paddle.linalg.det(x) >>> print(A) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [-1.29280925, 0.77832544, 0.89754158]) Inputr,r.r/r6r7detrJThe x must be at least 2-dimensional, but received Input x's dimensional: . rr"Expect squared input,but received  by matrix. determinantryr@r)r) rrrrrRrIrMrLrrPrQrSr)rTrrWrXs rZrr5 s 8zz!} GG  H   177m ;1$  336{3C2DC I $ 2+b/1  'O,DR0A M 17fh777agg7F!~u~   r[c[5(a[R"U5$[URS/SQS5 [ UR 5n[U5S:dS[U5S35eUSUS:XdS USS USS 35e[S0[5D6nURURS 9nURS SU/0SU/0S9 U$)az Calculates the sign and natural logarithm of the absolute value of a square matrix's or batches square matrices' determinant. The determinant can be computed with ``sign * exp`` (logabsdet). Supports input of float, double, complex64, complex128. Notes: 1. For matrices that have zero determinant, this returns ``(0, -inf)``. 2. For matrices with complex value, the :math:`abs(det)` is the modulus of the determinant, and therefore :math:`sign = det / abs(det)`. Args: x (Tensor): the batch of matrices of size :math:`(*, n, n)` where math:`*` is one or more batch dimensions. name (str|None, optional): Name of the output.It's used to print debug info for developers. Details: :ref:`api_guide_Name`. Default is None. Returns: y (Tensor), A tensor containing the sign of the determinant and the natural logarithm of the absolute value of determinant, respectively. The output shape is :math:`(2, *)`, where math:`*` is one or more batch dimensions of the input `x`. Examples: .. code-block:: python >>> import paddle >>> paddle.seed(2023) >>> x = paddle.randn([3, 3, 3]) >>> A = paddle.linalg.slogdet(x) >>> print(A) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[-1. , 1. , 1. ], [ 0.25681755, -0.25061053, -0.10809582]]) rr^slogdetrrrrrrrrslogdeterminantryr@r)r) rrrrrRrIrMrLrrPrQrSrs rZrrn sL~~a   GG  =   177m ;1$  336{3C2DC I $ 2+b/1  'O,DR0A M 1;&(;77agg7F"aS>SEN   r[rXc[5(a[R"XUS9$[US/SQS5 [ US[ S5 [ S 0[5D6nURURS9nURURS9nURURS9n0nXS'URSSU/0XVUS.US 9 XWU4$) a Computes the singular value decomposition of one matrix or a batch of regular matrices. Let :math:`X` be the input matrix or a batch of input matrices, the output should satisfies: .. math:: X = U * diag(S) * V^{H} Args: x (Tensor): The input tensor. Its shape should be `[..., N, M]`, where `...` is zero or more batch dimensions. N and M can be arbitrary positive number. Note that if x is singular matrices, the grad is numerical instable. The data type of x should be float32, float64, complex64 or complex128. full_matrices (bool, optional): A flag to control the behavior of svd. If full_matrices = True, svd op will compute full U and V matrices, which means shape of U is `[..., N, N]`, shape of V is `[..., M, M]`. K = min(M, N). If full_matrices = False, svd op will use a economic method to store U and V. which means shape of U is `[..., N, K]`, shape of V is `[..., M, K]`. K = min(M, N). Default value is False. name (str|None, optional): Name for the operation. For more information, please refer to :ref:`api_guide_Name`. Default value is None. Returns: - U (Tensor), is the singular value decomposition result U. - S (Tensor), is the singular value decomposition result S. - VH (Tensor), VH is the conjugate transpose of V, which is the singular value decomposition result V. Tuple of 3 tensors(U, S, VH): VH is the conjugate transpose of V. S is the singular value vectors of matrices with shape `[..., K]` Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1.0, 2.0], [1.0, 3.0], [4.0, 6.0]]).astype('float64') >>> x = x.reshape([3, 2]) >>> u, s, vh = paddle.linalg.svd(x) >>> print (u) Tensor(shape=[3, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[-0.27364809, -0.21695147], [-0.37892198, -0.87112408], [-0.88404460, 0.44053933]]) >>> print (s) Tensor(shape=[2], dtype=float64, place=Place(cpu), stop_gradient=True, [8.14753743, 0.78589688]) >>> print (vh) Tensor(shape=[2, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[-0.51411221, -0.85772294], [ 0.85772294, -0.51411221]]) >>> # one can verify : U * S * VT == X >>> # U * UH == I >>> # V * VH == I rrRr^rrryr>rrC)r) rrrrrr+rrPrQrRrS) r)rrTrXrWrrrrGs rZrr s@zz!44 wI5  =/4?/fh/  5 5AGG 5 D  6 6QWW 6 E  5 5AGG 5 D!.o!:A.  Rxr[c.[R"U5$)a Computes the singular values of one matrix or a batch of matrices. Let :math:`X` be the input matrix or a batch of input matrices, the output singular values :math:`S` are the diagonal elements of the matrix produced by singular value decomposition: .. math:: X = U * diag(S) * V^{H} Args: x (Tensor): The input tensor. Its shape should be `[..., M, N]`, where `...` is zero or more batch dimensions. The data type of x should be float32 or float64. name (str|None, optional): Name for the operation. For more information, please refer to :ref:`api_guide_Name`. Default: None. Returns: Tensor: Singular values of x. The shape is `[..., K]`, where `K = min(M, N)`. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1.0, 2.0], [1.0, 3.0], [4.0, 6.0]]) >>> s = paddle.linalg.svdvals(x) >>> print(s) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [8.14753819, 0.78589684]) )rsvdvalsrds rZrr sB >>! r[cPUR5(aUR5$U$r)rr7r)s rZ _conjugater- s||~~vvx Hr[cURn[[S[U555n/USSQUSPUSPn[R "X5$)Nrrr)rMrIrrLrr:)r)rMr;s rZ _transposer3 sS GGE aU$ %D +T#2Y +R +$r( +D   A $$r[c*[[U55$r)rrrs rZ _transjugater: s jm $$r[c<UcSOUnURSSupE[RRn[R"XQ4UR S9n[ U5n[U5n UcqU"[R"X55Sn [U5HAn U"[R"X55Sn U"[R"X 55Sn MC U $[U5n U"[R"X5[R"X75- 5Sn [U5Hon U"[R"X5[R"X5- 5Sn U"[R"X 5[R"X:5- 5Sn Mq U $)Nrrryr) rMrlinalgqrrandnrRrrr rr) r)qniterMmnrRA_tA_HQrM_Hs rZ_get_approximate_basisr> sIAEE 7723[ XV5S:wa/US:aU[ XV5::d[SUS[ XV535eUS:d[SUS 35eUcSnO&UR UR5n[U5n[U5nXV:dXa:Ga+[XX'S 9n [U 5n Uc[R"X 5n O-[R"X 5[R"X:5- n U RSU:XdU RU45eU RS S:wa&U RS U:XdU RU45eU RS U RS::dU R5e[RRU S S 9upn[U5nU RU5nGO4[XX#S 9n [U 5n Uc[R"X5nO-[R"X5[R"Xz5- n[U5n U RSS:wa&U RSU:XdU RU45eU RS U:XdU RU45eU RS U RS::dU R5e[RRU S S 9upn[U5nU RU 5n XU4$)aS Return the singular value decomposition (SVD) on a low-rank matrix or batches of such matrices. If :math:`X` is the input matrix or a batch of input matrices, the output should satisfies: .. math:: X \approx U * diag(S) * V^{H} When :math:`M` is given, the output should satisfies: .. math:: X - M \approx U * diag(S) * V^{H} Args: x (Tensor): The input tensor. Its shape should be `[..., N, M]`, where `...` is zero or more batch dimensions. N and M can be arbitrary positive number. The data type of ``x`` should be float32 or float64. q (int, optional): A slightly overestimated rank of :math:`X`. Default value is None, which means the overestimated rank is 6. niter (int, optional): The number of iterations to perform. Default: 2. M (Tensor, optional): The input tensor's mean. Its shape should be `[..., 1, M]`. Default value is None. name (str|None, optional): Name for the operation. For more information, please refer to :ref:`api_guide_Name`. Default: None. Returns: - Tensor U, is N x q matrix. - Tensor S, is a vector with length q. - Tensor V, is M x q matrix. tuple (U, S, V): which is the nearly optimal approximation of a singular value decomposition of the matrix :math:`X` or :math:`X - M`. Examples: .. code-block:: python >>> import paddle >>> paddle.seed(2024) >>> x = paddle.randn((5, 5), dtype='float64') >>> U, S, V = paddle.linalg.svd_lowrank(x) >>> print(U) Tensor(shape=[5, 5], dtype=float64, place=Place(cpu), stop_gradient=True, [[-0.03586982, -0.17211503, 0.31536566, -0.38225676, -0.85059629], [-0.38386839, 0.67754925, 0.23222694, 0.51777188, -0.26749766], [-0.85977150, -0.28442378, -0.41412094, -0.08955629, -0.01948348], [ 0.18611503, 0.56047358, -0.67717019, -0.39286761, -0.19577062], [ 0.27841082, -0.34099254, -0.46535957, 0.65071250, -0.40770727]]) >>> print(S) Tensor(shape=[5], dtype=float64, place=Place(cpu), stop_gradient=True, [4.11253399, 3.03227120, 2.45499752, 1.25602436, 0.45825337]) >>> print(V) Tensor(shape=[5, 5], dtype=float64, place=Place(cpu), stop_gradient=True, [[ 0.46401347, 0.50977695, -0.08742316, -0.11140428, -0.71046833], [-0.48927226, -0.35047624, 0.07918771, 0.45431083, -0.65200463], [-0.20494730, 0.67097011, -0.05427719, 0.66510472, 0.24997083], [-0.69645001, 0.40237917, 0.09360970, -0.58032322, -0.08666357], [ 0.13512270, 0.07199989, 0.98710572, 0.04529277, 0.01134594]]) Input must be tensor, but got rNrq(=>) must be non-negative integer and not greater than min(m, n)=niter(=) must be non-negative integerrrrFr)r is_tensorrNrDrMr broadcast_torrrr rrr)r)rrrrTrrM_trrQ_cB_trrVhVBs rZ svd_lowrankrV sF   A  9$q'CDD 7723m 9--'C--'&--*??Cyy}!1CIIq>1! 99R=A 99R=A% 5 1~ 5%yy} " -8syy8-==$$S$>b   HHQK "1u :m 9 c'A c'&--*AAAm 99R=A 99R=A% 5 1~ 5%yy}!1CIIq>1!yy} " -8syy8-==$$S$>b   HHQK 7Nr[c [R"U5(d[S[U535eURSSupVUc [ SXV5nO/US:aU[ XV5::d[SUS[ XV535eUS:d[SUS 35eU(d [ XUSS 9$URSS S 9n[ X- XSS 9$) a Performs linear Principal Component Analysis (PCA) on a low-rank matrix or batches of such matrices. Let :math:`X` be the input matrix or a batch of input matrices, the output should satisfies: .. math:: X = U * diag(S) * V^{T} Args: x (Tensor): The input tensor. Its shape should be `[..., N, M]`, where `...` is zero or more batch dimensions. N and M can be arbitrary positive number. The data type of x should be float32 or float64. q (int, optional): a slightly overestimated rank of :math:`X`. Default value is :math:`q=min(6,N,M)`. center (bool, optional): if True, center the input tensor. Default value is True. niter (int, optional): number of iterations to perform. Default: 2. name (str|None, optional): Name for the operation. For more information, please refer to :ref:`api_guide_Name`. Default: None. Returns: - Tensor U, is N x q matrix. - Tensor S, is a vector with length q. - Tensor V, is M x q matrix. tuple (U, S, V): which is the nearly optimal approximation of a singular value decomposition of a centered matrix :math:`X`. Examples: .. code-block:: python >>> import paddle >>> paddle.seed(2023) >>> x = paddle.randn((5, 5), dtype='float64') >>> U, S, V = paddle.linalg.pca_lowrank(x) >>> print(U) Tensor(shape=[5, 5], dtype=float64, place=Place(cpu), stop_gradient=True, [[ 0.80131563, 0.11962647, 0.27667179, -0.25891214, 0.44721360], [-0.12642301, 0.69917551, -0.17899393, 0.51296394, 0.44721360], [ 0.08997135, -0.69821706, -0.20059228, 0.51396579, 0.44721360], [-0.23871837, -0.02815453, -0.59888153, -0.61932365, 0.44721360], [-0.52614559, -0.09243040, 0.70179595, -0.14869394, 0.44721360]]) >>> print(S) Tensor(shape=[5], dtype=float64, place=Place(cpu), stop_gradient=True, [2.60101614, 2.40554940, 1.49768346, 0.19064830, 0.00000000]) >>> print(V) Tensor(shape=[5, 5], dtype=float64, place=Place(cpu), stop_gradient=True, [[ 0.58339481, -0.17143771, 0.00522143, 0.57976310, 0.54231640], [ 0.22334335, 0.72963474, -0.30148399, -0.39388750, 0.41438019], [ 0.05416913, 0.34666487, 0.93549758, 0.00063507, 0.04162998], [-0.39519094, 0.53074980, -0.16687419, 0.71175586, -0.16638919], [-0.67131070, -0.19071018, 0.07795789, -0.04615811, 0.71046714]]) rrNrrrrrrrTr)rrrNrDrMrrmean)r)rcenterrrTrrCs rZ pca_lowrankr s~   A  9$q'CDD WWRS\FQy 1L1fc!i!//21yk ;   QJ75')GHII 1u55 B%A qua 55r[c[5(a[R"X5$[USSS/S5 [ US[ S5 [ S 0[5D6nURURS9nURSSU0SU0SU0S 9 U$) a Computes the n-th power of a square matrix or a batch of square matrices. Let :math:`X` be a square matrix or a batch of square matrices, :math:`n` be an exponent, the equation should be: .. math:: Out = X ^ {n} Specifically, - If `n > 0`, it returns the matrix or a batch of matrices raised to the power of `n`. - If `n = 0`, it returns the identity matrix or a batch of identity matrices. - If `n < 0`, it returns the inverse of each matrix (if invertible) raised to the power of `abs(n)`. Args: x (Tensor): A square matrix or a batch of square matrices to be raised to power `n`. Its shape should be `[*, M, M]`, where `*` is zero or more batch dimensions. Its data type should be float32 or float64. n (int): The exponent. It can be any positive, negative integer or zero. 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 n-th power of the matrix (or the batch of matrices) `x`. Its data type should be the same as that of `x`. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2, 3], ... [1, 4, 9], ... [1, 8, 27]], dtype='float64') >>> print(paddle.linalg.matrix_power(x, 2)) Tensor(shape=[3, 3], dtype=float64, place=Place(cpu), stop_gradient=True, [[6. , 34. , 102.], [14. , 90. , 282.], [36. , 250., 804.]]) >>> print(paddle.linalg.matrix_power(x, 0)) Tensor(shape=[3, 3], dtype=float64, place=Place(cpu), stop_gradient=True, [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]) >>> print(paddle.linalg.matrix_power(x, -2)) Tensor(shape=[3, 3], dtype=float64, place=Place(cpu), stop_gradient=True, [[ 12.91666667, -12.75000000, 2.83333333 ], [-7.66666667 , 8. , -1.83333333 ], [ 1.80555556 , -1.91666667 , 0.44444444 ]]) rRr.r/ matrix_powerrryr>r@rC)r) rrrrrrrrPrQrRrS)r)rrTrWrXs rZrr% sv""1(( wI.  1c3/8vx877agg7F8CL(   r[cgrrr)moderTs rZrrr s  r[cgrrrs rZrrz s r[c[5(a#[R"X5up4US:XaU$X44$[US/SQS5 [ US[ S5 [ S 0[5D6nURURS9nURURS9n0nXS'URSSU/0X4S.US 9 US:XaU$X44$) aY Computes the QR decomposition of one matrix or batches of matrices (backward is unsupported now). Args: x (Tensor): The input tensor. Its shape should be `[..., M, N]`, where ... is zero or more batch dimensions. M and N can be arbitrary positive number. The data type of x supports float, double, complex64, complex128. mode (str, optional): A flag to control the behavior of qr. Suppose x's shape is `[..., M, N]` and denoting `K = min(M, N)`: If mode = "reduced", qr op will return reduced Q and R matrices, which means Q's shape is `[..., M, K]` and R's shape is `[..., K, N]`. If mode = "complete", qr op will return complete Q and R matrices, which means Q's shape is `[..., M, M]` and R's shape is `[..., M, N]`. If mode = "r", qr op will only return reduced R matrix, which means R's shape is `[..., K, N]`. Default: "reduced". name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: If mode = "reduced" or mode = "complete", qr will return a two tensor-tuple, which represents Q and R. If mode = "r", qr will return a tensor which represents R. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]).astype('float64') >>> q, r = paddle.linalg.qr(x) >>> print(q) Tensor(shape=[3, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[-0.16903085, 0.89708523], [-0.50709255, 0.27602622], [-0.84515425, -0.34503278]]) >>> print(r) Tensor(shape=[2, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[-5.91607978, -7.43735744], [ 0. , 0.82807867]]) >>> # one can verify : X = Q * R ; rrRr^rrryr>)rrrC)r) rrrrrr rrPrQrRrS)r)rrTrrrWrGs rZrr s\yy! 3;H4K wI4  4d+.VX.  5 5AGG 5 D  5 5AGG 5 Df sQCj2B%   3;H4Kr[cgrrr)pivot get_infosrTs rZlur s  r[cgrrrs rZrr s %(r[cgrrrs rZrr s=@r[c^[5(a[R"X5upEnOw[US/SQS5 [ S 0[ 5D6nUR URS9nUR SS9nUR SS9n0nXS'URSSU0XEUS.US 9 U(aXEU4$XE4$) a Computes the LU factorization of an N-D(N>=2) matrix x. Returns the LU factorization(inplace x) and Pivots. low triangular matrix L and upper triangular matrix U are combined to a single LU matrix. Pivoting is done if pivot is set to True. P mat can be get by pivots: .. code-block:: text ones = eye(rows) #eye matrix of rank rows for i in range(cols): swap(ones[i], ones[pivots[i]]) return ones Args: X (Tensor): the tensor to factor of N-dimensions(N>=2). Its data type should be float32, float64, complex64, or complex128. pivot (bool, optional): controls whether pivoting is done. Default: True. get_infos (bool, optional): if set to True, returns an info IntTensor. 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: factorization (Tensor), LU matrix, the factorization of input X. pivots (IntTensor), the pivots of size(\*(N-2), min(m,n)). `pivots` stores all the intermediate transpositions of rows. The final permutation `perm` could be reconstructed by this, details refer to upper example. infos (IntTensor, optional), if `get_infos` is `True`, this is a tensor of size (\*(N-2)) where non-zero values indicate whether factorization for the matrix or each minibatch has succeeded or failed. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]).astype('float64') >>> lu,p,info = paddle.linalg.lu(x, get_infos=True) >>> print(lu) Tensor(shape=[3, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[5. , 6. ], [0.20000000, 0.80000000], [0.60000000, 0.50000000]]) >>> print(p) Tensor(shape=[2], dtype=int32, place=Place(cpu), stop_gradient=True, [3, 3]) >>> print(info) Tensor(shape=[], dtype=int32, place=Place(cpu), stop_gradient=True, 0) >>> P,L,U = paddle.linalg.lu_unpack(lu,p) >>> print(P) Tensor(shape=[3, 3], dtype=float64, place=Place(cpu), stop_gradient=True, [[0., 1., 0.], [0., 0., 1.], [1., 0., 0.]]) >>> print(L) Tensor(shape=[3, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[1. , 0. ], [0.20000000, 1. ], [0.60000000, 0.50000000]]) >>> print(U) Tensor(shape=[2, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[5. , 6. ], [0. , 0.80000000]]) >>> # one can verify : X = P @ L @ U ; rRr^rryrrr>)r@PivotsInfosrC)r) rrrrrrPrQrRrS) r)rrrTrr~inforWrGs rZrr sdii) t wI4 .VX.  6 6QWW 6 E  5 5E 5 B88u8Eg8d;  d{u r[c RURS:a![S[UR535eURS:a![S[UR535eURS:a![S[UR535eURSURS:wa+[SURSSURS35eURS URS:wa+[S URS SURS35eURS URS :wa+[S URS SURS 35e[ URS SURS S5n[ XRRS S 5nURS SU:XaUO.[ R "X[URSS 5-5nUS :XaUOSnURS S U:XaUO.[ R "X&[URS S 5-5nURS SU:XaUO.[ R "X[URSS 5-5nSUl[R"XX#5nU$)a Computes the solution x to the system of linear equations :math:`Ax = b` , given LU decomposition :math:`A` and column vector :math:`b`. Args: b (Tensor): Column vector `b` in the above equation. It has shape :math:`(*, m, k)`, where :math:`*` is batch dimensions, with data type float32, float64, complex64, or complex128. lu (Tensor): LU decomposition. It has shape :math:`(*, m, m)`, where :math:`*` is batch dimensions, that can be decomposed into an upper triangular matrix U and a lower triangular matrix L, with data type float32, float64, complex64, or complex128. pivots (Tensor): Permutation matrix P of LU decomposition. It has shape :math:`(*, m)`, where :math:`*` is batch dimensions, that can be converted to a permutation matrix P, with data type int32. trans (str, optional): The transpose of the matrix A. It can be "N" , "T" or "C", "N" means :math:`Ax=b`, "T" means :math:`A^Tx=b`, "C" means :math:`A^Hx=b`, default is "N". 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 same data type as the `b` and `lu`. Examples: .. code-block:: python >>> import paddle >>> import numpy as np >>> A = paddle.to_tensor([[3, 1], [1, 2]], dtype="float64") >>> b = paddle.to_tensor([[9, 8], [9, 8]], dtype="float64") >>> lu, p = paddle.linalg.lu(A) >>> x = paddle.linalg.lu_solve(b, lu, p) >>> paddle.allclose(A @ x, b) >>> print(x) Tensor(shape=[2, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[1.80000000, 1.60000000], [3.60000000, 3.20000000]]) rz-`b` dimension must be gather than 2, but got z.`lu` dimension must be gather than 2, but got rz2`pivots` dimension must be gather than 1, but got rz;the rows of `b` must be equal to the rows of `lu`, but got z and rz8`lu` shape[-1] must be equal to `lu` shape[-2], but got z<`pivots` shape[-1] must be equal to `lu` shape[-1], but got NNTT) r rNrLrMrrrrI stop_gradientrlu_solve)brpivotstransrT temp_shape batch_shaperXs rZrrK sZ vvz;CL> J   ww{>> import paddle >>> x = paddle.to_tensor([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]).astype('float64') >>> lu,p,info = paddle.linalg.lu(x, get_infos=True) >>> print(lu) Tensor(shape=[3, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[5. , 6. ], [0.20000000, 0.80000000], [0.60000000, 0.50000000]]) >>> print(p) Tensor(shape=[2], dtype=int32, place=Place(cpu), stop_gradient=True, [3, 3]) >>> print(info) Tensor(shape=[], dtype=int32, place=Place(cpu), stop_gradient=True, 0) >>> P,L,U = paddle.linalg.lu_unpack(lu,p) >>> print(P) Tensor(shape=[3, 3], dtype=float64, place=Place(cpu), stop_gradient=True, [[0., 1., 0.], [0., 0., 1.], [1., 0., 0.]]) >>> print(L) Tensor(shape=[3, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[1. , 0. ], [0.20000000, 1. ], [0.60000000, 0.50000000]]) >>> print(U) Tensor(shape=[2, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[5. , 6. ], [0. , 0.80000000]]) >>> # one can verify : X = P @ L @ U ; r:The shape of x should be (*, M, N), but received ndim is [ < 2]rzr)PmatLrrC)r) r rNrrrrrrPrQrRrS) r)rorrrTPrrrWr~lrrGs rZrr s4` vvzHPU V   vvzJ166(RW X  ""1FaQw  =   5FH5  5 5AGG 5 D  5 5AGG 5 D  5 5AGG 5 D!.o!.o(Q/  Qwr[c4[5(a[R"U5$[US/SQS5 [ S0[ 5D6nUR UR5nUR UR5nSU0nX4S.nURSXVS9 X44$)a Performs the eigenvalue decomposition of a square matrix or a batch of square matrices. Note: - If the matrix is a Hermitian or a real symmetric matrix, please use :ref:`api_paddle_linalg_eigh` instead, which is much faster. - If only eigenvalues is needed, please use :ref:`api_paddle_linalg_eigvals` instead. - If the matrix is of any shape, please use :ref:`api_paddle_linalg_svd`. - This API is only supported on CPU device. - The output datatype is always complex for both real and complex input. Args: x (Tensor): A tensor with shape math:`[*, N, N]`, The data type of the x should be one of ``float32``, ``float64``, ``complex64`` or ``complex128``. 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: Eigenvalues(Tensor): A tensor with shape math:`[*, N]` refers to the eigen values. Eigenvectors(Tensor): A tensor with shape math:`[*, N, N]` refers to the eigen vectors. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1.6707249, 7.2249975, 6.5045543], ... [9.956216, 8.749598, 6.066444 ], ... [4.4251957, 1.7983172, 0.370647 ]]) >>> w, v = paddle.linalg.eig(x) >>> print(v) Tensor(shape=[3, 3], dtype=complex64, place=Place(cpu), stop_gradient=True, [[ (0.5061365365982056+0j) , (0.7971761226654053+0j) , (0.1851806491613388+0j) ], [ (0.8308236598968506+0j) , (-0.3463813066482544+0j) , (-0.6837005615234375+0j) ], [ (0.23142573237419128+0j), (-0.49449989199638367+0j), (0.7058765292167664+0j) ]]) >>> print(w) Tensor(shape=[3], dtype=complex64, place=Place(cpu), stop_gradient=True, [ (16.50470733642578+0j) , (-5.503481388092041+0j) , (-0.21026138961315155+0j)]) r>r^eig Eigenvalues Eigenvectorsr)r) rrrrrrPrQrRrS)r)rTrWrJvrErFs rZrrsZzz!} sEu /fh/  5 5agg >  5 5agg >q"#7eFDt r[c[UR5n[U5S:a[S[U5SU35eUSUS:wa[SU35e[ 5(a[ R "U5$[US/SQS 5 [S0[5D6nURURS 9nURS S U0S U0S 9 U$)a Compute the eigenvalues of one or more general matrices. Warning: The gradient kernel of this operator does not yet developed. If you need back propagation through this operator, please replace it with paddle.linalg.eig. Args: x (Tensor): A square matrix or a batch of square matrices whose eigenvalues will be computed. Its shape should be `[*, M, M]`, where `*` is zero or more batch dimensions. Its data type should be float32, float64, 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, A tensor containing the unsorted eigenvalues which has the same batch dimensions with `x`. The eigenvalues are complex-valued even when `x` is real. Examples: .. code-block:: python >>> import paddle >>> paddle.seed(2023) >>> x = paddle.rand(shape=[3, 3], dtype='float64') >>> print(x) Tensor(shape=[3, 3], dtype=float64, place=Place(cpu), stop_gradient=True, [[0.86583615, 0.52014721, 0.25960938], [0.90525323, 0.42400090, 0.40641288], [0.97020893, 0.74437359, 0.51785128]]) >>> print(paddle.linalg.eigvals(x)) Tensor(shape=[3], dtype=complex128, place=Place(cpu), stop_gradient=True, [ (1.788956694280852+0j) , (0.16364484879581526+0j), (-0.14491322408727625+0j)]) rzMThe dimension of Input(x) should be at least 2, but received x's dimension = z, x's shape = rrzNThe last two dimensions of Input(x) should be equal, but received x's shape = rRr^eigvalsryr>r@r)r) rIrMrLrNrrrrrrPrQrRrS)r)rTrYrWrXs rZrrYsL177mG 7|a[\_`g\h[iiwxxA B  r{gbk!\]d\e f  ~~a    =   3&(377agg7Fia5#,O r[c[5(a[R"U5$[US[[ 4S5 [ U5HLup#[US[U5-S-/SQS5 URUSR:wdMC[S5e [S 0[5D6nURSS9nURU5nURSS U0S U0S 9 U$) aY Multi_dot is an operator that calculates multiple matrix multiplications. Supports inputs of float16(only GPU support), float32 and float64 dtypes. This function does not support batched inputs. The input tensor in [x] must be 2-D except for the first and last can be 1-D. If the first tensor is a 1-D vector of shape(n, ) it is treated as row vector of shape(1, n), similarly if the last tensor is a 1D vector of shape(n, ), it is treated as a column vector of shape(n, 1). If the first and last tensor are 2-D matrix, then the output is also 2-D matrix, otherwise the output is a 1-D vector. Multi_dot will select the lowest cost multiplication order for calculation. The cost of multiplying two matrices with shapes (a, b) and (b, c) is a * b * c. Given matrices A, B, C with shapes (20, 5), (5, 100), (100, 10) respectively, we can calculate the cost of different multiplication orders as follows: - Cost((AB)C) = 20x5x100 + 20x100x10 = 30000 - Cost(A(BC)) = 5x100x10 + 20x5x10 = 6000 In this case, multiplying B and C first, then multiply A, which is 5 times faster than sequential calculation. Args: x (list[Tensor]): The input tensors which is a list Tensor. 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. Examples: .. code-block:: pycon >>> import paddle >>> # A * B >>> A = paddle.rand([3, 4]) >>> B = paddle.rand([4, 5]) >>> out = paddle.linalg.multi_dot([A, B]) >>> print(out.shape) paddle.Size([3, 5]) >>> # A * B * C >>> A = paddle.rand([10, 5]) >>> B = paddle.rand([5, 8]) >>> C = paddle.rand([8, 7]) >>> out = paddle.linalg.multi_dot([A, B, C]) >>> print(out.shape) paddle.Size([10, 7]) r) multi_dotzx[])r,r.r/r5rz:All the Tensors in the input must have the same data type.)input_param_namer>r@r)r)rrrrrIrJrOrr rRrrrPrrQrS)r)rTidr@rWrRrXs rZrrsn""1cD%=+6!! HB $s2w$;   zzQqTZZ'P%5FH5""C"877>c1Xs|   r[cpSn[5(d[5(aU"X5 [R"X5$U"X5 [ S 0[ 5D6n[ US/SQS5 URURS9nURURS9nURSSU0XVS.SU0S 9 XV4$) a Compute the eigenvalues and eigenvectors of a complex Hermitian (conjugate symmetric) or a real symmetric matrix. Args: x (Tensor): A tensor with shape :math:`[*, N, N]` , The data type of the input Tensor x should be one of float32, float64, complex64, complex128. UPLO (str, optional): (string, default 'L'), 'L' represents the lower triangular matrix, "'U' represents the upper triangular matrix.". Default: 'L'. 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: 2-element tuple containing - out_value(Tensor): A Tensor with shape :math:`[*, N]` and data type of float32 and float64. The eigenvalues of eigh op. - out_vector(Tensor): A Tensor with shape :math:`[*, N, N]` and data type of float32, float64, complex64 and complex128. The eigenvectors of eigh op. Examples: .. code-block:: pycon >>> import paddle >>> x = paddle.to_tensor([[1, -2j], [2j, 5]]) >>> out_value, out_vector = paddle.linalg.eigh(x, UPLO='L') >>> print(out_value) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [0.17157286, 5.82842731]) >>> print(out_vector) Tensor(shape=[2, 2], dtype=complex64, place=Place(cpu), stop_gradient=True, [[(-0.92387950+0.00000000j), (-0.38268340+0.00000000j)], [ (0.00000000+0.38268340j), (0.00000000-0.92387950j) ]]) c[UR5n[UR5S:a"[S[UR5S35eUSUS:wa[SU35eUS:waUS:wa[S U35egg NrzMInput(input) only support >=2 tensor, but received length of Input(input) is r<rrzQThe input matrix must be batches of square matrices. But received x's dimension: rrz+UPLO must be L or U. But received UPLO is: rIrMrLrNr)UPLOrYs rZrveigh..__check_inputqww- qwwrrrC)r) rrrrrrPrrQrRrS)r)rrTrvrW out_value out_vectors rZrrsP KMMa{{1## a0vx0  =   ==AGG=L >>QWW>M 8$-J4.  $$r[c  [5(GaU(Gd8[R"US5upEnURSS:XaUnO[R"US/S5n[ R "XRS9nX-n[S5n [ R "XRS9n [ R"XX:SU- SU - 5n [R"U S/5n [[[UR555n /U S SQU SPU SPn [R"Xm5nX-n[R"XSS5nU$[!5(a^UR"S:XaN[[[UR555n /U S SQU SPU SPn [R"X 5$[R$"US 5upT[ R&"U5n[R"US/S5n[ R "XRS9nX-n[S5n [ R "XRS9n [ R"UU:SU- SU - 5n [R"U S/5n XK-n[R("U5n[R"UUSS5nU$U(Gd[+S*0[-5D6nURn[/US S S/S 5 UR1U5nUR1U5nUR1U5nUR3SSU/0XFUS.SS0S9 UR1U5nUR3SSU0SU0S/SSS.S9 [5S/UUS9nX-n[S5n [5S/U US9n [ R"XX:SU- SU - 5n UR1US9n UR1US9nUR3SSU 0SS/0U US.S9 [[[UR555n /U S SQU SPU SPn UR1U5nUR1U5nUR3SSU/0U/U/S.SU 0S9 UR1U5nUR3SXS.SU0SS0S9 UR7U5nUR1U5nUR3S XS.SU0SSS!.S9 U$[+S*0[-5D6nURn[/US"/S#QS 5 U[ R8:XaSnOU[ R::XaS nOUnUR1U5nUR1U5nUR3S$SU0XTS%.S&S 0S9 UR1U5nUR3S'SU0SU0S(9 UR1U5nUR3SSU0SU0S/SSS.S9 [5S/UUS9nX-n[S5n [5S/U US9n [ R"UU:SU- SU - 5n UR1US9n UR1US9nUR3SSU 0SS/0U US.S9 UR1U5nUR3SXKS.SU0SS0S9 UR7U5nUR1U5nUR3S)SU0SU/0S(9 UR1U5nUR3S UUS.SU0SSS!.S9 U$)+aj Calculate pseudo inverse via SVD(singular value decomposition) of one matrix or batches of regular matrix. .. math:: if hermitian == False: x = u * s * vt (SVD) out = v * 1/s * ut else: x = u * s * ut (eigh) out = u * 1/s * u.conj().transpose(-2,-1) If x is hermitian or symmetric matrix, svd will be replaced with eigh. Args: x (Tensor): The input tensor. Its shape should be (*, m, n) where * is zero or more batch dimensions. m and n can be arbitrary positive number. The data type of x should be float32 or float64 or complex64 or complex128. When data type is complex64 or complex128, hermitian should be set True. rcond (Tensor|float, optional): the tolerance value to determine when is a singular value zero. Default:1e-15. hermitian (bool, optional): indicates whether x is Hermitian if complex or symmetric if real. Default: False. 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: The tensor with same data type with x. it represents pseudo inverse of x. Its shape should be (*, n, m). Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(15).reshape((3, 5)).astype('float64') >>> input = paddle.to_tensor(x) >>> out = paddle.linalg.pinv(input) >>> print(input) Tensor(shape=[3, 5], dtype=float64, place=Place(cpu), stop_gradient=True, [[0. , 1. , 2. , 3. , 4. ], [5. , 6. , 7. , 8. , 9. ], [10., 11., 12., 13., 14.]]) >>> print(out) Tensor(shape=[5, 3], dtype=float64, place=Place(cpu), stop_gradient=True, [[-0.22666667, -0.06666667, 0.09333333], [-0.12333333, -0.03333333, 0.05666667], [-0.02000000, -0.00000000, 0.02000000], [ 0.08333333, 0.03333333, -0.01666667], [ 0.18666667, 0.06666667, -0.05333333]]) # one can verify : x * out * x = x ; # or out * x * out = x ; FrrTryrrrNrpinvr)r.r/rr>rrrCrr@r)rM fill_valuerRrrr?)rDrErGrFr=rBelementwise_mulr matmul_v2)trans_xtrans_yrRr^rrrrrr7)r)rrrrMrrr?rRrwhererrIrrLr:r rsizerrr7rrPrrQrSr append_activationr7r6)r)rcondrbrTrrrmax_singular_valcutoffrosingularstr^r;rout_1out_2s_absu_conjrWrRst_shapev_shapes_types rZrr<sg@zz!U+HA"wwr{a#$ #)::a"t#< $$U'':E-Fe A  ''2A||AJAq1u=H!!(RD1Bc"((m,-D3T#2Y3R3$r(3D  *AFEMM%E48EL  QVVq[E#agg,/07cr7DH7d2h7''00;;q#&DAJJqME%zz%"t< $$U'':E-Fe A  ''2A||EFNAE1q5AH!!(RD1BFE[[^FMM%=EL 4684FGGE $Qi-CV L99%@A99%@A::5AB   aSz2&.   &HHO    !Qx 01!dEJ  suEBE-Fe AA31E:A||AJAq1u=H:::GB@@u@MH   !Xtn "h7  c"((m,-D3T#2Y3R3$r(3D99%@A??FG   !bT{!"y9tn  ==eDE   &(rl   ,,U3E==eDE    "+"'D9   L 4684FGGE $A  )))"&***"99%@A99&AA   Qx()=sm   ==fEE   C8eU^   &HHP    !U| 01!dEJ  suFCE-Fe AA31F;A||EFNAE1q5AH:::HB@@v@NH   !Xtn "h7  ==eDE   &(rl   ,,U3E>>uEF   S!Huvh6G  ==eDE    "0"'D9   Lr[cURSSn[UR5S:Xa3[SUS[UR5R S535eURSSnUSUS:wa[SUSU35eg)z=check the input shape of x and y for solve when left is FalserNrz]Incompatible shapes of X and Y for the equation Out * X = Y, where input X's matrix shape is z andinput Y's matrix shape is r)rMrLrNrIappend)r)rorYy_shapes rZ_check_right_solve_shaper :sggbclG 177|q //6i8))-agg)=)=a)@(A C  ''"#, 1: #33:)<--4I7  $r[c[[[UR555nUSUSsUS'US'[ X5nU$)z*transpose the last 2 dimension of a tensorrr)rIrrLrMr:)r) x_new_dimss rZ_transpose_last_2dimr#MsDeCL)*J%/^Z^"JrNJrN! A Hr[rcU(d![X5 [U5n[U5n[5(a[R"X5nOhU/U/S.n[ S 0[ 5D6n[USSS/S5 [USSS/S5 URURS9nURSXS.SU0S 9 U(d [W5nUb[R"WU5 W$) aa Computes the solution of a square system of linear equations with a unique solution for input 'X' and 'Y'. Let :math:`X` be a square matrix or a batch of square matrices, :math:`Y` be a vector/matrix or a batch of vectors/matrices. When `left` is True, the equation should be: .. math:: Out = X^-1 * Y When `left` is False, the equation should be: .. math:: Out = Y * X^-1 Specifically, this system of linear equations has one solution if and only if input 'X' is invertible. Args: x (Tensor): A square matrix or a batch of square matrices. Its shape should be ``[*, M, M]``, where ``*`` is zero or more batch dimensions. Its data type should be float32 or float64. Alias: ``A``. y (Tensor): A vector/matrix or a batch of vectors/matrices. Its shape should be ``[*, M, K]``, where ``*`` is zero or more batch dimensions. Its data type should be float32 or float64. Alias: ``B``. left (bool, optional): Whether to solve the system :math:`X * Out = Y` or :math:`Out * X = Y`. Default: True. 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: Tensor: The solution of a square system of linear equations with a unique solution for input 'x' and 'y'. Its data type should be the same as that of `x`. Examples: .. code-block:: python >>> # a square system of linear equations: >>> # 3*X0 + X1 = 9 >>> # X0 + 2*X1 = 8 >>> import paddle >>> x = paddle.to_tensor([[3, 1],[1, 2]], dtype="float64") >>> y = paddle.to_tensor([9, 8], dtype="float64") >>> out = paddle.linalg.solve(x, y) >>> print(out) Tensor(shape=[2], dtype=float64, place=Place(cpu), stop_gradient=True, [2., 3.]) rsolver)r.r/roryr@r)r%) r r#rrr%rrPrrQrRrSrr)r)roleftrTrXrrErWs rZr%r%Usr  &  #  #ll1 s!%11 C)Y)?I C)Y)?I77agg7Fq!1E3<   "3'  c3 Jr[c .[5(a[R"XX#U5$U/U/S.n[S 0[ 5D6n[ US/SQS5 [ US/SQS5 UR URS9nURSXS.SU0UUUS.S 9 U$) a Computes the solution of a system of equations with a triangular coefficient. `x` is coefficient matrix `y` is multiple right-hand sides of equations. Input `x` and `y` is 2D matrices or batches of 2D matrices. If the inputs are batches, the outputs is also batches. Equations can be described as: .. math:: x * Out = y Solution of Equations is: .. math:: Out = x ^ {-1} * y Args: x (Tensor): The input triangular coefficient matrix. Its shape should be `[*, M, M]`, where `*` is zero or more batch dimensions. Its data type should be float32, float64, complex64, complex128. y (Tensor): Multiple right-hand sides of system of equations. Its shape should be `[*, M, K]`, where `*` is zero or more batch dimensions. Its data type should be float32, float64, complex64, complex128. upper (bool, optional): Whether to solve the upper-triangular system of equations (default) or the lower-triangular system of equations. Default: True. transpose (bool, optional): whether `x` should be transposed before calculation. Default: False. unitriangular (bool, optional): whether `x` is unit triangular. If True, the diagonal elements of `x` are assumed to be 1 and not referenced from `x` . 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: Tensor: The solution of the system of equations. Its data type should be the same as that of `x`. Examples: .. code-block:: python >>> # a square system of linear equations: >>> # x1 + x2 + x3 = 0 >>> # 2*x2 + x3 = -9 >>> # -x3 = 5 >>> import paddle >>> x = paddle.to_tensor([[1, 1, 1], ... [0, 2, 1], ... [0, 0,-1]], dtype="float64") >>> y = paddle.to_tensor([[0], [-9], [5]], dtype="float64") >>> out = paddle.linalg.triangular_solve(x, y, upper=True) >>> print(out) Tensor(shape=[3, 1], dtype=float64, place=Place(cpu), stop_gradient=True, [[ 7.], [-2.], [-5.]]) rtriangular_solver)r^roryr@)r\r: unitriangularrC)r() rrr(rrPrrQrRrS) r)ror\r:r)rTrErWrXs rZr(r(s|&&qU}MMs!%<68<  =   !  =   77agg7F##CL&!.   r[c[5(a[R"XU5$[S 0[ 5D6n[ USSS/S5 [ USSS/S5 UR URS9nURSXS.SU0S U0S 9 U$) a Solves a linear system of equations A @ X = B, given A's Cholesky factor matrix u and matrix B. Input `x` and `y` is 2D matrices or batches of 2D matrices. If the inputs are batches, the outputs is also batches. Args: x (Tensor): Multiple right-hand sides of system of equations. Its shape should be `[*, M, K]`, where `*` is zero or more batch dimensions. Its data type should be float32 or float64. y (Tensor): The input matrix which is upper or lower triangular Cholesky factor of square matrix A. Its shape should be `[*, M, M]`, where `*` is zero or more batch dimensions. Its data type should be float32 or float64. upper (bool, optional): whether to consider the Cholesky factor as a lower or upper triangular matrix. 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: Tensor: The solution of the system of equations. Its data type is the same as that of `x`. Examples: .. code-block:: python >>> import paddle >>> u = paddle.to_tensor([[1, 1, 1], ... [0, 2, 1], ... [0, 0,-1]], dtype="float64") >>> b = paddle.to_tensor([[0], [-9], [5]], dtype="float64") >>> out = paddle.linalg.cholesky_solve(b, u, upper=True) >>> print(out) Tensor(shape=[3, 1], dtype=float64, place=Place(cpu), stop_gradient=True, [[-2.50000000], [-7. ], [ 9.50000000]]) cholesky_solver)r.r/roryrr@r\rC)r+) rrr+rrPrrQrRrS)r)ror\rTrWrXs rZr+r+sL$$Q511:: sY *,<  ! sY *,< 77agg7F!#CLE"   r[c[5(a%[R"XUR5up4U$Sn[ 5(a-U"X5 [R"XUR5up4U$U"X5 [ S 0[ 5D6n[US/SQS5 URURS9nURURS9nURn URSSU0XxS.XS.S 9 U$) a Computes the eigenvalues of a complex Hermitian (conjugate symmetric) or a real symmetric matrix. Args: x (Tensor): A tensor with shape :math:`[*, M, M]` , where * is zero or greater batch dimension. The data type of the input Tensor x should be one of float32, float64, complex64, complex128. UPLO(str, optional): Lower triangular part of a ('L', default) or the upper triangular part ('U'). 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: The tensor eigenvalues in ascending order. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, -2j], [2j, 5]]) >>> out_value = paddle.eigvalsh(x, UPLO='L') >>> print(out_value) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [0.17157286, 5.82842731]) c[UR5n[UR5S:a"[S[UR5S35eUSUS:wa[SU35eUS:waUS:wa[S U35eggrrrs rZrveigvalsh..__check_input`rr[eigvalshrRr^ryr>r)ris_testrC)r/) rrr/rrrrPrrQrRrS) r)rrTvalues_rvrWrrr0s rZr/r/@s8OOAQ__=   }}aOOAQ__=   a4684  =   ==AGG=L >>QWW>M //8$-J4  r[c [R"5nUS:XaUS;a[SU35eUcSOUnO=URS5(aUS;a[SU35eUcSOUnO [ S 5eUR UR :XaUR [R [R[RRRR[RRRR4;d [S 5eURS :a[S URS 35eURS :a[SURS 35eURSURS:wa,[SURSSURSS35eUGcUR [R :Xd<UR [RRRR:Xa*S[URSURS5-nOUR [R:Xd<UR [RRRR:Xa)S[URSURS5-n[!5(a["R$"XX#5upgpUS:Xa7[R&"S/SS9n[R&"S/UR S9n O&US:Xa [R&"S/UR S9n XgX4$[)S$0[+5D6n [-US/SQS5 [-US/SQS5 U R/UR S9nU R/UR S9nU R/[R0S9nU R/UR S9n U R3SXS.UUUU S.X#S.S 9 US:Xa?[R4R7S!S/S"9n[R4R7S#S/S"9n O%US:Xa[R4R7S#S/S"9n XgX4$)%a7 Computes a solution to the least squares problem of a system of linear equations. Args: x (Tensor): A tensor with shape ``(*, M, N)`` , the data type of the input Tensor ``x`` should be one of float32, float64. y (Tensor): A tensor with shape ``(*, M, K)`` , the data type of the input Tensor ``y`` should be one of float32, float64. rcond(float, optional): The default value is None. A float pointing number used to determine the effective rank of ``x``. If ``rcond`` is None, it will be set to max(M, N) times the machine precision of x_dtype. driver(str, optional): The default value is None. The name of LAPACK method to be used. For CPU inputs the valid values are 'gels', 'gelsy', 'gelsd, 'gelss'. For CUDA input, the only valid driver is 'gels'. If ``driver`` is None, 'gelsy' is used for CPU inputs and 'gels' for CUDA inputs. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tuple: A tuple of 4 Tensors which is (``solution``, ``residuals``, ``rank``, ``singular_values``). ``solution`` is a tensor with shape ``(*, N, K)``, meaning the least squares solution. ``residuals`` is a tensor with shape ``(*, K)``, meaning the squared residuals of the solutions, which is computed when M > N and every matrix in ``x`` is full-rank, otherwise return an empty tensor. ``rank`` is a tensor with shape ``(*)``, meaning the ranks of the matrices in ``x``, which is computed when ``driver`` in ('gelsy', 'gelsd', 'gelss'), otherwise return an empty tensor. ``singular_values`` is a tensor with shape ``(*, min(M, N))``, meaning singular values of the matrices in ``x``, which is computed when ``driver`` in ('gelsd', 'gelss'), otherwise return an empty tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 3], [3, 2], [5, 6.]]) >>> y = paddle.to_tensor([[3, 4, 6], [5, 3, 4], [1, 2, 1.]]) >>> results = paddle.linalg.lstsq(x, y, driver="gelsd") >>> print(results[0]) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.78350395, -0.22165027, -0.62371236], [-0.11340097, 0.78866047, 1.14948535]]) >>> print(results[1]) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [19.81443405, 10.43814468, 30.56185532]) >>> print(results[2]) Tensor(shape=[], dtype=int32, place=Place(cpu), stop_gradient=True, 2) >>> print(results[3]) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [9.03455734, 1.54167950]) >>> x = paddle.to_tensor([[10, 2, 3], [3, 10, 5], [5, 6, 12.]]) >>> y = paddle.to_tensor([[4, 2, 9], [2, 0, 3], [2, 5, 3.]]) >>> results = paddle.linalg.lstsq(x, y, driver="gels") >>> print(results[0]) Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.39386186, 0.10230169, 0.93606132], [ 0.10741688, -0.29028130, 0.11892584], [-0.05115093, 0.51918161, -0.19948851]]) >>> print(results[1]) Tensor(shape=[0], dtype=float32, place=Place(cpu), stop_gradient=True, []) cpu)Ngelsgelssgelsdgelsyz_Only support valid driver is 'gels', 'gelss', 'gelsd', 'gelsy' or None for CPU inputs. But got r8gpu)Nr5zEOnly support valid driver is 'gels' or None for CUDA inputs. But got r5z.Only support lstsq api for CPU or CUDA device.zIOnly support x and y have the same dtype such as 'float32' and 'float64'.rrrz:The shape of y should be (*, M, K), but received ndim is [rzx with shape (*, M = z, N) and y with shape (*, M = z, K) should have same M.gHz>rV瞯vKLL 177 GG NN NN KK   % % - - KK   % % - -    W   vvzHPU V   vvzHPU V   wwr{aggbk!#AGGBK=0NqwwWY{m[s t   } GGv~~ %ww&++**33;;;3qwwr{AGGBK88E GGv~~ %ww&++**33;;;C QWWR[99E5;\\ %6 2T V <>> import paddle >>> paddle.seed(2023) >>> xt = paddle.rand((3,4)) >>> print(paddle.linalg.corrcoef(xt)) Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.99999988, -0.47689581, -0.89559376], [-0.47689593, 1. , 0.16345492], [-0.89559382, 0.16345496, 1. ]]) rrz_Input(x) only support N-D (1<=N<=2) tensor in corrcoef, but received length of Input(input) is r<rRr.r/corrcoefrNr)rLrMrNrr:r rdiagrrealsqrtcomplexrAimag)r)rDrTcrstddevs rZrPrPFs:L 177|a3qwwUS :XdUS :XGa1US:dU S:Ga$[R"URS5SSS9n [R"URS5SSS9n [R"U/[UR S- 5QUR S - PUR S- PS9n [R"U /[U R S- 5QU R S - PU R S- PS9n[R""X 5S-U-U -n[R$"USS9R'5nU$[R(R+USS S S 24USS S S 2S S 24- USS!9$)"a Compute the p-norm distance between each pair of the two collections of inputs. This function is equivalent to `scipy.spatial.distance.cdist(input,'minkowski', p=p)` if :math:`p \in (0, \infty)`. When :math:`p = 0` it is equivalent to `scipy.spatial.distance.cdist(input, 'hamming') * M`. When :math:`p = \infty`, the closest scipy function is `scipy.spatial.distance.cdist(xn, lambda x, y: np.abs(x - y).max())`. Args: x (Tensor): A tensor with shape :math:`B \times P \times M`. y (Tensor): A tensor with shape :math:`B \times R \times M`. p (float, optional): The value for the p-norm distance to calculate between each vector pair. Default: :math:`2.0`. compute_mode (str, optional): The mode for compute distance. - ``use_mm_for_euclid_dist_if_necessary`` , for p = 2.0 and (P > 25 or R > 25), it will use matrix multiplication to calculate euclid distance if possible. - ``use_mm_for_euclid_dist`` , for p = 2.0, it will use matrix multiplication to calculate euclid distance. - ``donot_use_mm_for_euclid_dist`` , it will not use matrix multiplication to calculate euclid distance. Default: ``use_mm_for_euclid_dist_if_necessary``. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, the dtype is same as input tensor. If x has shape :math:`B \times P \times M` and y has shape :math:`B \times R \times M` then the output will have shape :math:`B \times P \times R`. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[0.9041, 0.0196], [-0.3108, -2.4423], [-0.4821, 1.059]], dtype=paddle.float32) >>> y = paddle.to_tensor([[-2.1763, -0.4713], [-0.6986, 1.3702]], dtype=paddle.float32) >>> distance = paddle.cdist(x, y) >>> print(distance) Tensor(shape=[3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[3.11927032, 2.09589314], [2.71384072, 3.83217239], [2.28300953, 0.37910119]]) r)r.r/cdistror~)#use_mm_for_euclid_dist_if_necessaryuse_mm_for_euclid_distdonot_use_mm_for_euclid_distzThe compute_mode should be 'use_mm_for_euclid_dist_if_necessary', 'use_mm_for_euclid_dist' or 'donot_use_mm_for_euclid_dist', but received compute_mode is r<rr[r\rr]rzLThe x must be at least 2-dimensional, But received Input x's dimensional is rzLThe y must be at least 2-dimensional, But received Input y's dimensional is rzTThe x and y must have same last dimension, But received Input x's last dimension is z, Input y's last dimension is z <  D<< 1 1 7 7177mG w<1  114Wc C 177mG w<1  114Wc C  2;'"+ % 44;BK=A''.r{m3 8 % 6 FqcM6 B B B aA Qw"'||RHAGG44 Qw||RHAGG44CxTQY419"r'R"WAEE!H2t<AEE!H2t<'' @eAFFQJ'@!@QVVaZ@ #,, L5q)L6;;?LFKK!OL mmA,r14EENkk#3',,. ==   #tQ,!Cq!O,,  r[c [URS/SQS5 [URS/SQS5 URUR:XdS5e[UR5S:aH[UR5S:a/[UR5[UR5S-:XdS5eURS URS :dS 5eURS URS :dS 5e[ URS S 5H,up4URUURU:XaM'S5e Sn[UR5S:XaU"X5$URS S upgURnURn UR S US US 45nUR S U S 45nURSn [ R"XU/URS9n [U 5HNn [5(aU"X X5X'M#[ RRXU"X X55n MP U R U5n U $)a# Computes the first n columns of a product of Householder matrices. This function can get the vector :math:`\omega_{i}` from matrix `x` (m x n), the :math:`i-1` elements are zeros, and the i-th is `1`, the rest of the elements are from i-th column of `x`. And with the vector `tau` can calculate the first n columns of a product of Householder matrices. :math:`H_i = I_m - \tau_i \omega_i \omega_i^H` Args: x (Tensor): A tensor with shape (*, m, n) where * is zero or more batch dimensions. tau (Tensor): A tensor with shape (*, k) where * is zero or more batch dimensions. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, the dtype is same as input tensor, the Q in QR decomposition. :math:`out = Q = H_1H_2H_3...H_k` Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[-1.1280, 0.9012, -0.0190], ... [ 0.3699, 2.2133, -1.4792], ... [ 0.0308, 0.3361, -3.1761], ... [-0.0726, 0.8245, -0.3812]]) >>> tau = paddle.to_tensor([1.7497, 1.1156, 1.7462]) >>> Q = paddle.linalg.householder_product(x, tau) >>> print(Q) Tensor(shape=[4, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[-0.74969995, -0.02181768, 0.31115776], [-0.64721400, -0.12367040, -0.21738708], [-0.05389076, -0.37562513, -0.84836429], [ 0.12702821, -0.91822827, 0.36892807]]) r)rhouseholder_producttauz5The input x must have the same dtype with input tau. rrzThe input x must have more than 2 dimensions, and input tau must have more than 1 dimension,and the dimension of x is 1 larger than the dimension of tau rrzMThe rows of input x must be greater than or equal to the columns of input x. z,The last dim of x must be greater than tau. Nz@The input x must have the same batch dimensions with input tau. c URSSup#URSn[R"U5RUR5n[ [ XC55GHnXS2U4n[5(aSUS'O![RRUSS5nURSS/5n[5(aUR[R[R4;aKUSS2US24USS2US24U-[R"U5R-X-- USS2US24'MUSS2US24USS2US24U-UR-X-- USS2US24'GM[RRU[S5[US54UR[R[R4;a,USS2US24USS2US24U-UR-X-- O+USS2US24USS2US24U-UR-X-- 5nGM USS2SU24$)Nrrrr)rMreyerrRrrrrJsetitemr%r7r6r7rslice)r)rjrrkrrrJs rZ_householder_product1householder_product.._householder_product_swwrs| IIbM JJqM  )s1y!A"a%A  !MM))!Q2 2q'"A  77v00&2B2BCC ABx!QR%1 v{{1~'7'77#&@ AaeH !ABx1QU8a@rrrrrv) ryrzr{mat_a4rRrr)r2r-r|r}s rZ_matrix_exp_pade5rs 0A    + + - -01 21V[[Q & 2 ~)%E: Q4&= 1Q4%< /C MM% %E aD6MAaD6M )AaD5L 8E < 3s!B'c|/SQn[RR5(d'UVs/sHn[R"SXu5PM nnUc[ USU5tp#pHXFSU--USU--USU--n [R "X 5n USU-USU--USU--US U--n X4$s snf) z7th-order Pade approximant.)g~pAg~`Ag@t>Ag@Ag@g@gL@rrrrrrrrv) ryrzr{rmat_a6rRrr)r2r-r|r}s rZ_matrix_exp_pade7rs LA    + + - -01 21V[[Q & 2 ~%1%E%B" Q4&= 1Q4&= 01Q4%< ?C MM% %E aD6MAaD6M )AaD6M 9AaD5L HE < 3s!B9c/SQn[RR5(d'UVs/sHn[R"SX5PM nnUc[ USU5tp#pEn XWSU--USU--USU--USU--n [R "X 5n USU-USU--US U--US U--US U--n X4$s snf) z9th-order Pade approximant.) gynBgynBgAg@ Ag2|Ag~@Ag@g@gV@rrrrrrrrrv) ryrzr{rrmat_a8rRrr)r2r-r|r}s rZ_matrix_exp_pade9rs A    + + - -01 21V[[Q & 2 ~-9%E-J* Q4&= 1Q4&= 01Q4&= @1Q4%< OC MM% %E !v A$-  A$-  A$-  A$,    < 3s!C c>/SQn[RR5(d'UVs/sHn[R"SXu5PM nnUc[ USU5tp#pH[R "XDUSU--USU--5USU--USU--USU--US U--n [R "X 5n US U-US U--US U--n [R "XK5USU--US U--USU--USU--n X4$s snf)z13th-order Pade approximant.) gD`lCgD`\Cg`=Hb;Cg eCgJXBg"5Bg/cBg\L8BgpķAgsyAgS-Ag@gf@rr r(rrrr rrrrrv) ryrzr{rrrRrr)r2tmp_ur|tmp_vr}s rZ_matrix_exp_pade13rsc A    + + - -01 21V[[Q & 2 ~%1%E%B"  fquv~5!v EF A$-  A$-  A$-  A$,    MM% 'E bEFNQrUV^ +adVm ;E f$ A$-  A$-  A$-  A$,    <+ 3s!Dc [U5S:Xa5[R"[R"X S5USUS5$[R"[R"X S5US[ USSUSSU55$)Nrr)rLrr less_than_matrix_uv_where)valscasesl1_norms rZrrs 4yA~||   W1g .a%(  ||   W1g . !H T!"XuQRy' :  r[c[R"X5nSnSnSnUS:a[R"X35nUS:a[R"XC5nUS:a[R"XS5nX4XV4$)Nrrr)rr )rytotalrRr{rrrs rZrxrx$si ]]5 (F F F F qyv. qyv. qyv. 6 ))r[c [R"URSUS9n[USU5tpVn[ XXSS9up[ XXVUS9up[ U[R"[R"[R"SSU5U5U5- UUS9up[R"SSU5[R"SSU54n[XX4U5n[XX4U5nUU4$)Nrryrrrg#"ՀA?gNj?) rrlrMrxr~rrr!rr r)ryr squaringsrRrzr{rr2u3v3u5v5u7v7condsrrs rZ_matrix_uv_float32r6s JJu{{2e 4E%eQ6FQ uV AFB uV5 IFB  ++ JJv{{2sE2I >   FB  B.6 B-u5 E R g6AR g6A a4Kr[c z[R"URSUS9n[USU5tpVpxn [ XXSS9up[ XXVUS9up[ XXVXsS9up[XXVXxUS9unn[U[R"[R"[R"SSU5U5U5- UUS9unn[R"SSU5[R"SSU5[R"SSU5[R"SS U54n[UXUUU4U5n[UXUUU4U5nUU4$) Nrryrrrg,?g|zی@?gQi?g d@) rrlrMrxr~rrrrr!rr r)ryrrrRrzr{rrrr2rrrrrru9v9u13v13rrrs rZ_matrix_uv_float64rPsI JJu{{2e 4E)5eQ)F&FFQ uV AFB uV5 IFB  ffFB ffEFB" ++ JJv{{2sE2I >   HC  B.6 B.6 B.6 B-u5  E R 5w?AR 5w?A a4Kr[c ^ ^ ^ ^ ^^^[U[R[RRR [RR RR45(d[R"U5m OUm [T R5m T S;a[ST 35eT RS:Xa[R"T 5$T RS:a [S5eT RST RS:wa [S5e[!T RSS 5S S /:Xa[R"T 5$[R""[R$"[R&"[R("T 5T RS- S 9SS 9SS/S 9n[R*"T RST 5mS nT S :Xa[R*"S ST 5n[R,"[R."X$- 5[R."[R*"S ST 55- 5m[R0"T[R2"T55m[4nOT S:Xa[R*"S ST 5n[R,"[R."X$- 5[R."[R*"S ST 55- 5m[R0"T[R2"T55m[6nU"T UTT 5umm[R8"[R$"U55m [R:R<R?T UU4SjU U 4Sj5n[R$"T5m [R*"S ST 5nU U 4SjnU4Sjn[R:R<RAXxXe/5upU$)a Computes the matrix exponential of square matrices. .. math:: exp(A) = \sum_{n=0}^\infty A^n/n! The input tensor x should be of square matrices with shape like :math:`(*, M, M)`, and the exponential output is computed by Pade approximation of the scaling and squaring method. [1] Nicholas J. Higham, The scaling and squaring method for the matrix exponential revisited. Args: x (Tensor): A tensor with shape :math:`(*, M, M)` where :math:`*` is zero or more batch dimensions. The data type should be one of float32, float64. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, the shape and dtype are same as input tensor. Examples: .. code-block:: python >>> import paddle >>> mat_a = paddle.empty((2, 2, 2)) >>> mat_a[0, :, :] = paddle.eye(2, 2) >>> mat_a[1, :, :] = 2 * paddle.eye(2, 2) >>> print(mat_a) Tensor(shape=[2, 2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1., 0.], [0., 1.]], [[2., 0.], [0., 2.]]]) >>> out = paddle.linalg.matrix_exp(mat_a) >>> print(out) Tensor(shape=[2, 2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[2.71828198, 0. ], [0. , 2.71828198]], [[7.38905621, 0. ], [0. , 7.38905621]]]) >>> import math >>> mat_a = paddle.to_tensor([[0, math.pi/3], [-math.pi/3, 0]]) >>> out = paddle.linalg.matrix_exp(mat_a) >>> print(out) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.49999994, 0.86602545], [-0.86602551, 0.50000000]]) rYz=The input tensor's dtype must be float32 or float64, but got rrz1The input tensor must be at least two-dimensionalrrz.Last 2 dimensions of the tensor must be squareNrr6r.rgj%eg@rr/gC|@cR>[RRT*T-TT-5$r)rrr%)rrsrZrmatrix_exp..s  ##QBFAE2r[cd>[R"TR[RT5$r)rr rMrnan)rRrysrZrrs EKK7r[ch>^[RRRTUU4SjS5$)Nc2>[R"TT5$r)rr)r max_squaringsrZr*matrix_exp..cond..sF$$Q 5r[cJ[R"SS[RS9$)NrFry)rr r+rr[rZrrsFKKE=r[)rrJnnr4)rr2 is_finiters` rZr4matrix_exp..conds)}}$$  5 =  r[c>US-[R"[R"UT5[R"X5U54$r)rrrr )rrrs rZbodymatrix_exp..bodys>1ufll   Q * MM& )    r[)!rKrr$rErwr libpaddlerhrir?rrRrNr exprMrIrrrrr floorlogmaximum zeros_likerrisfiniterJrr4 while_loop)r)rTr_matrix_uv_funcmaxnormrrr4rr2rRrryrrrrs @@@@@@@rZ matrix_exprssl  MM KK ! ! * * KK ! ! % % + +     # %++ &E **KE7 S   zzQzz%   zzA~LMM {{2%++b/)IJJ EKK !Q'zz%   6::fjj/ejj1nEBO"XG  EKKE2IO ++b"3U;LL JJw( )jjRe45 6 NN9f.?.? .JK , ) ++b"3U;LL JJw( )jjRe45 6 NN9f.?.? .JK , 5'9e >> import paddle >>> x = paddle.to_tensor([[0., 1.], [1., 0.], [2.,0.], [2., 2.]]) >>> bins = [3,3] >>> weights = paddle.to_tensor([1., 2., 4., 8.]) >>> paddle.histogramdd(x, bins=bins, weights=weights) (Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[0., 1., 0.], [2., 0., 0.], [4., 0., 8.]]), [Tensor(shape=[4], dtype=float32, place=Place(gpu:0), stop_gradient=True, [0. , 0.66666669, 1.33333337, 2. ]), Tensor(shape=[4], dtype=float32, place=Place(gpu:0), stop_gradient=True, [0. , 0.66666669, 1.33333337, 2. ])]) .. code-block:: python :name: examp2 >>> import paddle >>> y = paddle.to_tensor([[0., 0.], [1., 1.], [2., 2.]]) >>> bins = [2,2] >>> ranges = [0., 1., 0., 1.] >>> density = True >>> paddle.histogramdd(y, bins=bins, ranges=ranges, density=density) (Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[2., 0.], [0., 2.]]), [Tensor(shape=[3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [0. , 0.50000000, 1. ]), Tensor(shape=[3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [0. , 0.50000000, 1. ])]) cd[UR5S:dS5e[USSS/S5 g)Nrz4input x must be a tensor with at least 2 dimensions.r)r.r/ histogramdd)rLrMrrs rZ __check_xhistogramdd..__check_xHsB177|q  B   !    r[cUHJn[R"U5n[USSS/S5 URUR:XaMES5e g)Nrsr.r/rz@When bins is Tensor[], the dtype of bins must be the same as x. )rr?rrR)rsr) bins_tensors rZ __check_bins!histogramdd..__check_binsVs^K **;7K $ $$/ S / r[c*UcgURURp2[U5[U5S-:XdS5e[U5HupEX4X$:XaMS5e [USSS/S5 URUR:XdS5eg)Nrzrif weight tensor is provided,it should have the same shape as the input tensor excluding its innermost dimension. rr.r/rz,The dtype of weights must be the same as x. )rMrLrOrrR)r)rrY weights_shaperr2s rZ__check_weights$histogramdd..__check_weightsfs ? !"'--7|s=1A55  e 5m,DA #wz1 i 1- !     }}' ; 'r[c|Ucg[US[[4S5 US-[U5:XdSUS-S35eg)Nrangesrrz"The length of ranges list must be  )rrIrJrL)Drs rZ__check_ranges#histogramdd..__check_rangessI > 68dE]MB1uF # 0Qr : #r[c4[R"USSS25RSS9RS5SSn[R"U[R"S/UR S9/5n[R "USS9nX2-RSS9nU$)Nrr)rVrryr6)rr?cumprodflipr(rRstackr) index_list hist_shapestridesstacked_indicesflattened_indexs rZ__compute_flattened_index.histogramdd..__compute_flattened_indexs"":dd#34<<<CHHKABO-- f&&s'--@ A !,,z;*499r9Br[rtrrrNzThe size of weight must be rryr6rzThe length of bins must be z when bins is a list. z The type of z%-th element in bins list must be int.z+Input bins must be Tensor[], int[], or int.T)right)r)rr+rMr%rrRrr*rrrrJrmrnr?rKrrIrLrOrNr{rdiffrJ searchsortedrrr}r'r)"r)rsrrtrrTrrrrrrreshaped_inputrreshaped_weightsmaxvminvedgesrdedgesrUrebinredgeron_edge index_list_irhistrFrrMs" rZrr s |    4  w 47 aLA  AYYAw'NQA..)"??A3/%%a(A-P1LQC/PP-1 ~q!fAGG4zz.q1992$?zz.q1992$?  ! ! # #F1a4L1a4L]]**6E$K3CTJF]]**6E$K3CTJF!!&8@@!QH EJ F$d $$ dC 6A:D4yA~ )!,C D ~ 'FCd3i-- "3%'LM!adDIM177CA LLO MM!&&( #   d3i!m ,(  e   TC""3'C LL  MM#((* %   ciilQ. /  FGGJu% T%   nQV&>> import paddle >>> import numpy as np >>> from paddle import linalg >>> input = paddle.to_tensor([[-114.6, 10.9, 1.1], [-0.304, 38.07, 69.38], [-0.45, -0.17, 62]]) >>> tau = paddle.to_tensor([1.55, 1.94, 3.0]) >>> y = paddle.to_tensor([[-114.6, 10.9, 1.1], [-0.304, 38.07, 69.38], [-0.45, -0.17, 62]]) >>> output = linalg.ormqr(input, tau, y) >>> print(output) Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 63.82712936 , -13.82312393 , -116.28614044], [-53.65926361 , -28.15783691 , -70.42700958 ], [-79.54292297 , 24.00182915 , -41.34253311 ]]) rorormqrr&r:z9The input tau and y must have the same dtype with the x. rrzaThe input x and y must have more than 2 dimensions, and input tau must have more than 1 dimensionzsthe dimension of x is 1 larger than the dimension of tau and the dimension of x is equal to the dimension of inputrz7The innermost dimension of x and tau should be the samerz0The row dimensions of x and y should be the samezGThe column dimension of x and the row dimension of y should be the samezGThe row dimension of x and the column dimension of y should be the samezA- -#agg,# C3   772;#))B- 'A 'Twwr{aggbk) > )4wwr{aggbk) U ) 4wwr{aggbk) U )wwr{aggbk) J ) 177|qwwqzQWWQZ'AGGAJ#))A,,F K F A#A 177|qACC!.7F  Q *Q!VA\F M(.a|F Mr[cURS:wa [S5eURSURS:wa [S5eU(aURU-nOXR-n[R R U5$)a Using the Cholesky factor `U` to calculate the inverse matrix of a symmetric positive definite matrix, returns the matrix `inv`. If `upper` is `False`, `U` is lower triangular matrix: .. math:: inv = (UU^{T})^{-1} If `upper` is `True`, `U` is upper triangular matrix: .. math:: inv = (U^{T}U)^{-1} Args: x (Tensor): A tensor of lower or upper triangular Cholesky decompositions of symmetric matrix with shape `[N, N]`. The data type of the `x` should be one of ``float32``, ``float64``. upper (bool, optional): If `upper` is `False`, `x` is lower triangular matrix, or is upper triangular matrix. Default: `False`. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor. Computes the inverse matrix. Examples: .. code-block:: python >>> import paddle >>> # lower triangular matrix >>> x = paddle.to_tensor([[3.,.0,.0], [5.,3.,.0], [-1.,1.,2.]]) >>> out = paddle.linalg.cholesky_inverse(x) >>> print(out) Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[ 0.61728382, -0.25925916, 0.22222219], [-0.25925916, 0.13888884, -0.08333331], [ 0.22222218, -0.08333331, 0.25000000]]) >>> # upper triangular matrix >>> out = paddle.linalg.cholesky_inverse(x.T, upper=True) >>> print(out) Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[ 0.61728382, -0.25925916, 0.22222219], [-0.25925916, 0.13888884, -0.08333331], [ 0.22222218, -0.08333331, 0.25000000]]) rz&The input tensor must be 2-dimensionalrrz&The input tensor must be square matrix)r rNrMrrrinv)r)r\rTr s rZcholesky_inverser]spd vv{ABBwwqzQWWQZABB CC!G G ==  Q r[r)r)r$r; Sequence[int]rTrrr$)r_r$r^rrr$)r) paddle.TensorrTrrr)FFNrr,identityN)rNFN)r)r$r~rrBzint | Sequence[int] | Nonerr+rTrrRpaddle._typing.DTypeLike | NonerX Tensor | Nonerr$) r)r$r~rrBrrr+rTrrr$)NNFNNN)r)r$r~float | _POrder | NonerBz(int | list[int] | tuple[int, int] | Nonerr+rXzpaddle.Tensor | NonerRrrTrrr$)rN) r)r$ror$r~rrTrrr$)NN)r)r$r~rrTrrr$)rN) r)r$ror$rBrrTrrr$)TTNNN)r)r$rDr+rEr+rFrrGrrTrrr$)r_r$rTrrr$)r(N)FN)r)r$r\r+rTrrr$)NFNNN)r)r$rffloat | Tensor | Nonerbr+r`rrarrTrrr$)drrNFN)r_r$rsrrrrrrxrrtr+rTrrr$)rrrN) r_r$rsrrrrrrTrrr$)NrN) r)r$rrrrrTrrr$)r)r$rr$rTrrr$)r)r$rTrrr$) r)r$rr+rTrrXz$tuple[Tensor, Tensor, Tensor] | Nonertuple[Tensor, Tensor, Tensor])NrNN) r)r$r int | NonerrrrrTrrr)NTrN) r)r$rrrr+rrrTrrr)r)r$rrrTrrztuple[Tensor, int])..)r)r$rzLiteral['reduced', 'complete']rTrrtuple[Tensor, Tensor])r)r$rz Literal['r']rTrrr$)reducedN)rzTensor | tuple[Tensor, Tensor])...) r)r$rr+rzLiteral[False]rTrrr) r)r$rr+rz Literal[True]rTrrr) r)r$rr+rr+rTrr5tuple[Tensor, Tensor] | tuple[Tensor, Tensor, Tensor])TFN)rr)rN) rr$rr$rr$rzLiteral['N', 'T', 'C']rTr)TTN) r)r$ror$rr+rr+rTrrr)r)r$rTrrr)r)z list[Tensor]rTrrr$)rN)r)r$rLiteral['L', 'U']rTrrr)r:FN) r)r$rzfloat | Tensorrbr+rTrrr$)TN) r)r$ror$r&r+rTrrXrrr$)TFFN)r)r$ror$r\r+r:r+r)r+rTrrr$) r)r$ror$r\r+rTrrr$)r)r$rrrTrrr$)NNN) r)r$ror$rz float | Noner@z1Literal['gels', 'gelsy', 'gelsd', 'gelss'] | NonerTrrz%tuple[Tensor, Tensor, Tensor, Tensor])r)r$rDr+rTrrr$)rr[N) r)r$ror$r~rr_zhLiteral['use_mm_for_euclid_dist_if_necessary', 'use_mm_for_euclid_dist', 'donot_use_mm_for_euclid_dist']rTrrr$)r)r$rjr$rTrrr$)NNNN)NNNNN)rNFNN)r)r$rszTensor | list[int] | intrzSequence[float] | Nonertr+rrrTrrztuple[Tensor, list[Tensor]])r)r$rjr$ror$r&r+r:r+rTrrr$)w __future__rr&typingrrnumpyrtyping_extensionsrrrr paddle._C_opsr r r r paddle.base.libpaddler paddle.common_ops_importrpaddle.tensor.mathrpaddle.utils.decorator_utilsrrrrpaddle.utils.inplace_utilsrbase.data_feederrrrrcommon_ops_importrrwrrrrcreationr manipulationr!r"collections.abcr#r$r'__annotations____all__rYr:r]rarerprr rrr4r8r:r<rVrXr[rcrprzr}rrrrrrrrrrrrrrrrrrrrrr r#r%r(r+r/r;rPrZrir~rrrrrrxrrrrrrrr[rZrs # )1 44*,. D ) "( .GY.  7;} }"}*4} }}@**v))> @  ePE7UG45'+ }.2} } } %} }  } +} } }6}D/12h h  h h  ,h  h  h  h V GS>%IJ!%59 $-1t tt 3t t  t + t t tKtnoh!%E  E E  E  E V  ! ! ! !  !  !L"" | | | | |  |  | |~Tn(fug&' \ \ \ \  \  \(\~:~"&"&"& i i ii i i  i i\ O O O O  O  O  O O Oh 6: 6: 6: 6:  6:  6:  6:v" C C CC  C  CL:z6rBN S 15 S SS S . S # Sl!H %% 4 w ww w w  w # wx R6 R6R6 R6  R6  R6 # R6l+/J JJ'JJZ ,/   (               D$ DN  #              " ( ( ((  ( # ( ( LO@ @@-1@?I@:@ @ *.g:g\%( Y YY Y " Y  Y~ p p pp p  p # pf<~=@MbBFP% P%&P%4>P%P%j" { { {{  {  {|& #sc3Z( N  N N N N  N  N N)Nh [ [ [ [ [  [  [ [~CG8 88!%85?8 8xBFJ J&J4>J J`@D v: v: v: v: > v:  v: + v:rC R .z z z z z z z|04E EE",E ER t  ,0:>$9=GK&      % %R9=)GK)X  *$4 FTr&(%)! l l "l #l l  l  l!lf a a aa  a  a  a aJ8<<  < < *4<  < r[