BP神经网络实战：从链式求导到反向传播的完整实现与优化

1次阅读

没有评论

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

BP 神经网络（Back Propagation Neural Network）是一种多层前馈神经网络，它通过误差反向传播算法来调整网络权重，从而实现对复杂函数的逼近。BP 网络通常由输入层、隐藏层和输出层组成，每层由多个神经元节点构成。

前向传播是神经网络计算输出的过程。假设我们有一个简单的 3 层网络（输入层、隐藏层、输出层）：

输入层接收数据 x，传递到隐藏层
隐藏层每个节点计算加权和：$z^h = W^h x + b^h$
通过激活函数（如 Sigmoid）转换：$a^h = \sigma(z^h)$
输出层同样计算：$z^o = W^o a^h + b^o$
最终输出：$y = \sigma(z^o)$

反向传播的核心是通过链式求导法则计算各层权重的梯度。我们以均方误差（MSE）作为损失函数：

$L = \frac{1}{2}(y_{true} – y_{pred})^2$

计算损失对输出的导数：$\frac{\partial L}{\partial y} = y_{pred} – y_{true}$
通过激活函数导数：$\frac{\partial y}{\partial z^o} = y(1-y)$
权重梯度：$\frac{\partial L}{\partial W^o} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial z^o} \cdot a^h$

计算对隐藏层输出的导数：$\frac{\partial L}{\partial a^h} = \frac{\partial L}{\partial z^o} \cdot W^o$
通过激活函数导数：$\frac{\partial a^h}{\partial z^h} = a^h(1-a^h)$
权重梯度：$\frac{\partial L}{\partial W^h} = \frac{\partial L}{\partial a^h} \cdot \frac{\partial a^h}{\partial z^h} \cdot x$

import numpy as np

class BPNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.W1 = np.random.randn(input_size, hidden_size) * 0.1
        self.b1 = np.zeros(hidden_size)
        self.W2 = np.random.randn(hidden_size, output_size) * 0.1
        self.b2 = np.zeros(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.output = self.sigmoid(self.z2)
        return self.output

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

        # 输出层误差
        output_error = self.output - y_true
        d_output = output_error * self.output * (1 - self.output)

        # 隐藏层误差
        hidden_error = np.dot(d_output, self.W2.T)
        d_hidden = hidden_error * self.a1 * (1 - self.a1)

        # 更新权重
        self.W2 -= learning_rate * np.dot(self.a1.T, d_output) / m
        self.b2 -= learning_rate * np.sum(d_output, axis=0) / m
        self.W1 -= learning_rate * np.dot(x.T, d_hidden) / m
        self.b1 -= learning_rate * np.sum(d_hidden, axis=0) / m

    def train(self, X, y, epochs=1000, lr=0.1):
        for epoch in range(epochs):
            output = self.forward(X)
            self.backward(X, y, lr)
            if epoch % 100 == 0:
                loss = np.mean(0.5 * (y - output) ** 2)
                print(f'Epoch {epoch}, Loss: {loss:.4f}')

当网络层数加深时，梯度在反向传播过程中会逐渐变小，导致底层网络参数更新缓慢。解决方案：