CS336 学习笔记 03：缩放定律与推理优化

本文最后更新于 2026年9月28日 晚上

CS336 入门辅助学习文档 - Scaling Laws 与推理模块

写在前面：这三讲学什么？

这三讲属于课程的第三大模块——Scaling Laws 与推理。

为什么要学这个？因为做大模型，最核心的问题就是：

给你有限的算力和数据，怎么做出最好的模型？

  • 模型做多大？数据用多少？—— 这就是 Scaling Laws（L9、L11）
  • 模型做好了，怎么让它跑得快、用得起？—— 这就是推理优化（L10）

这三讲会告诉你： - 大模型的性能是怎么随着规模变大而提升的 - 怎么用小模型实验预测大模型的性能 - 推理为什么慢，怎么加速

💡 为什么这些很重要？ 训练一个大模型动辄几千万甚至上亿人民币，不能瞎试，必须有理论指导。 Scaling Laws 就是大模型时代的"经济学"——教你怎么把钱花在刀刃上。

第九讲：Scaling Laws 基础 — 大模型的"缩放定律"

9.0 前置知识：什么是 Scaling Laws？

想象一下：你有 1000 张 GPU，一个月时间，要做一个尽可能好的大模型。

你会怎么选？ - 模型做多大？1B？10B？100B？ - 数据用多少？1T tokens？10T？100T？ - 学习率设多少？batch size 设多少？

这些问题，就是 Scaling Laws 要回答的。

Scaling Laws（缩放定律） 是什么？

简单说：模型的性能和模型大小、数据量、计算量之间，存在简单的数学关系——幂律关系。

什么是幂律？就是在对数坐标图上是一条直线。

比如： - 数据量翻 10 倍，误差降低到原来的 1/2 - 模型大小翻 10 倍，误差降低到原来的 1/3

这种关系非常稳定，在很多任务、很多模型上都成立。

💡 生活类比： Scaling Laws 就像经济学里的"规模效应"—— - 工厂越大，单位成本越低（但降低的速度越来越慢） - 投入越多，产出越多（但边际收益递减）

Scaling Laws 就是大模型的"规模效应"——投入更多的算力、数据、参数，模型就会更好，但提升的速度会越来越慢。

为什么 Scaling Laws 重要？

因为有了它，你就可以： 1. 预测：用小模型做实验，预测大模型的性能，不用真的训大模型 2. 优化：在有限的预算下，找到最优的模型大小和数据量配比 3. 决策：决定要不要做更大的模型，值不值得

9.1 数据缩放定律：数据越多，模型越好？

先从最简单的开始：数据量和模型性能的关系。

9.1.1 幂律关系

研究发现，语言模型的性能（用测试集上的 loss 衡量）和训练数据量之间，存在幂律关系：

1
Loss ∝ 1 / N^α

其中 N 是数据量（token 数），α 是一个常数（指数）。

在 log-log 图上，这就是一条直线：

1
log(Loss) = -α × log(N) + C

这个关系非常稳定，在很多任务上都成立： - 机器翻译 - 语音识别 - 语言模型 - 等等

💡 什么是幂律？为什么叫"幂律"？ 幂律就是 y = x^a 这样的关系——x 的 a 次方。 之所以叫"幂律"，是因为变量在指数（幂）的位置。

比如： - 线性关系：y = 2x → 在普通坐标图上是直线 - 幂律关系：y = x^0.5 → 在 log-log 坐标图上是直线

幂律的特点：变量翻几倍，结果翻固定的倍数。比如数据量翻 10 倍，loss 降一半。

9.1.2 为什么是幂律？

你可能会问：为什么偏偏是幂律？不是别的什么关系？

这是个好问题，目前还没有完全统一的答案，但有一些理论解释：

解释一：样本复杂度

最简单的例子：估计一个正态分布的均值。

  • 你有 n 个样本，均值估计的误差是 σ/√n
  • 也就是误差 ∝ 1/√n → 这就是幂律，指数是 0.5

很多经典的统计模型都有类似的幂律缩放。

解释二：内在维度

另一个解释是：数据的"内在维度"决定了缩放指数。

比如你要学一个二维平面上的函数： - 你有 n 个样本 - 每个方向上大约有 √n 个样本 - 误差大约是 1/√n → 指数是 1/d，d 是维度

如果数据的内在维度是 d，那缩放指数大约就是 1/d。

语言模型的数据（自然语言）的内在维度是多少？目前还不太清楚，但肯定比词汇表大小小得多。

💡 内在维度是什么？ 想象你有一堆 1000 维的数据，但它们其实都分布在一条曲线上（1 维）。 虽然数据看起来是 1000 维的，但"内在维度"只有 1。

自然语言也是一样——虽然词表很大、序列很长，但语言的"内在维度"可能没那么高。 这就是为什么大模型能学好语言——因为语言的有效维度没那么大。

9.1.3 数据组成的影响

数据量不是唯一重要的，数据的质量和组成也很重要。

研究发现： - 数据组成影响的是"截距"（offset），不是"斜率"（指数） - 也就是说，好的数据让整体 loss 更低，但缩放的速度不变

比如： - 高质量数据：loss 整体低 10%，但数据量翻 10 倍还是降 50% - 低质量数据：loss 整体高 10%，但数据量翻 10 倍还是降 50%

💡 生活类比： 就像学习： - 好教材 = 起点高（截距好） - 学习时间 = 决定进步速度（斜率）

好教材让你一开始就懂更多，但学的时间越长，进步的速度是差不多的。

9.1.4 数据重复的影响

实际中，我们的数据是有限的，有时候需要重复使用数据（就是 epoch > 1）。

那数据重复会怎么样？

研究发现，重复的数据价值比新数据低。可以用"有效数据量"来衡量：

1
有效数据量 = 唯一数据量 × 某个系数

重复越多，有效数据量增长越慢。

这就是为什么： - 数据多的时候，应该少重复（epoch 少） - 数据少的时候，可以多重复（epoch 多） - 但重复太多会有收益递减

⚠️ 注意：数据重复太多可能导致过拟合，尤其是小模型。 大模型对重复的容忍度更高，但也不是无限的。

9.2 模型缩放定律：模型越大越好？

数据缩放讲完了，我们来看模型大小和性能的关系。

9.2.1 参数缩放定律

和数据缩放类似，模型大小（参数量）和性能之间也是幂律关系：

1
Loss ∝ 1 / N_params^β

β 是另一个常数指数。

同样，在 log-log 图上是一条直线。

这个关系也非常稳定，在很多架构、很多任务上都成立。

💡 一个有趣的发现： 模型大小的缩放指数 β 通常比数据缩放的指数 α 大。 也就是说，模型变大带来的提升比数据变多带来的提升更快？

不对，等一下——这取决于单位成本。模型变大和数据变多哪个更"贵"？ 这就是我们后面要讲的"计算最优"问题。

9.2.2 超参数和缩放

模型缩放不只是参数数量，还有很多超参数会影响。

我们一个个来看：

1. 架构选择：Transformer vs LSTM

Transformer 比 LSTM 好吗？

答案是：在小模型上差距不大，但模型越大，Transformer 的优势越明显。

也就是说，Transformer 的缩放指数更大——模型越大，提升越快。

LSTM 在小模型上还行，但大了之后提升就慢了。

这就是为什么现在大模型都用 Transformer——因为它缩放得更好。

2. 优化器选择：Adam vs SGD

优化器呢？Adam 和 SGD 哪个好？

研究发现： - 在小模型上，Adam 通常更好 - 但随着模型变大，两者的差距会缩小 - 最终的缩放趋势是一样的

也就是说，优化器影响的是"起点"，不是"斜率"。

3. 深度 vs 宽度

模型可以做深（层数多），也可以做宽（隐藏维度大）。哪个更好？

研究发现： - 1 层 vs 2 层：差距很大 - 但超过一定数量后，深度和宽度的影响不大 - 只要总参数量差不多，性能就差不多

也就是说，总参数量比深宽比更重要。

但这不是说深宽比完全不重要——太深的模型难训练，太宽的模型难并行。

💡 深宽比的经验法则： 一般来说，d_model / num_layers 在 100-200 之间比较合理。 太极端（特别深或特别宽）都不好。

4. Batch Size：关键 batch size

Batch size 也有缩放定律。

研究发现： - Batch size 小的时候，增大 batch size 可以加快训练（同样的计算量，更少的步数） - 但 batch size 超过某个"临界点"后，再增大就没用了

这个临界点叫关键 batch size（critical batch size）。

有趣的是：目标 loss 越低，关键 batch size 越大。

也就是说： - 训练到 loss 比较高就停 → 用小 batch 就行 - 要训练到 loss 很低 → 需要更大的 batch

💡 生活类比： 就像跑步： - 跑 100 米：可以全力冲刺（大 batch） - 跑马拉松：得控制节奏（小 batch）

目标越远，越不能急。

5. 学习率：muP

学习率和缩放的关系比较复杂。

朴素的做法：模型变大了，学习率也得调。

但有个叫 muP（Maximum Update Parametrization，最大更新参数化） 的技术，可以让学习率不随模型大小变化——小模型调好的学习率，大模型直接用就行。

这在大模型训练中很有用，因为不用在大模型上重新调学习率了。

⚠️ 注意：muP 是个好东西，但不是万能的。 有些研究发现 muP 在某些情况下效果不如预期，还是需要重新调参。 但总体来说，它能让缩放更稳定。

9.3 联合缩放：模型和数据的最优配比

现在我们知道了： - 数据越多越好 - 模型越大越好

但问题是：算力有限的情况下，模型做多大？数据用多少？

这就是联合缩放定律要回答的问题。

9.3.1 Kaplan 缩放定律

2020 年，OpenAI 的 Kaplan 等人提出了一个著名的缩放定律。

他们的结论： - 模型大小的缩放指数比数据大 - 也就是说，应该把更多的预算花在模型上，而不是数据上 - 最优配比：大约 2 个 token / 参数

也就是说，一个 10B 的模型，应该用 20B tokens 训练。

这就是 GPT-3 的配比（175B 参数，300B tokens，大约 1.7 tokens/参数）。

9.3.2 Chinchilla 缩放定律

2022 年，DeepMind 的 Chinchilla 论文挑战了 Kaplan 的结论。

他们说：Kaplan 错了，应该用更多的数据，更小的模型。

Chinchilla 的结论： - 最优配比大约是 20 个 token / 参数 - 也就是说，一个 10B 的模型，应该用 200B tokens 训练

差了 10 倍！

谁对谁错？现在业界普遍认为 Chinchilla 更接近正确。

为什么 Kaplan 错了？有几个原因： 1. Kaplan 没有算 embedding 层的参数 2. 小计算量下的 warmup 问题 3. 学习率调度的问题

💡 为什么这个争论很重要？ 因为这决定了你怎么花钱： - 如果 Kaplan 对：花更多钱做大模型，数据少点没关系 - 如果 Chinchilla 对：花更多钱做数据，模型可以小点

差 10 倍的话，那就是几千万甚至几个亿的差别！

9.3.3 三种拟合方法

Chinchilla 论文里提出了三种拟合缩放定律的方法：

方法一：下包络法（Minimum over runs）

  • 训练很多不同大小的模型，每个训练不同步数
  • 把所有训练曲线画在一起，取下边界（最低的 loss）
  • 这个下边界就是缩放定律

优点：简单直观 缺点：需要很多实验

方法二：等计算量法（IsoFLOPS）

  • 固定计算量（FLOPs）
  • 改变模型大小和数据量的配比
  • 找到最优的配比
  • 不同计算量下的最优点连起来就是缩放定律

优点：直接回答"给定算力，怎么做最好" 缺点：每个计算量都需要一组实验

方法三：联合拟合法（Joint fit）

  • 在模型大小 × 数据量的二维网格上做实验
  • 用最小二乘法拟合一个二维的缩放公式
  • 比如：Loss = A × N^α + B × D^β + C

优点：一个公式就能预测所有情况 缺点：需要的实验最多，拟合可能有偏差

⚠️ 注意：Chinchilla 论文里的方法三后来被发现有问题——数据处理有 bug。 重新拟合后，结果和方法一、二更接近了。 所以现在一般更信任方法一和方法二。

9.3.4 训练最优 ≠ 推理最优

还有一个重要的点：Chinchilla 是"训练最优"，不一定是"推理最优"。

什么意思？

Chinchilla 的目标是：给定训练算力，做出 loss 最低的模型。

但实际中，模型训练好之后还要推理，推理也要花钱。

如果模型用得很多（推理量很大），那： - 模型小一点 → 推理快，省钱 - 可以多训练一会儿 → 训练多花点钱，但推理省更多

所以对于推理量大的场景，应该"过度训练"——用比 Chinchilla 更多的数据，更小的模型。

看看实际的模型： - GPT-3：~2 tokens/参数（接近 Kaplan） - Chinchilla：~20 tokens/参数（Chinchilla 最优） - LLaMA 65B：~22 tokens/参数 - LLaMA 2 70B：~29 tokens/参数 - Mistral 7B：~110 tokens/参数 - LLaMA 3 70B：~215 tokens/参数

越来越多的模型选择"过度训练"，因为推理成本才是大头。

💡 生活类比： 就像买车： - 训练最优 = 买车最便宜（但油耗高） - 推理最优 = 买车贵点（但油耗低）

如果你开得少，买个便宜的车就行（训练最优）。 如果你天天开，买个省油的车更划算（推理最优）。

大模型也是一样——用得越多，越值得在训练上多投入，让推理更便宜。

9.4 缩放定律的应用

缩放定律有什么用？我们来看几个实际应用。

9.4.1 超参数调优

最直接的应用：用小模型调超参数，然后用到大模型上。

比如： 1. 训练几个小模型（10M、100M 参数） 2. 在小模型上找到最优的学习率、batch size、架构 3. 根据缩放定律，预测大模型的最优超参数 4. 直接用在大模型上

这样可以省很多钱——不用在大模型上瞎试。

⚠️ 注意：不是所有超参数都能这样"缩放"。 有些超参数在小模型上表现好，大模型上不一定好。 所以缩放定律是参考，不是金科玉律，还是要验证。

9.4.2 资源分配

缩放定律可以帮你决定：钱应该花在哪里？

比如你有 100 万预算： - 买 GPU 训练大模型？ - 还是买数据做小模型？

根据缩放定律，你可以算出来哪种配比的 loss 最低。

9.4.3 预测未来

缩放定律还可以用来预测：如果模型再大 10 倍，性能会怎么样？

这对做产品规划、投资决策很重要。

但要注意：缩放定律不是永远成立的。

可能的"拐点"： - 数据用完了（没有更多高质量数据了） - 模型太大，训练不稳定 - 出现了新的架构，缩放规律变了

所以预测要谨慎，不能无限外推。

9.5 本讲小结

这一讲我们学了 Scaling Laws 的基础：

数据缩放定律 - 数据量和性能是幂律关系（log-log 图上是直线） - 理论解释：样本复杂度、内在维度 - 数据质量影响截距，不影响斜率 - 数据重复有收益递减

模型缩放定律 - 参数量和性能也是幂律关系 - 架构、优化器、深度/宽度、batch size、学习率都有缩放规律 - Transformer 比 LSTM 缩放得更好

联合缩放 - Kaplan vs Chinchilla：数据和模型的最优配比 - 三种拟合方法：下包络、等计算量、联合拟合 - 训练最优 ≠ 推理最优：用得多就过度训练

应用 - 超参数调优（小模型实验 → 大模型应用） - 资源分配（钱花在哪里最优） - 预测未来（谨慎外推）

9.6 小白常见问题 Q&A

Q1：缩放定律是经验规律还是理论推导的？

A：主要是经验规律——通过大量实验观察到的。

有一些理论解释（比如样本复杂度、内在维度），但还没有一个完整的理论能精确预测缩放指数是多少。

目前的缩放定律都是"实验拟合"出来的，不是从第一性原理推导出来的。

Q2：缩放定律会一直成立吗？

A：不一定。目前观察到的范围内（比如从 1M 到 1T 参数），缩放定律大致成立。

但再大呢？没人知道。可能有拐点，可能没有。

历史上有很多次人们以为"AI 遇到瓶颈了"，结果又被新的突破打破了。所以不要太自信地预测极限。

Q3：为什么 Chinchilla 和 Kaplan 的结论差这么多？

A：主要是实验方法和数据处理的差异。

Kaplan 的实验有一些问题： 1. 没有算 embedding 参数 2. 小模型的 warmup 步数不够 3. 学习率调度可能不是最优的

Chinchilla 更仔细地做了实验，结论更可靠一些。

但 Chinchilla 也不是最终答案——后来的研究发现最优配比可能比 Chinchilla 还要高（更多数据/参数）。

Q4：MoE 模型的缩放定律和稠密模型一样吗？

A：不一样。MoE 有总参数量和激活参数量两个维度，缩放更复杂。

一般来说： - 激活参数量的缩放规律和稠密模型类似 - 总参数量的缩放指数更小（因为不是所有参数都用上了） - 但 MoE 可以用同样的计算量做更大的总参数量，效果可能更好

MoE 的缩放定律目前还是研究热点。

9.7 学习路线图

必须掌握： - 什么是缩放定律（幂律关系） - 数据缩放和模型缩放的基本概念 - Chinchilla 缩放定律的核心结论 - 训练最优 vs 推理最优的区别

了解即可： - 缩放定律的理论解释 - 三种拟合方法的细节 - muP 的具体原理 - 各种超参数的缩放细节

配合作业： - 作业 3（Scaling）就是做缩放定律实验，可以结合这一讲理解 - 下一讲（L10）会讲推理优化，可以接着看

第十讲：推理优化 — 让大模型跑得快、用得起

10.0 前置知识：为什么推理很重要？

前面几讲我们一直在讲训练——怎么把模型训出来。

但模型训出来之后呢？要用啊！这就是推理（Inference）。

推理有多重要？ - 训练是一次性的，花一次钱就完了 - 推理是持续的，用户每用一次就要花一次钱 - 用户越多、用得越频繁，推理成本越高

举个例子： - 训练一个大模型可能花几千万 - 但如果每天有几百万用户用，推理成本可能几个月就超过训练成本了

所以推理优化非常非常重要——直接关系到产品能不能赚钱、能不能大规模应用。

💡 生活类比： - 训练 = 建工厂（一次性投入） - 推理 = 生产产品（持续投入）

工厂建得贵不贵很重要，但每天生产的成本更重要——卖得越多，生产成本占比越大。

大模型也是一样：用得越多，推理优化越重要。

推理的应用场景： - 聊天机器人（ChatGPT、豆包等） - 代码补全 - AI Agent（自动执行任务） - 批量数据处理（比如批量翻译、批量摘要） - 模型评估（测试模型性能） - 强化学习（生成大量样本，然后打分）

推理的指标：

不同的场景，关注的指标不一样：

  1. Time-To-First-Token (TTFT)：从用户发请求到看到第一个字的时间
    • 对交互式应用很重要（聊天、代码补全）
    • 用户等第一个字的时间不能太长
  2. 延迟（Latency）：每个 token 生成的时间（秒/token）
    • 对交互式应用很重要
    • 字出现的速度不能太慢
  3. 吞吐量（Throughput）：每秒能生成多少 token
    • 对批量处理很重要
    • 越高越好

💡 三个指标的关系： - TTFT 短 = 响应快，用户体验好 - 延迟低 = 字出得快，用户体验好 - 吞吐量高 = 单位时间处理得多，成本低

理想情况是三个都好，但实际中往往需要权衡。

10.1 推理为什么慢？

要优化推理，先得知道推理为什么慢。

10.1.1 训练 vs 推理

训练和推理有什么不同？

训练： - 输入是一整个 batch 的序列 - 可以并行计算（整个序列同时处理） - 计算量大，是计算受限的

推理： - 输入是一个 token 一个 token 地生成 - 不能并行（下一个 token 依赖上一个） - 每次计算量小，是内存受限的

为什么推理是内存受限的？

因为每次生成一个 token，都要： 1. 从显存里读模型参数 2. 做计算 3. 写下一个 token

但计算量很小（矩阵-向量乘，不是矩阵-矩阵乘），所以大部分时间都在等数据从显存读进来。

💡 回顾算术强度： 第二讲学过 Roofline 模型： - 算术强度 = FLOPs / 字节访问量 - 算术强度高 → 计算受限 - 算术强度低 → 内存受限

训练的时候，batch 大，算术强度高 → 计算受限 推理的时候，batch 小（甚至是 1），算术强度低 → 内存受限

所以推理优化的核心是：减少内存访问，提高算术强度。

10.1.2 朴素推理的问题

朴素的推理是怎么做的？

生成第 t 个 token 的时候，把前 t 个 token 都喂进模型，重新计算一遍。

这样的话： - 生成第 1 个 token：计算 1 个 token 的前向传播 - 生成第 2 个 token：计算 2 个 token 的前向传播 - ... - 生成第 T 个 token：计算 T 个 token 的前向传播

总计算量是 O(T²)——生成 T 个 token，计算量是 T 的平方！

这也太慢了吧？

幸好，我们有个叫 KV Cache 的东西可以优化。

10.2 KV Cache：推理的"记忆"

10.2.1 什么是 KV Cache？

回忆一下注意力机制： - 每个 token 会生成 Q、K、V 三个向量 - 注意力 = softmax(Q × K^T) × V

在推理的时候，生成第 t 个 token： - 第 t 个 token 的 Q 是新的 - 但前 t-1 个 token 的 K 和 V 之前已经算过了！

我们不需要重新算前 t-1 个 token 的 K 和 V，直接存起来用就行。

这就是 KV Cache——把之前算过的 K 和 V 缓存起来，下次直接用。

有了 KV Cache 之后： - 生成第 t 个 token 时，只需要算第 t 个 token 的 Q、K、V - 然后把新的 K、V 加到 Cache 里 - 注意力用 Q × (所有 K)^T × (所有 V)

计算量从 O(T²) 变成了 O(T)——线性的！

💡 生活类比： KV Cache 就像你的"短期记忆"： - 每次你说一句话，我不需要把你之前说的所有话都重新想一遍 - 我只需要记住之前的重点（K、V），然后结合新的话（Q）来理解 - 这样就快多了

KV Cache 就是模型的"短期记忆"——记住之前说过的话，不用每次都重新算。

10.2.2 KV Cache 有多大？

KV Cache 听起来很好，但它有个问题：占内存。

KV Cache 有多大？我们来算一下：

假设： - batch size = B - 序列长度 = S - 层数 = L - 注意力头数 = N - 头维度 = H - 数据类型 = BF16（2 字节）

KV Cache 大小 = 2 × B × S × L × N × H × 2 字节

（前面的 2 是因为 K 和 V 各一份）

举个例子：LLaMA 70B - L = 80 层 - N = 64 头 - H = 128 维 - B = 1，S = 4096

KV Cache = 2 × 1 × 4096 × 80 × 64 × 128 × 2 字节 ≈ 6.4 GB

这还只是 batch size = 1 的情况！如果 batch size 大一点，或者序列更长，KV Cache 会非常大。

⚠️ KV Cache 是推理内存的大头： 对于长序列、大 batch 的推理，KV Cache 的大小可能超过模型参数本身！ 所以优化 KV Cache 是推理优化的重点。

10.2.3 Prefill 和 Decode

有了 KV Cache 之后，推理分成两个阶段：

1. Prefill（预填充）阶段 - 输入：用户的 prompt（一整段话） - 计算：一次性算出所有 prompt token 的 K、V，存入 Cache - 特点：并行计算，计算量大，算术强度高，计算受限

2. Decode（解码）/ Generation（生成）阶段 - 输入：上一个生成的 token - 计算：算出这个 token 的 K、V，加到 Cache 里，然后算注意力 - 特点：串行生成，计算量小，算术强度低，内存受限

💡 两个阶段的区别： - Prefill：像考试前复习，一口气把所有知识过一遍（快，因为可以并行） - Decode：像答题，一道一道地想（慢，因为串行）

Prefill 是计算受限的，Decode 是内存受限的。 优化的时候要分别考虑。

10.3 有损优化：牺牲一点精度换速度

KV Cache 太大了，怎么减小？

有一类优化方法叫有损优化——牺牲一点点精度，换来大的速度提升或内存节省。

10.3.1 减少 KV Cache 的大小

KV Cache 太大，最直接的优化就是：让 KV Cache 变小。

怎么变小？减少注意力头的数量！

还记得第三讲学的 GQA（分组查询注意力）吗？

  • MHA（多头注意力）：每个 Q 头对应一个 K 头和一个 V 头
  • MQA（多查询注意力）：所有 Q 头共享一个 K 头和一个 V 头
  • GQA（分组查询注意力）：Q 头分成几组，每组共享一个 K 头和一个 V 头

GQA 可以大幅减少 KV Cache 的大小： - 比如 32 个 Q 头，4 个 KV 头 → KV Cache 缩小 8 倍 - 精度损失很小

现在的大模型几乎都用 GQA，就是为了减小 KV Cache，让推理更快。

还有更激进的：MLA（Multi-head Latent Attention） - DeepSeek V2 提出的 - 把 K、V 压缩成低维的潜在表示 - KV Cache 可以压得更小

💡 为什么训练的时候不用 GQA？ 其实训练的时候也可以用 GQA，而且训练速度也会更快（因为注意力计算量小了）。

但 GQA 对精度有一点点影响。如果你的目标是最好的精度，可能还是 MHA 好。 但如果你的目标是推理速度，GQA 是很好的 trade-off。

现在的趋势是：大家都用 GQA，因为推理太重要了。

10.3.2 量化（Quantization）

另一个重要的优化：量化。

什么是量化？就是用更少的比特来存参数和激活值。

比如： - FP16/BF16：16 比特（2 字节） - INT8：8 比特（1 字节） - INT4：4 比特（0.5 字节） - FP8：8 比特（1 字节）

量化的好处： - 内存占用减半甚至更少 - 内存带宽压力减小（因为读的数据少了） - 有些硬件有专门的低精度计算单元，计算更快

代价： - 精度会有一点点损失 - 量化得太狠（比如 INT4），精度损失可能比较明显

常见的量化方法： - PTQ（Post-Training Quantization）：训好模型后直接量化，简单，但精度损失大一点 - QAT（Quantization-Aware Training）：训练的时候就考虑量化，精度更好，但麻烦 - GPTQ：一种流行的 PTQ 方法，INT4 量化精度损失很小 - AWQ：另一种流行的 PTQ 方法

现在 INT8 量化已经很成熟了，精度损失几乎可以忽略。INT4 也越来越好了。

💡 生活类比： 量化就像压缩图片： - 原图（FP16）：质量好，但文件大 - 压缩后的图（INT8/INT4）：文件小很多，但仔细看有点模糊

只要压缩得不过分，人眼看不出区别。 量化也是一样——只要量化得合理，模型效果几乎没区别。

10.3.3 剪枝和蒸馏

还有两种更激进的方法：

剪枝（Pruning）： - 把模型里"不重要"的参数删掉 - 比如删掉一些神经元、一些头、甚至一些层 - 模型变小了，推理就快了

但剪枝比较 tricky——删多了精度掉得厉害，删少了没效果。现在用得不如量化多。

蒸馏（Distillation）： - 用一个大模型（老师）教一个小模型（学生） - 小模型学习大模型的输出分布，而不是只学标签 - 这样小模型可以达到接近大模型的效果，但小很多、快很多

蒸馏是个好方法，但需要重新训练小模型，成本比较高。

💡 剪枝 vs 蒸馏： - 剪枝：从大模型里"剪掉"不重要的部分，剩下的还是原来的模型 - 蒸馏：用大模型"教"一个全新的小模型，小模型可能结构不一样

剪枝简单但效果有限，蒸馏效果好但麻烦。

10.4 无损优化：不损失精度的加速

上面的方法都会损失一点点精度。有没有不损失精度的方法？

有！投机采样（Speculative Sampling） 就是一种。

10.4.1 什么是投机采样？

推理慢的原因是：生成 token 是串行的，一个一个来。

那能不能一次生成多个 token？

投机采样的思路是： 1. 用一个小模型（草稿模型）快速生成几个 token（"猜测"） 2. 用大模型（目标模型）一次性验证这些 token 对不对 3. 对的就保留，错的就从错的地方重新生成

为什么叫"投机"？因为小模型是在"猜"大模型会生成什么，猜对了就赚了，猜错了也不亏（只是浪费了一点计算）。

💡 生活类比： 想象你在听写： - 老师（大模型）念得慢，但念得准 - 你（小模型）写得快，但可能写错

投机采样就像：你先根据上下文猜后面几个词，写下来，然后老师检查。 - 如果都对：你一下写了好几个词，快！ - 如果有错的：从错的地方改，也不亏。

平均下来，速度会快很多。

10.4.2 为什么是无损的？

因为最终的输出是大模型生成的，小模型只是"猜"。

如果小模型猜对了，那结果和大模型一个个生成的一模一样。 如果小模型猜错了，那就用大模型的结果，也没错。

所以投机采样是无损的——输出分布和只用大模型完全一样。

10.4.3 能加速多少？

取决于小模型的"猜测准确率"： - 准确率高 → 一次能验证多个 token → 加速多 - 准确率低 → 经常猜错 → 加速少

一般来说，能加速 2-3 倍。

小模型怎么来？ - 可以是同一个模型的小版本（比如 7B 做 70B 的草稿模型） - 也可以是从大模型蒸馏出来的小模型 - 甚至可以是大模型的前几层（叫做"草稿头"）

⚠️ 注意：投机采样不是万能的。 - 如果小模型和大模型差太多，猜测准确率低，加速就不明显 - 对于简单的、可预测的文本（比如代码、公式），准确率高，加速多 - 对于创造性的、不可预测的文本，准确率低，加速少

10.5 动态工作负载：处理真实的流量

前面讲的都是"理想情况"——batch 大小固定，序列长度固定。

但实际中，推理服务的流量是动态的： - 请求随时来，不是同时来的 - 每个请求的 prompt 长度不一样 - 每个请求生成的长度不一样 - 有些请求有相同的前缀（比如系统提示词）

怎么高效处理这些动态的工作负载？

10.5.1 连续批处理（Continuous Batching）

朴素的批处理： - 等一批请求凑齐了，一起处理 - 所有请求同时开始，同时结束 - 问题：短的请求要等长的请求，浪费时间

连续批处理： - 不用等凑齐一批，来了就加进去 - 每个 step 都可以加入新的请求，也可以移除完成的请求 - 像一个"流水线"，不断有进有出

这样 GPU 的利用率就高多了，不会因为等长请求而闲着。

💡 生活类比： - 朴素批处理 = 公交车：等人凑齐了才发车，大家一起到终点 - 连续批处理 = 电梯：随时可以上，随时可以下，不用等所有人

连续批处理让 GPU 始终保持忙碌，不浪费时间。

10.5.2 PagedAttention：KV Cache 的"虚拟内存"

KV Cache 还有个问题：内存碎片。

因为每个请求的序列长度不一样，KV Cache 的大小也不一样。 请求来了又走，内存里会留下很多"空洞"——碎片。

这就像操作系统里的内存碎片问题。

怎么解决？PagedAttention！

PagedAttention 的思路和操作系统的虚拟内存一样： - 把 KV Cache 分成固定大小的"页"（block） - 每个请求的 KV Cache 由很多页组成，这些页在物理内存里可以不连续 - 用一个"页表"来记录逻辑地址到物理地址的映射

这样的好处： - 没有内存碎片，内存利用率高 - 可以动态分配和释放页 - 共享前缀的请求可以共享页（比如系统提示词的 KV Cache 只存一份）

PagedAttention 是 vLLM 这个推理框架的核心技术，现在已经被广泛采用了。

💡 生活类比： - 朴素 KV Cache = 连续的书架：每本书占连续的位置，书拿走了就空一块，新书插不进去（碎片） - PagedAttention = 带索引的书架：书可以分散放，用索引记录每本书在哪

索引虽然占一点点空间，但利用率高多了。

10.5.3 RadixAttention：前缀缓存

还有一个优化叫 RadixAttention（SGLang 提出的）。

很多请求有相同的前缀，比如： - 系统提示词都是一样的 - 用户在同一个对话里，前面的历史是一样的

这些相同前缀的 KV Cache 是一样的，不需要重复计算。

RadixAttention 用一个前缀树（trie）来缓存 KV Cache： - 新请求来了，先看看前缀有没有缓存 - 有缓存的部分直接用，不用重新算 - 只算新的部分

这样可以大大减少 prefill 的时间，尤其是对于有很多共享前缀的场景（比如 Agent、多轮对话）。

💡 生活类比： RadixAttention 就像一个"备忘录"： - 之前算过的内容，记下来 - 下次遇到相同的开头，直接用之前的结果，不用重新算

对于 Agent 这种反复用相同系统提示词的场景，特别有用。

10.6 推理框架和工具

最后，我们来看看实际中用什么工具做推理。

开源推理框架： - vLLM：UC Berkeley 开发的，PagedAttention 的发明者，流行、性能好 - SGLang：UC Berkeley 开发的，RadixAttention，适合 Agent 场景 - TensorRT-LLM：NVIDIA 官方的，对 NVIDIA GPU 优化最好 - llama.cpp：纯 C++ 实现，支持 CPU 推理，适合本地运行

云服务提供商： - 闭源模型：OpenAI、Anthropic、Google 等 - 开源模型服务：Together、Fireworks、Baseten、DeepInfra、Groq、Cerebras 等

💡 怎么选？ - 如果你要自己部署：vLLM 是很好的默认选择 - 如果你做 Agent：可以试试 SGLang - 如果你用 NVIDIA GPU 追求极致性能：TensorRT-LLM - 如果你想在本地电脑上跑：llama.cpp

10.7 本讲小结

这一讲我们学了推理优化：

为什么推理重要 - 训练是一次性的，推理是持续的 - 推理成本可能超过训练成本 - 三个指标：TTFT、延迟、吞吐量

推理为什么慢 - 推理是内存受限的（算术强度低） - 朴素推理是 O(T²) 的

KV Cache - 缓存 K、V，避免重复计算 - 把 O(T²) 变成 O(T) - Prefill（计算受限）和 Decode（内存受限）两个阶段

有损优化 - GQA/MLA：减少 KV Cache 大小 - 量化：用更少的比特存数据 - 剪枝、蒸馏：让模型变小

无损优化 - 投机采样：用小模型猜，大模型验证

动态工作负载 - 连续批处理：提高 GPU 利用率 - PagedAttention：KV Cache 的虚拟内存，减少碎片 - RadixAttention：前缀缓存，减少重复计算

10.8 小白常见问题 Q&A

Q1：推理优化这么多方法，实际中用哪些？

A：实际中通常是多种方法一起用： 1. 模型层面：用 GQA（减小 KV Cache） 2. 量化：INT8 或 INT4（减小内存占用） 3. 框架层面：用 vLLM 或 SGLang（PagedAttention、连续批处理） 4. 投机采样：如果有合适的小模型

具体用哪些，要看你的场景和精度要求。

Q2：INT4 量化会不会让模型变笨？

A：取决于具体的模型和任务。

一般来说： - INT8：精度损失几乎可以忽略，放心用 - INT4：有一些精度损失，但对于很多任务来说不明显 - 越复杂的任务（比如推理、代码），量化的影响越大 - 越简单的任务（比如聊天、摘要），量化的影响越小

如果对精度要求很高，用 INT8；如果追求速度和内存，用 INT4。

Q3：为什么不直接用小模型？还要大模型做推理优化？

A：因为小模型的能力上限不如大模型。

有些任务，小模型就是做不好，必须用大模型。

推理优化的目标是：用大模型的能力，但付出小模型的成本。

如果小模型能满足你的需求，那当然直接用小模型最好——又快又便宜。

Q4：推理优化的未来方向是什么？

A：几个热门方向： 1. 新架构：比如 Mamba、GDN 这些线性复杂度的架构，推理天然快 2. 更激进的量化：比如 2bit、1bit 量化 3. 更好的投机采样：比如 Medusa、EAGLE 等改进版 4. 专用硬件：比如 Groq、Cerebras 等专门做推理的芯片 5. KV Cache 压缩：比如 MLA、KV Cache 量化等

10.9 学习路线图

必须掌握： - 推理为什么是内存受限的 - KV Cache 是什么，为什么重要 - Prefill 和 Decode 的区别 - GQA、量化、投机采样的基本思想 - PagedAttention 的核心思路

了解即可： - 各种推理框架的细节 - 量化的具体算法（GPTQ、AWQ 等） - RadixAttention 的实现细节 - 各种投机采样的变种

配合作业： - 作业 5（Alignment）里有推理相关的内容，可以结合理解 - 下一讲（L11）会讲缩放定律的案例研究，可以接着看

第十一讲：缩放定律案例研究 — 实际中怎么做大模型

11.0 前置知识：从理论到实践

上一讲学了缩放定律的理论——幂律关系、Chinchilla、联合缩放等等。

理论归理论，实际中做大模型的时候，大家真的是按缩放定律来的吗？

答案是：是的，但比理论更复杂、更细致。

这一讲我们来看几个实际的案例，看看各个团队是怎么做缩放分析的： - MiniCPM：清华团队的小模型，用了 muP - DeepSeek：深度求索的 7B 和 67B 模型 - LLaMA 3、Qwen、Kimi K2 等其他模型

通过这些案例，你会看到缩放定律在实际中是怎么用的，有哪些技巧和坑。

💡 为什么要学案例？ 理论是理想化的，实践中会遇到各种实际问题： - 小模型的缩放规律能推广到大模型吗？ - 学习率怎么随规模调整？ - batch size 怎么选？ - 怎么降低缩放分析的成本？

这些问题理论不会告诉你答案，但案例可以。

11.1 案例一：MiniCPM — 用 muP 做小而强的模型

先看第一个案例：MiniCPM。

MiniCPM 是清华团队 2024 年做的一个小模型（1-2.5B 参数），性能很强——打败了大多数 2B 模型，甚至能和很多 7B 模型媲美。

他们是怎么做的？核心就是仔细的缩放分析 + muP。

11.1.1 什么是 muP？

先回顾一下 muP（Maximum Update Parametrization，最大更新参数化）。

普通的参数化（Standard Parametrization，SP）有个问题：模型大小变了，最优学习率也会变。

也就是说，你在小模型上调好的学习率，放到大模型上不一定好用——得重新调。

muP 是一种特殊的参数化方式，可以让最优学习率不随模型大小变化。

怎么做到的？通过调整初始化和学习率的缩放方式，让： 1. 初始化时激活值的量级不变 2. 一步梯度更新后激活值的变化量也不变

这样，小模型上调好的学习率，大模型直接用就行——不用重新调。

💡 muP 的好处： - 小模型调好的超参数，大模型直接用 - 缩放更稳定，不容易出问题 - 节省大模型调参的成本

听起来很美好，对吧？但 muP 也不是万能的，后面会讲。

11.1.2 MiniCPM 的缩放策略

MiniCPM 的缩放策略是： 1. 用 muP 做参数化，保证学习率等超参数不随规模变化 2. 固定深宽比（aspect ratio），只缩放整体大小 3. 在小模型上做缩放分析，预测大模型的最优配置 4. 训练最终的大模型

他们发现，用 muP 之后，缩放确实很稳定——小模型上的规律可以很好地推广到大模型。

💡 固定深宽比： MiniCPM 固定了 d_model / num_layers 的比例，只缩放整体大小。 这样缩放更简单，因为只有一个变量（模型大小），而不是两个（深度和宽度）。

这也是很多团队的做法——先固定深宽比，再缩放。

11.1.3 WSD 学习率：让缩放分析更便宜

缩放分析有个问题：太贵了。

比如 Chinchilla 方法三（联合拟合），需要在模型大小 × 数据量的二维网格上做实验，每个点都要从头训练到收敛。

如果有 10 个模型大小 × 10 个数据量，那就是 100 次训练——太贵了！

MiniCPM 提出了一个技巧：WSD 学习率。

什么是 WSD？就是把学习率调度分成三段： 1. Warmup（预热）：学习率从 0 升到最大值 2. Stable（稳定）：学习率保持最大值不变 3. Decay（衰减）：学习率衰减到 0

普通的 cosine 学习率是平滑下降的，而 WSD 是"平的"——稳定阶段学习率不变。

为什么 WSD 有用？

因为在稳定阶段，loss 下降得很慢，模型的状态变化不大。你可以在稳定阶段的任意点"重启"训练，改变数据量或其他设置，效果和从头训练差不多。

这样，做缩放分析的时候，就不需要每个点都从头训练了——可以从稳定阶段接着训，省很多钱！

💡 WSD 的巧妙之处： 想象你在爬山（训练模型）： - Cosine 学习率 = 一直慢慢往上爬，速度越来越慢 - WSD = 先爬一段（warmup），然后在平台上走一会儿（stable），最后再冲顶（decay）

在平台上的时候，你可以停下来换条路（改变配置），也不会差太多。 这样你就不用每次都从山脚开始爬了——省了很多力气。

11.1.4 MiniCPM 的发现

MiniCPM 用缩放分析发现了什么？

  1. 最优学习率：用 muP 之后，最优学习率确实比较稳定，不怎么随规模变化
  2. 最优 batch size：目标 loss 越低，最优 batch size 越大（和之前的结论一致）
  3. 数据-模型配比：他们用 Chinchilla 方法一和方法三做了分析，发现最优的数据/参数比很高——比 Chinchilla 的 20:1 还要高

也就是说，MiniCPM 认为应该用更多的数据、更小的模型——和"过度训练"的趋势一致。

11.2 案例二：DeepSeek — 不用 muP 的缩放

第二个案例：DeepSeek。

DeepSeek 是深度求索团队 2024 年做的模型，有 7B 和 67B 两个版本，性能很强。

和 MiniCPM 不同，DeepSeek 不用 muP——他们直接在小模型上做网格搜索，估计最优的 batch size 和学习率。

11.2.1 DeepSeek 的缩放策略

DeepSeek 的缩放策略： 1. 假设大多数 Transformer 超参数（深度、宽度、FFN 比例等）不随规模变化 2. 在小模型上做 batch size 和学习率的缩放分析 3. 用 IsoFLOP 分析（Chinchilla 方法二）来确定模型大小和数据量的配比 4. 用 WSD 风格的学习率调度来降低缩放分析的成本

他们不用 muP，而是直接经验性地找学习率和 batch size 随规模的缩放规律。

💡 为什么不用 muP？ 可能的原因： 1. muP 实现起来有点麻烦 2. muP 不是万能的，有些情况下效果不如直接调参 3. 直接在小模型上做网格搜索也不贵，而且更直接

不同的团队有不同的风格，没有绝对的对错。

11.2.2 DeepSeek 的发现

DeepSeek 的缩放分析发现： 1. 学习率缩放：最优学习率随模型大小有变化，但变化不大 2. Batch size 缩放：最优 batch size 随数据量增长而增长 3. IsoFLOP 分析：用等计算量分析找到了最优的模型大小 4. 预测准确：缩放分析预测的最终 loss 和实际训练的结果很接近

这说明缩放定律确实有用——小模型上的分析可以准确预测大模型的性能。

11.3 其他模型的缩放实践

除了 MiniCPM 和 DeepSeek，还有很多模型也做了缩放分析。我们快速过一下。

11.3.1 Qwen 系列

Qwen 2.5 和 Qwen 3 也做了 batch size 和学习率的缩放分析。

他们的方法和 DeepSeek 类似——在小模型上做网格搜索，找到缩放规律，然后用到大模型上。

具体的细节公开得不多，但大方向是一致的。

11.3.2 LLaMA 3

LLaMA 3 用了 IsoFLOP 风格的缩放分析。

他们发现的最优数据/参数比大约是 39:1——比 Chinchilla 的 20:1 高，说明确实需要更多的数据。

11.3.3 Kimi K2

Kimi K2 是 MoE 模型，他们做了稀疏缩放定律的分析——找最优的稀疏度（专家数量、激活专家数）。

MoE 的缩放更复杂，因为多了一个维度（总参数量 vs 激活参数量）。

11.3.4 Hunyuan

Hunyuan 也做了 IsoFLOP 风格的 MoE 缩放分析，发现最优的数据/激活参数比大约是 96:1——非常高！

这说明 MoE 模型可能更需要"过度训练"。

💡 趋势总结： 看了这么多案例，你会发现一个共同的趋势： - 大家都认为最优的数据/参数比比 Chinchilla 的 20:1 要高 - 也就是说，应该用更多的数据，更小的模型 - MoE 模型的比例更高，因为激活参数少

为什么？可能是因为： 1. Chinchilla 的实验有偏差 2. 推理成本越来越重要，大家倾向于小模型多数据 3. 数据质量提高了，更多数据更有价值

11.4 优化器和缩放

除了模型大小和数据量，优化器也和缩放有关。

11.4.1 优化器的选择

不同的优化器有不同的性能，而且它们的缩放规律可能也不一样。

比如： - Adam vs SGD：Adam 在小模型上更好，但大模型上差距缩小 - AdamW vs Adam：现在大家基本都用 AdamW - Lion、Sophia 等新优化器：有些声称更快更好，但缩放特性还在研究中

选择优化器的时候，也要考虑缩放——不能只看小模型上的效果，要看大模型上怎么样。

⚠️ 注意：优化器的比较很容易有偏差。 如果你在小模型上调好了一个优化器，放到大模型上可能就不是最优的了。 所以比较优化器的时候，一定要在不同规模上都测试，不能只看一个点。

11.4.2 Muon 优化器

最近有个新的优化器叫 Muon，挺有意思的。

Muon 是什么？ - 专门针对"矩阵值"参数（比如线性层的权重矩阵）设计的 - 用 Newton-Schultz 迭代来近似正交化更新 - 据说比 Adam 缩放得更好

Muon 在一些模型上表现不错，比如 Kimi K2 就用了 Muon，说缩放效果很好。

但它还是比较新的，还没有被广泛验证。

💡 优化器的发展趋势： 从 SGD → Adam → AdamW → Lion/Sophia → Muon... 优化器一直在进化，目标都是： - 训练更快 - 更稳定 - 缩放更好

但 AdamW 目前还是主流——简单、可靠、大家都熟悉。

11.5 muP 深入：它到底是怎么工作的？

前面提到了 muP，这里我们深入一点，看看它到底是怎么工作的。

（这部分比较理论，小白可以跳过，不影响理解整体内容）

11.5.1 muP 的两个条件

muP 的设计基于两个条件：

条件 A1：初始化时，激活值的量级是 Θ(1) - 也就是说，不管网络多宽，初始化时每层的输出值大小差不多 - 这样可以保证信号不会在层间爆炸或消失

条件 A2：一步梯度更新后，激活值的变化量是 Θ(1) - 也就是说，不管网络多宽，一步更新对激活值的影响差不多 - 这样可以保证学习率不需要随宽度调整

如果这两个条件都满足，那最优学习率就不随宽度变化——小模型调好的学习率，大模型直接用。

11.5.2 怎么实现？

怎么让这两个条件成立？通过调整： 1. 初始化的方差：权重初始化的标准差随宽度变化 2. 学习率的缩放：不同层的学习率可能不一样 3. 残差连接的缩放：残差的缩放系数也可能要调整

具体的推导比较复杂，涉及矩阵谱范数、梯度的秩等等。

感兴趣的话可以去看 muP 的论文——"Scaling Limits of Wide Neural Networks"。

11.5.3 muP 好用吗？

muP 好用吗？这是个有争议的问题。

支持者认为： - 缩放更稳定 - 省调参成本 - 大模型上效果好

质疑者认为： - 实现复杂 - 效果不一定比仔细调的 SP 好 - 有些情况下缩放预测不准

CerebrasGPT 做了比较系统的研究（从 0.1B 到 13B），发现 muP 确实让缩放更稳定了。

但也有研究发现，muP 在某些设置下效果不如预期。

💡 我的建议： 如果你是初学者，不用太纠结 muP。 - 小模型：直接调参就行，不贵 - 大模型：可以试试 muP，但也要验证

muP 是工具，不是教条——有用就用，没用就不用。

11.6 缩放实践的经验总结

看了这么多案例，我们来总结一下缩放实践的经验。

11.6.1 缩放分析的一般流程

大多数团队做缩放分析的流程差不多：

  1. 固定架构超参数：先定好深度、宽度、FFN 比例等，只缩放整体大小
  2. 小模型实验：在几个小模型上做实验，收集数据
  3. 拟合缩放定律：用实验数据拟合缩放公式
  4. 预测大模型：用拟合的公式预测大模型的最优配置
  5. 训练验证：训练最终的大模型，验证预测是否准确

11.6.2 降低成本的技巧

缩放分析也不便宜，有一些技巧可以降低成本：

  1. WSD 学习率：在稳定阶段重启训练，不用每次从头来
  2. IsoFLOP 分析：比联合拟合需要的实验少
  3. 从小模型开始：先在很小的模型上找规律，再逐步放大
  4. muP：减少需要调的超参数数量

11.6.3 常见的坑

缩放分析也有很多坑：

  1. 小模型的规律不一定能推广到大模型
    • 有些现象在小模型上不出现，大模型才出现
    • 比如"涌现能力"
  2. 超参数的缩放规律可能不是幂律
    • 理论上假设是幂律，但实际可能更复杂
    • 不要太迷信公式
  3. 缩放定律是下界，不是上界
    • 缩放定律告诉你"至少能达到多少"
    • 但你可能做得更好（比如更好的架构、更好的数据）
  4. 下游任务的缩放更难预测
    • 预训练 loss 的缩放很规律
    • 但下游任务的性能缩放没那么规律
    • 不要只看预训练 loss

⚠️ 缩放定律是工具，不是真理： 缩放定律是经验规律，不是物理定律。 它可以指导你，但不能代替实验。 永远要验证，不要盲目相信。

11.7 本讲小结

这一讲我们通过案例学习了缩放定律在实践中的应用：

案例研究 - MiniCPM：用 muP + WSD 做小而强的模型 - DeepSeek：不用 muP，直接做经验缩放分析 - LLaMA 3、Qwen、Kimi K2 等：各有各的做法

缩放策略 - muP：让学习率不随规模变化 - WSD 学习率：降低缩放分析成本 - IsoFLOP 分析：找最优的模型大小和数据量配比

优化器和缩放 - 不同优化器有不同的缩放特性 - Muon 等新优化器在探索中

实践经验 - 缩放分析的一般流程 - 降低成本的技巧 - 常见的坑和注意事项

11.8 小白常见问题 Q&A

Q1：做缩放分析需要多少钱？

A：取决于你要做多细的分析。

  • 粗略分析：几个小模型，几万到几十万
  • 精细分析：几十个模型，可能几百万
  • 像 Chinchilla 那样的大规模分析：几千万

一般来说，小团队可以做粗略的，大团队可以做精细的。

Q2：muP 值不值得用？

A：看情况。

如果你训练的模型特别大（几十亿到上百亿参数），而且需要频繁调整规模，那 muP 可能值得——可以省很多调参成本。

如果只是训练一两个固定大小的模型，那直接调参可能更简单。

Q3：缩放定律在多小的模型上有效？

A：这是个好问题，目前还没有明确答案。

一般来说，从几百万参数开始，缩放定律就大致成立了。但也有研究发现，太小的模型（比如几万参数）的缩放规律可能和大模型不一样。

所以做缩放分析的时候，不要用太小的模型——至少得有几百万参数吧。

Q4：为什么不同团队的最优数据/参数比不一样？

A：有几个原因： 1. 数据质量不一样：好的数据可以用更高的比例 2. 模型架构不一样：不同架构的缩放规律可能不同 3. 目标不一样：有的追求训练最优，有的追求推理最优 4. 实验方法不一样：不同的拟合方法可能得到不同的结果

所以不要迷信某个具体的数字，要根据自己的情况来。

11.9 学习路线图

必须掌握： - 缩放分析在实践中的一般流程 - muP 的基本思想和作用 - WSD 学习率为什么能降低成本 - IsoFLOP 分析的思路 - 缩放定律是经验规律，不是真理

了解即可： - MiniCPM、DeepSeek 等具体案例的细节 - muP 的详细推导 - Muon 等新优化器 - 各种优化器的缩放特性

模块小结：Scaling Laws 与推理（L9-L11）

这三讲我们学了大模型的"经济学"——怎么把钱花在刀刃上。

Scaling Laws（L9、L11） - 核心思想：模型性能和规模之间是幂律关系 - 数据缩放、模型缩放、联合缩放 - Chinchilla 最优配比（训练最优） - 训练最优 ≠ 推理最优（用得多就过度训练） - 实践中怎么用：小模型实验 → 预测大模型 → 验证

推理优化（L10） - 推理是内存受限的，和训练不一样 - KV Cache：推理的"记忆"，把 O(T²) 变成 O(T) - 有损优化：GQA、量化、剪枝、蒸馏 - 无损优化：投机采样 - 系统优化：连续批处理、PagedAttention、RadixAttention

核心思想 - 衡量 → 分析 → 优化 → 验证 - 没有免费的午餐，都是权衡（trade-off） - 理论指导实践，但实践是检验真理的唯一标准

整个 Scaling Laws 与推理模块到这里就结束了。

下一模块是数据与评估（L12-L14），我们会学习怎么收集数据、怎么评估模型——这些也是做大模型的关键环节。

notes > CS
#CS336 #DL #AI #Scaling Laws
CS336 学习笔记 03：缩放定律与推理优化
https://cdro.tech/notes/CS/cs336-03-l9-l11-scaling-laws-inference-optimization/
作者
k9Q6CK42
发布于
2026年9月28日
更新于
2026年9月28日
许可协议