从20世纪80年代的反向传播算法论文到现代深度学习：核心思想与实现演进

1次阅读

共计 2597 个字符，预计需要花费 7 分钟才能阅读完成。

1986 年，Rumelhart、Hinton 和 Williams 在《Nature》发表的论文《Learning representations by back-propagating errors》首次系统描述了反向传播算法（Backpropagation）。这一工作解决了多层感知机（MLP）的训练难题，为神经网络的发展扫清了关键障碍。

突破性贡献 ：首次证明通过链式法则逐层传播误差信号可有效调整网络权重
历史地位 ：与 1958 年感知机、1969 年 Minsky 的批评形成完整技术脉络
核心思想 ：误差反向传播 + 梯度下降的协同工作模式沿用至今

对于具有 L 层的网络，定义：

$a^l$：第 l 层激活值
$z^l=W^l a^{l-1}+b^l$：加权输入
$\delta^l=\frac{\partial C}{\partial z^l}$：误差项

反向传播四步推导：

输出层误差计算
$$\delta^L = \nabla_a C \odot \sigma'(z^L)$$
反向传播误差
$$\delta^l = ((W^{l+1})^T \delta^{l+1}) \odot \sigma'(z^l)$$
梯度计算
$$\frac{\partial C}{\partial b^l} = \delta^l$$
$$\frac{\partial C}{\partial W^l} = \delta^l (a^{l-1})^T$$
参数更新
$$W^l \leftarrow W^l – \eta \frac{\partial C}{\partial W^l}$$

for each training example x:
    # 前向传播
    a1 = x
    for l in 2..L:
        zl = Wl * a{l-1} + bl
        al = σ(zl)

    # 反向传播
    deltaL = ∇C ⊙ σ'(zL)
    for l in L-1..1:
        deltal = (W{l+1}.T * delta{l+1}) ⊙ σ'(zl)
        grad_Wl = deltal * a{l-1}.T
        grad_bl = deltal

    # 参数更新
    for l in 1..L:
        Wl -= eta * grad_Wl
        bl -= eta * grad_bl

import torch
import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 256)
        self.fc2 = nn.Linear(256, 10)

    def forward(self, x):
        x = torch.sigmoid(self.fc1(x))
        return self.fc2(x)

model = Net()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

# 训练循环（自动微分）for epoch in range(10):
    for x, y in train_loader:
        optimizer.zero_grad()
        output = model(x)
        loss = criterion(output, y)
        loss.backward()  # 自动反向传播
        optimizer.step()

# 手动实现反向传播
def manual_backward(model, x, y):
    # 前向传播
    z1 = torch.matmul(x, model.fc1.weight.T) + model.fc1.bias
    a1 = torch.sigmoid(z1)
    z2 = torch.matmul(a1, model.fc2.weight.T) + model.fc2.bias

    # 计算输出层误差
    output = F.softmax(z2, dim=1)
    delta2 = output - F.one_hot(y, 10).float()

    # 反向传播
    grad_w2 = torch.matmul(delta2.T, a1)
    grad_b2 = torch.sum(delta2, dim=0)

    delta1 = torch.matmul(delta2, model.fc2.weight) * (a1 * (1 - a1))
    grad_w1 = torch.matmul(delta1.T, x)
    grad_b1 = torch.sum(delta1, dim=0)

    # 手动更新参数
    with torch.no_grad():
        model.fc1.weight -= 0.1 * grad_w1
        model.fc1.bias -= 0.1 * grad_b1
        model.fc2.weight -= 0.1 * grad_w2
        model.fc2.bias -= 0.1 * grad_b2