pytorch张量 张量的生成

一、torch.tensor()函数

生成张量：

A = torch.tensor([1.0,1.0],[2,2])
A
#tensor([1.,1.],
#       [2.,2.])

查看张量的一些属性：

A.shape() #张量的维度
#torch.Size([2,2])
A.size() #张量的形状
#torch.Size([2,2])
A.numel() #张量中元素的数量
#4

在使用torch.tensor()函数时，可以使用参数dtype来指定张量的数据类型，使用参数requires_grad来指定张量是否需要计算梯度。只有计算了梯度的张量，才能在深度网络优化时根据梯度大小进行更新。

B = torch.tensor([1,2,3],dtype=torch.float32,requires_grad = True)
B
#tensor([1.,2.,3.],requires_grad = True)

下面针对张量B计算sum(B^2)在每个元素上的梯度大小：

y = B.pow(2).sum()
y.backward()
B.grad
#tensor([2.,4.,6.])

需要注意的是，只有浮点类型的数据才能计算梯度，其他类型的数据不能计算张量的梯度。

二、torch.Tensor()函数

也可以根据指定形状生成张量：

C = torch.Tensor([1,2,3,4])
C
#tensor([1.,2.,3.,4.])
D = torch.Tensor(2,3) #生成2*3的张量
D
#tensor([[0.0000e+00,-1.0842e-19,-1.4324e+00],
         [8.5920e+09,1.1117e-21,1.4013e-45]]) 

针对已经生成的张量可以使用torch.**like()系列函数生成与指定张量维度相同、性质相似的张量

torch.ones_like(D) #生成一个与D相同大小和类型的全1向量
#tensor([[1.,1.,1.],
#        [1.,1.,1.]])

torch.zeros_like(D) #生成一个与D相同大小和类型的全0向量
#tensor([[0.,0.,0.],
#        [0.,0.,0.]])

torch.rand_like(D) #生成一个与D相同大小和类型的随机向量
#tensor([[0.3651,0.3743,0.4789],
#        [0.2079,0.7280,0.2771]])

针对一个创建好的张量D，可以使用D.new_**()系列函数创建出新的张量，如使用D.new_tensor()将列表转化为张量：

E = [[1,2],[3,4]]
E = D.new_tensor(E) #将列表E转化为32位浮点型的张量
print("D.dtype:"，D.dtype)
print("E.type:",E.dtype)
# D.dtype: torch.float32
# E.dtype: torch.float32

#其他：
D.new_full((3,3),fill_value= 1) #3*3使用1填充的张量
D.new_zeros((3,3))  #3*3的全0张量
D.new_empty((3,3))  #3*3的空张量
D.new_ones((3,3))  #3*3的全1张量

三、张量和numpy数据相互转换

将numpy数组转化为pytorch张量

import numpy as np
F = np.ones((3,3))
Ftensor = torch.as_tensor(F)  # torch.as_tensor()函数
Ftensor
#tensor([[1.,1.,1.],
#       [1.,1.,1.],
#       [1.,1.,1.]],dtype = torch.float64) #因为numpy生成的数组默认64位浮点型数据

Ftensor = torch.from_numpy(F) # torch.from_numpy()函数
Ftensor
#tensor([[1.,1.,1.],
#       [1.,1.,1.],
#       [1.,1.,1.]],dtype=torch.float64)

将pytorch张量转化为numpy数组

Ftensor.numpy()
#array([[1.,1.,1.],
#       [1.,1.,1.],
#       [1.,1.,1.]])

四、随机数生成张量

可以通过相关随机数来生成张量，并且可以指定生成随机数的分布函数等。在生成随机数之前，可以使用torch.manual_seed()函数，指定生成随机数的种子，用于保证生成的随机数是可重复出现的。
可以使用torch.normal()函数生成服从正态（0，1）分布的随机数。

torch.manual_seed(123)
#使用torch.normal()函数生成服从正态（0，1）分布的随机数
A = torch.normal(mean=0.0,std=torch.tensor(1.0)) #mean参数和std参数都只有一个元素则只会生成一个随机数
A
#tensor(-0.1115)

torch.manual_seed(123)
A = torch.normal(mean=0.0,std=torch.arange(1,5.0))#mean参数和std参数有多个值则只可生成多个随机数
A
#tensor([-0.1115,0.2407,-1.1089,-0.9617])
#解释：每个随机数服从的分布均值都是0，但是它们分布的标准差则分别为1，2，3，4

torch.manual_seed(123)
A = torch.normal(mean=torch.arange(1,5.0),std=torch.arange(1,5.0)) #也可以分别指定每个随机数服从的均值
A
#tensor([0.8885,2.2407,1.8911,3.0383])
#解释：每个随机数服从的分布均值分别为1，2，3，4，分布的标准差也分别为1，2，3，4

也可以使用torch.rand()函数，在区间【0，1】上生成服从均匀分布的张量

torch.manual_seed(123)
B = torch.rand(3,4)
B
#tensor([[0.2961, 0.5166, 0.2517, 0.6886],
#        [0.0740, 0.8665, 0.1366, 0.1025],
#        [0.1841, 0.7264, 0.3153, 0.6871]])

torch.rand_like()函数，可以根据其他张量的维度，生成与其维度相同的随机数张量

torch.manual_seed(123)
C = torch.ones(2,3)
D = torch.rand_like(C)
D
#tensor([[0.2961, 0.5166, 0.2517],
#        [0.6886, 0.0740, 0.8665]])

使用torch.randn()和torch.randn_like()函数可以生成服从标准正态分布的随机数张量

print(torch.randn(3,3))
print(torch.randn_like(C))
# tensor([[-0.1115,  0.1204, -0.3696],
#         [-0.2404, -1.1969,  0.2093],
#         [-0.9724, -0.7550,  0.3239]])
# tensor([[-0.1085,  0.2103, -0.3908],
#         [ 0.2350,  0.6653,  0.3528]])

使用torch.randperm(n）函数，则可将0~n(包含0不包含n)之间的整数进行随机排序后输出。

import torch
torch.manual_seed(123)
torch.randperm(10)
#tensor([2, 0, 8, 1, 3, 7, 4, 9, 5, 6])

五、其他生成张量的函数

torch.arange()函数

import torch
torch.arange(start=0,end=10,step=2)
#tensor([0, 2, 4, 6, 8])

torch.linspace()函数

import torch
torch.linspace(start=1,end=10,steps=5) #在范围内生成固定数量的等间隔张量
#tensor([ 1.0000,  3.2500,  5.5000,  7.7500, 10.0000])

torch.logspace()函数

import torch
print(torch.linspace(start=0.1,end=1.0,steps=5))
print(torch.logspace(start=0.1,end=1.0,steps=5)) #输出结果和10**(torch.linspace(start=0.1,end=1.0,steps=5))等价
# tensor([0.1000, 0.3250, 0.5500, 0.7750, 1.0000])
# tensor([ 1.2589,  2.1135,  3.5481,  5.9566, 10.0000])

一些预定义函数，用于生成特定的张量

torch.zeros(3,3) #3*3的全0张量
torch.ones(3,3) #3*3的全1张量
torch.eye(3) #3*3的单位张量
torch.full((3,3),fill_value=0.25) #3*3的使用0.25填充的张量
torch.empty(3,3) #3*3的空张量