从多层感知机到反向传播：1986年Rumelhart与Hinton的神经网络革命

1次阅读

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

在 1986 年之前，单层感知机（如 Rosenblatt 感知机）已被证明无法解决非线性可分问题（如 XOR 问题）。虽然多层网络结构的理论潜力被广泛认可，但缺乏有效的训练方法。主要障碍包括：

梯度计算缺失 ：没有系统方法计算隐藏层权重的误差梯度
局部极小值陷阱 ：随机初始化易使网络收敛到次优解
计算资源限制 ：当时的计算机性能难以支持复杂迭代运算

核心思想是通过链式法则将输出层误差反向传播到各层。以两层网络为例：

前向传播 ：
$$
z^{(2)} = W^{(2)}a^{(1)} + b^{(2)}, \quad a^{(2)} = \sigma(z^{(2)})
$$
$$
z^{(1)} = W^{(1)}x + b^{(1)}, \quad a^{(1)} = \sigma(z^{(1)})
$$
误差反向传播 （以 MSE 损失为例）：
$$
\frac{\partial L}{\partial W^{(2)}} = \frac{\partial L}{\partial a^{(2)}}\frac{\partial a^{(2)}}{\partial z^{(2)}}\frac{\partial z^{(2)}}{\partial W^{(2)}} = (a^{(2)}-y) \odot \sigma'(z^{(2)}) a^{(1)T}
$$
$$
\frac{\partial L}{\partial W^{(1)}} = \frac{\partial L}{\partial a^{(2)}}\frac{\partial a^{(2)}}{\partial z^{(2)}}\frac{\partial z^{(2)}}{\partial a^{(1)}}\frac{\partial a^{(1)}}{\partial z^{(1)}}\frac{\partial z^{(1)}}{\partial W^{(1)}}
$$

import numpy as np

class TwoLayerMLP:
    def __init__(self, input_size, hidden_size, output_size):
        self.W1 = np.random.randn(input_size, hidden_size) * 0.01
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * 0.01
        self.b2 = np.zeros((1, output_size))

    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def forward(self, X):
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.sigmoid(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = self.sigmoid(self.z2)
        return self.a2

    def backward(self, X, y, learning_rate=0.1):
        m = X.shape[0]

        # 输出层梯度
        da2 = (self.a2 - y) / m
        dz2 = da2 * self.a2 * (1 - self.a2)
        dW2 = np.dot(self.a1.T, dz2)
        db2 = np.sum(dz2, axis=0, keepdims=True)

        # 隐藏层梯度
        da1 = np.dot(dz2, self.W2.T)
        dz1 = da1 * self.a1 * (1 - self.a1)
        dW1 = np.dot(X.T, dz1)
        db1 = np.sum(dz1, axis=0, keepdims=True)

        # 参数更新
        self.W2 -= learning_rate * dW2
        self.b2 -= learning_rate * db2
        self.W1 -= learning_rate * dW1
        self.b1 -= learning_rate * db1

# 示例用法
X = np.array([[0,0], [0,1], [1,0], [1,1]])  # XOR 输入
y = np.array([[0], [1], [1], [0]])          # XOR 输出
model = TwoLayerMLP(2, 4, 1)
for epoch in range(10000):
    pred = model.forward(X)
    model.backward(X, y)