Pytorch学习——tensor的生成、构造、组织、计算、统计

Pytorch

Pytorch 是 Python 接口语言、可以使用GPU加速、构造动态神经网络（更灵活）、python优先

Tensor的生成

tensor的常见生成方式和性质

tensor = torch.Tensor([[2,3],[4,5],[6,7]]) #生成tensor
E = torch.from_numpy #使用numpy生成tensor
torch_e = torch.from_numpy
print(format(tensor)) #3*2
print(tensor.reshape(2,3)) #重新排列元素
print(tensor + 1)#逐元素运算
t_int8 = torch.tensor([1, 2], dtype = torch.int8)
t1 = torch.empty(2) #未初始化
t2 = torch.zeros(2, 2) #所有元素值为0
t3 = torch.ones(2, 2, 2) # 所有元素值为1
t4 = torch.full((2,2,2,2), 3.) #所有元素值为3
t5 = torch.ones_like(t2) #ones可以被替换为zeros、empty、full使用

torch.tensor的属性

• size()：返回张量的大小

• dim()：返回张量的维度 e.g. (2,3)

• numel()：张量中元素的个数 e.g. 6

  

tensor里面的数据可以有多种类型：

• 浮点型：torch.float16、torch.float32、torch.float64
• 整型：torch.uint8、torch.int8、torch.int16、torch.int32、torch.int64

print(format(tensor.dtype))

构造等比数列和等差数列张量

等差数列

torch.arrange(0, 4, step = 1) #从0到3，步长是1
torch.range(0, 3, step = 1)
torch.linspace(0,3, steps = 4) #表示只有4个元素

等比数列

torch.logspace(0, 3, steps = 4) #生成张量为1，10， 100， 1000

构造随机张量

机器生成的随机样本根据seed的值，记过严密的设计生成伪随机样本

随机样本是根据概率分布生成的，通过设置概率分布特征可以得到相应的分布

torch.bernoulli()

可以生成元素为0 或 1 的张量，这个函数的参数是一个概率张量，概率张量的各元素都是0~1的值，表示结果张量对应位置为0 的概率，接近1则为1，接近0则为0，中间值摇摆不定

这里张量中的数值应为float，不能是long，否则无法伯努利化

torch.rand() & torch.rand_like()

生成标准均匀分布的随机变量。标准均匀分布在[0, 1)上的概率都相同

print(torch.rand(2, 3))
print(torch.rand_like(torch.ones(2, 3)))
#输出
tensor([[0.2287, 0.0178, 0.4014],
        [0.2744, 0.9867, 0.6362]])
tensor([[0.6555, 0.5433, 0.4404],
        [0.2501, 0.8151, 0.8137]])

torch.randn() & torch.randn_like()

生成标准正态分布的随机变量，均值是0，方差是1

print(torch.randn(2, 3))
print(torch.randn_like(torch.ones(2, 3)))
#输出
tensor([[-0.7574, -0.0476,  0.7495],
        [ 0.1428,  0.3430,  1.9681]])
tensor([[-0.2542,  0.1794, -0.3052],
        [-1.4034,  1.2689, -1.0883]])

torch.normal()

生成正态分布的随机变量，不同之处在于它可以指定正态分布的均值和方差

mean = torch.tensor([0., 1.])
std = torch.tensor([3., 2.])
print(torch.normal(mean, std))
#输出
tensor([-1.7072,  3.5845])

组织张量的元素

重排张量元素

reshape(), squeeze(), unsqueeze()：这些成员不会改变元素的实际位置

import torch
tc = torch.arange(12)
print('tc = {}'.format(tc))
t322 = tc.reshape(3,2,2) #张量大小设置为322或者也可以是（4，3）

在使用reshape的时候，某个维度用-1 代替的时候，会自动根据其他维度的大小计算出这个维度的大小

reshape 操作也可以用squeeze()和unsqueeze来代替。squeeze()可以消除张量中维度大小为1的部分

unsqueeze()正好相反，是增加一些大小为0的维度，增加的位置由关键字参数dim指定

t = torch.arange(24).reshape(2, 1, 3, 1, 4) #大小为(2,1,3,1,4)
t.squeeze() #大小=(2, 3, 4)
t = torch.arange(24).reshape(2, 3, 4)
t.unsqeeze(dim = 2) #指定在2维后面增加大小为0的维度

其他的重排方法

#use permute to order tensor in a new way which is defined by dims
t = torch.arange(24).reshape(1, 2, 3, 4)
t.permute(dims = [2, 0, 1, 3]) #大小[1, 2, 3, 4]
#transpose the tensor
t12 = torch.tensor([[5., -9.], ])
t21 = t12.transpose(0, 1)

选取部分张量，张量的扩展和拼接

t = torch.arange(24).reshape(2, 3, 4)
index = torch.tensor([1, 2])
t.index_select(1, index)
#选取大小为(2, 2, 4)

t = torch.arange(12)
print(t[3])#第三个
print(t[-5])#倒数第五个
print(t[3:6])#从第3到第6个
print(t[:6])#前6个
print(t[3:])#从第三个往后
print(t[-5:])#倒数后五个
print(t[3:6:2])#三和六两个元素
print(t[3::2])#从三开始步长为2
#repeat
t12 = torch.tensor([[5., -9.], ])
print('t12 = {}'.format(t12))
t34 = t12.repeat(3, 2)#把t12作为一个元素重复三行两列
print('t34 = {}'.format(t34))
#cat
tp = torch.arange(12).reshape(3, 4)
tn = -tp
tc0 = torch.cat([tp, tn], 0)#参数为0则表示竖直拼接
print('tc0 = {}'.format(tc0))
tc1 = torch.cat([tp, tp, tn, -tn], 1)#参数1则表示横向拼接
print('tc1 = {}'.format(tc1))
#stack 输入的张量大小需要完全相同
tp = torch.arange(12).reshape(3, 4)
tn = -tp
tc0 = torch.stack([tp, tn], 0)#参数为0则表示竖直拼接
print('tc0 = {}'.format(tc0))
tc1 = torch.stack([tp, tp, tn, -tn], 1)#参数1则表示横向拼接
print('tc1 = {}'.format(tc1))

张量的运算

有理运算和广播语义

tl = torch.tensor([[1., 2., 3.], [4., 5., 6.]])
tr = torch.tensor([[7., 8., 9.], [10., 11., 12.]])
print(tl+tr)
print(tl-tr)
print(tl*tr)
print(tl/tr)
print(tl**tr)
print(tl**(1/tr))
print(tl+5)
print(-6*tr)
print(torch.ones(2, 3, 4)+torch.ones(4))

print(t1.reciprocal())#求倒数，数据类型不能为long
print(t1.sqrt())#求平方根

基本函数

torch.exp() 、expm1()、 sigmoid()、 sinh()、 tanh()、 cosh()

torch.log()、 log2()、 log10()

torch.sin()、 cos()、 tan()、 asin()、 acos()、 atan()

分段函数

符号函数torch.sign()，绝对值函数torch.abs()

向下取整floor()、向上取整ceil()、四舍五入round()、直接截取函数trunc()、取小数部分frac()

限制数据范围clamp()

和除法余数有关的函数fmod()、remainder()

统计函数

t = torch.arange(5)
print(t.var())#方差
print(t.prod())#各元素乘积
print(t.max())#最大值
print(t.median())#中位数
print(t.kthvalue())#第2大值
t1 = torch.arange(12).reshape(2, 2, 3)

#各元素的方差，添加dim参数后就是对某一个维度进行统计
print(t1.prod(dim = 1))
print(t1.var(dim = 1))

能看到这里的朋友不妨点个赞再走~
若有错误请指出