【学习笔记】反向传播到底是如何进行的？

一、写在前面

不知道小伙伴们有没有考虑过这种感觉，在最开始学习深度学习的时候，一定都了解过前向传播，反向传播等等，但是在实际的操作过程中却“几乎用不到”，那么反向传播过程在代码中到底是如何进行的呢？今天让我们来回顾一下。

跑过深度学习代码的小伙伴们想必都见过下面这几行：

self.opt.zero_grad()
loss = nn.MSELoss()(var_pred, var_true)
loss.backward()
self.opt.step()

接下来我们就重点分析这几行代码的作用！

• self.opt.zero_grad()

进行梯度清零，至于为什么要进行梯度清零，可以先看下面。

• loss = nn.MSELoss()(var_pred, var_true)

计算损失。

• loss.backward()

回传损失，计算梯度。

• self.opt.step()

更新权重。

二、举个例子

我们可以举一个简单的全连接层的例子，下面是具体的代码。

   import torch.nn as nn

   # 定义模型
   class SimpleModel(nn.Module):
       def __init__(self):
           super(SimpleModel, self).__init__()
           self.fc = nn.Linear(1, 1)  # 全连接层

       def forward(self, x):
           return self.fc(x)
   # 创建模型实例
   model = SimpleModel()

   # 定义损失函数
   criterion = nn.MSELoss()

   # 定义优化器
   optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

   # 输入数据
   input_data = torch.tensor([[1.0], [2.0], [3.0]], requires_grad=True)
   target = torch.tensor([[1.5], [2.5], [3.5]])
   for name, param in model.named_parameters():
       print(name, param)
   print()

   # 前向传播
   output = model(input_data)
   print("output:", output)
   # 计算损失
   loss = criterion(output, target)
   print(input_data.grad)
   # 反向传播 计算梯度
   loss.backward()
   print("loss:", loss.item())
   print(input_data.grad)

   for name, param in model.named_parameters():
       print(name, param, param.grad)
   print()

   # 权重更新
   optimizer.step()
   for name, param in model.named_parameters():
       print(name, param, param.grad)
   print()

在上面的例子中，我们定义的神经网络的数学公式为：
$$y=wx+b$$

那么这个神经网络的权重是如何更新的呢？

1. 权重指的是什么？

在本例中就是w和b，也就是除了输入和输出以外的其他变量。

2. 在我们创建模型的时候会自动初始化一个模型的权重；

在本例中，我们可以打印出来初始的权重：
fc.weight Parameter containing:
tensor([[-0.2505]], requires_grad=True)
fc.bias Parameter containing:
tensor([0.9166], requires_grad=True)
也就是说初始的w=-0.2505，b=0.9166;

3. 前向传播，计算输出：

根据公式y=f(x)，在本例中f(x)=wx+b，换成其他的神经网络也类似计算。
带入x可以获得输出：
output: tensor([[0.6661], [0.4156], [0.1651]],
grad_fn=<AddmmBackward0>)

4. 计算损失：

本例中采用的损失函数为MSE Loss，计算公式如下：
$L=\frac{}{N}$