深度学习优化：Adam算法原理与实现 – wiki基地

作者： /

深度学习优化：Adam算法原理与实现

在深度学习模型训练过程中，优化器的选择对于模型的收敛速度和最终性能至关重要。梯度下降及其变种是这类优化的核心，而Adam（Adaptive Moment Estimation）算法凭借其出色的性能和广泛的适用性，已成为当今最流行的深度学习优化器之一。本文将深入探讨Adam算法的原理、优势以及如何在实际中实现它。

1. 梯度下降的挑战与改进

在理解Adam之前，我们先回顾一下标准梯度下降（SGD）及其常见变种所面临的挑战：

  • 学习率选择困难：SGD需要手动设置一个全局学习率，过大可能导致震荡不收敛，过小则收敛缓慢。
  • 对稀疏梯度不友好：对于具有稀疏梯度的特征（例如在NLP任务中），SGD更新可能非常慢。
  • 易陷入局部最优：SGD可能在损失函数的鞍点或平坦区域停滞。
  • 无法自适应调整：学习率对所有参数都是一样的，而不同参数可能需要不同的学习率。

为了解决这些问题，人们提出了许多改进算法：

  • Momentum（动量）：引入历史梯度信息，平滑更新方向，加速收敛，并有助于跳出局部最优。
  • Adagrad（Adaptive Gradient）：根据参数的历史梯度平方和自适应地调整学习率，对不常更新的参数给予更大的学习率，对常更新的参数给予更小的学习率。但缺点是学习率会持续衰减，最终可能变得非常小以至于停止学习。
  • RMSprop（Root Mean Square Propagation）：改进了Adagrad，使用指数加权移动平均来限制历史梯度平方和的累积，从而避免学习率过快衰减的问题。
  • Adadelta：进一步改进Adagrad，除了累积历史梯度平方，还累积历史更新量的平方，无需手动设置全局学习率。

2. Adam算法的核心原理

Adam算法结合了Momentum和RMSprop的优点，它为每个参数维护了两个指数加权移动平均：

  1. 一阶矩估计（均值，即梯度的指数加权移动平均）：类似于Momentum，用于捕获梯度的方向性。
  2. 二阶矩估计（未中心化的方差，即梯度平方的指数加权移动平均）：类似于RMSprop，用于自适应地调整每个参数的学习率。

2.1 一阶矩估计（Momentum项）

对于在时间步 t 的梯度 g_t，一阶矩估计 m_t 计算如下：

m_t = β₁ * m_{t-1} + (1 - β₁) * g_t

其中，β₁ 是控制 m_t 中历史梯度贡献的超参数，通常设置为 0.9。m_0 初始化为 0。

2.2 二阶矩估计（RMSprop项）

二阶矩估计 v_t 计算如下：

v_t = β₂ * v_{t-1} + (1 - β₂) * g_t²

其中，g_t² 表示梯度的平方（逐元素），β₂ 是控制 v_t 中历史梯度平方贡献的超参数，通常设置为 0.999。v_0 初始化为 0。

2.3 偏差修正（Bias Correction）

由于 m_0 和 v_0 初始化为 0，在训练初期，m_t 和 v_t 会偏向于 0，导致更新不准确。为了解决这个问题，Adam引入了偏差修正：

m̂_t = m_t / (1 - β₁^t)
v̂_t = v_t / (1 - β₂^t)

这里，β₁^t 和 β₂^t 分别是 β₁ 和 β₂ 的 t 次方。随着 t 的增加，1 - β₁^t 和 1 - β₂^t 会趋近于 1，偏差修正的影响逐渐减小。

2.4 参数更新

最后，Adam算法使用修正后的一阶和二阶矩估计来更新参数 θ：

θ_{t+1} = θ_t - α * m̂_t / (√v̂_t + ε)

其中：
* α 是全局学习率（通常设置为 0.001）。
* ε 是一个非常小的常数（例如 10^-8），用于避免除以零。
* √v̂_t 逐元素计算修正后的二阶矩估计的平方根。

3. Adam算法的优势

  • 自适应学习率：为每个参数独立计算和调整学习率，能够更好地处理稀疏梯度和不同尺度的特征。
  • 结合动量：通过一阶矩估计，利用历史梯度信息，加速收敛并减少震荡。
  • 偏差修正：解决了初始化为零的矩估计在训练初期带来的偏差问题，使算法更加稳定。
  • 鲁棒性强：对超参数的选择相对不敏感，在大多数情况下都能取得良好的性能。
  • 高效：计算开销相对较低，每次更新只需要存储两个额外的变量（m和v）。

4. Adam算法的实现

Adam算法在各种深度学习框架中都有现成的实现，例如TensorFlow、PyTorch、Keras等。然而，理解其底层实现有助于我们更好地掌握其工作原理。

以下是一个简化的Python/NumPy实现示例：

“`python
import numpy as np

class AdamOptimizer:
def init(self, learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8):
self.learning_rate = learning_rate
self.beta1 = beta1
self.beta2 = beta2
self.epsilon = epsilon
self.m = {} # Dictionary to store first moment estimates for each parameter
self.v = {} # Dictionary to store second moment estimates for each parameter
self.t = 0 # Time step

def update(self, params, grads):
    self.t += 1
    updated_params = {}

    for param_name in params:
        # Initialize m and v for the current parameter if not already present
        if param_name not in self.m:
            self.m[param_name] = np.zeros_like(params[param_name])
            self.v[param_name] = np.zeros_like(params[param_name])

        grad = grads[param_name]

        # Update biased first and second moment estimates
        self.m[param_name] = self.beta1 * self.m[param_name] + (1 - self.beta1) * grad
        self.v[param_name] = self.beta2 * self.v[param_name] + (1 - self.beta2) * (grad ** 2)

        # Bias correction
        m_hat = self.m[param_name] / (1 - self.beta1 ** self.t)
        v_hat = self.v[param_name] / (1 - self.beta2 ** self.t)

        # Update parameters
        updated_params[param_name] = params[param_name] - \
                                     self.learning_rate * m_hat / (np.sqrt(v_hat) + self.epsilon)

    return updated_params

— 示例用法 —

if name == “main“:
# 假设我们有一个简单的模型参数
parameters = {
‘W1’: np.array([[0.1, 0.2], [0.3, 0.4]]),
‘b1’: np.array([0.01, 0.02])
}

# 假设我们计算出了梯度
gradients = {
    'W1': np.array([[0.01, -0.02], [0.03, -0.04]]),
    'b1': np.array([-0.005, 0.008])
}

adam = AdamOptimizer(learning_rate=0.01)

print("Initial Parameters:")
print("W1:\n", parameters['W1'])
print("b1:\n", parameters['b1'])

# 模拟多次更新
for i in range(5):
    print(f"\n--- Update Step {i+1} ---")
    parameters = adam.update(parameters, gradients) # 实际中梯度会在每次迭代重新计算
    print("Updated W1:\n", parameters['W1'])
    print("Updated b1:\n", parameters['b1'])
    # 在实际训练中，这里的gradients会是新的梯度
    # 为了演示，我们暂时保持梯度不变，但实际模型训练中，梯度会根据新的参数和数据重新计算

“`

代码解释：

  1. __init__: 初始化学习率、beta参数、epsilon以及用于存储一阶/二阶矩估计的字典 m 和 v。t 用于跟踪时间步。
  2. update(params, grads):
    • self.t 增加，表示进入一个新的时间步。
    • 遍历模型中的每个参数（param_name）。
    • 如果某个参数的 m 和 v 还没有初始化，则将其初始化为与参数形状相同的零数组。
    • 根据梯度 grad 更新 m[param_name] (一阶矩) 和 v[param_name] (二阶矩)。
    • 执行偏差修正，得到 m_hat 和 v_hat。
    • 使用修正后的矩估计来计算参数的更新量，并更新 params[param_name]。
    • 返回更新后的参数字典。

5. Adam的变种与注意事项

尽管Adam表现优异，但它并非完美。有一些研究表明，Adam在某些情况下可能无法收敛到全局最优，或者其泛化能力不如SGD。因此，出现了一些Adam的变种：

  • AdamW：针对Adam的权重衰减（L2正则化）问题进行了修正。在Adam中，权重衰减通常与学习率相乘后加到梯度上，但由于Adam的自适应学习率，这会导致不同参数的权重衰减效果不同。AdamW将权重衰减从梯度更新中分离出来，直接应用于参数，从而获得更好的正则化效果。
  • NAdam：结合了Adam和Nesterov加速梯度（NAG）的优点，通过在计算梯度时考虑“前瞻性”的参数，进一步加速收敛。
  • AMSGrad：解决了Adam在某些非凸优化问题上可能出现的收敛性问题，通过限制 v_t 的非递减性来确保更稳定的二阶矩估计。

使用Adam时的注意事项：

  • 超参数调优：尽管Adam对超参数相对不敏感，但 learning_rate、beta1 和 beta2 仍然可以通过网格搜索或随机搜索进行微调，以获得最佳性能。
  • 学习率调度：结合学习率衰减策略（如余弦退火、步长衰减等）可以进一步提高Adam的性能和泛化能力。
  • 权重衰减：对于Adam优化器，推荐使用AdamW而不是简单的L2正则化，以获得更一致的正则化效果。

结论

Adam算法以其结合动量和自适应学习率的优雅机制，成为了深度学习领域的主流优化器。它有效地解决了传统梯度下降方法面临的诸多挑战，加速了模型的训练过程，并提高了模型的收敛性和泛化能力。通过理解其核心原理和实现细节，开发者能够更好地应用和调优Adam，从而在各种深度学习任务中取得更好的效果。随着研究的深入，Adam及其变种将继续在人工智能的发展中扮演关键角色。

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部