torch.linalg.norm

torch.linalg.norm(A, ord=None, dim=None, keepdim=False, *, out=None, dtype=None) → Tensor

计算向量或矩阵的 norms（规范/范数）。

如果有更符合中文习惯的说法，可以进一步优化为：

计算向量或矩阵的 norm（范数）。

但根据要求只做自然通顺处理，则原句已经很合适，直接返回:

计算向量或矩阵的范数。

支持浮点型、双精度型、复数浮点型和复数双精度型数据类型的输入。

该函数是计算向量范数还是矩阵范数，取决于以下条件：

如果 dim 是一个 int，则会计算向量的范数。
如果 dim 是一个 2-元组，则会计算矩阵的范数。
如果 dim 和 ord 均为 None，A 将被展平为一维，并计算结果向量的 2-范数。
如果 dim = None 且 ord != None，则 A 必须是1D或2D数组。

ord 定义了要计算的范数。支持的范数包括：

`ord`	矩阵范数	向量范数
无（默认）	Frobenius 范数	2-范数（参见下文）
“fro”	Frobenius 范数	– 不支持 –
“nuc”	核范数	– 不支持 –
inf 由于这里的修改目标是为了使句子更自然、更符合中文习惯，但给定的内容仅为一个标签“inf”，在不改变其意义和结构的前提下，保持原样最为合适。因此直接返回原文： inf	max(sum(abs(x), dim=1))	max(\|x\|)
-∞	min(sum(abs(x), dim=1))	min(\|x\|)
0	– 不支持 –	sum(x ≠ 0)
1	max(sum(abs(x), dim=0))	如下方所示
-1	min(sum(abs(x), dim=0)) （表示先对x取绝对值，然后沿维度0求和，最后取最小值）	如下方所示
2	最大的奇异值	如下方所示
-2	最小奇异值	如下方所示
其他 int 或 float 类型	– 不支持 –	(∑(abs(x)^ord)^{(1 / ord)}

其中inf指的是float('inf')、NumPy的inf对象，或者任何等效的对象。

参见

torch.linalg.vector_norm() 用于计算向量的范数。

torch.linalg.matrix_norm() 用于计算矩阵的范数。

上述函数通常比使用torch.linalg.norm()更清晰和灵活。例如，torch.linalg.norm(A, ord=1, dim=(0, 1))总是计算矩阵范数，而torch.linalg.vector_norm(A, ord=1, dim=(0, 1))可以用来计算两个维度上的向量范数。

参数

A (Tensor) – 形状为(*, n) 或 (*, m, n) 的张量，其中 * 表示零个或多个批次维度。
ord (int, float, inf, -inf, 'fro', 'nuc', optional) – 范数的阶。默认值： None
dim (int, Tuple[int], optional) – 计算向量或矩阵范数的维度。当 dim= None 时，请参见上述说明。默认值： None
keepdim (bool, optional) – 如果设置为True，则减少的维度将保留在结果中作为大小为一的维度。默认值： False

关键字参数

out (Tensor, optional) – 输出张量。默认为None，若未指定则忽略。
dtype (torch.dtype, 可选) – 如果指定了，输入张量在执行操作前会被转换为 dtype 类型，并且返回的张量类型也将是 dtype。默认值： None

返回值

这是一个实值张量，即便在A为复数的情况下也成立。

示例:

>>> from torch import linalg as LA
>>> a = torch.arange(9, dtype=torch.float) - 4
>>> a
tensor([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
>>> B = a.reshape((3, 3))
>>> B
tensor([[-4., -3., -2.],
        [-1.,  0.,  1.],
        [ 2.,  3.,  4.]])

>>> LA.norm(a)
tensor(7.7460)
>>> LA.norm(B)
tensor(7.7460)
>>> LA.norm(B, 'fro')
tensor(7.7460)
>>> LA.norm(a, float('inf'))
tensor(4.)
>>> LA.norm(B, float('inf'))
tensor(9.)
>>> LA.norm(a, -float('inf'))
tensor(0.)
>>> LA.norm(B, -float('inf'))
tensor(2.)

>>> LA.norm(a, 1)
tensor(20.)
>>> LA.norm(B, 1)
tensor(7.)
>>> LA.norm(a, -1)
tensor(0.)
>>> LA.norm(B, -1)
tensor(6.)
>>> LA.norm(a, 2)
tensor(7.7460)
>>> LA.norm(B, 2)
tensor(7.3485)

>>> LA.norm(a, -2)
tensor(0.)
>>> LA.norm(B.double(), -2)
tensor(1.8570e-16, dtype=torch.float64)
>>> LA.norm(a, 3)
tensor(5.8480)
>>> LA.norm(a, -3)
tensor(0.)

使用dim参数计算向量范数：

>>> c = torch.tensor([[1., 2., 3.],
...                   [-1, 1, 4]])
>>> LA.norm(c, dim=0)
tensor([1.4142, 2.2361, 5.0000])
>>> LA.norm(c, dim=1)
tensor([3.7417, 4.2426])
>>> LA.norm(c, ord=1, dim=1)
tensor([6., 6.])

使用dim参数计算矩阵范数：

>>> A = torch.arange(8, dtype=torch.float).reshape(2, 2, 2)
>>> LA.norm(A, dim=(1,2))
tensor([ 3.7417, 11.2250])
>>> LA.norm(A[0, :, :]), LA.norm(A[1, :, :])
(tensor(3.7417), tensor(11.2250))