BP神经网络计算题实战：从数学推导到Python实现

1次阅读

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

BP 神经网络作为经典的深度学习模型，能通过多层非线性变换逼近任意复杂函数，特别适合解决异或 (XOR) 等线性不可分问题。其核心优势在于误差反向传播 (Backpropagation) 机制，可自动学习输入到输出的映射关系。但在实际训练中常面临梯度消失(Vanishing Gradient)、收敛速度慢、易陷局部最优等计算难题。

BP 算法的本质是链式法则 (Chain Rule) 的递归应用，以三层网络为例：

前向传播：
$$
\begin{aligned}
z^{(2)} &= W^{(1)}x + b^{(1)} \
a^{(2)} &= \sigma(z^{(2)}) \
z^{(3)} &= W^{(2)}a^{(2)} + b^{(2)} \
a^{(3)} &= \sigma(z^{(3)})
\end{aligned}
$$

反向传播（以均方误差损失为例）：
$$
\begin{aligned}
\delta^{(3)} &= (a^{(3)} – y) \odot \sigma'(z^{(3)}) \
\delta^{(2)} &= (W^{(2)T}\delta^{(3)}) \odot \sigma'(z^{(2)}) \
\frac{\partial J}{\partial W^{(2)}} &= \delta^{(3)}a^{(2)T} \
\frac{\partial J}{\partial b^{(2)}} &= \delta^{(3)}
\end{aligned}
$$

import numpy as np

class BPNetwork:
    def __init__(self, input_size, hidden_size):
        # 初始化权重（He 初始化）self.W1 = np.random.randn(input_size, hidden_size) * np.sqrt(2/input_size)
        self.b1 = np.zeros(hidden_size)
        self.W2 = np.random.randn(hidden_size, 1) * np.sqrt(2/hidden_size)
        self.b2 = np.zeros(1)

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

    def sigmoid_derivative(self, z):
        s = self.sigmoid(z)
        return s * (1 - s)

    def forward(self, X):
        self.z2 = np.dot(X, self.W1) + self.b1
        self.a2 = self.sigmoid(self.z2)
        self.z3 = np.dot(self.a2, self.W2) + self.b2
        return self.sigmoid(self.z3)

    def backward(self, X, y, lr=0.1):
        # 批量梯度下降
        delta3 = (self.a3 - y) * self.sigmoid_derivative(self.z3)
        dW2 = np.dot(self.a2.T, delta3)
        db2 = np.sum(delta3, axis=0)

        delta2 = np.dot(delta3, self.W2.T) * self.sigmoid_derivative(self.z2)
        dW1 = np.dot(X.T, delta2)
        db1 = np.sum(delta2, axis=0)

        # 参数更新（可添加梯度裁剪）self.W2 -= lr * dW2
        self.b2 -= lr * db2
        self.W1 -= lr * dW1
        self.b1 -= lr * db1

学习率	收敛步数	最终损失
0.5	震荡发散	NaN
0.1	1200	0.0012
0.01	6500	0.0008

建议：初始尝试 0.1，配合损失曲线动态调整

# 测试数据
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([[0], [1], [1], [0]])

# 训练网络
nn = BPNetwork(2, 4)
for epoch in range(10000):
    pred = nn.forward(X)
    nn.backward(X, y, lr=0.1)

# 输出预测结果
print(nn.forward(X))  # 应接近[[0], [1], [1], [0]]