四十三、Scaling Laws for Neural Language Models[2020]

1. language 为人工智能的研究提供了一个天然的领域，因为绝大多数的 reasoning task 都可以用语言有效地表达和评估，而且世界上的文本通过 generative modeling 为无监督学习提供了大量的数据。最近，深度学习在 language modeling 方面取得了快速进展， SOTA 模型在许多特定任务上的表现接近人类水平。

   人们可能预期语言建模的性能取决于模型结构、神经模型的规模、用于训练模型的算力、以及用于训练模型的数据。在论文 《Scaling Laws for Neural Language Models》 中，作者将实证研究 language modeling loss 对所有这些因素的依赖性，重点是 Transformer 架构。通过在语言任务上的性能的上限和下限，使作者能够研究 scale 中超过七个数量级的趋势。

   在整个过程中，作者将观察到性能的精确的 power-law scaling ，其中性能作为训练时间、上下文长度、数据集大小、模型大小、compute budget 的函数。

2. 相关工作：

   • 幂律（power-law ）可以从各种来源产生。在密度估计(density estimation ) 模型和随机森林模型中，随模型规模和数据集大小有关的 power-law scaling 可能与我们的结果有关。这些模型表明，幂律指数可能有一个非常粗糙的解释，即数据中相关特征数量的倒数。

   • 最近的工作 《Deep learning scaling is predictable,empirically》、《Beyond human-level accuracy: Computational challenges in deep learning》 也研究了模型大小和数据大小之间的 scaling ；他们的工作可能是文献中最接近我们的工作。然而，请注意， 《Deep learning scaling is predictable,empirically》 发现数据集大小与模型大小的超线性 scaling ，而我们发现的是亚线性 scaling 。

     • 我们关于计算量的 optimal allocation 的发现和 《One epoch is all you need》 之间有一些相似之处，包括 power-law learning curve 。

     • EfficientNet 似乎也服从于准确率和模型大小之间的近似的幂律关系。

     • 最近的工作 《A constructive prediction of the generalization error across scales》研究了各种数据集的数据集大小和模型大小的 scaling ，并符合与我们类似的分析方法。

   • EfficientNet 主张以指数方式 scale 模型的深度和宽度，以获得图像模型的最佳性能，导致宽度作为深度的函数出现 power-law scaling 。我们发现，对于语言模型来说，这个幂律在 scaling up 时应该是大致为 1 （即， width/depth 的比例应该保持固定）。但更重要的是，我们发现，与语言模型的 overall scale 相比，精确的架构超参数并不重要。

     • 在 《Residual networks behave like ensembles of relatively shallow networks》 中，有人认为 deep 的模型可以作为较浅的模型的 ensemble ，这有可能解释这一发现。

     • 早期的工作 《Wide residual networks》 比较了宽度和深度，发现 wide ResNet 在图像分类上可以胜过 deep ResNet 。

     • 一些研究固定了每个数据样本的计算量（计算量往往与模型参数的数量成正比，固定这个值意味着固定模型大小），而我们研究的是与模型大小和 training computation 的 scaling 。

   • 许多研究（《High-dimensional dynamics of generalization error inneural networks》、《Reconciling modern machine learning and the bias-variance trade-off》对高度过参数化的模型（highly overparameterized model）的泛化进行了研究，发现当模型规模达到数据集规模时，会出现 "jamming transition" （《Scaling description of generalization with number of parameters in deep learning》）（这可能需要超出典型实践许多数量级的 training ，尤其是不使用早停）。我们没有观察到这样的 transition ，并发现所需的训练数据在模型大小上呈亚线性 scaling 。模型规模的扩展，特别是在 large width 上的扩展，可能为思考我们的一些 scaling 关系提供了一个有用的框架。

     我们关于 optimization 的结果（如学习曲线的形状），很可能可以用一个 noisy 的二次模型来解释，它可以在现实环境中提供相当准确的预测（《Which algorithmic choices matter at which batch sizes? insights from a noisy quadratic model》）。定量评估这种联系将需要海森谱（ Hessian spectrum） 的特性。

这篇论文直接看结论部分即可，剩余的大多数都是实验报告。

43.1 背景和模型

1. 符号：

   • $L$$L$ ：交叉熵损失。通常情况下，它将是一个上下文中所有 token 的交叉熵损失的平均值，但在某些情况下，我们会报告上下文中特定位置处的 token 的损失。

   • $N$$N$：模型参数的数量，不包括所有 vocabulary embedding 和 positional embedding 。

   • $C\simeq 6NBS$$C\simeq 6NBS$：是对 non-embedding 的 training 总计算量的估计，其中 $B$$B$ 是 batch size ，$S$$S$ 是 training steps 数量（即 parameter updates ）。我们引入 PF-days 为单位，其中一个 PF-days 表示 ${10}^{15}\times 24\times 3600=8.64\times {10}^{19}$$10^{15}\times 24 \times 3600 = 8.64\times 10^{19}$ 次浮点运算。

   • $D$$D$ ：数据集的大小，单位为 token 。

   • $B_{\text{crit}}$$B_\text{crit}$：critical batch size，在后续内容中定义和讨论。使用 critical batch size 的训练提供了训练时间和计算效率之间的大致上的最佳 trade-off 。

   • $C_{min}$$C_\min$：对达到给定 loss 的最小 non-embedding compute 的估计。这是在模型以远小于 critical batch size的 batch size 进行训练时将使用的 training compute 。

     较小的 batch size 可以实现较小的计算量、但是需要较大的训练时间。

   • $S_{min}$$S_\min$：达到给定 loss 所需的最小 training steps 数的估计。这也是如果模型在batch size 远大于 critical batch size 的情况下所使用的 training steps 数量。

     较大的 batch size 可以实现较小的训练时间、但是需要较大的计算量。

   • ${\alpha }_X$$\alpha_X$：对 loss 缩放的幂率函数的指数，其中 $L(X)\propto {\left(1/X\right)}^{{\alpha }_X}$$L(X)\propto \left(1/X\right)^{\alpha_X}$ ，$X$$X$ 可以为 $N,D,C,S,B,C_{min}$$N,D,C,S, B,C_\min$ 中的任意一种。

   注，这里的 loss 函数是 test loss，而不是 train loss 。

2. 我们在 WebText2 上训练语言模型，这是 WebText数据集的扩展版本，使用 byte-pair encoding: BPE 进行 tokenize ，vocabulary size 为 $n_{\text{vocab}}=50257$$n_\text{vocab} = 50257$ 。我们优化 autoregressive log-likelihood （即交叉熵损失），在 1024-token 的上下文中取平均，这也是我们的主要性能指标。我们在 WebText2 测试集、以及其它一些测试集上记录 loss 。我们主要训练 decoder-only Transformer 模型，尽管我们也训练 LSTM 模型和 Universal Transformer 以进行比较。

   模型的性能评估指标是测试集上的交叉熵损失。

a. Transformer 的参数 scaling 和计算量 scaling

1. 我们使用超参数 $n_{\text{layer}}$$n_\text{layer}$ （层数）、$d_{\text{model}}$$d_\text{model}$ （residual stream 的维度）、$d_{\text{ff}}$$d_\text{ff}$ （中间 feed-forward layer 的维度）、$d_{\text{attn}}$$d_\text{attn}$ （ attention output 的维度）和 $n_{\text{heads}}$$n_\text{heads}$ （每层 attention head 的数量）对Transformer 架构进行参数化。我们在输入上下文中包括 $n_{\text{ctx}}$$n_\text{ctx}$ 个 token ，除另有说明外否则默认采用 $n_{\text{ctx}}=1024$$n_\text{ctx}=1024$ 。

   我们用 $N$$N$ 来表示模型大小，我们把它定义为 non-embedding parameters 的数量（推导过程参考Table 1 ）：

   $$\begin{array}{}\text{(1)}& \begin{array}{c}N\simeq 2d_{\text{model}}\times n_{\text{layer}}\times (2d_{\text{attn}}+d_{\text{ff}})=12n_{\text{layer}}{d}_{\text{model}}^2\\ \text{ with the standard }{d}_{\text{attn}}=d_{\text{ff}}/4=d_{\text{model}}\end{array}\end{array}$$

   其中，我们排除了 bias 项和其他次要的项。我们的模型在 embedding 矩阵中也有 $n_{\text{vocab}}\times d_{\text{model}}$$n_\text{vocab}\times d_\text{model}$ 个参数，并使用 $n_{\text{ctx}}\times d_{\text{model}}$$n_\text{ctx}\times d_\text{model}$ 个参数进行 positional embedding ，但我们在讨论 "模型大小" $N$$N$ 时不包括这些参数。我们将看到，这产生了明显更干净的 scaling law 。

   评估 Transformer 的前向传播大致上包括 $C_{\text{forward}}\simeq 2N+2n_{\text{layer}}\times n_{\text{ctx}}\times d_{\text{model}}$$C_\text{forward}\simeq 2N + 2n_\text{layer}\times n_\text{ctx}\times d_\text{model}$ 个乘加操作（add-multiply operation ），其中系数 2 来自于矩阵乘法中使用的 multiply-accumulate operation 。下表中包含了更详细的每个操作的参数数量和计算次数。

   

2. 对于 $d_{\text{model}}>n_{\text{ctx}}/12$$d_\text{model} > n_\text{ctx}/12$ 的上下文和模型，每个 token 的 context-dependent 的计算成本是总计算量的一个相对较小的部分。由于我们主要研究 $d_{\text{model}}\gg n_{\text{ctx}}/12$$d_\text{model} \gg n_\text{ctx}/12$ 的模型，我们的 training compute 的估计中不包括 context-dependent 项。考虑到反向传播（大约是前向传播计算量的两倍），我们为每个 training token 将估计的 non-embedding compute 定义 $C\simeq 6N$$C\simeq 6N$ 个浮点运算。

   对于 GPT-3 175B，$d_{\text{model}}=12288$$d_\text{model} = 12288$ ，$n_{\text{layer}}=96$$n_\text{layer} = 96$，$d_{\text{attn}}=d_{\text{model}}$$d_\text{attn} = d_\text{model}$，$d_{\text{ff}}=4\times d_{\text{model}}$$d_\text{ff} = 4\times d_\text{model}$ 。因此只需要 $n_{\text{ctx}}<147456$$n_\text{ctx} \lt 147456$ 即可满足上述条件。

b. 训练过程

1. 除非另有说明，我们用 Adam 优化器训练模型，其中训练了固定的 $2.5\times {10}^5$$2.5\times 10^5$ 步， batch size 为 512 个序列，每个序列包含 1024 tokens 。

   • 由于内存限制，我们最大的模型（超过 1B 个参数）是用 Adafactor 训练的。

   • 我们试验了各种学习率和 schedules 。我们发现，收敛的结果在很大程度上与 learning rate schedule 无关。除非另有说明，我们的数据中包括的所有 training runs 都使用了同一个 learning rate schedule ，即：3000 步的线性预热，然后是余弦衰减学习率到零。

2. 我们用各种学习率和 schedule 进行了实验。下图显示了一个小型语言模型的一系列 schedules 和测试结果。我们的结论是，只要 total summed learning rate 足够大，而且 schedule 包括一个预热期、以及最后衰减到接近零的学习率，那么 learning rate schedule 的选择基本上是不重要的。schedules 之间的方差似乎是统计学上的噪音，并为不同 training runs 之间的方差的 scale 提供一个粗略的衡量标准。在较大的模型上的实验表明，对于不同的模型大小，不同的随机种子之间的 final test loss 的方差的幅度是大致不变的。

   我们发现，较大的模型需要一个较小的学习率来防止发散，而较小的模型可以容忍较大的学习率。为了实现这一点，在大多数 runs 中使用了以下经验法则：

   $$\begin{array}{}\text{(2)}& \text{LR}(N)\simeq 0.003239\pm 0.0001395\times \log (N)\end{array}$$

   我们期望这个公式可以被改进。

   可能存在对 network width 的依赖性，可能是由 initialization scale 设定的。对于 $N>{10}^{10}$$N>10^{10}$ 个参数，该公式也会被打破。尽管如此，我们发现它对我们所考虑的模型有足够的作用。

   

c. 数据集

1. 我们在 GPT2中描述的 WebText 数据集的扩展版本上训练我们的模型。最初的 WebText 数据集是对 Reddit 在 2017 年 12 月的外链（包含 Reddit 用户的至少三个点赞）的网络爬取。在第二个版本中（即，WebText2 ），我们增加了 2018 年 1 月至 10 月期间的 Reddit 外链，也是至少有 3 个点赞的。karma 阈值（即，点赞的数量阈值）作为一种启发式方法，用于判断人们是否认为该链接有趣或有用。新链接的文本是用 Newspaper3k python library 提取的。

   总的来说，该数据集由 20.3M 篇文档组成，包含 96GB 的文本和 $1.62\times {10}^{10}$$1.62\times 10^{10}$ 个单词。然后我们应用 GPT2 中描述的可逆的 tokenizer ，产生 $2.29\times {10}^{10}$$2.29\times 10^{10}$ 个 token 。我们保留了其中的 $6.6\times {10}^8$$6.6\times 10^8$ 个 token 作为测试集，并且我们还在类似的 Books Corpus 、Common Crawl、English Wikipedia 、以及公开的 Internet Books 集合中进行测试。

43.2 实验结果和 Basic Power Laws

1. 为了刻画 language model scaling ，我们训练了各种各样的模型，其中改变了一些因子，包括：

   • 模型大小：从 768 到 1.5B 个 non-embedding 参数。

   • 数据集大小：从 22M 到 230B 个 token 。

   • 模型shape：包括 depth、width、attention head、以及 feed-forward dimension 。

   • 上下文长度：大多数 runs 设置为 1024，但我们也尝试使用较短的上下文。

   • batch size： 大多数 runs 设置为 $2^{19}$$2^{19}$，但我们也改变 batch size 从而测量 critical batch size 。

43.2.1 Transformer Shape

1. 当我们固定 non-embedding 参数总数 $N$$N$ 时， Transformer 的性能对 shape 参数 $n_{\text{layer}},n_{\text{heads}},d_{\text{ff}}$$n_\text{layer}, n_\text{heads}, d_\text{ff}$ 的依赖非常弱。

   为了确定这些结果，我们用固定的模型大小来训练模型，同时改变一个超参数。

   • 这对于 $n_{\text{heads}}$$n_\text{heads}$ 的情况是最简单的：改变 $n_{\text{heads}}$$n_\text{heads}$ 同时改变每个 head 的维度，使得 $d_{\text{model}}$$d_\text{model}$ 保持不变。

     右图中，每条曲线对应于固定的 $d_{\text{model}}$$d_\text{model}$ 同时改变 $n_{\text{heads}}$$n_\text{heads}$ 。

   • 当改变 $n_{\text{layer}}$$n_\text{layer}$ 时，我们同时改变$d_{\text{model}}$$d_\text{model}$ ，同时保持 $N\simeq 12n_{\text{layer}}{d}_{\text{model}}^2$$N\simeq 12n_\text{layer} d_\text{model}^2$ 固定。

     中间图中，每条曲线对应于固定的参数量同时改变 $n_{\text{layer}}$$n_\text{layer}$ 和 $d_{\text{model}}$$d_\text{model}$ 。

   • 同样地，为了在固定的模型大小下改变 $d_{\text{ff}}$$d_\text{ff}$，我们也同时改变 $d_{\text{model}}$$d_\text{model}$ 参数，这是由 Table 1 中的参数数量所要求的。

     左图中，每条曲线对应于固定的参数量同时改变 $d_{\text{ff}}$$d_\text{ff}$ 和 $d_{\text{model}}$$d_\text{model}$ 。

   如果 deeper Transformer 有效地表现为 shallower model 的 ensembles，那么就会导致 $n_{\text{layer}}$$n_\text{layer}$ 的独立性，正如对 ResNet 的建议（《Residual networks behave like ensembles of relatively shallow networks》）。结果显示在下图中。

   下图中，不同的模型形状，得到的 test loss 差异很小，差异基本上都在 10% 以内。

   

43.2.2 non-embedding 参数数量 N

a. 实验结果

1. 在下图中，我们展示了各种模型的性能，从 shape $(n_{\text{layer}},d_{\text{model}})=(2,128)$$(n_\text{layer}, d_\text{model}) = (2, 128)$ 的小模型、到十亿参数的大模型，其中大模型的 shape 从 $(6,4288)$$(6,4288)$ 到 $(207,768)$$(207, 768)$ 不等。在这里，我们已经在完整的 WebText2 数据集上训练到接近收敛，并且观察到没有过拟合（除了非常大的模型，因为对于非常大的模型则可能过拟合）。

   如 Figure 1 右图所示，我们发现关于 non-embedding 参数数量 $N$$N$ 的一个稳定的趋势，即：

   $$\begin{array}{}\text{(3)}& L(N)\simeq {\left(\frac{N_c}{N}\right)}^{{\alpha }_N}\end{array}$$

   

   要观察这些趋势，关键是要研究模型性能与 $N$$N$ 的关系。如果我们改用总的参数数量（包括 embedding 参数），趋势就有些模糊了（如下左图所示）。这表明，embedding matrix 可以做得更小而不影响性能，这在最近的工作中已经看到了（《Albert: A lite bert for self-supervised learning of language representations》）。

   ALBert 将 embedding matrix 分解为两个低维矩阵的乘积，这等价于降低了 embedding matrix 的大小。

   

2. 尽管这些模型是在 WebText2 数据集上训练的，但它们在其他各种数据集上的 test loss 也是 $N$$N$ 的幂律，指数几乎相同，如下左图所示。

   左图、右图的详细说明参考 “数据分布之间的泛化” 章节。

   

b. 与 LSTM 和 Universal Transformer的比较

1. 在下图中，我们比较了 LSTM 和 Transformer 的性能与 non-embedding 参数数量 $N$$N$ 的关系。LSTM 是用与 Transformer 相同的数据集和上下文长度来训练的。从右图中我们可以看出，LSTM 对于上下文位置中头部出现的 token 表现得和 Transformer 一样好，但是对于上下文位置中尾部出现的 token 则无法与 Transformer 的表现相媲美。

   红色曲线为 LSTM，蓝色曲线为 Transformer 。

   

2. 下图中给出了模型性能与上下文位置之间的幂律关系，其中，除了第一个 token 之外（最上面的一条曲线），都显示了随着模型大小的增加而稳定地改善，表明快速识别模式的能力有所提高。

   我们还包括用很小的 $n_{\text{ctx}}=8$$n_\text{ctx}=8$ 上下文来训练的模型，以便与我们的更长的上下文模型进行比较（即，$n_{\text{ctx}}=1024$$n_\text{ctx} = 1024$）。即使是在 $n_{\text{ctx}}=8$$n_\text{ctx}=8$ 的情况下训练的规模不大的模型也能在非常早期的 token 上超越我们最大的 $n_{\text{ctx}}=1024$$n_\text{ctx}=1024$ 模型。这也表明，在大的上下文下训练的更大的模型应该可以有进一步的改进。

   因为对于 $n_{\text{ctr}}=1024$$n_\text{ctr} = 1024$ 的模型，它看到的上下文信息更多，理论上应该表现更好。

   

3. 在固定模型大小的情况下， loss scale 似乎与上下文中的位置 $T$$T$ 成幂律关系，如下图所示。这可能是语言中潜在的 power-law correlation 的结果，或者是模型结构和 optimization 的一个更普遍的特征。它为在更大的上下文中训练的潜在好处（或潜在不足）提供了一些建议。不仅较大的模型在 $T=1024$$T=1024$ 时收敛到较好的性能，而且在 early tokens 时也改善得更快，这表明较大的模型在检测 less contextual information 的模式时更有效率。

   在右边的图中，我们显示了对于一个固定的模型， per-token 性能是如何作为 training steps 的函数而变化的。early tokens 在训练过程中更快地被学好，而末尾的 tokens 在训练的后期才能训练好。

   左图：每条曲线对应一个模型（不同模型大小）的 per-token test loss ，在模型训练结束后。

   右图：每条曲线对应一个 token index 的学习曲线，在模型训练过程中，固定的模型。

   

4. 我们还在下图中比较了标准 Transformer 和 recurrent Transformer （《Universal transformers》）的性能。 recurrent Transformer 模型复用参数，因此表现得略好（右图），但代价是每个参数的额外计算量。

   左图把 reuse 的参数也认为是全新的，因此参数规模会变大。

   

c. 数据分布之间的泛化

1. 我们还在一组额外的文本数据分布上测试了我们的模型。下图显示了这些数据集上的 test loss 与模型大小的关系。在所有情况下，模型都只在 WebText2 数据集上训练过。

   • 从左图中我们看到，在这些其他数据分布上的 loss 随着模型规模的增加而平滑地改善，直接地平行于 WebText2 的 test loss 曲线。

   • 从右图中我们发现，泛化性几乎完全取决于 in-distribution validation loss ，而不取决于训练的持续时间、或接近于收敛的程度。

     虚线表示单个大型模型在它训练过程中，所得到的 test loss；圆点表示很多收敛的模型对应的 test loss 。

   

2. 我们还观察到对模型深度没有依赖性（在固定模型大小的条件下）。

   

d. 性能与数据集大小和计算量的关系

1. 我们在下图中显示了 test loss 作为数据集大小 $D$$D$（以 token 数量为单位）和训练计算量 $C$$C$ 的函数的经验趋势。

   • 对于 $D$$D$ 上的趋势，我们在 WebText2 数据集的固定子集上训练了一个 $(n_{\text{layer}},n_{\text{embd}})=(36,1280)$$(n_\text{layer},n_\text{embd}) = (36, 1280)$ 的模型。一旦 test loss 不再减少，我们就停止训练。我们看到，所产生的 test loss 可以用数据集大小 $D$$D$ 的简单的幂律来拟合：

     $$\begin{array}{}\text{(4)}& L(D)\simeq {\left(\frac{D_c}{D}\right)}^{{\alpha }_D}\end{array}$$

     如 Figure 1 中间的图所示。

   • 训练过程中使用的 non-embedding 计算总量可以估计为 $C=6NBS$$C = 6NBS$ ，其中 $B$$B$ 是 batch size ，$S$$S$ 是 parameter updates 的数量，系数 6 代表了同时包含前向传播和反向传播。因此，对于一个给定的 $C$$C$ 值，我们可以扫描所有具有不同 $N$$N$ 的模型，找到在 step 数量 $S=\frac{C}{6BS}$$S = \frac{C}{6BS}$ 上具有最佳性能的模型。

     请注意，在这些结果中，batch size $B$$B$ 对所有模型都是固定的，这意味着这些经验结果不是真正的最优。我们将在后面的章节中使用调整后的 $C_{min}$$C_{\min}$ 来说明这一点，以产生更清晰的趋势。

     这个结果如Figure 1 左图的加粗黑线所示。它可以用如下的方程来拟合：

     $$\begin{array}{}\text{(5)}& L(C)\simeq {\left(\frac{C_c}{C}\right)}^{{\alpha }_C}\end{array}$$

     此外，在左图中还包括每个模型的学习曲线，从而展示每个模型何时达到最优。

   

2. 我们将在后面更仔细地研究计算量的最佳分配问题。数据强烈表明，sample efficiency 随着模型的大小增加而提高，如右图所示，对于给定的 test loss，模型越大所需要的样本数越少。

   • 左图：每条曲线表示在给定的 test loss （不同曲线采用不同的值）的条件下，最短的训练时间（由 minimum steps 衡量）和模型大小的关系。通常而言，模型参数越大，训练时间越短。

   • 右图：每条曲线表示在给定的 test loss （不同曲线采用不同的值）的条件下，最少的训练过程中看过的样本（ $E=B\times S$$E = B\times S$）和模型大小的关系。通常而言，模型参数越大，所需要的样本数越少。

   

43.3 Infinite Data Limit 和过拟合

1. 在前面的内容中，我们发现了针对语言建模性能的一些 basic scaling laws 。这里，我们将研究在具有 $D$$D$ 个 tokens 的数据集上训练的大小为 $N$$N$ 的模型，并同时改变 $N$$N$ 和 $D$$D$ 时模型的性能。我们将从经验上证明最佳的 test loss 符合公式 $L(N,D)$$L(N,D)$ 的 scaling law 。这为我们需要多少数据来训练规模不断扩大的模型、并同时控制过拟合提供了指导。

43.3.1 L(N, D) 公式

1. 我们选择参数化 $L(N,D)$$L(N,D)$ 为：

   $$\begin{array}{}\text{(6)}& L(N,D)={[{\left(\frac{N_c}{N}\right)}^{{\alpha }_N/{\alpha }_D}+\frac{D_c}{D}]}^{{\alpha }_D}\end{array}$$

   其中，这个公式基于三个原则：

   • 词表大小或 tokenization 的变化有望通过一个整体因子来 rescale 损失函数。 $L(N,D)$$L(N,D)$ 的参数化（以及所有 loss 的建模）自然必须考虑到这种 rescaling 。

   • 固定 $D$$D$ 并选择 $N\to \mathrm{\infty }$$N\rightarrow \infty$，那么 overall loss 应该接近 $L(D)$$L(D)$ 。相反地，固定 $N$$N$ 并选择 $D\to \mathrm{\infty }$$D\rightarrow \infty$ ，那么 overall loss 应该接近 $L(N)$$L(N)$ 。

   • $L(N,D)$$L(N,D)$ 应该在 $D=\mathrm{\infty }$$D=\infty$ 处是 analytic 的，因此它在 $1/D$$1/D$ 处具有整数幂次的级数展开（series expansion）。对这一原则的理论支持明显弱于前两者。

     即，对于无限的训练数据，模型应该能够收敛。

   我们选择的 $L(N,D)$$L(N, D)$ 满足第一个要求，因为我们可以通过改变词表来 rescale $N_c,D_c$$N_c, D_c$ 。这也暗示了 $N_c,D_c$$N_c, D_c$ 的具体取值没有根本意义。

   因为当 test loss 停止改善时我们提前结束训练，并且我们以相同方式优化所有模型，所以我们期望较大的模型应该总是比较小的模型表现得更好。但是对于固定的、有限的 $D$$D$ ，我们也不期望任何模型能够接近最佳的 possible loss 。类似地，具有固定大小的模型将是容量有限的。这些考虑激发了我们的第二个原则。注意，关于在 $D$$D$ 无穷大时的 $L(N)$$L(N)$ 、以及在 $N$$N$ 无穷大时的 $L(D)$$L(D)$ 的知识，完全决定了 $L(N,D)$$L(N,D)$ 中的参数。

   第三个原则更加是推测性的。一个简单而普遍的原因是，在非常大的 $D$$D$ 时，人们可能会过拟合到 $\text{scale }\propto 1/D$$\text{scale }\propto 1/D$。过拟合应该与数据集的方差或信噪比有关（《High-dimensional dynamics of generalization error in neural networks》），这与 $1/D$$1/D$ 成比例。这一预期应该适用于任何平滑的损失函数，因为我们希望能够将 loss 扩展到 $D\to \mathrm{\infty }$$D\rightarrow \infty$的极限。然而，这种观点假设 $1/D$$1/D$ correction 在其他方差来源中占主导地位，例如有限的 batch size 、efficacy of optimization 的其他限制。没有经验的证实，我们对它的适用性没有信心。

   我们的第三个原则解释了公式 $L(N,D)$$L(N,D)$ 中 $N$$N$ 和 $D$$D$ 的作用之间的不对称。非常相似的对称表达式也是可能的，但是它们不会有 $1/D$$1/D$ 的整数幂次展开式，并且需要引入一个额外的参数。

   在任何情况下，我们都会看到，我们对于 $L(N,D)$$L(N,D)$ 的公式很好地拟合了数据，这是我们的 $L(N,D)$$L(N,D)$ 假设方程的最重要的理由。

43.3.2 拟合结果

1. 我们以 10% 的 dropout rate 来正则化我们的所有模型，然后跟踪 test loss ，一旦 test loss 不再下降时我们就停止训练。实验结果如 Figure 9 左图所示，它包含了针对公式 $L(N,D)$$L(N,D)$ 中的四个参数 ${\alpha }_N,{\alpha }_D,N_c,D_d$$\alpha_N,\alpha_D,N_c,D_d$ 的拟合。拟合的参数如下表所示：

   Figure 9 左图：每条曲线代表一个 data size，给出了在该 data size 的条件下，test loss 和 $N$$N$ 的关系。

   Figure 9 右图：$\frac{L(N,D)}{L(N,D=\mathrm{\infty })}-1$$\frac{L(N,D)}{L(N,D=\infty)} -1$ 和 $N^{\frac{{\alpha }_N}{{\alpha }_D}}/D$$N^{\frac{\alpha_N}{\alpha_D}}/D$ 之间的拟合曲线。

   

   

   我们获得了极好的拟合，除了如下的 runs：数据集已经减少了 1024 倍到大约 $2\times {10}^7$$2\times 10^7$ tokens 。对于如此小的数据集，一个 epoch 仅包含 40 次参数更新。也许这样一个微小的数据集代表了语言建模的一个不同的区域，因为过拟合在训练的早期就发生了 （Figure 16 右图的第一条 Test Loss 曲线）。还要注意，这些参数与 basic power laws 中获得的参数略有不同，因为这里我们拟合的是完整的 $L(N,D)$$L(N,D)$ 而不仅仅是 $L(N,\mathrm{\infty })$$L(N,\infty)$ 或 $L(\mathrm{\infty },D)$$L(\infty,D)$。

   

43.3.3 D 和 N 之间的亚线性关系

1. 为了绘制 infinite data limit 的边界，我们可以直接研究过拟合的程度。对于除了最大的模型之外的所有模型，当用完整的 22B token 的 WebText2 数据集训练时，我们没有看到过拟合的迹象，因此我们可以将其作为 $D=\mathrm{\infty }$$D = \infty$ 的代表。因此，我们可以通过如下定义来比较有限的 $D$$D$ 和 infinite data limit ：

   $$\begin{array}{}\text{(7)}& \delta L(N,D)=\frac{L(N,D)}{L(N,\mathrm{\infty })}-1\end{array}$$

   并把它作为 $N,D$$N, D$ 的函数来研究。事实上，我们从经验上看到， $\delta L$$\delta L$ 仅依赖于 $N$$N$ 和 $D$$D$ 的特定组合，如 Figure 9 右图所示。这是根据等式 $L(N,D)$$L(N,D)$ 的 scaling law 得出的，即：

   $$\begin{array}{}\text{(8)}& \delta L\simeq {(1+{\left(\frac{N}{N_c}\right)}^{\frac{{\alpha }_N}{{\alpha }_D}}\times \frac{D_c}{D})}^{{\alpha }_D}-1\end{array}$$

   根据 $L(N)\simeq {\left(\frac{N_c}{N}\right)}^{{\alpha }_N}$$L(N) \simeq \left(\frac{N_c}{N}\right)^{\alpha_N}$ ，我们可以得到：

   $$\begin{array}{}\text{(9)}& \frac{L(N,D)}{L(N,\mathrm{\infty })}\simeq \frac{{[{\left(\frac{N_c}{N}\right)}^{{\alpha }_N/{\alpha }_D}+\frac{D_c}{D}]}^{{\alpha }_D}}{{\left({\left(\frac{N_c}{N}\right)}^{{\alpha }_N/{\alpha }_D}\right)}^{{\alpha }_D}}={(1+{\left(\frac{N}{N_c}\right)}^{\frac{{\alpha }_N}{{\alpha }_D}}\times \frac{D_c}{D})}^{{\alpha }_D}\end{array}$$

   注意，在大的 $D$$D$ 时，该公式也有 $1/D$$1/D$ 的幂级数展开。

   $L(N,\mathrm{\infty })$$L(N,\infty)$ 表示数据集无限大时的 test loss，它是 $L(N,D)$$L(N,D)$ 的下限，代表没有过拟合时的 test loss 。因此：

   • $\delta L$$\delta L$ 一定大于等于 0 。如 Figure 9 右图所示。

   • $\delta L$$\delta L$ 代表了由于数据量不足导致的过拟合。

   对于不同的随机数种子，我们估计 loss 的方差大约为 0.02 ，这意味着，为了避免过拟合，我们需要：

   $$\begin{array}{}\text{(10)}& D\ge (5\times {10}^3)\times N^{0.74}\end{array}$$

   推导过程：$\delta L\le 0.02$$\delta L \le 0.02$ ，即可得到该方程。

   利用这种关系，小于 ${10}^9$$10^9$ 个参数的模型可以在 22B token 的 WebText2 数据集上被训练从而具有最小的过拟合，但是我们最大的模型将会遇到一些轻微的过拟合。更一般地，这种关系表明数据集大小可以关于模型大小成亚线性增长，同时避免过拟合。然而，请注意，这通常并不代表 compute-efficient training 。

   我们还应该强调，在改变数据集和模型大小时，我们没有 optimized regularization （例如，dropout rate ）。

   

43.4 关于模型大小和训练时间的 scaling laws

1. 在本节中，我们将证明一个简单的 scaling law 可以很好地描述 loss 作为模型大小 $N$$N$ 和训练时间的函数。

   • 首先，我们将解释如何使用 《An empirical model of large-batch training》 的结果来定义 universal training step $S_{min}$$S_\min$ ，这说明了我们的大多数模型尚未在最佳 batch size 下训练的事实。

   • 然后，我们将证明我们可以使用公式 $L(N,S)$$L(N,S)$ 拟合 loss 与模型大小和训练时间。

   • 稍后，我们将使用这些结果来预测模型大小和训练时间之间关于训练计算量的最佳分配，然后确认该预测。

43.4.1 临界 Batch size

1. 在 《An empirical model of large-batch training》 中提出了一个关于训练的 batch size 依赖性的简单的经验理论。该论文认为，对于 training，有一个临界 batch size $B_{\text{crit}}$$B_\text{crit}$ ：

   • 对于 $B<B_{\text{crit}}$$B\lt B_\text{crit}$ ，batch size $B$$B$ 可以增加，而 compute-efficiency 的下降非常小。

   • 而对于 $B>B_{\text{crit}}$$B \gt B_\text{crit}$ ，$B$$B$ 的增加导致收益递减。

   该论文还认为， gradient noise scale 为 $B_{\text{crit}}$$B_\text{crit}$ 提供了一个简单的预测，并且 gradient noise scale 也不直接依赖于模型大小，而是依赖于已经获得的 loss value 。这些结果可用于预测训练时间和计算量将如何随 batch size 而变化。为了尽可能有效地平衡训练时间和计算量，最好使用 batch size 为 $B\simeq B_{\text{crit}}$$B\simeq B_\text{crit}$ 进行训练。在 $B\gg B_{\text{crit}}$$B\gg B_\text{crit}$ 的训练最小化了 training steps 数量，而在 $B\ll B_{\text{crit}}$$B\ll B_\text{crit}$ 的训练最小化了计算量的使用。

   即：大的 batch size 可以节省训练时间、但是浪费了计算量；小的 batch size 可以节省计算量、但是浪费了计算时间。

   更具体地，可以证明对于各种各样的神经网络任务， 当训练到 loss $L$$L$ 的任何固定值时，training steps 数量 $S$$S$ 和 processed 数据样本数量 $E=BS$$E=BS$ 满足简单的关系：

   $$\begin{array}{}\text{(11)}& (\frac{S}{S_{min}}-1)\times (\frac{E}{E_{min}}-1)=1\end{array}$$

   其中：$S_{min}$$S_\min$ 为达到 $L$$L$ 所需的最小 training steps 数量，而 $E_{min}$$E_\min$ 是必须处理的数据样本的最小数量。

   注意：$S_{min}$$S_\min$ 并不是在 $E_{min}$$E_\min$ 处取得的，即：$E_{min}\ne B{S}_{min}$$E_\min \ne B S_\min$ ，除了在 $B=B_{\text{crit}}$$B=B_\text{crit}$ 。

   我们在下图中展示了针对 Transformer 的这种关系（即，$(\frac{S}{S_{min}}-1)\times (\frac{E}{E_{min}}-1)=1$$\left(\frac{S}{S_\min} - 1\right)\times \left(\frac{E}{E_\min} - 1\right) = 1$ ）。左图、右图分别给出了两种不同参数规模下的曲线，横轴为 $S$$S$ 、纵轴为 $E$$E$ 。每条曲线代表一个固定的 test loss 。

   

   这个关系定义了临界的 batch size ：

   $$\begin{array}{}\text{(12)}& B_{\text{crit}}(L)=\frac{E_{min}}{S_{min}}\end{array}$$

   它是目标损失值的函数。在临界 batch size 的训练可以实现大致最优的 time/compute tradeoff ，需要 $S=2S_{min}$$S=2S_\min$ 的 training steps 、以及处理 $E=2E_{min}$$E=2E_\min$ 的数据样本。

2. 在下图中，我们绘制了两个不同模型的临界 batch size 和 gradient noise scale ，作为 training loss 的函数。我们看到，$B_{\text{crit}}(L)$$B_\text{crit}(L)$ 与模型大小无关，仅取决于 loss $L$$L$ 。因此，《An empirical model of large-batch training》 的 prediction 继续适用于 Transformer 语言模型。临界 batch size 在 loss 上符合幂律：

   $$\begin{array}{}\text{(13)}& B_{\text{crit}}(L)\simeq \frac{B_{\ast }}{L^{1/{\alpha }_B}}\end{array}$$

   其中：$B_{\ast }\simeq 2\times {10}^8$$B_*\simeq 2\times 10^8$，${\alpha }_B\simeq 0.21$$\alpha_B\simeq 0.21$ 。

   为什么选择这样的拟合公式？因为随着 loss 接近其最小值 $L_{min}$$L_\min$ ，gradient noise scale 预计会发散，并且我们期望$B_{\text{crit}}$$B_\text{crit}$ 跟踪该 noise scale 。因此随着 $L$$L$ 越来越小（接近 $L_{min}$$L_\min$ ），我们希望 $B_{\text{crit}}$$B_\text{crit}$ 越来越大。即， $L\to 0$$L\rightarrow 0$ 时 $B_{\text{crit}}$$B_\text{crit}$ 趋向于正无穷。

   注意：下图中，横轴的右侧为零。

   

3. 如果我们在 $B\gg B_{\text{crit}}(L)$$B\gg B_\text{crit}(L)$ 处训练，则大小为 $N$$N$ 的模型训练到 loss $L$$L$ 所需的 training steps 数量的临界值定义为：

   $$\begin{array}{}\text{(14)}& S_{min}=\frac{S}{1+B_{\text{crit}}(L)/B},\text{min steps at }B\gg B_{\text{crit}}\end{array}$$

   推导过程：根据定义 $B_{\text{crit}}(L)=\frac{E_{min}}{S_{min}}$$B_\text{crit}(L) = \frac{E_\min}{S_\min}$ 、$E=BS$$E=BS$ ，以及拟合公式 $(\frac{S}{S_{min}}-1)\times (\frac{E}{E_{min}}-1)=1$$\left(\frac{S}{S_\min} - 1\right)\times \left(\frac{E}{E_\min} - 1\right) = 1$ ，有：

   $$\begin{array}{}\text{(15)}& \begin{array}{c}1=(\frac{S}{S_{min}}-1)\times (\frac{E}{E_{min}}-1)=(\frac{S}{S_{min}}-1)\times (\frac{BS}{B_{\text{crit}}{S}_{min}}-1)\\ =\frac{B}{B_{\text{crit}}}{\left(\frac{S}{S_{min}}\right)}^2-(1+\frac{B}{B_{\text{crit}}})\frac{S}{S_{min}}+1\\ \to S_{min}=\frac{S}{1+B_{\text{crit}}(L)/B}\end{array}\end{array}$$

   推导过程中并未要求 $B\gg B_{\text{crit}}(L)$$B\gg B_\text{crit}(L)$ ，这个约束条件从何而来？论文并未说明。读者猜测可能是由于 $(\frac{S}{S_{min}}-1)\times (\frac{E}{E_{min}}-1)=1$$\left(\frac{S}{S_\min} - 1\right)\times \left(\frac{E}{E_\min} - 1\right) = 1$ 需要满足的条件而引起的。

   该式子的物理意义：

   • 根据 $S=S_{min}\times (1+B_{\text{crit}}/B)$$S = S_\min\times (1 + B_\text{crit}/B)$，则给定 batch size $B\gg B_{\text{crit}}$$B \gg B_\text{crit}$ ，我们可以预测需要多少个 training step $S$$S$ 模型能够收敛。

   • 另一方面，任意选择一个 batch size $B\gg B_{\text{crit}}$$B \gg B_\text{crit}$ ，根据它的收敛时的 training step $S$$S$ ，我们能够统计得到 $S_{min}$$S_\min$ 。

   如果我们在 $B\ll B_{\text{crit}}(L)$$B\ll B_\text{crit}(L)$ 处训练，这也定义了用大小为 $N$$N$ 的模型训练到 loss $L$$L$ 所需的计算量的临界值：

   $$\begin{array}{}\text{(16)}& C_{min}(C)=\frac{C}{1+B/B_{\text{crit}}(L)},\text{min compute at }B\ll B_{\text{crit}}\end{array}$$

   其中：$C=6NBS$$C = 6NBS$ 估计了 batch size $B$$B$ 处的 non-embedding 计算量。

   推导过程：根据定义 $B_{\text{crit}}(L)=\frac{E_{min}}{S_{min}}$$B_\text{crit}(L) = \frac{E_\min}{S_\min}$ 、$E=BS$$E=BS$ ，以及拟合公式 $(\frac{S}{S_{min}}-1)\times (\frac{E}{E_{min}}-1)=1$$\left(\frac{S}{S_\min} - 1\right)\times \left(\frac{E}{E_\min} - 1\right) = 1$ ，有：

   $$\begin{array}{}\text{(17)}& \begin{array}{c}1=(\frac{S}{S_{min}}-1)\times (\frac{E}{E_{min}}-1)=(\frac{E/B}{E_{min}/B_{\text{crit}}}-1)\times (\frac{E}{E_{min}}-1)\\ =\frac{B_{\text{crit}}}{B}{\left(\frac{E}{E_{min}}\right)}^2-(1+\frac{B_{\text{crit}}}{B})\frac{E}{E_{min}}+1\\ \to E_{min}=\frac{E}{1+B/B_{\text{crit}}(L)}\end{array}\end{array}$$

   根据 $C=6NBS$$C=6NBS$ ，则可以得到上述公式。

   推导过程中并未要求 $B\ll B_{\text{crit}}(L)$$B\ll B_\text{crit}(L)$ ，这个约束条件从何而来？论文也未说明。读者猜测可能是由于 $(\frac{S}{S_{min}}-1)\times (\frac{E}{E_{min}}-1)=1$$\left(\frac{S}{S_\min} - 1\right)\times \left(\frac{E}{E_\min} - 1\right) = 1$ 需要满足的条件而引起的。

43.4.2 关于模型大小和计算量的性能

1. 现在，我们将使用定义的 $S_{min}$$S_\min$ 来获得在 infinite data limit 下， loss 对模型大小和训练时间的依赖性的简单且通用的拟合。对于loss，我们将使用公式 $L(N,S)$$L(N,S)$ 来拟合稳定的、Adam 优化的 training runs ，即：

   $$\begin{array}{}\text{(18)}& L(N,S_{min})={\left(\frac{N_c}{N}\right)}^{{\alpha }_N}+{\left(\frac{S_c}{S_{min}}\right)}^{{\alpha }_S}\end{array}$$

   我们纳入了 learning rate schedule 的 warmup 阶段后的所有 training steps ，并找到了拟合数据的参数：

   

2. 有了这些参数，我们获得了右图中的学习曲线的拟合。尽管拟合并不完美，但我们相信，鉴于方程 $L(N,S_{min})$$L(N,S_\min)$ 的简单性，它们是相当令人信服的。

   右图中，每条曲线对应固定模型大小条件下不同 $S_{min}$$S_\min$ 的 test loss 。

   loss 对 $S_{min}$$S_\min$ 的 power-law dependence 反映了 optimizer dynamics 和 loss landscape 的相互作用。由于拟合曲线在训练后期是最好的，此时 loss 可能近似为二次方程，power-law 应该提供关于 loss 的 Hessian 谱的信息。它的普遍性表明，Hessian eigenvalue density 大致独立于模型大小。

   

3. 数据和拟合可以以不同的、更有趣的方式可视化，如下图所示。在此，我们研究了作为模型大小的函数的 test loss ，同时固定了训练中使用的总的 non-embedding compute $C$$C$ 、或 training steps 数量 $S$$S$ 。对于拟合，我们使用方程 $C_{min}$$C_\min$、$S_{min}$$S_\min$ 、上述参数、以及方程 $L(N,S_{min})$$L(N,S_\min)$。

   左图：每条曲线给出了固定计算预算条件下 test loss 和模型大小的关系；

   右图：每条曲线给出了固定 steps 条件下 test loss 和模型大小的关系；

   

43.4.3 Early Stopping Step 的下限

1. $L(N,S_{min})$$L(N,S_\min)$ 的结果可用于导出 training step 数量的下限（粗略的估计），其中在 data limited 训练中出现了早停。它的动机是这样的思想，对于给定的模型，有限的 $D$$D$ 和无限的 $D$$D$ 对应的学习曲线将会非常相似，直到我们达到 $S_{min}\simeq S_{\text{stop}}$$S_\min\simeq S_\text{stop}$。因此，过拟合应该与简单地在 $S_{\text{stop}}$$S_\text{stop}$ 结束训练所对应的 correction 成比例。这将低估 $S_{\text{stop}}$$S_\text{stop}$，因为在现实中，当我们有一个有限的 $D$$D$ 时，test loss 将下降得更慢，因此我们将需要更多的 training steps 数量来达到在有限的 $D$$D$ 时的最佳 test loss 。这个推理方向导致了不等式：

   $$\begin{array}{}\text{(19)}& S_{\text{stop}}(N,D)\ge \frac{S_c}{{[L(N,D)-L(N,\mathrm{\infty })]}^{1/{\alpha }_S}}\end{array}$$

   其中：$L(N,\mathrm{\infty })$$L(N,\infty)$ 为用无限可用数据评估的收敛后的损失。

   分母代表过拟合的程度，其中 $L(N,\mathrm{\infty })$$L(N,\infty)$ 表示无限数据条件下的 test loss （代表没有过拟合）。过拟合程度越少，那么 $S_{\text{stop}}$$S_\text{stop}$ 越大（早停发生的时刻越晚）。

   这个公式似乎不是推导而来，而是经验公式。

   左图显示了这个不等式及其与经验数据的比较。在该图中，$S_{\text{stop}}$$S_\text{stop}$ 和 $L(N,D)$$L(N,D)$ 是经验性的（尽管 $S_{\text{stop}}$$S_\text{stop}$ 被调整以模拟 $B\gg B_{\text{crit}}$$B\gg B_\text{crit}$ 时的训练），而 $L(N,\mathrm{\infty })$$L(N,\infty)$ 是对 $L(N,D)$$L(N,D)$ 在 $D=\mathrm{\infty }$$D=\infty$ 时评估而来。

   

43.5 计算量预算的最优分配

1. 我们在 Figure 1 的右上角显示了性能的经验趋势作为训练计算量的函数。然而，这一结果涉及固定 batch size $B$$B$ 的训练，但是我们知道，事实上我们可以通过前面讨论的 batch size $B_{\text{crit}}$$B_\text{crit}$ 来更有效地训练。

   在本节中，我们将针对这一疏忽进行调整。更重要的是，我们将使用前面的结果来确定模型大小 $N$$N$ 、以及训练期间处理的数据量 $E$$E$ 之间的计算量的最优分配。使用公式 $L(N,S_{min})$$L(N,S_\min)$，我们将从经验和理论两方面来确定这种分配， 我们将证明这些方法是一致的。

   

43.5.1 最优性能和分配

1. 从公式 $C_{min}$$C_\min$ 中，让我们首先研究 loss 作为最优分配计算量 $C_{min}$$C_\min$的函数。结果如下图所示，并符合幂律曲线。我们看到，与 Figure 1 的计算量图相比，新的关于 $C_{min}$$C_\min$ 的拟合有所改善。

   橙色曲线为 $L(C)$$L(C)$ ，而蓝色曲线为 $L(C_{min})$$L(C_\min)$，可以看到蓝色曲线的拟合更好。

   Figure 1 的左图也是 $L(C_{min})$$L(C_\min)$ 。

   

2. 给定 $L(C_{min})$$L(C_\min)$ ，很自然地会要求最佳模型大小 $N(C_{min})$$N(C_\min )$ ，以便在给定数量的训练计算量的情况下提供最小的 loss 。最佳模型尺寸如下左图所示。我们观察到 $N(C_{min})$$N(C_\min)$ 可以很好地拟合幂律：

   $$\begin{array}{}\text{(20)}& N(C_{min})\propto (C_{min}{)}^{0.73}\end{array}$$

   

3. 在下图中，我们展示了次优 model size 来训练模型的效果。

   左图，次优 model size 导致更多的计算量（相对于最佳计算量）。

   右图，更大 model size 导致更少的计算时间（相对于最佳计算时间）。

   

4. 通过定义 $C_{min}=6N{B}_{\text{crit}}{S}_{min}$$C_\min = 6NB_\text{crit}S_\min$，因此我们可以使用 $N(C_{min})$$N(C_\min)$ 来提取进一步的结果。具体而言，由于之前的拟合曲线显示 $B\propto L^{-4.8}$$B\propto L^{-4.8}$ 和 $L\propto C_{min}^{-0.05}$$L\propto C_\min^{-0.05}$，我们可以得出结论： $B_{\text{crit}}\propto C_{min}^{0.24}$$B_\text{crit}\propto C_\min^{0.24}$ 。

   $0.24=(-4.8)\times (-0.05)$$0.24 = (-4.8)\times (-0.05)$ 。

   这使我们得出结论，随着计算量的增加，最佳 training steps 数量只会非常缓慢地增长，因为 $S_{min}\propto C_{min}^{0.03}$$S_\min\propto C_\min^{0.03}$ 与 Figure 14 中右图的经验结果相匹配。事实上， measured exponent 足够小，我们的结果甚至可能与指数为零相一致。

   由于 $N(C_{min})\propto (C_{min}{)}^{0.73}$$N(C_\min)\propto (C_\min)^{0.73}$ 、$B_{\text{crit}}\propto C_{min}^{0.24}$$B_\text{crit}\propto C_\min^{0.24}$，此外根据 $C_{min}=6N{B}_{\text{crit}}{S}_{min}$$C_\min = 6NB_\text{crit}S_\min$，则 $S_{min}\propto C_{min}^{0.03}$$S_\min\propto C_\min^{0.03}$ ，其中 $0.03=1-0.73-0.24$$0.03 = 1-0.73-0.24$ 。

   因此，我们的结论是：当我们以最佳计算量分配来 scale up 语言模型时，我们应该主要增加模型大小 $N$$N$ ，同时 scale up batch size 为 $B\propto B_{\text{crit}}$$B\propto B_\text{crit}$，而 serial steps 数量增加可以忽略不计。由于 compute-efficient training 使用相对较少的 optimization steps ，因此可能需要进行额外的工作来加速早期的 training dynamics 。

43.5.2 $L(N,S_{min})$$L (N, S_\min)$ 的预测

1. $L(C_{min})$$L(C_\min)$ 和 allocation 的结果可以从方程 $L(N,S_{min})$$L(N,S_\min)$ 中预测出来。给定我们的 $L(N,S_{min})$$L(N,S_\min)$ 方程，我们可以用 $S_{min}=\frac{C_{min}}{6NB}$$S_\min = \frac{C_\min}{6NB}$ 来代替，然后找到最小的 loss 作为 $N$$N$ 的函数，同时固定训练计算量。

   对于 loss 作为训练计算量的函数，我们预测：

   $$\begin{array}{}\text{(21)}& L(C_{min})\propto {\left(\frac{C_c^{min}}{C_{min}}\right)}^{{\alpha }_C^{min}}\end{array}$$

   其中：

   $$\begin{array}{}\text{(22)}& {\alpha }_C^{min}=\frac{1}{1/{\alpha }_S+1/{\alpha }_B+1/{\alpha }_N}\simeq 0.054\end{array}$$

   与下图中的指数非常一致。

   下图中的指数是 -0.050 ，而这里的指数是 -0.054，存在一定的 gap 。因为它们是用不同的公式来预测的。

   

   我们还预测到：

   $$\begin{array}{}\text{(23)}& N(C_{min})\propto (C_{min}{)}^{{\alpha }_C^{min}/{\alpha }_N}\simeq (C_{min}{)}^{0.71}\end{array}$$

   这也和下图中的 scaling 相匹配，在几个百分点之内。

   前面已经得到 $N(C_{min})\propto (C_{min}{)}^{0.73}$$N(C_\min)\propto (C_\min)^{0.73}$ ，但是这里得到的是 $N(C_{min})\propto (C_{min}{)}^{0.71}$$N(C_\min)\propto (C_\min)^{0.71}$，存在一定的 gap 。因为它们是用不同的公式来预测的。

   我们的 scaling laws 为语言建模的性能提供了一个预测性的框架。

   

43.5.3 矛盾和猜想

1. 我们观察到，在计算量、数据量或模型大小的大数值下，没有偏离直接的 power-law 趋势的迹象。不过，我们的趋势最终必须趋于平稳，因为自然语言具有非零的熵（即，test loss 不可能降低到零）。

   事实上，本节中描述的 compute-efficient training 的趋势已经包含了一个明显的矛盾。在比这里记录的规模高几个数量级的时候， $L(C_{min})$$L(C_\min)$ scaling law 所预测的性能会下降到低于应该有的水平。这意味着我们的 scaling laws 必须在这一点之前崩溃，但是我们猜测这个交点有更深的含义：它提供了 Transformer 语言模型达到最大性能的一个估计值。

   由于 compute-efficient training 所使用的数据量随着计算预算的增加而缓慢增长，$L(C_{min})$$L(C_\min)$ 预测的性能最终会达到 $L(D)$$L(D)$ 幂律设定的下限（如下图所示）。让我们更详细地研究一下这个问题。

   

2. 为了控制过拟合，前面的结果意味着我们应该将数据集的规模扩大为：

   $$\begin{array}{}\text{(24)}& D\propto N^{0.74}\propto C_{min}^{0.54}\end{array}$$

   其中，我们使用了 Figure 14 中的 compute-efficient $N(C_{min})$$N(C_\min)$ 。

   让我们将其与 compute-efficient training 的数据要求进行比较。如果我们以临界 batch size （即 $C=2C_{min}$$C=2C_\min$）进行训练，并且在训练过程中不重复使用数据，我们会发现数据用量随着计算量的增长而增长，即：

   $$\begin{array}{}\text{(25)}& D(C_{min})=\frac{2C_{min}}{6N(C_{min})}\simeq (4\times {10}^{10}\text{ tokens})\times (C_{min}/\text{PF-Day}{)}^{0.26}\end{array}$$

   这是数据集大小能够随着计算量而有效增长的最大速度，因为它意味着我们只训练一个 epoch 。但它比方程 $D\propto N^{0.74}\propto C_{min}^{0.54}$$D\propto N^{0.74} \propto C_\min^{0.54}$ 中的数据集增长得更慢。这似乎意味着，compute-efficient training 最终会遇到过拟合的问题，即使训练过程中从未重复使用任何数据。

   根据 Figure 1 ，我们期望当我们受到数据集大小的瓶颈时（即过拟合），loss 的 scale 应该是 $L(D)\propto D^{-0.095}$$L(D)\propto D^{-0.095}$。这意味着，loss 将随着计算量的进行而 scale 为 $L(D(C_{min}))\propto C_{min}^{-0.03}$$L(D(C_\min))\propto C_\min^{-0.03}$，一旦我们受到数据限制。再一次，我们有一个矛盾，因为这将最终与我们在 Figure 13 中对 $L(C_{min})$$L(C_\min)$ 的预测相交，其中我们发现 scaling $L(C_{min})\propto C_{min}^{-0.050}$$L(C_\min)\propto C_\min^{-0.050}$ 。

   $L(D(C_{min}))$$L(D(C_\min))$ 和 $L(C_{min})$$L(C_\min)$ 的交叉点发生在：

   $$\begin{array}{}\text{(26)}& C^{\ast }\sim {10}^4\text{ PF-Days},N^{\ast }\sim {10}^{12}\text{ parameters },D^{\ast }\sim {10}^{12}\text{ tokens },L^{\ast }\sim 1.7\text{ nats/token}\end{array}$$

   尽管数值是非常不确定的，在任何一个方向都会有一个数量级的变化，这取决于 power-law 拟合的指数的精确值。最明显的解释是，我们的 scaling law 在达到这一点时或之前就已经崩溃了，而这一点在计算量和模型大小上都还有很多数量级。

3. 人们也可以猜想，这个交叉点有更深的含义。在相同数据要求的条件下，如果我们没有将模型规模增加到 $N^{\ast }$$N^*$ 以上，也许这意味着一旦我们达到 $C_{min}\ast$$C_\min*$ 和 $N^{\ast }$$N^*$ ，我们就已经提取了自然语言数据中所有的可靠信息。在这种解释中，$L^{\ast }$$L^*$ 将为自然语言 entropy-per-token 提供一个粗略的估计。在这种情况下，我们期望 loss 的趋势在 $L^{\ast }$$L^*$ 或之前趋于平稳。

   我们可以通过考虑添加了噪音的训练数据集的版本来猜测平缓之后的 $L(C_{min})$$L(C_\min)$ 的函数形式。例如，我们可以在展示给模型的每个上下文中附加一串随机的 tokens ，从而人为地用一个恒定的 additive factor 来提高损失。然后，与 noise floor 的距离 $L-L_{\text{noise}}$$L-L_\text{noise}$ 将是一个更有意义的性能指标，即使这个距离的小幅下降也可能代表定性的性能的显著提升。由于人工噪声会对我们所有的趋势产生同样的影响， $C^{\ast },N^{\ast },D^{\ast },L^{\ast }$$C^*,N^*,D^*,L^*$ 等临界点将不会改变（除了 $L^{\ast }$$L^*$ 的绝对值），即使它发生在平缓之后也可能是有意义的。

43.6 结论

43.6.1 总结

1. 我们 Transformer 语言模型的主要发现如下：

   • 模型性能强烈依赖于模型规模，弱依赖于 model shape ： 模型的性能最强烈地依赖于模型规模，它包括三个因素：模型参数的数量 $N$$N$（不包括 embedding 参数）、数据集的大小 $D$$D$ 、以及用于训练的计算量 $C$$C$。在合理的范围内，性能对其他架构超参数的依赖非常弱，如模型的 dpeth 与 width。

     注意，这里的模型性能是在测试集上评估的。

   • 平滑的幂率（smooth power laws）：模型性能与三个 scale factor $N,D,C$$N, D, C$ 中的每一个都有幂律关系，其趋势跨越六个数量级以上（如下图所示），当其它两个因素不是瓶颈时。我们观察到在 N/D/C 非常大时，并没有偏离这些趋势的迹象，尽管在达到 zero loss 之前，模型性能最终必须趋于平缓。

     

   • 过拟合的普遍性： 只要我们同步 scale up $N$$N$ 和 $D$$D$ ，性能就会有可预测的提高；但如果 $N$$N$ 或 $D$$D$ 保持固定而另一个增加，就会进入一个收益递减的区域。性能惩罚（performance penalty ）可预测地取决于 $N^{0.74}/D$$N^{0.74}/D$ 的比率，这意味着每次我们将模型规模增加 8 倍，我们只需要增加大约 5 倍的数据就可以避免惩罚。

   • training 的普遍性： 训练曲线（training curve）遵循可预测的幂律，其中训练曲线大致上与模型大小无关。通过推断训练曲线的早期部分，我们可以大致预测如果我们训练的时间更长，将会取得什么样的 loss。

   • transfer 提高测试性能：当我们在与训练时分布不同的文本上评估模型时，评估结果与验证集上的结果密切相关， loss 的偏移量大致不变。换句话说，迁移到一个不同的分布上会产生一个恒定的惩罚，但其他方面的改善与训练集上的表现大致一致。

   • 样本效率（sample efficiency）：大模型比小模型更具有样本效率，以更少的 optimization step （Figure 2 左图）和更少的数据点（Figure 4 左图）达到相同的性能水平。

     此外，Figure 19 提供了另一种观察这一现象的方法，它显示了不同模型达到各种固定 loss 的时间。

     

     

     

   • 收敛是低效的： 当在固定的计算预算 $C$$C$ 内工作，但对模型大小 $N$$N$ 或可用数据量 $D$$D$ 没有任何其他限制时，我们通过训练非常大的模型并在收敛之前明显地停止，从而达到最佳性能（Figure 3 ）。因此，与人们的预期相反，相比于训练小模型并收敛，这种方式得到的最佳 compute-efficient training 要更加 sample efficient 。随着训练计算量的增加，数据需求增长非常缓慢：$D\sim C^{0.27}$$D\sim C^{0.27}$ 。

     

   • 最优的 batch size：训练这些模型的最优的 batch size 大约仅仅是 loss 的幂次，并通过测量 gradient noise scale 来确定。对于我们可以训练的最大的模型，在收敛时大约是 1M ~ 2M 个 tokens 。

   综合来看，这些结果表明，当我们适当地 scale up 模型规模、数据规模、以及计算量时，language modeling 的性能会平稳地、可预测地提高。我们预计，更大的语言模型将比目前的模型表现得更好、更加 sample efficient 。

43.6.2 Scaling Laws 摘要

1. 当性能仅仅受 non-embedding parameters 数量 $N$$N$、数据集大小 $D$$D$ 、以及 optimally allocated 计算预算 $C_{min}$$C_\min$ 的限制时，可以用幂律来预测一个自回归语言模型训练的 Transformer 的 loss （如 Figure 1）：

   • 对于参数数量 $N$$N$ 受到限制的模型，在足够大的数据集上训练到收敛（即，$N$$N$ 的变化对于 $L$$L$ 的影响）：

     $$\begin{array}{}\text{(27)}& L(N)=(N_c/N{)}^{{\alpha }_N};{\alpha }_N\sim 0.076,N_c\sim 8.8\times {10}^{13}(\text{non-embedding parameters})\end{array}$$

   • 对于大型模型（即，$N$$N$ 足够大），在数据规模 $D$$D$ 受到限制的数据集上训练且早停（即，$D$$D$ 的变化对于 $L$$L$ 的影响）：

     $$\begin{array}{}\text{(28)}& L(D)=(D_c/D{)}^{{\alpha }_D};{\alpha }_D\sim 0.095,D_c\sim 5.4\times {10}^{13}(\text{tokens})\end{array}$$

   • 对于最佳规模的模型（即，$N$$N$ 足够大）、足够大的数据集（即，$D$$D$ 足够大）、足够小的 batch size（对计算量的最佳使用），在计算量 $C_{min}$$C_\min$ 受到限制的条件下进行训练：

     $$\begin{array}{}\text{(29)}& L(C_{min})=(C_c^{min}/C_{min}{)}^{{\alpha }_C^{min}};{\alpha }_C^{min}\sim 0.050,C_c^{min}\sim 3.1\times {10}^8(\text{PF-days})\end{array}$$

   这些关系在 $C_{min}$$C_\min$ 的 8 个数量级、$N$$N$ 的 6 个数量级、以及 $D$$D$ 的 2 个数量级上都成立。它们非常弱地依赖于 model shape 和其他的 Transformer 超参数（ depth 、 width 、自注意头的数量），具体数值与 Webtext2 训练集相关。

2. 幂率 ${\alpha }_N,{\alpha }_D,{\alpha }_C^{min}$$\alpha_N,\alpha_D,\alpha_C^\min$ 规定了当我们扩大 $N$$N$、$D$$D$ 或 $C_{min}$$C_\min$ 的规模时预期的性能改善程度。例如，参数数量 $N$$N$ 增加一倍（即 $N\to 2N$$N\rightarrow 2N$），产生的 loss 要更小，其中大约是原始 loss 的 $2^{-{\alpha }_N}=0.95$$2^{-\alpha_N }= 0.95$ 倍。 $N_c,C_c^{min},D_c$$N_c, C_c^\min,D_c$ 的精确数值取决于 vocabulary size 和 tokenization，因此没有基本的含义（fundamental meaning ）。

3. critical batch size 决定了数据并行的 speed/efficiency tradeoff，也大致服从 $L$$L$ 的幂率：

   $$\begin{array}{}\text{(30)}& B_{\text{crit}}(L)=\frac{B_{\ast }}{L^{1/{\alpha }_B}},B_{\ast }\sim 2\times {10}^8\text{ tokens},{\alpha }_B\sim 0.21\end{array}$$

4. 公式 $L(N)$$L(N)$ 和 $L(D)$$L(D)$ 共同表明，当我们增加模型大小时，我们应该根据 $D\propto N^{{\alpha }_N/{\alpha }_D}=N^{0.74}$$D\propto N^{\alpha_N/\alpha_D}= N^{0.74}$ 线性地增加数据集大小。事实上，我们发现有一个结合了 $L(N)$$L(N)$ 和 $L(D)$$L(D)$ 的单个方程，支配着对 $N$$N$ 和 $D$$D$ 的同时依赖，并支配着过拟合的程度：

   $$\begin{array}{}\text{(31)}& L(N,D)={[{\left(\frac{N_c}{N}\right)}^{{\alpha }_N/{\alpha }_D}+\frac{D_c}{D}]}^{{\alpha }_D}\end{array}$$

   这个方程与 Figure 4 的左图相配合。我们猜想，这种函数形式也可以为其他 generative modeling task 来参数化 trained log-likelihood 。

5. 当在 infinite data limit 中对一个给定的模型进行有限的 parameter update steps $S$$S$ 的训练时，在一个初始的短时间之后，学习曲线可以被准确地拟合（见 Figure 4 的右边）：

   $$\begin{array}{}\text{(32)}& L(N,S)={\left(\frac{N_c}{N}\right)}^{{\alpha }_N}+{\left(\frac{S_c}{S_{min}}\right)}^{{\alpha }_S}\end{array}$$

   其中：$S_c\simeq 2.1\times {10}^3$$S_c\simeq 2.1\times 10^3$，${\alpha }_S\simeq 0.76$$\alpha_S\simeq 0.76$ ，$S_{min}$$S_\min$ 是使用方程 $S_{min}=\frac{S}{1+B_{\text{crit}}(L)/B}$$S_\min = \frac{S}{1 + B_\text{crit}(L)/B}$ 估计的最小可能的 optimization steps （即参数更新次数）的数量，$B$$B$ 为 batch size 。

6. 当在固定的计算预算 $C$$C$ 内进行训练，但没有其他限制时，方程 $L(N,S)$$L(N,S)$ 导致预测最佳模型大小 $N$$N$、最佳 batch size $B$$B$、最佳 step 数 $S$$S$ 、以及数据集大小 $D$$D$ 应增长为：

   $$\begin{array}{}\text{(33)}& \begin{array}{c}N\propto C^{{\alpha }_C^{min}/{\alpha }_N},B\propto C^{{\alpha }_C^{min}/{\alpha }_B},S\propto C^{{\alpha }_C^{min}/{\alpha }_S},D=B\times S\\ {\alpha }_C^{min}=\frac{1}{1/{\alpha }_S+1/{\alpha }_B+1/{\alpha }_N}\end{array}\end{array}$$

   这与经验结果（$N\propto C_{min}^{0.73},B\propto C_{min}^{0.24},S\propto C_{min}^{0.03}$$N\propto C_\min^{0.73},\;B\propto C_\min^{0.24},\;S\propto C_\min^{0.03}$）比较接近。

7. 随着计算预算 $C$$C$ 的增加，计算预算应该主要用在更大的模型上，而不应在训练时间或数据集大小上有急剧增加（如 Figure 3 ）。这也意味着，随着模型的增大，它们的 sample efficient 也越来越高。在实践中，研究人员通常训练较小的模型（由于硬件的限制），较小模型的训练时间要更长（相比较于最大化计算效率的模型，即更大的模型）。最佳性能取决于总计算量的幂律（参考方程 $L(C_{min})$$L(C_\min)$）。

8. 我们为方程 $L(N,D)$$L(N,D)$ 提供了一些基本的理论动机，对 learning curve fit 及其对训练时间的影响进行了分析，并对我们每个 token 的结果进行了细分。我们还对LSTM 和 recurrent Transformer 做了一些简单的比较。

9. 公式总结：

   

   这些趋势的经验拟合参数为：

   

   compute efficient training 的最优参数为：

   

43.6.2 注意事项

1. 在这一节中，我们列出了一些对我们的分析可能存在的注意事项：

   • 目前，我们对我们提出的任何一个 scaling laws 都没有一个坚实的理论理解。与模型大小和计算量的 scaling 关系尤其神秘。通过用一个 noisy 的二次方来建模 loss ，在模型大小固定的情况下，也许有可能理解在非常大的 $D$$D$ 下的 scaling 关系，以及在训练后期的学习曲线的形状。但是在非常大的模型大小下，与 $D$$D$ 的 scaling 关系仍然是神秘的。如果没有一个理论、或者对我们的 scaling laws 的修正有一个系统的理解，就很难确定在什么情况下它们可以被信任。

   • 我们对远在我们所探索的范围之外的 loss 的 $B_{\text{crit}}(L)$$B_\text{crit}(L)$ 的预测不是特别有信心。$B_{\text{crit}}$$B_\text{crit}$ 的变化可能会对数据并行性、以及所需的 serial training steps数量之间的权衡产生重大影响，这将对训练时间产生重大影响。 

   • 我们没有彻底研究小数据的区域，对于最小的 $D$$D$ 值（一个 epoch 只有 40 个 step ），我们对 $L(N,D)$$L(N,D)$ 的拟合很差。此外，我们没有对正则化和数据增强进行试验。这些方面的改进可能会在数量上或质量上改变我们的结果。

   • 我们使用了估计的训练计算量 $C\simeq 6NBS$$C\simeq 6NBS$，它不包括与 $n_{\text{ctx}}$$n_\text{ctx}$ 成比例的贡献。因此，在非常大的 $n_{\text{ctx}}$$n_\text{ctx}$ 的系统中，特别是在 $n_{\text{ctx}}\ge 12d_{\text{model}}$$n_\text{ctx}\ge 12 d_\text{model}$ 的情况下，我们的计算量的 scaling 可能不太准确。 

   • 我们调优了学习率，并且采用了 learning rate schedule 进行实验。但是我们可能忽略了调优一些对 scaling 有重要影响的超参数（如 intialization scale 或动量）。

   • 学习率的最佳选择对 target loss 是敏感的。当训练接近收敛时，可能需要使用较小的学习率来避免发散。但是当进行 short training run 时（例如由于计算限制），可能会使用较大的学习率。对于没有进行收敛的 training runs， 我们没有进行更高学习率的实验。

四十四、Chinchilla[2022]

《Training Compute-Optimal Large Language Models》

1. 最近，一系列大型语言模型（Large Language Model: LLM ）被引入，目前最大的稠密语言模型拥有超过 500B 参数。这些大型自回归 transformer 模型在许多任务上使用各种评估协议（如 zero-shot 、few-shot 和 fine-tuning ），都表现出令人印象深刻的性能。

   训练大型语言模型的计算成本和能源成本很高，并随着模型规模的增加而上升。在实践中，分配的 training compute budget 通常是事先知道的：有多少个 accelerators 可用，以及用多久。由于这些大型模型通常只训练一次，因此准确估计给定 computational budget 条件下的最佳模型超参数至关重要（《Scale efficiently: Insights from pre-training and fine-tuning transformers》）。

   《Scaling laws for neural language models》 表明：自回归语言模型的参数数量与它的性能之间存在幂律（power law）关系。因此，该领域一直在训练越来越大的模型，并预期带来性能的提高。《Scaling laws for neural language models》 的一个值得注意的结论是：大型模型不应该被训练到其最低的损失（test loss ），以达到 compute optimal 。虽然我们得出了同样的结论，但我们估计大型模型的训练应该比作者建议的多得多的 training tokens 。具体来说，在 computational budget 增加十倍的情况下，他们建议模型的大小应该增加 5.5 倍，而 training tokens 的数量只应该增加 1.8 倍。相反，我们发现模型的大小和 training tokens 的数量应该以相等的比例进行 scale 。

   《Scaling laws for neural language models》 的结论：

   $$\begin{array}{}\text{(34)}& N\propto C_{min}^{0.73},B\propto C_{min}^{0.24},S\propto C_{min}^{0.03}\end{array}$$

   当计算预算增加十倍时，模型大小需要增加 ${10}^{0.73}=5.37$$10^{0.73} = 5.37$ 倍；training tokens 数量为 $E=B\times S$$E=B\times S$ ，需要增加 ${10}^{0.27}=1.86$$10^{0.27} = 1.86$ 倍。

   遵循 《Scaling laws for neural language models》 和 GPT-3 的训练设置，最近训练的许多大型模型已经训练了大约 300B token （如下表所示），这与增加计算量时主要增加模型规模的做法是一致的。

   

   在这项工作中，我们重新审视了这个问题： 在固定的 FLOPs 预算下，应该如何权衡模型大小和 training tokens 数量？为了回答这个问题，我们将最终的预训练损失 $L(N,D)$$L(N,D)$ 作为模型参数数量 $N$$N$ 和 training tokens 数量 $D$$D$ 的函数。由于 computational budget $C$$C$ 是模型参数数量 $N$$N$ 和 seen training tokens 数量 $D$$D$ 的确定性函数 $\text{FLOPs}(N,D)$$\text{FLOPs}(N, D)$，我们感兴趣的是在 $\text{FLOPs}(N,D)=C$$\text{FLOPs}(N, D) = C$ 的约束条件下最小化 $L$$L$ ：

   $$\begin{array}{}\text{(35)}& N_{\text{opt}}(C),D_{\text{opt}}(C)=\arg \underset{N,Ds.t.\text{FLOPs}(N,D)=C}{min}L(N,D)\end{array}$$

   其中：$N_{\text{opt}}(C),D_{\text{opt}}(C)$$N_\text{opt}(C), D_\text{opt}(C)$ 描述了 computational budget $C$$C$ 的最佳分配。

   注意：这里的 $D$$D$ 指的是 training tokens 数量，这跟 《Scaling Laws for Neural Language Models》 中的符号不同。在 《Scaling Laws for Neural Language Models》 中，$D$$D$ 表示训练集的 tokens 数量，$E=B\times S$$E=B\times S$ 才是 training tokens 数量。

   这里的 $L$$L$ 指的是 test loss 。

   我们根据 400多个模型的 loss 来经验性地估计这些函数，这些模型的参数规模从低于 70M 到超过 16B ，并在从 5B 到超过 400B 个 token 上进行训练，每个模型配置都在几个不同的 training horizons 进行训练。我们的方法导致了与 《Scaling laws for neural language models》 的结果大不相同。我们在下图中强调了我们的结果，并在后面章节中强调了我们的方法有什么不同。

   

   基于我们估计的 compute-optimal 边界，我们预测，对于用于训练 Gopher 的 compute budget ，最优模型应该小 4 倍，同时在 4 倍的 tokens 上进行训练。我们通过在 1.4T tokens 上训练一个更加 compute-optimal 的 70B 模型，称为 Chinchilla ，来验证这一点。Chinchilla 不仅比其更大的同类模型 Gopher 表现出色，而且其减少的模型尺寸大大降低了推理成本，并大大促进了下游在更小硬件上的使用。大型语言模型的能源成本通过 inference和微调的使用而摊销。因此，一个经过优化训练的小型模型，其好处要超过改善模型性能的直接好处。

2. 相关工作：

   • 大型语言模型：在过去的几年里，各种大型语言模型已经被引入。这些模型包括 dense transformer models 、以及 mixture-of-expert (MoE) models 。最大的 dense transformers 已经超过 500B 参数（《Using Deepspeed and Megatron to Train Megatron-turing NLG 530b, A Large-Scale Generative Language Model》）。

     训练越来越大的模型的动力是很明显的：到目前为止，增加语言模型的规模已经在许多语言建模任务中提高了 SOTA 。然而，大型语言模型面临着一些挑战，包括它们巨大的计算需求（training 和 inference 的成本随着模型的大小而增加），以及需要获得更多的高质量训练数据。事实上，在这项工作中，我们发现更大的、高质量的数据集将在语言模型的任何 further scaling 中发挥关键作用。

   • 对 scaling 行为进行建模：了解语言模型的 scaling 行为及其迁移特性（transfer property）在最近的大型模型的发展中一直很重要。

     《Scaling laws for neural language models》 首次展示了模型大小与 loss 之间在许多数量级上的 predictable relationship 。作者研究了在给定的计算预算（compute budget ）下选择最佳的模型大小来训练的问题。与我们类似，他们通过训练各种模型来解决这个问题。我们的工作在几个重要方面与《Scaling laws for neural language models》 不同：

     • 首先，作者对所有的模型都使用了固定的 training tokens 数量和学习率调度；这使得他们无法建模这些超参数对 loss 的影响。相比之下，我们发现，无论模型大小如何，将学习率调度设置为与 training tokens 数量大致匹配的结果是最好的 final loss ，如下图所示。

       《Scaling Laws for Neural Language Models》 论文中并未固定 training tokens 数量，所以这里的结论是从何而来？

       上面三个子图：training steps = 8M ；下面三个子图：training steps = 12.5M 。每条曲线分别代表余弦学习率的周期长度为 training steps 数量 $k$$k$ 倍，$k=1/1.1/1.25/1.5/2.0/5.0$$k=1/1.1/1.25/1.5/2.0/5.0$ 。

       对于一个固定的 learning rate cosine schedule，从训练刚开始到 130B tokens ，中间的 loss estimates （对于 $D^{\prime }\ll 130B$$D^\prime \ll 130 B$）高估了用与 $D^{\prime }$$D^\prime$ 相匹配的 schedule length 所训练的模型的 loss 。使用这些中间的 loss 的结果是，低估了在少于130B tokens 的数据上训练模型的有效性，并最终促成了这样的结论：随着计算预算的增加，模型规模的增加应该快于训练数据规模。相反，我们的分析的预测表明，这两个数量应该以大致相同的速度 scale 。

       给定一个 training tokens 数量，由于学习率调度的 non-optimal 选择，导致了训练得到的 training loss 要比最优的 training loss 更高。

       注意，这里是 training loss，而 《Scaling Laws for Neural Language Models》 中的指标是 test loss 。

       

     • 其次，我们包括参数高达 16B 的模型，因为我们观察到 FLOP-loss 边界有轻微的曲率。这意味着来自非常小的模型的预测与来自较大模型的预测不同。事实上，我们分析中使用的大多数模型都有超过 500M 个参数。相比之下，《Scaling laws for neural language models》 的大多数 runs 都要小得多，许多模型的参数不到 100M 。

       不同颜色的 training loss 曲线代表了不同大小的模型。

       在下图中，我们显示了使用第一批三个frontier-points 、中间三个frontier-points 、以及最后三个frontier-points 的线性拟合（橙色虚线、绿色虚线、蓝色虚线）。在这项工作中，我们没有考虑到这一点，我们把它作为有趣的未来工作，因为它表明，对于大的 FLOPs 预算，甚至更小的模型也可能是最佳的。

       

     最近，《Unified scaling laws for routed language models》 专门研究了 Mixture of Expert 语言模型的 scaling 特性，表明随着模型规模的增加，expert 数量的 scaling 会减弱。他们的方法将 loss 作为两个变量的函数：模型规模、专家数量。然而，与《Scaling laws for neural language models》 一样，该分析是在固定数量的 training tokens 下进行的，有可能低估了 branching 的改进。

   • 为大型模型而估计超参数：在选择语言模型，并且选择训练模型的程序时，模型大小和 training tokens 数量并不是唯一需要选择的两个超参数。其他重要的超参数包括学习率、学习率调度、batch size 、优化器、宽深比（width-to-depth ratio ）。在这项工作中，我们专注于模型大小和 training steps 数量，我们依靠现有的工作、以及所提供的实验启发式方法来确定其他必要的超参数。

     • 《Tuning large neural networks via zero-shot hyperparameter transfer》研究了如何选择这些超参数来训练自回归变 transformer ，包括学习率和 batch size。

     • 《An empirical model of large-batch training》 发现最佳 batch size 和模型大小之间只有微弱的依赖性。

     • 《Measuring the effects of data parallelism on neural network training》 提出，使用比我们使用的更大的 batch size 是可能的。

     • 《The depth-to-width interplay in self-attention》研究了各种 standard model size 的最佳 depth-to-width ratio 。我们使用比所提议的深度稍小的模型，因为这可以在我们的硬件上转化为更好的 wall-clock performance 。

   • 改进的模型架构：最近，人们提出了各种有前途的替代传统 dense transformer 的方法。例如，通过使用条件计算， 大型 MoE 模型 （如 1.7T 参数的 Switch transformer 、1.2T 参数的 GLaM 模型，以及其他模型）能够提供较大的有效 model size ，但是使用相对较少的 training FLOPs 和 inference FLOPs 。然而，对于非常大的模型，routed model 的计算优势似乎在减少（《Unified scaling laws for routed language models》）。

     改进语言模型的一个正交方法是用明确的检索机制来 augment transformer 。这种方法有效地增加了训练期间看到的 tokens 数量（在 《Improving language models by retrieving from trillions of tokens》 中增加了 10 倍）。这表明，语言模型的性能可能比以前认为的更加依赖于训练数据的大小。

44.1 方法

1. 我们提出三种不同的方法来回答问题： 在固定的 FLOPs 预算下，应该如何权衡模型大小和 training tokens 数量？在所有三种情况下，我们首先训练一系列模型，改变模型大小和 training tokens 数量，并使用所得的训练曲线来拟合一个empirical estimator ，该 empirical estimator 关于应该如何 scale 。我们假设计算量和模型大小之间存在幂律关系，正如《Unified scaling laws for routed language models》、《Scaling laws for neural language models》 所做的那样，尽管未来的工作可能希望针对大的模型规模在这种关系中包括潜在曲率（potential curvature）。

   所有三种方法的预测结果都是相似的，并且表明参数数量和 training tokens 数量应该随着计算量的增加而同样增加，这个比例如下表所示（括号里的值分别是 10% 分位、90% 分位的统计结果）。这与以前关于这个主题的工作形成了显著的对比，值得进一步研究。

   注意，《Scaling laws for neural language models》 研究的是 test loss，而这里研究的是 training loss 。

   

44.1.1 方法一：固定模型规模并改变 training tokens 数量

1. 在我们的第一种方法中，我们针对一系列的固定规模的模型（模型参数从 70M 到 10B ）改变训练步数，为每个模型训练 4 个不同数量的 training sequences （即，training seen examples 数量）。从这些 runs 中，我们能够直接提取在定数量的 training FLOPs 下实现的最小 loss 的估计。

   四个不同数量的 training sequences 是如何实现的？如果是非常大的数据集，那么很可能最长的 training steps 都没能过遍历一个 epoch，此时，每个样本仅被训练一次；如果是较小的数据，那么很可能最短的 training steps 都遍历了多个 epoch，此时每个样本被训练多次。

   论文并未说明预训练的 datasets 是如何构建的。

2. 我们对最小的模型使用最大的学习率为 $2\times {10}^{-4}$$2\times 10^{-4}$，对最大的模型使用最大的学习率为 $1.25\times {10}^{-4}$$1.25\times 10^{-4}$。在所有情况下，使用余弦学习率调度，学习率在训练结束时相比初始学习率下降了 10 倍。我们假设余弦周期的长度应该与训练步数大致匹配。我们发现，当余弦周期长度超出训练步数 25% 以上时，性能会明显下降，如下图所示。 我们使用窗长为 10 步的高斯平滑来平滑训练曲线。

   

3. 对于每个参数数量 $𝑁$$𝑁$ ，我们训练 4 个不同的模型（因此一共训练了 $4N$$4N$ 个模型），在一个范围为 16x 的 horizon （以 training tokens 数量来衡量）上将学习率衰减 10 倍。然后，对于每次 run ，我们平滑并插值训练损失曲线。由此，我们得到一个从 FLOP 数量到 training loss 的连续映射（如下左图所示）。然后：

   • 对于每个 FLOP 数量，我们确定哪个 runs 的 loss 最低（左图的灰色边界线）。

     是否存在这样的可能性：对于给定的 FLOP数量，有多个配置都能达到最低的 training loss ？即，是否存在 $N_1,D_1$$N_1,D_1$ 和 $N_2,D_2$$N_2,D_2$ ，使得 $C=\text{FLOPs}(N_1,D_1)=\text{FLOPs}(N_2,D_2)$$C=\text{FLOPs}(N_1,D_1) =\text{FLOPs}(N_2,D_2)$ 且它们都位于灰色边界线上？

   • 使用这些插值，我们得到了从任何 FLOP 数量 $𝐶$$𝐶$ 到 most efficient choice 的模型大小 $𝑁$$𝑁$ 和 training tokens 数量 $𝐷$$𝐷$ 的映射（参考中间的图、右侧的图），从而使得 $\text{FLOPs}(N,D)=C$$\text{FLOPs}(N,D) = C$。

   在 1500 个对数间隔的FLOP 值中，我们找到哪个模型大小能实现所有模型的最低 loss ，以及所需的 training tokens 数量。最后，我们拟合幂律来估计任何给定计算量的最佳模型大小和 training tokens 数量，得到一个关系 $N_{\text{opt}}\propto C^a$$N_\text{opt}\propto C^a$和 $D_{\text{opt}}\propto C^b$$D_\text{opt}\propto C^b$。我们发现 $a=0.50,b=0.50$$a=0.50, b=0.50$，如 Table 2 所总结的。

   在后续章节中，我们展示了在 ${10}^{21}$$10^{21}$ FLOPs 下的一对一比较，分别使用我们的分析所得到的模型规模、以及来自《Scaling laws for neural language models》 的分析所得到的模型规模，使用我们预测的模型大小具有明显的优势。

   注意中间的图、右图中绿色直线给出了 Chinchilla 的参数规模（67B）、FLOPs （$5.76\times {10}^{23}$$5.76\times 10^{23}$）、以及 Training Tokens（1.5T ）。

   

44.1.2 方法二：IsoFLOP profiles

1. 在我们的第二个方法中，我们选择九种固定的 FLOP 数量（从 $6\times {10}^{18}$$6\times 10^{18}$ 到 $3\times {10}^{21}$$3\times 10^{21}$ FLOPs ），然后改变模型规模，然后考虑每种配置的 final training loss 。方法一需要沿着整个 training runs 考虑数据点 (N, D, L) 。与方法一相反，方法二允许我们直接回答问题：对于给定的 FLOPs 预算，最佳的参数规模是多少？

   方法二中，对应于给定 FLOPs 数量的曲线中，Training Loss 最小的点，横坐标就是最佳参数规模。

2. 对于每个 FLOP 预算，我们在下图（左图）中绘制了 final loss （平滑之后）与参数规模的对比。在所有情况下，我们确保我们已经训练了足够多样化的 model size ，以便在 loss 中看到一个明显的最小值。我们对每条 IsoFLOPs 曲线拟合一条抛物线，以直接估计在何种模型规模下达到最小 loss 。

   与方法一相同，我们随后在 FLOPs 和 loss-optimal 的模型规模和 training tokens 数量之间拟合一个幂律，如下图的中间、右侧所示。再次，我们拟合指数函数的形式为 $N_{\text{opt}}\propto C^a$$N_\text{opt}\propto C^a$和 $D_{\text{opt}}\propto C^b$$D_\text{opt}\propto C^b$，并且发现 $a=0.50,b=0.50$$a=0.50, b=0.50$，正如 Table 2 所总结的。

   

44.1.3 方法三：拟合损失函数

1. 最后，我们将方法一和方法二中的实验的所有 final loss 建模为模型参数数量 $N$$N$ 和 training tokens 数量 $D$$D$ 的函数。按照经典的风险分解（详细推导过程参考原始论文的附录 D ），我们提出以下函数形式：

   $$\begin{array}{}\text{(36)}& \hat{L}(N,D)=E+\frac{A}{N^{\alpha }}+\frac{B}{D^{\beta }}\end{array}$$

   其中：

   • 第一项捕获数据分布上的理想 generative process 的损失，并应与自然文本的熵相对应。

   • 第二项反映了这样一个事实，即一个具有 $𝑁$$𝑁$ 个参数的 perfectly trained transformer 低于理想 generative process 的表现。

     模型规模越大，则模型拟合能力越强，因此 training loss 越小。

   • 最后一项反映了一个事实，即 transformer 没有被训练到收敛，因为我们只在数据集分布的一个样本（即，单个数据集）上进行了有限数量的 optimisation steps 。

     training tokens 数量越大，则模型见过的样本越多，则 training loss 越小。

2. 模型拟合：为了估计 $(A,B,E,\alpha ,\beta )$$(A, B, E, \alpha, \beta)$ ，我们使用 L-BFGS 算法，使 predicted logloss 和 observed log loss 之间的 Huber loss 最小：

   $$\begin{array}{}\text{(37)}& \underset{A,B,E,\alpha ,\beta }{min}\sum _{\text{Runs }i}{\text{Huber}}_{\delta }(\log \hat{L}(N_i,D_i)-\log L_i)\end{array}$$

   我们通过 a grid of initializations 中选择最佳拟合从而来考虑可能的局部最小值。Huber loss （其中 $\delta ={10}^{-3}$$\delta = 10^{-3}$）对 outliers 是鲁棒的，我们发现这对 held-out data points 的良好预测性能很重要。原始论文的附录 D 详细介绍了拟合过程和 loss decomposition 。

   我们使用 $\delta ={10}^{-3}$$\delta=10^{-3}$ ，因为我们发现：

   • 较大的 $\delta$$\delta$ 使得模型过拟合于小预算，而对大预算的预测很差。

   • 更小的 $\delta$$\delta$ 不会影响 resulting prediction 。

3. 有效的边界（frontier）：我们可以通过在约束条件 $\text{FLOPs}(N,D)\simeq 6ND$$\text{FLOPs}(N, D)\simeq 6ND$ 下最小化 parametric loss $\hat{L}$$\hat L$ 来近似 $N_{\text{opt}}$$N_\text{opt}$ 和 $D_{\text{opt}}$$D_\text{opt}$。

   根据 《Scaling Laws for Neural Language Models》 的推导过程， $\text{FLOPs}\simeq 6NBS$$\text{FLOPs} \simeq 6NBS$ ，而 $D=BS$$D = BS$ 。

   根据公式的结构，它们具有幂律形式：

   $$\begin{array}{}\text{(38)}& \begin{array}{c}{N}_{\text{opt}}(C)=G{\left(\frac{C}{6}\right)}^a,D_{\text{opt}}(C)=G^{-1}{\left(\frac{C}{6}\right)}^b\\ \text{where }G={\left(\frac{\alpha A}{\beta B}\right)}^{1/(\alpha +\beta )},a=\frac{\beta }{\alpha +\beta },b=\frac{\alpha }{\alpha +\beta }\end{array}\end{array}$$

   这是怎么推导来的？论文并未详细说明。

   我们在下图（左图）中显示了被拟合的函数 $\hat{L}$$\hat L$ 的等高线，蓝色显示了根据公式来理论求解的 efficient computational frontier。通过这种方法，我们发现 $a=0.46,b=0.54$$a=0.46, b=0.54$ ，如 Table 2 所总结的。