\;jQddlZddlZddlmZddlmZddlmZddlm Z ddl m Z m Z m Z ddlmZdd lmZmZmZd d lmZd d lmZd d lmZgZdZd5dZe d5dZd6dZd7dZd8dZ d9dZ!d5dZ"d:dZ#d5dZ$e d5dZ%d;dZ&ddZ*d?dZ+d5dZ,d5d Z-d5d!Z.ddHd2Z? dId3Z@d5d4ZAy)JN)_C_ops)DataType)VarDesc)inplace_apis_in_dygraph_only) check_dtype check_typecheck_variable_and_dtype)Variable) LayerHelperin_dynamic_modein_dynamic_or_pir_mode)full)cast)_get_reduce_axis c trtj||St|dgddt |dt t fdt|t r t |}t|t|jk7r.tdt|jdt|dt|D]D\}}|t|jk\std|||t|jfztdit}|j|j}|j|j}|j!d d |gi|g|gd d |i |S)aM 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`. Args: x (Tensor): The input Tensor. It is a N-D Tensor of data types bool, float32, float64, int32. perm (list|tuple): Permute the input according to the data of perm. name (str, 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 x = [[[ 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) = [2,3,4] # Example 1 perm0 = [1,0,2] y_perm0 = [[[ 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) = [3,2,4] # Example 2 perm1 = [2,1,0] y_perm1 = [[[ 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) = [4,3,2] Examples: .. code-block:: python >>> import paddle >>> x = paddle.randn([2, 3, 4]) >>> x_transposed = paddle.transpose(x, perm=[1, 0, 2]) >>> print(x_transposed.shape) [3, 2, 4] x) boolfloat16float32float64int32int64uint16 complex64 complex128 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 .zEach element in Input(perm) should be less than Input(x)'s dimension, but %d-th element in Input(perm) is %d which exceeds Input(x)'s dimension %d. transpose2XOutXShapeaxistypeinputsoutputsattrs)r)rrrr r listtuple isinstancelenshape ValueError enumerater locals"create_variable_for_type_inferencedtype append_op)rr nameidxdimhelperoutx_shapes ]G:\00. PROJECTS\API\Inventory\templateJSON\kerjaOCR\Lib\site-packages\paddle/tensor/linalg.pyrr$sjd4((    4$ < dE ":D t9AGG $99rArAs"   D))r?ctrtj||||S||d}d}|||tdit }|j |j }|jd||dd|i||S) a Applies matrix multiplication to two tensors. `matmul` follows the complete broadcast rules, and its behavior is consistent with `np.matmul`. Currently, the input tensors' number of dimensions can be any, `matmul` can be used to achieve the `dot`, `matmul` and `batchmatmul`. The actual behavior depends on the shapes of :math:`x`, :math:`y` and the flag values of :attr:`transpose_x`, :attr:`transpose_y`. Specifically: - If a transpose flag is specified, the last two dimensions of the tensor are transposed. If the tensor is ndim-1 of shape, the transpose is invalid. If the tensor is ndim-1 of shape :math:`[D]`, then for :math:`x` it is treated as :math:`[1, D]`, whereas for :math:`y` it is the opposite: It is treated as :math:`[D, 1]`. The multiplication behavior depends on the dimensions of `x` and `y`. Specifically: - If both tensors are 1-dimensional, the dot product result is obtained. - If both tensors are 2-dimensional, the matrix-matrix product is obtained. - If the `x` is 1-dimensional and the `y` is 2-dimensional, a `1` is prepended to its dimension in order to conduct the matrix multiply. After the matrix multiply, the prepended dimension is removed. - If the `x` is 2-dimensional and `y` is 1-dimensional, the matrix-vector product is obtained. - If both arguments are at least 1-dimensional and at least one argument is N-dimensional (where N > 2), then a batched matrix multiply is obtained. If the first argument is 1-dimensional, a 1 is prepended to its dimension in order to conduct the batched matrix multiply and removed after. If the second argument is 1-dimensional, a 1 is appended to its dimension for the purpose of the batched matrix multiple and removed after. The non-matrix (exclude the last two dimensions) dimensions are broadcasted according the broadcast rule. For example, if input is a (j, 1, n, m) tensor and the other is a (k, m, p) tensor, out will be a (j, k, n, p) tensor. Args: x (Tensor): The input tensor which is a Tensor. y (Tensor): The input tensor which is a Tensor. transpose_x (bool, optional): Whether to transpose :math:`x` before multiplication. Default is False. transpose_y (bool, optional): Whether to transpose :math:`y` before multiplication. Default is False. name (str, optional): If set None, the layer will be named automatically. For more information, please refer to :ref:`api_guide_Name`. Default is None. Returns: Tensor: The output Tensor. Examples: .. code-block:: python >>> import paddle >>> # vector * vector >>> x = paddle.rand([10]) >>> y = paddle.rand([10]) >>> z = paddle.matmul(x, y) >>> print(z.shape) [] >>> # matrix * vector >>> x = paddle.rand([10, 5]) >>> y = paddle.rand([5]) >>> z = paddle.matmul(x, y) >>> print(z.shape) [10] >>> # batched matrix * broadcasted vector >>> x = paddle.rand([10, 5, 2]) >>> y = paddle.rand([2]) >>> z = paddle.matmul(x, y) >>> print(z.shape) [10, 5] >>> # batched matrix * batched matrix >>> x = paddle.rand([10, 5, 2]) >>> y = paddle.rand([10, 2, 5]) >>> z = paddle.matmul(x, y) >>> print(z.shape) [10, 5, 5] >>> # batched matrix * broadcasted matrix >>> x = paddle.rand([10, 1, 5, 2]) >>> y = paddle.rand([1, 3, 2, 5]) >>> z = paddle.matmul(x, y) >>> print(z.shape) [10, 3, 5, 5] trans_xtrans_yc^||d}|jD]\}}t||gddy)N)ry)int8rrrrrrmatmul)itemsr )rrG var_namesr8vals r> __check_inputzmatmul..__check_inputs9a(I&__. c( /r? matmul_v2r6r#Yr%r()rN)rrrIr r4r5r6r7) rrG transpose_x transpose_yr8r,rMr;r<s r>rIrIsz}}Q; <<#"   $ a5FH577agg7F#CL   r?cdd} dd}d|dddffd }d|ddffd }|l|jt|tr|dk(r |||| Std |t|ttfr||||d | Std t |t|t r t|}t|trt|dk(r|d}t|trct|tr!|dk(r|d||d| Std |t|ttfr||||d|Std|t|trst|dk(re|dk(r |||| S|tjk(s|tj k(r |||||S|dk(rtd||||||Std|)a Returns the matrix norm (Frobenius) or vector norm (the 1-norm, the Euclidean or 2-norm, and in general the p-norm for p > 0) of a given tensor. Note: This norm API is different from `numpy.linalg.norm`. This api supports high-order input tensors (rank >= 3), and certain axis need to be pointed out to calculate the norm. But `numpy.linalg.norm` only supports 1-D vector or 2-D matrix as input tensor. For p-order matrix norm, this api actually treats matrix as a flattened vector to calculate the vector norm, NOT REAL MATRIX NORM. Args: x (Tensor): The input tensor could be N-D tensor, and the input data type could be float32 or float64. p (float|string, optional): Order of the norm. Supported values are `fro`, `0`, `1`, `2`, `inf`, `-inf` and any positive real number yielding the corresponding p-norm. Not supported: ord < 0 and nuclear norm. Default value is `fro`. axis (int|list|tuple, optional): The axis on which to apply norm operation. If axis is int or list(int)/tuple(int) with only one element, the vector norm is computed over the axis. If `axis < 0`, the dimension to norm operation is rank(input) + axis. If axis is a list(int)/tuple(int) with two elements, the matrix norm is computed over the axis. Default value is `None`. keepdim (bool, optional): Whether to reserve the reduced dimension in the output Tensor. The result tensor will have fewer dimension than the :attr:`input` unless :attr:`keepdim` is true, default value is 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`. Returns: Tensor: results of 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.]]]) >>> # 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, [17.43559647, 16.91153526, 16.73320007, 16.91153526]) >>> # 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.]]) NFc|)t|trt|dk(s tdt r2|t j |g|dSt j |||dS||dd}|d|d<t|ddd gd tdit}|j|j }|jd d |id |i||S)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. 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!TFr:keep_dim reduce_allrXinputrrfrobenius_normrOr#r%r()rZ) r/r-r0r2rrrZr r r4r5 input_dtyper7)rYr:keepdimr8r,r;r<s r>rZznorm..frobenius_normss ?JsD$9c#h!mS  " #{,,UBFF((WeD DWEJE{&*l# $wI 68H !>VX>F;;((*<C   %U|    Jr?ctr|d}tj|||d||S|t|dtt fd|t|dt dt |dgdd||nd| t |nd||dd }tdit}|j|j }|jdd |id |i| |S)a Calculate the p-order vector norm for certain dimension of Tensor `input`. Args: input (Variable): Tensor, data type float32, float64. porder (float, optional): None for porder=2.0. Default None. axis (int, optional): None for last dimension. Default None. keepdim (bool, optional): Whether keep the dimensions as the `input`, Default False. asvector (bool, optional): Whether keep the result as a vector, 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`. g-q=porderp_normr'rY)rrrr@)r'r_r\asvectorepsilonrOr#r%r()r`) r rr`r floatintr r r4r5r[r7) rYr_r'r\rbr8r,r;r<s r> vector_normznorm..vector_norms  |==eWhO O!68eS\8D4#9 $;  !% 0b+1+=%-3"$ E!6VX6F;;((*<C   U|    Jr?c 8tr[tj|}|tjdk(rtj |||Stj |||Std it}|j|j}|jdd|id|i|j|j}t| \} }|tjdk(rdnd} |j| d|id|i||| d  |S) NinfrOabsr#r%r)r*r+ reduce_max reduce_minrVr()inf_norm) r rrinprmaxminr r4r5r[r7r) rYr_r'r\rbr8r<r; reduce_outrX reduce_typers r>rmznorm..inf_norms2  **U#CE**zz#tW55zz#tW55 8vx8F;;((*<C   C<%   BB((*CJ 0a8 J &"**U*; ;      Sz + '",   r??c trgtj|}tj||}tj||d|}tj|t d|z }|St d it} | j| j}| j| j}| jdd|id|i| j| j}| jdd|id|id |i | j| j}t| \} }| jd d|id|i||| d  | jdd|id|id t d|z i |S)z NOTE: This function actually treats the matrix as flattened vector to calculate vector norm instead of matrix norm. NrsrOrir#r%rjpowfactorr( reduce_sumrVnorm) r rrirusumrdr r4r5r[r7r) rYr_r'r\r8abs_outpow_outsum_outr<blockrXrs r> p_matrix_normznorm..p_matrix_norms  jj'Gjj&1Gjj$g>G**WeC&L&9:CJ/fh/66##%7 ::##%;  U|eW5E  ::##%;  >G$V$  ::##%; ,D!4 D >G$#(   >CLU3<01   r?fro)r:r\r8z*only valid string values are 'fro', found T)r_r'r\rbr8z,only valid p type is string or float, found rrr)r'r_r\rbr8z8unspport p for p-order vector norm. except float, found )r_r'r\r8zHjust support axis type int or list (length of list <=1) if p = 0, found z9except axis type int or list (length of list <=2), found NFN)NNFFN) r/strr2rerdr)r.r-r0rnrh) rpr'r\r8rZrfrmrs ` r>ryrysE|&RLP0fuu4#J%(dE4l | a Ez%aT7NN @DC< (  >tAwiH $Dz$#d)q.Aw$ a Ez"#" !@DC< (  J1#N  D$ CIN :!!wTJ J "&&[A"&&LAadG$O O !VZ[_Z`a !!$d Gv N  r?cttrtj|||St|dgddt|dgddt |dt t fdtdit}|j|j}|g|gd}d|gi}dt |i}|jd|d|i||S) a3 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, 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.) r6)bfloat16rrrdistrrPr%r()r) rrrr r rdrer r4r5r6r7) rrGrr8r;r<r*r+r,s r>rrusx{{1a## 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 trtj|}tj||dd}|dk(s|tj k(rtj |dgdS|dk(s|tj k(rtj|dgdSytdit}|j|j}|j|j}|j|j}|jdd|id|i t|\}}|jd d|id|i|d|d  |dk(s|tj k(r|jd d|id|idgd|d  |dk(s|tj k(r|jdd|id|idgd|d  |S)z NOTE: Calculate the matrix norm of a square matrix or batches of square matrices, when porder is in (1, -1, inf, -inf) NFrr^rOrir#r%rjrwrVr(rkrlrx)rrrirzrnrhrorpr r4r5r[r7r) rYr_r'r{r}r~r<rXrs r>mat_normzcond..mat_normWs " #jj'Gjj$e>'')?G>>'')?G::'');C OOC<%9I   0a8 J OO!W~( %",  {f.%>"CL "t$)&0  |v"&&0%>"CL "t$)&0  Jr?rr^c (trhtj||}tj||dd}tj||dd}tj|t d|z St d it }|j|j}|j|j}|j|j}|j|j}|jdd|id|id|i t| \}}|jd d|id|i|d|d  |jd d|id|i|d|d  |jdd|id|idt d|z i |S) zr NOTE: Calculate the frobenius norm of a square matrix or batches of square matrices. NFrsrOrur#r%rvr(rwrVrx) rrrurzrdr r4r5r[r7r) rYr_r'r| sum_out_1 sum_out_2r~r<rXrs r>fro_normzcond..fro_norms " #jj/G 7D$>I 9dD%@I::isV|)<= =3&(3E>>'')?G@@'')AI@@'')AI::'');C OOU|((   0a8 J OO!W~ * %",   OO!Y' * %",   OOY' sV|!45   Jr?c t|d\}}}tr|dk(rtj||ddStj||d}tj ||d}|dk(rtj ||S|dk(rtj ||Syt| \}}tdit} | j| j} |dk(r| jdd |id | i|d|d  | S| j| j}| j| j}| jd d |id |i|d|d  | jdd |id |i|d|d  |dk(r| jd||dd | i|dd | S|dk(r| jd||dd | i|dd | Sy)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. F full_matricesnucNrrOrwr#r%rVr(rkrlelementwise_divrP)aixs use_mkldnnrx) svdrrrzrorpdividerr r4r5r[r7) rYr_r'usvhmax_outmin_outrXr~r<rs r>svd_normzcond..svd_norms8 uE21b ! #zz!T477jjD%0GjjD%0G{}}Wg66|}}Wg66 0a8 J3&(3E::'');C%8"CL#$)&0   >>'')?G>>'')?G OO!Qx( %",   OO!Qx( %",  {*!(w7"CL#'u=    |*!(w7"CL#'u=    r?cNtr|j|Std)Nz6only support x is nonempty tensor in static graph mode)rreshaper2)rYr1s r> empty_tensorzcond..empty_tensor!s' ! #==' ' D  r?z1input should be a matrix or batches of matrices, z'but the dimention of received input is rrrrrrr^)r_r'zonly support p is z when input is a z+square matrix or batches of square matrices)rr)r_z unsupported z' for p, only supporting ('fro', 'nuc', z 1, -1, 2, -2, inf, -inf) or none)rsN)r-r1r0r2rnrhinverse) rrr8rrrrr=x_sizex_invs ` r>condrs`>@ !t:x')TL\ 177mG w<1  ?7G ~F G   y >> import paddle >>> # 1-D Tensor * 1-D Tensor >>> x = paddle.to_tensor([1, 2, 3]) >>> y = paddle.to_tensor([4, 5, 6]) >>> z = paddle.dot(x, y) >>> print(z) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 32) >>> # 2-D Tensor * 2-D Tensor >>> x = paddle.to_tensor([[1, 2, 3], [2, 4, 6]]) >>> y = paddle.to_tensor([[4, 5, 6], [4, 5, 6]]) >>> z = paddle.dot(x, y) >>> print(z) Tensor(shape=[2], dtype=int64, place=Place(cpu), stop_gradient=True, [32, 64]) dotzx cannot be None in zy cannot be None in r)rrrrrrrrrGrOF)r8r6 persistablerPr%r)r*r,r+) rrrr r r4r5r6create_variabler7)rrGr8op_typer;r<s r>rrRsNzz!Q}> 4WI>>}}> 4WI>>}     !    W11 <;;!'';JC((e)C QQ/rE3<   r?cd}t|jdkDst|jdkr!tdt|jzt|dddgd|}t|jdk(r|j d}|s"|jd dk7r|j }d }|jd} ||j |j}t|jdkDr!td t|jz|jd | k7r(td j| |jd |jd krtd |jdtj|tj|j dk(s td||j |j} t| jdkDr!tdt|jzt|dddgd|jd | k7r(tdj| |jd |jd krtd|jd||| z}n| }tj| |j} ||.|j} | jd k(r td|||z} | jd| z } n|jd| z } |} |||r| ||zj| z z }n| |z }|d kr!tjd |j}|| j!dz }tj"|| j j%}tj&||j)}|S)uv 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, 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]]) covrrz]Input(x) only support N-D (1<=N<=2) tensor in cov, but received length of Input(input) is %s.r6rrrrNz`Input(fweights) only support N-D (N<=1) tensor in cov, but received shape of Input(input) is %s.ziThe number of Input(fweights) should equal to x's dim[1]: {}, but received size of Input(fweights) is {}.zWThe value of Input(fweights) cannot be negtive, but received min of Input(fweights) is r!z Input(fweights) must be integer zaInput(aweights) only support N-D (N<=1) tensor in cov, but received length of Input(input) is %s.ziThe number of Input(aweights) should equal to x's dim[1]: {}, but received size of Input(aweights) is {}.zWThe value of Input(aweights) cannot be negtive, but received min of Input(aweights) is rOz0The sum of weights is zero, can't be normalized.)r')r0r1r2r rtastyper6formatrppaddleallround to_tensorrzitem unsqueezemmconjrsqueeze)rrowvarddoffweightsaweightsr8rnxwobservation_numaww_sumnx_wavg norm_factorxxtrs r>rrsDG 177|a3qww>!  /117#X^^A%62  <<>A --5\\^,>!  /117#X^^A%62  <<>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) [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) [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) [3, 2] rInput(input) only support N-D (N<=2) tensor, but received length of Input(input) is %s. Perhaps you can use paddle.tensor.transpose() instead.rrrY)rrrrrrr"r#r$r'r()r) r0r1r2rrrr r r4r5r6r7)rYr8r r<r; input_shapes r>rr's!h 5;;! *,/ ,< =   u{{ q L1vud+    ?   -FH-77 D?? L u{{ q C   !eW~!$+?1v&    r?ct|jdkDr!tdt|jztr6t|jdkr|Sddg}t j ||}|Sy)z Inplace version of ``t`` API, the output Tensor will be inplaced with input ``input``. Please refer to :ref:`api_paddle_t`. rrrrN)r0r1r2r rrA)rYr8r r<s r>t_rs{  5;;! *,/ ,< =   u{{ q L1vt, r?c:tr!|tn|}tj|||St |dgddt |dgddt d it }|j|j}i}||d<|jd||dd|i||S) 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. y (Tensor): The second input tensor, the data type is float16, float32, float64, int32, int64. 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, 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)rrrrrrcrossrGr:rPr%r()r) r K_DEFAULT_DIMrrr r r4r5r6r7)rrGr'r8r;r<r,s r>rrsT $ }$||Aq$''  I   !  I   1177@e #CL   r?c trtj||St|dddgdt |dt dt d it}|j|j}|jdd|gid|id|i |S) a Computes the Cholesky decomposition of one symmetric positive-definite matrix or batches of symmetric positive-definite matrice. 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, 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]]) r6rrcholeskyupperrOr#r%r()r) rrrr r rr r4r5r6r7)rrr8r;r<s r>rrsRq%(( Gi-CZP5'44468477agg7F!:CLE"   r?ctrt|ttjj frL|j |j k7rt||j }n|}d}tj||||S|d}d}n t|}d}tj||||Si}i}t|dddgd||d<|d|d <njt|tr>d|d <|j |j k7rt||j |d <n"||d <nt|d tdd|d <||d <t|d td||d <tdit!} | j#d } | j%d|d| i|| S)aG Computes the rank of a matrix. 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. 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 or float64. 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. name (str, 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:: python >>> import paddle >>> a = paddle.eye(10) >>> b = paddle.linalg.matrix_rank(a) >>> print(b) Tensor(shape=[], dtype=int32, 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=int32, place=Place(cpu), stop_gradient=True, [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]) FTrrr matrix_rankr#use_default_tol TolTensortol hermitianrrOr%r()r)rr/r rpirOpResultr6rrmatrix_rank_tolrdrr r rr r4r5r7) rrrr8 tol_tensorrtol_attrr*r,r;r<s r>rrsR cHfjj&9&9: ;yyAGG#!#qww/  #O)):   ;H"OSzH#O!!!X JJ C)Y)?Os ;'+E# $ X &',E# $yyAGG#&*3&8{#&){# sE5- 8',E# $E%L9k4?&k7fh777g7Fvs|5   r?cRtrtj||S|j}|j}t |t |cxk(rdk(snt dj |||ddk7r.|ddk7r&|d|dk7rt dj |||ddk7r.|ddk7r&|d|dk7rt dj ||tdit}|j|j }|jd ||d d |i |S)a, Applies batched matrix multiplication to two tensors. Both of the two input tensors must be three-dementional and share the same batch size. If x is a (b, m, k) tensor, y is a (b, k, n) tensor, the output will be a (b, m, n) tensor. Args: x (Tensor): The input Tensor. y (Tensor): The input Tensor. name (str|None): A name for this layer(optional). If set None, the layer will be named automatically. Default: None. Returns: Tensor: The product Tensor. Examples: .. code-block:: python >>> import paddle >>> # In imperative mode: >>> # size x: (2, 2, 3) and y: (2, 3, 2) >>> x = paddle.to_tensor([[[1.0, 1.0, 1.0], ... [2.0, 2.0, 2.0]], ... [[3.0, 3.0, 3.0], ... [4.0, 4.0, 4.0]]]) >>> y = paddle.to_tensor([[[1.0, 1.0],[2.0, 2.0],[3.0, 3.0]], ... [[4.0, 4.0],[5.0, 5.0],[6.0, 6.0]]]) >>> out = paddle.bmm(x, y) >>> print(out) Tensor(shape=[2, 2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[6. , 6. ], [12., 12.]], [[45., 45.], [60., 60.]]]) zRx and y should be 3-dimensional. But received x's dimention: {}, y's dimention: {}rr^rzRx's width must be equal with y's height. But received x's shape: {}, y's shape: {}rzgx's batch (shape[0]) must be equal with y's batch (shape[0]). But received x's shape: {}, y's shape: {}bmmrOrPr%rj)r) rrrr1r0r2rr r4r5r6r7)rrGr8r=y_shaper;r<s r>rrlsKNzz!Q''''7|s7|0q0dkkW  1:  b 0WQZ71:5MdkkW  1:  b 0WQZ71:5MyAAW  /fh/77agg7FQQ/%   r?c trtj||||Stdit }t |dgdd|j tjj}|jdd|id|i|||d|S)a Computes the histogram of a tensor. The elements are sorted into equal width bins between min and max. If min and max are both zero, the minimum and maximum values of the data are used. Args: input (Tensor): A Tensor(or LoDTensor) with shape :math:`[N_1, N_2,..., N_k]` . The data type of the input Tensor should be float32, float64, int32, int64. bins (int, optional): number of histogram bins. Default: 100. min (int, optional): lower end of the range (inclusive). Default: 0. max (int, optional): upper end of the range (inclusive). Default: 0. name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: data type is int64, shape is (nbins,). Examples: .. code-block:: python >>> 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#rrrrr%)binsrpror()r) rrrr r4r r5rVarTypeINT64r7)rYrrpror8r;r<s r>rrs6tS#665FH5 3@+ 778M8MN<CLC8   r?c|jtjtjtj tj fvr tdtrtj|||Std it}t|dddgd|-t|dgdd|j|j}n|j|j}|jd||d d |id |i |S)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, 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#rrWeightsrrO)r#rr% minlengthr()r)r6rrrrINT32r TypeErrorrrrr r4r r5r7)rweightsrr8r;r<s r>rrs> ww    EFFq'9554684 C'7);ZH   $8   ;;'--;PC;;!'';JCw/CL *   r?ctrtj||Sd}|||tdit }|j |j }|jd||dd|i|S)aQ 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, 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 producted 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:||d}|jD]\}}t||ddgdt|j}t|j}t |dk7rt d|t |dk7rt dj |y) N)rvecrrmvrz7x should be 2-dimensional. But received x's dimention: rz=vec should be 1-dimensional. But received vec's dimention: {})rJr r-r1r0r2r)rrrKr8rLr= vec_shapes r>rMzmv..__check_inputAs,I&__. c( 95t/177mGSYYI7|q  MgYW9~" SZZ!#r?rrO)r#Vecr%rj)r)rrrr r4r5r6r7)rrr8rMr;r<s r>rrs|<yyC   & a.VX.77agg7FAc2UCL   r?ctrtj|St|jdgddt |j }t|dk\sJdt|z|d|dk(sJdj|d|dtd it}|j|j }|jd d|gid |gi |S)ar 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, 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]) Input)rrrdetrNThe x must be at least 2-dimensional, but received Input x's dimensional: %s. r^r3Expect squared input,but received {} by {} matrix. determinantrOr%rj)r) rrrrr6r-r1r0rr r4r5r7rr8rr;r<s r>rr^s8zz!}AGGW&GO177m ;1$  8:=k:J K $ O{2 . D K K O O  . 7fh777agg7F!~u~   r?ctrtj|St|jdddgdt |j }t|dk\sJdt|z|d|dk(sJd j|d|dtdit}|j|j }|jd d|gid |gi |S)a 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. Note that for matrices that have zero determinant, this returns ``(0, -inf)``. Args: x (Tensor): the batch of matrices of size :math:`(*, n, n)` where math:`*` is one or more batch dimensions. name (str, 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. 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]]) rrrslogdetrrr^rrslogdeterminantrOr%rj)r) rrrrr6r-r1r0rr r4r5r7rs r>rrsB~~a  AGGWy)&SEN   r?ctrtj||St|dddgdt |dt dt d it}|j|j}|j|j}|j|j}i}||d<|jdd|gi|||d| |||fS) 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) * VT Args: x (Tensor): The input tensor. Its shape should be `[..., N, M]`, where `...` is zero or more batch dimensions. N and M can be arbitraty positive number. Note that if x is sigular matrices, the grad is numerical instable. The data type of x should be float32 or float64. full_matrices (bool, optional): A flag to control the behavor of svd. If full_matrices = True, svd op will compute full U and V matrics, 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, 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 singlar value vectors of matrics 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 r6rrrrrOr#UVHSr()r) rrrr r rr r4r5r6r7)rrr8r;rrrr,s r>rrstzz!]++ Gi-CUK=/4?/fh/  5 5AGG 5 D  6 6QWW 6 E  5 5AGG 5 D!.o!:2A.  !Rxr?c  d d fd d fd d fd }tj|stdt||jd d\}}|t d||}n/|d k\r|t ||kstd |d t |||d k\std |d|s ||||dS|j d d}|||z ||dS)aN 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 arbitraty 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, 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]]) cF|jr|jS|SN) is_complexr)rs r> conjugatezpca_lowrank..conjugateXs <<>668Or?c|j}ttdt|}|dd|dgz|dgz}t j ||S)Nrrr^)r1r-ranger0rr)rr1r s r>rzpca_lowrank..transpose]sTE!SZ()CRyDH:%b 24((r?c |Sr)rrrs r> transjugatez pca_lowrank..transjugatecs1&&r?Nc(|dn|}|jdd\}}tjj}tj||f|j }|} |} |o|tj ||d} t|D]@} |tj | | d} |tj || d} B| S|} |tj ||tj ||z d} t|D]n} |tj | | tj | | z d} |tj || tj || z d} p| S)NrrrOr)r1rlinalgqrrandnr6rIr )rqniterMmnrRA_tA_HQiM_Hrr rs r>get_approximate_basisz*pca_lowrank..get_approximate_basisfs`]wwrs|1 ]]   LL!Qqww /ln 96==A&'*A5\v}}S!,-a0v}}Q*+A." a.C6==A&q!)<<=a@A5\v}}S!,v}}S!/DDEaHv}}Q*V]]1a-@@A!D"r?c|dn|}|jdd\}}|d}n|}|}||ks||kDr||||}|} |tj|| } n-tj|| tj|| z } | jd|k(sJ| j|f| jd|k(sJ| j|f| jd| jdksJ| jtjj | d\} } } | }|j|}n||||}|} |tj|| }n-tj|| tj|| z }|} | jd|k(sJ| j|f| jd|k(sJ| j|f| jd| jdksJ| jtjj | d\} } } | }|j| } | | |fS)Nrrrrr^Fr)r1rrIrr)rrrrrrM_trrQ_cB_trrVhVBrrr rs r> svd_lowrankz pca_lowrank..svd_lowrank}s>Awwrs|1 9CA,Cl q5AE%c1ESAAA,CymmAs+mmAs+fmmAs.CC99R=A% 5 1~ 5%99R=A% 5 1~ 5%99R=CIIbM1 <399 <1}}((E(BHAq"BA A%a%1=AA,CyMM#s+MM#s+fmmC.EEA,C99R=A% 5 1~ 5%99R=A% 5 1~ 5%99R=CIIbM1 <399 <1}}((E(BHAq"BA A!Qwr?zInput must be tensor, but got rrzq(=z>) must be non-negative integer and not greater than min(m, n)=zniter(=z) must be non-negative integerr Tr'r\rN)rrN)r is_tensorr2r)r1rpmean) rrcenterrr8r'rrCrrr rs @@@@r> pca_lowrankr.sr ) '.%%N   A 9$q'CDD WWRS\FQy 1aL1fc!Qi!//21ayk ;   QJ75')GHII 1au55 B%A q1uau 55r?ctrtj||St|dddgdt |dt dt d it}|j|j}|jdd|id|id|i |S) a Computes the n-th power of a square matrix or a batch of square matrices. Let :math:`X` be a sqaure 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, 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 ]]) r6rr matrix_powerrrOr#r%r()r0) rrr0r r rer r4r5r6r7)rrr8r;r<s r>r0r0sr""1a(( wI.  1c3/8vx877agg7F8CL(   r?ctr$tj||\}}|dk(r|S||fSt|dddgdt |dt dt d it}|j|j}|j|j}i}||d<|jdd|gi||d | |dk(r|S||fS) a Computes the QR decomposition of one matrix or batches of matrice (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 should be float32 or float64. 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, 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 ; rr6rrrmoderOr#)rrr()r) rrrr r rr r4r5r6r7)rr3r8rr2r;r,s r>rr sTyyD!1 3;Ha4K Gi-CTJ4d+.VX.  5 5AGG 5 D  5 5AGG 5 Df sQCj2B%   3;Ha4Kr?cltrtj||\}}}nt|dddgdt d it }|j |j}|j d}|j d}i}||d<|jdd|i|||d | |r|||fS||fS) u4 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). 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, 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=[1], 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 ; r6rrlurOrepivotr#)r%PivotsInfosr()r5) rrr5r r r4r5r6r7) rr6 get_infosr8r5rinfor;r,s r>r5r5F s`ii5) At Gi-CTJ.VX.  6 6QWW 6 E  5 5E 5 B88u8Eg8!d;  1d{1u r?c@|jdkrtd|jd|jdkrtd|jdtr!tj||||\}}}|||fSt |ddd gd t dit}|j|j } |j|j } |j|j } i} || d <|| d <|jd ||d| | | d| | | | fS)a Unpack L U and P to single matrix tensor . unpack L and U matrix from LU, unpack permutation matrix P from Pivtos . 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]]) Args: x (Tensor): The LU tensor get from paddle.linalg.lu, which is combined by L and U. y (Tensor): Pivots get from paddle.linalg.lu. unpack_ludata (bool, optional): whether to unpack L and U from x. Default: True. unpack_pivots (bool, optional): whether to unpack permutation matrix P from Pivtos. Default: True. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: P (Tensor), Permutation matrix P of lu factorization. L (Tensor), The lower triangular matrix tensor of lu factorization. U (Tensor), The upper triangular matrix tensor of lu factorization. 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=[1], 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]rz) ndimr2rrr>r r r4r5r6r7) rrGr?r@r8PrBrr;rlrr,s r>r>r> sER vvzHPU V   vvzJ166(RW X  ""1a F1a!Qw wI.  5FH5  5 5AGG 5 D  5 5AGG 5 D  5 5AGG 5 D!.o!.oa(QQ/  !Qwr?c4trtj|St|dgddt dit }|j |j}|j |j}d|i}||d}|jd||||fS)aX 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``, ``compplex64`` or ``complex128``. 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: Eigenvalues(Tensors): A tensor with shape math:`[*, N]` refers to the eigen values. Eigenvectors(Tensors): 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#rrrreig Eigenvalues Eigenvectorsrj)rH) rrrHr r r4r5r6r7)rr8r;rvr*r+s r>rHrH sZzz!} sEu /fh/  5 5agg >  5 5agg >q"#Q7eFGD!t r?ct|j}t|dkr$tdj t|||d|dk7rtd|t rt j|St|dgddtd it}|j|j }|jdd |id |i |S)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, 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)]) rz_The dimension of Input(x) should be at least 2, but received x's dimention = {}, x's shape = {}r^rzNThe last two dimensions of Input(x) should be equal, but received x's shape = r6rGeigvalsrOr#r%rj)rN)r-r1r0r2rrrrNr r r4r5r6r7)rr8r=r;r<s r>rNrNT sL177mG 7|a m t tG g   r{gbk!\]d\e f  ~~a    =   3&(377agg7Fia5#,O r?ctrtj|St|dtt fdt |D]K\}}t|dt|zdzgdd|j|djk7sBtdtd it}|jd}|j|}|jdd |id |i |S) a 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 ([Tensor]): The input tensors which is a list Tensor. name (str, 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:: python >>> import paddle >>> # A * B >>> A = paddle.rand([3, 4]) >>> B = paddle.rand([4, 5]) >>> out = paddle.linalg.multi_dot([A, B]) >>> print(out.shape) [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) [10, 7] r multi_dotzx[])rrrrrz:All the Tensors in the input must have the same data type.)input_param_namer#r%rj)rP)rrrPr r-r.r3r rr6rr r4r[r5r7)rr8idrr;r6r<s r>rPrP sn""1cD%=+6!! HB $s2w$;   zzQqTZZ'P%5FH5""C"877>c1Xs|   r?cPtrtj||Sd}|||td it }t |dgdd|j |j}|j |j}|jdd|i||dd|i ||fS) ah 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, 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:: python >>> 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.9238795042037964+0j), (-0.3826833963394165+0j)], [ 0.3826833963394165j , -0.9238795042037964j ]]) ct|j}t|jdkr!tdt|jz|d|dk7rtd||dk7r|dk7rtd|yy NrzPInput(input) only support >=2 tensor, but received length of Input(input) is %s.r^rzQThe input matrix must be batches of square matrices. But received x's dimention: rBrz+UPLO must be L or U. But received UPLO is: r-r1r0r2rUPLOr=s r>rMzeigh..__check_input 177mG177|a 469!''lCr{gbk) ghogpqs{ts{ A$H +{r?eighr6rGrOr#rIrYr()r[) rrr[r r4r r5r6r7)rrYr8rMr; out_value out_vectors r>r[r[ sJ{{1d##  a0vx0  =   ==AGG=L >>QWW>M 8$-zJ4.  *$$r?c  tr0|s*tj|d\}}}tj|dgd}t j ||j }||z}td} t j | |j } t j||kDd|z d| z } tj| dg} ttt|j} | dd| dgz| dgz} tj|| }|| z}tj||dd}|Stj |d \}}t j"|}tj|dgd}t j ||j }||z}td} t j | |j } t j||kDd|z d| z } tj| dg} || z}tj$|}tj||dd}|S|s(t'd*it)}|j }t+|d d d gd |j-|}|j-|}|j-|}|j/dd|gi|||dddi|j-|}|j/dd|id|idgdddt1dg||}||z}td} t1dg| |} t j||kDd|z d| z } |j-|} |j-|}|j/dd| iddgi| |dttt|j} | dd| dgz| dgz} |j-|}|j-|}|j/dd|gi|g|gdd| i|j-|}|j/d|| dd|iddd|j3|}|j-|}|j/d ||dd|iddd!|St'd*it)}|j }t+|d"gd#d |tj4k(rd }n|tj6k(rd }n|}|j-|}|j-|}|j/d$d|i||d%d d&i|j-|}|j/d'd|id|i(|j-|}|j/dd|id|idgdddt1dg||}||z}td} t1dg| |} t j||kDd|z d| z } |j-|} |j-|}|j/dd| iddgi| |d|j-|}|j/d|| dd|iddd|j3|}|j-|}|j/d)d|id|gi(|j-|}|j/d ||dd|iddd!|S)+a 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 arbitraty positive number. The data type of x should be float32 or float64 or complex64 or complex128. When data type is complex64 or cpmplex128, hermitian should be set True. rcond (Tensor, 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, 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 ; Fr^TrOrhrrNrYpinvrrrrr#rrr(rkr%rV)r1 fill_valuer6 unsqueeze2axesr$rr"r'elementwise_mulrP)r'rrNrCr6rGr[rIrBrirjr)r_)rrrrorrr6rdwhererr-r r0r1rrIr[rirr r4r r5r7rappend_activationrr)rrcondrr8rrvtmax_singular_valcutoffrGsingularstdimsr rLout_1out_2s_absu_conjr;r6st_shapev_shapes_types r>r_r_5 svzz!U+HAq"%zz!bT48 $$U!'':E--Fe A  !''2A||AJAq1u=H!!(RD1Bc"((m,-D9Rz)T"XJ6D  T*AFEMM%E48EL;;q&)DAqJJqME%zz%"t< $$U!'':E--Fe A  !''2A||EFNAE1q5AH!!(RD1BFE[[^FMM%=EL 4684FGGE $Qi-CV L99%@A99%@A::5AB   aSzr2&.   &HHO    !Qx 01!dEJ  suEBE--Fe AA31E:A||AJAq1u=H:::GB@@u@MH   !Xtn "h7  c"((m,-D9Rz)T"XJ6D99%@A??FG   !bT{!"y9tn  ==eDE   &R(!7   ,,U3E==eDE    "+"'D9   L 4684FGGE $A  )))"&***"99%@A99&AA   Qx()1=sm   ==fEE   C8eU^   &HHP    !U| 01!dEJ  suFCE--Fe AA31F;A||EFNAE1q5AH:::HB@@v@NH   !Xtn "h7  ==eDE   &R(!7   ,,U3E>>uEF   S!Huvh6G  ==eDE    "0"'D9   Lr?c$trtj||S|g|gd}td it }t |dddgdt |dddgd|j |j}|jd||dd|i |S) a Computes the solution of a square system of linear equations with a unique solution for input 'X' and 'Y'. Let :math:`X` be a sqaure matrix or a batch of square matrices, :math:`Y` be a vector/matrix or a batch of vectors/matrices, the equation should be: .. math:: Out = X^-1 * Y 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. 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. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. 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: >>> # 2*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.]) rPsolverrrrGrOr%rj)ru) rrrur r4r r5r6r7)rrGr8r*r;r<s r>ruru& sT||Aq!!s!%11 C)Y)?I C)Y)?I77agg7Fqq!1E3<   r?c 4trtj|||||S|g|gd}td it }t |dddgdt |dddgd|j |j}|jd||dd|i|||d  |S) 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 or float64. 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 or float64. 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, 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.]]) rPtriangular_solverrrrGrOr%)rr unitriangularr()rw) rrrwr r4r r5r6r7) rrGrrrxr8r*r;r<s r>rwrw_ sr&&q!UI}MMs!%<68< sY *,>  ! sY *,> 77agg7F##CL&!.   r?ctrtj|||Std it }t |dddgdt |dddgd|j |j}|jd||dd|id |i |S) 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, 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_solverrrrGrOrPr%rr()rz) rrrzr r4r r5r6r7)rrGrr8r;r<s r>rzrz sH$$Q511:: sY *,<  ! sY *,< 77agg7F!#CLE"   r?ctr&tj|||j\}}|Sd}|||t d it }t |dgdd|j|j}|j|j}|j} |jdd|i||d|| d |S) u 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, 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]) ct|j}t|jdkr!tdt|jz|d|dk7rtd||dk7r|dk7rtd|yyrVrWrXs r>rMzeigvalsh..__check_input rZr?eigvalshr6rGrOr#rI)rYis_testr()r}) rrr} stop_gradientr r4r r5r6r7) rrYr8values_rMr;r\r]r~s r>r}r} s4OOAtQ__=    a4684  =   ==AGG=L >>QWW>M //8$-zJG4  r?c tj}|dk(r|dvrtd||dn|}n(d|vr|dvrtd||dn|}n td |j|jk(r|jtj tj tjjjjtjjjjfvs td |jd krtd |jd |jd krtd|jd |jd|jdk7r,td|jdd|jdd||jtj k(s;|jtjjjjk(r*dt|jd|jdz}n|jtj k(s;|jtjjjjk(r)dt|jd|jdz}trt!j"||||\}}}} |dk(r;tj$dgd}tj$dg|j} n'|dk(r"tj$dg|j} |||| fSt'd$it)} t+|dgddt+|dgdd| j-|j}| j-|j}| j-tj.}| j-|j} | j1d||d|||| d||d |dk(rEtj2j5d!dg"}tj2j5d#dg"} n'|dk(r"tj2j5d#dg"} |||| fS)%uE 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 rgpu)NrzEOnly support valid driver is 'gels' or None for CUDA inputs. But got rz.Only support lstsq api for CPU or CUDA device.zIOnly support x and y have the same dtype such as 'float32' and 'float64'.rr<r=z: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>r^V瞯rr1 s+@   F  B Bqrxqyz #N &  'WX^W_` ">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;\\ q%6 2)T? 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. ]]) rrzbInput(x) only support N-D (1<=N<=2) tensor in corrcoef, but received length of Input(input) is %s.r6rrcorrcoefrNr^)r0r1r2r rrCrdiagrrealsqrtcomplexclipimag)rrr8cdstddevs r>rr s8L 177|a3qww 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, 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)rrcdistrGr)#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 %s.rrrrrrzPThe x must be at least 2-dimensional, But received Input x's dimensional is %s. zPThe y must be at least 2-dimensional, But received Input y's dimensional is %s. r^zTThe x and y must have same last dimension, But received Input x's last dimension is z, Input y's last dimension is z. z@The p must be greater than or equal to 0, But received p is %s. rrOraTr()r r)rp.N)rr')r r rdrer2r-r1r0rrr6zerosrzrurr rCrIrrrry)rrGr compute_moder8r3r=rr1r2c1x_normy_norm y_transposedy_norm_transposedress r>rr*s7XQ%;WEQ%;WEq#s|W-  /1= >  D<< 1 1 7 7177mG w<1  68;G  E 177mG w<1  68;G  E  2;'"+ % 44;BK=A''.r{m3 8 % 6 "$% &6 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 t|jdgddt|jdgdd|j|jk(sJdt|jdk\rFt|jdk\r.t|jt|jdzk(sJd|jd |jd k\sJd |jd |jd k\sJd t |jd d D]+\}}|j||j|k(r&Jdd}t|jdk(r |||S|jd d \}}|j}|j} |j d |d |d f}|j d | d f}|jd} t j| ||g|j} t| D]M} tr||| || | | < t jj| | ||| || } O| j |} | S)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, 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]]) rrGhouseholder_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 rr^zMThe 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 l|jdd\}}|jd}tj|j|j}t t ||D]}||d|f}trd|d<n!tjj|dd}|jddg}tr|jtjtjfvrJ|dd|df|dd|df|ztj|jz||zz |dd|df<|dd|df|dd|df|z|jz||zz |dd|df< tjj|tdt|df|jtjtjfvr-|dd|df|dd|df|z|jz||zz n,|dd|df|dd|df|z|jz||zz }|ddd|fS)Nrr^rr)r1reyerr6r rpr rsetitemrrrrTslice)rrrrkrrrs r>_householder_productz1householder_product.._householder_productswwrs|1 IIbM JJqM  )s1ay!A!"a%A !MM))!Q2 2q'"A 77v00&2B2BCC ABx!QR%1 v{{1~'7'77#a&@ AaeH !ABx1QU8arrseL         399@?@ AGG   Na  LC NQ. .  I  /  qwwr{"XWX"  syy}$767$AGGCRL)Q GGCLCIIcN * O N O ** 8 177|q#As++ 7723rHrNrPr[r_rurwrzr}rrrrr r?r>rsc *,CPP(LL"  `F**AH] @ odh V XvwtUp(EP6rTnCL)X>B<~3l:zK\X6vHV>BcLfR<~?DM`L%^nb6tBFPf6rCLp:fC NKOslr?