从1986年BP反向传播算法论文看神经网络研究的复兴之路

1次阅读

没有评论

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

1986 年前，神经网络研究正经历第二次低谷。单层感知机被证明无法解决非线性问题（如异或门），而多层网络又面临训练难题：

缺乏有效的权重更新方法
梯度消失现象未被系统认知
计算资源限制模型规模

鲁梅尔哈特等人发表在《自然》的论文《Learning representations by back-propagating errors》提出了误差反向传播算法（Backpropagation），其核心突破在于：

链式法则的应用 ：通过反向逐层传递误差信号
分布式表示 ：隐层实现自动特征提取
通用逼近能力 ：理论上能拟合任何连续函数

对于具有 $L$ 层的网络，前向传播为：
$$z^l = W^l a^{l-1} + b^l$$
$$a^l = \sigma(z^l)$$

误差反向传播时：

输出层误差：
$$\delta^L = \nabla_a J \odot \sigma'(z^L)$$
隐层误差传播：
$$\delta^l = ((W^{l+1})^T \delta^{l+1}) \odot \sigma'(z^l)$$
参数梯度：
$$\frac{\partial J}{\partial W^l} = \delta^l (a^{l-1})^T$$
$$\frac{\partial J}{\partial b^l} = \delta^l$$

graph LR
A[输入] --> B[前向传播]
B --> C[计算损失]
C --> D[反向传播]
D --> E[参数更新]
E --> A

import numpy as np

class BPNetwork:
    def __init__(self, layers):
        self.weights = [np.random.randn(y, x)*0.1 
                       for x, y in zip(layers[:-1], layers[1:])]
        self.biases = [np.zeros((y, 1)) for y in layers[1:]]

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

    def forward(self, x):
        for w, b in zip(self.weights, self.biases):
            x = self.sigmoid(np.dot(w, x) + b)
        return x

    def train(self, X, y, epochs=1000, lr=0.1):
        for _ in range(epochs):
            # 随机梯度下降
            for x, label in zip(X, y):
                # 前向传播
                activations = [x.reshape(-1,1)]
                zs = []
                for w, b in zip(self.weights, self.biases):
                    z = np.dot(w, activations[-1]) + b
                    zs.append(z)
                    activations.append(self.sigmoid(z))

                # 反向传播
                delta = (activations[-1] - label) * activations[-1] * (1-activations[-1])
                nabla_w = [np.zeros(w.shape) for w in self.weights]
                nabla_b = [np.zeros(b.shape) for b in self.biases]
                nabla_w[-1] = np.dot(delta, activations[-2].T)
                nabla_b[-1] = delta

                for l in range(2, len(self.weights)+1):
                    delta = np.dot(self.weights[-l+1].T, delta) * \
                           activations[-l] * (1-activations[-l])
                    nabla_w[-l] = np.dot(delta, activations[-l-1].T)
                    nabla_b[-l] = delta

                # 参数更新
                self.weights = [w-lr*nw for w, nw in zip(self.weights, nabla_w)]
                self.biases = [b-lr*nb for b, nb in zip(self.biases, nabla_b)]

SGD with Momentum：
$$v_t = \gamma v_{t-1} + \eta \nabla_\theta J(\theta)$$
$$\theta = \theta – v_t$$
Adam：
$$m_t = \beta_1 m_{t-1} + (1-\beta_1)g_t$$
$$v_t = \beta_2 v_{t-1} + (1-\beta_2)g_t^2$$
$$\hat{m}t = m_t/(1-\beta_1^t)$$
$$\hat{v}_t = v_t/(1-\beta_2^t)$$
$$\theta+\epsilon)$$} = \theta_t – \eta \hat{m}_t/(\sqrt{\hat{v}_t

残差连接（ResNet）
批量归一化（BatchNorm）
注意力机制

梯度消失 ：
使用 ReLU 等非饱和激活函数
初始化采用 He/Kaiming 方法
梯度爆炸 ：
梯度裁剪（Gradient Clipping）
权重正则化
死亡神经元 ：
LeakyReLU 激活函数
适当调小学习率

from sklearn.datasets import fetch_openml
mnist = fetch_openml('mnist_784')
X, y = mnist["data"], mnist["target"]
X_train, X_test = X[:60000] / 255., X[60000:] / 255.
y_train = np.eye(10)[y[:60000].astype(int)]

# 原始 BP
bp_net = BPNetwork([784, 30, 10])
bp_net.train(X_train, y_train, epochs=10)

# 对比现代优化器
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([Dense(30, activation='relu', input_shape=(784,)),
    Dense(10, activation='softmax')
])
model.compile(optimizer='adam', 
              loss='categorical_crossentropy',
              metrics=['accuracy'])
model.fit(X_train, y_train, epochs=10)

实验结果：