PyTorch 学习笔记（六）：PyTorch hook 和关于 PyTorch backward 过程的理解 call

最新推荐文章于 2024-12-11 22:52:42 发布
转载 最新推荐文章于 2024-12-11 22:52:42 发布 · 549 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://www.pytorchtutorial.com/pytorch-note6-pytorch-hook-and-pytorch-backward/

本文深入探讨了PyTorch中的Hook机制，包括Variable和nn.Module的Hook注册与使用，以及它们在前向和反向传播过程中的作用。通过具体代码示例，详细解析了Hook如何帮助我们理解和修改梯度计算。
部署运行你感兴趣的模型镜像
您的位置 首页 PyTorch 学习笔记系列

PyTorch 学习笔记（六）：PyTorch hook 和关于 PyTorch backward 过程的理解

发布: 2017年8月4日 7,195阅读 0评论
PyTorch入门实战教程

在看pytorch官方文档的时候，发现在nn.Module部分和Variable部分均有hook的身影。感到很神奇，因为在使用tensorflow的时候没有碰到过这个词。所以打算一探究竟。

Variable 的 hook

register_hook(hook)

注册一个backward钩子。

每次gradients被计算的时候，这个hook都被调用。hook应该拥有以下签名：

hook不应该修改它的输入，但是它可以返回一个替代当前梯度的新梯度。

这个函数返回一个 句柄(handle)。它有一个方法 handle.remove()，可以用这个方法将hook从module移除。

例子：

输出：

nn.Module的hook

register_forward_hook(hook)

在module上注册一个forward hook。

这里要注意的是，hook 只能注册到 Module 上，即，仅仅是简单的 op 包装的 Module，而不是我们继承 Module时写的那个类，我们继承 Module写的类叫做 Container。

每次调用forward()计算输出的时候，这个hook就会被调用。它应该拥有以下签名：

hook不应该修改 input和output的值。 这个函数返回一个 句柄(handle)。它有一个方法 handle.remove()，可以用这个方法将hook从module移除。

看这个解释可能有点蒙逼，但是如果要看一下nn.Module的源码怎么使用hook的话，那就乌云尽散了。

先看 register_forward_hook

result = self.forward(input, **kwargs)
for hook in self._forward_hooks.values():
#将注册的hook拿出来用
hook_result = hook(self, input, result)
…
return result

1
2
3
4
5
6
7
def call ( self , input , kwargs ) :
   result = self . forward ( input , * kwargs )
   for hook in self . _forward_hooks . values ( ) :
       #将注册的hook拿出来用
       hook_result = hook ( self , input , result )
   . . .
   return result

可以看到，当我们执行model(x)的时候，底层干了以下几件事：

  • 调用 forward 方法计算结果
  • 判断有没有注册 forward_hook，有的话，就将 forward 的输入及结果作为hook的实参。然后让hook自己干一些不可告人的事情。

看到这，我们就明白hook签名的意思了，还有为什么hook不能修改input的output的原因。

小例子：

def for_hook(module, input, output):
print(module)
for val in input:
print(“input val:”,val)
for out_val in output:
print(“output val:”, out_val)

class Model(nn.Module):
def init(self):
super(Model, self).init()
def forward(self, x):

    return x+1

model = Model()
x = Variable(torch.FloatTensor([1]), requires_grad=True)
handle = model.register_forward_hook(for_hook)
print(model(x))
handle.remove()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import torch
from torch import nn
import torch . functional as F
from torch . autograd import Variable
 
def for_hook ( module , input , output ) :
     print ( module )
     for val in input :
         print ( “input val:” , val )
     for out_val in output :
         print ( “output val:” , out_val )
 
class Model ( nn . Module ) :
     def init ( self ) :
         super ( Model , self ) . init ( )
     def forward ( self , x ) :
 
         return x + 1
 
model = Model ( )
x = Variable ( torch . FloatTensor ( [ 1 ] ) , requires_grad = True )
handle = model . register_forward_hook ( for_hook )
print ( model ( x ) )
handle . remove ( )

register_backward_hook

在module上注册一个bachward hook。此方法目前只能用在Module上，不能用在Container上，当Module的forward函数中只有一个Function的时候，称为Module，如果Module包含其它Module，称之为Container。

每次计算module的inputs的梯度的时候，这个hook会被调用。hook应该拥有下面的signature。

如果module有多个输入输出的话，那么grad_input grad_output将会是个tuple。

hook不应该修改它的arguments，但是它可以选择性的返回关于输入的梯度，这个返回的梯度在后续的计算中会替代grad_input。

这个函数返回一个句柄(handle)。它有一个方法 handle.remove()，可以用这个方法将hook从module移除。

从上边描述来看，backward hook似乎可以帮助我们处理一下计算完的梯度。看下面nn.Module中register_backward_hook方法的实现，和register_forward_hook方法的实现几乎一样，都是用字典把注册的hook保存起来。

先看个例子来看一下hook的参数代表了什么：

x=Variable(torch.FloatTensor([[1, 2, 3]]),requires_grad=True)
mod=Linear(3, 1, bias=False)
mod.register_backward_hook(bh) # 在这里给module注册了backward hook

out=mod(x)
out.register_hook(lambda grad: 0.1grad) #在这里给variable注册了 hook
out.backward()
print([’’]20)
print(“x.grad”, x.grad)
print(mod.weight.grad)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import torch
from torch . autograd import Variable
from torch . nn import Parameter
import torch . nn as nn
import math
def bh ( m , gi , go ) :
     print ( “Grad Input” )
     print ( gi )
     print ( “Grad Output” )
     print ( go )
     return gi [ 0 ] 0 , gi [ 1 ] 0
class Linear ( nn . Module ) :
     def init ( self , in_features , out_features , bias = True ) :
         super ( Linear , self ) . init ( )
         self . in_features = in_features
         self . out_features = out_features
         self . weight = Parameter ( torch . Tensor ( out_features , in_features ) )
         if bias :
             self . bias = Parameter ( torch . Tensor ( out_features ) )
         else :
             self . register_parameter ( ‘bias’ , None )
         self . reset_parameters ( )
 
     def reset_parameters ( self ) :
         stdv = 1. / math . sqrt ( self . weight . size ( 1 ) )
         self . weight . data . uniform_ ( - stdv , stdv )
         if self . bias is not None :
             self . bias . data . uniform_ ( - stdv , stdv )
 
     def forward ( self , input ) :
         if self . bias is None :
             return self . _backend . Linear ( ) ( input , self . weight )
         else :
             return self . _backend . Linear ( ) ( input , self . weight , self . bias )
 
x = Variable ( torch . FloatTensor ( [ [ 1 , 2 , 3 ] ] ) , requires_grad = True )
mod = Linear ( 3 , 1 , bias = False )
mod . register_backward_hook ( bh ) # 在这里给module注册了backward hook
 
out = mod ( x )
out . register_hook ( lambda grad : 0.1 grad ) #在这里给variable注册了 hook
out . backward ( )
print ( [ ’’ ] 20 )
print ( “x.grad” , x . grad )
print ( mod . weight . grad )

输出：

Variable containing:
0 0 0
[torch.FloatTensor of size 1x3]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Grad Input
( Variable containing :
1.00000e - 02
   5.1902 - 2.3778 - 4.4071
[ torch . FloatTensor of size 1x3 ]
, Variable containing :
0.1000    0.2000    0.3000
[ torch . FloatTensor of size 1x3 ]
)
Grad Output
( Variable containing :
0.1000
[ torch . FloatTensor of size 1x1 ]
, )
[ ’’ , ‘’ , '’ , ‘’ , '’ , ‘’ , '’ , ‘’ , '’ , ‘’ , '’ , ‘’ , '’ , ‘’ , '’ , ‘’ , '’ , ‘’ , '’ , '’ ]
x . grad Variable containing :
0 - 0 - 0
[ torch . FloatTensor of size 1x3 ]
 
Variable containing :
0    0    0
[ torch . FloatTensor of size 1x3 ]

可以看出，grad_in保存的是，此模块Function方法的输入的值的梯度。grad_out保存的是，此模块forward方法返回值的梯度。我们不能在grad_in上直接修改，但是我们可以返回一个新的new_grad_in作为Function方法inputs的梯度。

上述代码对variable和module同时注册了backward hook，这里要注意的是，无论是module hook还是variable hook，最终还是注册到Function上的。这点通过查看Varible的register_hook源码和Module的__call__源码得知。

Module的register_backward_hook的行为在未来的几个版本可能会改变

BP过程中Function中的动作可能是这样的：

关于pytorch run_backward()的可能实现猜测为：

中间Variable的梯度在BP的过程中是保存到GradBuffer中的(C++源码中可以看到), BP完会释放. 如果retain_grads=True的话,就不会被释放。

文章来源：Keith

49赞
标签:backward hook
PyTorch入门实战教程

相关文章

发表评论 取消回复

电子邮件地址不会被公开。 必填项已用标注

在这里插入图片描述

您可能感兴趣的与本文相关的镜像

PyTorch 2.5

PyTorch 2.5

PyTorch
Cuda

PyTorch 是一个开源的 Python 机器学习库，基于 Torch 库，底层由 C++ 实现，应用于人工智能领域，如计算机视觉和自然语言处理

深度学习PyTorch中nn.Module与Hook技巧详解：构建与优化神经网络模型
05-18
阅读建议：此资源详细讲解了PyTorch中nn.Module和Hook技巧的核心概念及实际应用，建议读者在学习过程中结合代码示例进行实践，逐步理解并掌握这些关键技术，以提升自身在深度学习领域的开发能力。
PyTorch学习—16.PyTorch中hook函数
柳杰的博客
08-17 997
文章目录一、Hook函数概念二、四种Hook函数介绍1. Tensor.register_hook2. Module.register_forward_hook3.Module.register_forward_pre_hook4. Module.register_backward_hook 一、Hook函数概念   Hook函数机制：不改变主体，实现额外功能，像一个挂件一样将功能挂到函数主体上。Hook函数与PyTorch中的动态图运算机制有关，因为在动态图计算，在运算结束后，中间变量是会被释放掉的，例如
Pytorch中的hook函数
斯人若彩虹，遇上方知有！
08-31 3502
一、Hook函数概念 Hook 是 PyTorch 中一个十分有用的特性。利用它，我们可以不必改变网络输入输出的结构，方便地获取、改变网络中间层变量的值和梯度。这个功能被广泛用于可视化神经网络中间层的 feature、gradient，从而诊断神经网络中可能出现的问题，分析网络有效性。 Hook函数机制：不改变主体，实现额外的功能，像一个挂件一样； 参考:知乎大佬的讲解 主要分为： Hook for Tensors：针对 Tensor 的 hook Hook for Modules：针对例如..
PyTorch的hook函数（register_hook、register_forward_hook、register_backward_hook、register_forward_pre_hook）
Le0v1n 的博客
10-16 5592
1. register_hook 2. register_forward_hook 3. register_backward_hook 4. register_forward_pre_hook
【Pytorch】backward与backward_hook
a_piece_of_ppx的博客
11-09 2226
pytorch中的backward和backward_hook用法，大部分为转载
PyTorch-hook
ZerinHwang
10-16 769
钩子编程（hooking），也称作“挂钩”，是计算机程序设计术语，指通过拦截软件模块间的函数调用、消息传递、事件传递来修改或扩展操作系统、应用程序或其他软件组件的行为的各种技术。处理被拦截的函数调用、事件、消息的代码，被称为钩子（hook）。 Hook 是 PyTorch 中一个十分有用的特性。利用它，我们可以不必改变网络输入输出的结构，方便地获取、改变网络中间层变量的值和梯度。这个功能被广泛用...
pytorch学习笔记五：模型的创建
Dear_learner的博客
02-14 1370
在上一节中整理了数据模块的知识点，在本节中主要围绕如何用pytorch构建一个模型来展开，最后用pytorch实现Alexnet网络结构的搭建。 下面基于上面的框架来探索每一个模块的实现细节。 一、模型的创建 上面是LetNet的网络图，由边和节点组成，节点表示输入的数据大小，而边就是数据之间的运算。从上面的LetNet的网络中可以看出，网络接受一个输入，然后经过运算得到一个输出，在网络结构的内部，又分为多个子网络层进行拼接组成，这些子网络层之间的拼接 配合，最终得到我们想要的输出。 所以通过上面的分析
pytorch学习笔记十五：Hook函数与CAM可视化
Dear_learner的博客
04-10 3248
一、hook函数
系统学习Pytorch笔记八：Tensorboard可视化与Hook机制
Miracle8070
04-27 3897
Pytorch官方英文文档：https://pytorch.org/docs/stable/torch.html? Pytorch中文文档：https://pytorch-cn.readthedocs.io/zh/latest/ 1. 写在前面 疫情在家的这段时间，想系统的学习一遍Pytorch基础知识，因为我发现虽然直接Pytorch实战上手比较快，但是关于一些内部的原理知识其实并不是太懂，这样...
【pytorch】register_hook、register_forward_hook 和 register_backward_hook
最新发布
rocking_struggling的博客
12-11 1502
使用 register_hook 修改张量的梯度，比如实现梯度剪裁或自定义优化策略。
Pytorch中的hook
Ken的博客
06-16 574
由于pytorch的中间变量在完成计算后就会被释放，如果想要获取中间的信息，就需要使用hook相关函数。首先搭建一个深度学习网络 指定网络中的conv2层添加hook，hook单独写一个函数来实现相关功能 register_hook，对象为Variable对象 register_backward_hook，对应反向传播，用来导出指定子模块输入输出张量的梯度，但只可修改输入张量的梯度，输出张量梯度不可修改 通过remove函数取消hook...
pytorch中的hook
qq_38992914的博客
11-18 477
pytorch中的hook 为了方便，我都是用单输入单输出的结构来测试的。 pytorch提供三种hook，一种用来看tensor的grad，一种用来看一个层的输入输出，还有一种用来看一个层输入输出的梯度。 所有的hook函数，都需要定义一个function供它使用。 tensor.register_hook(function)是最好理解的，能够获取的就是这个tensor的梯度。它需要的funct...
Pytorch中的Hook（常用于网络特征可视化等）
lyz21的博客
02-01 2562
Pytorch中的Hook 使用Hook函数获取网络中间变量. Hook函数机制是不改变函数主体，实现额外功能，像一个挂件，挂钩。正是因为PyTorch计算图动态图的机制，所以才会有Hook函数。在动态图机制的运算，当运算结束后，一些中间变量就会被释放掉，例如，特征图，非leaf节点的梯度。但是有时候，我们需要这些中间变量，所以就出现了Hook函数。 torch提供了四种hook方法，分别用于 获取各个参数的梯度值。tensor.register_hook(hook) 获取各个层前向传播的输入输出值。Mo
Pytorch的hook函数
莫比的博客
03-28 1957
勾子函数可以在不修改源代码的情况下实现功能的注入实现过程需要重写对应的勾子函数，需要注意执行的顺序以及参数的含义：在forward函数之后执行，输入参数为input和output，其中input是forward函数之前的输入，output是forwad函数之后的输入。这个勾子函数一般用于可视化特征图：在执行backward之时执行，backward到哪一个层就执行哪一个层的勾子函数，需要注意的是，输入参数分别为当前层的梯度输入和梯度输出，也即grad_input。
pytorch学习笔记（七）：pytorch hook 和 关于pytorch backward过程的理解
热门推荐
Keith
04-05 2万+
水平有限，如有错误，请不吝指正，谢谢！pytorch 的 hook 机制在看pytorch官方文档的时候，发现在nn.Module部分和Variable部分均有hook的身影。感到很神奇，因为在使用tensorflow的时候没有碰到过这个词。所以打算一探究竟。nn.Module的hookregister_forward_hook(hook)在module上注册一个forward hook。 每次调
钩子：pytorch hook
yjinyyzyq的博客
06-10 337
钩子：pytorch hook https://www.cnblogs.com/hellcat/p/8512090.html
pytorch中的hook机制
qq_42138662的博客
01-08 1820
一.hook的作用 由于pytorch中,训练产生的中间变量会在训练结束后被释放掉,因此想要将这些变量保存下来,需要用到hook函数,hook可以理解为一个外挂函数,挂载在原有函数上. 二.针对tensor的hook 这个用于保存反向传播时候的梯度 flag = 1 if flag: #定义网络 w = torch.tensor([1.], requires_grad=True) x = torch.tensor([2.], requires_grad=True) a = t
PyTorch中hook（钩子）的使用
weixin_42756682的博客
11-21 3355
参考链接1 参考链接2
pytorch中hook的使用
kking_edc的博客
10-12 716
在pytorch中，可以利用Hook获取、改变网络中间某一层变量的值和梯度，从而便捷地分析网络，而不用专门改变网络结构。 一、torch.Tensor中的hook 在使用pytorch时，只有叶节点（即直接指定数值的节点，而不是由其他变量计算得到的节点，比如网络输入）的梯度会保留，其余中间节点梯度在反向传播完成后就会自动释放以节省显存。 比如： import torch x=torch.Tensor([1,2]).requires_grad_(True) y=torch.Tensor([3,4]).req
PyTorch常用函数手册：14章164页完整笔记
《Pytorch常用函数手册（合计14章节笔记共164页）》是一份系统、全面且极具实用价值的深度学习技术文档，涵盖了使用PyTorch进行神经网络建模与训练过程中几乎所有的核心知识点。该手册以14个章节的形式组织内容，总...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值