BP神经网络公式推导：从数学原理到代码实现

1次阅读

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

BP 神经网络（Backpropagation Neural Network）是深度学习的基础模型之一，广泛应用于图像分类、语音识别和自然语言处理等领域。它的核心思想是通过误差反向传播算法（Backpropagation）来调整网络权重，从而最小化预测误差。理解 BP 算法的数学原理对于掌握深度学习至关重要，它不仅帮助我们调试模型，还能为后续学习更复杂的网络结构打下基础。

假设我们有一个简单的三层神经网络（输入层、隐藏层、输出层），前向传播过程可以用矩阵运算表示：

[
\mathbf{h} = \sigma(\mathbf{W}_1 \mathbf{x} + \mathbf{b}_1)
]
[
\mathbf{y} = \sigma(\mathbf{W}_2 \mathbf{h} + \mathbf{b}_2)
]

其中，(\mathbf{x})是输入向量，(\mathbf{W}_1)和 (\mathbf{W}_2) 是权重矩阵，(\mathbf{b}_1)和 (\mathbf{b}_2) 是偏置向量，(\sigma)是激活函数（如 Sigmoid 或 ReLU）。

常用的损失函数是均方误差（MSE）：

[
L = \frac{1}{2} \sum_{i=1}^{n} (y_i – t_i)^2
]

其中，(t_i)是真实标签，(y_i)是预测值。

反向传播的核心是通过链式法则计算损失函数对权重的梯度。以隐藏层权重 (\mathbf{W}_2) 为例：

[
\frac{\partial L}{\partial \mathbf{W}_2} = \frac{\partial L}{\partial \mathbf{y}} \cdot \frac{\partial \mathbf{y}}{\partial \mathbf{z}_2} \cdot \frac{\partial \mathbf{z}_2}{\partial \mathbf{W}_2}
]

其中，(\mathbf{z}_2 = \mathbf{W}_2 \mathbf{h} + \mathbf{b}_2)是隐藏层的线性输出。具体推导如下：

计算(\frac{\partial L}{\partial \mathbf{y}})：
[
\frac{\partial L}{\partial y_i} = y_i – t_i
]
计算(\frac{\partial \mathbf{y}}{\partial \mathbf{z}2})（激活函数的导数）：
[
\frac{\partial y_i}{\partial z)
]}} = \sigma'(z_{2,i
计算(\frac{\partial \mathbf{z}2}{\partial \mathbf{W}_2})：
[
\frac{\partial z = h_j
]}}{\partial W_{2,ij}

最终，梯度为：
[
\frac{\partial L}{\partial W_{2,ij}} = (y_i – t_i) \cdot \sigma'(z_{2,i}) \cdot h_j
]

类似地，可以推导出其他权重的梯度。

以下是用 NumPy 实现 BP 神经网络的核心代码：

import numpy as np

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重
        self.W1 = np.random.randn(input_size, hidden_size) * 0.01
        self.b1 = np.zeros(hidden_size)
        self.W2 = np.random.randn(hidden_size, output_size) * 0.01
        self.b2 = np.zeros(output_size)

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

    def sigmoid_derivative(self, x):
        return x * (1 - x)

    def forward(self, x):
        self.z1 = np.dot(x, self.W1) + self.b1
        self.h = self.sigmoid(self.z1)
        self.z2 = np.dot(self.h, self.W2) + self.b2
        self.y = self.sigmoid(self.z2)
        return self.y

    def backward(self, x, t, learning_rate):
        # 计算输出层误差
        error = self.y - t
        d_output = error * self.sigmoid_derivative(self.y)

        # 计算隐藏层误差
        error_hidden = np.dot(d_output, self.W2.T)
        d_hidden = error_hidden * self.sigmoid_derivative(self.h)

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

    def train(self, X, Y, epochs, learning_rate):
        for epoch in range(epochs):
            y_pred = self.forward(X)
            self.backward(X, Y, learning_rate)
            loss = np.mean((y_pred - Y) ** 2)
            if epoch % 100 == 0:
                print(f'Epoch {epoch}, Loss: {loss:.4f}')

学习率（learning rate）是影响模型收敛的关键参数。过大的学习率可能导致振荡甚至发散，而过小的学习率会减慢收敛速度。实验表明，学习率在 0.1 到 0.001 之间通常能取得较好的效果。

常用的激活函数包括 Sigmoid、ReLU 和 Tanh。Sigmoid 容易导致梯度消失问题，而 ReLU 在深层网络中表现更好，因为它能缓解梯度消失问题。

梯度消失表现为深层网络的权重更新非常缓慢。解决方法包括使用 ReLU 激活函数、批归一化（Batch Normalization）或残差连接（Residual Connections）。

权重初始化对训练效果有重要影响。常用的方法包括 Xavier 初始化和 He 初始化，它们根据输入和输出的维度调整初始权重的范围。