Lion优化器原理与训练实战

可视化演示

1 算法诞生：机器裁判选出的向导

山脚下的村庄要选拔下一任登山向导。以前靠人类老猎手拍脑袋总结经验，可这一次，“选向导”这件事本身被一台机器裁判接管了：它让成千上万种随机的“走法公式”在模拟山谷里互相比赛，跑得好的留下来继续变异，跑得差的直接淘汰。几轮进化之后，一个极其简单的走法杀出重围。

这个“机器裁判”正是 Google 研究团队在 2023 年论文《Symbolic Discovery of Optimization Algorithms》中做的符号程序搜索（symbolic program search）。他们不靠人肉调公式，而是把更新规则本身当作搜索对象：搜索空间由加、减、乘、指数、符号函数等基础算子搭成，让优化器公式在大量小型任务上“进化”，最终胜出的更新规则被命名为 EvoLved Sign Momentum（进化出的符号动量），简称 Lion。

从结构上看，Lion 并不复杂：它只维护一份一阶动量，更新时对“动量与梯度的混合方向”取符号，再叠加上解耦的权重衰减。搜索器之所以选中这个“简单配方”，是因为它在视觉、语言等大量任务上普遍比 AdamW 更稳、更快、更省内存——有时候，冠军的招数并不花哨，只是恰好踩中了正确的节奏。

所以新向导不是人类老猎手想出来的，而是机器在山谷模拟器里“打榜”打出来的冠军。它的走路方式出乎意料地简单：不看坡度多陡，只认左右方向。接下来我们就拆开它的步子仔细看。

2 核心更新规则：只问方向不问大小的狮子步

拿到向导执照后，人们开始观察 Lion 的走法。它从不掏出坡度计去测“这步坡度是 30° 还是 5°”，只做一个判断——该往左还是往右，然后迈出固定步幅。这个“往哪边走”的判断，来自它兜里那本小本子记录的动量。

本子上的内容在数学上叫一阶动量 $m$。它记录的不是当前这一脚的感觉，而是把最近若干步的方向做指数滑动平均——就像你走路时身体的惯性，不会因为脚下突然多了块小石头就急转弯。Lion 每一步先算一个候选方向 $c$，把“惯性方向”和“当前脚下坡度”按比例混合，再对 $c$ 取符号得到方向，参数就朝这个方向挪动一个学习率大小的步幅。

$$c_t = \beta_1 m_{t-1} + (1-\beta_1) g_t$$

$$\theta_t = \theta_{t-1} - \mathrm{lr}_t \times \left( \mathrm{sign}(c_t) + \lambda \theta_{t-1} \right)$$

$$m_t = \beta_2 m_{t-1} + (1-\beta_2) g_t$$

1. 候选方向：把昨天的动量 $m_{t-1}$ 与今天的梯度 $g_t$ 按 $\beta_1$ 加权混合，得到复合方向 $c_t$，相当于“惯性 + 脚下坡度”的综合判断。

$$c_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t$$

2. 参数更新：把当前位置朝 $c_t$ 的符号方向挪动一步，脚步大小由 $\mathrm{lr}_t$ 控制，符号函数保证方向只有正负两种。

$$\theta_t = \theta_{t-1} - \mathrm{lr}_t \times \mathrm{sign}(c_t)$$

3. 权重衰减项：$\lambda \theta_{t-1}$ 把参数往 0 方向轻拉，防止登山者越走越偏，这就是解耦权重衰减。

$$\theta_t \leftarrow \theta_t - \mathrm{lr}_t \times \lambda \theta_{t-1}$$

4. 动量更新：用另一组系数 $\beta_2$ 更新动量本子，默认 $\beta_1=0.9$、$\beta_2=0.99$，大批量训练时 $\beta_1$ 可调到 0.95。

$$m_t = \beta_2 m_{t-1} + (1 - \beta_2) g_t$$

这套“只看方向、固定步幅”的动作，像极了老狮子的标准步法：干脆、果断，不纠结于脚下每一寸坡度的变化。但固定步幅也有代价——后面会看到，它需要把步子调小、系上安全绳，才能在山谷里站稳。

3 与 Adam 全面对比：两份本本与一份本本

老向导 Adam 是村里经验最丰富的向导，他兜里揣着两本本子。第一本记动量，第二本记“坡度变化快慢”（二阶矩）。每走一步前，他都要翻两本本子算出一个恰到好处的步幅：坡陡时小步挪，坡缓时大步走。这是 Adam 最大的优点，也是它最大的负担。

Lion 上任后，人们对比发现两套走法的核心差别：Adam 修参数时，除了一阶矩，还要除以二阶矩的开方来做自适应缩放；Lion 根本没有第二本本子，也不除任何东西，只取符号。一个是“算好幅度再迈步”，一个是“只定方向就迈步”。

$$\theta_t = \theta_{t-1} - \frac{\mathrm{lr} \, \hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}$$

其中 $\hat{m}_t$、$\hat{v}_t$ 是偏差修正后的一阶矩与二阶矩，$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$。

1. 一阶矩 m：对梯度做指数滑动平均，相当于记“总方向”，Adam 和 Lion 都有。

$$m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t$$

2. 二阶矩 v：对梯度的平方做指数滑动平均，衡量坡度变化的剧烈程度，这是 Adam 专属的第二本本子。

$$v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2$$

3. 偏差修正：训练初期把 m、v 除以修正系数，避免起步时估计太小。

$$\hat{m}_t = \frac{m_t}{1 - \beta_1^t}, \quad \hat{v}_t = \frac{v_t}{1 - \beta_2^t}$$

4. 归一化更新：用修正后的一阶矩除以二阶矩开方，得到一个带“幅度”的自适应步长，而 Lion 用 sign 把这个幅度整个丢掉。

$$\theta_t = \theta_{t-1} - \frac{\mathrm{lr} \, \hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}$$

用登山打比方：Adam 每次迈步前都翻两本本子，算出“这步该迈 8 厘米还是 3 厘米”；Lion 永远迈同一个步长，只决定往左还是往右。前者精细，后者干脆，而在漫长的大模型登山路上，干脆常常更省力——代价是你要更小心地调好那双鞋。

4 内存与算力优势：背包减半的登山队

登山队除了向导，还要背补给，装备越重走得越慢。训练大模型时，显存就是登山队的补给总量。Adam 那本“坡度变化本本”（二阶矩 $v$）不是白给的——每个参数都要配一份，万亿参数就是万亿个数，存起来非常占地方。

Lion 把二阶矩状态整个删掉，只留动量一本本子。于是每个参数的优化器状态从两个数变成一个数，恰好省下一半。这对动辄百亿、千亿参数的大模型极其宝贵：省下来的显存可以放大 batch、加长序列长度，或者把模型再撑大一点。

$$\frac{\text{Memory}_{\text{Lion}}}{\text{Memory}_{\text{Adam}}} = \frac{P}{2P} = \frac{1}{2}$$

1. 状态量成本：$P$ 表示“每个参数配一个状态变量”时的总数目，也就是参数量本身。

$$P = \text{参数个数}$$

2. Adam 的负担：每个参数要额外保存 $m$ 和 $v$ 两份状态，总状态数是 $2P$。

$$\text{Memory}_{\text{Adam}} = 2 \times P$$

3. Lion 的轻装：只保留一份动量状态，总状态数是 $P$。

$$\text{Memory}_{\text{Lion}} = P$$

4. 比值：两者相除，恰好省下 50% 的优化器状态内存。

$$\frac{P}{2P} = \frac12$$

补给减半，登山队就能带更多水和干粮（数据和更大的 batch），走得更远。这正是 Lion 在大模型时代最直接的诱惑——同样的显存，它能让你“背”更大的模型。

5 训练调参要点：步幅、绳扣与热身

新向导虽然省力，但性子野：固定步幅意味着它不会因为坡陡就自动收脚，如果照抄 Adam 的步幅去迈，Lion 会在山谷两侧来回横跳，甚至直接摔下悬崖。所以实战第一条铁律：调小学习率。

论文给出的经验是：Lion 的最佳学习率一般是 AdamW 的 1/3 到 1/10；权重衰减建议调大约 10 倍（比如 AdamW 用 0.01 时，Lion 用 0.1）。这两招是“移植”Lion 的起手式，也是大多数翻车的根源。除此之外，默认的 $\beta_1=0.9$、$\beta_2=0.99$ 不用动，大批量训练可把 $\beta_1$ 提到 0.95；学习率调度建议沿用 warmup + cosine decay，跟 AdamW 一样。

$$\mathrm{lr}_{\text{Lion}} \approx \frac{1}{10} \, \mathrm{lr}_{\text{AdamW}}, \qquad \lambda_{\text{Lion}} \approx 10 \, \lambda_{\text{AdamW}}$$

1. 学习率缩小：Lion 每步都是符号方向的等幅移动，比 Adam 的自适应步长更“野”，所以 $\mathrm{lr}$ 通常取 AdamW 的 1/3 到 1/10。

$$\mathrm{lr}_{\text{Lion}} \approx \frac{1}{10} \, \mathrm{lr}_{\text{AdamW}}$$

2. 权重衰减放大：符号项丢了幅度信息，正则任务大多落到权重衰减身上，所以 $\lambda$ 建议放大到 10 倍左右。

$$\lambda_{\text{Lion}} \approx 10 \, \lambda_{\text{AdamW}}$$

给狮子系上绳扣（权重衰减）、把步子收小（学习率）、出发前先热身（warmup），野性十足的狮子步也能稳稳当当地走完全程，最后带着余弦衰减稳稳停在谷底。

6 实验效果评估：大山深处的记分牌

狮子步被套上缰绳后表现如何？锦标赛的记分牌给出了答案：在图像分类、语言模型预训练、扩散模型等大量任务上，Lion 用同等甚至更少的算力，拿到了接近或更优的成绩。

论文中的实测量级大概是：视觉 Transformer（ViT）在 ImageNet 上，Lion 能到约 87% 的 top-1 精度，高于 AdamW 的约 85.5%；BERT-Large 这类语言模型预训练中，达到同等困惑度所需的总算力大约只有 AdamW 的 1/3；在扩散模型（如 DiT 架构）上，Lion 也常带来更低的 FID。注意这些提升主要出现在“从头预训练大模型”的场景，而不是所有任务。

$$\frac{\text{Compute}_{\text{Lion}}}{\text{Compute}_{\text{AdamW}}} \approx \frac13 \quad (\text{同等效果下的部分预训练场景})$$

1. 总计算量：训练到同一精度所需的全部计算资源，按下式估算。

$$\text{Compute} = \text{卡时} \times \text{卡数}$$

2. 节约比例：部分预训练任务上，Lion 达到同等效果只需约 1/3 的算力。

$$\frac{\text{Compute}_{\text{Lion}}}{\text{Compute}_{\text{AdamW}}} \approx \frac13$$

记分牌上那串数字，等于告诉山民：新向导在大山深处（大模型）的表现，确实让老练的 Adam 刮目相看。尤其“同等精度下算力只要三分之一”这句话，正是工业界最心动的广告。

7 局限与工程选型：不是万能的登山鞋

但向导也有不擅长的路。Lion 只认方向不认大小，等于把“脚下坡度多陡”这个信息全部丢掉。在梯度噪声很大的乱石坡（小批量、高噪声、稀疏反馈场景），它每一步都一样大，容易在石缝间打滑。

数学上，符号函数在几乎所有点上导数为 0，在原点甚至不可导——这既是它省内存的原因，也是它对幅度信息零感知的根源。实践中也确实观察到：并非所有任务都归 Lion，部分 NLP 小任务、某些 Transformer 变体上 AdamW 依然更好；Lion 对学习率也更敏感，lr 挑不好会直接发散。

$$\frac{\mathrm{d}}{\mathrm{d}x} \, \mathrm{sign}(x) = 0 \quad (x \neq 0), \qquad \mathrm{sign}(0) \ \text{不可导}$$

1. 分段导数：sign 在非零点导数为 0，说明它完全不感知输入幅度。

$$\frac{\mathrm{d}}{\mathrm{d}x} \, \mathrm{sign}(x) = 0 \quad (x \neq 0)$$

2. 不可导点：x=0 处左右导数不一致，本质不可导，体现了符号操作“干脆但不平滑”的特性。

$$\mathrm{sign}(0) \ \text{不可导}$$

所以村长的建议是：去大山深处（大模型预训练、大规模视觉或扩散任务）优先装备狮子步；在小山头和乱石坡（小模型、微调、高噪声场景）还是让 AdamW 这员老将上。两个向导各管一段路，才是工程上最稳的组合。

AI 应用场景

Python 演示

import numpy as np def loss_fn(p):    x, y = p    return 0.5 * x * x + 5.0 * y * y def grad_fn(p):    x, y = p    return np.array([x, 10.0 * y]) def lion_step(p, m, g, lr, wd, beta1, beta2):    c = beta1 * m + (1 - beta1) * g    p = p - lr * (np.sign(c) + wd * p)    m = beta2 * m + (1 - beta2) * g    return p, m def adam_step(p, m, v, t, g, lr, beta1, beta2):    m = beta1 * m + (1 - beta1) * g    v = beta2 * v + (1 - beta2) * g * g    mh = m / (1 - beta1 ** t)    vh = v / (1 - beta2 ** t)    p = p - lr * mh / (np.sqrt(vh) + 1e-8)    return p, m, v def train(opt, lr0, steps=300):    p = np.array([1.0, 1.0])    m = np.zeros(2)    v = np.zeros(2)    total = 0.0    for t in range(1, steps + 1):        decay = 0.5 * (1 + np.cos(np.pi * t / steps))        lr = lr0 * decay        g = grad_fn(p)        if opt == "lion":            p, m = lion_step(p, m, g, lr, 0.0, 0.9, 0.99)        else:            p, m, v = adam_step(p, m, v, t, g, lr, 0.9, 0.999)        total += loss_fn(p)    return loss_fn(p), total if __name__ == "__main__":    for name, lr0 in [("lion", 0.04), ("adam", 0.08)]:        final, total = train(name, lr0)        print("opt=%-4s final loss=%.2e cum-loss=%.2f" % (name, final, total))

1. def lion_step(p, m, g, lr, wd, beta1, beta2):Lion 一步的完整实现，输入参数、动量、梯度，输出更新后的参数和动量。
2. c = beta1 * m + (1 - beta1) * g把惯性动量与当前梯度混合成候选方向，相当于登山者综合“惯性 + 脚下坡度”。
3. p = p - lr * (np.sign(c) + wd * p)sign 把方向压缩成 ±1，固定步长迈步；wd * p 是解耦权重衰减，把参数往原点轻拉。
4. m = beta2 * m + (1 - beta2) * g用另一组 β 更新动量本子，beta2=0.99 表示动量记得很久。
5. def adam_step(...)对照实现：Adam 多维护二阶矩 v，更新时除以 sqrt(v) 来自适应缩放步长。
6. decay = 0.5 * (1 + np.cos(np.pi * t / steps))余弦学习率衰减，这是 Lion 能稳定停在谷底的关键配套动作。
7. for name, lr0 in [("lion", 0.04), ("adam", 0.08)]:Lion 用更小的学习率起跑，符合“学习率缩到十分之一”的实战经验。

常见误区

面试题