Type LinearOperatorComposition
Namespace tensorflow.linalg
Parent LinearOperator
Interfaces ILinearOperatorComposition
Composes one or more `LinearOperators`. This operator composes one or more linear operators `[op1,...,opJ]`,
building a new `LinearOperator` with action defined by: ```
op_composed(x) := op1(op2(...(opJ(x)...))
``` If `opj` acts like [batch] matrix `Aj`, then `op_composed` acts like the
[batch] matrix formed with the multiplication `A1 A2...AJ`. If `opj` has shape `batch_shape_j + [M_j, N_j]`, then we must have
`N_j = M_{j+1}`, in which case the composed operator has shape equal to
`broadcast_batch_shape + [M_1, N_J]`, where `broadcast_batch_shape` is the
mutual broadcast of `batch_shape_j`, `j = 1,...,J`, assuming the intermediate
batch shapes broadcast. Even if the composed shape is well defined, the
composed operator's methods may fail due to lack of broadcasting ability in
the defining operators' methods.
#### Performance The performance of `LinearOperatorComposition` on any operation is equal to
the sum of the individual operators' operations. #### 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.
Show Example
# Create a 2 x 2 linear operator composed of two 2 x 2 operators. operator_1 = LinearOperatorFullMatrix([[1., 2.], [3., 4.]]) operator_2 = LinearOperatorFullMatrix([[1., 0.], [0., 1.]]) operator = LinearOperatorComposition([operator_1, operator_2]) operator.to_dense() ==> [[1., 2.] [3., 4.]] operator.shape ==> [2, 2] operator.log_abs_determinant() ==> scalar Tensor x =... Shape [2, 4] Tensor operator.matmul(x) ==> Shape [2, 4] Tensor # Create a [2, 3] batch of 4 x 5 linear operators. matrix_45 = tf.random.normal(shape=[2, 3, 4, 5]) operator_45 = LinearOperatorFullMatrix(matrix) # Create a [2, 3] batch of 5 x 6 linear operators. matrix_56 = tf.random.normal(shape=[2, 3, 5, 6]) operator_56 = LinearOperatorFullMatrix(matrix_56) # Compose to create a [2, 3] batch of 4 x 6 operators. operator_46 = LinearOperatorComposition([operator_45, operator_56]) # Create a shape [2, 3, 6, 2] vector. x = tf.random.normal(shape=[2, 3, 6, 2]) operator.matmul(x) ==> Shape [2, 3, 4, 2] Tensor
Methods
Properties
 batch_shape
 batch_shape_dyn
 domain_dimension
 domain_dimension_dyn
 dtype
 dtype_dyn
 graph_parents
 graph_parents_dyn
 is_non_singular
 is_non_singular_dyn
 is_positive_definite
 is_positive_definite_dyn
 is_self_adjoint
 is_self_adjoint_dyn
 is_square
 is_square_dyn
 name
 name_dyn
 name_scope
 name_scope_dyn
 operators
 operators_dyn
 PythonObject
 range_dimension
 range_dimension_dyn
 shape
 shape_dyn
 submodules
 submodules_dyn
 tensor_rank
 tensor_rank_dyn
 trainable_variables
 trainable_variables_dyn
 variables
 variables_dyn
Public instance methods
object matmul_dyn(object x, ImplicitContainer<T> adjoint, ImplicitContainer<T> adjoint_arg, ImplicitContainer<T> name)
Transform [batch] matrix `x` with left multiplication: `x > Ax`.
Parameters

object
x  `LinearOperator` or `Tensor` with compatible shape and same `dtype` as `self`. See class docstring for definition of compatibility.

ImplicitContainer<T>
adjoint  Python `bool`. If `True`, left multiply by the adjoint: `A^H x`.

ImplicitContainer<T>
adjoint_arg  Python `bool`. If `True`, compute `A x^H` where `x^H` is the hermitian transpose (transposition and complex conjugation).

ImplicitContainer<T>
name  A name for this `Op`.
Returns

object
 A `LinearOperator` or `Tensor` with shape `[..., M, R]` and same `dtype` as `self`.
Show Example
# 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]
Tensor matvec(ndarray x, bool adjoint, string name)
Transform [batch] vector `x` with left multiplication: `x > Ax`.
Parameters

ndarray
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.

bool
adjoint  Python `bool`. If `True`, left multiply by the adjoint: `A^H x`.

string
name  A name for this `Op`.
Returns

Tensor
 A `Tensor` with shape `[..., M]` and same `dtype` as `self`.
Show Example
# Make an operator acting like batch matric 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]
object solve(IEnumerable<PythonClassContainer> rhs, bool adjoint, bool adjoint_arg, string name)
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:
Parameters

IEnumerable<PythonClassContainer>
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.

bool
adjoint  Python `bool`. If `True`, solve the system involving the adjoint of this `LinearOperator`: `A^H X = rhs`.

bool
adjoint_arg  Python `bool`. If `True`, solve `A X = rhs^H` where `rhs^H` is the hermitian transpose (transposition and complex conjugation).

string
name  A name scope to use for ops added by this method.
Returns

object
 `Tensor` with shape `[...,N, R]` and same `dtype` as `rhs`.
Show Example
# 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
object solve(LinearOperator rhs, bool adjoint, bool adjoint_arg, string name)
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:
Parameters

LinearOperator
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.

bool
adjoint  Python `bool`. If `True`, solve the system involving the adjoint of this `LinearOperator`: `A^H X = rhs`.

bool
adjoint_arg  Python `bool`. If `True`, solve `A X = rhs^H` where `rhs^H` is the hermitian transpose (transposition and complex conjugation).

string
name  A name scope to use for ops added by this method.
Returns

object
 `Tensor` with shape `[...,N, R]` and same `dtype` as `rhs`.
Show Example
# 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
object solve(IGraphNodeBase rhs, bool adjoint, bool adjoint_arg, string name)
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:
Parameters

IGraphNodeBase
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.

bool
adjoint  Python `bool`. If `True`, solve the system involving the adjoint of this `LinearOperator`: `A^H X = rhs`.

bool
adjoint_arg  Python `bool`. If `True`, solve `A X = rhs^H` where `rhs^H` is the hermitian transpose (transposition and complex conjugation).

string
name  A name scope to use for ops added by this method.
Returns

object
 `Tensor` with shape `[...,N, R]` and same `dtype` as `rhs`.
Show Example
# 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