从梯度下降到共轭梯度：图解机器学习优化算法的演进与选择

你是否曾经盯着一个复杂的损失函数，尝试用梯度下降法去优化，却发现训练过程要么慢如蜗牛，要么在某个“峡谷”地形里反复震荡，迟迟无法收敛？或者，当你尝试使用更高级的牛顿法时，又被其庞大的计算量和内存需求劝退？这几乎是每一位机器学习实践者在入门优化算法时都会遇到的经典困境。

今天，我们不打算从厚重的数学公式开始，而是换一种方式——用眼睛去看。我们将通过一系列直观的二维等高线图，像观察地形图一样，亲眼见证梯度下降、牛顿法和共轭梯度法这三种核心优化算法，是如何在不同的“地形”上寻找最低点的。我们的目标是帮你建立起一种几何直觉，让你在面对具体问题时，能像经验丰富的地质学家解读地图一样，快速判断哪种“登山策略”最有效。本文面向希望深入理解优化算法背后原理，并渴望获得实际选择能力的初学者。我们将结合简单的PyTorch线性回归实例，把抽象的算法转化为可操作的代码和可视化的轨迹。

1. 优化算法的“地形学”：建立几何直觉

在深入任何算法细节之前，我们必须先统一“语言”。在优化问题中，我们通常要最小化一个目标函数，比如机器学习中的损失函数。你可以把这个函数想象成一片起伏的山地，我们的目标是找到海拔最低的山谷（全局或局部最小值）。函数的梯度（一阶导数）指向了当前位置最陡峭的上升方向，因此，负梯度方向就是最速下降方向。函数的海森矩阵（二阶导数）则描述了这片地形的“弯曲”程度，比如是平坦的平原、陡峭的山脊，还是蜿蜒的峡谷。

理解这些“地形特征”对选择算法至关重要。我们来看两种典型的地形：

  • 鞍点地形：像一个马鞍，在一个方向上是山谷，在垂直方向上却是山脊。梯度下降法在这里会陷入停滞，因为梯度接近零，但远未到达真正的最低点。
  • 峡谷地形（或称病态条件地形）：想象一个又长又窄、底部平坦的峡谷。等高线是拉长的椭圆形。梯度方向几乎垂直于峡谷走向，导致算法在峡谷两壁来回“之字形”震荡，进展缓慢。

提示：优化算法的性能极大程度上取决于损失函数地形的几何性质。没有一种算法在所有地形上都表现最佳。

为了量化地形的“难度”，我们引入一个简单但重要的概念：条件数。对于一个二次函数 f(x) = 1/2 * x^T A x - b^T x（其中A是对称正定矩阵），其海森矩阵就是A。矩阵A的条件数定义为最大特征值与最小特征值的比值。条件数越大，等高线椭圆就越扁长，峡谷地形就越明显，梯度下降法的收敛就会越慢。

地形类型等高线形状海森矩阵特征条件数对梯度下降的影响
理想球形同心圆特征值相等~1收敛最快，梯度直接指向中心
温和椭圆椭圆特征值差异适中中等（如10-100）收敛速度下降，出现轻微震荡
严重峡谷极扁长的椭圆特征值差异巨大很大（>1000）严重震荡，收敛极慢甚至难以收敛
鞍点双曲状特征值有正有负不适用（非正定）可能陷入停滞，误判为极小值

有了这些基本概念，我们就可以像拿着地图的探险家一样，开始评估不同的行进策略了。

2. 梯度下降法：最直接的“盲人登山者”

梯度下降法（Gradient Descent, GD）的策略最为直观：每走一步，都沿着当前所在位置最陡的下坡方向前进。这个方向就是负梯度方向。它的更新公式简单明了：

x_{k+1} = x_k - η * ∇f(x_k)

其中，η 是学习率，决定了步长。

我们用一段简单的Python代码，在二维峡谷地形上模拟它的轨迹：

import numpy as np
import matplotlib.pyplot as plt

# 定义一个峡谷状的二次损失函数: f(x) = 0.5 * x^T A x, 其中A的条件数很大
A = np.array([[1, 0], [0, 100]])  # 条件数为100
def f(x):
    return 0.5 * x.T @ A @ x
def grad_f(x):
    return A @ x

# 梯度下降
def gradient_descent(start, lr=0.01, steps=50):
    path = [start]
    x = start.copy()
    for _ in range(steps):
        g = grad_f(x)
        x = x - lr * g
        path.append(x.copy())
    return np.array(path)

# 绘制等高线和轨迹
x = np.linspace(-2, 2, 400)
y = np.linspace(-2, 2, 400)
X, Y = np.meshgrid(x, y)
Z = 0.5 * (A[0,0]*X**2 + A[1,1]*Y**2)

start_point = np.array([1.8, 1.8])
path_gd = gradient_descent(start_point, lr=0.02)

plt.figure(figsize=(8,6))
plt.contour(X, Y, Z, levels=30, cmap='viridis')
plt.plot(path_gd[:, 0], path_gd[:, 1], 'ro-', linewidth=2, markersize=4, label='梯度下降轨迹')
plt.scatter(0, 0, c='green', s=100, marker='*', label='最小值点')
plt.legend()
plt.title("梯度下降法在峡谷地形中的‘之字形’震荡")
plt.xlabel('x1')
plt.ylabel('x2')
plt.axis('equal')
plt.show()

运行这段代码，你会清晰地看到一条密集的、近乎垂直的“之字形”轨迹。算法在x2方向（陡峭方向）快速下降，但在x1方向（平缓方向）进展甚微，每次都要花很多步才能调整到正确的轴向。这就是梯度下降法在病态条件问题上的主要缺陷：收敛速度慢，且严重依赖学习率的精细调节。学习率太大，会在峡谷两侧“冲过头”，导致震荡甚至发散；学习率太小，在平缓方向上的前进速度将令人绝望。

注意：虽然随机梯度下降（SGD）及其变体（如Adam）在深度学习中被广泛使用，以应对高维非凸问题，但它们在本质上仍受限于这种“之字形”行为的底层几何原理，尤其是在病态子空间中。

3. 牛顿法：拥有“全局地图”的完美规划师

如果梯度下降法像是只凭脚下感觉走路的盲人，那么牛顿法（Newton‘s Method）就像是一位拥有精确全局地形图的规划师。它不仅知道当前的下坡方向（梯度），还知道地形的曲率（海森矩阵），从而能预测出一步直达山谷最低点的“最优跳跃点”。它的更新公式是：

x_{k+1} = x_k - H^{-1}(x_k) * ∇f(x_k)

其中 H(x_k) 是海森矩阵。乘以海森矩阵的逆，本质上是对梯度进行了一个“缩放”和“旋转”，使其直接指向当前二次近似下的最小值点。

让我们在代码中对比一下：

def newtons_method(start, steps=5):
    path = [start]
    x = start.copy()
    for _ in range(steps):
        g = grad_f(x)
        # 对于我们的二次函数，海森矩阵是常数A
        H_inv = np.linalg.inv(A)  # 实际中计算逆矩阵代价高昂
        x = x - H_inv @ g
        path.append(x.copy())
    return np.array(path)

path_newton = newtons_method(start_point, steps=3)

plt.figure(figsize=(8,6))
plt.contour(X, Y, Z, levels=30, cmap='viridis')
plt.plot(path_gd[:, 0], path_gd[:, 1], 'ro-', linewidth=1, markersize=3, label='梯度下降 (50步)', alpha=0.7)
plt.plot(path_newton[:, 0], path_newton[:, 1], 'bs-', linewidth=2, markersize=6, label='牛顿法 (3步)')
plt.scatter(0, 0, c='green', s=100, marker='*', label='最小值点')
plt.legend()
plt.title("牛顿法 vs 梯度下降法：一步到位 vs 之字形漫步")
plt.xlabel('x1')
plt.ylabel('x2')
plt.axis('equal')
plt.show()

你会惊讶地发现，牛顿法仅仅用了3步就精准地到达了最小值点，而梯度下降法走了50步还在震荡。对于二次函数，牛顿法具有二次收敛性，理论上一步就能收敛。这听起来完美无缺，但为什么我们没有在所有地方都使用牛顿法呢？

它的代价是巨大的：

  1. 计算与存储开销：需要计算并存储 O(n^2) 大小的海森矩阵（n为参数数量），对于现代深度学习动辄百万、千万的参数，这是不可想象的。
  2. 求逆的困难：对大规模矩阵求逆是 O(n^3) 复杂度的操作，计算上不可行。
  3. 非正定问题：在非凸函数的鞍点或局部极大值点，海森矩阵可能非正定，其逆矩阵与梯度的乘积可能不再是下降方向，导致算法失效。

因此，牛顿法更像是一个理论上的标杆，揭示了利用二阶信息所能达到的极限速度，但在实际的大规模机器学习问题中直接应用它是不现实的。

4. 共轭梯度法：兼具智慧与效率的“导航专家”

现在我们遇到了一个核心矛盾：我们既想要牛顿法那种利用曲率信息、不走“之字形”的聪明劲儿，又无法承受其巨大的计算成本。共轭梯度法（Conjugate Gradient, CG） 正是在这种需求下诞生的完美折衷方案。

它的核心思想非常巧妙：我们不再追求一步到位的“最优跳跃”，而是确保每一步都沿着一个“互不干扰”的方向前进。具体来说，它要求每次的搜索方向是关于海森矩阵A 共轭的。两个向量 d_i 和 d_j 是A共轭的，如果满足 d_i^T A d_j = 0 (i ≠ j)。

这有什么几何意义呢？在A定义的度量下，共轭方向是相互“正交”的。这意味着，沿着方向 d_i 前进并找到该方向上的最小值后，后续沿着 d_j 前进时，不会破坏在 d_i 方向上已经达到的最优性。因此，对于一个n维的二次问题，最多只需要n步（每个共轭方向一步）就能找到精确解，避免了梯度下降法的反复震荡。

更重要的是，共轭梯度法有一个神奇的特性：它能在不显式计算和存储海森矩阵A的情况下，仅通过一系列的梯度计算和内积运算，自动构造出这一组共轭方向。其算法框架如下：

  1. 初始化：选择初始点 x0，计算初始梯度 g0，设初始搜索方向 d0 = -g0。
  2. 迭代：对于 k = 0, 1, 2, ... 直到收敛： a. 计算最优步长：α_k = (g_k^T g_k) / (d_k^T A d_k)。这保证了在方向 d_k 上走到最低点。 b. 更新参数：x_{k+1} = x_k + α_k * d_k。 c. 计算新梯度：g_{k+1} = A x_{k+1} - b (对于二次函数) 或更一般的梯度。 d. 计算共轭系数：β_k = (g_{k+1}^T g_{k+1}) / (g_k^T g_k) (Fletcher-Reeves公式)。 e. 构造新的共轭方向：d_{k+1} = -g_{k+1} + β_k * d_k。

看，在整个过程中，我们只需要矩阵A以“矩阵-向量乘积” A * d_k 的形式参与运算，而无需将其完整地构造出来。这对于大规模稀疏矩阵（例如来自有限元法或某些机器学习问题的海森矩阵近似）是至关重要的优势。

让我们把共轭梯度法的轨迹也画出来：

def conjugate_gradient(start, steps=10):
    path = [start]
    x = start.copy()
    g = grad_f(x)  # 初始梯度
    d = -g         # 初始搜索方向（负梯度）
    for i in range(steps):
        # 计算步长 α = (g^T g) / (d^T A d)
        alpha = (g.T @ g) / (d.T @ A @ d)
        x = x + alpha * d
        path.append(x.copy())
        g_new = grad_f(x)
        # 计算共轭系数 β (Fletcher-Reeves)
        beta = (g_new.T @ g_new) / (g.T @ g)
        d = -g_new + beta * d
        g = g_new
    return np.array(path)

path_cg = conjugate_gradient(start_point, steps=5)

plt.figure(figsize=(10,8))
plt.contour(X, Y, Z, levels=30, cmap='viridis')
plt.plot(path_gd[:, 0], path_gd[:, 1], 'ro-', linewidth=1, markersize=2, label='梯度下降 (50步)', alpha=0.5)
plt.plot(path_newton[:, 0], path_newton[:, 1], 'bs-', linewidth=2, markersize=8, label='牛顿法 (3步)')
plt.plot(path_cg[:, 0], path_cg[:, 1], 'mD-', linewidth=2, markersize=5, label='共轭梯度法 (5步)')
plt.scatter(0, 0, c='green', s=150, marker='*', label='最小值点')
plt.legend()
plt.title("算法轨迹大比拼：共轭梯度法如何优雅地穿越峡谷")
plt.xlabel('x1')
plt.ylabel('x2')
plt.axis('equal')
plt.show()

观察紫色菱形标记的共轭梯度法轨迹：它不像梯度下降那样垂直震荡，也不像牛顿法那样需要计算矩阵逆。它用了比牛顿法稍多的步数（5步），但每一步都坚定地沿着一个“有效”的方向前进，轨迹干净利落，几乎没有冗余的移动。对于这个二维问题，它理论上应该在2步内收敛，图中显示5步已非常接近，演示中步数稍多是为了清晰展示路径。

5. 实战：在PyTorch线性回归中何时引入CG思想

理解了共轭梯度法的几何美感后，我们来看看它在实际机器学习场景中的应用。严格来说，标准的共轭梯度法求解的是 Ax=b 的线性系统或正定二次函数的最小化。在深度学习中，直接使用CG来训练大型神经网络并不常见，因为损失函数是非凸非二次的，且海森矩阵难以获得。

但是，CG的思想和变体在以下场景中极具价值：

场景一：大规模线性系统/逻辑回归 当你的模型是线性回归、岭回归或逻辑回归，且特征维度很高但样本量也很大时，使用梯度下降法求解正规方程 (X^T X + λI) w = X^T y 可能会很慢。此时，A = X^T X + λI 是一个大型的、通常是稀疏或结构化的正定矩阵。使用共轭梯度法可以高效求解这个线性系统，尤其当使用迭代求解器且只需要中等精度解时。

场景二：神经网络训练的优化子问题 在一些高级优化技术中，CG扮演着关键角色。例如：

  • 截断牛顿法：在牛顿法的框架内，求解线性系统 H p = -g（搜索方向p）时，并不直接求H的逆，而是使用共轭梯度法迭代求解这个方程。由于只需要矩阵-向量乘积（可以通过自动微分高效计算），这避免了显式海森矩阵。
  • 自然梯度下降/K-FAC：在优化中引入信息几何的概念，其更新方向涉及Fisher信息矩阵的逆。共轭梯度法常被用来近似求解这个方向。

让我们用一个具体的PyTorch例子，展示在二次损失下CG风格优化与普通SGD的对比。假设我们有一个设计矩阵 X 和标签 y，损失为 L(w) = ||Xw - y||^2。

import torch
import torch.nn as nn
import numpy as np

# 生成模拟数据：故意创造病态条件
n_samples, n_features = 1000, 50
torch.manual_seed(42)
# 让X的列具有不同的尺度，模拟峡谷地形
X = torch.randn(n_samples, n_features)
X = X * torch.linspace(1, 100, n_features)  # 特征尺度差异大
true_w = torch.randn(n_features)
y = X @ true_w + 0.1 * torch.randn(n_samples)

# 定义模型和损失
model = nn.Linear(n_features, 1, bias=False)
criterion = nn.MSELoss()

# 方法1：使用PyTorch内置的SGD优化器（模拟梯度下降）
optimizer_sgd = torch.optim.SGD(model.parameters(), lr=1e-4)
losses_sgd = []
for epoch in range(100):
    optimizer_sgd.zero_grad()
    output = model(X)
    loss = criterion(output.squeeze(), y)
    loss.backward()
    optimizer_sgd.step()
    losses_sgd.append(loss.item())
    if loss.item() < 1e-4:
        break

# 方法2：使用共轭梯度法思想（手动实现一个简化版）
# 重置模型参数
model.load_state_dict({‘weight’: torch.randn(1, n_features)})
w = model.weight.data.squeeze().clone().requires_grad_(False)
# 将问题转化为求解 (X^T X) w = X^T y
A = X.T @ X  # 注意：对于大规模数据，A可能太大，这里仅作演示
b = X.T @ y
# 手动实现CG求解
def manual_cg(A, b, x0, max_iter=100, tol=1e-6):
    x = x0.clone()
    r = b - A @ x  # 残差
    p = r.clone()
    rsold = r @ r
    for i in range(max_iter):
        Ap = A @ p
        alpha = rsold / (p @ Ap)
        x = x + alpha * p
        r = r - alpha * Ap
        rsnew = r @ r
        if torch.sqrt(rsnew) < tol:
            print(f"CG在 {i+1} 步后收敛")
            break
        p = r + (rsnew / rsold) * p
        rsold = rsnew
    return x

w_cg = manual_cg(A, b, w.clone())
# 将CG解赋给模型
with torch.no_grad():
    model.weight.copy_(w_cg.unsqueeze(0))
output_cg = model(X)
loss_cg = criterion(output_cg.squeeze(), y)

print(f"SGD最终损失: {losses_sgd[-1]:.6f}")
print(f"CG一步解损失: {loss_cg.item():.6f}")

在这个例子中，由于数据 X 被设计成病态的（特征尺度差异大），SGD需要很多步且需要仔细调参才能缓慢收敛。而共轭梯度法（这里演示了其在线性系统中的应用）通过利用问题的二次结构，以更少的迭代次数直接找到了高质量的解。在实际的线性回归中，你可能会使用 torch.linalg.lstsq 或 scipy.sparse.linalg.cg 这些更鲁棒的实现。

6. 算法选择指南：从直觉到决策

经过前面的可视化分析和实战接触，我们现在可以系统地总结一下，面对一个具体的优化问题时，应该如何选择算法。决策的关键在于回答以下几个问题：

  1. 问题的规模有多大？

    • 参数数量（n）巨大（>10^4）：首先排除需要显式海森矩阵的经典牛顿法。梯度下降族（SGD, Adam等）是默认起点。如果问题是（近似）二次的且矩阵-向量乘便宜，考虑迭代线性求解器（如CG）。
    • 参数数量中等：可以尝试使用拟牛顿法（如L-BFGS），它通过梯度信息近似海森矩阵，性能介于梯度下降和牛顿法之间。

  2. 损失函数是（近似）二次的吗？

    • 是：例如线性模型、最小二乘、带L2正则的逻辑回归。共轭梯度法是你的首选武器，它能以接近牛顿法的速度收敛，而开销仅略高于梯度下降。对于精确解，CG是迭代法中的佼佼者。
    • 否：例如深度神经网络的非凸损失。标准CG可能不适用。应使用随机梯度下降（SGD）及其自适应变体（如Adam）。在训练后期，可以切换到带动量的SGD或L-BFGS进行精细调优，它们在一定程度上继承了“共轭方向”的思想，能减少震荡。

  3. 计算和存储资源是否受限？

    • 内存紧张：避免任何需要存储 O(n^2) 矩阵的算法（牛顿法、拟牛顿法存储近似海森）。选择 O(n) 存储的算法（梯度下降、CG）。
    • 梯度计算昂贵：每次计算整个数据集的梯度（全量梯度）代价高。优先使用随机梯度下降（SGD），它每次只用一个或一小批样本估算梯度。

  4. 你需要多高的精度？

    • 中等精度即可：迭代法（如CG、梯度下降）通常在达到一定精度后收益递减，可以提前停止。
    • 需要非常高精度：牛顿法或CG（对于二次问题）能达到机器精度。梯度下降族可能永远无法达到如此高的精度，或者需要极多的迭代次数。

为了更直观，可以参考下面的快速决策流程图（用文字描述）：

开始 -> 问题规模 n 多大？
    -> n 极大（深度学习） -> 损失函数是否非凸？ -> 是 -> 使用 SGD/Adam
    -> n 中等或较大 -> 损失函数是否（近似）二次？ -> 是 -> 矩阵A是否稀疏/结构好？ -> 是 -> 使用 共轭梯度法(CG)
                                                                 -> 否 -> 使用 L-BFGS
                                                      -> 否 -> 使用 L-BFGS 或 带动量的SGD
    -> n 较小 -> 使用 牛顿法 或 L-BFGS 以求最快收敛

最后记住一点，优化算法的选择不是一成不变的。一个常见的混合策略是：在训练初期使用Adam快速下降，逃离初始的平坦区域；在损失曲面变得相对平滑后，切换到带动量的SGD或L-BFGS，以获得更稳定、更精确的收敛。这种切换本身，就体现了你对优化过程不同阶段“地形”变化的直觉理解。

# 机器学习
Logo
乐奇 Rokid 开放社区

更多推荐

在 Rokid AI Glasses 上做背单词应用：AIUI拍照听写的实现

分享在 Rokid AI Glasses 上用 AIUI 开发背单词应用的实践：从镜腿单击拍照、图片编码和多模态识别，到切题时的异步任务处理、语音调度与学习进度保存，结合关键代码和界面动图说明实现过程。

avatar 乐奇 Rokid 开放社区
cover

极刻觅镜 | AI眼镜周报｜智能眼镜周报：销售高增长、标准落地与新品密集发布

avatar 乐奇 Rokid 开放社区
cover

深圳十大 AI 智能眼镜 FPC 厂家盘点（2026 供应商选型参考）

avatar 乐奇 Rokid 开放社区