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

1次阅读

没有评论

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

BP 神经网络是深度学习的基础模型，在图像识别、语音处理等领域表现出色。它通过多层非线性变换实现复杂函数逼近，而反向传播算法则高效解决了参数更新问题。理解其数学本质，能帮助我们更好地调试模型和应对梯度消失等常见问题。

假设我们有一个三层的神经网络（输入层、隐藏层、输出层），前向传播过程如下：

输入层到隐藏层：
$$Z^{[1]} = W^{[1]}X + b^{[1]}$$
$$A^{[1]} = \sigma(Z^{[1]})$$
其中 $\sigma$ 是 sigmoid 函数：$\sigma(z) = \frac{1}{1+e^{-z}}$
隐藏层到输出层：
$$Z^{[2]} = W^{[2]}A^{[1]} + b^{[2]}$$
$$A^{[2]} = \sigma(Z^{[2]})$$

sigmoid 函数的导数为：
$$\sigma'(z) = \sigma(z)(1-\sigma(z))$$

误差反向传播使用链式法则计算梯度：

输出层误差：
$$dZ^{[2]} = A^{[2]} – Y$$
$$dW^{[2]} = \frac{1}{m}dZ^{[2]}A^{[1]T}$$
$$db^{[2]} = \frac{1}{m}np.sum(dZ^{[2]}, axis=1, keepdims=True)$$
隐藏层误差：
$$dZ^{[1]} = W^{[2]T}dZ^{[2]} * \sigma'(Z^{[1]})$$
$$dW^{[1]} = \frac{1}{m}dZ^{[1]}X^T$$
$$db^{[1]} = \frac{1}{m}np.sum(dZ^{[1]}, axis=1, keepdims=True)$$

import numpy as np

class BPNeuralNetwork:
    def __init__(self, layer_sizes):
        # Xavier 初始化
        self.W1 = np.random.randn(layer_sizes[1], layer_sizes[0]) * np.sqrt(1/layer_sizes[0])
        self.b1 = np.zeros((layer_sizes[1], 1))
        self.W2 = np.random.randn(layer_sizes[2], layer_sizes[1]) * np.sqrt(1/layer_sizes[1])
        self.b2 = np.zeros((layer_sizes[2], 1))

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

    def forward(self, X):
        self.Z1 = np.dot(self.W1, X) + self.b1
        self.A1 = self.sigmoid(self.Z1)
        self.Z2 = np.dot(self.W2, self.A1) + self.b2
        self.A2 = self.sigmoid(self.Z2)
        return self.A2

    def backward(self, X, Y, learning_rate, lambda_=0.1):
        m = X.shape[1]

        # 反向传播
        dZ2 = self.A2 - Y
        dW2 = (1/m) * np.dot(dZ2, self.A1.T) + (lambda_/m)*self.W2  # L2 正则化
        db2 = (1/m) * np.sum(dZ2, axis=1, keepdims=True)

        dZ1 = np.dot(self.W2.T, dZ2) * (self.A1 * (1-self.A1))
        dW1 = (1/m) * np.dot(dZ1, X.T) + (lambda_/m)*self.W1
        db1 = (1/m) * np.sum(dZ1, axis=1, keepdims=True)

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

Xavier 初始化根据输入和输出的维度调整初始化范围，防止梯度爆炸或消失：

# 对于第 l 层权重矩阵
W = np.random.randn(n_l, n_{l-1}) * np.sqrt(1/n_{l-1})

梯度检查是验证反向传播实现正确性的重要手段：

def gradient_check(X, Y, epsilon=1e-7):
    # 计算数值梯度
    W1_plus = model.W1 + epsilon
    W1_minus = model.W1 - epsilon
    # 计算损失函数差值
    # 比较数值梯度和解析梯度
    # 误差应小于 1e-7