牛顿法与拟牛顿法

牛顿法利用二阶导数（Hessian 矩阵）信息，在凸优化中能达到比梯度下降快得多的收敛速度——从线性收敛跃升到二次收敛。拟牛顿法（BFGS、L-BFGS）在不直接计算 Hessian 的前提下近似实现同样效果，是传统机器学习和科学计算的利器。近年来，二阶方法以”预条件器（Preconditioner）“的形式重新回到深度学习（如 Sophia、Shampoo、Muon 等优化器），本页梳理完整谱系。前置阅读：数值优化与数学基础、梯度下降与优化器、凸优化基础。

核心直觉

继续沿用”蒙眼下山”的比喻，但这次山不再是一维的斜坡，而是复杂的多维曲面：

梯度下降（一阶）= 只用脚感受坡度（一阶导数），朝最陡的方向走一步。简单，但走的是锯齿路线，在狭长峡谷里来回弹跳。
牛顿法（二阶）= 不仅感受坡度，还感受坡度的变化率（曲率/二阶导数）。相当于不仅知道哪边下坡，还知道这片地形是碗还是马鞍——直接算出碗底在哪，一步到位。
拟牛顿法= 牛顿法需要精确测量曲率（Hessian 矩阵），太贵了。拟牛顿法用历史走过的路来估计曲率，像用 GPS 轨迹反推地形——便宜很多，效果接近。
L-BFGS= 拟牛顿法的内存优化版。只记住最近几步的轨迹（而不是整个地形图），适合参数量很大的场景。

一阶方法为什么会”锯齿振荡”？

想象你站在一个狭长的峡谷底部（椭圆形等高线长宽比很大），梯度方向总是垂直于等高线——于是你几乎一直在横跨窄方向来回弹跳，沿着长方向的进展极慢。这种低效本质上是条件数（Condition Number，等高线长短轴之比，数值上等于 Hessian 最大特征值与最小特征值之比）造成的。条件数越大，梯度下降越低效。

牛顿法通过引入 Hessian 的逆，相当于把椭圆等高线”拉伸”成圆形——每一步都是径直朝碗心走，这正是它能二次收敛的根本原因。

原理详解

从一维到多维：牛顿法推导

一维情形。 假设我们要最小化 $f:\mathbb{R}\to\mathbb{R}$ ，在当前点 $x_k$ 处做二阶泰勒展开（Taylor Expansion，即用多项式局部近似函数）：

$f(x_k + d) \approx f(x_k) + f'(x_k)\,d + \frac{1}{2} f''(x_k)\,d^2$

对 $d$ 求导令其为零： $f'(x_k) + f''(x_k)\,d = 0$ ，解得：

$d = -\frac{f'(x_k)}{f''(x_k)}$

这就是一维牛顿更新： $x_{k+1} = x_k - \dfrac{f'(x_k)}{f''(x_k)}$ 。直觉上，这相当于用一个抛物线拟合当前点附近的地形，然后直接跳到抛物线的最低点。

数学小贴士：为什么是”二阶”？ 一阶泰勒展开（只留常数+线性项）得到的是一条直线，没有最低点——所以梯度下降只能沿方向走一个步长。只有加入二阶项，近似函数才有曲率、才有最低点，牛顿法才能”一步到位”。

多维情形。 将标量推广到向量 $x \in \mathbb{R}^n$ ，二阶泰勒展开变为：

$f(\mathbf{x} + \mathbf{d}) \approx f(\mathbf{x}) + \nabla f(\mathbf{x})^\top \mathbf{d} + \frac{1}{2} \mathbf{d}^\top \mathbf{H}(\mathbf{x})\, \mathbf{d}$

其中：

$\nabla f(\mathbf{x})$ 是梯度向量（Gradient），即各偏导数排成的列向量 $\left(\dfrac{\partial f}{\partial x_1}, \dots, \dfrac{\partial f}{\partial x_n}\right)^\top$ ；
$\mathbf{H}(\mathbf{x})$ 是 Hessian 矩阵，即二阶偏导数构成的 $n \times n$ 对称方阵，元素 $H_{ij} = \dfrac{\partial^2 f}{\partial x_i \partial x_j}$ ；
$\mathbf{d}$ 是搜索方向。

对 $\mathbf{d}$ 求导令其为零，得到牛顿方程：

$\mathbf{H}\,\mathbf{d} = -\nabla f \quad \Longrightarrow \quad \mathbf{d} = -\mathbf{H}^{-1}\nabla f$

完整更新规则：

$\mathbf{x}_{k+1} = \mathbf{x}_k - \alpha_k \mathbf{H}^{-1} \nabla f(\mathbf{x}_k)$

当 $\alpha_k = 1$ 时为纯牛顿步。对比梯度下降 $\mathbf{x}_{k+1} = \mathbf{x}_k - \alpha \nabla f$ ，区别就是多了一个”预条件矩阵” $\mathbf{H}^{-1}$ ——它把坐标系重新标度，让每一步都直指最优解。

收敛性分析：线性 vs 二次 vs 超线性

设 $\mathbf{x}^*$ 是最优解，定义误差 $e_k = \|\mathbf{x}_k - \mathbf{x}^*\|$ 。三种收敛速度的定义与直觉：

类型	数学定义	直觉	代表方法
线性收敛	$e_{k+1} \leq \rho\, e_k$ ， $0 < \rho < 1$	每步固定比例缩小（如 $\times 0.9$ ）	梯度下降
超线性收敛	$e_{k+1} / e_k \to 0$	缩小比例趋近于零，越来越快	L-BFGS、BFGS
二次收敛	$e_{k+1} \leq C\, e_k^2$	误差平方级缩小，位数翻倍	牛顿法

二次收敛的威力在于”位数翻倍”：若 $e_0 = 10^{-1}$ ，则 $e_1 \approx 10^{-2}$ ， $e_2 \approx 10^{-4}$ ， $e_3 \approx 10^{-8}$ ——只需三四步就达到机器精度。而梯度下降每步只按固定比例缩小，要达到同样精度可能需要上百步。

前提条件。 二次收敛要求：(1) 目标函数二阶可微且 Hessian 在最优解附近 Lipschitz 连续；(2) 起点足够靠近最优解；(3) Hessian 正定（函数局部是碗形）。这三条在凸优化中容易满足，在深度学习的非凸损失面上几乎都不成立。

牛顿法的三个致命问题

问题一：Hessian 矩阵太大。 对于 $n$ 个参数，Hessian 是 $n \times n$ 矩阵。深度学习动辄上亿参数（ $n \approx 10^8$ ），Hessian 有 $10^{16}$ 个元素，仅存储就需要 80 TB（双精度）。

问题二：Hessian 求逆太贵。 直接求逆或解线性方程组的复杂度是 $O(n^3)$ 。对 $n=10^4$ 的中等规模问题，单次分解就要约 $10^{12}$ 次浮点运算。

问题三：非凸函数可能发散。 在非凸问题中 Hessian 不一定正定（Positive Definite，即所有特征值大于零），可能是不定矩阵（Indefinite Matrix，有正有负特征值）。此时牛顿方向 $\mathbf{d} = -\mathbf{H}^{-1}\nabla f$ 可能指向鞍点（Saddle Point，某些方向是极小、另一些方向是极大的点）或极大值，而非极小值。深度学习的损失曲面高度非凸，充斥着鞍点，牛顿法没有收敛保证。

因此牛顿法主要用于凸优化问题（如逻辑回归、最大熵模型），在深度学习中几乎不用纯牛顿法——但二阶思想以变体形式回来了（见下文”深度学习中的二阶优化”）。

信赖域与阻尼牛顿法

为解决非凸问题，工程中常用信赖域（Trust Region）和阻尼牛顿法（Damped Newton）：

线搜索（Line Search）：先算牛顿方向，若该方向不是下降方向（Hessian 非正定），则回退到梯度方向或负曲率方向。即沿方向 $\mathbf{d}$ 搜索步长 $\alpha$ 使 $f(\mathbf{x} + \alpha \mathbf{d})$ 充分下降。
信赖域：先限定一个步长上界 $\Delta$ （信任范围），在 $\|\mathbf{d}\| \leq \Delta$ 的约束下求解近似子问题的最小值。若模型预测与实际下降吻合，扩大 $\Delta$ ；否则缩小 $\Delta$ 。

scipy 的 trust-constr 和 trust-ncg 方法用的就是信赖域策略。

拟牛顿法：BFGS

BFGS（Broyden–Fletcher–Goldfarb–Shanno，四人独立提出）是拟牛顿法（Quasi-Newton Method）中最常用的算法。核心思想：不直接计算 Hessian，而是用梯度差分信息迭代构建 Hessian 的近似矩阵 $\mathbf{B}$ 。

记第 $k$ 步的位移和梯度差为：

$\mathbf{s}_k = \mathbf{x}_{k+1} - \mathbf{x}_k \quad \text{（参数位移）}$

$\mathbf{y}_k = \nabla f(\mathbf{x}_{k+1}) - \nabla f(\mathbf{x}_k) \quad \text{（梯度差）}$

BFGS 的理论依据是割线方程（Secant Equation）：要求近似矩阵满足 $\mathbf{B}_{k+1}\mathbf{s}_k = \mathbf{y}_k$ （即用一阶差分模拟二阶信息）。在所有满足割线方程的矩阵中，BFGS 选择与 $\mathbf{B}_k$ 最接近的那个（最小化某种矩阵范数），得到秩二更新公式：

$\mathbf{B}_{k+1} = \mathbf{B}_k + \frac{\mathbf{y}_k \mathbf{y}_k^\top}{\mathbf{y}_k^\top \mathbf{s}_k} - \frac{\mathbf{B}_k \mathbf{s}_k \mathbf{s}_k^\top \mathbf{B}_k}{\mathbf{s}_k^\top \mathbf{B}_k \mathbf{s}_k}$

“秩二”是什么意思？ 右边两项各是一个外积（ $\mathbf{y}\mathbf{y}^\top$ 和 $\mathbf{B}\mathbf{s}\mathbf{s}^\top\mathbf{B}$ ），都是秩为 1 的矩阵。两个秩 1 矩阵之和秩至多为 2，所以叫”秩二更新”。秩二更新能保证近似矩阵保持正定性。

BFGS 只需要梯度信息（一阶），却能达到接近牛顿法的超线性收敛速度。代价是仍需存储 $n \times n$ 的近似矩阵。

DFP 与 BFGS 的对偶

BFGS 有一个”孪生兄弟”DFP（Davidon–Fletcher–Powell），它更新的是 Hessian 的逆 $\mathbf{B}^{-1}$ 而非 Hessian 本身。两者公式形式上对称——BFGS 的更新公式中把 $\mathbf{B}$ 换成 $\mathbf{B}^{-1}$ 、 $\mathbf{s}$ 和 $\mathbf{y}$ 互换，就得到 DFP。实践中 BFGS 几乎总是优于 DFP，所以 DFP 现在主要出现在教科书中。Broyden 族则把 BFGS 和 DFP 线性组合，统一了两者。

L-BFGS：有限内存 BFGS

L-BFGS（Limited-memory BFGS）针对 BFGS 的内存瓶颈做了优化。它不存储完整的 $n \times n$ 矩阵 $\mathbf{B}$ ，而是只保留最近 $m$ 步的 $(\mathbf{s}_k, \mathbf{y}_k)$ 对（通常 $m=5$ 到 $20$ ），在需要矩阵-向量乘积 $\mathbf{H}^{-1}\nabla f$ 时通过**双循环递归（Two-Loop Recursion）**动态重建。

L-BFGS 的内存开销从 $O(n^2)$ 降到 $O(mn)$ ，使其可用于参数量较大的问题（几十万到几百万参数）。它是传统机器学习（逻辑回归、CRF）和科学计算中的首选二阶方法。

双循环递归的直觉。 因为 BFGS 是秩二更新， $\mathbf{H}^{-1}\nabla f$ 可以表示为一系列向量运算的嵌套——不需要显式构造矩阵，只需依次用 $(\mathbf{s}_k, \mathbf{y}_k)$ 对做点积和线性组合。时间复杂度 $O(mn)$ ，空间 $O(mn)$ 。

与一阶方法的对比

特性	梯度下降	牛顿法	L-BFGS
导数阶	一阶	二阶	一阶（近似二阶）
每步开销	$O(n)$	$O(n^3)$	$O(mn)$
内存	$O(n)$	$O(n^2)$	$O(mn)$
收敛速度	线性	二次	超线性
凸问题适用	是	是	是
深度学习适用	是	否（不可行）	少量场景

深度学习中的二阶优化

纯牛顿法在深度学习中不可行，但二阶思想以”近似 + 结构化”的形式回来了。核心思路：不精确计算完整 Hessian，而是用结构化的近似矩阵作为预条件器（Preconditioner），即把更新方向从 $-\nabla f$ 改为 $-\mathbf{P}\nabla f$ ，其中 $\mathbf{P}$ 是 Hessian 逆的某种近似。

K-FAC：利用层结构

K-FAC（Kronecker-Factored Approximate Curvature，2015）观察到：全连接层的 Hessian 近似可以写成 Kronecker 积（Kronecker Product，一种矩阵块乘法）形式 $\mathbf{A} \otimes \mathbf{G}$ （ $\mathbf{A}$ 是输入激活的外积期望， $\mathbf{G}$ 是梯度的外积期望）。这样 $n^2$ 的矩阵被分解成两个小矩阵的 Kronecker 积，求逆复杂度大幅下降。K-FAC 是最早在大规模神经网络训练中取得与一阶方法相当甚至更优效果的二阶方法之一。

Shampoo：结构化预条件

Shampoo（Google，2018）把每层的梯度矩阵的预条件器限制为每行每列各一个小矩阵（即 $\mathbf{L}\nabla \mathbf{R}$ 的形式），只需存储和求逆几个小矩阵。它在推荐系统的大规模 embedding 训练中被 Google 生产环境广泛使用。

Sophia：对角 Hessian 估计

Sophia（Stanford，2023）用 Hutchinson 迹估计器（Hutchinson Trace Estimator，一种用随机向量估计矩阵对角元的方法）廉价估计 Hessian 对角线，作为对角预条件器。它在语言模型预训练上比 Adam 收敛更快、达到更低的损失。

Muon：2024-2025 年的新星

Muon（Moonshot/Moonlight 等，2024）是 2024 年兴起的新一代二阶启发式优化器，专为 LLM 训练设计。核心思想是对梯度矩阵做正交化（Orthogonalization）——用 Newton-Schulz 迭代近似计算 $\mathbf{G}(\mathbf{G}^\top\mathbf{G})^{-1/2}$ （即把梯度矩阵的奇异值归一化），等价于一种谱预条件。Muon 在多个开源 LLM 训练中展现了比 Adam 更快的收敛和更好的最终性能，是 2025 年最受关注的二阶优化方向之一。

直觉：为什么正交化有效？ 矩阵的正交化相当于把所有奇异值压到 1，消除了梯度在不同方向上的尺度差异——这正是 Hessian 预条件想做的事的极端版本。Muon 把它限制在每层的权重矩阵内（而非全模型），巧妙避开了 $n^2$ 内存问题。

原理图解

方法谱系

收敛速度直观对比

动手实践

scipy 求解无约束优化（L-BFGS-B）

import numpy as np
from scipy.optimize import minimize

# 目标函数: Rosenbrock 函数（经典测试函数，极难的一维峡谷）
def rosenbrock(x):
    return sum(100.0 * (x[1:] - x[:-1]**2)**2 + (1 - x[:-1])**2)

# 解析梯度（提供梯度能大幅加速收敛）
def rosenbrock_grad(x):
    g = np.zeros_like(x)
    g[:-1] = -400 * x[:-1] * (x[1:] - x[:-1]**2) - 2 * (1 - x[:-1])
    g[1:] += 200 * (x[1:] - x[:-1]**2)
    return g

x0 = np.array([-1.2, 1.0, 1.0])  # 初始点

# 分别用 L-BFGS-B 和 梯度下降（BFGS 带边界版）
result = minimize(rosenbrock, x0, method="L-BFGS-B",
                  jac=rosenbrock_grad, options={"maxiter": 200})
print(f"L-BFGS-B: {result.x.round(4)}, 迭代 {result.nit} 次")
# 理论最优解: [1, 1, 1]

numpy 手写牛顿法（一维问题）

import numpy as np

# 求函数 f(x) = x^4 - 3x^3 + 2 的极小值
def f(x):  return x**4 - 3*x**3 + 2
def df(x): return 4*x**3 - 9*x**2          # 一阶导
def d2f(x): return 12*x**2 - 18*x          # 二阶导（Hessian 的一维版本）

x = 0.5  # 初始猜测
for i in range(10):
    step = df(x) / d2f(x)   # 牛顿方向: grad / hessian
    x = x - step            # 更新
    if abs(step) < 1e-8:
        break
print(f"牛顿法 {i+1} 步收敛: x = {x:.6f}, f(x) = {f(x):.6f}")
# 对比梯度下降通常需要上百步才能达到同样精度

numpy 手写牛顿法（多维问题，含 Hessian 求逆）

下面是一个完整的多维牛顿法实现，最小化二元二次函数，展示梯度、Hessian 和更新规则的协作：

import numpy as np

# 目标函数: f(x, y) = (x - 3)^2 + 10*(y - 2)^2 + xy
# 最优解: 用解析法可求得 x=3, y=2 附近
def f(vec):
    x, y = vec
    return (x - 3)**2 + 10 * (y - 2)**2 + x * y

def gradient(vec):
    """解析梯度: [2(x-3) + y, 20(y-2) + x]"""
    x, y = vec
    return np.array([2 * (x - 3) + y, 20 * (y - 2) + x])

def hessian(vec):
    """解析 Hessian（本例为常数矩阵）:
       d2f/dx2=2, d2f/dy2=20, d2f/dxdy=1"""
    return np.array([[2.0, 1.0],
                     [1.0, 20.0]])

x = np.array([0.0, 0.0])  # 初始点，离最优解很远
for i in range(20):
    g = gradient(x)
    H = hessian(x)
    # 牛顿方向: 解 H d = -g（等价于 d = -H^{-1} g，但用 solve 更稳定）
    d = np.linalg.solve(H, -g)
    x_new = x + d  # 纯牛顿步 alpha=1
    if np.linalg.norm(x_new - x) < 1e-10:
        break
    x = x_new

print(f"牛顿法 {i+1} 步收敛: x = {x.round(6)}, f(x) = {f(x):.6f}")
# 注意：对二次函数，牛顿法理论上一步即达最优解（因为二阶泰勒展开是精确的）

关键观察：对于二次函数（Hessian 是常数矩阵），牛顿法一步就到最优解——因为二阶泰勒展开本身就是精确的，没有近似误差。这解释了”二次收敛”的含义：对一般函数，越接近最优解（越像二次函数），收敛越快。

PyTorch 中使用 L-BFGS 优化器

PyTorch 提供了 torch.optim.LBFGS，但由于 L-BFGS 需要完整的 loss 历史，用法和一阶优化器略有不同——需要传入一个闭包（closure）反复计算 loss：

import torch

# 简单示例: 最小化 f(x) = (x - 3)^2 + 0.1 * (y + 2)^2
x = torch.tensor([0.0, 0.0], requires_grad=True)
optimizer = torch.optim.LBFGS([x], lr=1.0, max_iter=20,
                               history_size=10)  # history_size 即 L-BFGS 的 m

def closure():
    optimizer.zero_grad()
    loss = (x[0] - 3)**2 + 0.1 * (x[1] + 2)**2
    loss.backward()
    return loss

optimizer.step(closure)  # 注意：传入 closure 而非直接调用
print(f"L-BFGS 收敛: x = {x.detach().numpy().round(6)}")
# 预期: [3.0, -2.0]

陷阱：L-BFGS 默认用全批量（full-batch）梯度，不适合 mini-batch 随机优化。在小批量噪声下，L-BFGS 的曲率估计 $(\mathbf{s}_k, \mathbf{y}_k)$ 对会被污染，收敛变差。这也是它在深度学习中用得少的原因之一。

实际应用案例

案例 1：逻辑回归的求解器选择

scikit-learn 的 LogisticRegression 默认用 L-BFGS 求解。对比一下不同求解器在同一数据集上的表现：

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import time

X, y = make_classification(n_samples=50000, n_features=100, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

for solver in ['lbfgs', 'sag', 'liblinear']:
    clf = LogisticRegression(solver=solver, max_iter=1000, random_state=42)
    t0 = time.time()
    clf.fit(X_train, y_train)
    dt = time.time() - t0
    acc = clf.score(X_test, y_test)
    print(f"{solver:12s}: acc={acc:.4f}, time={dt:.3f}s, iters={clf.n_iter_}")
# 预期: lbfgs 通常收敛最快（迭代次数最少），精度与其他相当

案例 2：科学计算中的参数拟合

在物理/工程仿真中，L-BFGS-B 是拟合模型参数的标准工具。例如拟合一个含边界约束的指数衰减模型：

import numpy as np
from scipy.optimize import minimize

# 模拟数据: y = 3 * exp(-0.5 * t) + 噪声
np.random.seed(42)
t = np.linspace(0, 10, 100)
y_true = 3.0 * np.exp(-0.5 * t)
y_obs = y_true + np.random.normal(0, 0.1, size=t.shape)

def residual(params):
    A, lam = params
    return np.sum((A * np.exp(-lam * t) - y_obs)**2)

def residual_grad(params):
    A, lam = params
    model = A * np.exp(-lam * t)
    dA = 2 * np.sum((model - y_obs) * np.exp(-lam * t))
    dlam = 2 * np.sum((model - y_obs) * (-A * t) * np.exp(-lam * t))
    return np.array([dA, dlam])

# 带边界约束: A > 0, 0 < lam < 1
result = minimize(residual, x0=[1.0, 0.1], method='L-BFGS-B',
                  jac=residual_grad, bounds=[(1e-6, None), (1e-6, 1.0)])
print(f"拟合结果: A={result.x[0]:.3f}, λ={result.x[1]:.3f}")
# 预期: A≈3.0, λ≈0.5（与真值吻合）

实践要点

传统机器学习首选 L-BFGS：逻辑回归、CRF、最大熵模型等参数量适中的凸优化问题，L-BFGS 比 Adam/SGD 收敛更快、精度更高。scikit-learn 和 scipy 都内置了。
深度学习基本不用牛顿法：参数量太大，Hessian 不可行。但少数小模型或微调场景（如贝叶斯神经网络的拉普拉斯近似）会用 L-BFGS。
提供解析梯度能大幅加速：数值梯度（有限差分）慢且不精确。如果目标函数可微，尽量提供解析梯度（scipy 的 jac 参数）。
非凸问题需要信赖域或线搜索：纯牛顿步在非凸区域可能发散。scipy 的 trust-constr 和 trust-ncg 方法用信赖域策略保证下降方向，适合中等规模非凸优化。
注意 Hessian 的条件数：条件数（最大特征值/最小特征值）越大，梯度下降越慢（锯齿振荡），牛顿法的优势越明显。这也解释了为什么预处理（Preconditioning）对一阶方法如此重要——Adam 的自适应学习率本质上就是一种对角预条件。
L-BFGS 的 m 参数调优：m（历史步数）通常取 5 到 20。m 越大近似越精确但内存越大；m 太小可能近似不足导致收敛变慢。
L-BFGS 与 mini-batch 不兼容：随机噪声会污染曲率估计。若必须用随机 L-BFGS，需要额外方差缩减技巧（如 SVRG 风样的梯度校正）。

典型应用

逻辑回归求解：scikit-learn 的 LogisticRegression 默认用 L-BFGS 求解。大规模 CTR 预估中也用 L-BFGS 或其变体。详见监督学习。
最大似然估计（MLE）：统计学中的 MLE 本质是凸优化（对数似然是凹函数），L-BFGS 是通用求解器。详见EM 算法。
图割与能量最小化：计算机视觉中的图割优化、CRF 推理在连续松弛后可用 L-BFGS 求解。
科学计算与工程优化：流体力学、结构优化、最优控制等领域的参数估计，L-BFGS-B 是标准工具。
深度学习中的少量场景：二阶优化在神经网络上的研究（如 K-FAC、Shampoo、Muon）是活跃方向，2024-2025 年 Muon 等方法开始在 LLM 训练中崭露头角，但工业界大规模训练仍以一阶 Adam 为主。

典型类库与工具

类库	语言	说明
scipy.optimize.minimize	Python	提供 L-BFGS-B、BFGS、Newton-CG、trust-constr 等完整二阶方法
scikit-learn	Python	LogisticRegression、LogisticRegressionCV 默认用 L-BFGS
pytorch.optim.LBFGS	Python	PyTorch 内置的 L-BFGS 优化器，适合小批量二阶优化
NLopt	C/C++	支持多种局部和全局优化算法的高性能库，含 L-BFGS
CVXPY	Python	凸优化建模语言，底层调用 ECOS/SCS 等求解器
Muon（开源实现）	Python	基于 PyTorch 的 Muon 优化器实现，2024 年社区项目

术语表

术语	英文	解释
牛顿法	Newton’s Method	利用二阶导数（Hessian）信息搜索最优解，凸问题中二次收敛
梯度下降	Gradient Descent	只用一阶导数（梯度）搜索最优解，收敛速度为线性
海森矩阵	Hessian Matrix	目标函数二阶偏导数构成的方阵，描述曲率信息
拟牛顿法	Quasi-Newton Method	用梯度差分信息近似 Hessian，避免直接计算二阶导数
BFGS	BFGS	最常用的拟牛顿法，用秩二更新公式迭代近似 Hessian 逆矩阵
L-BFGS	Limited-memory BFGS	BFGS 的有限内存版本，只存最近 m 步历史，适合大规模问题
超线性收敛	Superlinear Convergence	收敛速度介于线性（梯度下降）和二次（牛顿法）之间
信赖域	Trust Region	限制牛顿步在可信范围内的策略，保证非凸问题中的下降方向
预条件器	Preconditioner	用于改善条件数的矩阵变换，使一阶方法更快收敛；Adam 可视为对角预条件
条件数	Condition Number	Hessian 最大与最小特征值之比，越大梯度下降越低效
鞍点	Saddle Point	某些方向是极小、另一些方向是极大的驻点，非凸优化中的陷阱
Kronecker 积	Kronecker Product	一种矩阵块乘法，K-FAC 用它分解大 Hessian
正交化	Orthogonalization	将矩阵列向量变为正交的过程，Muon 用它做谱预条件