BP神经网络梯度下降链式法则：从数学原理到Python实现

1次阅读

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

在神经网络中，前向传播（Forward Propagation）是指输入数据通过网络的每一层，最终得到输出结果的过程。对于一个简单的单隐藏层全连接网络，前向传播可以表示为：

$$
\begin{aligned}
z^{[1]} &= W^{[1]} X + b^{[1]} \
a^{[1]} &= \sigma(z^{[1]}) \
z^{[2]} &= W^{[2]} a^{[1]} + b^{[2]} \
a^{[2]} &= \sigma(z^{[2]})
\end{aligned}
$$

其中，$X$ 是输入数据，$W^{[1]}$ 和 $W^{[2]}$ 是权重矩阵，$b^{[1]}$ 和 $b^{[2]}$ 是偏置向量，$\sigma$ 是激活函数（如 Sigmoid）。

前向传播虽然直观，但它无法告诉我们如何调整权重和偏置以最小化损失函数。这就是反向传播（Backpropagation）的作用——通过计算损失函数对权重和偏置的梯度，指导我们如何更新参数。

反向传播的核心是链式法则（Chain Rule），它允许我们逐层计算梯度。以一个单隐藏层网络为例，假设损失函数为均方误差（MSE）：

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

我们需要计算损失函数对权重和偏置的梯度。以下是具体的推导步骤：

首先计算损失函数对输出层激活值 $a^{[2]}$ 的梯度：

$$
\frac{\partial L}{\partial a^{[2]}} = a^{[2]} – y
$$

接下来，计算 $a^{[2]}$ 对 $z^{[2]}$ 的梯度（即 Sigmoid 函数的导数）：

$$
\frac{\partial a^{[2]}}{\partial z^{[2]}} = \sigma'(z^{[2]}) = a^{[2]} (1 – a^{[2]})
$$

然后，通过链式法则计算损失函数对 $z^{[2]}$ 的梯度：

$$
\frac{\partial L}{\partial z^{[2]}} = \frac{\partial L}{\partial a^{[2]}} \cdot \frac{\partial a^{[2]}}{\partial z^{[2]}} = (a^{[2]} – y) \cdot a^{[2]} (1 – a^{[2]})
$$

接下来，计算损失函数对隐藏层激活值 $a^{[1]}$ 的梯度：

$$
\frac{\partial L}{\partial a^{[1]}} = \frac{\partial L}{\partial z^{[2]}} \cdot \frac{\partial z^{[2]}}{\partial a^{[1]}} = \frac{\partial L}{\partial z^{[2]}} \cdot W^{[2]}
$$

然后，计算 $a^{[1]}$ 对 $z^{[1]}$ 的梯度：

$$
\frac{\partial a^{[1]}}{\partial z^{[1]}} = \sigma'(z^{[1]}) = a^{[1]} (1 – a^{[1]})
$$

最后，计算损失函数对 $z^{[1]}$ 的梯度：

$$
\frac{\partial L}{\partial z^{[1]}} = \frac{\partial L}{\partial a^{[1]}} \cdot \frac{\partial a^{[1]}}{\partial z^{[1]}} = \frac{\partial L}{\partial a^{[1]}} \cdot a^{[1]} (1 – a^{[1]})
$$

有了上述梯度后，我们可以计算损失函数对权重和偏置的梯度：

$$
\frac{\partial L}{\partial W^{[2]}} = \frac{\partial L}{\partial z^{[2]}} \cdot a^{[1]}
$$

$$
\frac{\partial L}{\partial b^{[2]}} = \frac{\partial L}{\partial z^{[2]}}
$$

$$
\frac{\partial L}{\partial W^{[1]}} = \frac{\partial L}{\partial z^{[1]}} \cdot X
$$

$$
\frac{\partial L}{\partial b^{[1]}} = \frac{\partial L}{\partial z^{[1]}}
$$

以下是使用 NumPy 实现上述反向传播算法的代码：

import numpy as np

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

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

# 初始化参数
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 = sigmoid(Z1)
    Z2 = np.dot(W2, A1) + b2
    A2 = sigmoid(Z2)

    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)

    dA1 = np.dot(W2.T, dZ2)
    dZ1 = dA1 * sigmoid_derivative(A1)
    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 update_parameters(parameters, grads, learning_rate=0.01):
    W1 = parameters['W1'] - learning_rate * grads['dW1']
    b1 = parameters['b1'] - learning_rate * grads['db1']
    W2 = parameters['W2'] - learning_rate * grads['dW2']
    b2 = parameters['b2'] - learning_rate * grads['db2']

    return {'W1': W1, 'b1': b1, 'W2': W2, 'b2': b2}

# 训练循环
def train(X, Y, hidden_size, num_iterations=1000, learning_rate=0.01):
    input_size = X.shape[0]
    output_size = Y.shape[0]

    parameters = initialize_parameters(input_size, hidden_size, output_size)

    for i in range(num_iterations):
        # 前向传播
        cache = forward_propagation(X, parameters)

        # 计算损失
        A2 = cache['A2']
        loss = np.mean((A2 - Y) ** 2) / 2

        # 反向传播
        grads = backward_propagation(X, Y, parameters, cache)

        # 更新参数
        parameters = update_parameters(parameters, grads, learning_rate)

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

    return parameters

梯度消失（Vanishing Gradient）是指在某些情况下，梯度会变得非常小，导致权重更新几乎停滞。这通常发生在使用 Sigmoid 或 Tanh 激活函数的深层网络中。