深入解析bp模型反向传播数学表示：从原理到实现

1次阅读

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

反向传播（Backpropagation，简称 BP）是训练神经网络的核心算法之一。它的主要作用是通过计算损失函数对网络参数的梯度，然后利用梯度下降等优化算法来更新参数，从而最小化损失函数。BP 算法的核心思想是链式法则，它能够高效地计算梯度，使得深度学习模型的训练成为可能。

在前向传播过程中，输入数据通过神经网络的每一层，最终得到输出。假设我们有一个简单的三层神经网络（输入层、隐藏层、输出层），前向传播的计算可以表示为：

输入层到隐藏层的计算：
[h = \sigma(W_1 x + b_1) ]
其中，(W_1) 是权重矩阵，(b_1) 是偏置向量，(\sigma) 是激活函数（如 Sigmoid 或 ReLU）。
隐藏层到输出层的计算：
[y = \sigma(W_2 h + b_2) ]

反向传播的目标是计算损失函数对权重和偏置的梯度。假设损失函数为均方误差（MSE）：
[L = \frac{1}{2} (y – t)^2 ]
其中，(t) 是真实标签。

计算损失函数对输出层权重的梯度：
[\frac{\partial L}{\partial W_2} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial W_2} ]
其中，(\frac{\partial L}{\partial y} = y – t )，(\frac{\partial y}{\partial W_2} = \sigma'(W_2 h + b_2) \cdot h )。
计算损失函数对隐藏层权重的梯度：
[\frac{\partial L}{\partial W_1} = \frac{\partial L}{\partial h} \cdot \frac{\partial h}{\partial W_1} ]
其中，(\frac{\partial L}{\partial h} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial h} )，(\frac{\partial y}{\partial h} = W_2 \cdot \sigma'(W_2 h + b_2) )。

以下是一个简单的 Python 实现，展示了反向传播的核心步骤：

import numpy as np

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

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

# 初始化参数
np.random.seed(1)
W1 = np.random.randn(2, 3)
W2 = np.random.randn(3, 1)
b1 = np.zeros((1, 3))
b2 = np.zeros((1, 1))

# 输入数据
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_true = np.array([[0], [1], [1], [0]])

# 训练循环
for epoch in range(10000):
    # 前向传播
    h = sigmoid(np.dot(X, W1) + b1)
    y_pred = sigmoid(np.dot(h, W2) + b2)

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

    # 反向传播
    dL_dy = y_pred - y_true
    dy_dW2 = sigmoid_derivative(y_pred) * h
    dL_dW2 = np.dot(h.T, dL_dy * sigmoid_derivative(y_pred))

    dL_dh = np.dot(dL_dy * sigmoid_derivative(y_pred), W2.T)
    dh_dW1 = sigmoid_derivative(h) * X
    dL_dW1 = np.dot(X.T, dL_dh * sigmoid_derivative(h))

    # 更新参数
    W1 -= 0.1 * dL_dW1
    W2 -= 0.1 * dL_dW2

print("Final predictions:", y_pred)

反向传播的计算复杂度主要取决于网络的大小和深度。对于一个有 (L) 层、每层 (n) 个神经元的网络，前向传播和反向传播的时间复杂度均为 (O(L \cdot n^2) )。

反向传播需要存储前向传播的中间结果（如激活值），这会导致内存消耗随网络深度线性增长。对于大型网络，内存可能成为瓶颈。