Pytorch中反向传播
【深度学习理论】一文搞透 pytorch 中的 tensor、autograd、反向传播和计算图
动态计算图
https://www.cnblogs.com/picassooo/p/13748618.html
https://www.cnblogs.com/picassooo/p/13818952.html
# Pytorch中loss.backward()和torch.autograd.grad的使用和区别
总结：
loss.backward()和torch.autograd.grad区别
相同点：
这两种梯度方法都会在反向传播求导的时候释放计算图，如果需要再次做自动求导，因为计算图已经不再了，就会报错。如果要在反向传播的时候保留计算图，可以设置retain_graph=True。
不同点
- 累加
loss.backward()会将求导结果累加在grad上。这也是为什么我们在训练每个batch的最开始，需要对梯度清零的原因。
torch.autograd.grad不会将求导结果累加在grad上。 - 叶子节点梯度
torch.autograd.grad可以获取非叶子节点的梯度。
loss.backward()后，非叶子节点的导数计算完成之后就会被清空。
计算图保留
import torch
x=torch.tensor(3,dtype=torch.float,requires_grad=True)
y=x*x
z=2*y
z.backward(retain_graph=True)
print(x.grad) #12
z.backward()
print(x.grad) #24
不保留计算图会报错。
同一张计算图计算两次，相当于两次grad相加，以上代码效果等同于
import torch
x=torch.tensor(3,dtype=torch.float,requires_grad=True)
y=x*x
z=2*y
z.backward()
print(x.grad)
x.grad = x.grad *2
print(x.grad)
https://www.cnblogs.com/luckyscarlett/p/10555632.html
import torch
x = torch.randn((1,4),dtype=torch.float32,requires_grad=True)
y = x ** 2
z = y * 4
print(x)
print(y)
print(z)
loss1 = z.mean()
loss2 = z.sum()
print(loss1,loss2)
loss1.backward() # 这个代码执行正常，但是执行完中间变量都free了，所以下一个出现了问题
print(loss1,loss2)
loss2.backward() # 这时会引发错误
计算节点数值保存了，但是计算图x-y-z结构被释放了，而计算loss2的backward仍然试图利用x-y-z的结构，因此会报错。
使用
loss1.backward(retain_graph=True)# 这里参数表明保留backward后的中间参数。
即可
叶子节点
一般地，由用户自己创建的张量为叶子节点。另外，神经网络中各层的权值weight和偏差bias对应的张量也为叶子节点。由叶子节点得到的中间张量为非叶子节点。
Pytorch中的张量有一个is_leaf的属性。若一个张量为叶子节点，则其is_leaf属性就为True，若这个张量为非叶子节点，则其is_leaf属性就为False。
在反向传播中，叶子节点可以理解为不依赖其它张量的张量
requires_grad_()
只有在是叶子节点且require_grad为True的时候，反向计算才会保留计算图。
requires_grad_作用是将Tensor的require_grad属性变为True
应用的情况为手动生成的Tensor，但忘记将该属性变为True
import torch
x=torch.tensor(3.) # 此处须为torch.float类型，如果不是，则需要进行如下的转换
print(x.requires_grad) #False
# 如果在创建张量x时，没有将requires_grad参数设置为True，则可以通过下式进行设定
x.requires_grad_(True)
grad_fn
如果一个张量是通过一些操作从其他张量创建的，那么这个张量将有一个 grad_fn 属性指向执行的函数。但是，对于叶子张量（即那些直接创建的张量，而不是通过计算得到的），它们默认没有 grad_fn
保留非叶子节点梯度
在非叶子节点之后，加上 “非叶子节点.retain_grad() 保留梯度
```python
import torch
x=torch.tensor(3,dtype=torch.float,requires_grad=True)
y=x*x
z=2*y
z.backward()
print(z.grad) # none
修改后代码：
import torch
x=torch.tensor(3,dtype=torch.float,requires_grad=True)
y=x*x
z=2*y
z.retain_grad()
z.backward()
print(z.grad) # 1
计算图可视化
20天吃掉那只Pytorch
from torch import nn
import torch
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.w = nn.Parameter(torch.randn(2,1))
self.b = nn.Parameter(torch.zeros(1,1))
def forward(self, x):
y = x@self.w + self.b
return y
net = Net()
net = Net()
from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter('../data/tensorboard')
writer.add_graph(net,input_to_model = torch.rand(10,2))
writer.close()
detach()和clone()的区别
import torch
# 创建一个张量，并启用梯度追踪
x = torch.randn(3, requires_grad=True)
# 做一些计算
y = 2 * x # y 参与反向传播
# z = y.clone() # 创建 y 的副本，z 会有与 y 相同的计算图
z = y.detach() # 创建 y 的副本，z 会有与 y 相同的计算图
# 计算一个目标函数
loss = sum(5 * x + 10 * z)
# 执行反向传播
loss.backward()
# 打印梯度
print(f"x.grad: {x.grad}")
clone()保存计算图，detach()不保存计算图
clone().detach()和detach()
区别在于是否共享内存空间。修改一个另外的变量也会修改，但是是否有计算图有区别。
import torch
# 创建一个启用了梯度追踪的张量
sub_buffer = torch.ones(3, requires_grad=True)
# 使用 detach() 断开计算图
sub_buffer_detached = sub_buffer.detach()
sub_buffer_clone = sub_buffer.clone().detach()
# 检查原始张量和 detatched 张量的计算图
print(f"sub_buffer requires_grad: {sub_buffer.requires_grad}") # True
print(f"sub_buffer_detached requires_grad: {sub_buffer_detached.requires_grad}") # False
print(f"sub_buffer.grad_fn: {sub_buffer.grad_fn}") # 显示计算图信息
print(f"sub_buffer_detached.grad_fn: {sub_buffer_detached.grad_fn}") # 显示计算图信息
# 修改 detatched 张量的值并查看是否影响原始张量
sub_buffer_detached += 1
print(f"sub_buffer: {sub_buffer}")
print(f"sub_buffer_detached: {sub_buffer_detached}")
# 修改副本的值并查看是否影响原始张量
sub_buffer_clone += 1
print(f"sub_buffer: {sub_buffer}")
print(f"sub_buffer_clone: {sub_buffer_clone}")
print(f"sub_buffer id: {id(sub_buffer)}")
print(f"sub_buffer_clone id: {id(sub_buffer_clone)}") # 不同
print(f"sub_buffer_detached id: {id(sub_buffer_detached)}") # 相同
#检查是否断开计算图
print(f"sub_buffer requires_grad: {sub_buffer.requires_grad}")
print(f"sub_buffer_detached requires_grad: {sub_buffer_detached.requires_grad}")
结果
sub_buffer requires_grad: True
sub_buffer_detached requires_grad: False
sub_buffer.grad_fn: None
sub_buffer_detached.grad_fn: None
sub_buffer: tensor([2., 2., 2.], requires_grad=True)
sub_buffer_detached: tensor([2., 2., 2.])
sub_buffer: tensor([2., 2., 2.], requires_grad=True)
sub_buffer_clone: tensor([2., 2., 2.])
sub_buffer id: 140125728706704
sub_buffer_clone id: 140125728663328
sub_buffer_detached id: 140125728706784
sub_buffer requires_grad: True
sub_buffer_detached requires_grad: False
torch.autograd.backward
import torch
# 创建两个张量，并启用梯度追踪
x = torch.randn(3, requires_grad=True)
y = torch.randn(3, requires_grad=True)
# 计算一个输出张量
out = x * y # out 参与计算图
# 使用 detach() 从计算图中分离出一个张量
out_detached = out.detach() # 这里使用 detach，断开 out 的计算图
out_detached.requires_grad_()
output = out_detached * 66
# 定义梯度张量，通常用于自定义梯度传播
grad_out = torch.ones_like(out_detached) # grad_out 是给定的梯度
# 使用 backward 进行反向传播
torch.autograd.backward(tensors=output, grad_tensors=grad_out)
# 打印梯度
print(f"x.grad: {x.grad}") # 由于 out_detached 不计算梯度，x 不会被更新
print(f"y.grad: {y.grad}") # y 也不会被更新
print(f"out.grad: {out_detached.grad}") # y 也不会被更新
print(f"out.leaf: {out_detached.is_leaf}") # y 也不会被更新
输出
x.grad: None
y.grad: None
out.grad: tensor([66., 66., 66.])
out.leaf: True
torch.autograd.backward反向传播，所得结果直接体现在叶子节点的梯度值上
再比如
import torch
# 创建两个张量，并启用梯度追踪
x = torch.randn(3, requires_grad=True)
y = torch.randn(3, requires_grad=True)
# 计算一个输出张量
out = x * y # out 参与计算图
# 使用 detach() 从计算图中分离出一个张量
out_detached = out.detach() # 这里使用 detach，断开 out 的计算图
out_detached.requires_grad_()
output = out_detached * 66
output2 = out_detached * 34
# 定义梯度张量，通常用于自定义梯度传播
grad_out = torch.ones_like(out_detached) # grad_out 是给定的梯度
# 使用 backward 进行反向传播
torch.autograd.backward(tensors=(output,output2),grad_tensors=(grad_out,grad_out))
# 打印梯度
print(f"x.grad: {x.grad}") # 由于 out_detached 不计算梯度，x 不会被更新
print(f"y.grad: {y.grad}") # y 也不会被更新
print(f"out.grad: {out_detached.grad}") # y 也不会被更新
print(f"out.leaf: {out_detached.is_leaf}") # y 也不会被更新
结果为
x.grad: None
y.grad: None
out.grad: tensor([100., 100., 100.])
out.leaf: True