pytorch学习笔记（六）——pytorch进阶教程之属性统计

目录

范数----norm

范数(norm)是数学中的一种基本概念。在泛函分析中，它定义在赋范线性空间中，并满足一定的条件，即①非负性；②齐次性；③三角不等式。它常常被用来度量某个向量空间（或矩阵）中的每个向量的长度或大小。
范数又分为向量范数和矩阵范数，区别如图所示

In [1]: import torch

In [2]: a = torch.full([8],1)

In [3]: a
Out[3]: tensor([1., 1., 1., 1., 1., 1., 1., 1.])

In [4]: b = a.view(2,4)

In [5]: b
Out[5]:
tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.]])

In [6]: c = a.view(2,2,2)

In [7]: c
Out[7]:
tensor([[[1., 1.],
         [1., 1.]],

        [[1., 1.],
         [1., 1.]]])

In [8]: a.norm(1),b.norm(1),c.norm(1)#1范数为所有元素的绝对值的求和
Out[8]: (tensor(8.), tensor(8.), tensor(8.))

In [9]: a.norm(2),b.norm(2),c.norm(2)#2范数为所有元素绝对值的平方和再开根号
Out[9]: (tensor(2.8284), tensor(2.8284), tensor(2.8284))

In [10]: b.norm(1,dim=1)#在维度1上求1范数
Out[10]: tensor([4., 4.])

In [11]: b.norm(2,dim=1)#在维度1上求2范数
Out[11]: tensor([2., 2.])

In [12]: c.norm(1,dim=0)#在维度0上求1范数
Out[12]:
tensor([[2., 2.],
        [2., 2.]])

常用操作

torch.min()最小值
torch.max()最大值
torch.mean()均值
torch.prod()累乘
torch.sum()求和
torch.argmin()最小值的索引，这里返回的是打平后的索引
torch.argmax()最大值的索引，这里返回的是打平后的索引
torch.argmin(dim)最小值的索引，这里返回的是某个维度上的索引
torch.argmax(dim)最大值的索引，这里返回的是某个维度上的索引

In [13]: a = torch.arange(8).view(2,4).float()

In [14]: a
Out[14]:
tensor([[0., 1., 2., 3.],
        [4., 5., 6., 7.]])

In [15]: a.min(),a.max(),a.mean(),a.prod()
Out[15]: (tensor(0.), tensor(7.), tensor(3.5000), tensor(0.))

In [16]: a.sum()
Out[16]: tensor(28.)

In [17]: a.argmax()
Out[17]: tensor(7)

In [18]: a.argmin()
Out[18]: tensor(0)

In [19]: a.argmin(dim=0),a.argmin(dim=1)
#返回dim0上的最小值下标 [2,4]==>[4]
#返回dim1上的最小值下标 [2,4]==>[2] 
Out[19]: (tensor([0, 0, 0, 0]), tensor([0, 0]))

In [20]: a.argmax(dim=0),a.argmax(dim=1)
Out[20]: (tensor([1, 1, 1, 1]), tensor([3, 3]))

注意：上面的argmax、argmin操作默认会将Tensor打平后取最大值索引和最小值索引，如果不希望Tenosr打平，而是求给定维度上的索引，需要指定在哪一个维度上求最大值索引或最小值索引。

比如，有shape=[4, 10]的Tensor，表示4张图片在10分类的概率结果，我们需要知道每张图片的最可能的分类结果：

a = torch.rand(4, 10)
print(a)
# 在第二维度上求最大值索引
print(a.argmax(dim=1))

输出结果：

tensor([[0.0711, 0.5641, 0.7945, 0.6964, 0.3609, 0.5817, 0.1705, 0.6913, 0.1263,
         0.8346],
        [0.0810, 0.0771, 0.1983, 0.0344, 0.1067, 0.9591, 0.8515, 0.3046, 0.0491,
         0.1291],
        [0.3527, 0.2676, 0.9859, 0.2656, 0.1985, 0.3759, 0.8221, 0.3571, 0.5340,
         0.7759],
        [0.0969, 0.3954, 0.5478, 0.3543, 0.8253, 0.9291, 0.4960, 0.4390, 0.3780,
         0.5858]])
tensor([9, 5, 2, 5])

直接使用max和min配合dim参数也可以获得最值索引，同时得到最值的具体值：

print(c.max(dim=1))

输出结果：

(tensor([0.9589, 1.7394, 1.3448, 2.2079]), tensor([2, 2, 5, 7]))

要注意这样的话会把求最值的dim给消除，如c:[4,10]==>[4]
使用keepdim=True可以保持应有的dim，即仅仅是将求最值的那个dim的size变成了1，返回的结果是符合原Tensor语义的。

print(c.argmax(dim=1, keepdim=True))
print(c.max(dim=1, keepdim=True))

输出结果：

tensor([[2],
        [2],
        [5],
        [7]])
(tensor([[0.9589],
        [1.7394],
        [1.3448],
        [2.2079]]), tensor([[2],
        [2],
        [5],
        [7]]))

取前k大/前k小/第k小的概率值及其索引

使用topk代替max可以完成更灵活的需求，有时候不是仅仅要概率最大的那一个，而是概率最大的k个。如果不是求最大的k个，而是求最小的k个，只要使用参数largest=False，kthvalue还可以取第k小的概率值及其索引。
代码：

# 假设2张图片,分为10个类别的置信度，分别表示图片属于十个类别的概率
d = torch.randn(2, 10)  
# 最大概率的3个类别 [2,10]==>[2,3] 同时还返回对应下标
print(d.topk(3, dim=1))  
# 最小概率的3个类别 [2,10]==>[2,3]  同时还返回对应下标
print(d.topk(3, dim=1, largest=False))  
# 求第8小概率的类别(一共10个那就是第3大) 相当于升序 从小到大排序
print(d.kthvalue(8, dim=1))  

输出结果：

(tensor([[2.0692, 1.6490, 0.9526],
        [1.5983, 1.5737, 1.5532]]), tensor([[6, 3, 5],
        [8, 1, 2]]))
(tensor([[-1.0023, -0.6423,  0.0655],
        [-1.2959, -1.1504, -0.9859]]), tensor([[4, 0, 2],
        [0, 5, 3]]))
(tensor([0.9526, 1.5532]), tensor([5, 2]))

比较操作

示例代码：

import torch
 
a = torch.randn(2, 3)
b = torch.randn(2, 3)
print(a)
print(b)

# 比较是否大于0，是对应位置返回1，否对应位置返回0，注意得到的是ByteTensor
# pytorch没有true false表示 因此用0 1代替
print(a > 0)  
print(torch.gt(a, 0))

# 是否不等于0，是对应位置返回1，否对应位置返回0
print(a != 0)

# 比较每个位置是否相等，是对应位置返回1，否对应位置返回0
print(torch.eq(a, b))  

# 比较每个位置是否相等，全部相等时才返回True
print(torch.equal(a, b), torch.equal(a, a))  

输出结果：

tensor([[-0.1425, -1.1142,  0.2224],
        [ 0.6142,  1.7455, -1.1776]])
tensor([[-0.0774, -1.1012, -0.4862],
        [-0.3110, -0.2110,  0.0381]])
tensor([[0, 0, 1],
        [1, 1, 0]], dtype=torch.uint8)
tensor([[0, 0, 1],
        [1, 1, 0]], dtype=torch.uint8)
tensor([[1, 1, 1],
        [1, 1, 1]], dtype=torch.uint8)
tensor([[0, 0, 0],
        [0, 0, 0]], dtype=torch.uint8)
False True