pytorch数据统计

1. 张量范数

关于范数的理解可以参考这篇文章，在Pytorch中矩阵的范数主要通过以下接口实现。

torch.norm(input, p='fro', dim=None, keepdim=False, out=None, dtype=None)

返回给定张量的矩阵范数或向量范数。

注意torch.norm 已弃用，可能会在未来的 PyTorch 版本中删除。

在计算向量范数时使用 torch.linalg.norm()，或者在计算矩阵范数时使用 torch.linalg.vector_norm() 和 torch.linalg.matrix_norm()。但是请注意，这些函数的签名与 torch.norm 的签名略有不同。

参数

• input (Tensor) –

  输入张量。它的数据类型必须是浮点数或复数类型。对于复数输入，范数是使用每个元素的绝对值计算的。如果输入是复数并且既没有指定 dtype 也没有指定 out，则结果的数据类型将是相应的浮点类型（例如，如果输入是 complexfloat，则为 float）。

• p(int, float, inf, -inf, 'fro', 'nuc', optional)

    范数的顺序。默认值：'fro' 可以计算以下范数：

  可以在任意数量的维度上计算向量范数。将输入的对应任意数量维度展平为一维，并在展平的维度上计算范数。Frobenius 范数在所有情况下都产生与 p=2 相同的结果，除非当 dim 是三个或更多维度时，在这种情况下 Frobenius 范数会引发错误。Nuclear 范数只能在两个维度上计算。

• dim(int, tuple of python: ints, list of python:ints, optional)

指定要计算范数的input的维度。如果 dim 为 None，则将在input的所有维度上计算范数。如果 p 所指示的范数类型不支持指定的维数，则会发生错误。

• keepdim(bool, optional)

输出张量是否保留了dim。如果dim = None 和out = None，则忽略。默认值：False

• out(Tensor, optional)

输出张量。如果dim = None 和out = None，则忽略。

• dtype(torch.dtype, optional)

返回张量的所需数据类型。如果指定，则在执行操作时将输入张量转换为 :attr:'dtype'。默认值：无。

注意：尽管 p='fro' 支持任意数量的维度，但 Frobenius 范数的真正数学定义仅适用于恰好具有两个维度的张量。带有 ord='fro' 的 torch.linalg.norm() 与数学定义一致，因为它只能应用于恰好两个维度。

举例：

>>> import torch
>>> 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.]])
>>> torch.norm(a)
tensor(7.7460)
>>> torch.norm(b)
tensor(7.7460)
>>> torch.norm(a, float('inf'))
tensor(4.)
>>> torch.norm(b, float('inf'))
tensor(4.)
>>> c = torch.tensor([[ 1, 2, 3],[-1, 1, 4]] , dtype= torch.float)
>>> torch.norm(c, dim=0)
tensor([1.4142, 2.2361, 5.0000])
>>> torch.norm(c, dim=1)
tensor([3.7417, 4.2426])
>>> torch.norm(c, p=1, dim=1)
tensor([6., 6.])
>>> d = torch.arange(8, dtype= torch.float).reshape(2,2,2)
>>> torch.norm(d, dim=(1,2))
tensor([ 3.7417, 11.2250])
>>> torch.norm(d[0, :, :]), torch.norm(d[1, :, :])
(tensor(3.7417), tensor(11.2250))

2. 张量统计

最基础的统计方法，比如张量中的最小值、最大值、均值、累加、累积。

举个例子：

>>> a = torch.arange(8).view(2, 4).float()
>>> a
tensor([[0., 1., 2., 3.],
        [4., 5., 6., 7.]])
>>> a.min(), a.max(), a.mean(), a.sum(), a.prod() # 分别求最小值、最大值、均值、累加、累积
(tensor(0.), tensor(7.), tensor(3.5000), tensor(28.), tensor(0.))
>>> a.argmin(), a.argmax() # 分别是把张量打平后最小值、最大值的索引
(tensor(0), tensor(7))
>>> a.argmin(1), a.argmax(1) # 不打平求 1 维度中每一部分最小值、最大值的索引
(tensor([0, 0]), tensor([3, 3]))

dim和keepdim

>>> a = torch.randn(5, 10)
>>> a
tensor([[-0.6346, -0.9074,  0.1525,  0.1901, -0.5391, -0.2437,  1.0150, -0.0427,
         -1.5336,  0.8542],
        [-0.1879,  1.9947, -0.3524, -1.2559, -0.8129, -0.3018,  0.5654,  0.8428,
         -0.3517, -0.7787],
        [ 0.0686,  0.6166,  0.2632, -0.0947, -0.5592, -1.4041,  1.5565,  1.5616,
         -1.3076, -0.1137],
        [ 0.5205, -1.5716, -1.1277,  0.8096, -0.2123, -0.0974,  0.7698,  1.1373,
          0.5165,  0.5256],
        [-0.4162,  0.3170,  0.2368,  1.1695, -0.1960, -0.3285,  0.2420,  1.6468,
          0.2646,  0.4573]])
>>> a.max(dim=1)
(tensor([1.0150, 1.9947, 1.5616, 1.1373, 1.6468]), tensor([6, 1, 7, 7, 7]))
>>> a.argmax(dim=1)
tensor([6, 1, 7, 7, 7])

max 添加 dim 后不仅显示了 1 维度中每一部分的最大值，还显示了其索引

>>> a.max(dim=1, keepdim=True)
(tensor([[1.0150],
        [1.9947],
        [1.5616],
        [1.1373],
        [1.6468]]), tensor([[6],
        [1],
        [7],
        [7],
        [7]]))
>>> a.argmax(dim=1, keepdim=True)
tensor([[6],
        [1],
        [7],
        [7],
        [7]])

保持维度一致。添加 keepdim 后，得出的结果维度不改变，原来是二维的数据，得出的结果还是二维。不添加得出的结果就是一维的。

3. 比较操作

• torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor）

沿给定 dim 维度返回输入张量 input 中 k 个最大值。 如果不指定 dim，则默认为 input 的最后一维。 如果为 largest 为 False ，则返回最小的 k 个值。

返回一个元组 (values,indices)，其中 indices 是原始输入张量 input 中测元素下标。 如果设定布尔值 sorted 为_True_，将会确保返回的 k 个值被排序。

• torch.kthvalue(input, k, dim=None, out=None) -> (Tensor, LongTensor)

取输入张量 input 指定维上第 k 个最小值。如果不指定 dim，则默认为 input 的最后一维。

返回一个元组 (values,indices)，其中indices是原始输入张量input中沿dim维的第 k 个最小值下标。

举个例子：

>>> b = torch.randn(5, 10)
>>> b
tensor([[ 0.1863,  0.0160, -1.0657, -1.8984,  2.3274,  0.6534,  1.8126,  1.8666,
          0.4830, -0.7800],
        [-0.9359, -1.0655,  0.8321,  1.6265,  0.6812, -0.2870,  0.6987,  0.6067,
         -0.1318,  0.7819],
        [-3.1129,  0.9571, -0.1319, -1.0016,  0.7267,  0.1060, -0.2926,  0.3492,
          1.0026,  0.2924],
        [-0.7101, -0.8327,  0.5463,  0.3805, -0.8720, -1.6723,  0.0365,  1.5540,
          0.1940,  1.4294],
        [ 0.4174, -0.9414, -0.0351, -1.6142, -0.7802, -2.3916, -2.4822,  0.7233,
         -0.7037,  0.2725]])
>>> b.topk(3, dim=1)
(tensor([[2.3274, 1.8666, 1.8126],
        [1.6265, 0.8321, 0.7819],
        [1.0026, 0.9571, 0.7267],
        [1.5540, 1.4294, 0.5463],
        [0.7233, 0.4174, 0.2725]]), tensor([[4, 7, 6],
        [3, 2, 9],
        [8, 1, 4],
        [7, 9, 2],
        [7, 0, 9]]))
>>> b.topk(3, dim=1, largest=False)
(tensor([[-1.8984, -1.0657, -0.7800],
        [-1.0655, -0.9359, -0.2870],
        [-3.1129, -1.0016, -0.2926],
        [-1.6723, -0.8720, -0.8327],
        [-2.4822, -2.3916, -1.6142]]), tensor([[3, 2, 9],
        [1, 0, 5],
        [0, 3, 6],
        [5, 4, 1],
        [6, 5, 3]]))
>>> a.kthvalue(8, dim=1)
(tensor([0.1034, 0.8940, 0.6155, 0.4210, 0.1955]), tensor([1, 2, 6, 4, 7]))

topk 添加 largest=False 就是返回最小，不添加就是返回最大。

kthvalue 返回以从大到小排列的指定位置的数。上面代码中即为返回第 8 小的数。

• torch.eq(input, other, out=None) → Tensor 比较元素相等性。第二个参数可为一个数或与第一个参数同类型形状的张量。
• torch.equal(tensor1, tensor2) → bool 如果两个张量有相同的形状和元素值，则返回 True ，否则 False。

举个例子：

>>> a = torch.ones(2, 3)
>>> b = torch.randn(2, 3)
>>> torch.eq(a, b)
tensor([[0, 0, 0],
        [0, 0, 0]], dtype=torch.uint8)
>>> torch.eq(a, a)
tensor([[1, 1, 1],
        [1, 1, 1]], dtype=torch.uint8)
>>> torch.equal(a, a)
True

eq 比较张量中的每个数据，equal 比较整个张量