Python tf.linalg.LinearOperatorBlockLowerTriangular用法及代碼示例

將LinearOperators 組合成一個塊狀下三角矩陣。

繼承自：LinearOperator，Module

用法

tf.linalg.LinearOperatorBlockLowerTriangular(
    operators, is_non_singular=None, is_self_adjoint=None,
    is_positive_definite=None, is_square=None,
    name='LinearOperatorBlockLowerTriangular'
)

該運算符使用嵌套的線性運算符列表進行初始化，這些線性運算符組合成一個新的LinearOperator，其基礎矩陣表示為正方形，並且每個運算符都在主對角線之上或之下，其他地方為零。外部列表的每個元素是與塊結構的row-partition相對應的LinearOperators列表。 row-partion i 中的 LinearOperator 的數量必須等於 i 。

例如，按塊 3 x 3 LinearOperatorBlockLowerTriangular 使用列表 [[op_00], [op_10, op_11], [op_20, op_21, op_22]] 進行初始化，其中 op_ij , i < 3, j <= i 是 LinearOperator 實例。 LinearOperatorBlockLowerTriangular 表現為以下塊狀矩陣，其中 0 表示 appropriately-sized [batch] 零矩陣：

[[op_00,     0,     0],
 [op_10, op_11,     0],
 [op_20, op_21, op_22]]

對角線上的每個 op_jj 都需要表示一個方陣，因此將具有形狀 batch_shape_j + [M_j, M_j] 。分塊結構的j 行中的LinearOperator 必須具有與op_jj 相同的range_dimension，並且j 列中的LinearOperators 必須具有與op_jj 相同的domain_dimension。

如果對角線上的每個 op_jj 具有形狀 batch_shape_j + [M_j, M_j] ，則組合運算符具有形狀 broadcast_batch_shape + [sum M_j, sum M_j] ，其中 broadcast_batch_shape 是 batch_shape_j , j = 0, 1, ..., J 的相互廣播，假設中間批次形狀廣播。即使組合形狀被很好地定義，組合算子的方法也可能由於定義算子的方法中缺乏廣播能力而失敗。

例如，要創建一個由三個 2 x 2 運算符組合而成的 4 x 4 線性運算符：

>>> operator_0 = tf.linalg.LinearOperatorFullMatrix([[1., 2.], [3., 4.]])
>>> operator_1 = tf.linalg.LinearOperatorFullMatrix([[1., 0.], [0., 1.]])
>>> operator_2 = tf.linalg.LinearOperatorLowerTriangular([[5., 6.], [7., 8]])
>>> operator = LinearOperatorBlockLowerTriangular(
...   [[operator_0], [operator_1, operator_2]])

operator.to_dense()
<tf.Tensor:shape=(4, 4), dtype=float32, numpy=
array([[1., 2., 0., 0.],
       [3., 4., 0., 0.],
       [1., 0., 5., 0.],
       [0., 1., 7., 8.]], dtype=float32)>

operator.shape
TensorShape([4, 4])

operator.log_abs_determinant()
<tf.Tensor:shape=(), dtype=float32, numpy=4.3820267>

x0 = [[1., 6.], [-3., 4.]]
x1 = [[0., 2.], [4., 0.]]
x = tf.concat([x0, x1], 0)  # Shape [2, 4] Tensor
operator.matmul(x)
<tf.Tensor:shape=(4, 2), dtype=float32, numpy=
array([[-5., 14.],
       [-9., 34.],
       [ 1., 16.],
       [29., 18.]], dtype=float32)>

上麵的matmul等價於：

>>> tf.concat([operator_0.matmul(x0),
...   operator_1.matmul(x0) + operator_2.matmul(x1)], axis=0)
<tf.Tensor:shape=(4, 2), dtype=float32, numpy=
array([[-5., 14.],
       [-9., 34.],
       [ 1., 16.],
       [29., 18.]], dtype=float32)>

形狀兼容性

該運算符作用於具有兼容形狀的 [batch] 矩陣。 x 是與 matmul 和 solve 的形狀兼容的批處理矩陣，如果

operator.shape = [B1,...,Bb] + [M, N],  with b >= 0
x.shape =        [B1,...,Bb] + [N, R],  with R >= 0.

例如：

創建一個 [2, 3] 批 4 x 4 線性算子：

>>> matrix_44 = tf.random.normal(shape=[2, 3, 4, 4])
>>> operator_44 = tf.linalg.LinearOperatorFullMatrix(matrix_44)

創建一個 [1, 3] 批次的 5 x 4 線性運算符：

>>> matrix_54 = tf.random.normal(shape=[1, 3, 5, 4])
>>> operator_54 = tf.linalg.LinearOperatorFullMatrix(matrix_54)

創建一個 [1, 3] 批 5 x 5 線性運算符：

>>> matrix_55 = tf.random.normal(shape=[1, 3, 5, 5])
>>> operator_55 = tf.linalg.LinearOperatorFullMatrix(matrix_55)

組合創建一個 [2, 3] 批次的 9 x 9 運算符：

>>> operator_99 = LinearOperatorBlockLowerTriangular(
...   [[operator_44], [operator_54, operator_55]])
>>> operator_99.shape
TensorShape([2, 3, 9, 9])

創建一個形狀 [2, 1, 9] 的向量批並將運算符應用於它。

>>> x = tf.random.normal(shape=[2, 1, 9])
>>> y = operator_99.matvec(x)
>>> y.shape
TensorShape([2, 3, 9])

創建向量的塊狀列表並將運算符應用於它。返回一個分塊列表。

>>> x4 = tf.random.normal(shape=[2, 1, 4])
>>> x5 = tf.random.normal(shape=[2, 3, 5])
>>> y_blockwise = operator_99.matvec([x4, x5])
>>> y_blockwise[0].shape
TensorShape([2, 3, 4])
>>> y_blockwise[1].shape
TensorShape([2, 3, 5])

性能

假設operator是由Drow-partitions和Dcolumn-partitions組成的LinearOperatorBlockLowerTriangular，這樣算子的總數就是N = D * (D + 1) // 2。

• operator.matmul 的複雜度等於各個運算符的matmul 複雜度之和。
• operator.solve 的複雜度等於對角線上運算符的solve 複雜度和對角線外運算符的matmul 複雜度之和。
• operator.determinant 的複雜度等於對角線上運算符的determinant 複雜度之和。

矩陣屬性提示

此 LinearOperator 使用 is_X 形式的布爾標誌初始化，用於 X = non_singular, self_adjoint, positive_definite, square 。它們具有以下含義：

• 如果 is_X == True ，調用者應該期望操作符具有屬性 X 。這是一個應該實現的承諾，但不是運行時斷言。例如，有限的浮點精度可能會導致違反這些承諾。
• 如果 is_X == False ，調用者應該期望操作符沒有 X 。
• 如果is_X == None(默認)，調用者應該沒有任何期望。