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.
• 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.