oneflow.linalg¶

OneFlow linear algebra operations.¶

oneflow.linalg.matrix_norm(input, ord='fro', dim=(- 2, - 1), keepdim=False, *, dtype=None, out=None) → Tensor¶

计算一个矩阵的范数。

支持 float, double, cfloat 和 cdouble 的输入属性。

该函数同时支持矩阵的 batch 。将通过由二元组的 dim 参数指定的维度计算范数，而其他的维度将被当作 batch 维度。输出矩阵将有相同的 batch 维度。

ord 定义了被计算出的矩阵范数。支持下列类型的范数：

`ord`	矩阵范数
‘fro’ (默认)	Frobenius 范数
‘nuc’	– 暂未支持 –
inf	max(sum(abs(x), dim=1))
-inf	min(sum(abs(x), dim=1))
1	max(sum(abs(x), dim=0))
-1	min(sum(abs(x), dim=0))
2	– 暂未支持 –
-2	– 暂未支持 –

此处 inf 指代 float(‘inf’), NumPy 的 inf 对象，或者任意等价的对象。

参数：

input (Tensor): 拥有两个或更多维度的张量。默认情况下，其形状被解释为 (*, m, n) ，其中 * 是零个或更多 batch 维度，但这个解释方法可以通过 dim 控制。
ord (int, inf, -inf, ‘fro’, ‘nuc’, 可选): 范数的类型。默认： ‘fro’
dim (Tuple[int, int], 可选): 用于计算范数的维度。默认： (-2, -1)
keepdim (bool, 可选): 如果设置为 True ，被减少的维度将以大小为一的维度保留。默认： False

返回值：

一个真实值的张量。

示例：

>>> import oneflow as flow
>>> from oneflow import linalg as LA
>>> import numpy as np
>>> a = flow.tensor(np.arange(9, dtype=np.float32)).reshape(3,3)
>>> a
tensor([[0., 1., 2.],
        [3., 4., 5.],
        [6., 7., 8.]], dtype=oneflow.float32)
>>> LA.matrix_norm(a)
tensor(14.2829, dtype=oneflow.float32)
>>> LA.matrix_norm(a, ord=-1)
tensor(9., dtype=oneflow.float32)
>>> b = a.expand(2, -1, -1)
>>> b
tensor([[[0., 1., 2.],
         [3., 4., 5.],
         [6., 7., 8.]],

        [[0., 1., 2.],
         [3., 4., 5.],
         [6., 7., 8.]]], dtype=oneflow.float32)
>>> LA.matrix_norm(b, dim=(0, 2))
tensor([ 3.1623, 10.0000, 17.2627], dtype=oneflow.float32)

oneflow.linalg.norm(input, ord=None, dim=None, keepdim=False, *, dtype=None, out=None) → Tensor¶

返回 input 的矩阵范数或向量范数。

此函数可以计算八种不同类型的矩阵范数之一，或无限数量的向量范数之一。具体取决于减少维度的数量和 ord 参数的值。

参数：

input (Tensor): 输入张量。如果 dim 是 None，则输入必须是一维或二维的，除非 ord 也是 None。

如果 dim 和 ord 都是 None ，则将返回扁平化为 1-D 的输入二范数。它的数据类型必须是浮点数或复数类型。对于复杂输入，范数是根据每个元素的绝对值计算的。

如果输入是复数并且既没有指定 dtype 也没有指定 out ，返回的数据类型将是相应的浮点类型（例如如果 input 是 complexfloat，则为 float）

ord (int, inf, -inf, ‘fro’, ‘nuc’, 可选): 范数的顺序。默认为 ‘None’ 。

可以计算以下范数：

`ord`	矩阵范数	向量范数
None	Frobenius norm	2-norm
‘fro’	Frobenius norm	– 尚不支持 –
‘nuc’	– 尚不支持 –	– 尚不支持 –
inf	max(sum(abs(x), dim=1))	max(abs(x))
-inf	min(sum(abs(x), dim=1))	min(abs(x))
0	– 尚不支持 –	sum(x != 0)
1	max(sum(abs(x), dim=0))	见下
-1	min(sum(abs(x), dim=0))	见下
2	– 尚不支持 –	见下
-2	– 尚不支持 –	见下
其他	– 不支持 –	sum(abs(x)^{ord})^{(1 / ord)}

其中 inf 指的是 float(‘inf’) 、 NumPy 的 inf 对象或任何等效对象。

dim (int, 2-tuple of ints, 2-list of ints, 可选): 如果 dim 是一个 int，向量范数将在指定的维度上计算。

如果 dim 是一个整数的二元组，矩阵范数将在指定的维度上计算。

如果 dim 为 None ，则输入张量是二维张量时计算矩阵范数，输入张量为一维时计算向量范数。默认值：None
keepdim (bool, 可选): 如果设定为 True ，则减少的维度将作为大小为 1 的维度保留在结果中。默认值：False
out (Tensor, 可选): 输出张量

示例：

>>> import oneflow as flow

>>> from oneflow import linalg as LA
>>> a = flow.arange(9, dtype=flow.float32) - 4
>>> a
tensor([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.], dtype=oneflow.float32)
>>> b = a.reshape(3, 3)
>>> b
tensor([[-4., -3., -2.],
        [-1.,  0.,  1.],
        [ 2.,  3.,  4.]], dtype=oneflow.float32)
>>> LA.norm(a)
tensor(7.7460, dtype=oneflow.float32)
>>> LA.norm(b)
tensor(7.7460, dtype=oneflow.float32)
>>> LA.norm(b, 'fro')
tensor(7.7460, dtype=oneflow.float32)
>>> LA.norm(a, float('inf'))
tensor(4., dtype=oneflow.float32)
>>> LA.norm(b, float('inf'))
tensor(9., dtype=oneflow.float32)
>>> LA.norm(a, -float('inf'))
tensor(0., dtype=oneflow.float32)
>>> LA.norm(b, -float('inf'))
tensor(2., dtype=oneflow.float32)
>>> LA.norm(a, 1)
tensor(20., dtype=oneflow.float32)
>>> LA.norm(b, 1)
tensor(7., dtype=oneflow.float32)
>>> LA.norm(a, -1)
tensor(0., dtype=oneflow.float32)
>>> LA.norm(b, -1)
tensor(6., dtype=oneflow.float32)
>>> LA.norm(a, 2)
tensor(7.7460, dtype=oneflow.float32)
>>> LA.norm(a, -2)
tensor(0., dtype=oneflow.float32)
>>> LA.norm(a, 3)
tensor(5.8480, dtype=oneflow.float32)
>>> LA.norm(a, -3)
tensor(0., dtype=oneflow.float32)
>>> c = flow.tensor([[1., 2., 3.],
...                   [-1, 1, 4]])
>>> LA.norm(c, dim=0)
tensor([1.4142, 2.2361, 5.0000], dtype=oneflow.float32)
>>> LA.norm(c, dim=1, keepdim = True)
tensor([[3.7417],
        [4.2426]], dtype=oneflow.float32)
>>> LA.norm(c, ord=1, dim=1)
tensor([6., 6.], dtype=oneflow.float32)

oneflow.linalg.vector_norm(self, ord=2, dim=None, keepdim=False, dtype=None)¶

计算一个矢量范数。

支持 float 和 double 的输入类型。

这个函数不总是将多维张量 input 作为矢量的 batch ，而是：

如果 dim = None, input 将在计算范数前被扁平化。
如果 dim 是一个 int 或者 tuple, 范数将在这些维度上计算，而其他维度将被当作 batch 维度。

此行为是为了与 flow.linalg.norm() 保持一致。

ord 定义了被计算出的矩阵范数。支持下列类型的范数：

`ord`	矢量范数
2 (默认)	2-norm (见下)
inf	max(abs(x))
-inf	min(abs(x))
0	sum(x != 0)
其他 int 或 float	sum(abs(x)^{ord})^{(1 / ord)}

此处 inf 指代 float(‘inf’), NumPy 的 inf 对象，或者任意等价的对象。

参数：

input (Tensor): 输入张量，默认情况下会被扁平化，但是此行为可以用 dim 控制。
ord (int, float, inf, -inf, ‘fro’, ‘nuc’, 可选): 范数的类型。默认： 2
dim (int, Tuple[int], 可选): 用于计算范数的维度。关于 dim= None 时的行为见之前段落。默认： None
keepdim (bool, 可选): 如果设置为 True ，被减少的维度将以大小为一的维度保留。默认： False

返回值：

一个真实值的张量。

示例：

>>> import oneflow as flow
>>> from oneflow import linalg as LA
>>> import numpy as np
>>> a = flow.tensor(np.arange(9, dtype=np.float32) - 4)
>>> a
tensor([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.], dtype=oneflow.float32)
>>> b = a.reshape(3, 3)
>>> b
tensor([[-4., -3., -2.],
        [-1.,  0.,  1.],
        [ 2.,  3.,  4.]], dtype=oneflow.float32)
>>> LA.vector_norm(a, ord=3.5)
tensor(5.4345, dtype=oneflow.float32)
>>> LA.vector_norm(b, ord=3.5)
tensor(5.4345, dtype=oneflow.float32)