BP神经网络的正向传播与反向传播：原理详解与高效实现

1次阅读

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

BP 神经网络（Backpropagation Neural Network）是深度学习的基础，广泛应用于分类、回归等任务。它通过正向传播计算输出，反向传播调整权重，实现模型的自我优化。理解 BP 网络的正向传播和反向传播机制，是掌握深度学习的关键一步。

正向传播是指输入数据通过网络层层传递，最终得到输出的过程。以一个简单的三层网络（输入层、隐藏层、输出层）为例：

输入层到隐藏层 ：
$$
z^{(1)} = W^{(1)}x + b^{(1)}
$$
$$
a^{(1)} = f(z^{(1)})
$$
其中，$W^{(1)}$ 是权重矩阵，$b^{(1)}$ 是偏置向量，$f$ 是激活函数（如 Sigmoid、ReLU）。
隐藏层到输出层 ：
$$
z^{(2)} = W^{(2)}a^{(1)} + b^{(2)}
$$
$$
a^{(2)} = g(z^{(2)})
$$
这里，$g$ 通常是 Softmax（分类任务）或恒等函数（回归任务）。

反向传播通过链式法则计算损失函数对权重的梯度，用于更新权重：

输出层误差 ：
$$
\delta^{(2)} = \frac{\partial L}{\partial a^{(2)}} \cdot g'(z^{(2)})
$$
隐藏层误差 ：
$$
\delta^{(1)} = (W^{(2)})^T \delta^{(2)} \cdot f'(z^{(1)})
$$
权重更新 ：
$$
\frac{\partial L}{\partial W^{(2)}} = \delta^{(2)} (a^{(1)})^T
$$
$$
\frac{\partial L}{\partial W^{(1)}} = \delta^{(1)} x^T
$$

使用 NumPy 可以高效实现矩阵运算，提升计算速度：

import numpy as np

# 初始化参数
def initialize_parameters(input_size, hidden_size, output_size):
    W1 = np.random.randn(hidden_size, input_size) * 0.01
    b1 = np.zeros((hidden_size, 1))
    W2 = np.random.randn(output_size, hidden_size) * 0.01
    b2 = np.zeros((output_size, 1))
    return {'W1': W1, 'b1': b1, 'W2': W2, 'b2': b2}

# 正向传播
def forward_propagation(X, parameters):
    W1, b1, W2, b2 = parameters['W1'], parameters['b1'], parameters['W2'], parameters['b2']
    Z1 = np.dot(W1, X) + b1
    A1 = np.tanh(Z1)  # 使用 tanh 激活函数
    Z2 = np.dot(W2, A1) + b2
    A2 = 1 / (1 + np.exp(-Z2))  # 使用 Sigmoid 激活函数
    return {'Z1': Z1, 'A1': A1, 'Z2': Z2, 'A2': A2}

# 反向传播
def backward_propagation(X, Y, parameters, cache):
    m = X.shape[1]
    W1, W2 = parameters['W1'], parameters['W2']
    A1, A2 = cache['A1'], cache['A2']

    dZ2 = A2 - Y
    dW2 = (1 / m) * np.dot(dZ2, A1.T)
    db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)
    dZ1 = np.dot(W2.T, dZ2) * (1 - np.power(A1, 2))
    dW1 = (1 / m) * np.dot(dZ1, X.T)
    db1 = (1 / m) * np.sum(dZ1, axis=1, keepdims=True)

    return {'dW1': dW1, 'db1': db1, 'dW2': dW2, 'db2': db2}

梯度检查是验证反向传播实现正确性的重要手段：

def gradient_check(parameters, gradients, X, Y, epsilon=1e-7):
    parameters_values = parameters.flatten()
    grad = gradients.flatten()
    num_parameters = parameters_values.shape[0]
    J_plus = np.zeros((num_parameters, 1))
    J_minus = np.zeros((num_parameters, 1))
    gradapprox = np.zeros((num_parameters, 1))

    for i in range(num_parameters):
        theta_plus = np.copy(parameters_values)
        theta_plus[i] += epsilon
        J_plus[i] = compute_cost(X, Y, theta_plus)

        theta_minus = np.copy(parameters_values)
        theta_minus[i] -= epsilon
        J_minus[i] = compute_cost(X, Y, theta_minus)

        gradapprox[i] = (J_plus[i] - J_minus[i]) / (2 * epsilon)

    numerator = np.linalg.norm(grad - gradapprox)
    denominator = np.linalg.norm(grad) + np.linalg.norm(gradapprox)
    difference = numerator / denominator

    if difference > 1e-7:
        print("梯度检查失败！")
    else:
        print("梯度检查通过！")

学习率过大可能导致震荡，过小则收敛缓慢。建议：