Pytorch学习手札(三)---张量的拼接分割、基本数学计算、属性统计

pytorch张量的拼接分割、基本数学计算、属性统计

1.Broadcasting：张量维度自动扩展

eg:张量a:[3,12,12,12]
偏置b:[12,1,1] > [1,12,1,1]>[3,12,12,12]
总结一下:
第一步：扩张一个维度；第二步：复制扩张成跟a一样形状。就可以和tensor a进行相乘相加等操作
结合以下实例理解:

2.tensor的拼接与分割

(1)合并API
1)Cat:对数据进行维度上的合并，不增加属性
2)Stack:增加一个维度，增加一个属性进行数据分类，不对数据进行简单的合并
(2)拆分API
1)Split:按长度拆分(by len([1,2,3…]) or len(1))
2)Chunk:按数量拆分(by num)

3.数学运算

(1)基本的加减乘除
1)运算符形式（±*/）
2)add/sub/mul/div-pytorch的运算名称
(2)次方函数power(a,n)
（a,n)表示a的n次方、指数exp和对数函数log函数
(3)矩阵相乘
torch.mm（仅仅适用于dim=2的情况）/torch.matmul()/@（三种形式）
(4)近似值函数：
a=torch.tensor(3.14)
print(a.floor()) #向下取整函数
print(a.ceil()) #向上取整函数
print(a.trunc()) #数据的整数部分
print(a.frac()) #数据的小数部分
print(a.round())
(5)clamp梯度裁剪

4.常见属性计算与统计

(1)范数函数norm:
1范数:所有x的绝对值相加
2范数:所有x的平方和 ，再开根号
(2)其他常用属性的计算与统计

 a=torch.randn(4,10)
print(a[0])
print(a.min())
print(a.max())
print(a.mean())
print(a.prod()) #所以元素累乘
print(a.std())
print(a.sum())
print(a.argmax(dim=0))
print(a.argsort())  #不指定维度变为一维
print(a.argmin(dim=1)) #指定维度

(3)dim/keepdim函数的作用:主要用来结果输出维度的变换
(4)topk函数：
topk(n,dim=None,largest=False)
求取某一维度数据上前n大的数据及其索引
参数:n:取几个，dim：指定维度，largest：大或小排序，默认按大到小
kthvalue(求取第n小的数据及其索引)
(5)常见比较函数:
< > >= <= !=
torch.gt()
torch.eq(a,b)
torch.equal(a,b)

5.其他的高阶操作

(1)where
where(condition,A,B)：函数原型：拼接和组装功能
condition:筛选条件
A,B:符合取A值，否则B值
(2)gather
gather(input,dim,index,out=NOne)
input:可以理解为输入概率值
dim:指定维度
index:下标

6.本节代码demo

# -*- coding: utf-8 -*-
'''
@Author: Jason
@Desc  : 
'''
import torch
#1.cat拼接：参数dim 指定合并维度，除该指定维度外其他维度需要一样
a=torch.rand(100,100,20)
b=torch.rand(200,100,20)
# print(torch.cat([a,b],dim=0).shape)#torch.Size([300, 100, 20])
# print(torch.cat([a,torch.rand(100,1,20)],dim=0).shape)#RuntimeError: invalid argument 0
# print(torch.cat([a,torch.rand(100,1,20)],dim=1).shape)#torch.Size([100, 101, 20])

#2.stack拼接：指定位置增加一个维度
a1 = torch.rand(100,100,20)
# print(torch.cat([a,a1],dim=2).shape)#torch.Size([100, 100, 40])
# print(torch.stack([a,a1],dim=2).shape) #torch.Size([100, 100, 2, 20])

#3.split拆分:按长度拆分
c = torch.stack([a,a1],dim=0)
# print(c.shape) #torch.Size([2, 100, 100, 20])
c1,c2 = c.split([1,1],dim=0)
# print(c1.shape,b.shape) #torch.Size([1, 100, 100, 20]) torch.Size([200, 100, 20])
c3  = torch.rand([6,100,20])
# 3.1 将第一维度指定拆分：eg成4:2
c31,c32 = c3.split([4,2],dim=0)
# print(c31.shape,c32.shape)#torch.Size([4, 100, 20]) torch.Size([2, 100, 20])
c33,c34,c35,c36 = c3.split([3,1,1,1],dim=0)
# print(c33.shape,c36.shape)#torch.Size([3, 100, 20]) torch.Size([1, 100, 20])
c37,c38,c39 = c3.split(2,dim=0)#将第一维度拆成指定n份，每份为2
# print(c37.shape)#torch.Size([2, 100, 20])

#4.chunk按数量拆分
d = torch.rand([6,6,6])
d1 = d.chunk(3,dim=0)#将第一维度拆成3份
# print(d1[0].shape)#torch.Size([2, 6, 6])  分成每个第一维度都是 2

#5.tensor的数学运算加减乘除
a=torch.rand(2,2)
# print(a)
'''
tensor([[0.3758, 0.0518],
        [0.1825, 0.4583]])
'''
b=torch.rand(2)#tensor([0.8340, 0.5110])
# print(b)
# '''tensor([[1.2098, 0.5628],
#         [1.0165, 0.9693]])
#         '''
# print(a+b)
# '''tensor([[0.3135, 0.0265],
#         [0.1522, 0.2342]])'''
# print(a*b)#以下结果省略复制
# print(a-b)
# print(a/b)
# print(torch.add(a,b)) #与上面是等效的
# print(torch.mul(a,b))
# print(torch.sub(a,b))
# print(torch.div(a,b))
# #矩阵的运算函数-矩阵相乘-torch.mm（仅仅适用于dim=2的情况）/torch.matmul()/@（三种形式）
a=torch.ones(2,2)
b=torch.tensor([[1.,2.],[3.,4.]])
# print(torch.mm(a,b))#只能对2维度的
'''tensor([[4., 6.],
        [4., 6.]])
'''
# print(torch.matmul(a,b))
'''
tensor([[4., 6.],
        [4., 6.]])'''
# print(a@b) #三种运算等效
'''
tensor([[4., 6.],
        [4., 6.]])
'''
# 矩阵相乘实际应用:矩阵降维
# a=torch.rand(4,784)
# w=torch.rand(512,784)
# [email protected]() #这里的转置只适用于2维，多维的话使用之前用过的transpose
# print(b.shape)

# #次方函数power（a,n)表示a的n次方、指数exp和对数函数
a=torch.tensor([[1,3],[2,4]],dtype=float)
# print(a)
'''tensor([[1., 3.],
        [2., 4.]], dtype=torch.float64)
'''
# print(pow(a,3)) #a的立方
'''tensor([[ 1., 27.],
        [ 8., 64.]], dtype=torch.float64)
'''
# print(a.sqrt()) #a的平方根
'''tensor([[1.0000, 1.7321],
        [1.4142, 2.0000]], dtype=torch.float64)
'''
# print(a.rsqrt()) #a的平方根的倒数
'''tensor([[1.0000, 0.5774],
        [0.7071, 0.5000]], dtype=torch.float64)'''

a = torch.exp(torch.ones(2,2))
# print(a)
'''
tensor([[2.7183, 2.7183],
        [2.7183, 2.7183]])
'''
# print(torch.exp(a)) #指数函数e^e
'''tensor([[2.7183, 2.7183],
        [2.7183, 2.7183]])'''
# print(torch.log(a)) #对数函数log(e)a
'''
tensor([[1., 1.],
        [1., 1.]])
'''


# #近似值函数
a=torch.tensor(3.14)
# print(a.floor()) #向下取整函数tensor(3.)
# print(a.ceil()) #向上取整函数tensor(4.)
# print(a.trunc()) #数据的整数部分tensor(3.)
# print(a.frac()) #数据的小数部分tensor(0.1400)
# print(a.round()) #求取数据的四舍五入的数据tensor(3.)

# #clamp梯度裁剪
a=torch.rand(2,6)*15
# print(a)
# print(a.clamp(10)) #取10以上的数据，小于10的数据代替为10
# print(a.clamp(8,10)) #取8-10的数据，将大于10的数据代替为10,小于8替换为8


#6.求取数据的统计属性
#数据的范数norm函数
a=torch.full([8],1) #生成长度为8，值全为1的数据
# print(a)#tensor([1., 1., 1., 1., 1., 1., 1., 1.])
b=a.view(2,4)
c=a.view(2,2,2)#
# print(a.view(2,4))#tensor([[1., 1., 1., 1.]，[1., 1., 1., 1.]])
# print(a.view(2,2,2))
'''tensor([[[1., 1.],
         [1., 1.]],

        [[1., 1.],
         [1., 1.]]])
'''
# print(a.norm(1),b.norm(1),c.norm(1))#tensor(8.) tensor(8.) tensor(8.)
# print(a.norm(2),b.norm(2),c.norm(2))#tensor(2.8284) tensor(2.8284) tensor(2.8284)
# print(b.norm(2,dim=1)) #指定维度  tensor([2., 2.])
# print(c.norm(2,dim=2))
'''tensor([[1.4142, 1.4142],
        [1.4142, 1.4142]])'''
# #其他常用属性的计算与统计
# a=torch.randn(4,10)
# print(a[0])
# print(a.min())
# print(a.max())
# print(a.mean())
# print(a.prod())
# print(a.std())
# print(a.sum())
# print(a.argmax(dim=0))
# print(a.argsort())
# print(a.argmin(dim=1))

# #dim/keepdim函数的作用
# print(a.argmax(dim=1))
# print(a.argmax(dim=1,keepdim=True)) #主要用来数据的维度变换[4],转换[4,1]
# #topk函数（求取某一维度数据上前n大的数据及其索引）/kthvalue(求取第n小的数据及其索引)
# a=torch.rand(4,10)
# print(a.topk(3,dim=1))
# x,y=a.topk(3,dim=1,largest=False)
# print(a.topk(3,dim=1,largest=False))
# print(x)
# print(a.kthvalue(8,dim=1))
# #常用比较函数compare
# a=torch.rand(4,10)
# print(a>0)
# print(a!=0)
# print(torch.gt(a,0))
# b=torch.rand(4,10)
# print(torch.eq(a,b)) #输出每个元素对应位置上的相同与否
# print(torch.equal(a,b)) #表示是否完全一样



#7.高阶操作函数where和gather
# #where函数相比for循环来说可以实现GPU高度并行进行，可以提高数数据处理的速度
cond=torch.tensor([[0.4,0.1],[0.7,0.8]])
# print(cond)
A=torch.rand(2,2)
B=torch.rand(2,2)
# print(A,B)
'''
tensor([[0.7527, 0.8846],
        [0.8806, 0.6668]]) 
tensor([[0.0272, 0.0106],
        [0.3369, 0.1159]])
'''
# print(cond)
'''
tensor([[0.4000, 0.1000],
        [0.7000, 0.8000]])
'''
# print(torch.where(cond>0.5,A,B))#cond中数值大于0.5取A中值，否则取B中相应位置值
'''
tensor([[0.0272, 0.0106],
        [0.8806, 0.6668]])
'''


# #gather函数-查表操作，可以在GPU上实现，从而提高数据的处理速度，在前沿的一些数据查询和加速方面比较常用
input1=torch.rand(4,10)#4行10列
print(input1)
'''
tensor([[0.9137, 0.9590, 0.0762, 0.7017, 0.5470, 0.9915, 0.1082, 0.2921, 0.5826,0.3139],
        [0.8550, 0.8030, 0.7478, 0.8831, 0.9125, 0.3933, 0.8986, 0.0966, 0.7523,0.7332],
        [0.7155, 0.0212, 0.4283, 0.9482, 0.2283, 0.3828, 0.7388, 0.1334, 0.9863,0.7742],
        [0.2813, 0.7313, 0.7587, 0.5425, 0.3005, 0.3247, 0.4904, 0.4449, 0.2057,0.5349]])
'''
print(input1.topk(3,dim=1)[1]) #最有可能的3种
'''
tensor([[5, 1, 0], #第一张照片概率最大的三个值，即可能是其对应的数字
        [4, 6, 3], #第二张...
        [8, 3, 9],
        [2, 1, 3]])
'''
label=torch.tensor(range(100,110))#映射 顺序对应的数字为
print(label)#tensor([100, 101, 102, 103, 104, 105, 106, 107, 108, 109])
print(label.shape)#torch.Size([10])
print(torch.gather(label.expand(4,10),dim=1,index=input1.topk(3,dim=1)[1])) #gather函数的经典案例帮助理解
'''
tensor([[105, 101, 100],
        [104, 106, 103],
        [108, 103, 109],
        [102, 101, 103]])
'''
if __name__ == "__main__":
    print(" ")

转载请标明 转自:https://leejason.blog.csdn.net/article/details/106865808