detach()、data、with no_grad()、requires_grad之间关系

比眉伴天荒 2023-02-27 13:55 6阅读 0赞

### detach 、data、with no\_grad、requires\_grad之间关系 ###

*   *   *  一. requires\_grad属性
         *   *  1. requires\_grad 的作用探讨
             *  2. 结论：
         *  二. detach()方法
         *  三. with torch.no\_grad()
         *  四. data属性
         *  五. 总结

最近在学习pytorch的时候，遇到了几个新知识点，弄得我头大（本身头大，但更大 ==!）

*  requires\_grad属性
 *  detach()
 *  with no\_grad()方法
 *  data属性

一直搞不明白这些东西到底有什么神奇的用法还有它们之间的关系；作为`为什么大王`我必须需总结一下，不然难受啊。

### 一. requires\_grad属性 ###

`requires_grad`：

> [官网说：][Link 1]If autograd should record operations on the returned tensor. Default: False.

是否追踪在张量上计算的所有操作，默认值为False  
什么意思？直接上代码测试一下吧！

#### 1. requires\_grad 的作用探讨 ####

# 测试一些什么都不做，查看计算的梯度
    import torch
    
    x = torch.tensor([1.0, 2.0])
    y1 = x ** 2
    y2 = y1 * 2
    y3 = y1 + y2
    
    print(y1, y1.requires_grad)
    print(y2, y2.requires_grad)
    print(y3, y3.requires_grad)
    
    # 为什么backward里面需要加一个torch.ones(y3.shape)？
    # 这是另外一个需要讨论的问题了可以在留言区一起讨论
    y3.backward(torch.ones(y3.shape))  # y1.backward() y2.backward()
    print(x.grad)

# 结果：
    tensor([1., 4.]) False
    tensor([2., 8.]) False
    tensor([ 3., 12.]) False
    RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn

--------------------

X的requires\_grad设置为True之后则如下：

# 设置好requires_grad的值为True
    import torch
    
    x = torch.tensor([1.0, 2.0], requires_grad=True)
    y1 = x ** 2
    y2 = y1 * 2
    y3 = y1 + y2
    
    print(y1, y1.requires_grad)
    print(y2, y2.requires_grad)
    print(y3, y3.requires_grad)
    
    y3.backward(torch.ones(y3.shape))  # y1.backward() y2.backward()
    print(x.grad)
    
    """
    结果：
    tensor([1., 4.], grad_fn=<PowBackward0>) True
    tensor([2., 8.], grad_fn=<MulBackward0>) True
    tensor([ 3., 12.], grad_fn=<AddBackward0>) True
    tensor([ 6., 12.])
    """

此时的y1、y2、y3输出都多了一个属性参数值：  
例如：y1的grad\_fn = `<PowBackward0>`,就表示y1的上一次计算操作为pow，即指数运算  
再回到我们的y1 = x \*\* 2 ,果然，正是如此。

#### 2. 结论： ####

"""
    1. 当grad_fn设置为Fasle或者默认时：计算梯度会出现如下错误
    RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn
    因为并没有追踪到任何计算历史，所以就不存在梯度的计算了
    
    2. 因此在最开始定义x张量的时候，就应当设置好是否计算追踪历史计算记录
    """

### 二. detach()方法 ###

`detach():`

> [官网又说：][Link 1]Returns a new Tensor, detached from the current graph.The result will never require gradient.

就是返回了一个新的张量，该张量与当前计算图完全分离。且该张量的计算将不会记录到梯度当中。  
上代码看看那啥意思吧！

# 设置好requires_grad的值为True
    import torch
    
    x = torch.tensor([1.0, 2.0], requires_grad=True)
    y1 = x ** 2
    y2 = y1.detach() * 2     # 注意这里在计算y2的时候对y1进行了detach()
    y3 = y1 + y2
    
    print(y1, y1.requires_grad)
    print(y2, y2.requires_grad)
    print(y3, y3.requires_grad)
    
    
    y3.backward(torch.ones(y3.shape))  # y1.backward() y2.backward()
    print(x.grad)

结果：

tensor([1., 4.], grad_fn=<PowBackward0>) True
    tensor([2., 8.]) False
    tensor([ 3., 12.], grad_fn=<AddBackward0>) True
    tensor([2., 4.])
    
    
    """
    	根据结果可知y2所计算出来的张量，grad_fn属性没有被输出（其实为None），即不具有追踪能力了
    	而y1和y3都仍然显示出各自上一次的计算操作，但是最终计算出的x的梯度发生了变化
    """

对比一下使用detach()前后的梯度值`tensor([ 6., 12.])`和`tensor([2., 4.])`  
（1）`tensor([ 6., 12.])`

y3 = y2 + y1,根据 y2 = y1*2, 而y1 = x ** 2
    所以y3 = 3x**2,    y3对xi的偏导则为6xi
    针对x = [1, 2]
    所以，对应的梯度（偏导）则为：[6, 12]

（2）`tensor([ 2., 4.])`

y3 = y2 + y1,因为y2是根据y1.detach()得到的；
    根据定义，所以计算梯度的时候不考虑y2,但是实际计算y3的值还是按原公式
    因此计算梯度时。y3 = y1 + (y2不考虑)，所以y3 = x ** 2
    y3对xi的偏导则为2xi
    针对x = [1, 2]
    所以，对应的梯度（偏导）则为：[2, 4]

总结一下detach()吧：  
当我们在计算到某一步时，不需要在记录某一个张量的时，就可以使用detach()将其从追踪记录当中分离出来，这样一来该张量对应计算产生的梯度就不会被考虑了。

### 三. with torch.no\_grad() ###

`torch.no_grad():`

> [官方还说：][Link 2]Disabling gradient calculation is useful for inference, when you are sure that you will not call :meth:`Tensor.backward()`. It will reduce memory consumption for computations that would otherwise have `requires_grad=True`.

先理解为也是类似取消梯度计算的一种方式，可以减少内存消耗，还是看代码结果吧！

# 设置好requires_grad的值为True
    import torch
    
    x = torch.tensor([1.0, 2.0], requires_grad=True)
    y1 = x ** 2
    
    with torch.no_grad():  # 这里使用了no_grad()包裹不需要被追踪的计算过程
        y2 = y1 * 2
        
    y3 = y1 + y2
    
    print(y1, y1.requires_grad)
    print(y2, y2.requires_grad)
    print(y3, y3.requires_grad)
    
    y3.backward(torch.ones(y3.shape))  # y1.backward() y2.backward()
    print(x.grad)

计算结果：

tensor([1., 4.], grad_fn=<PowBackward0>) True
    tensor([2., 8.]) False
    tensor([ 3., 12.], grad_fn=<AddBackward0>) True
    tensor([2., 4.])
    
    """
    	结果和detach()方法一致，就不在分析了
    """

可想而知，实际上`torch.no_grad()`功能和`detach()`方法作用是一致的。  
有差区别？  
`detach()`是考虑将单个张量从追踪记录当中脱离出来；  
而`torch.no_grad()`是一个warper，可以将多个计算步骤的张量计算脱离出去，本质上没啥区别。

### 四. data属性 ###

写到这了，突然忘了一个重要的事情，detach()和data属性都是由tensor调用；  
那么它们返回值存在什么关系呢？

# 设置好requires_grad的值为True
    import torch
    
    x = torch.tensor([1.0, 2.0], requires_grad=True)
    y1 = x ** 2
    
    print(y1)
    print(y1.data)
    print(y1.detach())
    print(id(y1), id(y1.data), id(y1.detach()))
    print(id(y1.storage()), id(y1.data.storage()), id(y1.detach().storage()))
    
    """
    	tensor([1., 4.], grad_fn=<PowBackward0>)
    	tensor([1., 4.])
    	tensor([1., 4.])
    	3092644292392 3092631327272 3092631327272
    	3092650494536 3092650494536 3092650494536
    """

可以很清楚的看到:

*  `y1.detach()`、`y1.data`、`y1`指向的内存单元是一样的
 *  `y1.detach()`和`y1.data`返回的对象都是一样的

表示我又乱了！

另外，终于找到一个比较好的解释了：[来自stackoverflow的解释][stackoverflow]1

![在这里插入图片描述][20200718191058962.png_x-oss-process_image]  
**简单翻译一下：**`data`方法是`Variable`的一个属性，而`Variable`在0.4版本以前，好像是封装Tensor所有操作，并提供额外属性的一个类（具体我也没了解）。  
在Pytorch 0.4版本以后，`Variable`和`Tensor`进行了彻底的合并，因此`.data`也随着`Variable`一同消失了（尽管`Variable`仍然存在，并且向后兼容，但是已经被弃用了）。

`.data` 是从 `Variable` 中获取底层 Tensor 的主要方式。 合并后，y = x.data得到的y是一个与x**共享内存**的Tensor，（前面也证实了内存地址不相同）并且 requires\_grad = False，它与 x 的计算历史无关。

当然，在某些情况下 .data 可能不安全。 对 x.data 的任何更改都不会被 autograd 跟踪，如果在反向过程中需要 x，那么计算出的梯度将不正确。另一种更安全的方法是使用 x.detach（），它将返回一个共享内存地址的 Tensor（requires\_grad = False），但如果在反向过程中需要 x，那么 autograd 将会**提示**你已经修改了该张量。

测试代码2如下：

# tensor.data
    >>> a = torch.tensor([1, 2, 3.], requires_grad =True)
    >>> out = a.sigmoid()
    >>> c = out.data
    >>> c.zero_()
    tensor([ 0., 0., 0.])
    
    >>> out       #  因为内存共享，所以out的数值被c.zero_()修改
    tensor([ 0., 0., 0.])
    
    >>> out.sum().backward()  #  反向传播
    >>> a.grad                
    tensor([ 0., 0., 0.])

>>> a = torch.tensor([1,2,3.], requires_grad =True)
    >>> out = a.sigmoid()
    >>> c = out.detach()
    >>> c.zero_()
    tensor([ 0., 0., 0.])
    
    >>> out                   #  out的值被c.zero_()修改 !!
    tensor([ 0., 0., 0.])
    
    >>> out.sum().backward()  #  需要原来out得值，但是已经被c.zero_()覆盖了，结果报错
    one of the variables needed for gradient computation has been modified by an inplace operation:
     [torch.FloatTensor [3]], which is output 0 of SigmoidBackward, 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).

### 五. 总结 ###

最后还是要总结一下：

*  `requires_grad`：在最开始创建Tensor时候可以设置的属性，用于表明是否追踪当前Tensor的计算操作。后面也可以通过requires\_grad\_（）方法设置该参数，但是只有叶子节点才可以设置该参数。
 *  `detach()`方法：则是用于将某一个Tensor从计算图中分离出来。返回的是一个内存共享的Tensor，一变都变。
 *  `torch.no_grad()`：对所有包裹的计算操作进行分离。  
    但是`torch.no_grad()`将会使用更少的内存，因为从包裹的开始，就表明不需要计算梯度了，因此就不需要保存中间结果。3
 *  `.data`则是以前Pytorch中`Variable`的一个属性，返回的是一个共享内存的Tensor，一变都变，只是现在很少使用了。

可能有些地方理解不到位，希望各位指出相互探讨。  
最后留一个问题：  
为什么y.backward()的时候，**有时候**需要传递一个同等维度的Tensor呢？  
欢迎大家一起来总结啊！！！

--------------------

1.  [Is .data still useful in pytorch?][stackoverflow] ↩︎
2.  [PyTorch中 tensor.detach() 和 tensor.data 的区别][PyTorch_ tensor.detach_ _ tensor.data] ↩︎
3.  [Difference between “detach()” and “with torch.nograd()” in PyTorch?][Difference between _detach_ and _with torch.nograd_ in PyTorch] ↩︎

[Link 1]: https://pytorch.org/docs/stable/tensors.html#torch.Tensor.requires_grad_
[Link 2]: https://pytorch.org/docs/stable/_modules/torch/autograd/grad_mode.html#no_grad
[stackoverflow]: https://stackoverflow.com/questions/51743214/is-data-still-useful-in-pytorch
[20200718191058962.png_x-oss-process_image]: /images/20230209/ea18fe0409c54842a56e65ed99bafe5f.png
[PyTorch_ tensor.detach_ _ tensor.data]: https://blog.csdn.net/DreamHome_S/article/details/85259533
[Difference between _detach_ and _with torch.nograd_ in PyTorch]: https://stackoverflow.com/questions/56816241/difference-between-detach-and-with-torch-nograd-in-pytorch