Scaling Law on Jiang Yi(姜祎)'s Homepage

Notes on Ling-mini-beta

Sat, 13 Dec 2025 15:58:51 +0800

Introduction

目前已经有了针对 dense LLM 的 scaling law, 如 Kaplan scaling law 和 Chinchilla scaling law.

但是，对于 MoE 模型，目前还缺乏一个比较系统的 scaling law.

为了解决这个问题，作者提出了 efficiency leverage (EL), 用于衡量 MoE 模型的效率，其定义为

$$ EL(\mathcal{X}_{\mathrm{MoE}}\mid \mathrm{Dense})=\frac{C_{\mathrm{Dense}}}{C_{{\mathrm{MoE}}}} $$

其中 $C_{\mathrm{Dense}}, C_{{\mathrm{MoE}}}$ 分别代表了训练模型所需要的算力。EL 衡量了 moe 模型达到对应 dense 模型表现所需要的算力，EL 值越大，说明 MoE 模型效率越高。EL 的可视化如下图所示

作者通过训练多个模型，探究了 MoE 架构与 EL 之间的关系。作者发现，MoE 模型的表现主要与专家激活比例以及算力相关。基于 scaling law, 作者训练了 Ling-mini-beta, 一个 17.5B-A0.85B 的 MoE 模型，其表现超过了 6.1B dense 模型的表现。

Preliminary

Notation	description
$N$	total parameters
$N_a$	active parameters
$E$	routed experts
$E_a$	activated experts
$E_s$	shared experts

作者定义 activation ratio 如下:

$$ A = \frac{E_a+E_s}{E+E_s} $$

定义 sharing ratio 如下

$$ S=\frac{E_s}{E_a+E_s} $$

定义 expert granularity 如下

$$ G = \frac{d_{\mathrm{model}}}{d_{\mathrm{Expert}}} $$

与 DeepSeek-LLM 一样，作者使用 $C=MD$ 来表示算力，non-embedding FLOPs $M$ 和训练 token 数 $D$ 之间的关系。

Hyper Parameters

作者首先探究了针对 MoE 模型的超参数配置，最终你和出来的结果如下图

实验结果说明，相比于 dense model, MoE model 需要更大的 batch size.

作者基于这个 scaling law 进行了验证，结果说明这个 scaling law 比较准确。

Parameters and Dataset Size

接下来作者探究了对于模型参数量以及训练 token 个数之间的 scaling law, 求解的问题如下

$$ (M^{opt}, D^{opt}) = \arg\min_{M,D}\mathcal{L}(M,D;C,A,G,S)\quad s.t.\ C=MD $$

实验结果如下图所示

结果说明，不同架构对应的系数接近 $0.5$, 说明我们应该将算力均衡分配到数据和 model size 上。领一方面，MoE 模型可以通过使用更多的数据来达到更优的表现。

Efficiency Leverage

作者将 Efficiency Leverage (EL) 定义为给定算力 $C_{target}$ 和一个 MoE 模型 $\mathcal{X}_{MoE}$, 对应 dense 模型达到 $\mathcal{X}_{MoE}$ 相同的表现所需要的算力 $C_{dense}$, 即

$$ \begin{aligned} &EL(\mathcal{X}_{\mathrm{MoE}}\mid \mathrm{Dense};C_{target})=\frac{C_{\mathrm{Dense}}}{C_{{\mathrm{MoE}}}}\\ s.t.\ & |\mathcal{L}(C_{MoE}, \mathcal{X}_{\mathrm{MoE}})-\mathcal{L}(C_{dense}, \mathcal{X}_{\mathrm{dense}})|\leq \epsilon (\epsilon\to 0) \end{aligned} $$

EL 值越高说明 MoE 模型越有效。为了公平起见，dense 模型和 MoE 模型的架构参数基本相同，作者只改变 $d_{model}, d_{ffn}, d_{expert}$ 以及 $n_{layer}$.

接下来，作者就探究了给定算力的情况下，最优的 MoE 配置，即

$$ (A^{opt}, G^{opt}, S^{opt}) = \arg\min_{(A,G,S)\in\mathcal{X}_{\mathrm{MoE}}}EL(\mathcal{X}_{\mathrm{MoE}}\mid \mathrm{Dense};C) $$

Scaling Law

首先，坐着探究了最优的 activation ratio $A$, 即

$$ A^{opt} = \arg\min_{A}\mathcal{L}(A;C,M,G,S) $$

拟合的结果如下图所示

实验结果表明：

模型表现随激活比例降低 er 提高
更系数的模型对于算力的提升其效率也提升更快

然后，作者探究了最优的 granularity ratio, 即

$$ G^{opt} = \arg\min_{G}\mathcal{L}(G;C,M,A,S) $$

拟合的结果如下图所示

可以看到，无限制提升 granularity 并不会提高模型的表现。并且，不同的算力对应的最优 granularity 处于一个固定的范围

接下来，作者探究了最优的 shared expert ratio, 即

$$ S^{opt} = \arg\min_{S}\mathcal{L}(S;C,M,A,G) $$

拟合的结果如下图所示

结果说明 shared expert 的比例也不是越多越好，其存在最优值。并且给定算力的情况下，非零最小值的 shared expert 表现最好。因此作者认为，一个 shared expert 的效果最好。

作者还探究了其他可能的因素，结论如下：

与 DeepSeek-V3 一样，将 early layer 替换为 dense layer 可以避免 routing imbalance, 并且不会损害模型的表现
attention 应该占 $30\%\sim40\%$ 左右的算力才能保证模型的表现和效率。进一步提升 attention 的算力占比虽然会提升表现但是会降低推理效率。

通过前面的发现，作者将 shared expert 设置为 1 个，然后探究 EL 与 activation ratio $A$, granularity $G$, FLOPs $C$ 之间的关系。

首先，作者分别假设 $EL$ 与 $A$, $G$, $C$ 之间存在如下关系：

$$ \begin{aligned} \log EL_{C,G}(\hat{A}) &= a_A\log\hat{A}, \text{ where }\frac{1}{\hat{A}}=\frac{1}{A+(1/A_{start}-1/A_{\max})^{-1}}+\frac{1}{A_{\max}}\\ \log EL_{C,A}(\hat{G}) &= a_G+b_G(\log G(\log G+c_G))\\ \log EL_{A,G}(C) &= a_C\log C+c_C \end{aligned} $$

拟合的结果如下图所示

结果显示：

提升算力以及降低 activation ratio 都可以提高 EL
granularity 对 EL 的影响在不同算力的情况下都是一致的
对于 MoE 模型，提升算力可以提高 EL

作者的结论为，activation ratio 是影响 MoE EL 的核心因素。并且随着算力的提升，MoE EL 会越来越明显。

作者因此构建了一个统一的公式来统一三个因素

$$ EL(A,G,C) = \hat{A}^{\alpha+\gamma(\log G)^2+\beta \log G} $$

其中 $\alpha=a+d\log C$ 代表了 EL 和 activation ratio 之间的关系。拟合出来的参数如下表所示

$\alpha$	$d$	$\gamma$	$\beta$	$A_{start}$	$A_{\max}$
1.23	-7.61e-2	1.67e-2	-1.17e-1	1.63e-2	5.28e+16

基于这个结果，作者发现在 1e22 FLOPs 的算力下，一个 activation ratio 为 $3.1\%$, granularity 为 $12$ 的 MoE 模型，其 EL 为 $7$.

Ling-mini-beta

基于上一节的发现，作者构建了 Ling-mini-beta, 一个 17.5B 总参数，激活参数为 0.85B 的 MoE 模型。训练使用了 1T token, 模型参数如下表所示

Model	$n_{\text{layers}}$	$d_{\text{model}}$	$d_{\text{ffn}}$	$d_{\text{expert}}$	$n_{\text{heads}}$	$n_{\text{kv\_head}}$	$E$	$E_a$	$E_s$	$N$	$N_a$
Dense 6.1B	28	4096	14336	-	32	8	-	-	-	6.11B	6.11B
Ling-mini-beta (A0.8B)	20	2048	5120	384	16	4	384	12	1	17.5B	0.85B

训练的损失变化情况如下图所示

从图中我们可以看出，dense model 一开始的损失下降比较快，但是其最终表现不如 moe 模型。

Conclusion

在本文中，作者提出了 Efficiency Leverage, 一个衡量 MoE 模型相对于 dense 模型计算效率的 metric, 作者构建了针对 MoE 模型的 scaling law. scaling 揭示了两个主要影响 MoE 模型效率的因素：算力与激活参数比例。基于 scaling law, 作者构建了 Ling-mini-beta, 一个 17B-A0.8B 的 MoE 模型，其效率超过了对应 dense 模型的 7 倍。

References

arxiv

Chinchilla Scaling Law

Wed, 22 Oct 2025 14:39:23 +0800

Introduction

本文中关注的研究问题为：

给定一个 FLOPs budget, 如何平衡 model size 和 dataset size 之间的关系？

即，我们希望求解如下优化问题：

$$ N_{opt}(C), D_{opt}(C) =\arg\min_{N,D,\ \mathrm{s.t.}\ FLOPs(N,D)=C} L(N,D) $$

作者通过训练 400 多个模型，构建了对应的 scaling law.

已有工作如 Kaplan scaling law 已经发现模型参数和大语言模型表现之间的关系，一个结论就是计算最优并不代表达到最优的 loss. 在本文中，作者也有相同结论，但是作者认为大模型应该使用比 Kaplan scaling law 推荐的更多的 training token. 基于这个发现，作者训练了 Chinchilla, 一个 70B 的 LLM, Chinchilla 相比 Gopher 表现有了大幅度的提升。

Scaling Law

Fix Model Size and Very Dataset Size

这个方法中，作者通过改变训练步数，来研究 FLOPs 与模型表现之间的关系，结果如下图所示

通过对实验结果进行拟合，作者发现存在关系 $N_{opt}(C)\propto C^a$ 以及 $D_{opt}(C)\propto C^b$, 拟合的结果为 $a=b=0.5$.

IsoFLOPS Profiles

这个方法中，作者使用了不同的模型大小以及算力来构建最优模型参数量与算力之间的关系。作者给定 9 个算力配置，然后选取不同参数量的模型，训练的 token 数由算力和模型参数量决定，实验结果如下图所示

结果显示，不同大小的模型的表现 (loss) 随算力上升先下降后上升。因此给定算力，存在一个最优的 model size. 作者基于拟合出来的曲线得到了 Gopher 使用的算力配置下的最优 model size 和 training tokens. 同样的，作者得到 $a=0.49,b=0.51$.

Fitting a Parametric Loss Function

这个方法中，作者对 $L(N,D)$ 进行建模，作者使用了如下的公式

$$ L(N,D) = E + \frac{A}{N^{\alpha}} + \frac{B}{D^{\beta}} $$

第一项代表了建模的误差，第二项代表了数据集充分大损失与模型参数之间的关系，第三项代表了当模型充分训练时，损失与数据集大小之间的关系。

为了求解 $(A,B,E,\alpha,\beta)$, 作者基于训练收集到的数据 $L(N_i,D_i)$, 通过 L-BFGS 算法来最小化 Huber loss 进行求解，结果得到 $(A,B,E,\alpha,\beta)=( 406.4, 410.7, 1.69, 0.34, 0.28)$.

将结果带入带上面的表达式中，然后求出梯度为 0 的点，就得到

$$ N_{opt}(C) = G\left(\frac C6\right)^a, D_{opt}(C) = G^{-1}\left(\frac C6\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} $$

带入数值之后就得到 $a=0.46$, $b=0.54$. 作者对结果可视化如下图所示，左图是拟合曲线的 Contour plot, 右图对左图的一个切片

Optimal Model Scaling

作者将三种方法的结果以及 Kaplan scaling law 的结果总结放在下表中，作者假设 $N_{opt}(C)\propto C^a$ 以及 $D_{opt}(C)\propto C^b$

Approach	$a$	$b$
Kaplan	0.73	0.26
Approach 1	0.50	0.50
Approach 2	0.49	0.51
Approach 3	0.46	0.54

结果表明，三种方法的结论差不多：model size 和 dataset size 增长 debility 差不多。

作者因此给出来的不同模型大小所需要的算力以及 token, 结果如下表所示

Parameters	Approach 1		Approach 2		Approach 3
	FLOPs	Tokens	FLOPs	Tokens	FLOPs	Tokens
400 M	1.92e+19	8.0 B	1.84e+19	7.7 B	1.84e+19	7.7 B
1 B	1.21e+20	20.2 B	1.20e+20	20.0 B	1.20e+20	20.0 B
10 B	1.23e+22	205.1 B	1.32e+22	219.5 B	1.32e+22	219.5 B
67 B	5.76e+23	1.5 T	6.88e+23	1.7 T	6.88e+23	1.7 T
175 B	3.85e+24	3.7 T	4.54e+24	4.3 T	4.54e+24	4.3 T
280 B	9.90e+24	5.9 T	1.18e+25	7.1 T	1.18e+25	7.1 T
520 B	3.43e+25	11.0 T	4.19e+25	13.4 T	4.19e+25	13.4 T
1 T	1.27e+26	21.2 T	1.59e+26	26.5 T	1.59e+26	26.5 T
10 T	1.30e+28	216.2 T	1.75e+28	292.0 T	1.75e+28	292.0 T

作者基于发现的 scaling law, 对已有模型进行了探究，发现现有的大模型都存在 under-training 的现象，结果如下图所示

实验结果显示，现有的大模型的 size 应该更小（或者需要更大的算力）。作者最终的结论就是，现有的比较小的模型，需要更多的算力才能达到更好的表现。

Chinchilla

基于上一节的发现，作者提出了 Chinchilla, 一个 70B 的模型，训练使用了 1.4T token. 训练的数据集为 MassiveText 的扩展版本，训练使用的优化器为 AdamW, tokenizer 为 SentencePiece.

模型配置如下表所示

Model	Layers	Number Heads	Key/Value Size	dmodel	Max LR	Batch Size
Gopher 280B	80	128	128	16384	$4\times 10^{-5}$	$3M\to6M$
Chinchilla 70B	80	64	128	8192	$1\times 10^{-5}$	$1.5M\to3M$

Ablation Study

learning rate schedule 作者还通过 ablation study 发现，cosine learning rate cycle length 应该和训练步数差不多，当 cycle length 太长时，模型表现会下降。

Optimizer 作者对比了 Adam 和 AdamW 的表现，结果发现，AdamW 的表现优于 Adam.

High Precision 训练时，作者使用了高精度也就是 float32 来保存梯度的状态，结果显示，不管是 Adam 还是 AdamW, 使用高精度都可以提高模型的表现

Comparison with Kaplan 作者还对比了 Chinchilla 和 Kaplan 的预测结果，如下图所示

结果显示，基于 Chinchilla 预测得到的模型训练效果比 Kaplan 的更好。

Curvature of the FLOPs-frontier 作者发现，FLOP-minimal loss frontier 存在 curvature, 也就是小模型和大模型预测出来的曲线是不一样的，作者将结果展示在下图中

结果显示，从小模型拟合出来的结果比大模型拥有更高的算力使用效率，作者认为这是未来的一个研究方向。

Conclusion

本文中作者重新探究了针对 LLM 的 scaling law, 作者发现已有的大模型都存在 under-training 的现象，也就是说，模型需要更多的训练 token, 具体来讲，model size scaling 和 dataset scaling 应该处于同一水平。作者基于这个结论，提出了 Chinchilla, 一个 70B 的 LLM, 其表现超过了 280B 的 LLM.

References

arxiv

Kaplan Scaling Law

Wed, 22 Oct 2025 14:10:52 +0800

Introduction

作者首先就总结了本文的发现，主要有以下几点：

损失与模型的 scale , 即除开 embedding 的模型参数，数据集大小以及算力强相关，与 model shape 比如 depth 或者 width 关系不大
scaling law 是非常光滑的，意味着 scaling law 是一个可预测的模型
overfitting 普遍存在，当参数和数据集大小同时增加时，模型的表现会增加，但是当其中一个量固定时，提升就比较小。并且当我们将模型参数提升 8 倍时，我们只需要将数据集的大小提升 5 倍就可以避免过拟合
训练的损失函数曲线与 model size 无关，因此我们可以预测给定大小模型的表现
模型在测试集和训练集上的表现高度相关，因此我们可以基于训练集的损失来预测模型的表现
大模型比小模型拥有更高的 sample efficiency, 即更小的训练步数就可以达到相同的表现
convergence 不能说明一切，我们可以通过 early-stopping 来提高算力使用效率，避免模型花费过多的算力在较小的提升上
最优的 batch size 与 loss 呈一个 power law 的关系

Notation

Symbol	Notation
$L$	cross entropy loss
$N$	non-embedding parametters
$B$	batch size
$S$	number of training steps
$C\approx 6NBS$	estimate of total training compute
$D$	dataset size in tokens
$B_{crit}$	critical batch size
$C_{\min}$	estimate of the minimum compute to reach a given value of loss
$S_{\min}$	estimate of the minimum steps to reach a given value of loss
$\alpha_X$	power-law exponents for the scaling law of loss
$d$	hidden size of the model

为了简便，后续未经特殊说明，我们说模型参数均指的是 non-embedding 的参数

Scaling Law Overview

当数据集 $D$ 足够大时，损失与模型参数大小 $N$ 之间的关系为

$$ L(N) = \left(\frac{N_C}{N}\right)^{\alpha_N}, \alpha_N\sim 0.076, N_C\sim 8.8\times 10^{13} $$

给定模型参数大小 $N$ , 损失与数据集大小 $D$ 之间的关系为

$$ L(D) = \left(\frac{D_C}{D}\right)^{\alpha_D}, \alpha_D\sim 0.095, D_C\sim 5.4\times 10^{13} $$

给定足够大的数据集 $D$ 和最优模型大小 $N$ 时，损失与算力 $C$ 之间的关系为

$$ L(C_{\min}) = \left(\frac{C_C^{\min}}{C_{\min}}\right)^{\alpha_D}, \alpha_C^{\min}\sim 0.050, C_C^{\min}\sim 3.1\times 10^{8} $$

作者在不同大小的数据集，算力，模型大小下进行了测试，结果发现 scaling 与模型的 shape, transformer 的超参数之间的关系比较小。$\alpha_N,\alpha_D,\alpha_C^{\min}$ 等决定了当我们 scale up 数据及大小，模型大小和算力时损失的变化情况。比如当我们将模型参数提升至 2 倍时，模型的损失会降低至原来的 $0.95$.

基于发现 1 和 2, 作者发现当我们将模型的 size 提升至原来的 2 倍时，模型的数据集大小应该提升至原来的 $1.67$ 倍，具体关系为 $D\sim N^{0.74}$.

作者使用了一个统一的公式来描述损失与数据及大小和模型参数大小之间的关系

$$ L(N,D) = \left[\left(\frac{N_c}{N}\right)^{\frac{\alpha_N}{\alpha_D}}+ \frac{D_c}{D}\right]^{\alpha_D} $$

当数据集充分大时，损失与模型参数大小以及更新步数 $S$ 的关系如下

$$ L(N, S) = \left(\frac{N_C}{N}\right)^{\alpha_N} +\left(\frac{S_C}{S_{\min}(S)}\right)^{\alpha_S} $$

这里 $S_C\approx 2.1\times 10^3$, $\alpha_S\approx 0.76$, $S_{\min}(S)$ 是估计出来的最小优化步数

最优的 batch size 与损失函数之间的关系如下

$$ B_{crit}(L) = \frac{B_*}{L^{1/\alpha_B}}, B_*\sim 2*10^8 \text{ tokens}, \alpha_B\sim 0.21 $$

给定算力 $C$ 且无其他限制时，模型参数，数据及大小，batch size 和更新参数与算力之间的关系如下

$$ 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=BS $$

其中

$$ \alpha_C^{\min} = \frac{1}{\frac{1}{\alpha_S}+\frac{1}{\alpha_B}+\frac{1}{\alpha_N}} $$

实验的结果为 $N\propto C_{\min}^{0.73}$, $B\propto C_{\min}^{0.24}$ , $S\propto C_{\min}^{0.03}$. 也就是说，当我们提升算力时，提升模型的参数大小带来的收益是最高的。

Background

首先，transformer 的参数量通过计算可以得到

$$ N\approx 2dn(2d+d_{ff}) = 12nd^2 $$

这里 $d$ 是 hidden size, $n$ 是 layer 个数，$d_{ff}$ 是 MLP 的 hidden size, 这里我们假设 $d_{ff}=4d$. 计算时我们丢掉了 bias 以及 LayerNorm 的参数量。具体计算过程见 LLM parameter analysis

transformer 一次前向计算的 operations 数量大概为

$$ C_{forward}\approx 2N + 2nLd $$

这里 $L$ 是输入的 token 长度。

由于反向传播所需要的 FLOPs 是前向传播两倍，因此 transformer 的计算量为

$$ C = C_{backward} + C_{forward} = 3C_{forward}\approx 6N $$

具体计算过程见 LLM FLOPs analysis。也就是说，对于参数量为 $N$ 的 transformer model, 每个 token 所需要的 FLOPs 为 $C\approx 6N$

Empirical Results and Basic Power Laws

Transformer Shape and Hyper-parameter Independence

作者基于 $N=12nd^2$, 在保持总参数量 $N$ 不变的情况下，分别调整 $n$, $d_{ff}$ 和 number of attention heads 的个数（变化 $d$ 用于维持总参数量不变），结果如下图所示

实验结果发现，损失对于 $d_{ff}/d$, $d/n$, $d/n_h$ 都比较 robust, 说明模型的损失对模型的 shape 依赖性比较低。

Non-embedding Parameter Count

作者探究了以下 model size 对损失的影响，作者使用了不同的 $n$ 和 $d$, 然后训练得到的损失情况如下图所示

作者发现，当包含 embedding parameter 时，损失不仅依赖于模型参数量，还依赖于 layer 层数 $n$, 但是当我们排除 embedding parameter 时，模型的损失便与 layer 层数 $n$ 关系不大。这个趋势可以用以下模型来表示

$$ L(N) \approx \left(\frac{N_c}{N}\right)^{\alpha_N} $$

最终拟合的曲线如下图所示

Comparing to LSTMs and Universal Transformers

作者比较了 LSTM 和 Transformer 结构的损失，结果如下图所示

可以看到，transformer 比 LSTM 拥有更强的学习能力， LSTM 架构对于 early context 表现比较好，但是随着 context 增加，LSTM 的表现逐渐弱于 transformer. 即 transformer 的长上下文能力强于 LSTM 架构。

Generalization Among Data Distributions

模型是在 WebText2 数据集上训练的，作者进一步在其他数据集上评估了以下模型的泛化性，结果如下图所示

结果发现，模型在其他数据集上的泛化性很好。并且，模型的泛化性能仅与训练阶段的表现相关（validation loss），而与训练阶段（是否收敛）无关。

作者还评估了 model depth 对模型泛化性的影响，结果如下图所示

实验结果显示，model depth 对模型泛化性基本没有影响。

Performance with Data Size and Compute

作者探究了损失与 dataset size $D$ 之间的关系。作者固定一个模型，然后当 test loss 不再下降时停止训练，结果发现 test loss 与 dataset size $D$ 之间存在如下关系

$$ L(D) \approx \left(\frac{D_c}{D}\right)^{\alpha_D} $$

拟合结果如下图所示

接下来，基于前面计算的结果，我们有 $C\approx 6ND=6NBS$, 这里 $B$ 是 batch size, $S$ 是训练步数。给定 $C$, 作者使用不同大小的模型进行训练，batch size $B$ 保持不懂，训练步数设置为 $S=C/6BS$,实验结果显示损失与算力 $C$ 之间满足如下关系

$$ L(C) \approx \left(\frac{C_c}{C}\right)^{\alpha_C} $$

拟合结果如下图所示

作者进一步探究了 sample efficiency 与 model size 之间的关系，实验结果如下图所示

结果显示，随着 model size 增加，sample efficiency 也在增加

Charting the Infinite Data Limit and Overfitting

作者在本节探讨了同时变化 $N$ 和 $D$ 对损失变化的影响。

Proposed Equation

作者基于三个原则进行建模：

改变 vocabulary size 或者 tokenization 会 rescale loss
固定 $D$ 并且令 $N\to\infty$, 则最终损失应该接近 $L(D)$. 反之固定 $N$, 令 $D\to\infty$, 最终损失应该接近 $L(N)$
$L(N,D)$ 在 $D=\infty$ 处应该是可解析的

基于以上三条原则，将模型选择为如下形式

$$ L(N,D) = \left[\left(\frac{N_c}{N}\right)^{\frac{\alpha_N}{\alpha_D}}+ \frac{D_c}{D}\right]^{\alpha_D} $$

作者基于不同配置进行训练，基于实验结果你和得到的参数如下

Parameter	$\alpha_N$	$\alpha_D$	$N_c$	$D_c$
Value	0.076	0.103	$6.4\times 10^{13}$	$1.8\times 10^{13}$

接下来，作者探究了模型的过拟合程度，作者定义如下 metric

$$ \delta L(N,D) := \frac{L(N,D)}{L(N,\infty)} - 1 $$

带入 $L(N,D)$ 定义就得到

$$ \delta L(N,D) = \left(1 + \left(\frac{N}{N_c}\right)^{\frac{\alpha_N}{\alpha_D}}\frac{D_c}{D}\right) - 1 $$

通过测试不同的模型，作者发现 $\delta L$ 的值在 $0.02$ 左右，将实验结果带入到上面的公式就得到

$$ D \geq (5\times 10^3)N^{0.7379} $$

也就是说对于参数量为 $N$ 的模型，需要 data size $D \geq (5\times 10^3)N^{0.7379}$ 才能避免过拟合。

Scaling Laws with Model Size and Training time

作者在本节构建了损失函数与 model size $N$ 以及训练时间的 scaling law

Adjustment for Training at Critical Batch Size

已有结论说明，存在一个 critical batch size $B_{crit}$, 当 batch size 接近 $B_{crit}$ 时，增加 batch size 对计算效率影响比较小，但是当 batch size 大于 $B_{crit}$ 时，带来的提升比较小。另一方面，batch size 会影响梯度的噪声程度。因此，训练步数 $S$ 和处理的样本数 $E=BS$ 应该满足：

$$ \left(\frac{S}{S_{\min}}-1\right)\left(\frac{E}{E_{\min}}-1\right) = 1 $$

这里 $S_{\min}$ 是达到损失 $L$ 所需要的最小训练步数，而 $E_{\min}$ 是最小的训练样本数量。

作者的实验结果如下

作者将 critical batch size 定义为

$$ B_{crit}(L) := \frac{E_{\min}}{S_{\min}} $$

使用 critical batch size 进行训练可以在计算效率和算力之间达到一个平衡。

作者基于上面的实验结果探究了 critical batch size 和 model performance 之间的关系，实验结果如下图所示

可以看到，critical batch size 与 model size 的关系不大，仅与损失 $L$ 有关。作者通过以下模型拟合 critical batch size:

$$ B_{crit}(L) \approx \frac{B_*}{L^{1/\alpha_B}} $$

这里 $B_*\approx 2\times 10^8$, $\alpha_B\approx 0.21$.

给定一个 target loss $L$, 当 batch size $B>> B_{crit}$ 时，作者定义最小训练步数为

$$ S_{\min}(S) := \frac{S}{1+B_{crit}(L)/B} $$

给定 target loss $L$ 和 model size $N$, 当 batch size $B<< B_{crit}$ 时，作者定义最小算力为

$$ C_{\min}(C) := \frac{C}{1+B_{crit}(L)/B} $$

Performance with Model Size and Compute

作者使用如下公式来探究损失与 model size 和 computer 之间的关系

$$ L(N, S_{\min}) = \left(\frac{N_C}{N}\right)^{\alpha_N} +\left(\frac{S_C}{S_{\min}(S)}\right)^{\alpha_S} $$

拟合结果如下表所示

Parameter	$\alpha_N$	$\alpha_S$	$N_c$	$S_c$
Value	0.077	0.76	$6.5\times 10^{13}$	$2.1\times 10^{3}$

基于这个拟合结果，作者得到了下图的结果

作者还使用了不同的可视化方式，如下图所示

实验结果显示，上面的公式拟合的很好。

Lower Bound on Early Stopping step

作者还探究了以下 early step 与模型大小以及数据集之间的关系，作者通过分析得到如下结果

$$ S_{stop}(N,D) \gtrsim \frac{S_c}{[L(N,D)-L(N,\infty)]^{1/\alpha_S}} $$

其中 $L(N,\infty)$ 是在充分大数据集上的收敛损失。作者对实验结果进行了拟合，结果如下图所示

Optimal Allocation of the Compute Budget

作者在本节探究了最优算力与 model size $N$ 和训练数据 $2B_{crit}S_{\min}$ 之间的关系

Optimal Performance and Allocations

作者首先基于

$$ C_{\min}(C) := \frac{C}{1+B_{crit}(L)/B} $$

绘制了如下曲线图

作者发现，相比于 loss 与算力 $C$ 之间的关系，使用 $C_{\min}$ 进行拟合效果更好。

接下来，作者基于 $L(C_{\min})$ 进一步探究了给定算力如何决定最优的 model size $N(C_{\min})$. 其实验结果如下图所示

实验结果显示，model size 和算力之间有如下关系

$$ N(C_{\min}) \propto (C_{\min})^{0.73} $$

作者进一步探究了对于非最优模型大小与算力之间的关系，作者先构建了如下的关系

$$ \frac{C(N, N_{\mathrm{eff}})}{C(N_{\mathrm{eff}}, N_{\mathrm{eff}})} = \frac{N}{N_{\mathrm{eff}}} \left[ 1 + \frac{\alpha_S}{\alpha_N} \left( 1 - \left( \frac{N_{\mathrm{eff}}}{N} \right)^{\alpha_N} \right) \right]^{-\!1 / \alpha_S}. $$

对应的示意图为

实现结果发现，大小为最优模型的 $0.6\sim 2.2$ 倍只需要额外 $20\%$ 的算力。作者强调，这个实验结果对于超大模型不一定适用。

作者进一步推导了 $S_{\min}$ 和 $C_{\min}$ 之间的关系，由于 $C_{\min}=6NB_{crit}S$, 且我们前面已经有 $B\propto L^{-4.8}$ 和 $L\propto C_{\min}^{-0.05}$, 因此我们有

$$ B_{crit}\propto L^{-4.8} \propto (C_{\min})^{-0.05\times (-4.8)}\propto (C_{\min})^{0.24} $$

以及

$$ S_{\min} \propto \frac{C_{\min}}{6B_{crit}N(C_{\min})} \propto (C_{\min})^{0.03} $$

拟合的结果如下图所示

因此，基于上面的结果，当我们增加算力时，我们的主要精力应该放在增加模型大小和提高 batch size 上，而训练步数基本可以保持不变。

Another way of Derivation

作者还给出了另一种建模 $L(C_{\min})$ 的方式，即从 $L(N,S_{\min})$ 中进行推导，作者将 $B_{crit}$ 和 $S_{\min}$ 的表达式带入到 $L(N,S_{\min})$ 然后求解最小值就得到

$$ L(C_{\min})= \left(\frac{C_C^{\min}}{C_{\min}}\right)^{\alpha_C^{\min}} $$

其中

$$ \alpha_C^{\min} = \frac{1}{\frac{1}{\alpha_S}+\frac{1}{\alpha_B}+\frac{1}{\alpha_N}} \approx 0.054 $$

这和前面的结果基本是吻合的，进一步进行推导得到

$$ N(C_{\min})\propto (C_{\min})^{\alpha_C^{\min}/\alpha_N}\approx (C_{\min})^{0.71} $$

这个结果也和上面的差不多。

Contradiction and a Conjecture

作者发现，尽管拟合的 scaling law 曲线非常好，但是由于自然语言不可能达到 zero entropy, 因此该曲线最终一定会失效。作者基于更大的模型进行了实验，结果发现，模型在某一点开始就比预测的损失曲线下降的更慢。作者认为这是因为 transformer 模型已经达到了 maximal performance 导致的。

通过前面的分析，我们发现 $L(C_{\min})$ 比 $L(D)$ 下降的快，因此两者必然在某一点相交。

在前面的章节中，我们基于以下关系来决定数据集大小

$$ D\propto N^{0.74}\propto (C_{\min})^{0.74*0.73}\propto (C_{\min})^{0.54} $$

这里我们利用了 $N(C_{\min})$ 的结果

另一方面，我们有

$$ D(C_{\min}) = \frac{2C_{\min}}{6N(C_{\min})}\propto (C_{\min})^{0.26} $$

可以看到，基于训练最优导出的数据集大小相比于拟合出来的数据集大小，实际上存在过拟合。

作者进一步分析出了 $L(D(C_{\min}))$ 和 $L(C_{\min})$ 这两条曲线的交点，结果得到

$$ C^*\approx 10^4 \text{ PF-Days}, N^*\approx 10^{12}\text{ parameters}, D^*\approx 10^12\text{ tokens}, L^*\approx 1.7\text{1.7nats/token} $$

作者认为出现这种原因有以下几种情况：

$L^*$ 给出了自然语言的 entropy 的一个估计，因此当模型充分大之后，模型可能已经获取到了数据中的所有知识
$L(C_{\min})$ 可以作为数据集噪声的一个量化表现，其衡量了数据集的质量

Learning Rate Schedule

附录中，作者还探究了 learning rate 与损失之间的关系，作者使用了不同 learning rate schedule 对模型损失的影响，结果如下图所示

实验结果显示，只要 learning rate 下降的不会太快，模型的表现基本上差不太多。

作者基于实验结果得到了学习率和模型参数之间的关系如下

$$ \text{lr}(N)\approx 0.003239 - 0.0001395\log N $$

也就是说，小模型用比较大的学习率，大模型用较小的学习率。

Conclusion

作者在本文中训练了大量不同配置的大模型，然后构建了损失（损失）与模型参数，数据及大小以及算力之间的关系。实验结果发现，损失与架构和优化参数之间的关系比较小，主要由模型参数量决定，更大的模型拥有更高的采样效率。

作者认为，本文的局限在于损失函数不一定能够反应模型在其他语言任务上的表现。

References

arxiv

LLM FLOPs Computation

Wed, 15 Oct 2025 16:33:39 +0800

本文中，我们介绍如何计算基于 transformer 架构的 LLM 的 FLOPs, 计算完成之后，我们可以推导出算力 $C$ 与模型参数量 $N$，数据集大小 $D$ 之间的关系，即 $C\approx 6ND$.

Background

FLOPs

FLOPs，floating point operations，表示浮点数运算次数，一般计算 FLOPs 仅考虑加法和乘法。

假设 $A\in\mathbb{R}^{m\times p}$, $B\in\mathbb{R}^{p\times n}$, 则计算 $C=AB$ 的过程中一共需要进行 $mnp$ 次乘法运算和 $mnp$ 次加法运算，因此总的 FLOPs 为 $2mnp$.

Assumption

假设 $A\in\mathbb{R}^{m\times p}$, $B\in\mathbb{R}^{p\times n}$, $C\in\mathbb{R}^{m\times n}$ 则计算 $D=AB+C$ 的过程中一共需要进行 $mnp$ 次乘法运算和 $mnp+mn$ 次加法运算，因此总的 FLOPs 为 $2mnp+mn\approx 2mnp$.

基于上述结论，我们计算 FLOPs 时，忽略 element-wise 的操作，即我们做如下假设：

忽略 normalization 中的小常数项运算
忽略 residual connection 和 bias term 的加法
忽略注意力的 MASK 和 softmax，因为这两者都是 element-wise operation.
使用 look-up 计算 embedding layer

注，基于以上假设，我们的结果与 Chinchilla Scaling law 的结果稍有不同，但结论不变。

Notation

Math Variable	Code Variable	Description
$n$	`num_hidden_layers`	Transformer block 个数
$\vert V\vert$	`vocab_size`	词表大小
$d$	`hidden_size`	token embedding 的维度
$d_{ff}$	`intermediate_size`	MLP 的中间层的维度
$h$	`num_attention_heads`	query head 的个数
$s$	`seq_len`	length of token sequence

注：为了避免混淆，我们使用 $n$ 来表示 decode layer 的个数。

Computation

我们计算训练阶段的总 FLOPs, 记为 $C$, Kaplan scaling law 用 PF-days 作为单位，$1\text{ PF-Days}=10^{15}\times 24\times 3600\ FLOPs$. 训练阶段包括前向阶段 (forward pass) 和反向传播阶段 (backward pass). 因此

$$ C = FLOPs(\text{forward}) + FLOPs(\text{backward}) $$

Forward

decoder-only transformer 的模型架构包含三个模块：

1 层 embedding layer
$n$ 层 decoder layer
1 层 lm head layer

因此模型总的 FLOPs 为

$$ FLOPs(\text{forward}) = FLOPs(\text{embedding}) + n*FLOPs(\mathrm{decode\_layer})+FLOPs(\mathrm{lm\_head}) $$

Embedding & Lm Head

首先，对于 embedding layer, embedding layer 本质上是一个 look up table, 计算过程中不涉及浮点数运算，因此 $\boxed{FLOPs(\text{embedding})=0}$.

接下来，对于 lm_head, 这是一个 linear layer, 其权重大小为 $W\in\mathbb{R}^{d\times |V|}$, 输入为 $x\in\mathbb{R}^{s\times d}$, 因此 $\boxed{FLOPs(\mathrm{lm\_head})=2sd|V|}$.

因此，我们有

$$ FLOPs(\text{forward}) = n*FLOPs(\mathrm{decode\_layer})+ 2sd|V| $$

Decode Layer

对于 decode_layer, 其又包含了四个模块：

pre-normalization
attention
post-normalization
FFN

pre-normalization 和 post-normalization 一般是一样的，因此

$$ \begin{aligned} FLOPs(\mathrm{decode\_layer}) &= FLOPs(\mathrm{pre\_normoalization}) + FLOPs(\mathrm{Attention}) + FLOPs(\mathrm{post\_normoalization}) +FLOPs(\mathrm{FFN})\\ &= 2*FLOPs(\mathrm{normoalization}) + FLOPs(\mathrm{Attention})+FLOPs(\mathrm{FFN}) \end{aligned} $$

Normalization

现在有两种常见的 normalization, 也就是 LayerNorm 和 RMSNorm

LayerNorm 定义如下

$$ \mathrm{LayerNorm}(x) = \frac{x-\mathbb{E}[x]}{\sqrt{\mathrm{var}[x]+\epsilon}}\odot \beta + \gamma $$

其中 $\beta,\gamma\in\mathbb{R}^d$ 是可学习的参数。

对输入 $x\in\mathbb{R}^{s\times d}$, 均值需要约 $sd$ 次 FLOPs，方差 $\mathrm{var}[x]$ 只需要约 $3sd$ 次 FLOPs，这两者的计算都可以忽略。接下来就是 scaling 和 shift, 这两者都是 element-wise 操作，我们这里，因此总的 FLOPs 为

$$ \boxed{FLOPs(\mathrm{normoalization}) = 4sd} $$

RMSNorm 的作用和 LayerNorm 是一样的，但是实现上更简单

$$ \mathrm{RMSNorm}(x) = \frac{x}{\sqrt{\|x\|_2^2+\epsilon}}\odot \gamma $$

其中 $\gamma\in\mathbb{R}^d$ 是可学习的参数

对于 RMSNorm，其分析方式与 LayerNorm 基本一致，因此总的 FLOPs 为

$$ \boxed{FLOPs(\mathrm{normoalization}) = 4sd} $$

总之，不管使用哪种 normalization，其 FLOPs 都是

$$ \boxed{FLOPs(\mathrm{normoalization}) = 4sd} $$

Attention

Attention 定义如下

$$ \mathrm{Attention}(X) = \mathrm{softmax}\left(\frac{QK^T}{\sqrt{d}}\right)V\in\mathbb{R}^{m\times d} $$

其中 $X\in\mathbb{R}^{s\times d}$, $W_Q,W_K,W_V\in\mathbb{R}^{d\times d}$

$$ Q = W_QX\in\mathbb{R}^{s\times d},\quad K =W_KX\in\mathbb{R}^{s\times d},\quad V = W_VX\in\mathbb{R}^{s\times d} $$

$Q,K,V$ 计算的 FLOPs 为 $6*sd^2$. $QK^T$ 的 FlOPs 为 $2s^2d$, $\mathrm{softmax}(\cdot)V$ 的 FLOPs 为 $2s^2d$, 最后对于 multi-head attention 还有一个 output projection layer, 其权重为 $W_O\in\mathbb{R}^{d\times d}$, 因此 FLOPs 为 $2sd^2$. 故 attention 最终的 FLOPs 为

$$ FLOPs(\mathrm{Attention})=6sd^2+2s^2d+2s^2d+2sd^2=\boxed{8sd^2+4s^2d} $$

FFN

对于 FFN，有两种常见的形式，一种基于 ReLU 激活函数，其定义如下

$$ y = \max(xW_1+b_1, 0)W_2 + b_2 $$

其中 $W_1\in\mathbb{R}^{d_{ff}\times d}$, $W_2\in\mathbb{R}^{d\times d_{ff}}$. $b_1\in\mathbb{R}^{d_{ff}}$, $b_2\in\mathbb{R}^{d}$.

对输入 $x\in\mathbb{R}^{s\times d}$, 其 FLOPs 为

$$ FLOPs(\mathrm{FFN_{ReLU}}) = 2sdd_{ff} + 2sd_{ff}d =\boxed{4sdd_{ff}} $$

其中第一项和第二项分别为为 $xW_1$ 与 $\max(xW_1+b_1, 0)W_2$ 的 FLOPs.

另一种基于 SwiGLU 激活函数，其定义为

$$ \mathrm{SwiGLU}(x) = x\odot \sigma(x) $$

其中 $\sigma(\cdot)$ 是 sigmoid 函数

FFN 的定义为

$$ y = W_2(W_3x\odot \mathrm{SwiGLU}(W_1x)) $$

其中 $W_3,W_1\in\mathbb{R}^{d_{ff}\times d}$, $W_2\in\mathbb{R}^{d\times d_{ff}}$.

对输入 $x\in\mathbb{R}^{s\times d}$, 其 FLOPs 为

$$ FLOPs(\mathrm{FFN_{SwiGLU}}) = 2sdd_{ff} + 2sdd_{ff} + 2sd_{ff}d = \boxed{6sdd_{ff}} $$

Summary

最终，decoder-only transformer 的 FLOPs 计算量为（我们假设使用 multi-head attention, 基于 SwiGLU 的 MLP）

$$ \begin{aligned} FLOPs(\text{forward}) &= FLOPs(\text{embedding}) + n*FLOPs(\mathrm{decode\_layer})+FLOPs(\mathrm{lm\_head})\\ &= n*FLOPs(\mathrm{decode\_layer})+2sd|V|\\ &= n*(2*FLOPs(\mathrm{normoalization}) + FLOPs(\mathrm{Attention})+FLOPs(\mathrm{FFN}))+2sd|V|\\ &= n*(8sd+8sd^2+4s^2d+6sdd_{ff})+2sd|V|\\ &= nsd^2\left(\frac8d + 8+\frac{4s}{d}+\frac{6d_{ff}}{d}+\frac{2|V|}{nd}\right)\\ &\approx \boxed{nsd^2\left(8+\frac{4s}{d}+\frac{6d_{ff}}{d}+\frac{2|V|}{nd}\right)} \end{aligned} $$

这里我们丢弃了 normalization 项，因为 normalization 的 FLOPs 是一个低阶项

Backward

首先，我们有如下结论：

神经网络 backward 过程的计算量（FLOPs）为 forward 过程的两倍

我们使用一个简单的例子来证明这个结论，考虑线性层 $h=Wx$, 其中 $W\in\mathbb{R}^{m\times d}$, 对于输入 $x\in\mathbb{R}^{d\times 1}$ 其 forward 过程的计算量为 $2md$.

对于反向过程，我们需要分别计算损失 $L$ 对权重和输入的梯度，即

$$ \frac{\partial L}{\partial x} = W^T\frac{\partial L}{\partial h}\in\mathbb{R}^{d\times 1}, \quad\frac{\partial L}{\partial W} = \frac{\partial L}{\partial h}\otimes x^T\in{m\times d}, $$

这里 $\frac{\partial L}{\partial h}\in\mathbb{R}^{m\times 1}$ 为损失对输出 $h$ 的梯度。因此反向传播的总计算量为

$$ 2dm + 2md = 4md $$

这里的两项分别是对 $x$ 和 $W$ 求梯度的 FLOPs.

Overall

将前向传播和反向传播的计算量汇总我们就得到一次前向传播和一次反向传播过程中，对于长度为 $s$ 的 token, 其 FLOPs 为 (multi-head attention, SwiGLU-FFN)

$$ \begin{aligned} C &= FLOPs(\text{forward}) + FLOPs(\text{backward})\\ &= 3FLOPs(\mathrm{forward}) \\ &\approx \boxed{3nsd^2\left(8+\frac{4s}{d}+\frac{6d_{ff}}{d}+\frac{2V}{nd}\right)} \end{aligned} $$

Extension

GQA

GQA 与 MHA 不同的地方在于通过共享 key 和 value 来降低 KV cache 的占用，我们假设 group number 为 $g$, 则 key 和 value 的 FLOPs 现在变成了

$$ 2sdd_h\frac{h}{g}+2sdd_h\frac{h}{g}=4sdd_h\frac{h}{g} $$

因此 attention 部分总的 FLOPs 变成了

$$ FLOPs(\mathrm{Attention})=4sd^2+2s^2d+2s^2d+4sdd_h\frac{h}{g}=4sd^2+4s^2d+4sdd_h\frac{h}{g} $$

当 $g=h$ 时，GQA 就变成了 MHA, 此时的 FLOPs 也一致。

MoE

MoE 是针对 Dense FFN 的一个改进，介绍见 MoE, 我们假设一共有 $e$ 个路由专家，其中激活 $k$ 个。

Gate layer 一般是一个 linear layer, 其权重矩阵大小为 $W_{G}\in\mathbb{R}^{d\times e}$, 因此 $FLOPs(\text{router})= 2sde$.

Expert layer 和前面提到的 FFN 一致，我们每次挑选出 $k$ 个专家进行计算，因此 expert 部分 $FLOPs(\text{expert})=6ksdd_{ff}$.

从而对于 MoE 来说，FFN 部分的 FLOPs 为

$$ FLOPs(\text{MoE}) = FLOPs(\text{router})+FLOPs(\text{expert})= \boxed{2sde+6ksdd_{ff}} $$

Simplification

我们已经得到了 transformer 的 FLOPs 计算表达式，但是其表达式比较繁琐，因此，在研究 scaling law 时，一般会进行简化。

首先，在 LLM parameter analysis 中，我们已经给出了 LLM 参数量 $N$ （基于 Qwen3）的计算结果

$$ N=n*(4d+3dd_{ff}+2hh_{d}d + 2h_{kv}h_dd) + d(2|V|+1) $$

我们这里对其进行简化，一般来说 $d_{ff}=8/3d$, $h_{kv}=h$, $h_d=d/h$, 带入就得到

$$ N = n(4d+8d^2+2d^2+2d^2) + d(2|V|+1)=n(12d^2+4d)+ d(2|V|+1) $$

我们忽略关于 $d$ 的一阶项，并且我们假设 $|V| << 12nd$, 则最终模型参数量可以近似为

$$ \boxed{N \approx 12nd^2} $$

接下来，我们基于上面的配置简化 FLOPs 表达式

$$ \begin{aligned} C &= 3nsd^2\left(8+\frac{4s}{d}+\frac{6d_{ff}}{d}+\frac{2|V|}{nd}\right) \\ &= 3nsd^2\left(24+\frac{4s}{d}+\frac{2|V|}{nd}\right)\\ &\approx 72nsd^2 \\ &= 6sN \end{aligned} $$

这里我们利用了前面的 $|V| << 12nd$ 假设，为了简便我们还舍弃了 $4s/d$.

注意到 $s$ 代表 token 序列长度，如果训练集的总 token 个数为 $D$, 则最终对于包含 $D$ tokens 的数据集和包含 $N$ 参数量的 LLM, 其训练总 FLOPs 可以近似估计为

$$ \boxed{C\approx 6ND} $$

Experiments

Setting

接下来我们定量分析一些模型的 FLOPs. 我们基于 Chinchilla scaling law 给出的实验配置 (Table A9), 我们筛掉 kv_size * n_heads != d_model 的配置，$|V|=32,000$.

各部分的 FLOPs 计算代码如下

1
2
3
4
5


def compute_flops(n, V, d, d_ff, s):
 lm_head_flops = 2 * V * d * s
 attention_flops = 8 * s * d * d + 4 * s * s * d
 feed_forward_flops = 4 * s * d * d_ff
 return lm_head_flops, attention_flops, feed_forward_flops

首先我们看一下不同大小模型的 FLOPs 分布情况

可以看到，当模型越来越大，FFN 层的算力占比越来越高，这也是为什么后来采用 MoE 架构的一个原因。

接下来，我们看一下模型 FLOPs 分布情况随上下文长度变化的情况

可以看到，随 context length 增加，attention 的算力占比逐渐上升，这符合 attention 是一个平方复杂度的算法的结论。并且，当上下文足够长之后，计算还出现了 overflow (图像右端的突然下降)。

Conclusion

在本文中，我们介绍了如何计算基于 decoder-only transformer LLM 的 FLOPs, 并推导除了 Kaplan scaling law 中使用的公式 $C=6ND$, 这为后面的 infra 和 scaling law 的学习提供了基础。