TensorFlow函数:tf.linalg.LinearOperator

由 Carrie 创建, 最后一次修改 2018-08-08

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。

以上内容是否对您有帮助:
W3Cschool app 编程微课功能上线
二维码
建议反馈
二维码