BP神经网络前向计算与误差反向传播更新机制图：原理详解与高效实现

1次阅读

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

BP 神经网络（Backpropagation Neural Network）是最基础且广泛应用的神经网络模型之一。其训练过程主要分为前向传播（Forward Propagation）和误差反向传播（Backward Propagation）两个阶段。前向传播负责计算神经网络的输出，而反向传播则根据输出误差调整网络权重，逐步优化模型性能。

前向传播是神经网络从输入层到输出层的计算过程。假设我们有一个简单的三层神经网络（输入层、隐藏层、输出层），其数学表达如下：

输入层到隐藏层

$$h_j = f\left(\sum_{i=1}^n w_{ij}x_i + b_j\right)$$

$x_i$ 是输入层第 $i$ 个节点的输入值
$w_{ij}$ 是输入层第 $i$ 个节点到隐藏层第 $j$ 个节点的权重
$b_j$ 是隐藏层第 $j$ 个节点的偏置
$f(\cdot)$ 是激活函数（如 Sigmoid、ReLU 等）
隐藏层到输出层

$$y_k = f\left(\sum_{j=1}^m w_{jk}h_j + b_k\right)$$

$h_j$ 是隐藏层第 $j$ 个节点的输出值
$w_{jk}$ 是隐藏层第 $j$ 个节点到输出层第 $k$ 个节点的权重
$b_k$ 是输出层第 $k$ 个节点的偏置
$y_k$ 是输出层第 $k$ 个节点的最终输出

反向传播的核心是通过链式法则（Chain Rule）计算损失函数对各个权重的梯度，然后使用梯度下降法更新权重。假设我们使用均方误差（MSE）作为损失函数：

$$E = \frac{1}{2}\sum_{k=1}^p (t_k – y_k)^2$$

输出层权重的梯度

$$\frac{\partial E}{\partial w_{jk}} = \frac{\partial E}{\partial y_k} \cdot \frac{\partial y_k}{\partial net_k} \cdot \frac{\partial net_k}{\partial w_{jk}}$$

其中：

$\frac{\partial E}{\partial y_k} = -(t_k – y_k)$
$\frac{\partial y_k}{\partial net_k} = f'(net_k)$（$net_k$ 是输出层的加权输入）
$\frac{\partial net_k}{\partial w_{jk}} = h_j$

因此：

$$\frac{\partial E}{\partial w_{jk}} = -(t_k – y_k) \cdot f'(net_k) \cdot h_j$$

隐藏层权重的梯度

类似地，可以推导出隐藏层权重的梯度：

$$\frac{\partial E}{\partial w_{ij}} = \left(\sum_{k=1}^p \frac{\partial E}{\partial y_k} \cdot \frac{\partial y_k}{\partial net_k} \cdot \frac{\partial net_k}{\partial h_j}\right) \cdot \frac{\partial h_j}{\partial net_j} \cdot \frac{\partial net_j}{\partial w_{ij}}$$

其中：

$\frac{\partial net_k}{\partial h_j} = w_{jk}$
$\frac{\partial h_j}{\partial net_j} = f'(net_j)$（$net_j$ 是隐藏层的加权输入）
$\frac{\partial net_j}{\partial w_{ij}} = x_i$

因此：

$$\frac{\partial E}{\partial w_{ij}} = \left(\sum_{k=1}^p -(t_k – y_k) \cdot f'(net_k) \cdot w_{jk}\right) \cdot f'(net_j) \cdot x_i$$

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((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 sigmoid_derivative(self, x):
        return x * (1 - x)

    def forward(self, X):
        # 前向传播
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.sigmoid(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = self.sigmoid(self.z2)
        return self.a2

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

        # 计算输出层误差
        self.dz2 = output - y
        self.dW2 = np.dot(self.a1.T, self.dz2) / m
        self.db2 = np.sum(self.dz2, axis=0, keepdims=True) / m

        # 计算隐藏层误差
        self.dz1 = np.dot(self.dz2, self.W2.T) * self.sigmoid_derivative(self.a1)
        self.dW1 = np.dot(X.T, self.dz1) / m
        self.db1 = np.sum(self.dz1, axis=0, keepdims=True) / m

        # 更新权重和偏置
        self.W1 -= learning_rate * self.dW1
        self.b1 -= learning_rate * self.db1
        self.W2 -= learning_rate * self.dW2
        self.b2 -= learning_rate * self.db2

    def train(self, X, y, epochs, learning_rate):
        for i in range(epochs):
            # 前向传播
            output = self.forward(X)

            # 计算损失
            loss = np.mean(np.square(y - output))

            # 反向传播和参数更新
            self.backward(X, y, output, learning_rate)

            if i % 1000 == 0:
                print(f'Epoch {i}, Loss: {loss}')

# 示例使用
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])  # 输入

y = np.array([[0], [1], [1], [0]])  # 输出（XOR 问题）# 创建神经网络
nn = NeuralNetwork(input_size=2, hidden_size=4, output_size=1)

# 训练
nn.train(X, y, epochs=10000, learning_rate=0.1)

# 测试
print('Predictions:')
print(nn.forward(X))