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

1次阅读

没有评论

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

BP 神经网络作为深度学习的基础算法，通过误差反向传播机制实现了多层神经网络的权重调整。它的核心价值在于能够自动学习特征表示，但同时也面临梯度消失、局部最优等典型问题。在实际应用中，理解其数学原理对调试模型和解决收敛问题至关重要。

输入层到隐藏层的计算可以表示为：$h = \sigma(W_1x + b_1)$，其中 $\sigma$ 是激活函数
隐藏层到输出层的计算：$\hat{y} = \sigma(W_2h + b_2)$
使用矩阵表示可以高效处理批量数据，这也是后续向量化实现的基础

对于分类问题，我们通常使用交叉熵损失函数：

$$L = -\frac{1}{N}\sum_{i=1}^N [y_i\log(\hat{y}_i) + (1-y_i)\log(1-\hat{y}_i)]$$

首先计算损失对输出的导数：$\frac{\partial L}{\partial \hat{y}} = -\frac{y}{\hat{y}} + \frac{1-y}{1-\hat{y}}$
然后计算输出对激活输入的导数（以 Sigmoid 为例）：$\frac{\partial \hat{y}}{\partial z_2} = \hat{y}(1-\hat{y})$
最后结合两者得到权重梯度：$\frac{\partial L}{\partial W_2} = (\hat{y}-y)h^T$

需要继续应用链式法则回溯：$\frac{\partial L}{\partial h} = W_2^T(\hat{y}-y)$
计算隐藏层激活的导数：$\frac{\partial h}{\partial z_1} = h \odot (1-h)$
最终得到：$\frac{\partial L}{\partial W_1} = [(\hat{y}-y)W_2^T \odot h \odot (1-h)]x^T$

import numpy as np

class BPNeuralNetwork:
    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.h = self.sigmoid(self.z1)
        self.z2 = np.dot(self.h, self.W2) + self.b2
        self.y_hat = self.sigmoid(self.z2)
        return self.y_hat

    def backward(self, X, y, learning_rate):
        # 反向传播
        m = X.shape[0]

        # 输出层梯度
        dy = self.y_hat - y
        dW2 = np.dot(self.h.T, dy) / m
        db2 = np.sum(dy, axis=0, keepdims=True) / m

        # 隐藏层梯度
        dh = np.dot(dy, self.W2.T)
        dz1 = dh * self.h * (1 - self.h)
        dW1 = np.dot(X.T, dz1) / m
        db1 = np.sum(dz1, axis=0, keepdims=True) / m

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