LostTech.TensorFlow : API Documentation

Type LinearOperatorAdjoint

Namespace tensorflow.linalg

Parent LinearOperator

Interfaces ILinearOperatorAdjoint

`LinearOperator` representing the adjoint of another operator.

This operator represents the adjoint of another operator. #### Performance

The performance of `LinearOperatorAdjoint` depends on the underlying operators performance.

#### 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.
            operator = LinearOperatorFullMatrix([[1 - i., 3.], [0., 1. + i]])
            operator_adjoint = LinearOperatorAdjoint(operator) 
 operator_adjoint.to_dense()
==> [[1. + i, 0.]
     [3., 1 - i]] 
 operator_adjoint.shape
==> [2, 2] 
 operator_adjoint.log_abs_determinant()
==> - log(2) 
 x =... Shape [2, 4] Tensor
operator_adjoint.matmul(x)
==> Shape [2, 4] Tensor, equal to operator.matmul(x, adjoint=True)

Methods

Properties

Public instance methods

Tensor add_to_tensor(IGraphNodeBase x, string name)

Add matrix represented by this operator to `mat`. Equiv to `I + mat`.
Parameters
IGraphNodeBase x
string name
A name to give this `Op`.
Returns
Tensor
A `Tensor` with broadcast shape and same `dtype` as `self`.

object add_to_tensor_dyn(object x, ImplicitContainer<T> name)

Add matrix represented by this operator to `mat`. Equiv to `I + mat`.
Parameters
object x
ImplicitContainer<T> name
A name to give this `Op`.
Returns
object
A `Tensor` with broadcast shape and same `dtype` as `self`.

Tensor diag_part(string name)

Efficiently 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.] ```
Parameters
string name
A name for this `Op`.
Returns
Tensor

object diag_part_dyn(ImplicitContainer<T> name)

Efficiently 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.] ```
Parameters
ImplicitContainer<T> name
A name for this `Op`.
Returns
object

object solve(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
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_dyn(object rhs, ImplicitContainer<T> adjoint, ImplicitContainer<T> adjoint_arg, ImplicitContainer<T> 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
object 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.
ImplicitContainer<T> adjoint
Python `bool`. If `True`, solve the system involving the adjoint of this `LinearOperator`: `A^H X = rhs`.
ImplicitContainer<T> adjoint_arg
Python `bool`. If `True`, solve `A X = rhs^H` where `rhs^H` is the hermitian transpose (transposition and complex conjugation).
ImplicitContainer<T> 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

Tensor solvevec(ndarray rhs, bool adjoint, string name)

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:
Parameters
ndarray 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.
bool adjoint
Python `bool`. If `True`, solve the system involving the adjoint of this `LinearOperator`: `A^H X = rhs`.
string name
A name scope to use for ops added by this method.
Returns
Tensor
`Tensor` with shape `[...,N]` 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 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

Tensor solvevec(IEnumerable<PythonClassContainer> rhs, bool adjoint, string name)

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:
Parameters
IEnumerable<PythonClassContainer> 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.
bool adjoint
Python `bool`. If `True`, solve the system involving the adjoint of this `LinearOperator`: `A^H X = rhs`.
string name
A name scope to use for ops added by this method.
Returns
Tensor
`Tensor` with shape `[...,N]` 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 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

object trace(string name)

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.
Parameters
string name
A name for this `Op`.
Returns
object
Shape `[B1,...,Bb]` `Tensor` of same `dtype` as `self`.

object trace_dyn(ImplicitContainer<T> name)

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.
Parameters
ImplicitContainer<T> name
A name for this `Op`.
Returns
object
Shape `[B1,...,Bb]` `Tensor` of same `dtype` as `self`.

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;

object operator get;

object operator_dyn get;

The operator before taking the adjoint.

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;