TensorFlow函数:tf.linalg.LinearOperator
tf.linalg.LinearOperator函数
LinearOperator类
别名:
- tf.contrib.linalg.LinearOperator类
- tf.linalg.LinearOperator类
定义在:tensorflow/python/ops/linalg/linear_operator.py.
请参阅指南:线性代数(contrib)>LinearOperator
定义[batch of]线性运算符[s]的基类.
LinearOperator的子类提供对(batch)矩阵的常用方法的访问,而不需要具体化矩阵.这允许:
- 矩阵自由计算
- 利用特殊结构的操作符,同时为用户提供一致的API.
子类
要启用公共方法,子类应实现方法的前导下划线版本.除了省略name="..."外,参数签名应该相同.例如,要启用matmul(x, adjoint=False, name="matmul"),子类应该实现_matmul(x, adjoint=False).
履约合同
子类应该只实现断言方法(例如,assert_non_singular),如果它们可以在不到O(N^3)时间内完成.
类文档字符串应包含计算复杂性的解释.由于这是一个高性能库,因此应注意细节,解释可以包括常量和Big-O表示法.
形状兼容性
LinearOperator子类应该在具有兼容形状的[batch]矩阵上运行.类文档字符串应该定义兼容形状的含义.某些子类可能不支持批处理.
一个例子是:
x是一个具有matmulif的兼容形状的批处理矩阵,如果满足下列条件:
operator.shape = [B1,...,Bb] + [M, N], b >= 0,
x.shape = [B1,...,Bb] + [N, R]
rhs是一个具有solveif的兼容形状的批处理矩阵,如果满足下列条件:
operator.shape = [B1,...,Bb] + [M, N], b >= 0,
rhs.shape = [B1,...,Bb] + [M, R]
子类的示例文档字符串
该运算符的作用类似于(batch)矩阵A,其形状为[B1,...,Bb, M, N],适合某些b >= 0.第一个b指数索引一个批处理成员.对于每个批次索引(i1,...,ib),A[i1,...,ib, : :],都是一个m x n矩阵.同样,该矩阵A可能没有实现,但为了识别和使用兼容的参数,形状是相关的.
例子:
some_tensor = ... shape = ????
operator = MyLinOp(some_tensor)
operator.shape()
==> [2, 4, 4]
operator.log_abs_determinant()
==> Shape [2] Tensor
x = ... Shape [2, 4, 5] Tensor
operator.matmul(x)
==> Shape [2, 4, 5] Tensor
矩阵属性提示
该LinearOperator是使用表单is_X的布尔标志初始化,用于X = non_singular, self_adjoint, positive_definite, square,它们具有以下含义:
- 如果is_X == True,则调用方应该期望运算符拥有属性X.这是一个应该实现的承诺,但不是运行时断言.例如,有限浮点精度可能导致这些承诺被违反.
- 如果is_X == False,则调用方应该期望运算符没有X.
- 如果is_X == None(默认值),则调用方应该没有任何期望.
属性
- batch_shape
LinearOperator的批处理维度的 TensorShape.
如果这个运算符的作用类似于具有A.shape = [B1,...,Bb, M, N]的批量矩阵A,则返回TensorShape([B1,...,Bb]),相当于A.get_shape()[:-2]
返回:
TensorShape,静态确定,可能是未定义的.
- domain_dimension
此运算符的域的维度(在向量空间的意义上).
如果这个运算符的作用类似于带有A.shape = [B1,...,Bb, M, N]的批量矩阵A,则返回N.
返回:
Dimension对象.
- dtype
LinearOperator处理的张量在DType.
- graph_parents
LinearOperator的图依赖关系列表.
- is_non_singular
- is_positive_definite
- is_self_adjoint
- is_square
返回True/False,取决于此运算符是否为正方形.
- name
名称前置于由LinearOperator创建的所有操作.
- range_dimension
此运算符范围的维度(在向量空间意义上).
如果这个运算符的作用类似于具有A.shape = [B1,...,Bb, M, N]的批量矩阵A,则返回M.
返回:
Dimension对象.
- shape
这个LinearOperator的TensorShape.
如果此运算符的作用类似于带有A.shape = [B1,...,Bb, M, N]的批量矩阵A,则返回TensorShape([B1,...,Bb, M, N]),相当于A.get_shape().
返回:
TensorShape,静态确定,可能是未定义的.
- tensor_rank
对应于该运算符的矩阵的秩(在张量的意义上).
如果这个运算符的作用类似于具有A.shape = [B1,...,Bb, M, N]的批量矩阵A,则返回b + 2.
参数:
- name:这个运算的名字.
返回:
Python整数,如果张量的秩未定义,则为None.
方法
- __init__
__init__( dtype, graph_parents=None, is_non_singular=None, is_self_adjoint=None, is_positive_definite=None, is_square=None, name=None )
该方法用于初始化LinearOperator.
这是子类使用的私有方法,子类应复制粘贴此__init__文档.
参数:
- dtype:该LinearOperator的类型,matmul和solve的参数必须是这种类型.
- graph_parents:LinearOperator的图形先决条件的Python列表,通常在初始化期间传递的张量.
- is_non_singular:期望此运算符是非单数的.
- is_self_adjoint:期望此运算符等于其hermitian转置;如果dtype是真的,这相当于对称.
- is_positive_definite:期望此运算符是正定的,意味着二次型x^H A x对所有非零x都有正实部.注意,我们不要求运算符是自共轭的,是正定的.请参阅:https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices
- is_square:期望此运算符的作用类似于square [batch]矩阵.
- name:该LinearOperator的名称.
可能引发的异常:
- ValueError:如果graph_parents的任何成员是None,而不是一个Tensor.
- ValueError:如果提示设置不正确.
- add_to_tensor
add_to_tensor( x, name='add_to_tensor' )
将此运算符表示的矩阵添加到x,相当于A + x.
参数:
- x:具有相同dtype和形状广播的Tensor,可广播到self.shape.
- name:给操作的名字.
返回:
具有广播形状并且与self有相同dtype的张量.
- assert_non_singular
assert_non_singular(name='assert_non_singular')
返回一个运算,它可以断言此运算符是非单数的.
如果满足以下条件,则这个运算符被认为是非单数的:
ConditionNumber < max{100, range_dimension, domain_dimension} * eps, eps := np.finfo(self.dtype.as_numpy_dtype).eps
参数:
- name:要添加到创建的ops的字符串名称.
返回:
返回一个Assert Op,当运行时,如果操作符是单数的话,将引发一个InvalidArgumentError.
- assert_positive_definite
assert_positive_definite(name='assert_positive_definite')
返回一个运算,断言此运算符是正定的.
这里,正定意味着二次形式x^H A x对于所有非零x都具有正实部.请注意,我们不要求运算符是自共轭的,是正定的.
参数:
- name:这个运算的名称.
返回:
返回一个Assert Op,即在运行时,如果运算符不正定,则会引发InvalidArgumentError.
- assert_self_adjoint
assert_self_adjoint(name='assert_self_adjoint')
返回一个运算,它断言此运算符是自共轭的.
在这里,我们检查此运算符是否与其hermitian转置完全相同.
参数:
- name:要添加到创建的ops的字符串名称.
返回:
返回一个Assert Op,即在运行时,将引发一个InvalidArgumentError,如果运算符不是自共轭的.
- batch_shape_tensor
batch_shape_tensor(name='batch_shape_tensor')
在运行时确定的此运算符的批处理维度的形状.
如果这个操作符的作用类似于带有A.shape = [B1,...,Bb, M, N]的批量矩阵A,则将返回一个具有[B1,...,Bb]的Tensor.
参数:
- name:表示这个运算的名字.
返回:
返回int32类型的Tensor.
- determinant
determinant(name='det')
每个批次成员的决定因素.每个批处理成员的行列式.
参数:
- name:这个运算的名字.
返回:
具有形状self.batch_shape并且与self具有相同dtype的Tensor
可能引发的异常:
- NotImplementedError:如果self.is_square是False.
- diag_part
diag_part(name='diag_part')
有效地获取此运算符的 [批] 对角线部分.
如果这个操作符有形状 [B1,..., Bb, M, N], 这返回一个张量对角线, 形状 [B1,..., Bb, min (M, N)], 其中对角线 [B1,..., bb, i] = 自. to_dense () [B1,..., Bb, 我, 我].
有效地获得此运算符的[batch]对角线部分.
如果此运算符具有形状[B1,...,Bb, M, N],则返回Tensor diagonal,其形状为[B1,...,Bb, min(M, N)],其中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.matrix_diag_part(my_operator.to_dense()) ==> [1., 2.]
参数:
- name:这个运算的名字.
返回:
- diag_part:一个与self具有相同dtype的Tensor.
- domain_dimension_tensor
domain_dimension_tensor(name='domain_dimension_tensor')
此运算符的域的维度(在向量空间的意义上).
在运行时确定.
如果这个操作符的作用类似于具有A.shape = [B1,...,Bb, M, N]的批量矩阵A,则返回N.
参数:
- name:这个运算的名字.
返回:
返回int32类型的Tensor.
- log_abs_determinant
log_abs_determinant(name='log_abs_det')
记录每个批处理成员的行列式的对数绝对值.
参数:
- name:这个运算的名字.
返回:
返回具有形状self.batch_shape并且和self具有相同dtype的Tensor.
可能引发的异常:
- NotImplementedError:如果self.is_square是False.
- matmul
matmul( x, adjoint=False, adjoint_arg=False, name='matmul' )
使用左乘法:x --> Ax转换[batch]矩阵x.
# 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]
参数:
- x:具有兼容的形状,并且和self具有相同dtype的Tensor.
- adjoint:Python bool,如果True,则左边乘以伴随:A^H x.
- adjoint_arg:Python bool,如果True,则计算A x^H,其中x^H是hermitian转置(转置和复合共轭).
- name:这个运算的名字.
返回:
返回具有形状[..., M, R],并且和delf具有相同dtype的Tensor.
- matvec
matvec( x, adjoint=False, name='matvec' )
用左乘法:x --> Ax变换[batch]向量x.
# 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]
参数:
- x:具有兼容的形状,并且和self具有相同dtype的Tensor.x被视为[batch]向量,对每一组前导维度都有意义,最后一个维度定义向量.
- adjoint:Python bool,如果为True,左边乘以伴随:A^H x.
- name:这个运算的名字.
返回:
返回具有形状[..., M],并且和self具有相同dtype的Tensor.
- range_dimension_tensor
range_dimension_tensor(name='range_dimension_tensor')
此运算符范围的维度(在向量空间意义上).
在运行时确定.
如果这个运算符的作用类似于具有A.shape = [B1,...,Bb, M, N]的批量矩阵A,则返回M.
参数:
- name:这个运算的名字.
返回:
返回int32类型的Tensor.
- shape_tensor
shape_tensor(name='shape_tensor')
该LinearOperator的形状,在运行时确定.
如果此操作符的作用类似于具有A.shape = [B1,...,Bb, M, N]的批次矩阵A,则返回一个具有[B1,...,Bb, M, N]的Tensor,相当于tf.shape(A).
参数:
- name:这个运算的名字.
返回:
返回int32类型的Tensor
- solve
solve( rhs, adjoint=False, adjoint_arg=False, name='solve' )
求解(精确或近似)R(批量)方程组:A X = rhs.
如果A条件良好,则返回的Tensor将接近一个精确的解决方案.否则亲密程度会有所不同.
例子:
# 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
参数:
- rhs:Tensor与此运算符和兼容形状相同dtype的Tensor.rhs被视为[batch]矩阵,表示每组前导维度;后两个维度定义矩阵.
- adjoint:Python bool,如果为True,则解决涉及这个LinearOperator伴随的系统:A^H X = rhs.
- adjoint_arg:Python bool,如果为True,则解决A X = rhs^H,其中rhs^H是hermitian转置(转置和复共轭).
- name:用于此方法添加的运算的名称范围.
返回:
返回具有形状[...,N, R],并且和rhs具有相同dtype的Tensor.
可能引发的异常:
- NotImplementedError:如果self.is_non_singular或is_square为False.
- solvevec
solvevec( rhs, adjoint=False, name='solve' )
尽最大努力解决单个方程式:A X = rhs.
如果A条件良好,返回的Tensor将接近一个精确的解决方案.否则亲密程度会有所不同.
例子:
# 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
参数:
- rhs:与此运算符具有相同dtype的Tensor,rhs被视为[batch]向量,对每一组前导维度都有意义,最后一个维度定义向量.
- adjoint:Python bool,如果为True,则解决涉及这个LinearOperator伴随的系统:A^H X = rhs.
- name:用于此方法添加的运算的名称范围.
返回:
返回具有形状[...,N],并且和rhs具有相同dtype的Tensor.
可能引发的异常:
- NotImplementedError:如果self.is_non_singular或is_square是False.
- rhs:与此运算符具有相同dtype的Tensor,rhs被视为[batch]向量,对每一组前导维度都有意义,最后一个维度定义向量.
- tensor_rank_tensor
tensor_rank_tensor(name='tensor_rank_tensor')
对应于该运算符的矩阵的秩(在张量的意义上).
如果这个操作符的作用类似于具有A.shape = [B1,...,Bb, M, N]的批量矩阵A,则返回b + 2.
参数:
- name:这个运算的名字.
返回:
返回int32类型的Tensor,在运行时确定.
- to_dense
to_dense(name='to_dense')
返回表示此运算符的密集(批处理)矩阵.
- trace
trace(name='trace')
线性操作的跟踪,等于self.diag_part()的总和.
如果运算符为平方,则这也是特征值的总和.
参数:
- name:这个运算的名字.
返回:
返回形状为[B1,...,Bb]的Tensor,与self具有相同的dtype.