想象你在一个雾气弥漫的山谷里开车回家：家在山谷最低处，可你既没有全景地图，也看不清远处，只能靠脚下的坡度判断方向。把山路换成损失函数，把车换成待训练的参数，把“踩油门调整方向”换成一次次更新参数——这就是优化算法要解决的事。 怎么判断朝哪开、油门踩多大、要不要借着惯性冲过小坑、四个轮子要不要各自调刹车……这些司机的决策，恰好对应着梯度下降、学习率策略、动量法和自适应学习率。而 Adam，就是集惯性、独立刹车与起步校准于一身的“老司机”。 这篇文章用一套“开车下山”的比喻，把面试里最常考到的优化算法原理、对比口径与调参思路讲透。你不需要先懂数学公式，只要跟着这位司机上路，就能在面试中把“为什么用 Adam”“学习率怎么衰减”“SGD 和 Adam 怎么选”讲得明明白白。

岗位关联

优化器是 AI 面试必考的基础盘。掌握这套比喻框架和对比口径，你就能在技术面里三分钟讲清 SGD、动量与 Adam 的取舍关系，避免“用过却说不出原理”的尴尬，稳稳拿下这一分。

目录
  1. 可视化演示
  2. 梯度下降家族
  3. 学习率策略
  4. 动量法
  5. 自适应学习率
  6. Adam 优化器
  7. 选型对比
  8. 收敛与调参
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

本节配有交互动效（进入视口后自动加载，约 3KB）。

优化器收敛轨迹：四种算法对比 Adam：自适应学习率，最快收敛到最优 Momentum：惯性加速，平稳下降 SGD：基础梯度下降，震荡明显 θ = θ - η × ∇L(θ) 滑块调节学习率，观察收敛速度变化

梯度下降家族

想象你开着一辆越野车往山谷底部回家，山脚就是损失函数的最低点。回家这件事，不同司机有不同策略：第一种司机下车把整片山坡的每一寸路面都测一遍坡度，再挑最陡的方向走；第二种司机瞟一眼轮胎正下方就猛打方向盘，边走边看；第三种司机则扫过车头前方十几米的一段路，大致判断整体走向再动。三种策略，恰好对应梯度下降家族的三个成员。

机器学习里，“山坡”是损失函数 J(θ)，“车的朝向”是参数 θ，“最陡方向”是梯度 ∇J(θ)。一次性用全部训练数据计算梯度，方向最准，但每走一步都要遍历整个数据集，代价极高——这叫批量梯度下降（BGD）。每次只随机抽一个样本算梯度——这是随机梯度下降（SGD），单步开销极小，但单个样本的方向噪声很大，路径像醉汉开车般歪歪扭扭。

深度学习实际训练几乎都用小批量梯度下降（Mini-batch GD）：每轮随机取 |S| 个样本，把它们的梯度平均后再更新。它兼得两边好处——方向比 SGD 稳、开销比 BGD 小，而且小批量天然适合 GPU 并行计算。数学上就是这样一个更新式：

回到下山：BGD 是测绘全山，SGD 是只看轮底，Mini-batch 是提前看十几米路。面试时你只要说清“小批量综合判断”这个折中逻辑，再点出三者时间开销与稳定性差异，考官就知道你的方向感很准。

θt+1=θt−η∣S∣∑i∈S∇J(θt;x(i),y(i))\displaystyle \theta_{t+1} = \theta_t - \frac{\eta}{|S|}\sum_{i \in S} \nabla J(\theta_t; x^{(i)}, y^{(i)})
每个 mini-batch 给出一小段路的“综合坡度”，参数朝坡度的反方向挪一步；|S| 越大，坡度越接近全山平均，越稳但越费时间。
  1. 参数位置第 t 轮更新前，车当前所在的位置，也就是模型当前的权重。
    θt\theta_t
  2. 学习率每一步迈多大，相当于油门深度。
    η\eta
  3. 小批量平均梯度对 S 内每个样本分别算坡度再平均，得到眼前这段路的综合走向。
    1∣S∣∑i∈S∇J(θt;x(i),y(i))\frac{1}{|S|}\sum_{i \in S} \nabla J(\theta_t; x^{(i)}, y^{(i)})
  4. 参数更新朝综合坡度的反方向走一步，得到新位置。
    θt+1=θt−η⋅g\theta_{t+1} = \theta_t - \eta \cdot g

学习率策略

同一位司机，油门踩多深，直接决定是顺利回家还是翻进沟里。学习率就是深度学习里那枚“油门踏板”——它控制每一步参数更新的幅度，是训练里最敏感的超参数。

学习率 η 设得太大，一步跨过山谷甚至冲上对面山坡，损失函数来回震荡，严重时直接发散到 NaN，相当于飙车冲出弯道；设得太小，像蚂蚁爬坡，几十个 epoch 过去还在山腰原地踏步，训练迟迟不收敛。因此实践中几乎都会使用学习率衰减：前期保持较大学习率快速下山，后期逐步减小，让参数在谷底附近精细收敛。

最常用的“按步衰减”策略，是每训练 T 轮就把学习率乘以一个小于 1 的因子 ρ。公式如下：

除了按步衰减，还有指数退火——每一轮都把学习率乘上略小于 1 的因子，让油门平滑收小；实际项目里还有余弦退火等变体。面试中能说出“前期大步探索、后期精细收敛”这八个字，再补一个衰减公式，这一问就稳了。这就像跑长途，平直大道上深踩油门，临近家门口收油轻点刹车，才能稳稳停在车位里。

ηt=η0×ρ⌊t/T⌋\displaystyle \eta_t = \eta_0 \times \rho^{\lfloor t / T \rfloor}
每开完 T 公里，把油门限量调小一档；ρ < 1，乘的次数越多，油门越小，车就越接近稳稳停进车位。
  1. 初始学习率出发时的油门深度，通常设在 0.01 到 0.1 之间。
    η0\eta_0
  2. 衰减因子每次衰减时乘上的比例，比如 0.1 表示直接把学习率缩小到十分之一。
    ρ\rho
  3. 阶段计数t 是当前迭代轮次，除以 T 后向下取整，表示已经过了多少个衰减阶段。
    ⌊t/T⌋\lfloor t / T \rfloor
  4. 整体作用阶段数越多，指数越高，学习率越小，后期更新越精细。
    η0×ρ⌊t/T⌋\eta_0 \times \rho^{\lfloor t / T \rfloor}

动量法

山路常有弯弯绕绕的小土坡：忽上忽下，方向乱变。有经验的司机发现，与其每一步都被眼前小坡牵着走，不如让车的惯性帮忙——下坡时惯性加速，遇到小凸起时惯性带着冲过去，方向基本不被打乱。

动量法（Momentum）正是给优化器装上“惯性”。它额外维护一个速度变量 v，每一步都先把上一轮的速度按比例保留下来，再叠加上当前坡度给出的“推力”。如果连续几步方向一致，速度越滚越大，加速下山；如果方向来回摇摆，新旧速度互相抵消，震荡自然被抑制。

数学上，动量法把参数更新从“直接减梯度”改成了“先累加速度，再沿速度滑行”：

动量法的额外红利是更容易冲出浅坑：遇到一个局部小凹坑，只要有足够的速度，惯性会直接带你翻过坑沿继续向下。面试时你只需说“方向一致的步子越走越快，方向乱变的步子互相抵消”，考官就知道你抓住了它的物理本质。

vt=γvt−1+η∇J(θt),θt+1=θt−vt\displaystyle v_t = \gamma v_{t-1} + \eta \nabla J(\theta_t), \qquad \theta_{t+1} = \theta_t - v_t
新速度 = 0.9 × 旧速度 + 本轮坡度给的推力；参数不再沿瞬时梯度走，而是沿合成速度滑出去。
  1. 历史速度上一轮积累下来的惯性，相当于记忆里“车正在往哪个方向滑”。
    vt−1v_{t-1}
  2. 动量系数通常取 0.9，决定保留多少旧速度；越大惯性越强，但也越容易刹不住车。
    γvt−1\gamma v_{t-1}
  3. 本轮推力当前坡度给出的瞬时加速度，相当于新看到的这一段路。
    η∇J(θt)\eta \nabla J(\theta_t)
  4. 参数更新沿合成速度滑行一步，而不是沿瞬时梯度走，这就是“惯性”的落点。
    θt+1=θt−vt\theta_{t+1} = \theta_t - v_t

自适应学习率

山路不仅是坡度问题，还有“路况”差异：有的方向坑坑洼洼，有的方向一马平川。聪明的司机会给四个轮子分别调刹车——崎岖方向踩重些避免颠簸，平坦方向松刹车跑快些。这就是逐参数自适应学习率的朴素直觉。

AdaGrad 是最早的尝试：对每个参数，把历史所有梯度的平方累加起来，历史梯度大的参数自动得到更小的步长。它的致命缺点是累加值只会单调增大，刹车越踩越死，训练后期几乎走不动。RMSProp 做了关键改进：用滑动窗口代替全量累加，只记“最近一段路况”，这样刹车既能及时响应新路况，又不会被几个月前的旧坑洞永久拖累。

RMSProp 的核心是维护每个参数的梯度平方滑动平均：

这套“各方向各走各的步长”的思路，正是自适应学习率方法的共同灵魂。它像每次出门只参考最近一周的路况来调刹车，既跟得上新变化，又不被老账拖累。

E[g2]t=ρ E[g2]t−1+(1−ρ) gt2,θt+1=θt−ηE[g2]t+εgt\displaystyle \mathbb{E}[g^2]_t = \rho \, \mathbb{E}[g^2]_{t-1} + (1-\rho) \, g_t^2, \qquad \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{\mathbb{E}[g^2]_t + \varepsilon}} g_t
每个参数维护一个“近期路况指数”；路况越颠簸，该参数当轮的步长就越短，从而在崎岖方向上自动减速。
  1. 当前路况本轮该参数的梯度平方，用来衡量这个方向起伏的剧烈程度。
    gt2g_t^2
  2. 历史路况衰减上一轮的路况指数乘以 ρ，让旧信息按比例淡出视野。
    ρ E[g2]t−1\rho \, \mathbb{E}[g^2]_{t-1}
  3. 新旧加权合并新的路况只占 1-ρ 的权重，通常 ρ=0.9，即九成旧、一成新。
    (1−ρ) gt2(1-\rho) \, g_t^2
  4. 步长缩放更新时除以路况的平方根，ε 是一个极小常数，防止除零。
    ηE[g2]t+ε\frac{\eta}{\sqrt{\mathbb{E}[g^2]_t + \varepsilon}}

Adam 优化器

如果把“惯性”和“四轮独立刹车”装进同一辆车：下坡有惯性加速，转弯处每个轮子按各自路况独立减速——这就是 Adam。它自 2014 年提出后迅速成为深度学习的事实标准，也是面试中默认你会用的优化器。

Adam 内部维护两个量：一阶矩 m，是对梯度做指数加权平均，相当于带惯性的“平均前进方向”；二阶矩 v，是对梯度平方做指数加权平均，相当于“路况记录”。由于 m、v 初始都为零，起步阶段读数会被严重低估，所以 Adam 还加了偏差修正，把起步时的异常读数校准回来。

完整的 Adam 更新过程可以写成：

Adam 的默认超参 β₁=0.9、β₂=0.999、ε=1e-8 几乎不用手动调整，像一辆出厂就调好底盘的新车。这也是面试官默认你会用它起步的原因——它把动量的快和自适应步长的稳结合得恰到好处。

m^t=mt1−β1t,v^t=vt1−β2t,θt+1=θt−ηv^t+εm^t\displaystyle \hat{m}_t = \frac{m_t}{1-\beta_1^t}, \quad \hat{v}_t = \frac{v_t}{1-\beta_2^t}, \qquad \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{\hat{v}_t} + \varepsilon} \hat{m}_t
m 是平均方向，v 是路况读数；修正是把起步阶段偏小的读数放大校准；最终步长 = 全局油门 × 平均方向 ÷ 路况。
  1. 一阶矩对梯度做指数加权平均，累积出类似动量的前进方向。
    mt=β1mt−1+(1−β1)gtm_t = \beta_1 m_{t-1} + (1-\beta_1) g_t
  2. 二阶矩对梯度平方做指数加权平均，记录每个方向的颠簸程度。
    vt=β2vt−1+(1−β2)gt2v_t = \beta_2 v_{t-1} + (1-\beta_2) g_t^2
  3. 偏差修正t 很小时 m、v 被初值零拉低，除以 1-β^t 把读数校准到无偏。
    m^t=mt1−β1t\hat{m}_t = \frac{m_t}{1-\beta_1^t}
  4. 路况缩放步长用路况的平方根缩放方向项，颠簸方向自动走小步。
    ηv^t+εm^t\frac{\eta}{\sqrt{\hat{v}_t} + \varepsilon} \hat{m}_t
  5. 参数更新完成一步移动，进入下一轮迭代。
    θt+1=θt−Δt\theta_{t+1} = \theta_t - \Delta_t

选型对比

家里的车库停着不同性格的车：Adam 是自动驾驶的舒适 SUV，SGD 加动量是手动挡老车但越开越稳，RMSProp 是省油小车。选哪辆，取决于你要跑长途、跑市区，还是油钱紧张。

面试中最忌讳“背结论”，要会从三个维度做取舍。收敛速度：Adam 靠自适应步长通常前期最快。内存开销：SGD 只存参数本身，Adam 要额外存一阶矩和二阶矩两份状态，显存占用大约是 SGD 的 2 倍。泛化能力：大量实验发现 SGD（或 SGD+Momentum）最终收敛到“更平坦”的极小值，在测试集上往往比 Adam 更好。所以实践中常有一种打法：前期用 Adam 快速压低损失，后期切换到 SGD 加学习率衰减做精细打磨。

所有优化器其实都可以装进同一个更新框架——回答两个问题：往哪走、走多远。

这一节的对比口径，几乎是面试必考。记住“方向、步长、显存”三元组，再补一句实战口诀“Adam 起步、SGD 收尾”，比背十个结论都管用。

θt+1=θt−η⋅dt⋅st\displaystyle \theta_{t+1} = \theta_t - \eta \cdot d_t \cdot s_t
d_t 是方向项（瞬时梯度、速度或一阶矩），s_t 是步长项（1 或 1/√v̂）；SGD 两个都不改，Adam 两个都改。
  1. 全局学习率所有优化器共用的基础油门。
    η\eta
  2. 方向校正项Momentum 和 Adam 不直接用瞬时梯度，而是用累积的速度或一阶矩作为方向。
    dtd_t
  3. 步长校正项自适应方法按路况缩放步长，即每个参数除以自己的路况平方根。
    st=1v^t+εs_t = \frac{1}{\sqrt{\hat{v}_t} + \varepsilon}
  4. 统一后的差异对比时只需要说明“谁改了方向、谁改了步长、要多存多少状态”。
    θt+1=θt−η⋅dt⋅st\theta_{t+1} = \theta_t - \eta \cdot d_t \cdot s_t

收敛与调参

车开得对不对，要看仪表盘。训练的仪表盘就是损失曲线。但原始损失曲线毛刺很多——尤其是 SGD，锯齿密得看不清趋势。经验丰富的工程师会先做平滑，再看趋势。

TensorBoard 里的 smooth 滑块、各种训练曲线的平滑功能，本质都是指数加权平均（EWA）：新读数只占一小部分权重，历史趋势缓慢更新。判断收敛有三条线索：训练损失降到平台期不再明显下降；验证集损失不再下降甚至开始回升（过拟合预警）；曲线尾巴只在极小区间内抖动。把这三条合起来看，才敢说“模型训好了”。

平滑公式就是一个递推式：

调参顺序也有讲究：先定优化器和学习率，再看曲线决定衰减节奏，最后动 batch size 与动量系数。老司机也是先看仪表盘再动手脚——调参不是玄学，是读曲线加小步试错的循环。

Jˉt=βJˉt−1+(1−β)Jt\displaystyle \bar{J}_t = \beta \bar{J}_{t-1} + (1-\beta) J_t
每一时刻的平滑读数 = 0.9 × 上一刻平滑值 + 0.1 × 当前原始读数。毛刺被摊薄，趋势浮现出来。
  1. 原始读数当轮真实训练损失，含大量高频噪声。
    JtJ_t
  2. 历史平滑值上一轮的平滑结果，相当于已经积累的趋势。
    Jˉt−1\bar{J}_{t-1}
  3. 平滑系数通常取 0.9 到 0.99，越大曲线越平，但响应越滞后。
    β\beta
  4. 新旧混合新旧读数按比例合并，得到新的平滑读数，供人眼判读。
    Jˉt\bar{J}_t

AI 应用场景

视觉模型训练选型与切换

阶段：模型训练与调优

解决的问题：直接全程使用 SGD 训练 ResNet，前期收敛太慢，几十个 epoch 损失还高高在上；全程使用 Adam，后期又容易过拟合、验证集抖动。传统做法靠反复试错，浪费大量 GPU 时间。利用本文的对比框架，可采取“Adam 快速下山 + SGD 精细打磨”的两段式策略，兼顾速度与泛化。

具体案例：某图像分类业务中，ResNet-50 前 80% 轮次用 Adam 快速压低损失，后 20% 切换 SGD+Momentum 并配合按步衰减，训练轮数减少约 30%，验证集准确率比全程 Adam 高出约 0.8 个百分点。

大模型微调的显存攻坚

阶段：模型微调与部署前优化

解决的问题：7B 参数的 LLM 若用 Adam 全参微调，仅 m、v 两份优化器状态就要各存一份 7B 参数的浮点数，显存几乎翻倍，普通显卡直接内存溢出。传统直觉是“换更大的卡”，成本高昂；理解优化器内存结构后，可针对性下药。

具体案例：用 LoRA 把可训练参数降到千分之一量级，再配合轻量优化器替代 Adam 的状态存储，在单张 24G 显存显卡上即可完成 7B 模型微调，显存占用下降 90% 以上。

训练曲线的平滑与收敛判断

阶段：训练监控与诊断

解决的问题：分布式训练中 loss 曲线毛刺极大，工程师难以判断模型到底在收敛还是震荡，只能靠肉眼猜。用指数加权平均平滑曲线后，趋势一目了然，可以在 loss 进入平台期时及时决定是否降低学习率或提前停止。

具体案例：某中文大模型预训练中，使用 1000 步线性热身加余弦退火的学习率调度，并用平滑系数 0.99 的 EWA 曲线做监控，成功将训练损失稳定压到基线水平，避免了初期 loss 冲高导致的训练失败。

Python 演示

python65 行
import numpy as np def cost(theta):    return theta[0] ** 2 + 2.0 * theta[1] ** 2 def grad(theta):    return np.array([2.0 * theta[0], 4.0 * theta[1]]) def run_sgd(init, lr=0.1, steps=30):    theta = init.copy()    path = np.zeros((steps + 1, 2))    path[0] = theta    for t in range(steps):        theta = theta - lr * grad(theta)        path[t + 1] = theta    return path def run_momentum(init, lr=0.08, mu=0.9, steps=30):    theta = init.copy()    v = np.zeros_like(theta)    path = np.zeros((steps + 1, 2))    path[0] = theta    for t in range(steps):        v = mu * v - lr * grad(theta)        theta = theta + v        path[t + 1] = theta    return path def run_rmsprop(init, lr=0.05, rho=0.9, eps=1e-8, steps=30):    theta = init.copy()    s = np.zeros_like(theta)    path = np.zeros((steps + 1, 2))    path[0] = theta    for t in range(steps):        g = grad(theta)        s = rho * s + (1 - rho) * g * g        theta = theta - lr * g / (np.sqrt(s) + eps)        path[t + 1] = theta    return path def run_adam(init, lr=0.1, b1=0.9, b2=0.999, eps=1e-8, steps=30):    theta = init.copy()    m = np.zeros_like(theta)    v = np.zeros_like(theta)    path = np.zeros((steps + 1, 2))    path[0] = theta    for t in range(1, steps + 1):        g = grad(theta)        m = b1 * m + (1 - b1) * g        v = b2 * v + (1 - b2) * g * g        mhat = m / (1 - b1 ** t)        vhat = v / (1 - b2 ** t)        theta = theta - lr * mhat / (np.sqrt(vhat) + eps)        path[t + 1] = theta    return path if __name__ == "__main__":    init = np.array([1.2, -1.0])    for name, path in (        ("SGD", run_sgd(init)),        ("Momentum", run_momentum(init)),        ("RMSProp", run_rmsprop(init)),        ("Adam", run_adam(init)),    ):        print(name, "30-step loss:", round(cost(path[-1]), 6))
目的：在同一个二元二次函数上跑通四种优化器，对比 30 步后的收敛效果，直观验证“Adam 快、SGD 稳”的差异。
  1. def grad(theta):返回当前位置的坡度向量，对应下山比喻中的“眼前坡度”。
  2. v = mu * v - lr * grad(theta)动量法核心：惯性加上新推力，合成新速度。
  3. theta = theta + v动量法沿合成速度滑行，而不是沿瞬时梯度走。
  4. s = rho * s + (1 - rho) * g * gRMSProp 的滑动窗口路况统计，只记近期。
  5. theta = theta - lr * g / (np.sqrt(s) + eps)路况越颠簸步长越短。
  6. m = b1 * m + (1 - b1) * gAdam 的一阶矩，累积平均方向。
  7. mhat = m / (1 - b1 ** t)偏差修正，校准起步阶段被低估的读数。
  8. theta = theta - lr * mhat / (np.sqrt(vhat) + eps)Adam 完整更新：方向除以路况。

常见误区

误区很多人觉得“面试里说 Adam 最快最好，所以所有任务无脑用 Adam 就对了”，甚至认为用 SGD 是过时做法。

正解Adam 的优势是前期收敛快、对学习率不敏感，但最终泛化能力不一定优于 SGD。大量实验表明 SGD（尤其是带动量）常常收敛到更平坦的极小值，在测试集上表现更好。类比来说，Adam 是起步快的跑车，SGD 是耐力更稳的老爷车；长途比赛（追求泛化）未必是跑车赢。

为何常见：论文和教程里的训练曲线大都是 Adam 跑出来的，初学者只看收敛图不看测试集，误把“快”等同于“好”。

误区“把学习率调大，loss 掉得快，那我直接设 0.5 不就能一步到位了吗？”

正解学习率是步长而非速度。过大时参数会来回跨越山谷，损失剧烈震荡，甚至发散到 NaN。正确策略是先用中等学习率试出量级，再用衰减策略收尾——就像油门踩到底不是最快到家的方式，而是最容易翻车的方式。

为何常见：在小数据、凸函数的简单例子上，大学习率确实偶尔又快又稳，初学者容易把特例当规律。

误区“动量法让步子变大，那我把学习率乘 2 效果不是一样吗？”

正解两者机制完全不同。调大学习率只是放大当前瞬时梯度，方向依然是“一步一看”；动量法是通过速度累积产生方向记忆，连续一致的方向越走越快，方向摇摆的步骤互相抵消。这就像开车，靠惯性滑行和猛踩油门是两回事。

为何常见：二者表面都让“移动距离变大”，不做数值实验很难察觉震荡模式的差异。

误区“Adam 不是自带修正和自适应吗？那把学习率设成 1 它也能自己调好吧。”

正解偏差修正只解决起步阶段 m、v 被零值拉低的问题，它并不保证大学习率不发散。自适应步长只是让每个参数按路况缩放，缩放之后乘以一个过大的全局学习率，照样冲出山谷。出厂调好的底盘不意味着你可以把油门焊死。

为何常见：Adam 的鲁棒性被过度宣传，“免调参”的说法让人忽略了学习率仍然是最重要的超参数。

误区“损失曲面都是大碗套小碗，掉进小碗就永远出不来，所以只能多随机初始化几次碰运气。”

正解低维画出来的“碗形”会误导直觉。高维空间中真正的障碍更多是鞍点——某些方向上升、某些方向下降的“马鞍”。动量法靠着惯性可以冲过鞍点，自适应方法靠着逐方向步长也能摆脱平坦区域。所以实践中“多初始化”远不如“换优化器、加动量”有效。

为何常见：教科书为了直观总画二维碗形图，初学者把二维直觉直接搬到了高维。

面试题

Q1. 批量梯度下降（BGD）每次迭代计算梯度时，使用的数据范围是？

单选题 · easy

  • A.使用全部训练数据集← 正确答案
  • B.只使用单个随机样本
  • C.使用一小批随机样本
  • D.使用验证集全部样本

答案：A。BGD 的“批量”指全部训练集，方向最准但每轮都要完整遍历数据，代价极高。B 是 SGD，C 是 Mini-batch GD，D 用验证集算梯度属于概念混淆。

Q2. 学习率设置过大时，训练通常会出现什么现象？

单选题 · easy

  • A.收敛到更好的极小值
  • B.损失震荡甚至直接发散← 正确答案
  • C.训练速度明显变慢很多
  • D.梯度直接消失变为零值

答案：B。学习率是步长，过大时参数来回跨越谷底，损失震荡甚至发散到 NaN。C 是学习率过小的表现；A 是理想期望而非过大后果；D 是梯度消失或已收敛的问题。

Q3. 动量法（Momentum）的核心思想是模拟什么？

单选题 · mid

  • A.物理学中的惯性效应← 正确答案
  • B.热力学中的温度场
  • C.电磁学中的磁场方向
  • D.光学中的折射率变化

答案：A。动量法保留历史速度并按 γ 衰减叠加当前梯度，本质是惯性：方向一致加速、方向相反抵消。其余选项与梯度下降机制无关，是干扰项。

Q4. Adam 优化器同时结合了以下哪两种机制？

单选题 · mid

  • A.动量法与自适应学习率结合← 正确答案
  • B.批量归一化与网络剪枝结合
  • C.参数共享与权重稀疏化结合
  • D.数据增强与正则化手段结合

答案：A。Adam 的一阶矩对应动量思想，二阶矩对应自适应学习率。B、C、D 分别是归一化、剪枝、数据增强等独立技术，与 Adam 的构造无关。

Q5. 学习率按步衰减（每 T 轮乘一次 ρ）的主要目的是？

单选题 · mid

  • A.前期大步探索后期精细收敛← 正确答案
  • B.前期小步后期大步冲过谷底
  • C.缩小训练和验证集差距
  • D.直接降低模型参数量级

答案：A。衰减让训练前期用大学习率快速下山、后期用小学习率在谷底精细收敛，兼顾速度与稳定。B 方向反了；C、D 与学习率无因果关系。

Q6. 关于 RMSProp 与 AdaGrad 的区别，下列说法正确的是？

单选题 · mid

  • A.RMSProp 累计全部历史平方
  • B.AdaGrad 累计全部历史平方← 正确答案
  • C.AdaGrad 使用指数滑动平均
  • D.两者数学形式完全相同

答案：B。AdaGrad 把历史所有梯度平方累加，单调增长导致步长趋零；RMSProp 用滑动窗口只记近期路况。A 和 C 正好把两者说反了，D 与事实不符。

Q7. Adam 中偏差修正（m̂ = m/(1-β₁ᵗ)）主要解决的问题是？

单选题 · hard

  • A.训练初期矩估计偏向零值← 正确答案
  • B.训练后期学习率失控
  • C.梯度传播出现 NaN 值
  • D.显存占用率过高问题

答案：A。m、v 初值为零，t 很小时加权平均被严重低估，除以 1-βᵗ 可校准到无偏。B 说的是学习率调度，C 是数值稳定性，D 是内存优化，与偏差修正无关。

Q8. 下列哪些方法属于自适应学习率方法？

多选题 · mid

  • A.AdaGrad 累积式方法← 正确答案
  • B.SGD 带动量版本
  • C.RMSProp 滑动窗口法← 正确答案
  • D.Adam 矩估计方法← 正确答案

答案：ACD。自适应学习率指按路况逐参数调整步长，AdaGrad、RMSProp、Adam 都属于。SGD 不论是否带动量，都使用全局统一的固定步长，没有逐参数缩放，因此不选。

Q9. 关于 Adam 与 SGD 的泛化能力，下列说法正确的是？

多选题 · hard

  • A.SGD 常收敛到较平坦极小值← 正确答案
  • B.Adam 一定比 SGD 泛化更好
  • C.SGD 的噪声有隐式正则作用← 正确答案
  • D.微调阶段常回退到 SGD 使用← 正确答案

答案：ACD。SGD 的小批量采样噪声带来隐式正则，常收敛到平坦极小值，测试集表现更好，因此微调阶段常用 SGD。B 是绝对化表述，泛化优劣取决于任务，不能断言“一定更好”。

Q10. 大模型训练中 Adam 带来高显存开销，常见的缓解手段有？

多选题 · extreme

  • A.使用 Adafactor 轻量优化器替代← 正确答案
  • B.对优化器状态进行分片存储← 正确答案
  • C.用 LoRA 减少训练参数量← 正确答案
  • D.直接降低 batch size 到 1

答案：ABC。Adam 需存 m、v 两份状态，可用轻量优化器、分片或降参直接削减状态量。D 降低 batch size 影响训练效率与曲线稳定性，且并不直接减少优化器状态本身，故不选。