深度学习之-“深入理解梯度下降”

发布于：2025-03-07 ⋅ 阅读:(14) ⋅ 点赞:(0)

梯度下降是机器学习和深度学习的核心优化算法，几乎所有的模型训练都离不开它。然而，梯度下降并不是一个单一的算法，而是一个庞大的家族，包含了许多变体和改进方法。本文将从最基础的梯度下降开始，逐步深入学习，并通过代码进一步理解每个算法的实现细节。

梯度下降的基本原理

梯度下降的核心思想是通过迭代的方式，沿着目标函数的负梯度方向逐步调整参数，最终找到函数的最小值。这个过程可以类比为一个盲人下山的过程：盲人无法看到整个山的地形，但可以通过脚下的坡度来判断下山的方向，并一步步向山脚移动。

一维梯度下降

让我们从一个简单的例子开始：一维函数 f(x)=x^2。这个函数的导数为 f′(x)=2x，因此梯度下降的更新规则为：
在这里插入图片描述

其中，η是学习率，控制着每一步的步长。以下是一个简单的 Python 实现：

def gradient_descent_1d(start, lr=0.1, epochs=100):
    x = start
    history = []
    for _ in range(epochs):
        grad = 2 * x  # 计算梯度
        x -= lr * grad  # 更新参数
        history.append(x)
    return history

# 测试
start_value = 10.0
learning_rate = 0.1
result = gradient_descent_1d(start_value, lr=learning_rate, epochs=50)
print("最终结果:", result[-1])

在这个例子中，我们从初始值 x=10.0开始，经过 50 次迭代后，x的值会逐渐趋近于 0，即函数的最小值。
在这里插入图片描述

其中，学习率的选择对结果有重要影响，过大的学习率可能导致震荡，而过小的学习率则会导致收敛速度过慢。

二维梯度下降

接下来，我们考虑一个二维函数 f(x,y)=x2+2y2。这个函数的梯度为 ∇f=[2x,4y]，因此梯度下降的更新规则为：
在这里插入图片描述

以下是二维梯度下降的 Python 实现：

def gradient_descent_2d(start, lr=0.1, epochs=100):
    x, y = start
    history = []
    for _ in range(epochs):
        grad_x = 2 * x  # x 方向的梯度
        grad_y = 4 * y  # y 方向的梯度
        x -= lr * grad_x  # 更新 x
        y -= lr * grad_y  # 更新 y
        history.append((x, y))
    return history

# 测试
start_value = (5.0, 5.0)
learning_rate = 0.1
result = gradient_descent_2d(start_value, lr=learning_rate, epochs=50)
print("最终结果:", result[-1])

运行结果如下：
在这里插入图片描述

在这个例子中，我们可以看到梯度下降在不同维度上的收敛速度是不同的。由于y方向的梯度是x方向的两倍，因此在y方向上的收敛速度会更快。这种差异在某些情况下会导致优化路径呈现出椭圆形的轨迹。

随机梯度下降（SGD）

在实际的机器学习问题中，目标函数通常是基于大量数据的损失函数。传统的梯度下降需要计算整个数据集的梯度，这在数据量较大时会变得非常耗时。为了解决这个问题，随机梯度下降（Stochastic Gradient Descent, SGD）应运而生。

SGD 的基本原理

SGD 的核心思想是每次迭代只使用一个随机样本或一个小批量样本来估计梯度。虽然这种估计会引入噪声，但它在实践中通常能够显著加快收敛速度，尤其是在大规模数据集上。
以下是 SGD 的 Python 实现：

import numpy as np

def sgd(data, start, lr=0.1, epochs=100, batch_size=1):
    x, y = start
    history = []
    n_samples = len(data)
    for _ in range(epochs):
        # 随机打乱数据
        np.random.shuffle(data)
        for i in range(0, n_samples, batch_size):
            batch = data[i:i + batch_size]
            grad_x = 2 * x  # 假设梯度计算
            grad_y = 4 * y  # 假设梯度计算
            x -= lr * grad_x  # 更新 x
            y -= lr * grad_y  # 更新 y
            history.append((x, y))
    return history

# 测试
data = np.random.randn(100, 2)  # 生成随机数据
start_value = (5.0, 5.0)
learning_rate = 0.1
result = sgd(data, start_value, lr=learning_rate, epochs=10, batch_size=10)
print("最终结果:", result[-1])

运行结果如下：
在这里插入图片描述

SGD 的优缺点

SGD 的主要优点是计算效率高，尤其是在大规模数据集上。然而，由于每次迭代只使用部分数据，SGD 的更新方向可能会引入较大的噪声，导致收敛路径不稳定。为了缓解这个问题，通常会采用学习率衰减策略，即在训练过程中逐渐减小学习率。

动量机制

尽管 SGD 在大规模数据上表现良好，但它仍然存在一些问题，尤其是在优化路径中存在大量震荡或噪声时。为了改善这种情况，动量机制（Momentum）被引入到梯度下降中。

动量的基本原理

动量机制的核心思想是引入一个速度变量，使得参数更新不仅依赖于当前的梯度，还依赖于之前的速度。具体来说，动量机制的更新规则为：
在这里插入图片描述

其中，γ是动量系数，通常取值在 0.9 左右。当γ=0时，退化为普通的SGD。以下是动量机制的 Python 实现：

def momentum(start, lr=0.1, gamma=0.9, epochs=100):
    x, y = start
    vx, vy = 0, 0  # 初始化速度
    history = []
    for _ in range(epochs):
        grad_x = 2 * x  # 计算梯度
        grad_y = 4 * y
        vx = gamma * vx + lr * grad_x  # 更新速度
        vy = gamma * vy + lr * grad_y
        x -= vx  # 更新参数
        y -= vy
        history.append((x, y))
    return history

# 测试
start_value = (5.0, 5.0)
learning_rate = 0.1
momentum_coeff = 0.9
result = momentum(start_value, lr=learning_rate, gamma=momentum_coeff, epochs=100)
print("最终结果:", result[-1])

运行结果如下：
在这里插入图片描述

涅斯捷洛夫动量

涅斯捷洛夫动量（Nesterov Momentum）是动量机制的一个改进版本。它的核心思想是先根据当前的速度预估未来的参数位置，然后在该位置计算梯度。这种前瞻性的梯度计算能够进一步提高收敛速度。具体来说，其更新规则为：
在这里插入图片描述

以下是涅斯捷洛夫动量的 Python 实现：

import numpy as np

def nesterov_momentum(gradient, theta_init, learning_rate=0.1, momentum=0.9, num_iters=100):
    """
    涅斯捷洛夫动量梯度下降算法实现

    参数:
    - gradient: 梯度函数，接受参数 theta，返回梯度值
    - theta_init: 初始参数值
    - learning_rate: 学习率 (默认 0.1)
    - momentum: 动量系数 (默认 0.9)
    - num_iters: 迭代次数 (默认 100)

    返回:
    - theta_history: 参数更新历史
    - loss_history: 损失函数值历史
    """
    theta = theta_init  # 初始化参数
    v = np.zeros_like(theta)  # 初始化速度
    theta_history = [theta.copy()]  # 记录参数更新历史
    loss_history = []  # 记录损失函数值历史

    for i in range(num_iters):
        # 计算前瞻位置的梯度
        lookahead_theta = theta + momentum * v
        grad = gradient(lookahead_theta)

        # 更新速度
        v = momentum * v - learning_rate * grad

        # 更新参数
        theta += v

        # 记录历史
        theta_history.append(theta.copy())
        loss = theta[0]**2 + 2 * theta[1]**2  # 计算损失函数值
        loss_history.append(loss)

    return theta_history, loss_history

# 定义目标函数的梯度
def gradient_function(theta):
    x, y = theta
    return np.array([2 * x, 4 * y])

# 初始参数值
theta_init = np.array([5.0, 5.0])  # 初始点 (x, y) = (5, 5)

# 运行涅斯捷洛夫动量梯度下降
theta_history, loss_history = nesterov_momentum(gradient_function, theta_init, learning_rate=0.1, momentum=0.9, num_iters=50)

# 输出结果
print("最终参数值:", theta_history[-1])
print("最终损失值:", loss_history[-1])

# 可视化损失函数值的变化
import matplotlib.pyplot as plt
plt.plot(loss_history)
plt.xlabel("Iteration")
plt.ylabel("Loss")
plt.title("Loss over Iterations")
plt.show()

运行结果如下：
在这里插入图片描述
绘制出的loss曲线如下：
在这里插入图片描述

自适应梯度下降

随着深度学习模型的复杂性不断增加，传统的梯度下降方法在某些情况下可能表现不佳。为了应对这一问题，自适应梯度下降方法应运而生。这些方法通过动态调整每个参数的学习率，使得优化过程更加高效。

RMSprop

RMSprop 是一种常用的自适应梯度下降方法，它通过维护一个指数衰减的梯度平方均值来调整学习率。以下是 RMSprop 的 Python 实现：

def rmsprop(start, lr=0.1, decay_rate=0.9, eps=1e-8, epochs=100):
    x, y = start
    cache_x, cache_y = 0, 0  # 初始化缓存
    history = []
    for _ in range(epochs):
        grad_x = 2 * x  # 计算梯度
        grad_y = 4 * y
        cache_x = decay_rate * cache_x + (1 - decay_rate) * grad_x ** 2  # 更新缓存
        cache_y = decay_rate * cache_y + (1 - decay_rate) * grad_y ** 2
        x -= lr * grad_x / (np.sqrt(cache_x) + eps)  # 更新参数
        y -= lr * grad_y / (np.sqrt(cache_y) + eps)
        history.append((x, y))
    return history

# 测试
start_value = (5.0, 5.0)
learning_rate = 0.1
decay_rate = 0.9
result = rmsprop(start_value, lr=learning_rate, decay_rate=decay_rate, epochs=100)
print("最终结果:", result[-1])

运行结果如下：
在这里插入图片描述

Adam

Adam（Adaptive Moment Estimation）是目前最流行的自适应梯度下降方法之一。它结合了动量机制和 RMSprop 的优点，通过维护两个指数衰减的均值来调整学习率。以下是 Adam 的 Python 实现：

def adam(start, lr=0.001, beta1=0.9, beta2=0.999, eps=1e-8, epochs=100):
    x, y = start
    m_x, m_y = 0, 0  # 初始化一阶矩
    v_x, v_y = 0, 0  # 初始化二阶矩
    history = []
    for t in range(1, epochs + 1):
        grad_x = 2 * x  # 计算梯度
        grad_y = 4 * y
        m_x = beta1 * m_x + (1 - beta1) * grad_x  # 更新一阶矩
        m_y = beta1 * m_y + (1 - beta1) * grad_y
        v_x = beta2 * v_x + (1 - beta2) * grad_x ** 2  # 更新二阶矩
        v_y = beta2 * v_y + (1 - beta2) * grad_y ** 2
        # 偏差修正
        m_x_hat = m_x / (1 - beta1 ** t)
        m_y_hat = m_y / (1 - beta1 ** t)
        v_x_hat = v_x / (1 - beta2 ** t)
        v_y_hat = v_y / (1 - beta2 ** t)
        x -= lr * m_x_hat / (np.sqrt(v_x_hat) + eps)  # 更新参数
        y -= lr * m_y_hat / (np.sqrt(v_y_hat) + eps)
        history.append((x, y))
    return history

# 测试
start_value = (5.0, 5.0)
learning_rate = 0.1
result = adam(start_value, lr=learning_rate, epochs=100)
print("最终结果:", result[-1])

运行结果如下：
在这里插入图片描述
可见Adam的收敛速度较慢。将epochs改为500，运行结果如下：
在这里插入图片描述

优化器选择指南

优化器的选择与特定的数据集有关。对于大多数的深度学习任务，Adam表现良好。但有时候，使用SGD也能调试出很好的结果。下面是关于优化器选择的总结：

优化器 优点 缺点 适用场景
SGD 简单、易于调参 收敛慢、易陷入局部最优 小数据集、简单任务
SGD+Momentum 加速收敛、减少振荡 需要调参 大数据集、复杂任务
NAG 比 Momentum 更快收敛 实现稍复杂 需要快速收敛的任务
Adam 自适应学习率、默认参数表现良好 可能在某些任务上过拟合 大多数深度学习任务
RMSProp 自适应学习率、适合非平稳目标 需要调参 RNN、非平稳目标函数
Adagrad 适合稀疏数据 学习率单调下降、可能过早停止 稀疏数据集（如 NLP）
Adadelta 无需设置初始学习率 收敛速度较慢 需要自适应学习率且不想调参的场景

总结

梯度下降作为机器学习和深度学习的核心优化算法，经历了从基础到现代的不断演进。从最简单的梯度下降，到随机梯度下降、动量机制，再到自适应梯度下降方法，每一步的改进都使得优化过程更加高效和稳定。
在实际应用中，选择合适的优化算法需要根据具体问题的特点来决定。对于简单的凸优化问题，传统的梯度下降或动量机制可能已经足够；而对于复杂的深度学习模型，Adam 等自适应方法则往往能够提供更好的性能。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布