想象你是一位厨师，正在熬一锅汤。想知道咸淡，你有三种办法：端起锅把整锅汤喝完，用指尖蘸一滴尝，或用勺子舀一小口。喝完一整锅，你掌握了最准确的味道，但代价是时间久、肚子撑；蘸一滴，瞬间出结果，可这一滴可能刚巧没沾到盐，让你误判；舀一小口，又快又有代表性，成为老练厨师的标准动作。 梯度下降训练神经网络的“喂数据”过程，与这如出一辙。批量梯度下降用全部样本算一次方向，随机梯度下降只看一条样本，小批量梯度下降取一小撮样本。本文将带你认识这三把“勺子”，理解它们的收敛抖动、显存消耗与速度差异，并学会在实际工程中挑选合适的 batch size。

岗位关联

学会控制喂数据的方式，等于掌握训练神经网络的油门与刹车，让你在算力有限时也能驯服模型。

目录
  1. 可视化演示
  2. 数据喂养三模式
  3. 批量梯度下降
  4. 随机梯度下降
  5. 小批量梯度下降
  6. 收敛特点对比
  7. 资源权衡
  8. batch size 选择
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

展示批量(BGD)、随机(SGD)、小批量(MBGD)三种梯度下降的数据使用方式、收敛轨迹与batch size对泛化的影响。

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

三种梯度下降变体 BGD用全部样本（稳但慢），SGD用1个样本（快但抖），MBGD用mini-batch折中 BGD: N, SGD: 1, MBGD: b MBGD是工程实践最常用的优化方法

数据喂养三模式

像厨师试汤一样，梯度下降也需要“品尝”数据。每次参数更新前，模型都要计算一个“咸淡方向”——也就是损失函数对参数的梯度。这里的“梯度”可以理解为：这锅汤现在偏咸还是偏淡、该加盐还是加水，以及该加多少。用多少条数据来算这个方向，决定了梯度下降的性格。

在机器学习中，常见做法有三种：把训练集里全部 N 条样本都拿来看一遍，称为批量梯度下降（BGD）；只随手抽一条，称为随机梯度下降（SGD）；抽取一小批 B 条，则是小批量梯度下降（Mini-batch GD）。它们唯一的区别，就是梯度的计算范围——喂给模型“尝味道”的数据量不同。

不管哪种方式，参数的更新公式都长成一个样：新参数 = 旧参数 − 学习率 × 梯度估计。公式如下。这里的梯度估计 g 就是我们要喂给模型的“数据味道摘要”。

三把“勺子”尝到的味道各不相同：整锅汤最全，一滴汤最快，一小口最均衡。接下来三节，我们逐一品味。

θt+1=θt−η⋅g\displaystyle \theta_{t+1} = \theta_t - \eta \cdot g
这个公式是梯度下降家族的总纲，不同的 g 来源定义了不同的分支。
  1. 更新规则每一步都要让参数朝损失下降的方向移动。
    θt+1=θt−…\displaystyle \theta_{t+1} = \theta_t - \dots
  2. 学习率\eta 控制迈步子的幅度，相当于你尝汤后决定加多少盐。
    −η⋅g\displaystyle -\eta \cdot g
  3. 梯度估计g 是当前模式计算出的梯度方向，可能来自全部、单条或一小批样本。
    g\displaystyle g

批量梯度下降

想象你把整锅汤一饮而尽：你对咸淡的判断最精确，可是不仅胃被撑满，下结论也慢。批量梯度下降正是如此，每次更新都要计算所有训练样本的梯度并求平均。这个操作好比把所有样本的味道混在一起，得到一个绝对平均的结论。

BGD 的梯度估计是最诚实的。它用全部 N 个样本的梯度和除以 N，得到的方向没有任何抽样噪声，因此参数更新路径非常平滑。但它也有致命伤：每走一步都要遍历全量数据。当数据集有百万条样本时，一步更新就足以让计算资源“撑到胃痛”。

其更新公式可以写成：旧参数减去学习率乘以“平均梯度”。这个平均梯度需要遍历全部样本，所以一步计算量是 O(N)。在凸优化（一种像碗底一样只有一个最低点的简化问题）里，BGD 能稳定收敛到全局最低点；但在深度学习这种“崇山峻岭”的非凸地形里，它反而容易陷在路边的小坑中。

正因如此，BGD 适合数据量小、凸优化或需要精确方向的场景，就像老厨师只为一道镇店之菜才肯整锅试喝。但当汤（数据）太多时，它会让你的“胃”（显存）炸裂——这就是深度学习里几乎不用 BGD 的原因。

θt+1=θt−ηN∑i=1N∇Li(θt)\displaystyle \theta_{t+1} = \theta_t - \frac{\eta}{N} \sum_{i=1}^{N} \nabla L_i(\theta_t)
平均之前，每个样本的梯度都要算一遍，N 越大，这一步越“重”。
  1. 遍历全部样本损失函数对第 i 个样本求梯度。
    ∇Li(θt)\displaystyle \nabla L_i(\theta_t)
  2. 取平均把所有样本的梯度累加并除以样本总数 N，得到平均梯度。
    1N∑i=1N∇Li(θt)\displaystyle \frac{1}{N} \sum_{i=1}^{N} \nabla L_i(\theta_t)
  3. 按比例迈步用学习率 \eta 缩放平均梯度，然后更新参数。
    θt+1=θt−ηN…\displaystyle \theta_{t+1} = \theta_t - \frac{\eta}{N} \dots

随机梯度下降

如果急着知道咸淡，你会用指尖蘸一滴汤。这一滴未必均匀，可能没沾到盐，也可能正好是盐粒子，于是你的判断忽咸忽淡。SGD 就是这种“急性子”：每次只随机抽一条样本，用它的梯度当作全量梯度的近似。

SGD 用单条样本的梯度近似全量梯度。从期望上看，它和 BGD 同方向：长期平均下来，味道判断不会系统性地偏咸或偏淡；但从方差上看，它抖动十分剧烈。好在单条计算极快，更新频率高，而且这种抖动反而像一种“探索”，能帮助模型跳出尖锐的局部极小值。

更新公式简洁到只剩一条样本的梯度。这里的 i 是每步随机抽取的样本下标，因此每一步方向都带噪声——好比每一滴汤的咸淡都不完全一样，但只要你蘸得足够多，总趋势还是正确的。SGD 特别适合在线学习：数据像流水一样涌来，你不必等收集齐全部样本，来一条就学一条。

SGD 虽然杂乱无章，但在线学习却离不开它：数据像流水一样涌来，你不可能等收集齐全部再更新，蘸一滴就更新一次，正是流式场景的救命勺。它的缺点是损失曲线像醉汉走路，忽上忽下，但别担心，最终它总能摸到汤碗的方向。

θt+1=θt−η∇Li(θt)\displaystyle \theta_{t+1} = \theta_t - \eta \nabla L_i(\theta_t)
这里的 i 是每步随机抽取的样本下标，因此每一步方向都带噪声。
  1. 随机选一条从训练集中均匀随机挑出第 i 条样本。
    ∇Li(θt)\displaystyle \nabla L_i(\theta_t)
  2. 直接当梯度不再求平均，用这条样本的梯度代表全局方向。
    −η∇Li(θt)\displaystyle -\eta \nabla L_i(\theta_t)
  3. 高频更新更新完立刻换下一条样本，参数一刻不停地跳动。
    θt+1=θt−…\displaystyle \theta_{t+1} = \theta_t - \dots

小批量梯度下降

聪明的厨师既不会喝整锅，也不会只蘸一滴，而是舀一小口均匀的汤。Mini-batch 梯度下降从数据集中随机抽取一个小批量 B，用这批样本的平均梯度作为更新方向。这个“小批量”通常是 16、32、64 等数字，兼顾了效率与稳定性。

小批量既保留了部分噪声以帮助逃离局部极小值，又平均掉了单条样本的极端干扰，方差介于 SGD 和 BGD 之间。更重要的是，它能利用 GPU 的并行计算：一批样本同时前向传播、同时求梯度，这种“同时上菜”的能力让显存和算力被高效利用，正是现代深度学习框架的基石。

更新公式是大锅汤和一滴汤的折中：先对 B 内的样本梯度求平均，再乘学习率更新。批量大小 |B| 通常远小于 N，却足以提供稳定的梯度估计。你可以把它想象成用一把可调大小的勺子：舀少了抖动大，舀多了胃疼，恰到好处的容量带来了“稳中带活”的优化过程。

这就是为什么 PyTorch、TensorFlow 等框架默认用 mini-batch：它像一把可调大小的勺子，既能装下足够的味道样本，又不会把胃撑破。对于大多数深度学习任务，小批量是从 32 起步的“标准吃法”。

θt+1=θt−η∣B∣∑i∈B∇Li(θt)\displaystyle \theta_{t+1} = \theta_t - \frac{\eta}{|B|} \sum_{i \in B} \nabla L_i(\theta_t)
批量大小 |B| 通常远小于 N，却足以提供稳定的梯度估计。
  1. 建造小批量从数据中随机选出 |B| 条样本组成集合 B。
    1∣B∣\displaystyle \frac{1}{|B|}
  2. 小批量平均梯度对这 |B| 条样本的梯度求和再除以 |B|。
    ∑i∈B∇Li(θt)\displaystyle \sum_{i \in B} \nabla L_i(\theta_t)
  3. 更新参数用平均梯度乘学习率，然后从旧参数中减去。
    θt+1=θt−η∣B∣…\displaystyle \theta_{t+1} = \theta_t - \frac{\eta}{|B|} \dots

收敛特点对比

三种“尝法”的味觉波动差异巨大。把每次尝汤的口味偏差看成随机变量，批量喝汤几乎不偏不抖，蘸一滴抖动剧烈，小口喝则适度抖动。这种统计特性直接映射到训练曲线上：BGD 的误差曲线如宁静湖面，SGD 像过山车，Mini-batch 则像起伏平缓的丘陵。

数学上，梯度估计的期望总是真实梯度（无偏性），但方差却与批量大小成反比。批量越大，每步方向越稳定，损失曲线越平滑；批量越小，噪声越大，损失曲线蹦蹦跳跳，但也可能更有探索性。理解这一点，你就明白了为什么“大 batch 更稳，小 batch 更跳”不是玄学，而是统计规律。

用随机变量 \hat{g} 表示任意一种梯度估计，它的期望等于真实梯度，方差等于单样本方差 σ² 除以批量大小。这个简洁的公式就像厨房里的温度计：批量大小决定了“味觉波动”的幅度。|B| = 1 时方差最大，|B| = N 时方差归零，小批量则取中间值。

理解方差就理解了收敛图景：BGD 像平静湖面上的直线，SGD 像醉汉走山路，Mini-batch 则像稳健的登山者，用适度的摇摆换取可观的速度。调参时，观察损失曲线的抖动幅度，就能反推出当前 batch size 是否合适。

E[g^]=∇L,Var(g^)=σ2∣B∣\displaystyle \mathbb{E}[\hat{g}] = \nabla L, \quad \text{Var}(\hat{g}) = \frac{\sigma^2}{|B|}
σ² 是单样本梯度的方差，批量越大，估算越稳定。
  1. 无偏性在随机采样下，梯度估计的期望等于真实梯度。
    E[g^]=∇L\displaystyle \mathbb{E}[\hat{g}] = \nabla L
  2. 方差公式方差等于单样本方差除以批量大小。
    σ2∣B∣\displaystyle \frac{\sigma^2}{|B|}
  3. 代入两种极端当 |B| = 1 时方差最大，当 |B| = N 时方差为 0。
    ∣B∣=1→Var 最大;∣B∣=N→Var=0\displaystyle |B| = 1 \rightarrow \text{Var} \text{ 最大}; \quad |B| = N \rightarrow \text{Var} = 0

资源权衡

喝整锅汤需要巨大的胃，蘸一滴几乎不占胃，小口汤则丰俭由人。训练模型时，“胃容量”就是显存，“上菜速度”就是训练吞吐量。批量大小直接影响这两者，这也是机器学习工程师日常要做的选择题。

批次越大，每次迭代的矩阵乘法越稠密，硬件利用率高——像一锅一次炒很多菜，火候足；但中间结果和梯度都要留在显存里，内存占用随批次线性增长。批次太小，则每次更新的计算颗粒度太散，GPU 喂不饱，训练时间反而变长。这个权衡可以用两个式子估算。

第一个式子算每轮训练时间：数据总量 N 除以批量 b，得到批次数，再乘以每批耗时 t_b。第二个式子估算显存：单样本显存占用 m_s 乘以批次 b，再加上模型参数占用 m_p。这就是为什么大 batch 需要大显存、小 batch 虽然省显存但耗时可能更高。

调 batch size 就像给不同食客选餐具：大胃王适合大碗但成本高，小鸟胃用个小勺却效率低。在显卡有限的创业公司，选择一个折中尺寸，才能在速度和显存之间取得平衡。GPU 上的实际吞吐量曲线通常是先升后降的倒 U 形，找到一个高效且不爆显存的批次，正是调参的乐趣。

Time/epoch=Nb⋅tb,Mem≈b⋅ms+mp\displaystyle \text{Time/epoch} = \frac{N}{b} \cdot t_b, \quad \text{Mem} \approx b \cdot m_s + m_p
其中 b 为 batch size，t_b 是处理一个批次的耗时，m_s 是单样本显存，m_p 是参数显存。
  1. 每轮迭代次数数据总量 N 除以批量 b，需要这么多批。
    Nb\displaystyle \frac{N}{b}
  2. 时间估算批次数乘以每批耗时，得到一轮训练时间。
    Nb⋅tb\displaystyle \frac{N}{b} \cdot t_b
  3. 显存估算显存近似等于批次内的样本占用加上模型参数占用。
    b⋅ms+mp\displaystyle b \cdot m_s + m_p

batch size 选择

给客人上汤，餐具大小还得看厨房条件。实际工程里，batch size 不是一个随便定的数字，它通常取 2 的幂（32、64、128、256），因为这样能对齐 GPU 的内存布局，也能简化学习率的调参。这就像饭店统一采购同一规格的碗碟，清洗、存放都省心。

如果显存只够 b_old 这么大批次，你却想尝试更大的 b_new，不能直接加大学习率了事。常见的做法是线性缩放：批次翻倍，学习率也翻倍，以保持参数更新的平均步长一致。这是因为梯度噪声随着批次增大而减小，放大学习率能弥补单步更新次数的减少。

缩放公式如下：新学习率等于旧学习率乘以新批次与旧批次的比值。注意这个规则在小范围调参时适用，极端变化时还需要 warmup 等技巧。比如从 64 增加到 128，学习率从 1e-3 提高到 2e-3，通常能保持训练曲线相似。

选好这把勺子，你的模型这锅汤就能炖得快而稳。实际中，从 64 或 128 起步，先看显存是否吃紧，再根据损失曲线微调，才是行之有效的调参路径。记住：没有最好的 batch size，只有最适合你“厨房条件”的 batch size。

ηnew=ηold×bnewbold\displaystyle \eta_{\text{new}} = \eta_{\text{old}} \times \frac{b_{\text{new}}}{b_{\text{old}}}
注意这个规则在小范围调参时适用，极端变化时还需要 warmup 等技巧。
  1. 已知基准记录当前使用的旧批次和学习率。
    ηold\displaystyle \eta_{\text{old}}
  2. 计算缩放比新批次与旧批次的比值。
    bnewbold\displaystyle \frac{b_{\text{new}}}{b_{\text{old}}}
  3. 得到新学习率旧学习率乘以缩放比。
    ηnew=ηold×bnewbold\displaystyle \eta_{\text{new}} = \eta_{\text{old}} \times \frac{b_{\text{new}}}{b_{\text{old}}}

AI 应用场景

显存受限时的“大锅汤”模拟

阶段：模型训练与调优

解决的问题：小公司的显卡只有 12GB 显存，想模仿别人用 256 的大 batch 训练大模型，一跑就爆显存。传统硬上大 batch 会 OOM，AI 工程师用梯度累积：每步用 32 的小批量算梯度，攒够 4 次再更新一次参数，等效于 batch = 128 而显存只占 32。就像小胃的人把一小口一小口的汤攒起来，最后凑成一碗的量，既没撑胃又尝到整碗味道。

具体案例：某创业团队微调一个 7B 参数的 LLM，显卡为 RTX 3080。他们先用 batch = 32 热身，每 32 条数据算完梯度不更新，累加 4 个步的梯度后统一更新权重，成功复现了大 batch 的训练曲线，最终让模型在显存极限下多跑了 20% 的样本。

在线推荐系统的“随机蘸汤”

阶段：在线学习/增量训练

解决的问题：短视频推荐系统每秒涌入海量新行为，无法等全量数据攒好再训。采用 SGD（或单样本）更新，每来一条点击数据就微调模型，实时捕捉用户兴趣变化。就像派一个随行厨师，每过一秒就蘸一滴汤判定咸淡，永远跟上口味变化。

具体案例：某电商 App 在双十一大促期间，实时推荐模型每收到一条曝光/点击日志，就执行一次 SGD 更新，延迟从分钟级降至秒级，GMV 提升 5%。这种“蘸一滴”的模式让模型对瞬时热点反应极其灵敏。

大模型预训练的“标准小批”

阶段：数据加载与分布式训练

解决的问题：预训练 BERT/GPT 时，数据量动辄几百 GB，BGD 不可能，SGD 又太抖。工程师选 mini-batch（如 64/128），配合混合精度和梯度累积，既喂饱 GPU 又控制方差。就像自助餐厅的厨师用容量合适的餐盘，既保证每桌都上菜（并行），又不会让厨房拥挤（内存）。

具体案例：某公司预训练一个 10B 模型，在 512 张 A100 上采用 batch = 4096（通过梯度累积等效），并通过 linear warmup 调学习率，训练稳定性大幅提升，最终在公开 benchmark 上刷新了纪录。

Python 演示

python32 行
import numpy as np def gen_data(n=1000):    rng = np.random.RandomState(42)    X = rng.randn(n, 2)    w_true = np.array([3.0, -2.0])    y = X @ w_true + 0.1 * rng.randn(n)    return X, y def grad_for(X, y, w, idx):    Xb = X[idx]    yb = y[idx]    return 2 * Xb.T @ (Xb @ w - yb) / len(idx) def run(X, y, batch_size, epochs=100, lr=0.05):    n = X.shape[0]    w = np.zeros(X.shape[1])    for _ in range(epochs):        perm = np.random.permutation(n)        for i in range(0, n, batch_size):            idx = perm[i:i + batch_size]            w -= lr * grad_for(X, y, w, idx)    loss = np.mean((X @ w - y) ** 2)    return w, loss if __name__ == "__main__":    X, y = gen_data()    for name, bs, epochs in [("BGD", X.shape[0], 200),                             ("SGD", 1, 5),                             ("MBGD", 32, 50)]:        w, loss = run(X, y, bs, epochs, lr=0.05)        print(f"{name}: w={np.round(w,3)}, loss={loss:.4f}")
目的：用同一个梯度下降框架模拟批量、随机、小批量三种模式，观察不同 batch size 下模型最终学到的参数和损失。
  1. def grad_for(X, y, w, idx):定义梯度计算函数，接受一个样本索引数组，返回当前批次的平均梯度。
  2. return 2 * Xb.T @ (Xb @ w - yb) / len(idx)用矩阵运算一次性算出均方误差的梯度。
  3. perm = np.random.permutation(n)打乱索引，确保每个 batch 都有代表性，避免数据顺序带来的偏差。
  4. for i in range(0, n, batch_size):按 batch_size 切分数据，循环处理所有批次。
  5. w -= lr * grad_for(X, y, w, idx)沿负梯度方向更新参数，这是梯度下降的核心一步。
  6. if __name__ == "__main__":作为脚本入口，依次运行三种模式并打印结果。

常见误区

误区我总觉得把 batch size 调大，模型能用更全的数据训练，效果一定更好，所以每次直接怼到显存极限。

正解批量过大会让梯度估计方差趋近于零，模型容易陷入尖锐的局部极小，泛化能力反而变差；显存压力还会限制 batch size。就像喝整锅汤虽然信息最全，但可能被汤底沉淀误导，而且胃会撑爆。适当的小批量噪声反而能帮模型跳出坏区域，起到隐式正则化的作用。

为何常见：人们直觉上认为“信息越多越好”，忽略了随机噪声对优化的正则化价值和硬件限制。

误区随机梯度下降每次都只用一个样本，方向不准，所以一定比批量慢。

正解SGD 虽然单步方向噪声大，但参数更新频率极高，在数据量大、目标函数非凸时，它能更快逃离鞍点，甚至在线流式场景中只有 SGD 可行。就像一个只蘸一滴汤的急性子，虽然每步判断有波动，但跑得次数多，往往率先找到大致方向。收敛速度要结合计算成本看，不能只看每步质量。

为何常见：人们把“单步准确度”与“总耗时”混为一谈，忽略了更新次数和硬件吞吐。

误区小批量梯度下降只是把 N 减小了一点，本质还是全量梯度下降。

正解小批量的随机采样引入了可控的梯度噪声（方差），这使优化轨迹有探索性，能逃离局部极小；同时小批量的计算可以高并行地喂给 GPU。它不是“缩小的 BGD”，而是介于 BGD 和 SGD 之间的一种独立策略，拥有独特的收敛特性。就像一小口汤不等于稀释的整锅汤，它是有代表性的采样。

为何常见：只看公式形式相似，忽略了随机性带来的统计性质变化。

误区网上说 batch size 必须取 32、64、128，否则训练不了。

正解2 的幂只是为了契合 GPU 内存对齐和某些后端优化，从而可能带来少量速度提升，但非硬性要求。实际中如 3、5、10 等也能训练，只是吞吐率略差。选择 batch size 首要看显存大小、模型特性和数据量。就像选勺子不必非买固定型号，顺手就行。

为何常见：从众心理和框架默认值让人误以为存在硬性规则。

面试题

Q1. 批量梯度下降（BGD）每次更新参数时使用多少数据？

单选题 · easy

  • A.一条随机样本
  • B.所有训练样本← 正确答案
  • C.一小批随机样本
  • D.无样本

答案：B。BGD 用全部训练样本计算平均梯度，方向最稳但计算贵。就像整锅汤都喝掉，信息最全。其他选项分别是 SGD 和 Mini-batch 的定义。

Q2. 随机梯度下降（SGD）的“随机”体现在哪里？

单选题 · easy

  • A.随机初始化参数
  • B.每次随机选一条样本估计梯度← 正确答案
  • C.随机选择学习率
  • D.随机跳过更新

答案：B。SGD 每次从训练集中均匀随机抽一条样本，用它的梯度代替全量梯度，所以更新方向带噪声。就像每次蘸的汤滴不一定均匀，因此判断会有随机波动。

Q3. 小批量梯度下降中，控制抖动大小的核心超参数是？

单选题 · easy

  • A.学习率
  • B.batch size← 正确答案
  • C.动量
  • D.正则化系数

答案：B。梯度估计的方差与 batch size 成反比，批量越大抖动越小。学习率影响步长，而非抖动幅度。所以选 B。

Q4. 在显存不足又想等效大 batch 训练时，常用的技巧是？

单选题 · mid

  • A.减小模型参数量
  • B.梯度累积← 正确答案
  • C.降低学习率
  • D.使用单精度

答案：B。梯度累积先把多个小 batch 的梯度累加，再统一更新，等效于大 batch 更新，但显存只装下一个小 batch。就像小口喝汤攒成一碗，既没撑胃又尝到整碗味道。

Q5. 关于 SGD，下列哪些说法正确？

多选题 · mid

  • A.更新频率高，计算代价小← 正确答案
  • B.梯度估计的期望等于全量梯度← 正确答案
  • C.梯度方差比 BGD 小
  • D.适合在线学习← 正确答案

答案：ABD。SGD 每次只用一条样本，计算快、更新频率高，且其期望无偏，方差最大而非最小，所以 C 错。流式数据来不及攒齐全量，SGD 天然适配在线学习。

Q6. 当 batch size 从 32 增大到 64，学习率也加倍，这属于？

单选题 · mid

  • A.线性缩放法则← 正确答案
  • B.平方根缩放法则
  • C.学习率衰减
  • D.warmup

答案：A。经验上，增大 batch size 时按同样比例放大学习率，可保持参数更新步长大致不变，这就是线性缩放法则。好比加餐的量，相应加大盐量的比例。

Q7. 梯度估计的方差为 σ²/b，当 b=1 时方差最大。这个结论来自哪个假设？

单选题 · hard

  • A.样本独立同分布← 正确答案
  • B.梯度完全无噪声
  • C.学习率必须很小
  • D.损失函数是凸的

答案：A。方差公式基于独立同分布抽样的统计性质，与凸性无关。只要样本 i.i.d.，平均梯度的方差就会随样本数递减。就像每次舀汤的勺子独立均匀，舀的次数越多，平均味道越稳定。

Q8. 深度学习框架（如 PyTorch）默认使用的梯度下降变体是？

单选题 · easy

  • A.BGD
  • B.SGD
  • C.Mini-batch GD← 正确答案
  • D.随机坐标下降

答案：C。现代框架默认按小批量迭代数据，兼顾效率与稳定性，这就是 mini-batch。它像标准的饭勺，大小适中。

Q9. 关于 BGD 和 SGD 的收敛特点，正确的有？

多选题 · hard

  • A.BGD 的损失曲线通常更平滑← 正确答案
  • B.SGD 更容易跳出局部极小← 正确答案
  • C.BGD 每次更新耗时为 O(N)← 正确答案
  • D.SGD 的期望梯度大于真实梯度

答案：ABC。BGD 用全量梯度，曲线平滑；SGD 含噪声，可能扰动模型跳出局部极小；BGD 每步要算所有样本，O(N) 正确；SGD 的期望梯度等于真实梯度而非大于，故 D 错。

Q10. 假设你显存只支持 batch=64，但阅读论文发现对方用 batch=1024。在同样数据顺序下，想复现其训练曲线，第一步应做什么？

单选题 · extreme

  • A.把 batch 调成 1024 硬跑
  • B.使用梯度累积，每 16 个小批次更新一次← 正确答案
  • C.增加学习率 100 倍
  • D.减少训练轮数

答案：B。显存不足时，用梯度累积把 16 个 64 大小的梯度累加后更新一次，等效 batch=1024，同时可配合线性缩放学习率。直接硬跑会 OOM，学习率 100 倍不科学，D 更无依据。