pytorch张量与变量 （一）

pytorch基础

Tensor(张量)

不同数据类型的Tensor

• 32位浮点型：torch.FloatTensor()
• 64位浮点型：torch.DoubleTensor()
• 16位整型：torch.ShortTensor()
• 32位整型：torch.IntTensor()
• 64位整型：torch.LongTensor()

注意：torch.Tensor()默认是32位的torch.FloatTensor()

---

创建一个全为0的Tensor

>>>b = torch.zeros((3,2)) #表示3行2列
>>>b
tensor([[0., 0.],
        [0., 0.],
        [0., 0.]])

创建一个正态分布作为随机初始值

>>>c = torch.randn((3,2))
>>>c
tensor([[ 1.4054, -1.4447],
        [-0.6969,  0.3615],
        [-1.0447, -0.1037]])

可以通过索引获取值或更改值

>>>b[0,1] = 10
>>>b
tensor([[ 0., 10.],
        [ 0.,  0.],
        [ 0.,  0.]])

>>>b[0,1]
tensor(10,)

Tensor()与numpy.ndarray()相互转换

>>>a = torch.Tensor([[2,3],[4,8],[7,9]])
>>>a
tensor([[2., 3.],
        [4., 8.],
        [7., 9.]])
#--------------------转为numpy.ndarray-----------------
>>>numpy_a = a.numpy()
>>>numpy_a
array([[2., 3.],
       [4., 8.],
       [7., 9.]], dtype=float32)

>>>e = np.array([1,2],[3,4])
>>>e
array([[1, 2],
       [3, 4]])
#--------------------转为Tensor-----------------------
>>>torch_e = torch.from_numpy(e)
>>>torch_e
tensor([[1, 2],
        [3, 4]], dtype=torch.int32)

#-------------------torch_e再转为浮点型----------------
>>>f_torch_e = torch_e.float()
>>>f_torch_e
tensor([[1., 2.],
        [3., 4.]])    #注意多了小数点

要更改Tensor的数据类型，只需要在需要转换的数据后面添加上想要转换成的数据类型就行了，如上面获得f_torch_e的例子。

将Tensor放到GPU上运行

如果电脑支持GPU加速，就可以将Tensor放到GPU上运行

判断电脑是否支持GPU：

>>>torch.cuda.is_available()
True #返回True说明支持

把Tensor a放到cuda运行：

a_cuda = a.cuda()
print(a_cuda)

---

Variable（变量）

Variable是神经网络计算图特有的一个概念，在numpy中没有；

Variable具有自动求导的功能；

Variable和Tensor本质上没有区别，不过Variable会被放入一个计算图中，然后进行前向传播、反向传播，自动求导。

将一个Tensor转变为Variable

from torch.autograd import Variable
x = Variable(torch.Tensor([1]), requires_grad=True)

构建Variable时注意传入参数requires_grad=True,表示是否对这个变量求梯度，默认为False

Variable具有三个属性：

• data
• grad
• grad_fn

通过data可以取出Variable里的Tensor数值：

>>>x.data
tensor([1.])

grad_fn表示得到这个Variable需要进行的运算，比如加减或乘除：

>>>y = 2 * x + 1
>>>y.grad_fn
<AddBackward0 at 0x1744b29eb00>

grad表示这个Variable反向传播的梯度

>>>y = 2 * x + 1
>>>y.backward()      #即自动对y求导
>>>x.grad            #实际就是y关于x的导数
tensor([2.])

y.backward()实际就是 y.backward(torch.FloatTensor([1])),但由于上面的都是标量，所以参数写不写都行

对矩阵求导

x = torch.Tensor([2,3,4])
x = Variable(x, requires_grad=True)

y= x * 3
print(y)

y.backward(torch.FloatTensor([1,1,1])) #参数不能省略
x.grad

#------------输出------------------------------------
tensor([ 6.,  9., 12.], grad_fn=<MulBackward0>)
tensor([3., 3., 3.])

这里的 y.backward(torch.FloatTensor([1,1,1])) 参数不能省略，否则报错。此时 x.grad 返回各个分量的梯度；

如果传入的参数是torch.FloatTensor([1,0.1,0.01])，则返回的是原来的梯度再分别乘以1，0.1, 0.01