一文要約: Scaling Laws は、言語モデルの損失がモデルサイズ・データセットサイズ・計算量のべき乗関数として予測可能に低下することを示しています。つまり 70B の学習コストを紙の裏で計算できますし、そうすべきです。

付録 A の概観: Kaplan と Chinchilla の Scaling Laws — 計算量・パラメータ数・トークン数に対する対数−対数の損失曲線、および 70B の学習ランをナプキンの裏でスケッチするための FLOPs ≈ 6·N·D ルール

A.1 Scaling Law とは何か

A.1.1 直感に反する発見

2020 年、OpenAI は「Scaling Laws」論文を発表しました。アーキテクチャの工夫が進歩を牽引すると思っていた人々を驚かせた中心的な結果はこうです。

言語モデルの損失（保留テキストのクロスエントロピーで測定）は、パラメータ数 N、データセットサイズ D、計算量 C の 3 つの量に対してべき乗則の関係をたどる。

これは「大きいほど常に良い」という主張ではありません。「関係が予測可能だ」という主張です。固定された予算が与えられれば、学習を始める前に大体どれくらいの損失になるかを計算できます。その予測には価値があります。

A.1.2 三つのべき乗則方程式

OpenAI 論文のコア方程式:

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

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

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

各記号の意味:

$L$ はモデルのクロスエントロピー損失（低いほど良い）
$N$ はパラメータ数、 $D$ は学習トークン数、 $C$ は総計算量（FLOPs）
$N_c, D_c, C_c$ はフィッティングで求めた定数
$\alpha$ はべき乗則の指数

経験的にフィッティングされた指数:

$\alpha_N \approx 0.076$
$\alpha_D \approx 0.095$
$\alpha_C \approx 0.050$

指数が小さいということは、大きな損失改善を得るためには積極的にスケールアップする必要があることを意味します。パラメータを 2 倍にしても損失は半減しません — 約 5% 低下するだけです。

A.1.3 曲線の形

対数−対数プロットでは、各関係は指数を負の傾きとする近似的な直線になります。対数−対数空間でのこの直線がべき乗則です。

Loss
 |  \
 |   \
 |    \
 |     \____
 |          \____
 |               \____
 +-----------------------------> log(N  or  D  or  C)

これまで観測されているどのスケールでも直線は平坦になっていません。それがフロンティアラボをスケールアップし続けさせる理由です。

A.2 パラメータ数の見積もり

A.2.1 Transformer 内のパラメータの在り処

標準的な密な Transformer のパラメータは 3 箇所から来ます。

埋め込み層

トークン埋め込み:    vocab_size × d_model
位置埋め込み: max_seq_len × d_model   (学習済みの場合; RoPE では省略)

各 Transformer ブロック（モデルの大部分）

Multi-Head Attention:
  W_Q: d_model × d_model
  W_K: d_model × d_model
  W_V: d_model × d_model
  W_O: d_model × d_model
  小計: 4 × d_model²

Feed Forward Network（FFN、拡張比 4）:
  W_1: d_model × 4·d_model
  W_2: 4·d_model × d_model
  小計: 8 × d_model²

LayerNorm（×2）:
  γ, β per layer: 4 × d_model  （無視できる）

ブロックあたり合計: ≈ 12 × d_model²

出力ヘッド

LM head: d_model × vocab_size
（通常は埋め込み行列と共有 — 追加パラメータなし）

A.2.2 簡略化された見積もり公式

$L$ 層、隠れ次元 $d_\text{model}$ のモデルでは、支配的な項は:

N \approx 12 \times L \times d_{\text{model}}^2

埋め込みと出力層は大規模モデルでは従属的なので、粗い見積もりでは無視できます。

GPT-3 175B で素早くチェック: $L = 96$ 、 $d_\text{model} = 12288$

12 \times 96 \times 12288^2 = 12 \times 96 \times 150,994,944 \approx 173\text{B} \checkmark

A.2.3 6 モデルにわたる検証表

モデル	L	d_model	予測 N	実際の N	一致率
GPT-2 Small	12	768	85M	117M	~73%
GPT-2 Medium	24	1024	302M	345M	~88%
GPT-2 Large	36	1280	709M	762M	~93%
GPT-2 XL	48	1600	1.47B	1.5B	~98%
GPT-3 Small	12	768	85M	125M	~68%
GPT-3 175B	96	12288	173B	175B	~99%

小規模モデルでは埋め込みパラメータが全体に占める割合が大きいため、この公式の精度は下がります。1B パラメータ以上のモデルでは数パーセント以内に収まります。これはまた Scaling Law の予測が最も信頼できるレジームでもあります。

A.3 計算量の見積もり

A.3.1 FLOP とは何か

FLOPs（Floating Point Operations）は、計算に必要な浮動小数点の加算と乗算の回数を数えます。

最も重要な基本操作: 形状 $A[m, k] \times B[k, n]$ の行列積は正確に $2mnk$ FLOPs かかります（出力要素ごとに 1 回の乗算と加算、出力要素は $m \times n$ 個あり、それぞれ $k$ 回の積和演算が必要）。

A.3.2 学習計算量の公式

標準的な学習コスト見積もりは:

C_\text{train} \approx 6 \times N \times D

各記号の意味:

$N$ はモデルのパラメータ数
$D$ は学習トークン数
定数 6 は順伝播と逆伝播を考慮したもの:
- 順伝播: 各パラメータはトークンあたり 1 回の積和演算に参加 → トークンあたり $2N$ FLOPs
- 逆伝播: 活性化に対する損失の勾配 + 重みに対する勾配 → トークンあたり $4N$ FLOPs
- トークンあたり合計: $2N + 4N = 6N$

計算例 — LLaMA-7B を 1 兆トークンで学習:

C = 6 \times 7 \times 10^9 \times 10^{12} = 4.2 \times 10^{22} \text{ FLOPs}

42 ゼタFLOPs です。数字で書くと: 42,000,000,000,000,000,000,000 演算。

A.3.3 推論計算量の公式

推論は順伝播のみを実行し、一度に 1 トークンを生成します。

C_\text{inference} \approx 2 \times N \times T_\text{generated}

例 — LLaMA-7B で 100 トークン生成:

C = 2 \times 7 \times 10^9 \times 100 = 1.4 \times 10^{12} \text{ FLOPs} = 1.4 \text{ TFLOPs}

H100 一枚なら、ピークスループットで 2 ミリ秒以下で処理できます。自己回帰生成のボトルネックは計算量ではなく、メモリ帯域幅です。だからこそ KV キャッシュ（第 22 章）と量子化（第 27 章）が推論レイテンシにとって非常に重要なのです。

A.3.4 GPU スペックと学習時間

代表的な GPU スペック（FP16 / BF16 Tensor Core スループット）:

GPU	FP16/BF16 TFLOPs	VRAM	備考
RTX 3090	35 TFLOPs（FP32）/ 142（FP16 sparse）	24 GB	コンシューマー向け; 学習は遅い
RTX 4090	83 TFLOPs（FP32）/ 330（FP16 sparse）	24 GB	最高のコンシューマーカード; スケール時はファインチューニングのみ
A100 80GB	312 TFLOPs（BF16）	80 GB	データセンター標準; 2 年間ほとんどのラボのバックボーン
H100 80GB	990 TFLOPs（BF16）	80 GB	学習スループットで A100 の 3×
H200 141GB	990 TFLOPs（BF16）	141 GB	H100 と同等の計算量; バッチサイズと KV キャッシュ用の追加メモリ

コンシューマー GPU の sparse FP16 数値は、ほとんどの学習ワークロードが利用できない構造化スパース性を前提にしています。最適化されていない学習の実用的な上限として dense FP32 の数値を使ってください。

学習時間の公式:

\text{Days} = \frac{C_\text{train}}{\text{GPUs} \times \text{TFLOPs} \times \text{utilization} \times 86400}

現実的な稼働率は 0.4 〜 0.5 です — 通信オーバーヘッド、データロード、時折の再起動、チェックポイント保存がすべてピークスループットを削ります。

例 — LLaMA-7B を A100 80GB × 1000 台で学習:

\text{Days} = \frac{4.2 \times 10^{22}}{1000 \times 312 \times 10^{12} \times 0.4 \times 86400} \approx \frac{4.2 \times 10^{22}}{1.08 \times 10^{19}} \approx 3.9 \text{ days}

スポット価格が GPU 時間あたり約 $1.30 とすると、このランのコストは:

1000 \times 3.9 \times 24 \times \$1.30 \approx \$122{,}000

175B パラメータ・300B トークンの GPT-3 は 2020 年のハードウェアで $4〜500 万に近い金額でした — ほんの一握りの組織しか学習できなかった理由です。

A.4 演算ごとの FLOPs クイックリファレンス

Transformer ブロック全体を見積もる前に、各基本操作のコストを把握しておきましょう。

演算	FLOPs
行列積 $A[m,k] \times B[k,n]$	$2mnk$
ベクトルの内積（長さ $n$ ）	$2n$
長さ $L$ の軸に沿った Softmax	出力要素あたり $\approx 5L$
サイズ $d$ のベクトルに対する LayerNorm	$\approx 8d$
GELU 活性化（要素ごと）	$\approx 4$ FLOPs

Softmax は要素あたり約 5 演算（最大値減算・指数関数・合計・除算・ブックキーピング）かかります。LayerNorm は約 8 演算（平均・分散・正規化・スケール・シフト・ブックキーピング）かかります。典型的な構成では行列積と比べると小さいですが、長いコンテキスト長では積み重なります。

A.5 Transformer ブロックの FLOPs 内訳

A.5.1 公式

シーケンス長 $s$ 、隠れ次元 $d$ （FFN 次元 $4d$ ）を処理する単一の Transformer ブロックでの順伝播時のトークンあたり FLOPs は:

\text{FLOPs per block per token} \approx 24sd^2 + 4s^2 d

2 つの項はそれぞれ異なるスケーリングレジームを反映しています。

$24sd^2$ : 行列積で、 $d$ に対して 2 乗でスケール
$4s^2 d$ : Attention スコア計算で、シーケンス長 $s$ に対して 2 乗でスケール

A.5.2 コンポーネント内訳

コンポーネント	トークンあたり FLOPs	公式
Attention QKV 射影	$6sd^2$	3 つの $[s,d] \times [d,d]$ 行列積
Attention スコア (QKᵀ)	$2s^2 d$	$[s,d] \times [d,s]$
Attention 出力射影	$2sd^2$	$[s,d] \times [d,d]$
FFN（2 つの線形層）	$16sd^2$	$[s,d]\times[d,4d]$ + $[s,4d]\times[4d,d]$
合計	$24sd^2 + 4s^2d$

Softmax、LayerNorm、GELU は数パーセント上乗せしますが、先頭次オーダーの公式からは省略されています。

A.5.3 Attention が支配するのはいつか

短いシーケンスでは FFN が支配的です — FFN は $16sd^2$ かかるのに対し、Attention のスコア計算は $4s^2 d$ です。クロスオーバーは:

s \approx 4d

$d_\text{model} = 4096$ （LLaMA-7B）では、クロスオーバーは $s \approx 16{,}384$ トークンです。それ以下では FFN が支配し、それ以上では Attention の 2 乗コストが支配します — 長いコンテキスト推論が高コストである理由、そして線形 Attention・スライディングウィンドウ Attention・スパース Attention などのアーキテクチャが存在する理由がここにあります。

A.5.4 計算例 — LLaMA-7B 単一順伝播

LLaMA-7B: $L = 32$ 、 $d = 4096$ 、 $s = 2048$

ブロックあたり、トークンあたり:

24 \times 2048 \times 4096^2 + 4 \times 2048^2 \times 4096

= 24 \times 2048 \times 16{,}777{,}216 + 4 \times 4{,}194{,}304 \times 4096

\approx 8.25 \times 10^{11} + 6.87 \times 10^{10} \approx 8.94 \times 10^{11} \text{ FLOPs per block}

32 ブロック全体:

32 \times 8.94 \times 10^{11} \approx 2.86 \times 10^{13} \text{ FLOPs for one 2048-token sequence}

1 兆学習トークンに対する $C = 6ND$ の見積もり $4.2 \times 10^{22}$ と比較してみましょう。シーケンス数は $10^{12} / 2048 \approx 4.9 \times 10^8$ で、 $3 \times 2.86 \times 10^{13} \times 4.9 \times 10^8 \approx 4.2 \times 10^{22}$ （3 倍は順伝播+逆伝播の分）。2 つの見積もりが一致するのは良いサインです。

A.6 Chinchilla 最適性

A.6.1 DeepMind が発見したこと

2022 年、DeepMind は Chinchilla 論文を発表しました。2020 年の OpenAI 論文よりも広いモデルサイズとトークン数の範囲で体系的な研究を行い、従来の常識を修正する知見を得ました。

固定された計算予算の最適な配分は、パラメータとデータを等比率でスケールさせることだ。

GPT-3 のアプローチ — 比較的小さいデータセットで非常に大規模なモデルを学習する — は計算量的に劣るのです。同じ計算量で、より小さなモデルをより多くのデータで学習させれば、より低い損失が得られます。

A.6.2 Chinchilla の公式

D_\text{optimal} \approx 20 \times N

学習トークン数はパラメータ数の約 20 倍にすべきです。これは Chinchilla のスケーリング曲線フィッティングから導かれた経験則であり、物理定数ではありません。

A.6.3 未学習・過学習・そしてなぜ重要か

モデル	N	D（学習済みトークン）	Chinchilla 最適 D	ステータス
GPT-3 175B	175B	300B	3.5T	Chinchilla では未学習
Chinchilla 70B	70B	1.4T	1.4T	定義上最適
LLaMA-1 7B	7B	1T	140B	過学習（意図的）
LLaMA-2 70B	70B	2T	1.4T	過学習（意図的）

「過学習」は LLaMA の場合にはバグではありません — 設計上の選択です。固定された推論コストでできる限り高い品質を目指すなら、小さいモデルをより長く学習させたいのです。7B モデルが 100 トークン/秒で動作するのは、70B モデルが 12 トークン/秒で動作するよりも実用的です。たとえ 70B が名目上 Chinchilla 最適であってもです。

この区別 — 学習計算量の最適性 vs 推論効率 — は大規模モデルのデプロイにおいて最も重要なエンジニアリングトレードオフの一つです。

A.7 実践的なリソース計画

A.7.1 計算予算から始める

FLOPs での計算予算 $C_\text{budget}$ が与えられたとき、Chinchilla 最適な配分は:

# 擬似コード: Chinchilla 最適リソース計画
def plan_training(budget_flops):
    # C ≈ 6ND かつ D ≈ 20N から:
    # C ≈ 6N × 20N = 120N²
    # N = sqrt(C / 120)
    N = (budget_flops / 120) ** 0.5  # パラメータ数
    D = 20 * N                        # トークン数
    return N, D

$C = 10^{23}$ FLOPs（おおよそ A100 1000 台 × 3 ヶ月）では:

N \approx \sqrt{10^{23} / 120} \approx 2.9 \times 10^{10} \approx 29\text{B パラメータ}

D \approx 20 \times 29\text{B} = 580\text{B トークン}

これは Mistral-22B や初期の Falcon-40B のレジームに近い — フロンティア近傍だが GPT-4 スケールではない領域です。

A.7.2 損失予測

OpenAI 論文は計算量から損失を予測する経験的な公式も提供しています。

L(C) \approx 1.69 \times C^{-0.048}

これで学習前に最終的な損失を予測できます。予測は正確ではありません — 効率フロンティア付近にいることを前提にしています — が、クラスタをコミットする前の GO/NO-GO 判断には有用です。

A.7.3 小モデル vs 大モデル戦略

戦略	強み	弱み
大きいモデル、少ないデータ	高い能力の天井	高コストな推論、未学習の品質
小さいモデル、多いデータ	高速・安価なサービング	低い能力の天井
Chinchilla 最適	学習中の FLOP あたり最低損失	デプロイには最適でない場合がある
意図的に過学習させた小モデル	サービング FLOP あたり最高品質	パラメータあたりの学習コストが高い

正しい選択は、学習コストを最適化するかサービングコストを最適化するかによります。大規模では、推論を継続的に実行するが学習は一度だけのため、サービングコストが通常支配的になります。

A.8 主要結果のまとめ

Scaling Laws: 損失は $N$ 、 $D$ 、 $C$ に対してそれぞれ指数 0.076、0.095、0.050 のべき乗則に従う。
パラメータ見積もり: $N \approx 12 \times L \times d_{\text{model}}^2$ — 1B 以上のモデルで数パーセント以内の精度。
学習計算量: $C_\text{train} \approx 6ND$ — 6 という係数は 2N 順伝播 + 4N 逆伝播から。
推論計算量: $C_\text{inference} \approx 2N \times T_\text{generated}$ 。
Chinchilla 最適性: $D_\text{optimal} \approx 20N$ — ただし多くのデータで学習した小モデルはサービング時にこれを上回ることが多い。
学習時間: $\text{Days} = C / (\text{GPUs} \times \text{TFLOPs} \times 0.4{-}0.5 \times 86400)$ 。
ブロック FLOPs: トークンあたりブロックあたり $24sd^2 + 4s^2 d$ ; 短いコンテキストでは FFN 支配、 $s \approx 4d$ 以上では Attention 支配。

参考文献

Scaling Laws for Neural Language Models — Kaplan et al., OpenAI, 2020. オリジナル論文。
Training Compute-Optimal Large Language Models — Hoffmann et al., DeepMind, 2022. フィールドを修正した Chinchilla 論文。
Scaling Laws for Autoregressive Generative Modeling — Henighan et al., OpenAI, 2020. モダリティをまたいだ拡張スケーリング研究。

計算機なしで 70B ランの学習コストを見積もれるなら、Scaling Laws を本当に理解しています。付録 B ではデコード戦略に踏み込みます。