深入解析BP神经网络中的梯度下降：从数学原理到实现优化

1次阅读

没有评论

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

BP 神经网络通过误差反向传播算法（Backpropagation）来训练网络权重，而梯度下降则是这一过程的核心优化算法。在实际训练中，我们常常会遇到以下问题：

收敛速度慢：尤其当学习率设置不当时，训练过程可能需要大量迭代才能收敛。
局部最优：梯度下降容易陷入局部最优解，尤其是在非凸优化问题中。
梯度消失 / 爆炸：深层网络中，梯度可能在反向传播过程中变得极小或极大，导致训练困难。

梯度下降的核心思想是通过迭代调整参数，使损失函数最小化。其更新规则为：

$$\theta_{t+1} = \theta_t – \eta \cdot \nabla_\theta J(\theta)$$

其中，$\theta$ 表示网络参数，$\eta$ 为学习率，$\nabla_\theta J(\theta)$ 是损失函数 $J$ 关于参数 $\theta$ 的梯度。

在 BP 神经网络中，梯度计算通过链式法则实现。以单隐层网络为例，权重更新公式为：

$$\frac{\partial J}{\partial w_{ij}} = \frac{\partial J}{\partial y} \cdot \frac{\partial y}{\partial z} \cdot \frac{\partial z}{\partial w_{ij}}$$

其中，$y$ 是输出，$z$ 是隐藏层激活值。

SGD 是最基础的优化算法，每次迭代使用单个样本计算梯度。优点是计算量小，但缺点是梯度方向波动大。

$$\theta_{t+1} = \theta_t – \eta \cdot \nabla_\theta J(\theta; x_i, y_i)$$

Momentum 通过引入动量项来加速收敛，减少震荡：

$$v_t = \gamma v_{t-1} + \eta \nabla_\theta J(\theta)$$
$$\theta_{t+1} = \theta_t – v_t$$

RMSprop 通过调整学习率来适应不同参数：

$$E[g^2]t = \rho E[g^2] + (1-\rho)g_t^2$$
$$\theta_{t+1} = \theta_t – \frac{\eta}{\sqrt{E[g^2]_t + \epsilon}} g_t$$

Adam 结合了 Momentum 和 RMSprop 的优点：

$$m_t = \beta_1 m_{t-1} + (1-\beta_1)g_t$$
$$v_t = \beta_2 v_{t-1} + (1-\beta_2)g_t^2$$
$$\hat{m}t = \frac{m_t}{1-\beta_1^t}$$
$$\hat{v}_t = \frac{v_t}{1-\beta_2^t}$$
$$\theta_t$$} = \theta_t – \frac{\eta}{\sqrt{\hat{v}_t} + \epsilon} \hat{m

import numpy as np

def gradient_descent(X, y, learning_rate=0.01, epochs=100):
    n_samples, n_features = X.shape
    weights = np.zeros(n_features)

    for epoch in range(epochs):
        # 计算梯度
        gradient = -2/n_samples * X.T.dot(y - X.dot(weights))

        # 更新权重
        weights -= learning_rate * gradient

        # 打印损失
        if epoch % 10 == 0:
            loss = np.mean((y - X.dot(weights))**2)
            print(f'Epoch {epoch}, Loss: {loss:.4f}')

    return weights

class AdamOptimizer:
    def __init__(self, learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8):
        self.lr = learning_rate
        self.beta1 = beta1
        self.beta2 = beta2
        self.epsilon = epsilon
        self.m = None
        self.v = None
        self.t = 0

    def update(self, params, grads):
        if self.m is None:
            self.m = np.zeros_like(params)
            self.v = np.zeros_like(params)

        self.t += 1
        self.m = self.beta1 * self.m + (1 - self.beta1) * grads
        self.v = self.beta2 * self.v + (1 - self.beta2) * (grads**2)

        m_hat = self.m / (1 - self.beta1**self.t)
        v_hat = self.v / (1 - self.beta2**self.t)

        params -= self.lr * m_hat / (np.sqrt(v_hat) + self.epsilon)
        return params