pytorch学习笔记——2.2张量（上）

一、张量的数据类型：

        在torch中张量默认的数据类型是32位浮点型（即torch.FloatTensor)，但是我们可以使用torch.set_default_tensor_type()函数来更改默认的数据类型（虽然如此，但数据类型仍必须是float）。

        下面我们查看张量的数据类型：

torch.tensor([1.2,3.4]).dtype

结果为：（说明torch中张量默认的数据类型是32位浮点型）

torch.float32

         下面我们使用torch.set_default_tensor_type()函数来更改默认的数据类型：

torch.set_default_tensor_type(torch.DoubleTensor)
torch.tensor([1.2,3.4]).dtype

结果为：（说明已成功将默认数据类型更改为64位浮点型）

---

二、张量的生成：

1.使用torch.tensor()函数生成张量

        python的列表或序列可以通过torch.tensor()函数构造张量

        我们试着使用torch.tensor()函数将列表转化为张量：

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

结果为：

tensor([[1., 1.],
        [2., 2.]])

 我们可以使用方法shape查看张量的维度，size()查看张量的大小，numel()查看张量内元素个数：

###
A.shape#查看维度

torch.Size([2, 2])
###
A.size()#查看大小

torch.Size([2, 2])
###
A.numel()#查看元素个数

4

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

P.S.梯度的定义：梯度的本意是一个向量（矢量），表示某一函数在该点处的方向导数沿着该方向取得最大值，即函数在该点处沿着该方向（此梯度的方向）变化最快，变化率最大

        下面我们尝试生成一个需要计算梯度的向量：

B = torch.tensor((1,2,3),dtype = torch.float32,requires_grad=True)
#生成一个需要计算梯度的张量B（必须先指定B中元素类型，
#再用requires_grad=True表明B可以计算每个元素的grad）

    其中dtype表示指定张量B中的元素为32位浮点型，requires_grad参数表示张量B可以计算每个元素的梯度

     下面我们更进一步，针对张量B计算sum(B**2)在每个元素的梯度大小：

y=B.pow(2).sum()
y.backward()
B.grad

结果如下，符合x**2导数为2x的常识

tensor([2., 4., 6.])

 值得注意的是，仍然是只有浮点数才可以计算梯度！

2.使用torch.Tensor()函数生成张量

        在pytorch中，我们可以使用torch.Tensor()函数来生成张量，并且可以根据指定的形状进行生成

        下面我们试着用列表生成张量C：

C = torch.Tensor([1,2,3,4])#根据列表生成张量

结果为：

tensor([1., 2., 3., 4.])

 也可以根据自定的形状参数生成特定尺寸的张量，我们以生成2*3的张量D为例：

D = torch.Tensor(2,3)#根据给定的形状参数生成特定尺寸的张量

结果为：

tensor([[0.0000e+00, 2.0000e+00, 1.8754e+28],
        [2.0110e+20, 8.2263e+20, 1.2982e-11]])

         如果已知某个张量，我们还可以通过torch.****_like系列生成与指定张量维度相同、性质相似的张量，例如：生成与D维度相同的全1张量

D = torch.Tensor(2,3)
torch.ones_like(D)

结果如下，与张量D维度相同：

tensor([[1., 1., 1.],
        [1., 1., 1.]])

         类似的，我们可以通过torch.zeros_like(D)，生成与D维度相同的全0张量；通过torch.rand_like(D)，生成与D维度相同的随机张量：

###全0张量
torch.zeros_like(D)

tensor([[0., 0., 0.],
        [0., 0., 0.]])
###随机张量
torch.rand_like(D)

tensor([[0.0611, 0.3999, 0.9493],
        [0.8734, 0.4869, 0.2798]])

        最后，针对一个已经创建好的张量D，我们可以使用D.new**()系列函数创建出新的类型相似、尺寸不同的张量，它们的dtype与device都相同，我们用

#针对一个创建好的张量D，可以用D.new_**()创建新的张量，类型相似，尺寸不同
E = [[1,2],[3,4]]
E = D.new_tensor(E)
#Returns a new Tensor with as the tensor data. 
#By default, the returned Tensor has the same torch.dtype and torch.device as this tensor.data
print(D.size())
print(E.size())

3.张量和numpy数据互相转换

1. 利用numpy数组生成张量：

        值得注意的是，使用numpy生成的数组默认是64位浮点型数组，转化为张量就是torch.float64，有别于默认数据类型！

        将numpy数组转化为张量，我们一般有两种方法：使用torch.as_tensor()或使用torch.from_numpy()

        首先，我们尝试使用torch.as_tensor()将3*3全1数组转化为张量：

import numpy as np
F = np.ones((3,3))
#使用torch.as_tensor()
Ftensor = torch.as_tensor(F)

结果为：

tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)

         下面我们使用torch.from_numpy()将数组转化为张量：

#使用torch.from_numpy()
Ftensor = torch.from_numpy(F)

结果为：

tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)

     2.利用张量生成numpy数组： 

        我们使用torch.numpy()即可将张量转化为numpy数组，示例如下：

import numpy as np
F = np.ones((3,3))
Ftensor.numpy()

结果为：

array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

4.使用随机数生成张量

        在pytorch中我们可以通过相关随机数来生成张量，并且可以指定生成随机数的分布函数等，注意：我们可以使用torch.manual_seed()指定生成随机数的种子，设置随机种子后，是每次运行test.py文件的输出结果都一样，而不是每次随机函数生成的结果一样

        首先，我们使用torch.normal生成服从正态分布的随机数，并使用参数mean和std控制均值和标准差，使用mean和std的个数控制生成随机数的个数，首先生成一个服从标准正态分布的随机数如下：

torch.manual_seed(0)
A = torch.normal(mean = 0.0,std = torch.tensor(1.0))

结果为;

tensor(1.5410)

我们可以通过 mean和std的个数控制生成随机数的个数

例如生成均值均为0，但标准差分别为1,2,3,4的四个随机数张量：

torch.manual_seed(0)
#生成均值均为0，但标准差分别为1,2,3,4的四个随机数张量
A = torch.normal(mean = 0.0,std = torch.arange(1,5.0))

结果为：

tensor([ 1.5410, -0.5869, -6.5364,  2.2737])

 生成均值分别为1,2,3,4，标准差分别为1,2,3,4的四个随机数张量：

torch.manual_seed(0)
#生成均值分别为1,2,3,4，标准差分别为1,2,3,4的四个随机数张量
A = torch.normal(mean = torch.arange(1,5.0),std = torch.arange(1,5.0))

结果为：

tensor([ 2.5410,  1.4131, -3.5364,  6.2737])

         然后，我们还可以使用torch.rand()生成在[0,1]上服从均匀分布的张量，示例如下：

torch.manual_seed(0)
B = torch.rand(2,3)

C = torch.rand_like(B)

 结果为(其中使用torch.rand_like函数可以根据其他张量维度生成与其维度相同的随机数张量)：

B
tensor([[0.4963, 0.7682, 0.0885],
        [0.1320, 0.3074, 0.6341]])
C
tensor([[0.4901, 0.8964, 0.4556],
        [0.6323, 0.3489, 0.4017]])

        我们还可以使用torch.randn()生成服从标准正态分布的张量，示例如下：

torch.randn(2,3)

结果为：

tensor([[ 0.4033,  0.8380, -0.7193],
        [-0.4033, -0.5966,  0.1820]])

        最后，我们简单介绍其他几个生成张量的函数：

        示例1：使用torch.arange，其中参数start指定开始，end指定结束，step指定步长

torch.arange(0,10,2)#start end step

结果为：

tensor([0, 2, 4, 6, 8])

        示例2：使用torch.linespace在范围内生成指定数量的等间隔张量，其中参数start指定开始，end指定结束，number指定张量个数

torch.linspace(1,10,2)#start end number

结果为:

tensor([ 1., 10.])