具有价值的做pc端网站,特色专业建设验收网站,个人主页模板图片导航栏,株洲电商网站建设PyTorch 的 Autograd 转自#xff1a;PyTorch 的 Autograd PyTorch 作为一个深度学习平台#xff0c;在深度学习任务中比 NumPy 这个科学计算库强在哪里呢#xff1f;我觉得一是 PyTorch 提供了自动求导机制#xff0c;二是对 GPU 的支持。由此可见#xff0c;自动求导 (a…PyTorch 的 Autograd 转自PyTorch 的 Autograd PyTorch 作为一个深度学习平台在深度学习任务中比 NumPy 这个科学计算库强在哪里呢我觉得一是 PyTorch 提供了自动求导机制二是对 GPU 的支持。由此可见自动求导 (autograd) 是 PyTorch乃至其他大部分深度学习框架中的重要组成部分。
了解自动求导背后的原理和规则对我们写出一个更干净整洁甚至更高效的 PyTorch 代码是十分重要的。但是现在已经有了很多封装好的 API我们在写一个自己的网络的时候可能几乎都不用去注意求导这些问题因为这些 API 已经在私底下处理好了这些事情。现在我们往往只需要搭建个想要的模型处理好数据的载入调用现成的 optimizer 和 loss function直接开始训练就好了。仔细一想好像连需要设置 requires_gradTrue 的地方好像都没有。有人可能会问那我们去了解自动求导还有什么用啊
原因有很多可以帮我们更深入地了解 PyTorch 这些宽泛的理由我就不说了我举一个例子当我们想使用一个 PyTorch 默认中并没有的 loss function 的时候比如目标检测模型 YOLO 的 loss我们可能就得自己去实现。如果我们不熟悉基本的 PyTorch 求导机制的话对于实现过程中比如 tensor 的 in-place 操作等很容易出错导致需要话很长时间去 debug有的时候即使定位到了错误的位置也不知道如何去修改。相反如果我们理清楚了背后的原理我们就能很快地修改这些错误甚至根本不会去犯这些错误。鉴于现在官方支持的 loss function 并不多而且深度学习领域日新月异很多新的效果很好的 loss function 层出不穷如果要用的话可能需要我们自己来实现。基于这个原因我们了解一下自动求导机制还是很有必要的。
本文所有代码例子都基于 Python3 和 PyTorch 1.1, 也就是不会涉及 0.4 版本以前的 Variable 这个数据结构。在文章中我们不会去分析一些非常底层的代码而是通过一系列实例来理解自动求导机制。在举例的过程中我尽量保持场景的一致性不用每个例子都需要重新了解假定的变量。另外本文篇幅比较长。如果发现文章中有错误或者没有讲清楚的地方欢迎大家在评论区指正和讨论。
目录
计算图一个具体的例子叶子张量inplace 操作动态图静态图 计算图
首先我们先简单地介绍一下什么是计算图Computational Graphs以方便后边的讲解。假设我们有一个复杂的神经网络模型我们把它想象成一个错综复杂的管道结构不同的管道之间通过节点连接起来我们有一个注水口一个出水口。我们在入口注入数据的之后数据就沿着设定好的管道路线缓缓流动到出水口这时候我们就完成了一次正向传播。想象一下输入的 tensor 数据在管道中缓缓流动的场景这就是为什么 TensorFlow 叫 TensorFlow 的原因emmm好像走错片场了不过计算图在 PyTorch 中也是类似的。至于这两个非常有代表性的深度学习框架在计算图上有什么区别我们稍后再谈。
计算图通常包含两种元素一个是 tensor另一个是 Function。张量 tensor 不必多说但是大家可能对 Function 比较陌生。这里 Function 指的是在计算图中某个节点node所进行的运算比如加减乘除卷积等等之类的Function 内部有 forward() 和 backward() 两个方法分别应用于正向、反向传播。
a torch.tensor(2.0, requires_gradTrue)
b a.exp()
print(b)
# tensor(7.3891, grad_fnExpBackward)在我们做正向传播的过程中除了执行 forward() 操作之外还会同时会为反向传播做一些准备为反向计算图添加 Function 节点。在上边这个例子中变量 b 在反向传播中所需要进行的操作是 ExpBackward 。
一个具体的例子
了解了基础知识之后现在我们来看一个具体的计算例子并画出它的正向和反向计算图。假如我们需要计算这么一个模型
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如果对这个规则不熟悉欢迎参考 我上一篇博文的第一部分 或者直接查看 官方 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 。另外还有一个问题虽然 w 开头的那些和我们的计算结果相符但是为什么 l1l2l3甚至其他的部分的求导结果都为空呢想要解答这个问题我们得明白什么是叶子张量。
叶子张量
对于任意一个张量来说我们可以用 tensor.is_leaf 来判断它是否是叶子张量leaf tensor。在反向传播过程中只有 is_leafTrue 的时候需要求导的张量的导数结果才会被最后保留下来。
对于 requires_gradFalse 的 tensor 来说我们约定俗成地把它们归为叶子张量。但其实无论如何划分都没有影响因为张量的 is_leaf 属性只有在需要求导的时候才有意义。
我们真正需要注意的是当 requires_gradTrue 的时候如何判断是否是叶子张量当这个 tensor 是用户创建的时候它是一个叶子节点当这个 tensor 是由其他运算操作产生的时候它就不是一个叶子节点。我们来看个例子
a torch.ones([2, 2], requires_gradTrue)
print(a.is_leaf)
# Trueb a 2
print(b.is_leaf)
# False
# 因为 b 不是用户创建的是通过计算生成的这时有同学可能会问了为什么要搞出这么个叶子张量的概念出来原因是为了节省内存或显存。我们来想一下那些非叶子结点是通过用户所定义的叶子节点的一系列运算生成的也就是这些非叶子节点都是中间变量一般情况下用户不会去使用这些中间变量的导数所以为了节省内存它们在用完之后就被释放了。
我们回头看一下之前的反向传播计算图在图中的叶子节点我用绿色标出了。可以看出来被叫做叶子可能是因为游离在主干之外没有子节点因为它们都是被用户创建的不是通过其他节点生成。对于叶子节点来说它们的 grad_fn 属性都为空而对于非叶子结点来说因为它们是通过一些操作生成的所以它们的 grad_fn 不为空。
我们有办法保留中间变量的导数吗当然有通过使用 tensor.retain_grad() 就可以
# 和前边一样
# ...
loss l4.mean()l1.retain_grad()
l4.retain_grad()
loss.retain_grad()loss.backward()print(loss.grad)
# tensor(1.)
print(l4.grad)
# tensor([[0.2500, 0.2500],
# [0.2500, 0.2500]])
print(l1.grad)
# tensor([[7., 7.],
# [7., 7.]])如果我们只是想进行 debug只需要输出中间变量的导数信息而不需要保存它们我们还可以使用 tensor.register_hook例子如下
# 和前边一样
# ...
loss l4.mean()l1.register_hook(lambda grad: print(l1 grad: , grad))
l4.register_hook(lambda grad: print(l4 grad: , grad))
loss.register_hook(lambda grad: print(loss grad: , grad))loss.backward()# loss grad: tensor(1.)
# l4 grad: tensor([[0.2500, 0.2500],
# [0.2500, 0.2500]])
# l1 grad: tensor([[7., 7.],
# [7., 7.]])print(loss.grad)
# None
# loss 的 grad 在 print 完之后就被清除掉了这个函数的功能远远不止打印导数信息用以 debug但是一般很少用所以这里就不扩展了更多请参考知乎提问 pytorch中的钩子Hook有何作用
到此为止我们已经讨论完了这个实例中的正向传播和反向传播的有关内容了。回过头来看 input 其实很像神经网络输入的图像w1, w2, w3 则类似卷积核的参数而 l1, l2, l3, l4 可以表示4个卷积层输出如果我们把节点上的加法乘法换成卷积操作的话。实际上这个简单的模型很像我们平时的神经网络的简化版通过这个例子相信大家多少也能对神经网络的正向和反向传播过程有个大致的了解了吧。
inplace 操作
现在我们来看一下本篇的重点inplace operation。可以说我们求导时候大部分的 bug都出在使用了 inplace 操作上。现在我们以 PyTorch 不同的报错信息作为驱动来讲一讲 inplace 操作吧。第一个报错信息
RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation: balabala...不少人可能会感到很熟悉没错我就是其中之一。之前写代码的时候竟经常报这个错原因是对 inplace 操作不了解。要搞清楚为什么会报错我们先来了解一下什么是 inplace 操作inplace 指的是在不更改变量的内存地址的情况下直接修改变量的值。我们来看两种情况大家觉得这两种情况哪个是 inplace 操作哪个不是或者两个都是 inplace
# 情景 1
a a.exp()# 情景 2
a[0] 10答案是情景1不是 inplace类似 Python 中的 ii1, 而情景2是 inplace 操作类似 i1。依稀记得当时做机器学习的大作业很多人都被其中一个 i1 和 ii1 问题给坑了好长时间。那我们来实际测试一下
# 我们要用到 id() 这个函数其返回值是对象的内存地址
# 情景 1
a torch.tensor([3.0, 1.0])
print(id(a)) # 2112716404344
a a.exp()
print(id(a)) # 2112715008904
# 在这个过程中 a.exp() 生成了一个新的对象然后再让 a
# 指向它的地址所以这不是个 inplace 操作# 情景 2
a torch.tensor([3.0, 1.0])
print(id(a)) # 2112716403840
a[0] 10
print(id(a), a) # 2112716403840 tensor([10., 1.])
# inplace 操作内存地址没变PyTorch 是怎么检测 tensor 发生了 inplace 操作呢答案是通过 tensor._version 来检测的。我们还是来看个例子
a torch.tensor([1.0, 3.0], requires_gradTrue)
b a 2
print(b._version) # 0loss (b * b).mean()
b[0] 1000.0
print(b._version) # 1loss.backward()
# RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation ...每次 tensor 在进行 inplace 操作时变量 _version 就会加1其初始值为0。在正向传播过程中求导系统记录的 b 的 version 是0但是在进行反向传播的过程中求导系统发现 b 的 version 变成1了所以就会报错了。但是还有一种特殊情况不会报错就是反向传播求导的时候如果没用到 b 的值比如 yx1 y 关于 x 的导数是1和 x 无关自然就不会去对比 b 前后的 version 了所以不会报错。
上边我们所说的情况是针对非叶子节点的对于 requires_gradTrue 的叶子节点来说要求更加严格了甚至在叶子节点被使用之前修改它的值都不行。我们来看一个报错信息
RuntimeError: leaf variable has been moved into the graph interior这个意思通俗一点说就是你的一顿 inplace 操作把一个叶子节点变成了非叶子节点了。我们知道非叶子节点的导数在默认情况下是不会被保存的这样就会出问题了。举个小例子
a torch.tensor([10., 5., 2., 3.], requires_gradTrue)
print(a, a.is_leaf)
# tensor([10., 5., 2., 3.], requires_gradTrue) Truea[:] 0
print(a, a.is_leaf)
# tensor([0., 0., 0., 0.], grad_fnCopySlices) Falseloss (a*a).mean()
loss.backward()
# RuntimeError: leaf variable has been moved into the graph interior我们看到在进行对 a 的重新 inplace 赋值之后表示了 a 是通过 copy operation 生成的grad_fn 都有了所以自然而然不是叶子节点了。本来是该有导数值保留的变量现在成了导数会被自动释放的中间变量了所以 PyTorch 就给你报错了。还有另外一种情况
a torch.tensor([10., 5., 2., 3.], requires_gradTrue)
a.add_(10.) # 或者 a 10.
# RuntimeError: a leaf Variable that requires grad has been used in an in-place operation.这个更厉害了不等到你调用 backward只要你对需要求导的叶子张量使用了这些操作马上就会报错。那是不是需要求导的叶子节点一旦被初始化赋值之后就不能修改它们的值了呢我们如果在某种情况下需要重新对叶子变量赋值该怎么办呢有办法
# 方法一
a torch.tensor([10., 5., 2., 3.], requires_gradTrue)
print(a, a.is_leaf, id(a))
# tensor([10., 5., 2., 3.], requires_gradTrue) True 2501274822696a.data.fill_(10.)
# 或者 a.detach().fill_(10.)
print(a, a.is_leaf, id(a))
# tensor([10., 10., 10., 10.], requires_gradTrue) True 2501274822696loss (a*a).mean()
loss.backward()
print(a.grad)
# tensor([5., 5., 5., 5.])# 方法二
a torch.tensor([10., 5., 2., 3.], requires_gradTrue)
print(a, a.is_leaf)
# tensor([10., 5., 2., 3.], requires_gradTrue) Truewith torch.no_grad():a[:] 10.
print(a, a.is_leaf)
# tensor([10., 10., 10., 10.], requires_gradTrue) Trueloss (a*a).mean()
loss.backward()
print(a.grad)
# tensor([5., 5., 5., 5.])修改的方法有很多种核心就是修改那个和变量共享内存但 requires_gradFalse 的版本的值比如通过 tensor.data 或者 tensor.detach()至于这二者更详细的介绍与比较欢迎参照我 上一篇文章的第四部分。我们需要注意的是要在变量被使用之前修改不然等计算完之后再修改还会造成求导上的问题会报错的。 为什么 PyTorch 的求导不支持绝大部分 inplace 操作呢从上边我们也看出来了因为真的很 tricky。比如有的时候在一个变量已经参与了正向传播的计算之后它的值被修改了在做反向传播的时候如果还需要这个变量的值的话我们肯定不能用那个后来修改的值吧但没修改之前的原始值已经被释放掉了我们怎么办一种可行的办法就是我们在 Function 做 forward 的时候每次都开辟一片空间储存当时输入变量的值这样无论之后它们怎么修改都不会影响了反正我们有备份在存着。但这样有什么问题这样会导致内存或显存使用量大大增加。因为我们不确定哪个变量可能之后会做 inplace 操作所以我们每个变量在做完 forward 之后都要储存一个备份成本太高了。除此之外inplace operation 还可能造成很多其他求导上的问题。
总之我们在实际写代码的过程中没有必须要用 inplace operation 的情况而且支持它会带来很大的性能上的牺牲所以 PyTorch 不推荐使用 inplace 操作当求导过程中发现有 inplace 操作影响求导正确性的时候会采用报错的方式提醒。但这句话反过来说就是因为只要有 inplace 操作不当就会报错所以如果我们在程序中使用了 inplace 操作却没报错那么说明我们最后求导的结果是正确的没问题的。这就是我们常听见的没报错就没有问题。
动态图静态图
可能大家都听说过PyTorch 使用的是动态图Dynamic Computational Graphs的方式而 TensorFlow 使用的是静态图Static Computational Graphs。所以二者究竟有什么区别呢我们本节来就来讨论这个事情。
所谓动态图就是每次当我们搭建完一个计算图然后在反向传播结束之后整个计算图就在内存中被释放了。如果想再次使用的话必须从头再搭一遍参见下边这个例子。而以 TensorFlow 为代表的静态图每次都先设计好计算图需要的时候实例化这个图然后送入各种输入重复使用只有当会话结束的时候创建的图才会被释放不知道这里我对 tf.Session 的理解对不对如果有错误希望大佬们能指正一下就像我们之前举的那个水管的例子一样设计好水管布局之后需要用的时候就开始搭搭好了就往入口加水什么时候不需要了再把管道都给拆了。
# 这是一个关于 PyTorch 是动态图的例子
a torch.tensor([3.0, 1.0], requires_gradTrue)
b a * a
loss b.mean()loss.backward() # 正常
loss.backward() # RuntimeError# 第二次从头再来一遍
a torch.tensor([3.0, 1.0], requires_gradTrue)
b a * a
loss b.mean()
loss.backward() # 正常从描述中我们可以看到理论上来说静态图在效率上比动态图要高。因为首先静态图只用构建一次然后之后重复使用就可以了其次静态图因为是固定不需要改变的所以在设计完了计算图之后可以进一步的优化比如可以将用户原本定义的 Conv 层和 ReLU 层合并成 ConvReLU 层提高效率。
但是深度学习框架的速度不仅仅取决于图的类型还很其他很多因素比如底层代码质量所使用的底层 BLAS 库等等等都有关。从实际测试结果来说至少在主流的模型的训练时间上PyTorch 有着至少不逊于静态图框架 CaffeTensorFlow 的表现。具体对比数据可以参考 这个 GitHub 仓库。
大家不要急着纠正我我知道我现在就说当然在 9102 年的今天动态图和静态图直接的界限已经开始慢慢模糊。PyTorch 模型转成 Caffe 模型越来越方便而 TensorFlow 也加入了一些动态图机制。
除了动态图之外PyTorch 还有一个特性叫 eager execution。意思就是当遇到 tensor 计算的时候马上就回去执行计算也就是实际上 PyTorch 根本不会去构建正向计算图而是遇到操作就执行。真正意义上的正向计算图是把所有的操作都添加完构建好了之后再运行神经网络的正向传播。
正是因为 PyTorch 的两大特性动态图和 eager execution所以它用起来才这么顺手简直就和写 Python 程序一样舒服debug 也非常方便。除此之外我们从之前的描述也可以看出PyTorch 十分注重占用内存或显存大小没有用的空间释放很及时可以很有效地利用有限的内存。
总结
本篇文章主要讨论了 PyTorch 的 Autograd 机制和使用 inplace 操作不当可能会导致的各种报错。在实际写代码的过程中涉及需要求导的部分不建议大家使用 inplace 操作。除此之外我们还比较了动态图和静态图框架PyTorch 作为动态图框架的代表之一对初学者非常友好而且运行速度上不逊于静态图框架再加上现在通过 ONNX 转换为其他框架的模型用以部署也越来越方便我觉得是一个非常称手的深度学习工具。
最后感谢阅读希望大家读完之后有所收获。
参考资料
PyTorch Docs: AUTOGRAD MECHANICSYouTube 英文视频PyTorch Autograd Explained - In-depth TutorialInplace operation in pytorch关于 pytorch inplace operation, 需要知道的几件事cs231n 2019 lecture 6: Hardware and SoftwareAutomatic differentiation in PyTorchUnderstanding how Automatic Differentiation works
