LostTech.TensorFlow : API Documentation

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

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

Public properties

object batch_shape get;

object batch_shape_dyn get;

Dimension domain_dimension get;

object domain_dimension_dyn get;

object dtype get;

object dtype_dyn get;

IList<object> graph_parents get;

object graph_parents_dyn get;

Nullable<bool> is_non_singular get;

object is_non_singular_dyn get;

object is_positive_definite get;

object is_positive_definite_dyn get;

object is_self_adjoint get;

object is_self_adjoint_dyn get;

Nullable<bool> is_square get;

object is_square_dyn get;

object name get;

object name_dyn get;

object name_scope get;

object name_scope_dyn get;

IList<object> operators get;

object operators_dyn get;

object PythonObject get;

Dimension range_dimension get;

object range_dimension_dyn get;

TensorShape shape get;

object shape_dyn get;

ValueTuple<object> submodules get;

object submodules_dyn get;

Nullable<int> tensor_rank get;

object tensor_rank_dyn get;

object trainable_variables get;

object trainable_variables_dyn get;

object variables get;

object variables_dyn get;