Pytorch 网络冻结的三种方法区别：detach、requires_grad、with_no_grad

detach方法就是返回了一个新的张量，该张量与当前计算图完全分离，且该张量的计算将不会记录到梯度当中。

import torchx = torch.tensor([1.0, 2.0], requires_grad=True)
y = torch.tensor([3.0, 4.0], requires_grad=True)
z = torch.tensor([3.0, 2.0], requires_grad=True)
x = x * 2
z1 = z.detach()
x1 = x.detach() 
y1 = 2.0 * x1 + 2.0 * y + 3 * z1
y1.backward(torch.tensor([1.0, 1.0])) 
print(x.requires_grad)
print(x.grad)
print(y.requires_grad)
print(y.grad)
print(z.requires_grad)
print(z.grad)
print(z1.requires_grad)
print(z1.grad)"""
结果：
True
None
True
tensor([2., 2.])
True
None
False
None
C:\Users\26973\AppData\Local\Temp\ipykernel_37516\3652236761.py:12: UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad attribute won't be populated during autograd.backward(). If you indeed want the gradient for a non-leaf Tensor, use .retain_grad() on the non-leaf Tensor. If you access the non-leaf Tensor by mistake, make sure you access the leaf Tensor instead. See github.com/pytorch/pytorch/pull/30531 for more informations.print(x.grad)
"""

从上面实验可以看到，使用detach()方法后，可以截断反向传播的梯度流，其作用有点类似于将requires_grad属性置为False的情况。

与requires_grad_()将requires_grad属性置为False不同的是 detach()函数会返回一个新的Tensor对象b ， 并且新Tensor是与当前的计算图分离的，其requires_grad属性为False，反向传播时不会计算其梯度。 b与a共享数据的存储空间，二者指向同一块内存。

而requires_grad_()函数会改变Tensor的requires_grad属性并返回Tensor，修改requires_grad的操作是原位操作(in place)。其默认参数为requires_grad=True。requires_grad=True时，自动求导会记录对Tensor的操作，requires_grad_()的主要用途是告诉自动求导开始记录对Tensor的操作。

关于detach()返回的张量与原张量共享数据的存储空间，二者指向同一块内存可以由以下代码看出：

z1[0] = 5.0
print(z)
print(z1)"""
结果：
tensor([5., 2.], requires_grad=True)
tensor([5., 2.])
"""

当我们修改z1中的数据时，z中的数据也随之修改。

**总结：**当我们在计算到某一步时，不需要在记录某一个张量的梯度时，就可以使用detach()将其从追踪记录当中分离出来，这样一来该张量对应计算产生的梯度就不会被考虑了。比较常见的就是在GAN生成模型中，当训练一次生成器后，再训练判别器时，需要对生成器生成的fake进行损失计算，但是又不希望这部分损失对生成器进行权值的更新，这个时候需要冻结生成器那部分的权值，因此通常将生成器生成的fake张量使用fetch()进行阶段，再输入到判别器进行运算，这样最后使用loss.backward()时仅会对判别器部分的梯度进行计算

import torch
import numpy as npy = torch.tensor([3.0, 4.0], requires_grad=True)
z = torch.tensor([3.0, 2.0], requires_grad=True)
z1 = z.detach()
z2 = z1 + y
y1 = torch.sum(3 * z2)
y1.backward() 
print(z2, z2.requires_grad)
print(y.grad)
print(z2.grad)
print(z1.grad)"""
结果：
tensor([6., 6.], grad_fn=<AddBackward0>) True
tensor([3., 3.])
None
None
"""

这里假设z是生成器生成的图片，z1表示的是使用detch()截断后的张量，y表示的判别器内部的一些运算张量，z2表示经过判别器后的结果，y1假设是计算loss的损失函数，我们可以看到，使用y1.backward() 后，不会对生成器生成的z产生任何的梯度，在优化器优化时自然而然不会对其进行优化。而对于后面的步骤仍然会跟踪记录其所有的计算过程，比如对于z1在判别器中进行运算仍然会记录其过程，并仅会对判别器内部的参数y进行梯度计算，从而进行优化。

（注：这里z2.grad之所以也为None，是因为z2节点不是叶子节点，它是由z1和y进行累加而来的，所以在z2处不会有grad属性，这部分可以看其给出的警告）

UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad attribute won't be populated during autograd.backward(). If you indeed want the gradient for a non-leaf Tensor, use .retain_grad() on the non-leaf Tensor. If you access the non-leaf Tensor by mistake, make sure you access the leaf Tensor instead. See github.com/pytorch/pytorch/pull/30531 for more informations.

torch.no_grad()是一个上下文管理器，用来禁止梯度的计算，通常用来网络推断中，它可以减少计算内存的使用量。

# 设置好requires_grad的值为True
import torchx = torch.tensor([1.0, 2.0], requires_grad=True)
y1 = x ** 2with torch.no_grad():  # 这里使用了no_grad()包裹不需要被追踪的计算过程y2 = y1 * 2y3 = x ** 5y4 = y1 + y2 + y3print(y1, y1.requires_grad)
print(y2, y2.requires_grad)
print(y3, y3.requires_grad)
print(y4, y4.requires_grad)y4.backward(torch.ones(y4.shape))  # y1.backward() y2.backward()
print(x.grad)"""
结果：
tensor([1., 4.], grad_fn=<PowBackward0>) True
tensor([2., 8.]) False
tensor([ 1., 32.]) False
tensor([ 4., 44.], grad_fn=<AddBackward0>) True
tensor([2., 4.])
"""

可以看出，其实使用with torch.no_grad()这个后，被其包裹的所有运算都是不计算梯度的，其效果与detach()类似，所以使用下列代码的运行结果是一样的：

# 设置好requires_grad的值为True
import torchx = torch.tensor([1.0, 2.0], requires_grad=True)
y1 = x ** 2# with torch.no_grad():  # 这里使用了no_grad()包裹不需要被追踪的计算过程
y2 = y1 * 2
y3 = x ** 5
y2 = y2.detach()
y3 = y3.detach()y4 = y1 + y2 + y3print(y1, y1.requires_grad)
print(y2, y2.requires_grad)
print(y3, y3.requires_grad)
print(y4, y4.requires_grad)y4.backward(torch.ones(y4.shape))  # y1.backward() y2.backward()
print(x.grad)
"""
结果：
tensor([1., 4.], grad_fn=<PowBackward0>) True
tensor([2., 8.]) False
tensor([ 1., 32.]) False
tensor([ 4., 44.], grad_fn=<AddBackward0>) True
tensor([2., 4.])
"""

detach()是考虑将单个张量从追踪记录当中脱离出来；
而torch.no_grad()是一个warper，可以将多个计算步骤的张量计算脱离出去，本质上没啥区别。

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