BP神经网络误差反向传播原理解析与Python实现

1次阅读

没有评论

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

神经网络是一种模仿生物神经元工作方式的数学模型，由输入层、隐藏层和输出层组成。每层包含若干个神经元，神经元之间通过权重连接。前向传播时，输入数据经过层层计算得到预测结果，但初始权重是随机的，预测结果往往不准确。

误差反向传播（Backpropagation，简称 BP）正是解决这个问题的关键算法。它的核心思想是：

计算预测结果与实际标签的误差
将误差从输出层反向传播回各隐藏层
根据误差调整各层权重，逐步减小误差

BP 算法的数学基础是链式求导法则。我们以一个简单的三层网络（输入层、隐藏层、输出层）为例，推导权重更新过程：

定义损失函数（以均方误差为例）：
```
E = 1/2 * Σ(y_true - y_pred)^2
```
输出层权重更新（W2）：
```
∂E/∂W2 = ∂E/∂y_pred * ∂y_pred/∂z2 * ∂z2/∂W2
```
其中 z2 是输出层的加权输入
隐藏层权重更新（W1）：
```
∂E/∂W1 = ∂E/∂h * ∂h/∂z1 * ∂z1/∂W1
```
这里 h 是隐藏层输出，z1 是隐藏层的加权输入

通过这种链式求导，我们可以将误差逐层反向传播，计算出所有权重的梯度。

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.W2 = np.random.randn(hidden_size, output_size) * 0.01

    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.h = self.sigmoid(self.z1)
        self.z2 = np.dot(self.h, self.W2)
        self.y_pred = self.sigmoid(self.z2)
        return self.y_pred

    def backward(self, X, y_true, learning_rate=0.1):
        # 输出层误差
        error = y_true - self.y_pred
        d_output = error * self.sigmoid_derivative(self.y_pred)

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

        # 更新权重
        self.W2 += self.h.T.dot(d_output) * learning_rate
        self.W1 += X.T.dot(d_hidden) * learning_rate

    def train(self, X, y, epochs=1000, learning_rate=0.1):
        for epoch in range(epochs):
            y_pred = self.forward(X)
            self.backward(X, y, learning_rate)

            # 每 100 次迭代打印损失
            if epoch % 100 == 0:
                loss = np.mean(np.square(y - y_pred))
                print(f'Epoch {epoch}, Loss: {loss}')

# 示例使用
X = np.array([[0,0], [0,1], [1,0], [1,1]])  # 输入数据
y = np.array([[0], [1], [1], [0]])          # 异或问题目标值

nn = NeuralNetwork(2, 4, 1)  # 2 输入，4 隐藏神经元，1 输出
nn.train(X, y, epochs=1000)

当网络层数较多时，反向传播的梯度会随着层数增加而指数级减小，导致浅层权重几乎不更新。解决方案：