pytorch:norm/argmax/argmin/topk/kthvalue以及比较函数

import torch

norm 范数

||x||_p = (||x₁||^p + ||x₂||^p + … + ||x₃||^p)^1/p

• 1范数：所有元素绝对值相加
• 2范数：所有元素平方和开根号
• ∞范数：所有元素绝对值中的最大值

a = torch.randint(-10,11,[2,3,2])
a = a.to(torch.float64)
a

tensor([[[ -7.,  -5.],
         [  6.,  -5.],
         [ -1.,  10.]],

        [[-10.,  -9.],
         [ -5.,  -4.],
         [ -8.,   2.]]], dtype=torch.float64)

a.norm(1)

tensor(72., dtype=torch.float64)

a.norm(2)

tensor(22.9347, dtype=torch.float64)

• norm带有dim的情况：

• 设X是一个IJK的矩阵，x_ijk是里面的元素
• Y = X.norm(n,dim=0) 生成一个J*K的矩阵，y₁₂是所有x_i12的n范数 y₂₃是所有x_i23的n范数
• Y = X.norm(n,dim=1) 生成一个I*K的矩阵，y₁₂是所有x_1j2的n范数 y₂₃是所有x_2j3的n范数
• Y = X.norm(n,dim=[1,2]) 生成一个size=I的vector y₁是所有x_1ij的n范数 y₂是所有x_2ij的n范数

a.norm(1,dim=0) #17=abs(-7)+abs(-10) 14=abs(-5)+abs(-9) ...

tensor([[17., 14.],
        [11.,  9.],
        [ 9., 12.]], dtype=torch.float64)

a.norm(1,dim=1) #14=abs(-7)+abs(6)+abs(-1) 20=abs(-5)+abs(-5)+abs(10) ...

tensor([[14., 20.],
        [23., 15.]], dtype=torch.float64)

a.norm(1,dim=2) #12=abs(-7)+abs(-5) 11=abs(6)+abs(-5)

tensor([[12., 11., 11.],
        [19.,  9., 10.]], dtype=torch.float64)

a.norm(1,dim=[0,1])

tensor([37., 35.], dtype=torch.float64)

a.norm(1,dim=[0,2])

tensor([31., 20., 21.], dtype=torch.float64)

最大值、最小值及索引

a = torch.randint(-20,21,[2,2,3,2]).to(torch.float64)
a

tensor([[[[-17., -17.],
          [ -3.,  17.],
          [  7.,   0.]],

         [[  7., -20.],
          [-16., -18.],
          [ 18.,  -5.]]],


        [[[ 14., -20.],
          [  5., -12.],
          [  5., -13.]],

         [[-16., -20.],
          [ 16.,  -9.],
          [ -1.,  15.]]]], dtype=torch.float64)

print(a.argmax()) #把a拉平成一维vector 然后再找最大值索引
print(a.argmin()) #把a拉平成一维vector 然后再找最小值索引

tensor(10)
tensor(19)

• argmax带dim:
• 设X是一个PQM*N的tensor
• Y=a.argmax(dim=0) Y是一个QMN的tensor Y₁₁₂是所有X_p112中最大的那个的索引 Y₂₃₄是所有X_p234中最大的那个的索引
• Y=a.argmax(dim=3) Y是一个PQM的tensor Y₁₁₂是所有X_112q中最大的那个的索引 Y₂₃₄是所有X_234p中最大的那个的索引
• argmin同理
• max\min带dim 思路和上面一样，只是返回的东西包含两部分，第一部分是值，第二部分是索引

print(a.argmax(dim=0)) 
print(a.argmin(dim=0)) 

tensor([[[1, 0],
         [1, 0],
         [0, 0]],

        [[0, 1],
         [1, 1],
         [0, 1]]])
tensor([[[0, 1],
         [0, 1],
         [1, 1]],

        [[1, 1],
         [0, 0],
         [1, 0]]])

print(a.argmax(dim=1))
print(a.argmax(dim=2))

tensor([[[1, 0],
         [0, 0],
         [1, 0]],

        [[0, 1],
         [1, 1],
         [0, 1]]])
tensor([[[2, 1],
         [2, 2]],

        [[0, 1],
         [1, 2]]])

print('索引：\n',a.max(dim=2)[1])
print('值：\n',a.max(dim=2)[0])

索引：
 tensor([[[2, 1],
         [2, 2]],

        [[0, 1],
         [1, 2]]])
值：
 tensor([[[  7.,  17.],
         [ 18.,  -5.]],

        [[ 14., -12.],
         [ 16.,  15.]]], dtype=torch.float64)

topk

• b的size是pqj
• b.topk(n,dim=0) 返回的东西包括两个nqj的tensor，第一个tensor是value 第二个tensor是indice 其他思路和max差不多
• b.topk(n,dim=1) 返回的东西包括两个pnj的tensor，第一个tensor是value 第二个tensor是indice 其他思路和max差不多
• dim不写 默认为最大的 比如本例中就是2
• largest=False则返回的是最小的n个

b = torch.rand(2,3,10) #假设2个batch，每个batch3张照片，10表示每张照片依次是0~9的概率
b

tensor([[[0.5304, 0.1505, 0.5322, 0.0247, 0.1890, 0.8630, 0.6212, 0.4308,
          0.3447, 0.9590],
         [0.7632, 0.1420, 0.7258, 0.8698, 0.6531, 0.2155, 0.8730, 0.3963,
          0.1711, 0.4374],
         [0.7572, 0.4117, 0.2699, 0.4153, 0.9025, 0.7338, 0.4403, 0.6043,
          0.6109, 0.9631]],

        [[0.5738, 0.9288, 0.2986, 0.8859, 0.2687, 0.9388, 0.4515, 0.9561,
          0.9277, 0.6534],
         [0.4825, 0.9142, 0.4260, 0.4814, 0.8739, 0.9296, 0.8225, 0.5581,
          0.8214, 0.2455],
         [0.5460, 0.6100, 0.5846, 0.7510, 0.5964, 0.4243, 0.8347, 0.7734,
          0.5279, 0.5943]]])

b.topk(1,dim=2)
# 0.9590表示第一个batch的第一张照片的10个概率值中，最大的是0.9590 并且我们可以看到它对应的indice是9 表示这张照片是“9”的概率为0.9590
# 0.9296表示第2个batch的第2张照片的10个概率值中，最大的是0.9296 并且我们可以看到它对应的indice是5 表示这张照片是“5”的概率为0.9590

torch.return_types.topk(
values=tensor([[[0.9590],
         [0.8730],
         [0.9631]],

        [[0.9561],
         [0.9296],
         [0.8347]]]),
indices=tensor([[[9],
         [6],
         [9]],

        [[7],
         [5],
         [6]]]))

b.topk(1)

torch.return_types.topk(
values=tensor([[[0.9590],
         [0.8730],
         [0.9631]],

        [[0.9561],
         [0.9296],
         [0.8347]]]),
indices=tensor([[[9],
         [6],
         [9]],

        [[7],
         [5],
         [6]]]))

kthvalue

• kthvalue的分析思路和max带dim的分析思路一样，只是把最大换成第几大
• 当kthvalue的dim不写的时候，默认为最大

print(b.shape,'\n')
print(b)

torch.Size([2, 3, 10]) 

tensor([[[0.5304, 0.1505, 0.5322, 0.0247, 0.1890, 0.8630, 0.6212, 0.4308,
          0.3447, 0.9590],
         [0.7632, 0.1420, 0.7258, 0.8698, 0.6531, 0.2155, 0.8730, 0.3963,
          0.1711, 0.4374],
         [0.7572, 0.4117, 0.2699, 0.4153, 0.9025, 0.7338, 0.4403, 0.6043,
          0.6109, 0.9631]],

        [[0.5738, 0.9288, 0.2986, 0.8859, 0.2687, 0.9388, 0.4515, 0.9561,
          0.9277, 0.6534],
         [0.4825, 0.9142, 0.4260, 0.4814, 0.8739, 0.9296, 0.8225, 0.5581,
          0.8214, 0.2455],
         [0.5460, 0.6100, 0.5846, 0.7510, 0.5964, 0.4243, 0.8347, 0.7734,
          0.5279, 0.5943]]])

print(b.kthvalue(2,dim=2)[0].shape,'\n')
print(b.kthvalue(2,dim=2))

torch.Size([2, 3]) 

torch.return_types.kthvalue(
values=tensor([[0.1505, 0.1711, 0.4117],
        [0.2986, 0.4260, 0.5279]]),
indices=tensor([[1, 8, 1],
        [2, 2, 8]]))

比较： > < == != torch.ge/gt/le/lt() torch.eq() torch.equal()

a = torch.tensor([[1,2],[7,8]])
b = torch.tensor([[1,4],[5,6]])

a>b

tensor([[False, False],
        [ True,  True]])

a == 0

tensor([[False, False],
        [False, False]])

torch.ge(a,b) #a>=b? element-wise 如果dim不合适，就broadcast

tensor([[ True, False],
        [ True,  True]])

torch.gt(a,b) #a>b?

tensor([[False, False],
        [ True,  True]])

torch.le(a,b) #a<=b

tensor([[ True,  True],
        [False, False]])

torch.lt(a,b) #a<b

tensor([[False,  True],
        [False, False]])

torch.eq(a,b)

tensor([[ True, False],
        [False, False]])

torch.equal(a,b)

False