AVhdZddlZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Z dd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z!ddl"m#Z#ddl$m%Z%ddl$m&Z&ddl$m'Z'ddl$m(Z(ddl)m*Z*dgZ+Gd d!ejXZ-e*d"Gd#dej\ej^ej`$Z1Gd%d&ejdZ3d3d'Z4d(Z5d)Z6e&jnejpe1d4d*Z9e&jnejte1d4d+Z;e&jnejxe1 d5d,Z=e&jnej|e1d4d-Z?e&jneje1d6d.ZAe&jneje1d4d/ZCe&jneje1 d7d0ZEe&jneje1 d6d1ZGe&jneje1d4d2ZIy)8z Base class for linear operators.N)composite_tensor)composite_tensor_gradient)dtypes)ops)tensor_conversion) tensor_shape) tensor_spec) tensor_util) type_spec)type_spec_registry)module) array_ops) check_ops) linalg_ops)math_ops)resource_variable_ops) variables) linalg_impl)linear_operator_util)property_hint_util)slicing) tf_logging)data_structures) deprecation)dispatch)nest)variable_utils) tf_exportLinearOperatorceZdZdZdZdZy)_LinearOperatorGradientz/Composite tensor gradient for `LinearOperator`.c8|jj|SN) _type_spec_to_components)selfvalues \/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/linalg/linear_operator.pyget_gradient_componentsz/_LinearOperatorGradient.get_gradient_components<s    * *5 11ctj|}td|Dryjj }g}t |tj|D]C\}}|+|j tjfd|d3|j |Etj||}jj|S)Nc3$K|]}|du ywr#).0cs r( zF_LinearOperatorGradient.replace_gradient_components..Cs .19 .scFtj|jS)N)dtype)r zeros_liker2)xr's r(zE_LinearOperatorGradient.replace_gradient_components..Os)..q Dr*T)expand_composites) rflattenallr$r%zipappend map_structurepack_sequence_as_from_components) r&r' componentsflat_componentsvalue_componentsflat_grad_componentsgcvcgrad_componentss ` r(replace_gradient_componentsz3_LinearOperatorGradient.replace_gradient_components?sll:.O .o ..  ''66u=ot||4D'EF(B ##   D"& ( ) ##B'(++.0O    , ,_ ==r*N)__name__ __module__ __qualname____doc__r)rEr-r*r(r!r!8s72>r*r!zlinalg.LinearOperatorceZdZdZej ddd dTdZejdUdZ e dZ e dZ e d Z e ejdd d Ze d Ze d Ze dZe dZej*dZe dZdZdVdZe dZdWdZdUdZe dXdZdYdZdUdZe dZ dZdZ!dUdZ"e dZ#d[dZ$dUdZ%d Z&d!Z'd\d"Z(d#Z)d]d$Z*d%Z+d^d&Z,d'Z-ej*d_d(Z. d`d)Z/ dad+Z0d,Z1dbd-Z2dcd.Z3d/Z4ddd0Z5d1Z6ded2Z7d_d3Z8d_d4Z9dfd5Z: dad6Z;dbd7Zd*dfd:Z?e e?dZ@did;ZAdjd9e>d*dfd<ZBdid=ZCdkd9e>d*dfd>ZDdid?ZEd@ZFdldAZGdBZHdmdCZIdDZJdndEZKdFZLdodGZMdHZNdpdIZOdJZPdqdKZQdLZRdMZSe dNZTe dOZUe dPZVdQZWdRZXe dSZYeZZ[y)rraBase class defining a [batch of] linear operator[s]. Subclasses of `LinearOperator` provide access to common methods on a (batch) matrix, without the need to materialize the matrix. This allows: * Matrix free computations * Operators that take advantage of special structure, while providing a consistent API to users. #### Subclassing To enable a public method, subclasses should implement the leading-underscore version of the method. The argument signature should be identical except for the omission of `name="..."`. For example, to enable `matmul(x, adjoint=False, name="matmul")` a subclass should implement `_matmul(x, adjoint=False)`. #### Performance contract Subclasses should only implement the assert methods (e.g. `assert_non_singular`) if they can be done in less than `O(N^3)` time. Class docstrings should contain an explanation of computational complexity. Since this is a high-performance library, attention should be paid to detail, and explanations can include constants as well as Big-O notation. #### Shape compatibility `LinearOperator` subclasses should operate on a [batch] matrix with compatible shape. Class docstrings should define what is meant by compatible shape. Some subclasses may not support batching. Examples: `x` is a batch matrix with compatible shape for `matmul` if ``` operator.shape = [B1,...,Bb] + [M, N], b >= 0, x.shape = [B1,...,Bb] + [N, R] ``` `rhs` is a batch matrix with compatible shape for `solve` if ``` operator.shape = [B1,...,Bb] + [M, N], b >= 0, rhs.shape = [B1,...,Bb] + [M, R] ``` #### Example docstring for subclasses. This operator acts like a (batch) matrix `A` with shape `[B1,...,Bb, M, N]` for some `b >= 0`. The first `b` indices index a batch member. For every batch index `(i1,...,ib)`, `A[i1,...,ib, : :]` is an `m x n` matrix. Again, this matrix `A` may not be materialized, but for purposes of identifying and working with compatible arguments the shape is relevant. Examples: ```python some_tensor = ... shape = ???? operator = MyLinOp(some_tensor) operator.shape() ==> [2, 4, 4] operator.log_abs_determinant() ==> Shape [2] Tensor x = ... Shape [2, 4, 5] Tensor operator.matmul(x) ==> Shape [2, 4, 5] Tensor ``` #### Shape compatibility This operator acts on batch matrices with compatible shape. FILL IN WHAT IS MEANT BY COMPATIBLE SHAPE #### Performance FILL THIS IN #### Matrix property hints This `LinearOperator` is initialized with boolean flags of the form `is_X`, for `X = non_singular, self_adjoint, positive_definite, square`. These have the following meaning: * If `is_X == True`, callers should expect the operator to have the property `X`. This is a promise that should be fulfilled, but is *not* a runtime assert. For example, finite floating point precision may result in these promises being violated. * If `is_X == False`, callers should expect the operator to not have `X`. * If `is_X == None` (the default), callers should have no expectation either way. #### Initialization parameters All subclasses of `LinearOperator` are expected to pass a `parameters` argument to `super().__init__()`. This should be a `dict` containing the unadulterated arguments passed to the subclass `__init__`. For example, `MyLinearOperator` with an initializer should look like: ```python def __init__(self, operator, is_square=False, name=None): parameters = dict( operator=operator, is_square=is_square, name=name ) ... super().__init__(..., parameters=parameters) ``` Users can then access `my_linear_operator.parameters` to see all arguments passed to its initializer. Nz;Do not pass `graph_parents`. They will no longer be used. graph_parentsc |r|dur tdd}|r|dur tdd}|r|dur tdd}||_||j|ng|_|rt j |j n||_||_||_ ||_ |j||_ d|_ |xst|j|_y)aInitialize the `LinearOperator`. **This is a private method for subclass use.** **Subclasses should copy-paste this `__init__` documentation.** Args: dtype: The type of the this `LinearOperator`. Arguments to `matmul` and `solve` will have to be this type. graph_parents: (Deprecated) Python list of graph prerequisites of this `LinearOperator` Typically tensors that are passed during initialization is_non_singular: Expect that this operator is non-singular. is_self_adjoint: Expect that this operator is equal to its hermitian transpose. If `dtype` is real, this is equivalent to being symmetric. is_positive_definite: Expect that this operator is positive definite, meaning the quadratic form `x^H A x` has positive real part for all nonzero `x`. Note that we do not require the operator to be self-adjoint to be positive-definite. See: https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices is_square: Expect that this operator acts like square [batch] matrices. name: A name for this `LinearOperator`. parameters: Python `dict` of parameters used to instantiate this `LinearOperator`. Raises: ValueError: If any member of graph_parents is `None` or not a `Tensor`. ValueError: If hints are set incorrectly. Fz2A positive definite matrix is always non-singular.Tz'A non-singular matrix is always square.z'A self-adjoint matrix is always square.N) ValueError"_is_square_set_or_implied_by_hints_set_graph_parents_graph_parentsras_dtype base_dtype_dtype_is_non_singular_is_self_adjoint_is_positive_definite_no_dependency _parameters_parameters_sanitizedtyperF_name) r&r2rKis_non_singularis_self_adjointis_positive_definite is_squarename parameterss r(__init__zLinearOperator.__init__sN E !MNNo e BCCi e BCCi.7D+  m,d7<&//%(33%DK+D+D!5D**:6D!&D,d,,DJr*c#K|j}||d|zz }tj|5}|dddy#1swYyxYww)z(Helper function to standardize op scope.N/)r`r name_scope)r&r` full_namescopes r( _name_scopezLinearOperator._name_scopesL I 3:i  "e ks,A< AAAc,t|jS)zCDictionary of parameters used to instantiate this `LinearOperator`.)dictrXr&s r(razLinearOperator.parameters%s   !!r*c|jS)z:The `DType` of `Tensor`s handled by this `LinearOperator`.)rSrks r(r2zLinearOperator.dtype*s ;;r*c|jS)z;Name prepended to all ops created by this `LinearOperator`.)r[rks r(r`zLinearOperator.name/s ::r*zDo not call `graph_parents`.c|jS)z4List of graph dependencies of this `LinearOperator`.)rPrks r(rKzLinearOperator.graph_parents4s   r*c|jSr#)rTrks r(r\zLinearOperator.is_non_singular:   r*c|jSr#)rUrks r(r]zLinearOperator.is_self_adjoint>rpr*c|jSr#)rVrks r(r^z#LinearOperator.is_positive_definiteBs  % %%r*c|j|jk(}|jdur |r td|j|S|jS)zUser set is_square hint to False, but the operator was square.)domain_dimensionrange_dimensionrNrM)r&auto_square_checks r(r_zLinearOperator.is_squareFs\ --1E1EE ..%7>r*c tjd5tj|jj j }tjtjdtj|j|jtj|j|jg|j|z}d|z cdddS#1swYyxYw)zAReturn the maximum condition number that we consider nonsingular. max_nonsingular_condition_numbergY@g?N) rrenpfinfor2as_numpy_dtypeepsrcastrrr)r& dtype_epsrs r(rz7LinearOperator._max_condition_number_to_be_non_singular>s : ;((4::44599i MM   mmD7794::FmmD88:DJJG  jj   &  &c #Xs C C))C2cp|j|5|jcdddS#1swYyxYw)aReturns an `Op` that asserts this operator is non singular. This operator is considered non-singular if ``` ConditionNumber < max{100, range_dimension, domain_dimension} * eps, eps := np.finfo(self.dtype.as_numpy_dtype).eps ``` Args: name: A string name to prepend to created ops. Returns: An `Assert` `Op`, that, when run, will raise an `InvalidArgumentError` if the operator is singular. N)rhrrs r(assert_non_singularz"LinearOperator.assert_non_singularJs3"   $ )  & & ()))rctjd|jrKtjt j tj|jdStd)z4Default implementation of _assert_positive_definite.zUsing (possibly slow) default implementation of assert_positive_definite. Requires conversion to a dense matrix and O(N^3) operations.z!Matrix was not positive definite.rz,assert_positive_definite is not implemented.) rrr]rassert_positivermatrix_diag_partrcholeskyrryrks r(_assert_positive_definitez(LinearOperator._assert_positive_definite^sc LL IJ   & &  $ $Z%8%8%I J577 L MMr*cp|j|5|jcdddS#1swYyxYw)aReturns an `Op` that asserts this operator is positive definite. Here, positive definite means that the quadratic form `x^H A x` has positive real part for all nonzero `x`. Note that we do not require the operator to be self-adjoint to be positive definite. Args: name: A name to give this `Op`. Returns: An `Assert` `Op`, that, when run, will raise an `InvalidArgumentError` if the operator is not positive definite. N)rhrrs r(rz'LinearOperator.assert_positive_definitens3   $ .  + + -...rc|j}tjdtj|t j |dS)NzlUsing (possibly slow) default implementation of assert_self_adjoint. Requires conversion to a dense matrix.z$Matrix was not equal to its adjoint.r)rrrr assert_equallinalgadjoint)r&denses r(_assert_self_adjointz#LinearOperator._assert_self_adjointsE MMOE LL 34  ! ! u6 88r*cp|j|5|jcdddS#1swYyxYw)abReturns an `Op` that asserts this operator is self-adjoint. Here we check that this operator is *exactly* equal to its hermitian transpose. Args: name: A string name to prepend to created ops. Returns: An `Assert` `Op`, that, when run, will raise an `InvalidArgumentError` if the operator is not self-adjoint. N)rhrrs r(assert_self_adjointz"LinearOperator.assert_self_adjoints3   $ )  & & ()))rc|jj|jk7r(td|jd|jd|y)z#Check that arg.dtype == self.dtype.z Expected argument to have dtype z . Found: z in tensor N)r2rR TypeError)r&args r(_check_input_dtypez!LinearOperator._check_input_dtypes> yytzz)  ::syy# ' ((*r*ctd)Nz_matmul is not implemented.rx)r&r4r adjoint_args r(_matmulzLinearOperator._matmuls ; < Ax`. ```python # Make an operator acting like batch matrix A. Assume A.shape = [..., M, N] operator = LinearOperator(...) operator.shape = [..., M, N] X = ... # shape [..., N, R], batch matrix, R > 0. Y = operator.matmul(X) Y.shape ==> [..., M, R] Y[..., :, r] = sum_j A[..., :, j] X[j, r] ``` Args: x: `LinearOperator` or `Tensor` with compatible shape and same `dtype` as `self`. See class docstring for definition of compatibility. adjoint: Python `bool`. If `True`, left multiply by the adjoint: `A^H x`. adjoint_arg: Python `bool`. If `True`, compute `A x^H` where `x^H` is the hermitian transpose (transposition and complex conjugation). name: A name for this `Op`. Returns: A `LinearOperator` or `Tensor` with shape `[..., M, R]` and same `dtype` as `self`. NzIOperators are incompatible. Expected `x` to have dimension {} but got {}.r4rrrrr) isinstancerrrurtrMformatrh _linop_matmulrrrrdimension_at_indexr|assert_is_compatible_withr) r&r4rrr` left_operatorright_operatorself_dimarg_dims r(matmulzLinearOperator.matmulskF!^$(/dllnTm&1qyy{qn  ( ( 4  ( ( 4  ( (M,J,J J $f..0N0NPQ Q   D !A!!-@AA   $  G  > >qs Ka a Bh!rg%% **h 9 9ggg! \\!W+\ F G GAA G Gs*E%BE1%E.1E:returncRt|drt|ds|St|dr%|jr |js td|Stj||}d}d}d}|rtj||}n |durd}d}d}ddlm}|j||g||||S) N _ones_diag multiplier _zeros_diagzhMatmul with non-square `LinearOperator`s or non-square `LinearOperatorZeros` not supported at this time.Frlinear_operator_composition operatorsr\r]r^r_)hasattrr_rMrcombined_non_singular_hinttensorflow.python.ops.linalgrLinearOperatorComposition)r&rrr_r\r]r^rs r(rzLinearOperator._linop_matmuls~|,W 6  /  % %]-D-D K  %..}nMioo! ,GG >   $ K ( B B"N3))3 Cr*c$|j|Sr#)r)r&others r( __matmul__zLinearOperator.__matmul__s ;;u r*ctj|d}|j||}tj|dS)Nrrr)r expand_dimsrsqueeze)r&r4rx_maty_mats r(_matveczLinearOperator._matvecs9  ! !!" -E KKwK /E   U ,,r*cJ|j|5tj|d}|j||rdnd}t j |j |j|j d|j||cdddS#1swYyxYw)a<Transform [batch] vector `x` with left multiplication: `x --> Ax`. ```python # Make an operator acting like batch matrix A. Assume A.shape = [..., M, N] operator = LinearOperator(...) X = ... # shape [..., N], batch vector Y = operator.matvec(X) Y.shape ==> [..., M] Y[..., :] = sum_j A[..., :, j] X[..., j] ``` Args: x: `Tensor` with compatible shape and same `dtype` as `self`. `x` is treated as a [batch] vector meaning for every set of leading dimensions, the last dimension defines a vector. See class docstring for definition of compatibility. adjoint: Python `bool`. If `True`, left multiply by the adjoint: `A^H x`. name: A name for this `Op`. Returns: A `Tensor` with shape `[..., M]` and same `dtype` as `self`. r4rrrrN) rhrrrrrr|rr)r&r4rr`rs r(matveczLinearOperator.matvecs6   $ .  > >qs Ka a Bh%% **h 9 9!''"+ F \\!W\ - ... A=BB"ctjd|jr#tj|j St j|jS)NzUsing (possibly slow) default implementation of determinant. Requires conversion to a dense matrix and O(N^3) operations.) rrrrexplog_abs_determinantrmatrix_determinantrrks r( _determinantzLinearOperator._determinant=sR LL IJ  \\$224 55  ( ( 99r*c|jdur td|j|5|jcdddS#1swYyxYw)zDeterminant for every batch member. Args: name: A name for this `Op`. Returns: `Tensor` with shape `self.batch_shape` and same `dtype` as `self`. Raises: NotImplementedError: If `self.is_square` is `False`. FNDeterminant not implemented for an operator that is expected to not be square.N)r_ryrhrrs r( determinantzLinearOperator.determinantEsS ~~      $ !    !!! AAcdtjd|jrdtjt j |j}dtjtj|dgzStj|j\}}|S)Nrrr) rrrrrrrrr reduce_sumlogrslogdet)r&diag_ log_abs_dets r(_log_abs_determinantz#LinearOperator._log_abs_determinantXs LL IJ   ' ' (;(;DMMO(L Md $$X\\$%7rdC CC^^DMMO4NA{ r*c|jdur td|j|5|jcdddS#1swYyxYw)a Log absolute value of determinant for every batch member. Args: name: A name for this `Op`. Returns: `Tensor` with shape `self.batch_shape` and same `dtype` as `self`. Raises: NotImplementedError: If `self.is_square` is `False`. FrN)r_ryrhrrs r(rz"LinearOperator.log_abs_determinantbsS ~~      $ )  & & ()))r c@|jdur td|rtj|n|}|j r7t j t j|j|Stj|j||S)z&Solve by conversion to a dense matrix.Fz6Solve is not yet implemented for non-square operators.r) r_ryrrrrcholesky_solverrrmatrix_solve_with_broadcastr&rhsrrs r( _dense_solvezLinearOperator._dense_solveus ~~  B DD!,&.. #C   & &   dmmo .55  ; ; g //r*cTtjd|j|||S)z!Default implementation of _solve.ztUsing (possibly slow) default implementation of solve. Requires conversion to a dense matrix and O(N^3) operations.r)rrrrs r(_solvezLinearOperator._solves/ LL IJ   S'{  KKr*c^|jdur td|jdur tdt|tr|r|j n|}|r|j n|}|j T|jH|j |jk7r/tdj|j|j |j|5|j||cdddS|j|5tj|d}|j||rdnd }|rdnd }tj |j"|j%|j"||j'||| cdddS#1swYxYw#1swYyxYw) aSolve (exact or approx) `R` (batch) systems of equations: `A X = rhs`. The returned `Tensor` will be close to an exact solution if `A` is well conditioned. Otherwise closeness will vary. See class docstring for details. Examples: ```python # Make an operator acting like batch matrix A. Assume A.shape = [..., M, N] operator = LinearOperator(...) operator.shape = [..., M, N] # Solve R > 0 linear systems for every member of the batch. RHS = ... # shape [..., M, R] X = operator.solve(RHS) # X[..., :, r] is the solution to the r'th linear system # sum_j A[..., :, j] X[..., j, r] = RHS[..., :, r] operator.matmul(X) ==> RHS ``` Args: rhs: `Tensor` with same `dtype` as this operator and compatible shape. `rhs` is treated like a [batch] matrix meaning for every set of leading dimensions, the last two dimensions defines a matrix. See class docstring for definition of compatibility. adjoint: Python `bool`. If `True`, solve the system involving the adjoint of this `LinearOperator`: `A^H X = rhs`. adjoint_arg: Python `bool`. If `True`, solve `A X = rhs^H` where `rhs^H` is the hermitian transpose (transposition and complex conjugation). name: A name scope to use for ops added by this method. Returns: `Tensor` with shape `[...,N, R]` and same `dtype` as `rhs`. Raises: NotImplementedError: If `self.is_non_singular` or `is_square` is False. FzLExact solve not implemented for an operator that is expected to be singular.zNExact solve not implemented for an operator that is expected to not be square.NzKOperators are incompatible. Expected `rhs` to have dimension {} but got {}.rrrrr)r\ryr_rrrrurtrMrrh _linop_solverrrrrr|rr) r&rrrr`rrrrs r(solvezLinearOperator.solvesR u$    ~~   #~&(/dllnTm(3s{{}n  ( ( 4  ( ( 4  ( (M,J,J J $f..0N0NPQ Q   D !@  ?@@   $  H  @ @ E c c"Bh!rg%% **h 9 9ii !"[[g;[ G H H@@ H HsF BF#F #F,c6t|drt|ds|jStj||}d}d}d}|rtj||}n |durd}d}d}ddlm}ddlm}|j|j||g||||S)NrrFrrlinear_operator_inversionr) rinverserr_rrrr"rLinearOperatorInversion) r&rrr_r\r]r^rr"s r(rzLinearOperator._linop_solves~|,W 6 " " $$#,,]NKIOO*EE o e oo" IF & @ @ % = =m L  ('1 A  r*ctj|d}|j||}tj|dS)z$Default implementation of _solvevec.rrr)rrrr)r&rrrhs_mat solution_mats r( _solveveczLinearOperator._solvevecs9##Cb1G::gw:7L   \ 33r*cJ|j|5tj|d}|j||rdnd}t j |j |j|j d|j||cdddS#1swYyxYw)a!Solve single equation with best effort: `A X = rhs`. The returned `Tensor` will be close to an exact solution if `A` is well conditioned. Otherwise closeness will vary. See class docstring for details. Examples: ```python # Make an operator acting like batch matrix A. Assume A.shape = [..., M, N] operator = LinearOperator(...) operator.shape = [..., M, N] # Solve one linear system for every member of the batch. RHS = ... # shape [..., M] X = operator.solvevec(RHS) # X is the solution to the linear system # sum_j A[..., :, j] X[..., j] = RHS[..., :] operator.matvec(X) ==> RHS ``` Args: rhs: `Tensor` with same `dtype` as this operator. `rhs` is treated like a [batch] vector meaning for every set of leading dimensions, the last dimension defines a vector. See class docstring for definition of compatibility regarding batch dimensions. adjoint: Python `bool`. If `True`, solve the system involving the adjoint of this `LinearOperator`: `A^H X = rhs`. name: A name scope to use for ops added by this method. Returns: `Tensor` with shape `[...,N]` and same `dtype` as `rhs`. Raises: NotImplementedError: If `self.is_non_singular` or `is_square` is False. rrrrrN) rhrrrrrr|rr()r&rrr`rs r(solveveczLinearOperator.solvevecsN   $  2  @ @ E c c"Bh%% **h 9 9#))B- H ^^C^ 1 2 2 2rr`c|jdur|S|j|5|jcdddS#1swYyxYw)aGReturns the adjoint of the current `LinearOperator`. Given `A` representing this `LinearOperator`, return `A*`. Note that calling `self.adjoint()` and `self.H` are equivalent. Args: name: A name for this `Op`. Returns: `LinearOperator` which represents the adjoint of this `LinearOperator`. TN)r]rh_linop_adjointrs r(rzLinearOperator.adjoint7sF t# k  $ #  "###s <Acddlm}|j||j|j|j |j S)Nr)linear_operator_adjointr\r]r^r_)rr.LinearOperatorAdjointr\r]r^r_)r&r.s r(r,zLinearOperator._linop_adjointKsBD " 8 8 ,,,,!66.. 9 ""r*c|jdur td|jdur td|j|5|j cdddS#1swYyxYw)aReturns the Inverse of this `LinearOperator`. Given `A` representing this `LinearOperator`, return a `LinearOperator` representing `A^-1`. Args: name: A name scope to use for ops added by this method. Returns: `LinearOperator` representing inverse of this matrix. Raises: ValueError: When the `LinearOperator` is not hinted to be `non_singular`. FzFCannot take the Inverse: This operator represents a non square matrix.zDCannot take the Inverse: This operator represents a singular matrix.N)r_rMr\rh_linop_inversers r(r#zLinearOperator.inverseTss ~~ . // u$ , --   $ #  "###s AA'cddlm}|j||j|j|j |j S)Nrr!r/)rr"r$r\r]r^r_)r&r"s r(r2zLinearOperator._linop_inversemsE G $ < < ,,,,!66.. = ""r*c|js td|j|5|jcdddS#1swYyxYw)aReturns a Cholesky factor as a `LinearOperator`. Given `A` representing this `LinearOperator`, if `A` is positive definite self-adjoint, return `L`, where `A = L L^T`, i.e. the cholesky decomposition. Args: name: A name for this `Op`. Returns: `LinearOperator` which represents the lower triangular matrix in the Cholesky decomposition. Raises: ValueError: When the `LinearOperator` is not hinted to be positive definite and self adjoint. zTCannot take the Cholesky decomposition: Not a positive definite self adjoint matrix.N)rrMrh_linop_choleskyrs r(rzLinearOperator.cholesky{sT&  ! ! # F GG  $ $  ! ! #$$$s AAczddlm}|jtj|j dddS)Nr) linear_operator_lower_triangularTF)r\r]r_)rr7LinearOperatorLowerTriangularrrr)r&r7s r(r5zLinearOperator._linop_choleskys;M + I IDMMO, J r*c>|jjr |j}n|j}tj|j }||}n|j }tj|||j}|j|S)>Generic and often inefficient implementation. Override often.)num_rowsrr2) rrrrrrtrreyer2r)r&rrnr<s r( _to_densezLinearOperator._to_denses ((*$$k++-k,,T-B-BCI a  & & (a ..!DJJ OC ;;s r*cp|j|5|jcdddS#1swYyxYw)z9Return a dense (batch) matrix representing this operator.N)rhr>rs r(rzLinearOperator.to_denses/  $  ^^ rcHtj|jS)r:)rrrrks r( _diag_partzLinearOperator._diag_parts  % %dmmo 66r*cp|j|5|jcdddS#1swYyxYw)auEfficiently get the [batch] diagonal part of this operator. If this operator has shape `[B1,...,Bb, M, N]`, this returns a `Tensor` `diagonal`, of shape `[B1,...,Bb, min(M, N)]`, where `diagonal[b1,...,bb, i] = self.to_dense()[b1,...,bb, i, i]`. ``` my_operator = LinearOperatorDiag([1., 2.]) # Efficiently get the diagonal my_operator.diag_part() ==> [1., 2.] # Equivalent, but inefficient method tf.linalg.diag_part(my_operator.to_dense()) ==> [1., 2.] ``` Args: name: A name for this `Op`. Returns: diag_part: A `Tensor` of same `dtype` as self. N)rhrArs r( diag_partzLinearOperator.diag_parts12   $  __ rcLtj|jdS)Nrr)rr rCrks r(_tracezLinearOperator._traces   t~~/b 99r*cp|j|5|jcdddS#1swYyxYw)a Trace of the linear operator, equal to sum of `self.diag_part()`. If the operator is square, this is also the sum of the eigenvalues. Args: name: A name for this `Op`. Returns: Shape `[B1,...,Bb]` `Tensor` of same `dtype` as `self`. N)rhrErs r(tracezLinearOperator.traces0   $  [[]rc(|j|zSr#r)r&r4s r(_add_to_tensorzLinearOperator._add_to_tensors ==?Q r*c|j|5tj|d}|j||j |cdddS#1swYyxYw)aAdd matrix represented by this operator to `x`. Equivalent to `A + x`. Args: x: `Tensor` with same `dtype` and shape broadcastable to `self.shape`. name: A name to give this `Op`. Returns: A `Tensor` with broadcast shape and same `dtype` as `self`. r4rN)rhrrrrJ)r&r4r`s r( add_to_tensorzLinearOperator.add_to_tensorsU   $ $  > >qs Ka a   #$$$s 9AAcHtj|jSr#)rself_adjoint_eigvalsrrks r(_eigvalszLinearOperator._eigvalss  * *4==? ;;r*c|js td|j|5|jcdddS#1swYyxYw)aeReturns the eigenvalues of this linear operator. If the operator is marked as self-adjoint (via `is_self_adjoint`) this computation can be more efficient. Note: This currently only supports self-adjoint operators. Args: name: A name for this `Op`. Returns: Shape `[B1,...,Bb, N]` `Tensor` of same `dtype` as `self`. z)Only self-adjoint matrices are supported.N)r]ryrhrOrs r(eigvalszLinearOperator.eigvalssE     K LL  $  ]]_s AA c |js&tj|jd}n#t j |j }t j|dt j|dz S)NFrrr) r]rrrrabsrOrr)r&valss r(_condzLinearOperator._cond sc   ^^DMMO >d\\$--/ *d   2 .   2 . /0r*cp|j|5|jcdddS#1swYyxYw)zReturns the condition number of this linear operator. Args: name: A name for this `Op`. Returns: Shape `[B1,...,Bb]` `Tensor` of same `dtype` as `self`. N)rhrUrs r(rzLinearOperator.conds0   $  ZZ\rc6|jxr |jSr#)r]r^rks r(rz LinearOperator._can_use_cholesky$s    =D$=$==r*c|gn|}t|D]B\}}|,tj|rtj|r4t d||fz||_y)a(Set self._graph_parents. Called during derived class init. This method allows derived classes to set graph_parents, without triggering a deprecation warning (which is invoked if `graph_parents` is passed during `__init__`. Args: graph_parents: Iterable over Tensors. Nz)Graph parent item %d is not a Tensor; %s.) enumerateris_refr is_tf_typerMrP)r&rKits r(rOz!LinearOperator._set_graph_parents'sj(/B]M-(O1 /66q9&11!4D1vMNNO(Dr*cy)awA tuple of parameter names to rebuild the `LinearOperator`. The tuple contains the names of kwargs to the `LinearOperator`'s constructor that the `TypeSpec` needs to rebuild the `LinearOperator` instance. "is_non_singular", "is_self_adjoint", "is_positive_definite", and "is_square" are common to all `LinearOperator` subclasses and may be omitted. r-r-rks r(_composite_tensor_fieldsz'LinearOperator._composite_tensor_fields9s r*cy)aQA tuple of names referring to parameters that may be treated statically. This is a subset of `_composite_tensor_fields`, and contains the names of of `Tensor`-like args to the `LinearOperator`s constructor that may be stored as static values, if they are statically known. These are typically shapes or axis values. r-r-rks r(&_composite_tensor_prefer_static_fieldsz5LinearOperator._composite_tensor_prefer_static_fieldsFs r*cyr#r-rks r(r$zLinearOperator._type_specQs  r*c|jj|}tj|}|jj |S)aRecursively converts ResourceVariables in the LinearOperator to Tensors. The usage of `self._type_spec._from_components` violates the contract of `CompositeTensor`, since it is called on a different nested structure (one containing only `Tensor`s) than `self.type_spec` specifies (one that may contain `ResourceVariable`s). Since `LinearOperator`'s `_from_components` method just passes the contents of the nested structure to `__init__` to rebuild the operator, and any `LinearOperator` that may be instantiated with `ResourceVariables` may also be instantiated with `Tensor`s, this usage is valid. Returns: tensor_operator: `self` with all internal Variables converted to Tensors. )r$r%rconvert_variables_to_tensorsr=)r&r>tensor_componentss r(_convert_variables_to_tensorsz,LinearOperator._convert_variables_to_tensorsYsB //5J&CC ?? + +,= >>r*c2tj|i|S)N)params_overridesslices)r batch_slice)r&ris r( __getitem__zLinearOperator.__getitem__os   tb HHr*cy)a;A dict of names to number of dimensions contributing to an operator. This is a dictionary of parameter names to `int`s specifying the number of right-most dimensions contributing to the **matrix** shape of the densified operator. If the parameter is a `Tensor`, this is mapped to an `int`. If the parameter is a `LinearOperator` (called `A`), this specifies the number of batch dimensions of `A` contributing to this `LinearOperator`s matrix shape. If the parameter is a structure, this is a structure of the same type of `int`s. r-r-rks r(-_experimental_parameter_ndims_to_matrix_ndimszrrArCrErGrJrLrOrQrUrrrOr_rar$rfrkrmr!__composite_gradient__r-r*r(rr[swt;t&56EG"##$(@-G@-D " "     ;$ >?@  ! ! ! ! & &  3  3<<    C $(    ("   ( #  !  !-$  *  *,$>" )(N ."8) (==   <G|.+.=M..`- !.F:!&)& /LKHZ(+(=M( (T4 02d###.>#$w!"###.>#2 "$3$0@$2  78:  $<& 0 >($          ?,I    34r*) metaclassc^eZdZdZdZdZedZdZdZ e dZ dZ d Z d Zd Zy ) _LinearOperatorSpecz+A tf.TypeSpec for `LinearOperator` objects. _param_specs_non_tensor_params_prefer_static_fieldsc.||_||_||_y)aInitializes a new `_LinearOperatorSpec`. Args: param_specs: Python `dict` of `tf.TypeSpec` instances that describe kwargs to the `LinearOperator`'s constructor that are `Tensor`-like or `CompositeTensor` subclasses. non_tensor_params: Python `dict` containing non-`Tensor` and non- `CompositeTensor` kwargs to the `LinearOperator`'s constructor. prefer_static_fields: Python `tuple` of strings corresponding to the names of `Tensor`-like args to the `LinearOperator`s constructor that may be stored as static values, if known. These are typically shapes, indices, or axis values. Nr)r& param_specsnon_tensor_paramsprefer_static_fieldss r(rbz_LinearOperatorSpec.__init__s$D/D!5Dr*cd}t|t|j|z}i}i}t|j D]z\}}t |}t j|D cgc]} t| tj} } t| r|||<\t| s|||<mtd|d||||jScc} w)aBuilds a `_LinearOperatorSpec` from a `LinearOperator` instance. Args: operator: An instance of `LinearOperator`. Returns: linear_operator_spec: An instance of `_LinearOperatorSpec` to be used as the `TypeSpec` of `operator`. r/keyszField z5 contains a mix of `Tensor` and non-`Tensor` values.rrr)_extract_attrssetr_listitems_extract_type_spec_recursivelyrr7rr TypeSpecr8anyryra) clsoperatorvalidation_fieldskwargsrrkvtype_spec_or_vr4 is_tensors r( from_operatorz!_LinearOperatorSpec.from_operators>  225FF GIFKV\\^$ <15a8n LL8:a!3!34:i: Y' A9~ !!F1#.:#;< < < +%LL NN:s+!CcBt|t|jS)Nr)rrr)r&objs r(r%z"_LinearOperatorSpec._to_componentss #D):):$; <rs r(r=z$_LinearOperatorSpec._from_componentss+ $)) 8Z 8F 4?? $V $$r*c|jSr#)rrks r(_component_specsz$_LinearOperatorSpec._component_specss   r*cH|j|j|jfSr#rrks r( _serializez_LinearOperatorSpec._serializes'     # #  & & ((r*c |j|j|jd}|j|t |di|S)Nrr-)rrrupdaterZ)r& overridesrs r(_copyz_LinearOperatorSpec._copysF((!44 $ : :F  MM) 4:  r*cj|jtjfd|jS)zFReturns a TypeSpec representing a batch of objects with this TypeSpec.c&|jSr#)_batch)spec batch_sizes r(r5z,_LinearOperatorSpec._batch..sZ0r*rrrr;rr&rs `r(rz_LinearOperatorSpec._batchs3 ::&& 0      r*cd|jtjd|jS)zBReturns a TypeSpec representing a single element of this TypeSpec.c"|jSr#)_unbatch)rs r(r5z._LinearOperatorSpec._unbatch..s r*rrrs r(rz_LinearOperatorSpec._unbatchs2 ::&& (      r*N)rFrGrHrI __slots__rb classmethodrr%r=rurrrrrr-r*r(r~r~sX3M)6$!N!NF=%  (    r*r~cdj|j}t|tfd|i}t j dj|||t |j|_|S)zBClass decorator to convert `LinearOperator`s to `CompositeTensor`.z{}Specrz{}.{}) rrFrZr~r registerrurr$)r module_name spec_name spec_types r(make_composite_tensorrseoocll+)924|S6IJ)Egnn[)DEiPI334#. *r*cbi}t|D]}t||t|d|zt|dij|g}tfd|Dr|Dcgc] }|us| c}d||<nt d|d|d|d|d |d ||j vr<||7t j||rt j||}||||<t||tjtjfs||j||<|Scc}w) a+Extract constructor kwargs to reconstruct `op`. Args: op: A `LinearOperator` instance. keys: A Python `tuple` of strings indicating the names of the constructor kwargs to extract from `op`. Returns: kwargs: A Python `dict` of kwargs to `op`'s constructor, keyed by `keys`. rrac3&K|]}|u ywr#r-)r.r not_founds r(r0z!_extract_attrs..s ,!1I  ,srz4Could not determine an appropriate value for field `z` in object `z#`. Looked for 1. an attr called `z`, 2. an attr called `_z-`, 3. an entry in `op.parameters` with key 'z'.)objectgetattrgetrrMrar rconstant_valuerrndarraygenerictolist)oprrrsrcsr static_valrs @r(rrsZ &h) %aAy!72sQw #BL"%))!Y7 D ,t ,,"9ay&819!>  B 5 55&):O   vay ) //q :  ! &)&)bjj"**56)""$fQi)%* -:s % D,/D,ct|tjr |jSt|tj r6t j|j|j|jStj|r*tj|j|jSt|trtd|DSt|t j"rt%|j&St|t(rt+|d|DSt|t,r&t+|d|j/DS|S)aXReturn (collection of) `TypeSpec`(s) for `value` if it includes `Tensor`s. If `value` is a `Tensor` or `CompositeTensor`, return its `TypeSpec`. If `value` is a collection containing `Tensor` values, recursively supplant them with their respective `TypeSpec`s in a collection of parallel stucture. If `value` is none of the above, return it unchanged. Args: value: a Python `object` to (possibly) turn into a (collection of) `tf.TypeSpec`(s). Returns: spec: the `TypeSpec` or collection of `TypeSpec`s corresponding to `value` or `value`, if no `Tensor`s are found. )r2 trainablec32K|]}t|ywr#r)r.rs r(r0z1_extract_type_spec_recursively..4sAa.q1Ac32K|]}t|ywr#r)r.r4s r(r0z1_extract_type_spec_recursively..8sHQ5a8Hrc3<K|]\}}|t|fywr#r)r.rrs r(r0z1_extract_type_spec_recursively..:s'21a9!<=2s)rrCompositeTensorr$rVariabler VariableSpecr|r2rr rr TensorSpecrrTrackableDataStructurer __wrapped__tuplerZrjr)r's r(rrs"'778   y))* - - 5;;%// CC5!  ! !%++u{{ ;;t A5A AA==> )%*;*; <<u 4;H%H HHt 4;2#(;;=2 22 ,r*c$|j|Sr#rmatrixr`s r(_adjointrDs  r*c$|j|Sr#roinputr`s r( _choleskyrIs  r*c$|j|Sr#rp)rr`r padding_valuealigns r(rArAQs  r*c$|j|Sr#)r rs r(_detr\s   4  r*cL|j|}|r|j}|Sr#)r#r)rrr`invs r(_inverseras# d# ++-C *r*cj|jr|jr|j|Std)Nz5Expected matrix to be self-adjoint positive definite.)r^r]rrMrs r(_logdetris0   V%;%;  % %d ++JKKr*c |s|r td|s|r tdt|ts,|j|| | | } t j | S|j|||| S)Nz'Transposing not supported at this time.z*Sparse methods not supported at this time.)rrr`)rMrrrrr) ab transpose_a transpose_b adjoint_a adjoint_b a_is_sparse b_is_sparse output_typegrad_agrad_br`adjoint_matmuls r(rrpsK > ??K A BB A~ &XX "]  N >>. ))    >>r*c`t|ts td|j|||S)NzOPassing in `matrix` as a Tensor and `rhs` as a LinearOperator is not supported.)rr`)rrrMr)rrrr`s r(rrs5 FN + 8 99 c7 66r*c$|j|Sr#rq)r4r`s r(rErEs r*)z tf.linalgr#)rCrr RIGHT_LEFT)FN) FFFFFFNFFN)JrIrwrsnumpyrtensorflow.python.frameworkrrrrrrr r r r tensorflow.python.moduler tensorflow.python.opsrrrrrrrrrrrrtensorflow.python.platformrrtensorflow.python.trackablertensorflow.python.utilrrrr tensorflow.python.util.tf_exportr__all__CompositeTensorGradientr!ModulerABCMetarBatchableTypeSpecr~rrrdispatch_for_typesrrrrrCrArnrrrlogdetrrrrrrGrEr-r*r(rs}' 8A.+94331:+++,*7+>=;0<7.+'16  >55>F "#f5 MM#33s{{f5$f5R)` )55` F #L$XV^^^<=V__n=>V--~>   ?VZZ8!9!VZZ8 9 V]]N;L<L X__n=   >>><V\\>:  7;7V\\>:;r*