pytorch基操01-常用Tensor创建方法汇总

1.Tensor的创建

初学pytorch，看代码时难免会遇到各种各样创建Tensor的方法，比较零散，这里做一个简单的汇总。

1.1 使用torch.Tensor

在torch.Tensor()方法中可以只输入tensor形状，即可生成指定形状tensor，其值随机，默认为float类型。

# 通过形状生成tensor 默认FloatTensor
x=torch.Tensor(2,3)
print('x:{0}\n{1}'.format(x.type(),x))

x:torch.FloatTensor
tensor([[1.0899e+27, 2.0339e+32, 4.5445e+30],
        [6.9983e+28, 5.0840e+31, 1.8057e+28]])

也可也像numpy一样输入数组，生成tensor，默认为float类型。

# 通过数据生成tensor 默认FloatTensor
x=torch.Tensor([[2,3],[4,5]])
print('x:{0}\n{1}'.format(x.type(),x))

x:torch.FloatTensor
tensor([[2., 3.],
        [4., 5.]])

1.2 使用torch.eye

输入形状，输出对角线为1.，其余为0的tensor。

x_eye=torch.eye(3,4) # 对角线是1的tensor
print('对角线是1的tensor:{0}\n{1}'.format(x_eye.type(),x_eye))

对角线是1的tensor:torch.FloatTensor
tensor([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.]])

1.3 全0或全1的tensor

# 全0或1的tensor
x_zeros=torch.zeros(size=(2,3))
print('x_zeros:{0}\n{1}'.format(x_zeros.type(),x_zeros))

x_ones=torch.ones(size=(2,3))
print('x_ones:{0}\n{1}'.format(x_ones.type(),x_ones))

x_tmp=torch.Tensor(3,5)

# 形状相同值为0的tensor
x_zeroslike=torch.zeros_like(x_tmp)
print('x_zeroslike:{0}\n{1}'.format(x_zeroslike.type(),x_zeroslike))

# 形状相同 值为1的tensor
x_oneslike=torch.ones_like(x_tmp)
print('x_oneslike:{0}\n{1}'.format(x_oneslike.type(),x_oneslike))

x_zeros:torch.FloatTensor
tensor([[0., 0., 0.],
        [0., 0., 0.]])
x_ones:torch.FloatTensor
tensor([[1., 1., 1.],
        [1., 1., 1.]])
x_zeroslike:torch.FloatTensor
tensor([[0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.]])
x_oneslike:torch.FloatTensor
tensor([[1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.]])

1.4 根据分布随机生成tensor

1.4.1 torch.rand

torch.rand可以生成服从[0,1)间均匀分布的tensor。

# [0,1)之间均匀分布的tensor
x_uni_rand=torch.rand(size=(200,300))
print('x_rand:{0}\n{1}'.format(x_uni_rand.type(),x_uni_rand))
print('mean:\n',x_uni_rand.mean())

x_rand:torch.FloatTensor
tensor([[0.4036, 0.9079, 0.6418,  ..., 0.3767, 0.4146, 0.1524],
        [0.6061, 0.8902, 0.8018,  ..., 0.0853, 0.1156, 0.9581],
        [0.0028, 0.2050, 0.0332,  ..., 0.2657, 0.9351, 0.3759],
        ...,
        [0.5128, 0.1673, 0.6643,  ..., 0.9475, 0.9222, 0.0723],
        [0.9637, 0.7653, 0.5252,  ..., 0.1249, 0.8553, 0.1134],
        [0.1345, 0.7025, 0.2348,  ..., 0.4171, 0.5114, 0.7842]])
mean:
 tensor(0.4991)

1.4.2 torch.randn

torch.randn可以生成服从标准正态分布的tensor。

# 服从正态分布的tensor
x_nor_randn=torch.randn(size=(2,3))
print('x_randn:{0}\n{1}'.format(x_nor_randn.type(),x_nor_randn))

x_randn:torch.FloatTensor
tensor([[ 0.2138, -1.8686,  0.3602],
        [-0.2928, -0.0673,  1.1447]])

1.4.3 torch.normal

由不同均值方差的正态分布产生的tensor，下面tensor中的元素服从的均值和方差依次为(1,1),(100,10),(1000,20)。

# 从不同均值方差的正态分布中采用出值，生成一个tensor
x_dif_nor=torch.normal(mean=torch.Tensor([1.,100.,1000.]),std=torch.Tensor([1.,10.,20.]))
print('tensor value from different nor dis:{0}\n{1}'.format(x_dif_nor.type(),x_dif_nor))

tensor value from different nor dis:torch.FloatTensor
tensor([   2.2927,  110.6787, 1002.7673])

1.4.4 torch.Tensor.uniform_

将tensor使用符合[a,b)间均匀分布的值填充。

# 将tensor使用符合[a,b)间均匀分布的值填充
x_uniform_=torch.Tensor(2,3).uniform_(200,300)
print('x_uniform:{0}\n{1}'.format(x_uniform_.type(),x_uniform_))

x_uniform:torch.FloatTensor
tensor([[294.6545, 295.1939, 212.2958],
        [268.0899, 275.7062, 203.0763]])

1.5 生成序列tensor

1.5.1 torch.arange(a,b,step)

和python中的range类似，生成[a,b)间用步长step增长的tensor（左闭右开），注意默认类型为LongTensor。

# 1. 使用arange 左闭右开 默认LongTensor
x_arange=torch.arange(0,10)
print('x_range:{0}\n{1}'.format(x_arange.type(),x_arange))

x_range:torch.LongTensor
tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

1.5.2 torch.linspace(a,b,num)

和np.linspace相同，生曾将[a,b]切分成num份后（头尾断点都包含），由切分点组成的tensor，左闭右闭，默认FloatTensor。

# 2. 使用linspace 左闭右闭
x_linspace=torch.linspace(0,9,10)
print('x_linspace:{0}\n{1}'.format(x_linspace.type(),x_linspace))

x_linspace:torch.FloatTensor
tensor([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])

1.5.3 torch.randperm(n)

生成将[0,1,…,n]随机打乱后的tensor，可以用于打乱索引顺序，注意默认为LongTensor。

# 3. 使用randperm 打乱索引 默认LongTensor
x_randperm=torch.randperm(10)
print('x_randperm:{0}\n{1}'.format(x_randperm.type(),x_randperm))

x_randperm:torch.LongTensor
tensor([2, 9, 7, 0, 6, 4, 3, 5, 8, 1])