深度学习入门：从零实现BP算法及其关键细节解析

1次阅读

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

神经网络的训练本质上是通过调整权重参数，使得网络的输出尽可能接近真实值。这个过程需要两个关键步骤：前向传播（Forward Propagation）和反向传播（Backpropagation，简称 BP）。前向传播负责计算网络的预测输出，而反向传播则通过计算损失函数的梯度来更新权重。BP 算法是整个训练过程的核心，它利用链式法则高效地计算梯度，是深度学习能够成功的关键之一。

BP 算法的核心数学工具是链式法则。链式法则告诉我们，复合函数的导数可以通过各层函数的导数相乘得到。在神经网络中，损失函数通常是多层复合函数的结果，因此链式法则非常适合用来计算梯度。

举个例子，假设我们有一个简单的两层神经网络，其中每层的激活函数为 Sigmoid。损失函数可以表示为：

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

其中，$\hat{y}$ 是网络的输出，$y$ 是真实值。我们需要计算损失函数对权重 $w$ 的梯度 $\frac{\partial L}{\partial w}$。通过链式法则，我们可以将梯度分解为：

$$
\frac{\partial L}{\partial w} = \frac{\partial L}{\partial \hat{y}} \cdot \frac{\partial \hat{y}}{\partial z} \cdot \frac{\partial z}{\partial w}
$$

其中，$z$ 是神经元的加权输入。这种分解方式使得我们可以逐层计算梯度，从而高效地更新权重。

在深层网络中，梯度消失和爆炸是常见的问题。梯度消失指的是在反向传播过程中，梯度逐渐变小，导致深层网络的权重更新非常缓慢，甚至停止学习。梯度爆炸则相反，梯度变得非常大，导致权重更新幅度过大，网络无法收敛。

梯度消失问题在使用 Sigmoid 激活函数时尤为明显，因为 Sigmoid 函数的导数最大值仅为 0.25，当多层叠加时，梯度会指数级减小。梯度爆炸通常发生在权重初始化过大时，梯度在反向传播过程中不断放大。

以下是一个用 NumPy 实现的双层神经网络，包含前向传播和反向传播的完整代码。代码中使用了 Sigmoid 激活函数，并详细注释了每一步的梯度计算过程。

import numpy as np
import matplotlib.pyplot as plt

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

def sigmoid_derivative(x):
    return sigmoid(x) * (1 - sigmoid(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 compute_loss(A2, Y):
    m = Y.shape[1]
    loss = np.sum((A2 - Y) ** 2) / (2 * m)
    return loss

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

    # 输出层的梯度
    dZ2 = (A2 - Y) * sigmoid_derivative(Z2)
    dW2 = np.dot(dZ2, A1.T) / m
    db2 = np.sum(dZ2, axis=1, keepdims=True) / m

    # 隐藏层的梯度
    dA1 = np.dot(W2.T, dZ2)
    dZ1 = dA1 * sigmoid_derivative(Z1)
    dW1 = np.dot(dZ1, X.T) / m
    db1 = np.sum(dZ1, axis=1, keepdims=True) / m

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

# 更新参数
def update_parameters(parameters, grads, learning_rate):
    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, learning_rate, epochs):
    input_size = X.shape[0]
    output_size = Y.shape[0]
    parameters = initialize_parameters(input_size, hidden_size, output_size)
    losses = []

    for i in range(epochs):
        # 前向传播
        cache = forward_propagation(X, parameters)
        loss = compute_loss(cache["A2"], Y)
        losses.append(loss)

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

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

    return parameters, losses

# 生成模拟数据
X = np.random.randn(2, 100)
Y = np.random.randn(1, 100)

# 训练网络
parameters, losses = train(X, Y, hidden_size=4, learning_rate=0.1, epochs=1000)

# 绘制损失曲线
plt.plot(losses)
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.title("Training Loss")
plt.show()

学习率是训练神经网络时最重要的超参数之一。过大的学习率可能导致网络无法收敛，而过小的学习率则会使训练过程非常缓慢。学习率衰减是一种常见的优化技巧，随着训练的进行，逐渐减小学习率，以更精细地调整权重。

Xavier 初始化是一种权重初始化方法，特别适合 Sigmoid 和 Tanh 激活函数。它的基本思想是根据输入和输出的维度来调整初始权重的范围，以避免梯度消失或爆炸。Xavier 初始化的公式为：

$$
W \sim \mathcal{N}(0, \sqrt{\frac{2}{n_{in} + n_{out}}})
$$

其中，$n_{in}$ 和 $n_{out}$ 分别是权重矩阵的输入和输出维度。

梯度校验（Gradient Checking）是一种验证反向传播实现是否正确的方法。它的基本思想是通过数值逼近的方式计算梯度，然后与反向传播计算的梯度进行比较。如果两者接近，则说明反向传播的实现是正确的。

梯度校验的实现步骤如下：