【pyTorch基础】(2) 张量的创建方法

终于还是入坑了pyTorch，这个月的目标检测先停更一段时间，先学一段时间的GCN。立个flag，下个月把TensorFlow版的YOLOV5更完。

---

1. 创建 numpy 类型转为 Tensor 类型

由于numpy数组类型是最常用的，可以先使用numy创建数组，再从数组转为张量，基本数据类型保持不变，例如：np.float64 变成 torch.float64。

从numpy转为tensor类型的方法： torch.from_numpy( numpy数组 )

# 转换后的数据类型是对应的
import numpy as np

#（1）创建一个维度=1，长度=2的向量
data = np.array([2, 3.3])
# array([2. , 3.3])

# 将numpy类型转为tensor类型
data = torch.from_numpy(data)
# tensor([2.0000, 3.3000], dtype=torch.float64)

#（2）创建一个全为1的二阶矩阵
data = np.ones(shape=[2,3])
# array([[1., 1., 1.],
#        [1., 1., 1.]])

# 转变为tensor类型
data = torch.from_numpy(data)
# tensor([[1., 1., 1.],
#         [1., 1., 1.]], dtype=torch.float64)

---

2. 列表类型转为 tensor 类型

注意，该函数是直接把传入的列表变成张量，输入和输出的数值是不变的，输入参数的不是张量的shape

列表转为tensor类型： torch.tensor( 列表 )

# 将传入的列表变成tensor类型
data = torch.tensor([2.2, 3.3])
# tensor([2.2000, 3.3000])

data = torch.tensor([[2.2, 3.3], [4.4, 5.5]])
# tensor([[2.2000, 3.3000],
#         [4.4000, 5.5000]])

---

3. 生成未初始化的 tensor

注意，该方法生成的数据非常不规则，使用时一定要把后续的数据写进来，如果直接使用，可能会报错nan

生成指定形状的张量，张量内的元素随机： torch.empty( 张量shape )

生成指定形状指定数据类型的张量，张量内的元素随机：

float类型： torch.FloatTensor( 张量shape )

int类型： torch.IntTensor( 张量shape )

#（1）生成一片内存空间，不需要初始化
data1 = torch.empty(1)  # 长度为1
# tensor([9.9184e-39])

data2 = torch.empty([2,3])  # 2行3列的未初始化矩阵tensor
# tensor([[2.1707e-18, 4.2330e+21, 7.2251e+28],
#         [7.0368e+28, 3.3127e-18, 1.6892e-04]])

#（2）生成指定维度的未初始化的数据
data1 = torch.FloatTensor(2, 3)  # float类型二阶矩阵
# tensor([[9.2755e-39, 1.0561e-38, 1.1204e-38],
#         [1.0194e-38, 9.9184e-39, 8.4490e-39]])

data2 = torch.IntTensor(2)  # int类型向量
# tensor([0, 1083129856], dtype=torch.int32)

---

4. 随机初始化

4.1 rand() 随机0-1初始化

给定张量的形状shape，张量的每个元素是在[0,1]之间的

torch.rand( 张量shape )

torch.rand(2) # 向量
# tensor([0.2300, 0.7452])

torch.rand(2,3)  # 矩阵
# tensor([[0.0214, 0.4409, 0.3778],
#         [0.8571, 0.4957, 0.7218]])

torch.rand(2,2,3)  # 三维
# tensor([[[0.7301, 0.0870, 0.0573],
#          [0.4576, 0.5049, 0.9410]],
#         [[0.7045, 0.6702, 0.3119],
#          [0.1384, 0.9376, 0.9691]]])

---

4.2 rand_like() 给定tensor的随机0-1初始化

创建和输入参数tensor的shape相同的张量，张量的元素是0-1随机初始化

torch.rand_like( tensor )

# 创建一个向量
data = torch.tensor([1.1, 2.2, 3.3])  
# 随机0-1初始化一个shape和data相同的tensor
torch.rand_like(data)
# tensor([0.7710, 0.5399, 0.4941])

---

4.3. randint() 在某一范围内随机整数采样

在某个范围内随机取值，取整数。需要指定该范围的下限和上限，以及需创建的张量的形状shape。取值范围包含下限，不包含上限。

torch.randint( 下限, 上限, shape )

# 需要指定最小值, 最大值, shape，随机采样包含最小值，不包含最大值
torch.randint(1, 10, size=[2,3])
# tensor([[4, 3, 2],
#         [5, 2, 2]])

---

4.4 randn() 随机正态分布

给定要创建的张量的shape，张量的每个元素满足 均值为0，方差为1 的随机正态分布

torch.randn( shape )

torch.randn(3)  # 向量
# tensor([-0.8556, -1.3012, -0.1202])

torch.randn(size=[2,3])  # 矩阵
# tensor([[-0.5486,  1.0590,  2.7441],
#         [ 0.4896,  0.0592, -0.5964]])

---

5. 创建全为某个值的 tensor

5.1 全为1的张量

创建指定定shape的全为1的张量： torch.ones( shape )

创建和传入tensor的shape相同的全为1的张量： torch.ones_like( tensor )

#（1）ones()  # 全为1的tensor
data = torch.ones(size=[2,3])
# tensor([[1., 1., 1.],
#         [1., 1., 1.]])

# 和data的shape相同的全为1的tensor
torch.ones_like(data)
# tensor([[1., 1., 1.],
#         [1., 1., 1.]])

---

5.2 全为0的张量

创建指定定shape的全为0的张量： torch.zeros( shape )

创建和传入tensor的shape相同的全为0的张量： torch.zeros_like( tensor )

#（2）zeros()  # 全为0的tensor
data = torch.zeros(size=[2,3])
# tensor([[0., 0., 0.],
#         [0., 0., 0.]])

# 和data的shape相同的全为1的tensor
torch.zeros_like(data)
# tensor([[0., 0., 0.],
#         [0., 0., 0.]])

---

5.3 全为某个值的张量

创建指定shape的张量，张量的元素都是指定的值： torch.full( shape , 数值 )

# 2行3列全为1的tensor
torch.full(size=[2,3], fill_value=7.0)
# tensor([[7., 7., 7.],
#         [7., 7., 7.]])

# 初始化一个标量
torch.full(size=[], fill_value=7)
# tensor(7)

# 初始化一个向量
torch.full(size=[1], fill_value=7)
# tensor([7])

---

5.4 单位矩阵

创建指定shape的张量，正对角方向的元素为1，其他元素为0

torch.eye( shape )

# 三行三列，可略写(3,3)
torch.eye(3)
# tensor([[1., 0., 0.],
#         [0., 1., 0.],
#         [0., 0., 1.]])

torch.eye(3,4)
# tensor([[1., 0., 0., 0.],
#         [0., 1., 0., 0.],
#         [0., 0., 1., 0.]])

---

6. arange() 递增张量

给定等差数列的下限和上限，以及步长(默认为1)，张量包含下限不包含上限

torch.arange( 下限值，上限值，step=步长 )

# 从0到10每次递增1，包含0不包含10
torch.arange(0,10)
# tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# 从0到10每次递增2，包含0不包含10
torch.arange(0, 10, 2)
# tensor([0, 2, 4, 6, 8])

---

7. linspace 等分张量

给定等差数列的下限和上限，以及等分成几份，即张量中有几个元素。张量包含上限也包含下限

torch.linspace( 下限，上限，step=等分几份 )

# 从0到10，等分成4份的等差数列，包含0也包含10
torch.linspace(0, 10, 4)
# tensor([ 0.0000,  3.3333,  6.6667, 10.0000])

# 0到10等分7份
torch.linspace(0, 10, 7)
# tensor([ 0.0000,  1.6667,  3.3333,  5.0000,  6.6667,  8.3333, 10.0000])

---

8. logspace 幂指数递增

torch.logspace( 下限，上限，step=等分几份，base=底数 )

生成等比数列，如 torch.logspace(0, -1, steps=8, base=10) 代表生成10的0次方为起始值，10的-1次方为终止值的8个数构成的等比数列

# base代表对数的底数，0-10分成11步，计算10^(n)
torch.logspace(0, 10, steps=10, base=10)
# tensor([1.0000e+00, 1.0000e+01, 1.0000e+02, 1.0000e+03, 1.0000e+04, 1.0000e+05, 1.0000e+06, 1.0000e+07, 1.0000e+08, 1.0000e+09, 1.0000e+10])

# 计算2^(n)，从0到-1分成11步
torch.logspace(0, -1, steps=10, base=2)
# tensor([1.0000, 0.9259, 0.8572, 0.7937, 0.7349, 0.6804, 0.6300, 0.5833, 0.5400, 0.5000])

---

9. randperm() 随机打乱

用于生成随机打乱后的索引。举个例子data1代表图片，data2代表图片的类别信息，对图片随机打乱，并且还能保留图片和类别之间的对应关系。

torch.randperm( 索引数 )

# 生成0-10的随机索引[0,9]之间
torch.randperm(10)
# tensor([7, 8, 9, 6, 3, 1, 0, 4, 2, 5])

# 索引打乱后还能配对
index = torch.randperm(10)
# 创建两个张量
data1 = torch.arange(0,10)
data2 = torch.arange(0,10) * 10
# 索引配对打乱，不改变data1和data2各元素之间的对应关系
data1[index]*10 == data2[index] 
# tensor([True, True, True, True, True, True, True, True, True, True])

---

10. 更改默认数据类型

我们创建的张量，若不指定数据类型，那么默认是 'torch.FloatTensor'，可以更改默认数据类型

torch.set_default_tensor_type( 数据类型 )

# 默认创建的数据类型是float类型
torch.tensor([1.2, 3]).type()
# 'torch.FloatTensor'

# 更改默认数据类型为Double类型
torch.set_default_tensor_type(torch.DoubleTensor)

# 再查看一下数据类型
torch.tensor([1.2, 3]).type()
# 'torch.DoubleTensor'