沧州网站建设专业定制,手机网站开发,做dhl底单的网站是 什么,学历提升的重要性Pytorch autograd.grad与autograd.backward详解
引言
平时在写 Pytorch 训练脚本时#xff0c;都是下面这种无脑按步骤走#xff1a;
outputs model(inputs) # 模型前向推理
optimizer.zero_grad() # 清除累积梯度
loss.backward() # 模型反向求导
optimizer.step()…Pytorch autograd.grad与autograd.backward详解
引言
平时在写 Pytorch 训练脚本时都是下面这种无脑按步骤走
outputs model(inputs) # 模型前向推理
optimizer.zero_grad() # 清除累积梯度
loss.backward() # 模型反向求导
optimizer.step() # 模型参数更新对用户屏蔽底层自动微分的细节使得用户能够根据简单的几个 API 将模型训练起来。这对于初学者当然是极好的也是 Pytorch 这几年一跃成为最流行的深度学习框架的主要原因易用性。
但是我们有时需要深究自动微分的机制比如元学习方法 MAML 参考 Pytorch 代码中需要分别根据支持集和查询集的梯度按照不同的策略更新模型参数。这时还是需要了解一些 Pytorch 框架的自动微分机制。幸运的是Pytorch 关于这部分的框架设计也很清晰在参考了几个博客之后笔者将自己的对 Pytorch 自动微分机制接口总结在这里。 注意只是自动微分机制的 Python 接口而非底层实现。 背景知识
计算图
当今主流深度学习框架的计算图主要有两种形式静态图TensoFlow 1.x、Caffe …和动态图Pytorch …。两者的却别简单说来就是静态图是在模型确定之后就先生成一张计算图然后每次对于不同的输入样本都直接丢到计算图中跑而动态图则是对于每次样本输入都重新构建一张计算图。从它们的区别也可以感受到它们彼此最重要的优劣势静态图速度快但是不够灵活动态图灵活但速度稍慢。
在今天各个框架中动态图与静态图的区分也没有那么绝对了。比如 TensorFlow 2.0 已经采用动态图而 Pytorch 也可通过 scripting/tracing 转换成 JIT torchscript 静态图。但这不是本文的重点对深度学习框架计算图感兴趣可参考机器学习系统:设计与实现 计算图。
我们要讨论的是 Pytorch 的自动微分机制Pytorch 中主要是动态图即计算图的搭建和计算是同时的对每次输入都是重新建图计算。在 Pytorch 的计算图里有两种元素数据tensor和 运算operation。
运算包括了加减乘除、开方、幂指对、三角函数等可微分运算。数据在 Pytorch 中数据的形式一般就是张量 torch.Tensor。
tensor
Pytorch 中 tensor 具有如下属性 requires_grad是否需要求导 关于 requires_grad 属性的默认值。自己定义的叶子节点默认为 False而非叶子节点默认为 True神经网络中的权重默认为 True。判断哪些节点是True/False 的一个原则就是从你需要求导的叶子节点到 loss 节点之间是一条可求导的通路这条通路上的节点的 requires_grad 都应当是 True。 grad_fn当前节点是经过什么运算如加减乘除等得到的 grad导数值 datatensor 的数据 is_leaf是否为叶子节点 其他几个概念都比较好理解这里解释一下什么是叶子节点。 在 Pytorch 中如果一个张量的 requires_gradTrue则进一步可分为叶子节点和非叶子节点。叶子节点是用户创建的节点不依赖其它节点非叶子结点则是由叶子结点计算得到的中间张量。 a torch.randn(2, 2).requires_grad_()
b a * 2
print(a.is_leaf, b.is_leaf)
# 输出True False对于 requires_gradFalse 的 tensor 来说我们约定俗成地把它们归为叶子张量。但其实无论如何划分都没有影响因为张量的 is_leaf 属性只有在需要求导的时候才有意义。 由于叶子节点是用户创建的所以它的 grad_fn 为空而非叶子节点都是经过运算得到的所以 grad_fn 非空 叶子/非叶子表现出来的区别在于反向传播结束之后非叶子节点的梯度会被释放掉只保留叶子节点的梯度这样就节省了内存。如果想要保留非叶子节点的梯度可以使用 retain_grad() 方法。
关于 Pytorch tensor 的更多细节可参考浅谈 PyTorch 中的 tensor 及使用 。
一个例子
以下例子来自PyTorch 的 Autograd。
了解过背景知识之后现在我们来看一个具体的计算例子先用最常见的梯度反传方式 loss.backward() 并画出它的正向和反向计算图。假如我们需要计算这么一个模型
l1 input x w1
l2 l1 w2
l3 l1 x w3
l4 l2 x l3
loss mean(l4)这个例子比较简单涉及的最复杂的操作是求平均但是如果我们把其中的加法和乘法操作换成卷积那么其实和神经网络类似。我们可以简单地画一下它的计算图其中绿色节点表示叶子节点 图1正向计算图下面给出了对应的代码我们定义了 inputw1w2w3 这三个变量其中 input 不需要求导结果。根据 Pytorch 默认的求导规则对于 l1 来说因为有一个输入需要求导也就是 w1 需要所以它自己默认也需要求导即 requires_gradTrue即前面提到的 ”是否在需要求导的通路上“ 如果对这个规则不熟悉欢迎参考 浅谈 PyTorch 中的 tensor 及使用 或者直接查看 官方 Tutorial 相关部分。在整张计算图中只有 input 一个变量是 requires_gradFalse 的。正向传播过程的具体代码如下
input torch.ones([2, 2], requires_gradFalse)
w1 torch.tensor(2.0, requires_gradTrue)
w2 torch.tensor(3.0, requires_gradTrue)
w3 torch.tensor(4.0, requires_gradTrue)l1 input * w1
l2 l1 w2
l3 l1 * w3
l4 l2 * l3
loss l4.mean()print(w1.data, w1.grad, w1.grad_fn)
# tensor(2.) None Noneprint(l1.data, l1.grad, l1.grad_fn)
# tensor([[2., 2.],
# [2., 2.]]) None MulBackward0 object at 0x000001EBE79E6AC8print(loss.data, loss.grad, loss.grad_fn)
# tensor(40.) None MeanBackward0 object at 0x000001EBE79D8208正向传播的结果基本符合我们的预期。我们可以看到变量 l1 的 grad_fn 储存着乘法操作符 MulBackward0用于在反向传播中指导导数的计算。而 w1 是用户自己定义的不是通过计算得来的所以其 grad_fn 为空同时因为还没有进行反向传播grad 的值也为空。接下来我们看一下如果要继续进行反向传播计算图应该是什么样子 图2反向计算图反向图也比较简单从 loss 这个变量开始通过链式法则依次计算出各部分的导数。说到这里我们不妨先自己手动推导一下求导的结果再与程序运行结果作对比。如果对这部分不感兴趣的读者可以直接跳过。
再摆一下公式
input [1.0, 1.0, 1.0, 1.0]
w1 [2.0, 2.0, 2.0, 2.0]
w2 [3.0, 3.0, 3.0, 3.0]
w3 [4.0, 4.0, 4.0, 4.0]l1 input x w1 [2.0, 2.0, 2.0, 2.0]
l2 l1 w2 [5.0, 5.0, 5.0, 5.0]
l3 l1 x w3 [8.0, 8.0, 8.0, 8.0]
l4 l2 x l3 [40.0, 40.0, 40.0, 40.0]
loss mean(l4) 40.0首先 loss14∑i03l4iloss\frac{1}{4}\sum_{i0}^3l_4^iloss41∑i03l4i , 所以 losslossloss 对 l4il_4^il4i 的偏导分别为 ∂loss∂l4i14\frac{\partial loss}{\partial l_4^i}\frac{1}{4}∂l4i∂loss41 ;
接着 ∂l4∂l3l2[5.0,5.0,5.0,5.0]\frac{\partial l_4}{\partial l_3}l_2[5.0,5.0,5.0,5.0]∂l3∂l4l2[5.0,5.0,5.0,5.0] , 同时 ∂l4∂l2l3[8.0,8.0,8.0,8.0]\frac{\partial l_4}{\partial l_2}l_3[8.0,8.0,8.0,8.0]∂l2∂l4l3[8.0,8.0,8.0,8.0] ;
现在看 l3l_3l3 对它的两个变量的偏导
∂l3∂l1w3[4.0,4.0,4.0,4.0]\frac{\partial l_3}{\partial l_1}w3[4.0,4.0,4.0,4.0]∂l1∂l3w3[4.0,4.0,4.0,4.0]∂l3∂w3l1[2.0,2.0,2.0,2.0]\frac{\partial l_3}{\partial w_3}l1[2.0,2.0,2.0,2.0]∂w3∂l3l1[2.0,2.0,2.0,2.0]
因此 ∂loss∂w3∂loss∂l4∂l4∂l3∂l3∂w3[2.5,2.5,2.5,2.5]\frac{\partial loss}{\partial w_3}\frac{\partial loss}{\partial{l_4}}\frac{\partial{l_4}}{\partial{l_3}}\frac{\partial{l_3}}{\partial w_3}[2.5,2.5,2.5,2.5]∂w3∂loss∂l4∂loss∂l3∂l4∂w3∂l3[2.5,2.5,2.5,2.5] , 其和为 10 ;
同理再看一下求 w2w_2w2 导数的过程 ∂loss∂w2∂loss∂l4∂l4∂l2∂l2∂w3[2.0,2.0,2.0,2.0]\frac{\partial loss}{\partial w_2}\frac{\partial loss}{\partial{l_4}}\frac{\partial{l_4}}{\partial{l_2}}\frac{\partial{l_2}}{\partial w_3}[2.0,2.0,2.0,2.0]∂w2∂loss∂l4∂loss∂l2∂l4∂w3∂l2[2.0,2.0,2.0,2.0] 其和为 8。
其他的导数计算基本上都类似因为过程太多这里就不全写出来了如果有兴趣的话大家不妨自己继续算一下。 接下来我们继续运行代码并检查一下结果和自己算的是否一致
loss.backward()print(w1.grad, w2.grad, w3.grad)
# tensor(28.) tensor(8.) tensor(10.)
print(l1.grad, l2.grad, l3.grad, l4.grad, loss.grad)
# None None None None None首先我们需要注意一下的是在之前写程序的时候我们给定的 w 们都是一个常数利用了广播的机制实现和常数和矩阵的加法乘法比如 w2 l1实际上我们的程序会自动把 w2 扩展成 [[3.0, 3.0], [3.0, 3.0]]和 l1 的形状一样之后再进行加法计算计算的导数结果实际上为 [[2.0, 2.0], [2.0, 2.0]]为了对应常数输入所以最后 w2 的梯度返回为矩阵之和 8 。
另外还有一个问题注意到 l1l2l3以及其他的部分的求导结果都为空。这验证了我们之前提到的叶子结点的概念对于非叶子几点不会保留其梯度值如果一定要保留需要设置 retain_graphTrue。
torch.autogradgrad与backward
自动微分机制是深度学习框架的核心对于 Pytorch 也不例外。 [Pytorch autograd官方文档][https://pytorch.org/docs/stable/autograd.html#]指出Pytorch 中有两种方式可以实现反向传播求导分别是 torch.auograd.grad 和 torch.autograd.backward 。 在我们日常搭建训练脚本的过程中最常见的是 loss.backward() 。其实这是与 torch.autograd.backward(loss) 是等价的即上述后一种方式。 两种方式的区别是前者是返回参数的梯度值列表而后者是直接修改各个 tensor 的 grad 属性。
接口定义
torch.autograd.backward
torch.autograd.backward(tensors, grad_tensorsNone, retain_graphNone, create_graphFalse, grad_variablesNone)tensor用于计算梯度的tensor。前面提到过以下两种方式是等价的torch.autograd.backward(z) z.backward()grad_tensors在计算矩阵的梯度时会用到。也是一个tensorshape一般需要和前面的 tensor 保持一致。retain_graph通常在调用一次 grad/backward 后Pytorch会自动把计算图销毁所以要想对某个变量重复调用 backward则需要将该参数设置为 Truecreate_graph当设置为 True 的时候可以用来计算更高阶的梯度grad_variables这个官方说法是 ‘grad_variables’ is deprecated. Use ‘grad_tensors’ instead.也就是说这个参数后面版本中应该会丢弃直接使用 grad_tensors 就好了。
torch.autograd.grad
torch.autograd.grad(outputs, inputs, grad_outputsNone, retain_graphNone, create_graphFalse, only_inputsTrue, allow_unusedFalse)outputs结果节点通常是损失值inputs需要求梯度的叶子节点通常是模型参数grad_outputs类似于 backward 方法中的 grad_tensorsretain_graph同上create_graph同上only_inputs默认为 True。如果为 True, 则只会返回指定 input 的梯度值。 若为 False则会计算所有叶子节点的梯度并且将计算得到的梯度累加到各自的grad属性上去。allow_unused默认为 False 即必须要指定input如果没有指定的话则报错。
例子
还是通过一个例子来看
import torch
import torch.nn as nnclass MyModel(nn.Module):def __init__(self):super().__init__()self.conv1 nn.Conv2d(in_channels2, out_channels2, kernel_size1, padding0, biasFalse)self.conv2 nn.Conv2d(in_channels2, out_channels1, kernel_size1, padding0, biasFalse)def forward(self, z):return self.conv2(self.conv1(z))c 2
h 5
w 5
lr 0.01
inputs torch.arange(0, c * h * w).float().view(1, c, h, w)
model MyModel()
outputs model(inputs)loss outputs.sum()model.zero_grad()
grad torch.autograd.grad(loss, model.parameters(), retain_graphTrue)
# grad torch.autograd.grad(loss, model.parameters())
# 注意这里需要 retain_grad True否则会报错
# RuntimeError: Trying to backward through the graph a second time (or directly access saved tensors after they have already been freed). Saved intermediate values of the graph are freed when you call .backward() or autograd.grad(). Specify retain_graphTrue if you need to backward through the graph a second time or if you need to access saved tensors after calling backward.
loss.backward()for i, (name, param) in enumerate(model.named_parameters()):print(******************)print(name)print(grad using loss.backward: , param.grad.data)print(grad using autograd.grad: , grad[i])print(******************)# 更新参数# 相当于 optimizer.step()# theta_1 theta_0 - lr * gradparam.data.sub_(lr * param.grad.data)# 或者# param.data.sub_(lr * grad[i])我们定义了一个简单的两层卷积模型然后分别用 grad 和 backward 的方式来计算它们的梯度并打印出来比较一下发现是完全一致的。
如果想要根据梯度更新参数的话也可以在拿到梯度之后直接按照梯度下降的公式手动进行更新 θ1θ0−α∇θ0\theta_1\theta_0-\alpha \nabla\theta_0 θ1θ0−α∇θ0 这一步就相当于执行了 optimizer.step() 它会使用封装好的优化器进行更新。
求高阶导
如何求高阶导比如求二阶导 无非就是 grad_x 再对 x 求梯度
x torch.tensor(2.).requires_grad_()
y torch.tensor(3.).requires_grad_()z x * x * ygrad_x torch.autograd.grad(outputsz, inputsx, retain_graphTrue)
grad_xx torch.autograd.grad(outputsgrad_x, inputsx)print(grad_xx[0])
# 报错RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn报错了虽然 retain_graphTrue 保留了计算图和中间变量梯度 但没有保存 grad_x 的运算方式需要使用 create_graphTrue 在保留原图的基础上再建立额外的求导计算图也就是会把 ∂z∂y2xy\frac{\partial{z}}{\partial{y}}2xy∂y∂z2xy 这样的运算存下来。
一阶二阶导我们可以分别用 autograd.grad 或者 backward 来做即我们有四种排列组合都是可以的
# autograd.grad() autograd.grad()
x torch.tensor(2.).requires_grad_()
y torch.tensor(3.).requires_grad_()z x * x * ygrad_x torch.autograd.grad(outputsz, inputsx, create_graphTrue)
grad_xx torch.autograd.grad(outputsgrad_x, inputsx)print(grad_xx[0])
# 输出tensor(6.)grad_xx 这里也可以直接用 backward相当于直接从 ∂z∂y2xy\frac{\partial{z}}{\partial{y}}2xy∂y∂z2xy 开始回传
# autograd.grad() backward()
x torch.tensor(2.).requires_grad_()
y torch.tensor(3.).requires_grad_()z x * x * ygrad torch.autograd.grad(outputsz, inputsx, create_graphTrue)
grad[0].backward()print(x.grad)
# 输出tensor(6.)也可以先用 backward 然后对 x.grad 这个一阶导继续求导
# backward() autograd.grad()
x torch.tensor(2.).requires_grad_()
y torch.tensor(3.).requires_grad_()z x * x * yz.backward(create_graphTrue)
grad_xx torch.autograd.grad(outputsx.grad, inputsx)print(grad_xx[0])
# 输出tensor(6.)那是不是也可以直接用两次 backward 呢第二次直接 x.grad 从开始回传我们试一下
# backward() backward()
x torch.tensor(2.).requires_grad_()
y torch.tensor(3.).requires_grad_()z x * x * yz.backward(create_graphTrue) # x.grad 12
x.grad.backward()print(x.grad)
# 输出tensor(18., grad_fnCopyBackwards)发现了问题结果不是 6而是18发现第一次回传时输出 x 梯度是12。这是因为 Pytorch 使用 backward 时默认会累加梯度需要手动把前一次的梯度清零
x torch.tensor(2.).requires_grad_()
y torch.tensor(3.).requires_grad_()z x * x * yz.backward(create_graphTrue)
x.grad.data.zero_()
x.grad.backward()print(x.grad)
# 输出tensor(6., grad_fnCopyBackwards)对输出矩阵自动微分
到此为止我们都是对标量进行自动微分当我们试图对向量或者矩阵进行梯度反传时会怎么样呢
import torch
x torch.tensor([1., 2.]).requires_grad_()
y x * xy.backward()
print(x.grad)
# 报错RuntimeError: grad can be implicitly created only for scalar outputs报错了只有对标量输出才能隐式地求梯度。即因为只能标量对标量标量对向量求梯度 x 可以是标量或者向量但 y 只能是标量所以只需要先将 y 转变为标量对分别求导没影响的就是求和。比如下面这样
import torch
x torch.tensor([1., 2.]).requires_grad_()
y x * xy y.sum() # 求和得到标量
y.backward()
print(x.grad)
# 输出tensor([2., 4.])此时x[x1,y1]x[x_1,y_1]x[x1,y1]y[x12,x22]y[x_1^2,x_2^2]y[x12,x22] y′y.sum()x12x22yy.sum()x_1^2x_2^2y′y.sum()x12x22 很显然求梯度有 ∂y′∂x12x12∂y′∂x22x24\frac{\partial y}{\partial x_1}2x_12\ \ \ \ \ \ \ \ \ \ \frac{\partial y}{\partial x_2}2x_24 ∂x1∂y′2x12 ∂x2∂y′2x24 与程序输出相同。
为什么必须是标量呢我们先写出当输出是一个向量 y[y1,y2]y[y_1,y_2]y[y1,y2] 时的雅克比矩阵 J[∂y∂x1,∂y∂x2][∂y1∂x1∂y1∂x2∂y2∂x1∂y2∂x2]{J}[\frac{\partial y}{\partial x_1},\frac{\partial y}{\partial x_2}]\begin{bmatrix}{\frac{\partial y_1}{\partial x_1}}{\frac{\partial y_1}{\partial x_2}}\\{\frac{\partial y_2}{\partial x_1}}{\frac{\partial y_2}{\partial x_2}}\end{bmatrix} J[∂x1∂y,∂x2∂y][∂x1∂y1∂x1∂y2∂x2∂y1∂x2∂y2] 而我们想要的是 [∂y1∂x1,∂y2∂x2][\frac{\partial y_1}{\partial x_1},\frac{\partial y_2}{\partial x_2}][∂x1∂y1,∂x2∂y2] 从矩阵计算的角度来看是不是只要对雅克比矩阵左乘个 [1,1][1,1][1,1] 就可以得到我们想要的了 [∂y1∂x1,∂y2∂x2][1,1]⋅J[\frac{\partial y_1}{\partial x_1},\frac{\partial y_2}{\partial x_2}][1,1]\cdot J [∂x1∂y1,∂x2∂y2][1,1]⋅J 这就是不使用 y.sum() 的另一种方式通过 backward 接口的 grad_tensors 参数上面介绍过
x torch.tensor([1., 2.]).requires_grad_()
y x * xy.backward(torch.ones_like(y))
print(x.grad)
# 输出tensor([2., 4.])如果要使用 torch.autograd.grad 对应的接口形参是 grad_outputs
x torch.tensor([1., 2.]).requires_grad_()
y x * xgrad_x torch.autograd.grad(outputsy, inputsx, grad_outputstorch.ones_like(y))
# 或者
# grad_x torch.autograd.grad(outputsy.sum(), inputsx)
print(grad_x[0])
# 输出tensor([2., 4.])实际上grad_tensors 的作用其实可以简单地理解成在求梯度时的权重因为可能不同值的梯度对结果影响程度不同所以 Pytorch 弄了个这种接口而没有固定为全是1。引用自知乎上的一个评论如果从最后一个节点(总loss)来backward这种实现(torch.sum(y*w))的意义就具体化为 multiple loss term with difference weights 这种需求了吧。
关于对输出矩阵求微分更详细的可参考PyTorch 的 backward 为什么有一个 grad_variables 参数
几个细节
zero_grad
在写训练脚本时我们通常在每次 backward 反传之前都要进行一步 optimizer.zero_gard() 这一步是做什么的呢实际上就如同名字显示那样本步的目的就是将目前叶子结点中上一步的梯度 grad 清零然后再进行反传计算本 batch 的梯度。
那能不能不每次都清零梯度呢实际上是可以的这可以作为一种变相增大 batch size 的 trick。如果我们的机器每个 batch 最多只能 64 个样本那我们设置每步都计算梯度并累计到叶子结点的 grad 属性中但是每隔一步才进行一次参数更新和梯度清零这就相当于 batch_size 成了 128。但这也会出现一些问题比如 BN 怎么办这在知乎上也有一些问题有讨论过感兴趣可以查一下。
model.zero_grad()还是optimizer.zero_grad()?
看代码时有时候会看到 model.zero_grad() 有时又会看到 optimizer.zero_grad() 到底有什么区别呢
我们知道模型就是一堆参数按照特定的运算结构组织起来我们在构建 optimizer 时会把优化器要优化的参数传递给它比如
optimizer Adam(model.parameters(), lrlr)常规情况下传入优化器的只有 model.parameters()但是并不总是如此。有时候整个模型要优化的不只有模型本身的参数还可能有一些自定义的 parameters比如
pref_vec torch.nn.Parameter(torch.randn(1, 512))
optimizer Adam([{params: model.parameters()}, {params: pref_vec}], lrlr)在这种情况下 model.parameters() 与 pref_vec 是一起更新的都有 optimizer 这个优化器来更新。
指出这一点之后大家应该就明白 model.zero_grad() 和 optimizer.zero_grad() 的区别了。它们指向的待更新参数叶子结点不一定是一样的。一般情况下优化器待更新参数就是模型参数二者是等价的但是如果待更新的参数除了模型的参数之外还有一些自定义的参数就必须用 optimizer.zero_grad() 了。
detach
detach 会切断当前张量与计算图之间的联系不会再往后计算梯度。
假设有模型 A 和模型 B我们需要将 A 的输出作为 B 的输入但训练时我们只训练模型B那么可以这样做
input_B output_A.detach()inplace
inplace 操作顾名思义就是直接在原地改变张量的值而不是计算后得到一个新的张量并返回。
注意叶子节点不可执行 in-place 操作因为反向传播时会访问原来的对象地址。
关于 inplace 操作也有很多坑经常见到的一个报错是
RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation: ...关于 inplace 操作的问题在 PyTorch 的 Autograd 中有详细的讨论。
Ref
Pytorch autograd官方文档一文解释PyTorch求导相关 (backward, autograd.grad)MAML-Pytorch机器学习系统:设计与实现 计算图浅谈 PyTorch 中的 tensor 及使用PyTorch 的 Autograd一文解释PyTorch求导相关 (backward, autograd.grad)PyTorch 的 backward 为什么有一个 grad_variables 参数Pytorch autograd,backward详解
