PyTorch的张量tensor和自动求导autograd详解
作者：Vic·Tory
PyTorch是一个基于python的科学计算包，除了可以替代NumPy构建数组张量来利用GPU进行计算之外，还是一个高灵活性、速度快的深度学习平台
张量
张量(Tensor)实际上是一个多维数组，使用GPU可以加速张量的运算。
创建tensor：可以通过torch.tensor()将普通数组转化为tensor，torch.empty()或rand()可以创建随机tensor，torch.zeros()、ones()创建数据都是0或1的tensor。
t.clone()可以克隆一个张量，t.size()可以获取张量的形状。
import torch t = torch.tensor([[5, 6], [7, 8]]) # 转化为tensor t1 = torch.empty(5, 3) # 创建随机5×3的tensor t2 = torch.rand(5, 3) t3 = torch.zeros(5, 3, dtype=torch.float16) # 创建全为0的5×3数组 t4 = torch.ones(5, 3) # 创建全为1的 t5 = torch.ones_like(t3) # 创建形状和t3一样、全为1的数组 print(t5.size()) # 输出：torch.Size([5, 3])
操作tensor：tensor可以像Numpy一样直接对数组进行索引、截取、切片等操作。
view(-1，2)可以改变tensor的形状，类似于numpy.reshape()，这里修改为第一维长度为2，第二维-1代表自动计算维度。permute()可以交换数组维度位置，类似于numpy.transpose()squeeze()可以压缩张量中长度为1的维度，比如数组[[1,2,3]]形状为(1,3)，经过压缩后变成长度为3的数组[1,2,3]。反之，unsqueeze()可以在指定位置将维度增加长度为1expand()可以按原数据为元素扩大维度，即将原来的数据复制多份并一起组成更高维度，扩大tensor不需要分配新内存，只是仅仅新建一个tensor的视图。使用时注意保持新维度与原维度的统一。
t = torch.tensor([[1, 2, 3],
[4, 5, 6]])
print(t[0, :2]) # 选取首行前两个元素，输出tensor([1, 2])
print(t.view(-1, 2)) # 改变形状
'''
tensor([[1, 2],
[3, 4],
[5, 6]])
'''
t = torch.unsqueeze(t, dim=0) # 给张量第一维增加一个维度
print(t)
'''
tensor([[[1, 2, 3],
[4, 5, 6]]])
'''
print(t.permute(2, 1, 0)) # 交换维度位置
'''
tensor([[1, 3, 5],
[2, 4, 6]])
'''
print(t.expand(2, 2, 3)) # 将(2,3)的tensor扩维成为(2,2,3)
'''
tensor([[[1, 2, 3],
[4, 5, 6]],
[[1, 2, 3],
[4, 5, 6]]])
'''
通过tensor进行四则运算也十分方便，下面以加法为例记录几种使用的形式：
x = torch.tensor([[1, 2, 3],
[4, 5, 6]])
y = torch.tensor([[7, 8, 9],
[10, 11, 12]])
print(x + y) # 用运算符
print(torch.add(x, y)) # 用add()函数
z = torch.empty(2, 3)
torch.add(x, y, out=z) # 指明输出对象
print(z)
y.add_(x) # 在原数组上操作
print(y)
值得注意的是，pytorch中在原张量上进行的操作函数后面都跟有一个_，例如其他的还有在原张量上复制x.copy_()。
和NumPy数组相互转化：通过tensor.numpy()可以将tensor转为numpy数组，但二者会共享一个内存空间，即对tensor进行的修改操作之后，输出numpy的结果也会随之改变。如果希望产生一个新的可以通过clone()函数。通过torch.from_numpy()可以从numpy数组创建tensor，同样地二者共享内存。
t = torch.ones(5) print(t) n1 = t.numpy() # 转化为numpy n2 = t.clone().numpy() t.add_(1) # 对原来的tensor进行操作 print(n1) print(n2) n = np.ones(5) t2 = torch.from_numpy(n) # 从numpy创建tensor ''' tensor([1., 1., 1., 1., 1.]) 原来的t [2. 2. 2. 2. 2.] 操作t后对应的n1也随之改变 [1. 1. 1. 1. 1.] 但是克隆产生的n2不会改变 '''
使用不同设备计算tensor，例如下面使用to()来将tensor移入和移出GPU
if torch.cuda.is_available():
device = torch.device("cuda") # a CUDA device object
y = torch.ones_like(x, device=device) # 直接在GPU上创建tensor
x = x.to(device) # 或者使用.to("cuda")，将tensor移入GPU
z = x + y
print(z)
print(z.to("cpu", torch.double)) # 将tensor移出GPU，也能在移动时改变dtype
'''
tensor([2., 2., 2., 2., 2.], device='cuda:0')
tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
'''
自动求导
PyTorch中，所有神经网络的核心是 autograd 包，它为张量上的所有操作提供了自动求导机制。
Pytorch通过Tensor来储存数据，我们可以把它看作一个节点，通过Function实现数据操作，即节点之间转换的路径。
如下所示为一个训练过程，输入张量x，经过一系列操作之后得到输出y。
如下所示为实现上面过程的代码，首先通过tensor定义张量，通过属性requires_grad指定是否需要自动求导。之后执行正向操作*w1、+b、*w2，最后求平均得到输出y。
接着通过backward()执行反向传播，就可以得到张量的grad值了。
# 定义张量 x = torch.ones(5, requires_grad=True) w1 = torch.tensor(2.0, requires_grad=True) w2 = torch.tensor(3.0, requires_grad=True) b = torch.tensor(4.0, requires_grad=False) # 执行正向操作 l1 = x * w1 l2 = l1 + b l3 = l2 * w2 y = l3.mean() # 反向传播 y.backward() print(l1.data, l1.grad, l1.grad_fn) # tensor([2., 2., 2., 2., 2.]) None <MulBackward0 object at 0x0000024D8E921BE0> print(l2.data, l2.grad, l2.grad_fn) # tensor([6., 6., 6., 6., 6.]) None <AddBackward0 object at 0x000001B960FC0F98> print(y) # tensor(18., grad_fn=<MeanBackward0>) print(w1.grad, w2.grad) # tensor(3.) tensor(6.) print(x.grad) # tensor([1.2000, 1.2000, 1.2000, 1.2000, 1.2000])
从上面的输出可以看到x一开始为[1,1,1,1,1]，乘以w1后为[2., 2., 2., 2., 2.]，+b之后为[6., 6., 6., 6., 6.]，再乘以3为[18., 18., 18., 18., 18.]，求均值得到y为18。
Tensor的grad_fn属性用于记录上一步是经过怎样的操作得到自己的，用于反向传播时进行求导。例如l1.grad_fn为MulBackward0代表其反向传播操作为乘法
反向传播后通过grade属性可以获得最后输出对本张量的导数值。例如上面的操作中输出为y，反向传播后，w2.grad获得的就是dy/dw2。由链式求导法则可得dy/dw2=dy/dl3 × dl3/dw2。由于y由l3求均值得到，即y=1/5(Σl3)，所以dy/dl3=1/5，又l3=l2 * w2，所以dl3/dw2=l2，所以dy/dw2=1/5*l2=1/5(6., 6., 6., 6., 6.)=6。同理通过反向链式求导得到w1、x的grad
注意到l1、l2的grade值为None，这是由于张量l1、l2、l3都是中间计算结果，它们被称为非叶张量，相对地由用户创建的x、w1、w2被称为叶张量（leaf tensor）。pytorch为了节约内存并不会保存中间张量的导数值，只会用grad_fn来记录是通过什么操作产生的。如果我们希望查看的话，可以通过retain_grad()来保存非叶张量的导数值。
... l1.retain_grad() l2.retain_grad() y.backward() print(l1.data, l1.grad, l1.grad_fn) # tensor([2., 2., 2., 2., 2.]) tensor([0.6000, 0.6000, 0.6000, 0.6000, 0.6000]) <MulBackward0 object at 0x000001DF52100F60> print(l2.data, l2.grad, l2.grad_fn) # tensor([6., 6., 6., 6., 6.]) tensor([0.6000, 0.6000, 0.6000, 0.6000, 0.6000]) <AddBackward0 object at 0x000001DF52111048>
如果我们设置了张量requires_grad，但在某个训练过程中不需要记录梯度grad，可以把代码块包裹在with torch.no_grad():中，这样里面的所有张量都不会保存grad
x = torch.ones(5, requires_grad=True)
print((x ** 2).requires_grad) # 输出True，记录grad
with torch.no_grad():
print((x ** 2).requires_grad) # 输出False，不记录
总结
以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。