深入理解bp反向传播算法：从数学推导到代码实现

1次阅读

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

反向传播（Backpropagation，简称 BP）算法是神经网络训练的核心，它通过计算损失函数对网络参数的梯度，指导参数更新方向。无论是简单的全连接网络，还是复杂的卷积神经网络，BP 算法都扮演着关键角色。本文将带你从数学原理到代码实现，全面理解这一算法。

在深入 BP 算法之前，我们需要明确神经网络的基本结构和工作原理。一个典型的神经网络由输入层、隐藏层和输出层组成，每一层包含若干神经元。神经元之间的连接权重决定了信号的传递强度。

前向传播 ：数据从输入层流向输出层的过程。具体来说，每一层的输出是上一层输出的加权和，经过激活函数变换后得到。例如，对于一个简单的两层网络：

$$
z = Wx + b \
a = \sigma(z)
$$

其中，$W$ 是权重矩阵，$b$ 是偏置向量，$\sigma$ 是激活函数（如 Sigmoid 或 ReLU）。

BP 算法的核心是链式法则（Chain Rule），它用于计算损失函数对网络参数的梯度。假设网络的损失函数为 $L$，我们需要计算 $\frac{\partial L}{\partial W}$ 和 $\frac{\partial L}{\partial b}$。

输出层梯度计算 ：

对于输出层的神经元，梯度计算相对直接。例如，使用均方误差（MSE）作为损失函数：

$$
L = \frac{1}{2}(y – a)^2
$$

其中，$y$ 是真实值，$a$ 是网络输出。梯度为：

$$
\frac{\partial L}{\partial a} = -(y – a)
$$

隐藏层梯度计算 ：

对于隐藏层，梯度需要通过链式法则逐层反向传播。以 Sigmoid 激活函数为例：

$$
\frac{\partial L}{\partial z} = \frac{\partial L}{\partial a} \cdot \sigma'(z)
$$

其中，$\sigma'(z)$ 是激活函数的导数。对于 Sigmoid 函数，$\sigma'(z) = \sigma(z)(1 – \sigma(z))$。

权重和偏置的梯度 ：

最终，权重和偏置的梯度可以通过以下公式计算：

$$
\frac{\partial L}{\partial W} = \frac{\partial L}{\partial z} \cdot x \
\frac{\partial L}{\partial b} = \frac{\partial L}{\partial z}
$$

BP 算法的具体步骤如下：

前向传播：计算每一层的输出 $a$ 和加权输入 $z$。
计算输出层的误差 $\delta = \frac{\partial L}{\partial a} \cdot \sigma'(z)$。
反向传播误差：对于每一层，计算 $\delta^{l} = (W^{l+1})^T \delta^{l+1} \cdot \sigma'(z^l)$。
计算梯度：$\frac{\partial L}{\partial W^l} = \delta^l \cdot (a^{l-1})^T$，$\frac{\partial L}{\partial b^l} = \delta^l$。
更新参数：使用梯度下降或其他优化算法更新权重和偏置。

以下是一个简单的 BP 算法实现，用于训练一个两层神经网络：

import numpy as np

# 定义 Sigmoid 激活函数及其导数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return x * (1 - x)

# 初始化参数
input_size = 2
hidden_size = 3
output_size = 1

W1 = np.random.randn(input_size, hidden_size)
W2 = np.random.randn(hidden_size, output_size)
b1 = np.zeros((1, hidden_size))
b2 = np.zeros((1, output_size))

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

# 训练参数
learning_rate = 0.1
epochs = 10000

# 训练过程
for epoch in range(epochs):
    # 前向传播
    z1 = np.dot(X, W1) + b1
    a1 = sigmoid(z1)
    z2 = np.dot(a1, W2) + b2
    a2 = sigmoid(z2)

    # 计算损失
    loss = np.mean(0.5 * (y - a2) ** 2)

    # 反向传播
    delta2 = -(y - a2) * sigmoid_derivative(a2)
    dW2 = np.dot(a1.T, delta2)
    db2 = np.sum(delta2, axis=0, keepdims=True)

    delta1 = np.dot(delta2, W2.T) * sigmoid_derivative(a1)
    dW1 = np.dot(X.T, delta1)
    db1 = np.sum(delta1, axis=0, keepdims=True)

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

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

# 测试
print('Final predictions:')
print(a2)