This operator acts like a scaled [batch] identity 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
a scaled version of the N x N identity matrix.
LinearOperatorIdentity is initialized with num_rows, and a multiplier
(a Tensor) of shape [B1,...,Bb]. N is set to num_rows, and the
multiplier determines the scale for each batch member.
# Create a 2 x 2 scaled identity matrix.
operator = LinearOperatorIdentity(num_rows=2, multiplier=3.)
operator.to_dense()
==> [[3., 0.]
[0., 3.]]
operator.shape
==> [2, 2]
operator.log_abs_determinant()
==> 2 * Log[3]
x = ... Shape [2, 4] Tensor
operator.matmul(x)
==> 3 * x
y = tf.random.normal(shape=[3, 2, 4])
# Note that y.shape is compatible with operator.shape because operator.shape
# is broadcast to [3, 2, 2].
x = operator.solve(y)
==> 3 * x
# Create a 2-batch of 2x2 identity matrices
operator = LinearOperatorIdentity(num_rows=2, multiplier=5.)
operator.to_dense()
==> [[[5., 0.]
[0., 5.]],
[[5., 0.]
[0., 5.]]]
x = ... Shape [2, 2, 3]
operator.matmul(x)
==> 5 * x
# Here the operator and x have different batch_shape, and are broadcast.
x = ... Shape [1, 2, 3]
operator.matmul(x)
==> 5 * x
Shape compatibility
This operator acts on [batch] matrix with compatible shape.
x is a batch matrix with compatible shape for matmul and solve if
operator.shape = [B1,...,Bb] + [N, N], with b >= 0
x.shape = [C1,...,Cc] + [N, R],
and [C1,...,Cc] broadcasts with [B1,...,Bb] to [D1,...,Dd]
Performance
operator.matmul(x) is O(D1*...*Dd*N*R)
operator.solve(x) is O(D1*...*Dd*N*R)
operator.determinant() is O(D1*...*Dd)
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
num_rows
Scalar non-negative integer Tensor. Number of rows in the
corresponding identity matrix.
multiplier
Tensor of shape [B1,...,Bb], or [] (a scalar).
is_non_singular
Expect that this operator is non-singular.
is_self_adjoint
Expect that this operator is equal to its hermitian
transpose.
Expect that this operator acts like square [batch] matrices.
assert_proper_shapes
Python bool. If False, only perform static
checks that initialization and method arguments have proper shape.
If True, and static checks are inconclusive, add asserts to the graph.
name
A name for this LinearOperator
Raises
ValueError
If num_rows is determined statically to be non-scalar, or
negative.
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]
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.
multiplier
The [batch] scalar Tensor, c in cI.
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 diagonal
my_operator.diag_part()
==> [1., 2.]
# Equivalent, but inefficient method
tf.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_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.
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 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.
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 2020-10-01 UTC."],[],[]]