AVhdZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Z dd lmZdd lmZdd lddlmZddlmZddlmZdZedddgej.d4dZedddgej.ej2dd5dZeddej.ddej6dfdZedddgej.ej2dd6dZedd gej.d5d!Zed"d#gej.d5d$Zed%d%d&gej.ej2d&d5d'Z ed(d(d)gej.ej2d)d5d*Z!ed+d+d,gej.ej2d,d7d-Z"ed.d/gej. d8d0Z#ed.d/gej.ejHdd1d2 d9d3Z%y):zAOperations for linear algebra. API docstring: tensorflow.linalg N)dtypes)ops)tensor) array_opscond) gen_array_ops)gen_linalg_ops)linalg_ops_impl)map_fn)math_ops)*) deprecation)dispatch) tf_exportctj|||| }t|tjs|dk7rt j |}|dd}|r|d}n|d}t|||j}|j |rdnd}|j|j ddj||g|||zz }tj|S)arComputes Cholesky factorization of regularized gramian matrix. Below we will use the following notation for each pair of matrix and right-hand sides in the batch: `matrix`=\\(A \in \Re^{m \times n}\\), `output`=\\(C \in \Re^{\min(m, n) \times \min(m,n)}\\), `l2_regularizer`=\\(\lambda\\). If `first_kind` is True, returns the Cholesky factorization \\(L\\) such that \\(L L^H = A^H A + \lambda I\\). If `first_kind` is False, returns the Cholesky factorization \\(L\\) such that \\(L L^H = A A^H + \lambda I\\). Args: matrix: `Tensor` of shape `[..., M, N]`. l2_regularizer: 0-D `double` `Tensor`. Ignored if `fast=False`. first_kind: bool. Controls what gramian matrix to factor. Returns: output: `Tensor` of shape `[..., min(M,N), min(M,N)]` whose inner-most 2 dimensions contain the Cholesky factors \\(L\\) described above. ) adjoint_a adjoint_brN) batch_shapedtype) r matmul isinstance tensor_libTensorrshapeeyer set_shape concatenater cholesky) matrixl2_regularizer first_kindgramian matrix_shaper small_dimidentitysmall_dim_statics P/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/linalg_ops.py_RegularizedGramianCholeskyr++s0 OO f *n F' 1 12n6I??6*Ls#Kr"ir"i9+V\\JH||*B"=  Sb%%'79I&JKM ~((G   ))zlinalg.triangular_solvematrix_triangular_solve)v1ctj|d||g5tj||||cdddS#1swYyxYw)a5Solve systems of linear equations with upper or lower triangular matrices. `matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions form square matrices. If `lower` is `True` then the strictly upper triangular part of each inner-most matrix is assumed to be zero and not accessed. If `lower` is `False` then the strictly lower triangular part of each inner-most matrix is assumed to be zero and not accessed. `rhs` is a tensor of shape `[..., M, N]`. The output is a tensor of shape `[..., M, N]`. If `adjoint` is `True` then the innermost matrices in output satisfy matrix equations ` sum_k matrix[..., i, k] * output[..., k, j] = rhs[..., i, j]`. If `adjoint` is `False` then the innermost matrices in output satisfy matrix equations `sum_k adjoint(matrix[..., i, k]) * output[..., k, j] = rhs[..., i, j]`. Example: >>> a = tf.constant([[3, 0, 0, 0], ... [2, 1, 0, 0], ... [1, 0, 1, 0], ... [1, 1, 1, 1]], dtype=tf.float32) >>> b = tf.constant([[4], [2], [4], [2]], dtype=tf.float32) >>> x = tf.linalg.triangular_solve(a, b, lower=True) >>> x >>> tf.matmul(a, x) Args: matrix: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`, `complex64`, `complex128`. Shape is `[..., M, M]`. rhs: A `Tensor`. Must have the same type as `matrix`. Shape is `[..., M, N]`. lower: An optional `bool`. Defaults to `True`. Boolean indicating whether the innermost matrices in matrix are lower or upper triangular. adjoint: An optional `bool`. Defaults to `False`. Boolean indicating whether to solve with matrix or its (block-wise) adjoint. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as matrix, and shape is `[..., M, N]`. triangular_solve)loweradjointNr name_scoper r-)r"rhsr1r2names r*r-r-TsFt ~~d. >3  1 15' 3333s =Azlinalg.cholesky_solvecholesky_solvectj|d||g5tj||dd}tj||dd}|cdddS#1swYyxYw)a Solves systems of linear eqns `A X = RHS`, given Cholesky factorizations. Specifically, returns `X` from `A X = RHS`, where `A = L L^T`, `L` is the `chol` arg and `RHS` is the `rhs` arg. ```python # Solve 10 separate 2x2 linear systems: A = ... # shape 10 x 2 x 2 RHS = ... # shape 10 x 2 x 1 chol = tf.linalg.cholesky(A) # shape 10 x 2 x 2 X = tf.linalg.cholesky_solve(chol, RHS) # shape 10 x 2 x 1 # tf.matmul(A, X) ~ RHS X[3, :, 0] # Solution to the linear system A[3, :, :] x = RHS[3, :, 0] # Solve five linear systems (K = 5) for every member of the length 10 batch. A = ... # shape 10 x 2 x 2 RHS = ... # shape 10 x 2 x 5 ... X[3, :, 2] # Solution to the linear system A[3, :, :] x = RHS[3, :, 2] ``` Args: chol: A `Tensor`. Must be `float32` or `float64`, shape is `[..., M, M]`. Cholesky factorization of `A`, e.g. `chol = tf.linalg.cholesky(A)`. For that reason, only the lower triangular parts (including the diagonal) of the last two dimensions of `chol` are used. The strictly upper part is assumed to be zero and not accessed. rhs: A `Tensor`, same type as `chol`, shape is `[..., M, K]`. name: A name to give this `Op`. Defaults to `cholesky_solve`. Returns: Solution to `A x = rhs`, shape `[..., M, K]`. r7FT)r2r1Nr3)cholr5r6yxs r*r7r7sdR ~~d,tSk: .. c5 .A.. aT +A    s 4AA!rz linalg.eyec6tj|||||S)anConstruct an identity matrix, or a batch of matrices. See also `tf.ones`, `tf.zeros`, `tf.fill`, `tf.one_hot`. ```python # Construct one identity matrix. tf.eye(2) ==> [[1., 0.], [0., 1.]] # Construct a batch of 3 identity matrices, each 2 x 2. # batch_identity[i, :, :] is a 2 x 2 identity matrix, i = 0, 1, 2. batch_identity = tf.eye(2, batch_shape=[3]) # Construct one 2 x 3 "identity" matrix tf.eye(2, num_columns=3) ==> [[ 1., 0., 0.], [ 0., 1., 0.]] ``` Args: num_rows: Non-negative `int32` scalar `Tensor` giving the number of rows in each batch matrix. num_columns: Optional non-negative `int32` scalar `Tensor` giving the number of columns in each batch matrix. Defaults to `num_rows`. batch_shape: A list or tuple of Python integers or a 1-D `int32` `Tensor`. If provided, the returned `Tensor` will have leading batch dimensions of this shape. dtype: The type of an element in the resulting `Tensor` name: A name for this `Op`. Defaults to "eye". Returns: A `Tensor` of shape `batch_shape + [num_rows, num_columns]` ) num_columnsrrr6)r r)num_rowsr=rrr6s r*rrs&R   X)4)4#("&  ((r,z linalg.lstsqmatrix_solve_lsc0 fd}dd  fd}tjdjtjk(r|dk7r t dj }|||r |||Stj||| S) a Solves one or more linear least-squares problems. `matrix` is a tensor of shape `[..., M, N]` whose inner-most 2 dimensions form `M`-by-`N` matrices. Rhs is a tensor of shape `[..., M, K]` whose inner-most 2 dimensions form `M`-by-`K` matrices. The computed output is a `Tensor` of shape `[..., N, K]` whose inner-most 2 dimensions form `M`-by-`K` matrices that solve the equations `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]` in the least squares sense. Below we will use the following notation for each pair of matrix and right-hand sides in the batch: `matrix`=\\(A \in \Re^{m \times n}\\), `rhs`=\\(B \in \Re^{m \times k}\\), `output`=\\(X \in \Re^{n \times k}\\), `l2_regularizer`=\\(\lambda\\). If `fast` is `True`, then the solution is computed by solving the normal equations using Cholesky decomposition. Specifically, if \\(m \ge n\\) then \\(X = (A^T A + \lambda I)^{-1} A^T B\\), which solves the least-squares problem \\(X = \mathrm{argmin}_{Z \in \Re^{n \times k}} ||A Z - B||_F^2 + \lambda ||Z||_F^2\\). If \\(m \lt n\\) then `output` is computed as \\(X = A^T (A A^T + \lambda I)^{-1} B\\), which (for \\(\lambda = 0\\)) is the minimum-norm solution to the under-determined linear system, i.e. \\(X = \mathrm{argmin}_{Z \in \Re^{n \times k}} ||Z||_F^2 \\), subject to \\(A Z = B\\). Notice that the fast path is only numerically stable when \\(A\\) is numerically full rank and has a condition number \\(\mathrm{cond}(A) \lt \frac{1}{\sqrt{\epsilon_{mach}}}\\) or\\(\lambda\\) is sufficiently large. If `fast` is `False` an algorithm based on the numerically robust complete orthogonal decomposition is used. This computes the minimum-norm least-squares solution, even when \\(A\\) is rank deficient. This path is typically 6-7 times slower than the fast path. If `fast` is `False` then `l2_regularizer` is ignored. Args: matrix: `Tensor` of shape `[..., M, N]`. rhs: `Tensor` of shape `[..., M, K]`. l2_regularizer: 0-D `double` `Tensor`. Ignored if `fast=False`. fast: bool. Defaults to `True`. name: string, optional name of the operation. Returns: output: `Tensor` of shape `[..., N, K]` whose inner-most 2 dimensions form `M`-by-`K` matrices that solve the equations `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]` in the least squares sense. Raises: NotImplementedError: linalg.lstsq is currently disabled for complex128 and l2_regularizer != 0 due to poor accuracy. c|dury|dd}|dd}|jsy|jjjz}|jt j |kD}d}||kDr|ryy)a Determines whether to use the composite or specialized CPU kernel. When the total size of the tensor is larger than the cache size and the batch size is large compared to the smallest matrix dimension, then the composite implementation is inefficient since it has to read the entire tensor from memory multiple times. In this case we fall back to the original CPU kernel, which does all the computational steps on each matrix separately. Only fast mode is supported by the composite impl, so `False` is returned if `fast` is `False`. Args: fast: bool indicating if fast mode in the solver was requested. tensor_shape: The shape of the tensor. Returns: True if the composite impl should be used. False otherwise. FNrTi)is_fully_defined num_elementsrsizenpmin)fast tensor_shaperr& tensor_size is_io_boundL2_CACHE_SIZE_GUESSTIMATEr"s r*_use_composite_implz,matrix_solve_ls.._use_composite_impl0s( u} s#K$L  ( ( * ++- 0A0AAK**,rvvl/CCK &..;  r,cbt||d}t|tj||dS)z3Computes (A^H*A + l2_regularizer)^{-1} * A^H * rhs.Tr#r$r)r+r7r rr"r5r#r9s r*_overdeterminedz(matrix_solve_ls.._overdeterminedRs. &~$ @D $t L MMr,cbt||d}tj|t||dS)z3Computes A^H * (A*A^H + l2_regularizer)^{-1} * rhs.FrNTrO)r+r rr7rPs r*_underdeterminedz)matrix_solve_ls.._underdeterminedXs. &~% AD ??6>$#< MMr,c tjdg5jdd}|jr1|d|dk\rcdddScdddSt j dd}t j |d|dk\fdfdcdddS#1swYyxYw)z>Composite implementation of matrix_solve_ls that supports GPU.r?rNrcSN)rQr#r"r5sr*z:matrix_solve_ls.._composite_impl..msOFC@r,cSrVrW)rSr#r"r5sr*rXz:matrix_solve_ls.._composite_impl..ns$VS.Ar,)rr4 get_shaperBrrr)r"r5r#r&rQrSr6s``` r*_composite_implz(matrix_solve_ls.._composite_impl^s /&#~1N OC%%',l  & & (  |B/ / n= CC "&#~> CC!v.rs3 yy   R 0 0 @ ACCCCs8C! C4ACC r")r6rzbmatrix_solve_ls is currently disabled for complex128 and l2_regularizer != 0 due to poor accuracy.)rGr6) rconvert_to_tensorrr complex128NotImplementedErrorrZr r?) r"r5r#rGr6rLr[rHrQrSs ` ` @@r*r?r?sx DN N C$  h 7& \\V&&&>Q+> / 00!!#,|, 63 77  ) )^$T ;;r,z linalg.eigeigcl|jtjk(s|jtjk(rtj}nJ|jtjk(s|jtj k(rtj }t j|d|\}}||fS)aFComputes the eigen decomposition of a batch of matrices. The eigenvalues and eigenvectors for a non-Hermitian matrix in general are complex. The eigenvectors are not guaranteed to be linearly independent. Computes the eigenvalues and right eigenvectors of the innermost N-by-N matrices in `tensor` such that `tensor[...,:,:] * v[..., :,i] = e[..., i] * v[...,:,i]`, for i=0...N-1. Args: tensor: `Tensor` of shape `[..., N, N]`. Only the lower triangular part of each inner inner matrix is referenced. name: string, optional name of the operation. Returns: e: Eigenvalues. Shape is `[..., N]`. The eigenvalues are not necessarily ordered. v: Eigenvectors. Shape is `[..., N, N]`. The columns of the inner most matrices contain eigenvectors of the corresponding matrices in `tensor` TTout compute_vr6rrfloat32 complex64float64r]r r_)rr6 out_dtypeevs r*r_r_~s0 \\V^^#v||v7G7G'G  I ||v~~%9J9J)J!!I   Fd N$!Q A+r,zlinalg.eigvalseigvalsch|jtjk(s|jtjk(rtj}nJ|jtjk(s|jtj k(rtj }t j|d|\}}|S)a|Computes the eigenvalues of one or more matrices. Note: If your program backpropagates through this function, you should replace it with a call to tf.linalg.eig (possibly ignoring the second output) to avoid computing the eigen decomposition twice. This is because the eigenvectors are used to compute the gradient w.r.t. the eigenvalues. See _SelfAdjointEigV2Grad in linalg_grad.py. Args: tensor: `Tensor` of shape `[..., N, N]`. name: string, optional name of the operation. Returns: e: Eigenvalues. Shape is `[..., N]`. The vector `e[..., :]` contains the `N` eigenvalues of `tensor[..., :, :]`. Frard)rr6rhri_s r*rkrks{& \\V^^#v||v7G7G'G  I ||v~~%9J9J)J!!I   Fe$ O$!Q (r,z linalg.eighself_adjoint_eigc@tj|d|\}}||fS)aComputes the eigen decomposition of a batch of self-adjoint matrices. Computes the eigenvalues and eigenvectors of the innermost N-by-N matrices in `tensor` such that `tensor[...,:,:] * v[..., :,i] = e[..., i] * v[...,:,i]`, for i=0...N-1. Args: tensor: `Tensor` of shape `[..., N, N]`. Only the lower triangular part of each inner inner matrix is referenced. name: string, optional name of the operation. Returns: e: Eigenvalues. Shape is `[..., N]`. Sorted in non-decreasing order. v: Eigenvectors. Shape is `[..., N, N]`. The columns of the inner most matrices contain eigenvectors of the corresponding matrices in `tensor` Trcr6r self_adjoint_eig_v2)rr6rirjs r*rnrns%(  + +Fd N$!Q A+r,zlinalg.eigvalshself_adjoint_eigvalsc<tj|d|\}}|S)aComputes the eigenvalues of one or more self-adjoint matrices. Note: If your program backpropagates through this function, you should replace it with a call to tf.linalg.eigh (possibly ignoring the second output) to avoid computing the eigen decomposition twice. This is because the eigenvectors are used to compute the gradient w.r.t. the eigenvalues. See _SelfAdjointEigV2Grad in linalg_grad.py. Args: tensor: `Tensor` of shape `[..., N, N]`. name: string, optional name of the operation. Returns: e: Eigenvalues. Shape is `[..., N]`. The vector `e[..., :]` contains the `N` eigenvalues of `tensor[..., :, :]`. Frprq)rr6rirms r*rsrss!(  + +Fe$ O$!Q (r,z linalg.svdsvdctj||||\}}}|rtj|||fStj|S)a; Computes the singular value decompositions of one or more matrices. Computes the SVD of each inner matrix in `tensor` such that `tensor[..., :, :] = u[..., :, :] * diag(s[..., :, :]) * transpose(conj(v[..., :, :]))` ```python # a is a tensor. # s is a tensor of singular values. # u is a tensor of left singular vectors. # v is a tensor of right singular vectors. s, u, v = svd(a) s = svd(a, compute_uv=False) ``` Args: tensor: `Tensor` of shape `[..., M, N]`. Let `P` be the minimum of `M` and `N`. full_matrices: If true, compute full-sized `u` and `v`. If false (the default), compute only the leading `P` singular vectors. Ignored if `compute_uv` is `False`. compute_uv: If `True` then left and right singular vectors will be computed and returned in `u` and `v`, respectively. Otherwise, only the singular values will be computed, which can be significantly faster. name: string, optional name of the operation. Returns: s: Singular values. Shape is `[..., P]`. The values are sorted in reverse order of magnitude, so s[..., 0] is the largest value, s[..., 1] is the second largest, etc. u: Left singular vectors. If `full_matrices` is `False` (default) then shape is `[..., M, P]`; if `full_matrices` is `True` then shape is `[..., M, M]`. Not returned if `compute_uv` is `False`. v: Right singular vectors. If `full_matrices` is `False` (default) then shape is `[..., N, P]`. If `full_matrices` is `True` then shape is `[..., N, N]`. Not returned if `compute_uv` is `False`. @compatibility(numpy) Mostly equivalent to numpy.linalg.svd, except that * The order of output arguments here is `s`, `u`, `v` when `compute_uv` is `True`, as opposed to `u`, `s`, `v` for numpy.linalg.svd. * full_matrices is `False` by default as opposed to `True` for numpy.linalg.svd. * tf.linalg.svd uses the standard definition of the SVD \\(A = U \Sigma V^H\\), such that the left singular vectors of `a` are the columns of `u`, while the right singular vectors of `a` are the columns of `v`. On the other hand, numpy.linalg.svd returns the adjoint \\(V^H\\) as the third output argument. ```python import tensorflow as tf import numpy as np s, u, v = tf.linalg.svd(a) tf_a_approx = tf.matmul(u, tf.matmul(tf.linalg.diag(s), v, adjoint_b=True)) u, s, v_adj = np.linalg.svd(a, full_matrices=False) np_a_approx = np.dot(u, np.dot(np.diag(s), v_adj)) # tf_a_approx and np_a_approx should be numerically close. ``` @end_compatibility ) compute_uv full_matricesr6)r rur real)rrxrwr6surjs r*rurusM~    =t M'!Q == Q !! == r,normz linalg.normc"t|||||S)aF Computes the norm of vectors, matrices, and tensors. This function can compute several different vector norms (the 1-norm, the Euclidean or 2-norm, the inf-norm, and in general the p-norm for p > 0) and matrix norms (Frobenius, 1-norm, 2-norm and inf-norm). Args: tensor: `Tensor` of types `float32`, `float64`, `complex64`, `complex128` ord: Order of the norm. Supported values are `'fro'`, `'euclidean'`, `1`, `2`, `np.inf` and any positive real number yielding the corresponding p-norm. Default is `'euclidean'` which is equivalent to Frobenius norm if `tensor` is a matrix and equivalent to 2-norm for vectors. Some restrictions apply: a) The Frobenius norm `'fro'` is not defined for vectors, b) If axis is a 2-tuple (matrix norm), only `'euclidean'`, '`fro'`, `1`, `2`, `np.inf` are supported. See the description of `axis` on how to compute norms for a batch of vectors or matrices stored in a tensor. axis: If `axis` is `None` (the default), the input is considered a vector and a single vector norm is computed over the entire set of values in the tensor, i.e. `norm(tensor, ord=ord)` is equivalent to `norm(reshape(tensor, [-1]), ord=ord)`. If `axis` is a Python integer, the input is considered a batch of vectors, and `axis` determines the axis in `tensor` over which to compute vector norms. If `axis` is a 2-tuple of Python integers it is considered a batch of matrices and `axis` determines the axes in `tensor` over which to compute a matrix norm. Negative indices are supported. Example: If you are passing a tensor that can be either a matrix or a batch of matrices at runtime, pass `axis=[-2,-1]` instead of `axis=None` to make sure that matrix norms are computed. keepdims: If True, the axis indicated in `axis` are kept with size 1. Otherwise, the dimensions in `axis` are removed from the output shape. name: The name of the op. Returns: output: A `Tensor` of the same type as tensor, containing the vector or matrix norms. If `keepdims` is True then the rank of output is equal to the rank of `tensor`. Otherwise, if `axis` is none the output is a scalar, if `axis` is an integer, the rank of `output` is one less than the rank of `tensor`, if `axis` is a 2-tuple the rank of `output` is two less than the rank of `tensor`. Raises: ValueError: If `ord` or `axis` is invalid. @compatibility(numpy) Mostly equivalent to numpy.linalg.norm. Not supported: ord <= 0, 2-norm for matrices, nuclear norm. Other differences: a) If axis is `None`, treats the flattened `tensor` as a vector regardless of rank. b) Explicitly supports 'euclidean' norm as the default, including for higher order tensors. @end_compatibility rordaxiskeepdimsr6)r|r~s r*norm_v2r1s @ V  r,z-keep_dims is deprecated, use keepdims instead keep_dimsc tjd|d|}|d}t|txst|txrt |dk(}|rtt|}t|dt rt|dt r |d|dk(rtd|d d ddtjg}||vrvtd |d |t|t s|td|d ddtjg}tj|r|dkr||vrtd |||f}tj|d|g5tj|}|dvr|r;|dvr6tj|t!j fdtj|} t#j$} tj&t)j*| | t,j.d| gdt!j fd| } tj0|} tj2t#j4t#j6t9j:| ddddd} tj0| | }n0t#j<t#j>|t#j@|z|d}nt#j6|}|dk(r?|dn|d}t#j>||d}|rt#j4||dd}n|tjk(r?|rt#j>||dd}|dn|d}t#j4||d}nCt#jBt#j>t#jB|||dd|z }|stjD||}|cdddS#1swYyxYw)aj Computes the norm of vectors, matrices, and tensors. This function can compute several different vector norms (the 1-norm, the Euclidean or 2-norm, the inf-norm, and in general the p-norm for p > 0) and matrix norms (Frobenius, 1-norm, 2-norm and inf-norm). Args: tensor: `Tensor` of types `float32`, `float64`, `complex64`, `complex128` ord: Order of the norm. Supported values are 'fro', 'euclidean', `1`, `2`, `np.inf` and any positive real number yielding the corresponding p-norm. Default is 'euclidean' which is equivalent to Frobenius norm if `tensor` is a matrix and equivalent to 2-norm for vectors. Some restrictions apply: a) The Frobenius norm `fro` is not defined for vectors, b) If axis is a 2-tuple (matrix norm), only 'euclidean', 'fro', `1`, `2`, `np.inf` are supported. See the description of `axis` on how to compute norms for a batch of vectors or matrices stored in a tensor. axis: If `axis` is `None` (the default), the input is considered a vector and a single vector norm is computed over the entire set of values in the tensor, i.e. `norm(tensor, ord=ord)` is equivalent to `norm(reshape(tensor, [-1]), ord=ord)`. If `axis` is a Python integer, the input is considered a batch of vectors, and `axis` determines the axis in `tensor` over which to compute vector norms. If `axis` is a 2-tuple of Python integers it is considered a batch of matrices and `axis` determines the axes in `tensor` over which to compute a matrix norm. Negative indices are supported. Example: If you are passing a tensor that can be either a matrix or a batch of matrices at runtime, pass `axis=[-2,-1]` instead of `axis=None` to make sure that matrix norms are computed. keepdims: If True, the axis indicated in `axis` are kept with size 1. Otherwise, the dimensions in `axis` are removed from the output shape. name: The name of the op. keep_dims: Deprecated alias for `keepdims`. Returns: output: A `Tensor` of the same type as tensor, containing the vector or matrix norms. If `keepdims` is True then the rank of output is equal to the rank of `tensor`. Otherwise, if `axis` is none the output is a scalar, if `axis` is an integer, the rank of `output` is one less than the rank of `tensor`, if `axis` is a 2-tuple the rank of `output` is two less than the rank of `tensor`. Raises: ValueError: If `ord` or `axis` is invalid. @compatibility(numpy) Mostly equivalent to numpy.linalg.norm. Not supported: ord <= 0, 2-norm for matrices, nuclear norm. Other differences: a) If axis is `None`, treats the flattened `tensor` as a vector regardless of rank. b) Explicitly supports 'euclidean' norm as the default, including for higher order tensors. @end_compatibility rrNFrzF'axis' must be None, an integer, or a tuple of 2 unique integers, got euclideanfroz)'ord' must be a supported matrix norm in z, got z+'ord' must be a supported vector norm, got r|)rrr@)rrcHtjdk\fdfdS)NrcSrVrW)isr*rXz(norm....sr,czSrVrWrranksr*rXz(norm....s Dr,rrs`r*rXznorm..sdiiQ "r,)rc tjtjtjtj |t jS)N)r)r castrsqueezewhere_v2equalrint32)r perm_befores r*rXznorm..s?hmm!!&&x~~k1'EFHll$r,)perm)rwrT)rr)rg?)#rdeprecated_argument_lookuprtuplelistlenint ValueErrorrEinfisrealrr4r\rrr r rangeconcatr list_diffrr transpose expand_dims reduce_maxabsr rusqrt reduce_sumconjpowr)rrrrr6ris_matrix_normsupported_matrix_normssupported_vector_norms positive_axisaxes perm_afterpermed matrix_2_normresultsum_axismax_axisrrs @@r*r|r|ysH 3 3J4?L( He,F 40F#IN ;D tAw $JtAw,D Q47  ""& ) ***5!Q? (( B01u> ?? tS !T\  --1F 4 55*1a8 IIcNcQhC7M,M DSEJ KK Wd ~~dFVH-9  " "6 *F ** C8O~~f%  "  ! !$ ' ) ~~d#&&  # #D- Fq I ( -. / ]] $&* + $$V+>!--    ^//5I!LM   $$]D    v..t EF||F#f <4T!W$$VXE &&vtBx$G& "&&= &&vtAwF&<4T!W$$VXE    VS 94$ O #I   .f s999s J"O00O9)TFNrV)gTN)FTN)rNNN)rNNNN)&__doc__numpyrEtensorflow.python.frameworkrrrrtensorflow.python.opsrrr r r r r $tensorflow.python.ops.gen_linalg_opstensorflow.python.utilrr tensorflow.python.util.tf_exportrr+add_dispatch_supportr-deprecated_endpointsr7rerr?r_rkrnrsrurdeprecated_argsr|rWr,r*rs .+<+&/01(*2.+6 &*R !#<=? 83?83v !8:J KM !!!"23* 4M* Z 5, nn  +( +(\ >~/@AB !!!"34D;5CD;N <2& '< Y2.  / 2 =m-?@A !!!"456B* "35K!LM !!!"89 :N * <\512 !!!%(A)3AJ 6=R(  B)BL v}%&  9;H WH'Wr,