LostTech.TensorFlow : API Documentation

Type LinearOperatorKronecker

Namespace tensorflow.linalg

Parent LinearOperator

Interfaces ILinearOperatorKronecker

Kronecker product between two `LinearOperators`.

This operator composes one or more linear operators `[op1,...,opJ]`, building a new `LinearOperator` representing the Kronecker product: `op1 x op2 x.. opJ` (we omit parentheses as the Kronecker product is associative).

If `opj` has shape `batch_shape_j + [M_j, N_j]`, then the composed operator will have shape equal to `broadcast_batch_shape + [prod M_j, prod N_j]`, where the product is over all operators. #### Performance

The performance of `LinearOperatorKronecker` 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 4 x 4 linear operator composed of two 2 x 2 operators.
            operator_1 = LinearOperatorFullMatrix([[1., 2.], [3., 4.]])
            operator_2 = LinearOperatorFullMatrix([[1., 0.], [2., 1.]])
            operator = LinearOperatorKronecker([operator_1, operator_2]) 
 operator.to_dense()
==> [[1., 2., 0., 0.],
     [3., 4., 0., 0.],
     [2., 4., 1., 2.],
     [6., 8., 3., 4.]] 
 operator.shape
==> [4, 4] 
 operator.log_abs_determinant()
==> scalar Tensor 
 x =... Shape [4, 2] Tensor
operator.matmul(x)
==> Shape [4, 2] 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 20 x 30 operators.
operator_large = LinearOperatorKronecker([operator_45, operator_56]) 
 # Create a shape [2, 3, 20, 2] vector.
x = tf.random.normal(shape=[2, 3, 6, 2])
operator_large.matmul(x)
==> Shape [2, 3, 30, 2] Tensor

Properties

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;