BP神经网络反向传播算法推导过程详解：从数学基础到代码实现

1次阅读

没有评论

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

BP 神经网络（Backpropagation Neural Network）是一种多层前馈网络，通过误差反向传播算法进行训练。它由输入层、隐藏层和输出层组成，每层之间通过权重连接。

前向传播是指输入数据从输入层经过隐藏层最终到达输出层的过程。具体步骤如下：

输入层接收输入向量 x
计算隐藏层输入：z = W1 * x + b1
通过激活函数得到隐藏层输出：a = σ(z)
计算输出层输入：z’ = W2 * a + b2
最终输出：y = σ(z’)

数学表达式为：
$$ y = \sigma(W_2\cdot\sigma(W_1\cdot x + b_1) + b_2) $$

反向传播算法的核心是通过链式法则计算损失函数对各个参数的梯度，然后使用梯度下降法更新参数。

假设我们使用均方误差作为损失函数：
$$ L = \frac{1}{2}(y – t)^2 $$
其中 t 是真实标签。

计算损失对输出的偏导：
$$ \frac{\partial L}{\partial y} = y – t $$
计算输出对 z ’ 的偏导（考虑 sigmoid 激活函数）：
$$ \frac{\partial y}{\partial z’} = y(1-y) $$
通过链式法则得到输出层的误差项：
$$ \delta_2 = \frac{\partial L}{\partial z’} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial z’} = (y-t) \cdot y(1-y) $$

计算 z ’ 对隐藏层输出 a 的偏导：
$$ \frac{\partial z’}{\partial a} = W_2 $$
计算 a 对 z 的偏导：
$$ \frac{\partial a}{\partial z} = a(1-a) $$
隐藏层的误差项：
$$ \delta_1 = \delta_2 \cdot W_2^T \cdot a(1-a) $$

使用学习率 η 更新参数：

输出层权重更新：
$$ W_2 \leftarrow W_2 – \eta \cdot \delta_2 \cdot a^T $$
$$ b_2 \leftarrow b_2 – \eta \cdot \delta_2 $$
隐藏层权重更新：
$$ W_1 \leftarrow W_1 – \eta \cdot \delta_1 \cdot x^T $$
$$ b_1 \leftarrow b_1 – \eta \cdot \delta_1 $$

import numpy as np

class BPNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重
        self.W1 = np.random.randn(input_size, hidden_size) * 0.1
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * 0.1
        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.a1 = self.sigmoid(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.output = self.sigmoid(self.z2)
        return self.output

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

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

        # 隐藏层误差
        delta1 = np.dot(delta2, self.W2.T) * self.a1 * (1 - self.a1)
        dW1 = np.dot(x.T, delta1) / m
        db1 = np.sum(delta1, axis=0, keepdims=True) / m

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

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

BP 神经网络的时间复杂度主要取决于：