pytorch 中 .detach() .detach_() 和 .data用于切断反向传播的实现

pytorch 中 .detach() .detach_() 和 .data用于切断反向传播的实现

当我们再训练网络的时候可能希望保持一部分的网络参数不变,只对其中一部分的参数进行调整;或者只训练部分分支网络,并不让其梯度对主网络的梯度造成影响,这时候我们就需要使用detach()函数来切断一些分支的反向传播。

1. detach()

返回一个新的Variable,从当前计算图中分离下来的,但是仍指向原变量的存放位置,不同之处只是requires_grad为false,得到的这个Variable永远不需要计算其梯度,不具有grad。即使之后重新将它的requires_grad置为true,它也不会具有梯度grad。这样我们就会继续使用这个新的Variable进行计算,后面当我们进行反向传播时,到该调用detach()的Variable就会停止,不能再继续向前进行传播。

源码:

def detach(self):

    """Returns a new Variable, detached from the current graph.

    Result will never require gradient. If the input is volatile, the output

    will be volatile too.

    .. note::

     Returned Variable uses the same data tensor, as the original one, and

     in-place modifications on either of them will be seen, and may trigger

     errors in correctness checks.

    """

    result = NoGrad()(self) # this is needed, because it merges version counters

    result._grad_fn = None

     return result

可见函数进行的操作有:

  • 将grad_fn设置为None
  • 将Variable的requires_grad设置为False

注意:

返回的Variable和原始的Variable公用同一个data tensor。in-place函数修改会在两个Variable上同时体现(因为它们共享data tensor),当要对其调用backward()时可能会导致错误。

举例:

import torch

a = torch.tensor([1, 2, 3.], requires_grad=True)
print(a.grad)
out = a.sigmoid()
out.sum().backward()
print(a.grad)



Output:
--------------------------------------------------------
None
tensor([0.1966, 0.1050, 0.0452])
--------------------------------------------------------

当使用detach()但是没有进行更改时,并不会影响backward():

import torch

a = torch.tensor([1, 2, 3.], requires_grad=True)
print(a.grad)
out = a.sigmoid()
print(out)

#添加detach(),c的requires_grad为False
c = out.detach()
print(c)

#这时候没有对c进行更改,所以并不会影响backward()
out.sum().backward()
print(a.grad)


Output:
------------------------------------------------------------------
None
tensor([0.7311, 0.8808, 0.9526], grad_fn=<SigmoidBackward>)
tensor([0.7311, 0.8808, 0.9526])
tensor([0.1966, 0.1050, 0.0452])
------------------------------------------------------------------

可见c,out之间的区别是c是没有梯度的,out是有梯度的。

如果这里使用的是c进行sum()操作并进行backward(),则会报错:

import torch

a = torch.tensor([1, 2, 3.], requires_grad=True)
print(a.grad)
out = a.sigmoid()
print(out)

#添加detach(),c的requires_grad为False
c = out.detach()
print(c)

#使用新生成的Variable进行反向传播
c.sum().backward()
print(a.grad)


Output:
------------------------------------------------------------------
None
tensor([0.7311, 0.8808, 0.9526], grad_fn=<SigmoidBackward>)
tensor([0.7311, 0.8808, 0.9526])
RuntimeError                              Traceback (most recent call last)
---> 13 c.sum().backward()
RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn
------------------------------------------------------------------

为c添加一个requires_grad=True,来继续使用c进行后续的计算,但是c之前的操作的梯度都被消除,a不会具有梯度,也不会被更新。(但似乎这样操作也没啥意义。)

import torch

a = torch.tensor([1, 2, 3.], requires_grad=True)
print(a.grad)
out = a.sigmoid()
print(out)

#添加detach(),c的requires_grad为False
c = out.detach()
print(c)

#为新生成的Variable进行添加允许梯度下降,进行反向传播
c.requires_grad = True
c.sum().backward()
print(a.grad)



Output:
------------------------------------------------------------------
None
tensor([0.7311, 0.8808, 0.9526], grad_fn=<SigmoidBackward>)
tensor([0.7311, 0.8808, 0.9526])
RuntimeError                              Traceback (most recent call last)
---> 13 c.sum().backward()
RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn
------------------------------------------------------------------

如果此时对c进行了更改,这个更改会被autograd追踪,在对out.sum()进行backward()时也会报错,因为此时的值进行backward()得到的梯度是错误的:

import torch

a = torch.tensor([1, 2, 3.], requires_grad=True)
print(a.grad)
out = a.sigmoid()
print(out)

#添加detach(),c的requires_grad为False
c = out.detach()
print(c)

c.zero_() #使用in place函数对其进行修改, 会发现c的修改同时会影响out的值
print(c)
print(out)

#这时候对c进行更改,所以会影响backward(),这时候就不能进行backward(),会报错
out.sum().backward()
print(a.grad)

Output:
------------------------------------------------------------------
None
tensor([0.7311, 0.8808, 0.9526], grad_fn=<SigmoidBackward0>)
tensor([0.7311, 0.8808, 0.9526])
tensor([0., 0., 0.])
tensor([0., 0., 0.], grad_fn=<SigmoidBackward0>)
RuntimeError                              Traceback (most recent call last)
---> 18 out.sum().backward()
RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation: [torch.FloatTensor [3]], which is output 0 of SigmoidBackward0, is at version 1; expected version 0 instead. Hint: enable anomaly detection to find the operation that failed to compute its gradient, with torch.autograd.set_detect_anomaly(True).
------------------------------------------------------------------

detach可以用来控制网络参数更新

如果A网络的输出被喂给B网络作为输入, 如果我们希望在梯度反传的时候只更新B中参数的值,而不更新A中的参数值,这时候就可以使用detach()。

a = A(input)
a = a.deatch() # 或者a.detach_()进行in_place操作
out = B(a)
loss = criterion(out, labels)
loss.backward()

但是,如果希望修改A的参数, 而不希望修改B的参数, 那么就需要手动将B中参数的requires_grad属性设置为False,因为B在A之后如果给B进行detach,会使得A、B参数都不更新。

for param in B.parameters():
    param.requires_grad = False

还有一点需要注意的是Tensor.detach()和Tensor.data()的区别

Tensor.data()和Tensor.detach()一样, 都会返回一个新的Tensor, 这个Tensor和原来的Tensor共享内存空间,一个改变,另一个也会随着改变,且都会设置新的Tensor的requires_grad属性为False。这两个方法只取出原来Tensor的tensor数据, 丢弃了grad、grad_fn等额外的信息。区别在于Tensor.data()方法不能被autograd追踪到,如果你修改了Tensor.data()返回的新Tensor,原来的Tensor也会改变, 但是这时候的微分并没有被追踪到,那么当你执行loss.backward()的时候并不会报错,但是求的梯度就是错误的!因此, 如果你使用了Tensor.data()方法, 那么切记一定不要随便修改返回的新Tensor的值。如果你使用的是Tensor.detach()方法, 当你修改他的返回值并进行求导操作,会报错。 因此,Tensor.detach()是安全的。

detach可以用来导出存储embedding

2. data

如果上面的操作使用的是.data,效果会不同:

这里的不同在于.data的修改不会被autograd追踪,这样当进行backward()时它不会报错,回得到一个错误的backward值

import torch

a = torch.tensor([1, 2, 3.], requires_grad=True)
print(a.grad)
out = a.sigmoid()
print(out)

c = out.data
print(c)
c.zero_() #使用in place函数对其进行修改


#会发现c的修改同时也会影响out的值
print(c)
print(out)

#这里的不同在于.data的修改不会被autograd追踪,这样当进行backward()时它不会报错,回得到一个错误的backward值
out.sum().backward()
print(a.grad)


Output:
------------------------------------------------------------------
None
tensor([0.7311, 0.8808, 0.9526], grad_fn=<SigmoidBackward0>)
tensor([0.7311, 0.8808, 0.9526])
tensor([0., 0., 0.])
tensor([0., 0., 0.], grad_fn=<SigmoidBackward0>)
tensor([0., 0., 0.])
------------------------------------------------------------------

上面的内容实现的原理是:

In-place 正确性检查

所有的Variable都会记录用在他们身上的 in-place operations。如果pytorch检测到variable在一个Function中已经被保存用来backward,但是之后它又被in-place operations修改。当这种情况发生时,在backward的时候,pytorch就会报错。这种机制保证了,如果你用了in-place operations,但是在backward过程中没有报错,那么梯度的计算就是正确的。

下面结果正确是因为改变的是sum()的结果,中间值a.sigmoid()并没有被影响,所以其对求梯度并没有影响:

import torch


a = torch.tensor([1, 2, 3.], requires_grad=True)
print(a.grad)
out = a.sigmoid().sum() #但是如果sum写在这里,而不是写在backward()前,得到的结果是正确的
print(out)

c = out.data
print(c)
c.zero_() #使用in place函数对其进行修改


#会发现c的修改同时也会影响out的值
print(c)
print(out)

#没有写在这里

out.backward()
print(a.grad)


Output:
------------------------------------------------------------------
None
tensor(2.5644, grad_fn=<SumBackward0>)
tensor(2.5644)
tensor(0.)
tensor(0., grad_fn=<SumBackward0>)
tensor([0.1966, 0.1050, 0.0452])
------------------------------------------------------------------

3. detach_()

将一个Variable从创建它的图中分离,并把它设置成叶子variable

其实就相当于变量之间的关系本来是x -> m -> y,这里的叶子variable是x,但是这个时候对m进行了.detach_()操作,其实就是进行了两个操作:

  • 将m的grad_fn的值设置为None,这样m就不会再与前一个节点x关联,这里的关系就会变成x, m -> y,此时的m就变成了叶子结点
  • 然后会将m的requires_grad设置为False,这样对y进行backward()时就不会求m的梯度

这么一看其实detach()和detach_()很像,两个的区别就是detach_()是对本身的更改,detach()则是生成了一个新的variable

比如x -> m -> y中如果对m进行detach(),后面如果反悔想还是对原来的计算图进行操作还是可以的

但是如果是进行了detach_(),那么原来的计算图也发生了变化,就不能反悔了

参考链接


 本篇
pytorch 中 .detach() .detach_() 和 .data用于切断反向传播的实现 pytorch 中 .detach() .detach_() 和 .data用于切断反向传播的实现
pytorch 中 .detach() .detach_() 和 .data用于切断反向传播的实现当我们再训练网络的时候可能希望保持一部分的网络参数不变,只对其中一部分的参数进行调整;或者只训练部分分支网络,并不让其梯度对主网络的梯度造成影
2022-05-11
下一篇 
KGE-CL/ Contrastive Learning of Knowledge Graph Embeddings 阅读笔记 KGE-CL/ Contrastive Learning of Knowledge Graph Embeddings 阅读笔记
作者在知识图谱嵌入任务中,针对于不同三元组中相关实体和实体-关系对间的语义相似性的问题,提出一个对于知识图谱嵌入简单且高效的对比学习框架,使用该框架作为一个额外的约束项一同训练KGE,这可以使不同三元组中相关实体和实体-关系对间的语义距离变
  目录