This operator acts like a [batch] diagonal matrix A with shape
[B1,...,Bb, N, N] for some b >= 0. The first b indices index a
batch member. For every batch index (i1,...,ib), A[i1,...,ib, : :] is
an N x N matrix. This matrix A is not materialized, but for
purposes of broadcasting this shape will be relevant.
LinearOperatorDiag is initialized with a (batch) vector.
# Create a 2 x 2 diagonal linear operator.diag=[1.,-1.]operator=LinearOperatorDiag(diag)operator.to_dense()==> [[1.,0.][0.,-1.]]operator.shape==> [2,2]operator.log_abs_determinant()==> scalarTensorx=...Shape[2,4]Tensoroperator.matmul(x)==> Shape[2,4]Tensor# Create a [2, 3] batch of 4 x 4 linear operators.diag=tf.random.normal(shape=[2,3,4])operator=LinearOperatorDiag(diag)# Create a shape [2, 1, 4, 2] vector. Note that this shape is compatible# since the batch dimensions, [2, 1], are broadcast to# operator.batch_shape = [2, 3].y=tf.random.normal(shape=[2,1,4,2])x=operator.solve(y)==> operator.matmul(x)=y
Shape compatibility
This operator acts on [batch] matrix with compatible shape.
x is a batch matrix with compatible shape for matmul and solve if
Suppose operator is a LinearOperatorDiag of shape [N, N],
and x.shape = [N, R]. Then
operator.matmul(x) involves N * R multiplications.
operator.solve(x) involves N divisions and N * R multiplications.
operator.determinant() involves a size Nreduce_prod.
If instead operator and x have shape [B1,...,Bb, N, N] and
[B1,...,Bb, N, R], every operation increases in complexity by B1*...*Bb.
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.
Args
diag
Shape [B1,...,Bb, N]Tensor with b >= 0N >= 0.
The diagonal of the operator. Allowed dtypes: float16, float32,
float64, complex64, complex128.
is_non_singular
Expect that this operator is non-singular.
is_self_adjoint
Expect that this operator is equal to its hermitian
transpose. If diag.dtype is real, this is auto-set to True.
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.
Raises
TypeError
If diag.dtype is not an allowed type.
ValueError
If diag.dtype is real, and is_self_adjoint is not True.
Attributes
H
Returns the adjoint of the current LinearOperator.
Given A representing this LinearOperator, return A*.
Note that calling self.adjoint() and self.H are equivalent.
batch_shape
TensorShape of batch dimensions of this LinearOperator.
If this operator acts like the batch matrix A with
A.shape = [B1,...,Bb, M, N], then this returns
TensorShape([B1,...,Bb]), equivalent to A.shape[:-2]
diag
domain_dimension
Dimension (in the sense of vector spaces) of the domain of this operator.
If this operator acts like the batch matrix A with
A.shape = [B1,...,Bb, M, N], then this returns N.
dtype
The DType of Tensors handled by this LinearOperator.
graph_parents
List of graph dependencies of this LinearOperator. (deprecated)
is_non_singular
is_positive_definite
is_self_adjoint
is_square
Return True/False depending on if this operator is square.
parameters
Dictionary of parameters used to instantiate this LinearOperator.
range_dimension
Dimension (in the sense of vector spaces) of the range of this operator.
If this operator acts like the batch matrix A with
A.shape = [B1,...,Bb, M, N], then this returns M.
shape
TensorShape of this LinearOperator.
If this operator acts like the batch matrix A with
A.shape = [B1,...,Bb, M, N], then this returns
TensorShape([B1,...,Bb, M, N]), equivalent to A.shape.
tensor_rank
Rank (in the sense of tensors) of matrix corresponding to this operator.
If this operator acts like the batch matrix A with
A.shape = [B1,...,Bb, M, N], then this returns b + 2.
Returns 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 AssertOp, that, when run, will raise an InvalidArgumentError if
the operator is not positive definite.
Efficiently get the [batch] diagonal part of this operator.
If this operator has shape [B1,...,Bb, M, N], this returns a
Tensordiagonal, 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 diagonalmy_operator.diag_part()==> [1.,2.]# Equivalent, but inefficient methodtf.linalg.diag_part(my_operator.to_dense())==> [1.,2.]
Transform [batch] matrix x with left multiplication: x --> Ax.
# 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_jA[...,:,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.
Transform [batch] vector x with left multiplication: x --> Ax.
# Make an operator acting like batch matrix A. Assume A.shape = [..., M, N]operator=LinearOperator(...)X=...# shape [..., N], batch vectorY=operator.matvec(X)Y.shape==> [...,M]Y[...,:]=sum_jA[...,:,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.
Shape of this LinearOperator, determined at runtime.
If this operator acts like the batch matrix A with
A.shape = [B1,...,Bb, M, N], then this returns a Tensor holding
[B1,...,Bb, M, N], equivalent to tf.shape(A).
Solve (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:
# 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.
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:
# 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.
[[["Easy to understand","easyToUnderstand","thumb-up"],["Solved my problem","solvedMyProblem","thumb-up"],["Other","otherUp","thumb-up"]],[["Missing the information I need","missingTheInformationINeed","thumb-down"],["Too complicated / too many steps","tooComplicatedTooManySteps","thumb-down"],["Out of date","outOfDate","thumb-down"],["Samples / code issue","samplesCodeIssue","thumb-down"],["Other","otherDown","thumb-down"]],["Last updated 2023-10-06 UTC."],[],[]]