Chinchilla最適スケーリング — 計算予算に対するモデルサイズとデータ量の最適配分

あなたが100億円の計算予算を持っているとしましょう。GPUを買い、データセンターを借り、大規模言語モデル（LLM）を訓練します。さて、モデルのパラメータ数を2,000億にして少ないデータで学習するのと、パラメータ数を700億に抑えて大量のデータで学習するのと、どちらが賢い選択でしょうか？

2020年まで、業界のコンセンサスは「とにかくモデルを大きくせよ」でした。OpenAIのKaplan et al.によるスケーリング則がそう示していたからです。GPT-3は1,750億パラメータに対して3,000億トークンで学習しました。パラメータ1つあたりわずか1.7トークン — 人間に例えれば、百科事典並みの脳を持ちながら絵本を数冊読んだだけのようなものです。

2022年、DeepMindのHoffmann et al.は「Training Compute-Optimal Large Language Models」（通称Chinchilla論文）で、この常識を覆しました。彼らの結論は明快です — モデルサイズとデータ量は同じ比率で増やすべき であり、最適にはパラメータ1つあたり約20トークンが必要です。この指針に従い、たった700億パラメータのChinchillaが、2,800億パラメータのGopherを全ベンチマークで上回りました。

Chinchillaの知見は、以下のような場面で直接役立ちます。

• LLMの訓練計画: 計算予算が決まったとき、パラメータ数と学習データ量をどう配分すればよいかの定量的な指針が得られます
• コスト最適化: 過剰に大きなモデルを避けることで、推論コストも含めたトータルコストを削減できます
• 研究動向の理解: LLaMA、Mistralなど後続モデルの設計思想（あえてChinchilla則を超えるover-training戦略）を理解する前提知識になります

本記事の内容

• Kaplan et al.のスケーリング則の内容と限界
• Hoffmann et al.の3つの推定手法（IsoFLOP、IsoLoss、パラメトリックフィット）
• Chinchillaスケーリング則 $L(N,D) = E + A/N^\alpha + B/D^\beta$ の数学的構造
• 最適配分 $N_\text{opt} \propto C^a$, $D_\text{opt} \propto C^b$ の導出
• IsoFLOPカーブと設計チャートのPython実装
• Chinchilla以降の展開とover-training戦略

前提知識

この記事を読む前に、以下の記事を読んでおくと理解が深まります。

なぜ「大きければ良い」は間違いだったのか

2020年時点のコンセンサス

2020年の深層学習コミュニティには、ある強固な信念がありました — 計算予算が増えたら、とにかくモデルを大きくすべきだ、というものです。

この信念を裏づけたのが、OpenAIのKaplan et al.「Scaling Laws for Neural Language Models」（2020）です。彼らは大規模な実験を行い、言語モデルの損失（クロスエントロピー）がパラメータ数 $N$、データ量 $D$、計算量 $C$ それぞれに対してべき乗則で減少することを示しました。

パラメータ数に対するスケーリングは次のように表されます。

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

ここで $\alpha_N \approx 0.076$ です。同様に、データ量に対しては $\alpha_D \approx 0.095$、計算量に対しては $\alpha_C \approx 0.050$ と推定されました。

Kaplanの「パラメータ優先」結論

Kaplanの論文で最も影響力を持った結論は、固定計算予算 $C$ の下での最適配分に関するものです。彼らの分析によれば、最適なパラメータ数とデータ量は次のようにスケーリングします。

$$ N_\text{opt} \propto C^{0.73}, \quad D_\text{opt} \propto C^{0.27} $$

指数を見てください。計算予算が10倍になったとき、パラメータ数は $10^{0.73} \approx 5.4$ 倍に増やすべきですが、データ量は $10^{0.27} \approx 1.9$ 倍に増やせば十分 — つまり 予算の大部分をモデルの巨大化に費やすべき という結論です。

この結論に従い、GPT-3（2020）は1,750億パラメータという当時としては桁違いのモデルを、わずか3,000億トークンで訓練しました。パラメータあたりのトークン数はたった1.7です。

身近なアナロジーで考える

この状況を料理人の修行に例えてみましょう。Kaplanの主張は「料理人の能力を上げたければ、調理器具（パラメータ）をとにかく高級にしろ。練習する料理の数（データ）はそこそこで良い」と言っているようなものです。

しかし、直感的に考えると何かおかしくありません？ どんなに素晴らしい包丁を持っていても、実際に100品の料理を作った人と、10品しか作っていない人では、前者の方が腕が良いはずです。Chinchilla論文は、まさにこの直感が正しかったことを定量的に証明しました。

では、Kaplanの分析のどこに問題があったのでしょうか？ 次のセクションでは、Kaplanの実験設計に潜んでいた系統的なバイアスを検証します。

Kaplanの実験設計の問題点

学習トークン数の固定

Kaplanの実験には、後から振り返ると致命的な問題が2つありました。

第一の問題: 不十分な学習トークン数

Kaplanの主要な実験では、各モデルの学習を比較的少ないステップ数で打ち切っていました。具体的には、多くの実験でモデルは最適な学習回数に達する前に学習を止められていたのです。

これは何を意味するでしょうか？ 大きなモデルは、学習の初期段階で小さなモデルより速く損失が下がります。しかし、小さなモデルでも十分なデータを与えて長時間学習すれば、初期の差を縮めることができます。学習を途中で打ち切る実験設計では、「大きなモデルが優れている」という結論にバイアスがかかってしまいます。

第二の問題: 学習率スケジュールの不一致

もう一つの微妙だが重要な問題は、学習率スケジュールでした。Kaplanの実験では、コサイン学習率スケジュールの長さが学習ステップ数と一致していませんでした。学習率の減衰スケジュールは、学習の終盤で損失に大きな影響を与えます。スケジュールが最適でなければ、本来のモデルの能力を過小評価してしまいます。

系統的バイアスの方向

これら2つの問題は、どちらも同じ方向にバイアスをかけます — 大きなモデルに有利、小さなモデル＋大量データに不利 です。

なぜでしょうか？ 大きなモデルは初期の収束が速いため、学習を早期に打ち切っても比較的良い性能を示します。一方、小さなモデルはより多くのデータを「消化」する時間が必要ですが、その時間が与えられていなかったのです。

結果として、Kaplanの実験は「計算予算が増えたらパラメータを増やせ」という結論を過大に支持することになりました。最適なトークン/パラメータ比を過小評価し、実際に必要なデータ量の5倍から10倍少ない値を「最適」と報告してしまったのです。

この系統的なバイアスを認識した上で、Hoffmann et al.はより注意深い実験設計で最適配分を調べ直しました。次のセクションでは、彼らが用いた3つの独立した推定手法を見ていきます。

Hoffmann et al. の3つの推定手法

Chinchilla論文の最も説得力のある点は、3つの全く異なる方法で同じ結論に到達したことです。科学において、独立な手法が一致した結論を出すことは、その結論の信頼性を大きく高めます。

手法1: IsoFLOPプロファイル

最もわかりやすい方法から始めましょう。IsoFLOP（等計算量）プロファイルとは、計算量を固定して、パラメータ数の配分を変えた実験です。

具体的なプロセスは以下の通りです。

1. 計算量 $C$ を固定する（例えば $C = 10^{19}$ FLOPs）
2. 様々なモデルサイズ $N$ を用意する（例: 70M, 150M, 400M, 1B, …）
3. 各モデルの学習データ量を $D = C / (6N)$ として、合計の計算量が $C$ になるようにする
4. 各モデルの最終損失を記録する
5. 損失が最小になる $N$ が、その計算予算に対する最適パラメータ数

この手順を異なる計算量 $C$ で繰り返すと、各予算レベルに対する最適な $(N_\text{opt}, D_\text{opt})$ の組が得られます。結果として、$C$ が2倍になると $N_\text{opt}$ も $D_\text{opt}$ もそれぞれ $\sqrt{2}$ 倍程度になるという関係が浮かび上がりました。

手法2: IsoLoss コンター

第二の方法は、視点を変えて損失を固定し、その損失を達成する $(N, D)$ の組み合わせを調べるものです。

$N$-$D$ 平面上で等損失線（IsoLoss contour）を描くと、各等損失線は「この性能を達成するための $N$ と $D$ のトレードオフ」を示す曲線になります。この曲線上で、$C = 6ND$ が最小になる点が最適配分です。

IsoLoss法は、IsoFLOP法とは全く異なるアプローチですが、得られた最適配分はIsoFLOP法とよく一致しました。

手法3: パラメトリックフィッティング

第三の方法は、最も数学的に洗練されたアプローチです。損失関数に以下のパラメトリックな形を仮定します。

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

ここで $E$, $A$, $B$, $\alpha$, $\beta$ はフィッティングパラメータです。すべての実験データ点（400以上のモデル訓練結果）に対してこの関数をフィッティングし、パラメータの推定値を得ます。

得られたパラメータを使って最適配分を解析的に導出すると、やはりIsoFLOP法、IsoLoss法と同じ結論に到達します。

3手法の一致

3つの手法から得られた結論は驚くほど一致していました。

3つの方法すべてで、指数 $a$ と $b$ はほぼ0.5ずつ — つまりパラメータ数とデータ量は同じ比率で増やすべき、という結論です。これはKaplanの $(a, b) = (0.73, 0.27)$ とは劇的に異なります。

この「均等配分」の結論がどこから来るのかを理解するために、次のセクションではChinchillaの損失関数の数学的構造を詳しく見ていきましょう。

Chinchilla スケーリング則の数学的構造

損失関数の3つの項

Chinchillaのスケーリング則は、言語モデルの損失を3つの独立した項の和として表現します。この形を直感的に理解するところから始めましょう。

試験の点数に例えるとわかりやすいです。テストで100点を取れないのには3つの理由があります — (1) そもそも問題に曖昧さがある（完璧な答えが存在しない）、(2) 勉強した教科書の範囲が狭い（モデルが小さい）、(3) 練習問題を解いた量が足りない（データが少ない）。Chinchillaの損失関数は、まさにこの3つの「失点要因」を数式で表現したものです。

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

各項の意味を見ていきましょう。

第1項: $E$（既約誤差）

$E$ は自然言語そのものが持つ本質的な不確実性です。英語のテキストでは、次の単語を完璧に予測することは原理的に不可能です — 同じ文脈から複数の自然な続き方が存在するからです。どれだけモデルを大きくし、どれだけデータを集めても、この下限を下回ることはできません。Hoffmann et al.の推定値は $E \approx 1.69$（nats単位のクロスエントロピー）です。

第2項: $A / N^\alpha$（モデル能力の限界による誤差）

パラメータ数 $N$ が有限であることから生じる誤差です。推定値は $A \approx 406.4$, $\alpha \approx 0.34$ です。$N$ を増やすとべき乗的に減少しますが、その速度は $\alpha$ で決まります。$\alpha = 0.34$ は比較的緩やかな減少を意味し、パラメータ数を10倍にしても、この項は $10^{0.34} \approx 2.2$ 倍しか改善しません。

第3項: $B / D^\beta$（データ不足による誤差）

訓練データ量 $D$ が有限であることから生じる誤差です。推定値は $B \approx 410.7$, $\beta \approx 0.28$ です。$A$ と $B$ のオーダーが近いことに注目してください — これはモデルの能力不足とデータ不足が、損失に対してほぼ同程度の影響を持つことを示唆しています。

パラメータの推定値まとめ

Hoffmann et al.がフィッティングで得た推定値を整理しておきます。

なぜ加法的な形なのか

損失が $A/N^\alpha + B/D^\beta$ という加法的な形になっていることは重要です。もし損失がパラメータ数とデータ量の積に依存する形（例えば $C / (N \cdot D)^\gamma$）なら、最適配分の計算はまったく異なります。

加法的な分離は、モデルの表現力不足とデータ不足が独立な失点要因である という仮定を反映しています。モデルが十分大きければ、第2項はほぼゼロになり、残る誤差はデータ不足 $B/D^\beta$ と既約誤差 $E$ だけです。逆にデータが十分にあれば、第3項がほぼゼロになり、モデルの表現力が律速になります。

この加法的構造こそが、「パラメータとデータを均等に増やすべき」という結論の数学的な根拠になっています。では、実際にこの損失関数を制約条件のもとで最小化して、最適配分を導出しましょう。

最適配分の数学的導出

最適化問題の定式化

計算予算 $C$ が固定されているとき、パラメータ数 $N$ とデータ量 $D$ の最適な配分を見つける問題は、制約付き最小化問題として定式化できます。

まず、Transformerモデルの訓練に必要な計算量を確認しましょう。$N$ パラメータのモデルを $D$ トークンで訓練するとき、おおよその総FLOPs数は次の近似式で与えられます。

$$ \begin{equation} C \approx 6ND \end{equation} $$

係数6は、各パラメータが1トークンの順伝播で2 FLOPs（乗算と加算）、逆伝播でその約2倍の4 FLOPs、合計6 FLOPsを消費することから来ています。

したがって、最適化問題は次のように書けます。

$$ \begin{equation} \min_{N, D} \left[ E + \frac{A}{N^\alpha} + \frac{B}{D^\beta} \right] \quad \text{subject to} \quad 6ND = C \end{equation} $$

$E$ は定数なので最適化に影響しません。実質的には $A/N^\alpha + B/D^\beta$ を最小化する問題です。

ラグランジュ乗数法による解法

制約付き最適化なので、ラグランジュ乗数法を使います。ラグランジアンを構成します。

$$ \mathcal{L}(N, D, \lambda) = \frac{A}{N^\alpha} + \frac{B}{D^\beta} + \lambda(6ND – C) $$

最適性の必要条件（KKT条件）として、$\mathcal{L}$ の各変数に関する偏微分をゼロとおきます。

まず $N$ で偏微分すると:

$$ \frac{\partial \mathcal{L}}{\partial N} = -\frac{\alpha A}{N^{\alpha+1}} + 6\lambda D = 0 $$

$\lambda$ について解くと:

$$ \begin{equation} \lambda = \frac{\alpha A}{6 D N^{\alpha+1}} \end{equation} $$

次に $D$ で偏微分すると:

$$ \frac{\partial \mathcal{L}}{\partial D} = -\frac{\beta B}{D^{\beta+1}} + 6\lambda N = 0 $$

同様に $\lambda$ について解くと:

$$ \begin{equation} \lambda = \frac{\beta B}{6 N D^{\beta+1}} \end{equation} $$

$\lambda$ の消去と最適比率の導出

式(4)と式(5)を等置して $\lambda$ を消去します。

$$ \frac{\alpha A}{6 D N^{\alpha+1}} = \frac{\beta B}{6 N D^{\beta+1}} $$

両辺に $6 D N$ を掛けて整理すると:

$$ \frac{\alpha A}{N^{\alpha}} = \frac{\beta B}{D^{\beta}} $$

この式は非常に重要な意味を持ちます。左辺はモデルサイズの誤差項 $A/N^\alpha$ に $\alpha$ を掛けたもの、右辺はデータ不足の誤差項 $B/D^\beta$ に $\beta$ を掛けたものです。最適配分では、各項の「限界改善度」が等しくなる のです。これは経済学の限界費用均等化の原理と同じ構造です。

この条件式を $D$ について解きましょう。

$$ D^\beta = \frac{\beta B}{\alpha A} \cdot N^\alpha $$

両辺を $1/\beta$ 乗すると:

$$ \begin{equation} D = \left(\frac{\beta B}{\alpha A}\right)^{1/\beta} N^{\alpha/\beta} \end{equation} $$

計算量制約との組み合わせ

式(6)を制約 $C = 6ND$ に代入します。

$$ C = 6N \cdot \left(\frac{\beta B}{\alpha A}\right)^{1/\beta} N^{\alpha/\beta} $$

$N$ についてまとめると:

$$ C = 6\left(\frac{\beta B}{\alpha A}\right)^{1/\beta} N^{1 + \alpha/\beta} $$

$N$ について解くと:

$$ N_\text{opt} = \left[\frac{C}{6} \cdot \left(\frac{\alpha A}{\beta B}\right)^{1/\beta}\right]^{\frac{\beta}{\alpha + \beta}} $$

つまり、最適パラメータ数は計算量 $C$ のべき乗でスケーリングし、その指数は:

$$ \begin{equation} N_\text{opt} \propto C^{a}, \quad a = \frac{\beta}{\alpha + \beta} \end{equation} $$

同様に、$D_\text{opt} = C / (6 N_\text{opt})$ から:

$$ \begin{equation} D_\text{opt} \propto C^{b}, \quad b = \frac{\alpha}{\alpha + \beta} \end{equation} $$

数値の代入と解釈

Hoffmann et al.の推定値 $\alpha = 0.34$, $\beta = 0.28$ を代入してみましょう。

$$ a = \frac{0.28}{0.34 + 0.28} = \frac{0.28}{0.62} \approx 0.452 $$

$$ b = \frac{0.34}{0.34 + 0.28} = \frac{0.34}{0.62} \approx 0.548 $$

そして $a + b = 1$ であることが確認できます（制約 $C = 6ND$ から自明）。

Kaplanの値 $(a, b) = (0.73, 0.27)$ と比較してください。Chinchillaでは $a \approx 0.45$, $b \approx 0.55$ であり、パラメータ数とデータ量にほぼ均等に計算予算を配分すべきだということがわかります。むしろ、データ量の方がわずかに速くスケーリングすべきとすら言えます。

最適トークン/パラメータ比

最適な $D/N$ 比もスケーリングの関数として求まります。

$$ \frac{D_\text{opt}}{N_\text{opt}} \propto C^{b – a} = C^{\frac{\alpha – \beta}{\alpha + \beta}} $$

$\alpha > \beta$ なので、$b – a > 0$ であり、計算予算が大きいほどパラメータあたりのトークン数は（ゆっくりと）増加します。しかし実用的な範囲では、Hoffmann et al.は以下の経験則を推奨しています。

$$ \begin{equation} D_\text{opt} \approx 20 \times N_\text{opt} \end{equation} $$

すなわち、パラメータ1つあたり約20トークンが最適です。この「20倍ルール」はChinchillaスケーリング則の最も実用的な要約と言えるでしょう。

ここまでで数学的な導出が完了しました。次のセクションでは、この理論が実際のモデル比較でどのように検証されたかを見ていきます。

具体的な計算: C = 6ND と最適配分表

FLOPs概算の具体例

理論を具体的な数字で確認しましょう。GPT-3の訓練を例に取ります。

GPT-3は $N = 175 \times 10^9$（1,750億パラメータ）を $D = 300 \times 10^9$（3,000億トークン）で訓練しました。計算量は:

$$ C = 6 \times 175 \times 10^9 \times 300 \times 10^9 = 3.15 \times 10^{23} \text{ FLOPs} $$

この計算量でChinchilla則に従って最適配分すると、$D/N \approx 20$ の条件と $C = 6ND$ を連立して:

$C = 6N \cdot 20N = 120 N^2$ より:

$$ N_\text{opt} = \sqrt{\frac{C}{120}} = \sqrt{\frac{3.15 \times 10^{23}}{120}} \approx 5.1 \times 10^{10} $$

つまり約510億パラメータです。対応するデータ量は:

$$ D_\text{opt} = 20 \times N_\text{opt} \approx 1.02 \times 10^{12} \text{ トークン} $$

約1兆トークンです。GPT-3は1,750億パラメータ/3,000億トークンでしたが、Chinchilla最適は510億パラメータ/1兆トークンとなり、パラメータ数を1/3に減らしてデータ量を3倍以上にすべきだったことがわかります。

予算別の最適配分表

様々な計算予算に対するChinchilla最適配分を表にまとめます。

GPU-hours の概算は、A100 (312 TFLOPS, FP16) の実効利用率を約30%として計算しています。この表を使えば、計算予算が決まった時点で、適切なモデルサイズと必要なデータ量をすぐに見積もれます。

Chinchilla vs Gopher: 実証的な検証

Hoffmann et al.は理論の正しさを実証するために、Gopher（2,800億パラメータ, 3,000億トークン）と同じ計算予算を使って、Chinchilla最適に従うモデルを訓練しました。

同じ計算量で、4倍小さなモデルが全ベンチマークで勝利しました。特にMMLU（大規模マルチタスク言語理解）では7.6ポイントの差がつきました。これは単なる統計的ゆらぎではなく、配分の最適化が性能に大きな影響を及ぼすことの明確な証拠です。

さらに重要なのは推論コストへの影響です。Chinchillaは70Bパラメータ — Gopherの1/4のサイズです。つまり推論時のメモリ使用量は約1/4、推論速度は約4倍です。同じ性能を達成しながら、推論コストを大幅に削減できるのです。

この実験結果は、理論が予測した最適配分の正しさを鮮やかに裏付けました。次のセクションでは、Pythonを使ってIsoFLOPカーブや最適配分をプログラムで計算・可視化する方法を実装していきます。

Pythonによるスケーリング則の実装と可視化

Chinchilla損失関数の実装

まず、Chinchillaの損失関数とラグランジュ乗数法による最適配分の計算をPythonで実装します。

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import minimize_scalar

# Chinchillaスケーリング則のパラメータ（Hoffmann et al. 2022 の推定値）
E = 1.69      # 既約誤差
A = 406.4     # モデルサイズ係数
B = 410.7     # データ量係数
ALPHA = 0.34  # モデルサイズ指数
BETA = 0.28   # データ量指数


def chinchilla_loss(N, D):
    """Chinchillaスケーリング則による損失を計算する"""
    return E + A / (N ** ALPHA) + B / (D ** BETA)


def optimal_allocation(C):
    """
    計算予算Cに対するChinchilla最適配分を解析的に求める

    Parameters
    ----------
    C : float
        計算予算（FLOPs）

    Returns
    -------
    N_opt : float
        最適パラメータ数
    D_opt : float
        最適トークン数
    """
    # C = 6NDの制約下で、D = C/(6N) を代入し、Nについて最小化
    # 解析解: N_opt = sqrt(C / 120)（D/N ≈ 20の近似）
    # より正確には、ラグランジュ乗数法の解を使用
    G = (BETA * B / (ALPHA * A)) ** (1 / BETA)
    N_opt = (C / (6 * G)) ** (BETA / (ALPHA + BETA))
    D_opt = C / (6 * N_opt)
    return N_opt, D_opt


# 具体的な計算量での最適配分を表示
compute_budgets = [1e18, 1e19, 1e20, 1e21, 1e22, 1e23, 1e24]
print("=" * 72)
print(f"{'C (FLOPs)':>12}  {'N_opt':>12}  {'D_opt':>12}  {'D/N':>6}  {'Loss':>8}")
print("=" * 72)
for C in compute_budgets:
    N_opt, D_opt = optimal_allocation(C)
    loss = chinchilla_loss(N_opt, D_opt)
    print(f"{C:>12.1e}  {N_opt:>12.2e}  {D_opt:>12.2e}  {D_opt/N_opt:>6.1f}  {loss:>8.4f}")
print("=" * 72)

このコードは、解析的に導出した最適配分の公式をそのまま実装しています。各計算予算に対して、最適なパラメータ数 $N_\text{opt}$ とデータ量 $D_\text{opt}$ を計算し、対応する損失値も表示します。出力表を見ると、計算予算が10倍になるごとに $N_\text{opt}$ と $D_\text{opt}$ がそれぞれ約3.2倍ずつ増加し（$10^{0.5} \approx 3.16$）、$D/N$ 比はほぼ一定（約20）に保たれていることが確認できます。これは理論的な予測と完全に一致しています。

IsoFLOPカーブの描画

次に、Chinchilla論文の最も象徴的なグラフである IsoFLOPカーブ を描きます。各計算予算レベルで、パラメータ数を横軸、損失を縦軸にプロットしたものです。

import numpy as np
import matplotlib.pyplot as plt

# パラメータ（前のブロックと同じ値を使用）
E = 1.69
A = 406.4
B = 410.7
ALPHA = 0.34
BETA = 0.28


def chinchilla_loss(N, D):
    """Chinchillaスケーリング則による損失"""
    return E + A / (N ** ALPHA) + B / (D ** BETA)


def optimal_allocation(C):
    """計算予算Cに対する最適配分"""
    G = (BETA * B / (ALPHA * A)) ** (1 / BETA)
    N_opt = (C / (6 * G)) ** (BETA / (ALPHA + BETA))
    D_opt = C / (6 * N_opt)
    return N_opt, D_opt


# IsoFLOPカーブの計算
compute_levels = [1e18, 1e19, 1e20, 1e21, 1e22, 1e23]
colors = ['#e74c3c', '#e67e22', '#f1c40f', '#2ecc71', '#3498db', '#9b59b6']
N_range = np.logspace(7, 12, 300)

fig, ax = plt.subplots(figsize=(10, 7))

for C, color in zip(compute_levels, colors):
    losses = []
    valid_N = []
    for N in N_range:
        D = C / (6 * N)
        if D > 0:
            loss = chinchilla_loss(N, D)
            losses.append(loss)
            valid_N.append(N)
    losses = np.array(losses)
    valid_N = np.array(valid_N)

    # 損失が発散する領域を除外
    mask = losses < 10
    ax.plot(valid_N[mask], losses[mask], color=color,
            linewidth=2, label=f'C = {C:.0e} FLOPs')

    # 最適点をマーク
    N_opt, D_opt = optimal_allocation(C)
    L_opt = chinchilla_loss(N_opt, D_opt)
    ax.scatter([N_opt], [L_opt], color=color, s=120, zorder=5,
               edgecolors='black', linewidths=1.5)

ax.set_xscale('log')
ax.set_xlabel('Parameters (N)', fontsize=13)
ax.set_ylabel('Loss (Cross-Entropy, nats)', fontsize=13)
ax.set_title('IsoFLOP Curves: Loss vs Parameters for Fixed Compute Budget',
             fontsize=14, fontweight='bold')
ax.legend(fontsize=11, loc='upper right')
ax.set_ylim(1.6, 5.0)
ax.grid(True, alpha=0.3, which='both')
plt.tight_layout()
plt.savefig('isoflop_curves.png', dpi=150, bbox_inches='tight')
plt.show()

このIsoFLOPカーブは、Chinchilla論文の核心を1枚の図で示しています。各色の曲線は異なる計算予算レベルを表し、黒枠の丸いマーカーが各予算に対する最適パラメータ数を示しています。

グラフから3つの重要な特徴が読み取れます。第一に、各カーブにはU字型の「谷」があり、パラメータが少なすぎても多すぎても損失が増大します。左側（パラメータが少なすぎる）ではモデルの表現力不足、右側（パラメータが多すぎる）ではデータ不足が損失を支配しています。第二に、最適点を結ぶと右下がりの直線（対数スケールで）になり、計算予算の増加とともに最適パラメータ数が系統的に増えることがわかります。第三に、最適点を外れた場合のペナルティは右側（パラメータ過多）の方が急峻であり、モデルを大きくしすぎるコストの方がデータを増やしすぎるコストよりも大きいことが視覚的に確認できます。

Kaplan vs Chinchilla: 最適配分の比較

Kaplan則とChinchilla則で最適配分がどれほど異なるかを可視化します。

import numpy as np
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 3, figsize=(18, 5))

C_range = np.logspace(18, 25, 100)

# --- パネル1: 最適パラメータ数の比較 ---
ax = axes[0]
N_kaplan = (C_range / 120) ** 0.73 * 1e-3   # Kaplan: N ∝ C^0.73（比例定数は概算）
N_chinchilla = np.sqrt(C_range / 120)         # Chinchilla: N ∝ C^0.5

ax.loglog(C_range, N_kaplan, 'b--', linewidth=2, label='Kaplan ($N \\propto C^{0.73}$)')
ax.loglog(C_range, N_chinchilla, 'r-', linewidth=2, label='Chinchilla ($N \\propto C^{0.50}$)')
ax.set_xlabel('Compute Budget C (FLOPs)', fontsize=12)
ax.set_ylabel('Optimal Parameters $N_{opt}$', fontsize=12)
ax.set_title('Optimal Model Size', fontsize=13, fontweight='bold')
ax.legend(fontsize=11)
ax.grid(True, alpha=0.3, which='both')

# --- パネル2: 最適データ量の比較 ---
ax = axes[1]
D_kaplan = C_range / (6 * N_kaplan)
D_chinchilla = C_range / (6 * N_chinchilla)

ax.loglog(C_range, D_kaplan, 'b--', linewidth=2, label='Kaplan ($D \\propto C^{0.27}$)')
ax.loglog(C_range, D_chinchilla, 'r-', linewidth=2, label='Chinchilla ($D \\propto C^{0.50}$)')
ax.set_xlabel('Compute Budget C (FLOPs)', fontsize=12)
ax.set_ylabel('Optimal Tokens $D_{opt}$', fontsize=12)
ax.set_title('Optimal Data Size', fontsize=13, fontweight='bold')
ax.legend(fontsize=11)
ax.grid(True, alpha=0.3, which='both')

# --- パネル3: D/N比の比較 ---
ax = axes[2]
ax.loglog(C_range, D_kaplan / N_kaplan, 'b--', linewidth=2, label='Kaplan')
ax.loglog(C_range, D_chinchilla / N_chinchilla, 'r-', linewidth=2, label='Chinchilla')
ax.axhline(y=20, color='green', linestyle=':', linewidth=2, alpha=0.7,
           label='D/N = 20 (Chinchilla rule of thumb)')
ax.set_xlabel('Compute Budget C (FLOPs)', fontsize=12)
ax.set_ylabel('Tokens per Parameter (D/N)', fontsize=12)
ax.set_title('Data-to-Parameter Ratio', fontsize=13, fontweight='bold')
ax.legend(fontsize=10)
ax.grid(True, alpha=0.3, which='both')

plt.tight_layout()
plt.savefig('kaplan_vs_chinchilla.png', dpi=150, bbox_inches='tight')
plt.show()

3つのパネルから、KaplanとChinchillaの違いが一目瞭然です。左パネルでは、Kaplanが計算量の増加に対してモデルサイズを急激に増やすのに対し、Chinchillaは緩やかに増やしています。中央パネルでは逆のパターンが見られ、Chinchillaはデータ量をKaplanよりも遥かに速く増やしています。右パネルの $D/N$ 比が最も示唆的で、Kaplanでは計算量が増えるほど $D/N$ が減少する（巨大モデルをますます少ないデータで学習する）のに対し、Chinchillaでは約20の一定値を保っています。

スケーリング則のフィッティング

実験データからパラメータをフィッティングする手順も実装しておきましょう。実際の論文では400以上のモデルの訓練データを使いますが、ここでは合成データでフィッティングの流れを示します。

import numpy as np
from scipy.optimize import curve_fit
import matplotlib.pyplot as plt

# Chinchilla損失関数の定義（フィッティング用）
def loss_model(X, E, A, B, alpha, beta):
    """
    パラメトリック損失関数

    Parameters
    ----------
    X : array-like, shape (2, n)
        X[0] = N (パラメータ数), X[1] = D (トークン数)
    E, A, B, alpha, beta : float
        フィッティングパラメータ
    """
    N, D = X
    return E + A / (N ** alpha) + B / (D ** beta)


# 合成データの生成（真の値にノイズを加える）
np.random.seed(42)
n_samples = 200

# ランダムなN, Dの組み合わせ
log_N = np.random.uniform(7, 11, n_samples)  # 10^7 〜 10^11
log_D = np.random.uniform(8, 13, n_samples)  # 10^8 〜 10^13
N_data = 10 ** log_N
D_data = 10 ** log_D

# 真のパラメータで損失を計算し、ノイズを加える
E_true, A_true, B_true = 1.69, 406.4, 410.7
alpha_true, beta_true = 0.34, 0.28
L_true = E_true + A_true / (N_data ** alpha_true) + B_true / (D_data ** beta_true)
noise = np.random.normal(0, 0.02, n_samples)
L_data = L_true + noise

# フィッティング
X_data = np.vstack([N_data, D_data])
p0 = [1.5, 400, 400, 0.3, 0.3]  # 初期推定値
bounds = ([0, 0, 0, 0, 0], [5, 1000, 1000, 1, 1])  # パラメータの範囲

popt, pcov = curve_fit(loss_model, X_data, L_data, p0=p0, bounds=bounds,
                       maxfev=10000)
E_fit, A_fit, B_fit, alpha_fit, beta_fit = popt
perr = np.sqrt(np.diag(pcov))  # 標準誤差

print("フィッティング結果:")
print(f"  E     = {E_fit:.4f} ± {perr[0]:.4f}  (真値: {E_true})")
print(f"  A     = {A_fit:.2f} ± {perr[1]:.2f}  (真値: {A_true})")
print(f"  B     = {B_fit:.2f} ± {perr[2]:.2f}  (真値: {B_true})")
print(f"  alpha = {alpha_fit:.4f} ± {perr[3]:.4f}  (真値: {alpha_true})")
print(f"  beta  = {beta_fit:.4f} ± {perr[4]:.4f}  (真値: {beta_true})")

# フィッティングの良さを可視化
L_pred = loss_model(X_data, *popt)
fig, ax = plt.subplots(figsize=(7, 7))
ax.scatter(L_data, L_pred, alpha=0.4, s=20, color='steelblue')
lims = [min(L_data.min(), L_pred.min()), max(L_data.max(), L_pred.max())]
ax.plot(lims, lims, 'r--', linewidth=2, label='Perfect fit')
ax.set_xlabel('Observed Loss', fontsize=13)
ax.set_ylabel('Predicted Loss (fitted model)', fontsize=13)
ax.set_title('Parametric Fit Quality: Predicted vs Observed', fontsize=14,
             fontweight='bold')
ax.legend(fontsize=12)
ax.grid(True, alpha=0.3)
ax.set_aspect('equal')
plt.tight_layout()
plt.savefig('fit_quality.png', dpi=150, bbox_inches='tight')
plt.show()

フィッティング結果を見ると、推定値が真の値に非常に近く、5つのパラメータが安定して復元されていることがわかります。散布図では、予測値と観測値がほぼ対角線上に乗っており、パラメトリックモデル $L(N,D) = E + A/N^\alpha + B/D^\beta$ が損失の振る舞いを良く捉えていることが確認できます。実際の論文ではノイズがより大きく、またデータ点の分布も偏りがあるため、ブートストラップや交差検証による頑健性の確認が重要になります。

実際のモデルの配置図

最後に、実際のLLMがChinchilla最適線に対してどこに位置するかを可視化します。

import numpy as np
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(10, 8))

# 実際のモデルのデータ
models = {
    'GPT-3':       {'N': 175e9,  'D': 300e9,   'color': '#e74c3c', 'marker': 'o'},
    'Gopher':      {'N': 280e9,  'D': 300e9,   'color': '#e67e22', 'marker': 's'},
    'Chinchilla':  {'N': 70e9,   'D': 1.4e12,  'color': '#2ecc71', 'marker': '*'},
    'LLaMA-7B':    {'N': 7e9,    'D': 1e12,    'color': '#3498db', 'marker': '^'},
    'LLaMA-65B':   {'N': 65e9,   'D': 1.4e12,  'color': '#2980b9', 'marker': '^'},
    'LLaMA2-70B':  {'N': 70e9,   'D': 2e12,    'color': '#1abc9c', 'marker': 'D'},
    'Mistral-7B':  {'N': 7e9,    'D': 8e12,    'color': '#9b59b6', 'marker': 'v'},
    'PaLM':        {'N': 540e9,  'D': 780e9,   'color': '#f39c12', 'marker': 'p'},
}

for name, info in models.items():
    ax.scatter(info['N'], info['D'], s=200, color=info['color'],
               marker=info['marker'], edgecolors='black', linewidths=1,
               zorder=5, label=name)

# Chinchilla最適線 (D = 20N)
N_line = np.logspace(8, 12, 100)
D_optimal = 20 * N_line
ax.plot(N_line, D_optimal, 'k--', linewidth=2, alpha=0.7,
        label='Chinchilla optimal (D = 20N)')

# 領域の塗りつぶし
ax.fill_between(N_line, D_optimal, 1e14, alpha=0.08, color='green',
                label='Over-trained region (D/N > 20)')
ax.fill_between(N_line, 1e6, D_optimal, alpha=0.08, color='red',
                label='Under-trained region (D/N < 20)')

ax.set_xscale('log')
ax.set_yscale('log')
ax.set_xlabel('Parameters (N)', fontsize=13)
ax.set_ylabel('Training Tokens (D)', fontsize=13)
ax.set_title('LLM Landscape: Chinchilla Optimal vs Actual Models',
             fontsize=14, fontweight='bold')
ax.legend(fontsize=9, loc='upper left', ncol=2)
ax.set_xlim(1e9, 1e12)
ax.set_ylim(1e10, 1e14)
ax.grid(True, alpha=0.3, which='both')
plt.tight_layout()
plt.savefig('llm_landscape.png', dpi=150, bbox_inches='tight')
plt.show()

この「LLM地図」から、言語モデルの歴史的な変遷が読み取れます。GPT-3とGopherは黒い破線（Chinchilla最適線）の下にあり、明確にunder-trained（データ不足）です。パラメータに対してトークン数が圧倒的に少なく、モデルの潜在能力を十分に引き出せていません。Chinchillaはほぼ最適線上に位置しており、同じ計算量のGopherを大きく上回った理由が視覚的に理解できます。

一方、LLaMA系列やMistralは最適線の上側（over-trained領域）に位置しています。これは意図的な選択であり、Chinchilla以降の重要なトレンドです。次のセクションで、このover-training戦略の合理性を考察します。

Chinchilla以降の展開

Over-training 戦略: なぜChinchilla則を「破る」のか

Chinchillaの結論は「計算予算を最も効率的に使うなら、パラメータ数とデータ量を均等に増やせ」でした。しかし、2023年以降のLLM開発では、あえてこの法則を「破る」over-training戦略が主流になっています。

Meta のLLaMA（2023）は7Bパラメータを1兆トークンで訓練しました。Chinchilla最適では7Bモデルには140Bトークンで十分なはずですが、実際には7倍以上のデータを使っています。LLaMA 2の70Bモデルも2兆トークンで訓練され、最適の20倍ルールを超えています。

この一見非効率に見える戦略には、合理的な理由があります。

推論コストの支配

LLMのライフサイクルコストを考えると、訓練コストは一度きりですが、推論コストはモデルを使い続ける限り発生し続けます。商用LLMでは、推論コストが訓練コストの数十倍から数百倍に達することもあります。

推論コストはパラメータ数にほぼ比例します。したがって、多少の訓練効率を犠牲にしてでも、パラメータ数を減らした方がトータルコストは低くなります。7Bモデルを「over-train」して70Bモデルの性能に近づけられるなら、推論コストは1/10で済むのです。

推論込みのスケーリング則

この考え方を数式で表現すると、訓練コスト $C_\text{train} = 6ND$ に加えて、推論コスト $C_\text{infer} \propto N \cdot T_\text{infer}$（$T_\text{infer}$ は推論トークン総数）を考慮した総コストは:

$$ C_\text{total} = 6ND + \gamma \cdot N \cdot T_\text{infer} $$

ここで $\gamma$ は推論1トークンあたりのFLOPs定数です。$T_\text{infer}$ が十分大きい場合、$N$ を小さくする圧力が強くなり、Chinchilla最適より小さなモデルに多くのデータを流す戦略が最適になります。

新しいスケーリング則の提案

Sardana & Frankle (2023) は、推論需要を考慮した修正スケーリング則を提案しました。推論トークン数 $T_\text{infer}$ を明示的にパラメータとして含め、最適パラメータ数を:

$$ N_\text{opt}(C, T_\text{infer}) \propto C^a \cdot f(T_\text{infer}) $$

のように修正します。$T_\text{infer}$ が大きいほど $N_\text{opt}$ は小さくなり、代わりにデータ量を増やしてover-trainingする方が合理的になります。

データの壁

Over-training戦略にはもう1つの現実的な制約があります — データの壁（data wall） です。

インターネット上の高品質な英語テキストは、推定で5兆〜10兆トークン程度です。Chinchilla最適に従って175Bパラメータのモデルを訓練しようとすると、3.5兆トークンが必要になります。しかし、1兆パラメータのモデルをChinchilla最適で訓練するには20兆トークンが必要で、これは現存するデータでは足りません。

この問題に対して、現在は合成データ（AIが生成したデータ）や、マルチモーダルデータ（画像、動画、コードなど）でテキストデータを補完するアプローチが活発に研究されています。データの品質をどう維持するかが、次世代のスケーリングにおける最大の課題です。

エポック数とデータ繰り返しの影響

データの壁に対するもう1つのアプローチは、同じデータを複数回学習する（マルチエポック学習）ことです。Muennighoff et al. (2023) は、データの繰り返しが性能に与える影響を体系的に調査し、4エポック程度までは性能劣化がほとんどないことを示しました。ただし、それ以上のエポック数では過学習のリスクが高まり、正則化の工夫が必要になります。

これはChinchillaの枠組みを拡張する上で重要な知見です。Chinchilla則は「ユニークなトークン数」を前提としていますが、データの繰り返しによる有効データ量の減衰を考慮した修正スケーリング則の開発は、今後の重要な研究課題です。

ここまでの議論を踏まえて、最後にChinchillaスケーリング則の要点と今後の学習ロードマップをまとめましょう。

まとめ

本記事では、Chinchilla最適スケーリングについて解説しました。

• Kaplanの限界: Kaplan et al.のスケーリング則は、学習の早期打ち切りと学習率スケジュールの問題により、「パラメータ数を優先すべき」（$N \propto C^{0.73}$）という偏った結論を導いていた
• Chinchillaの3手法: Hoffmann et al.はIsoFLOP、IsoLoss、パラメトリックフィットの3つの独立な手法で、パラメータとデータを均等に増やすべき（$a \approx b \approx 0.5$）という結論に到達した
• 数学的根拠: 損失関数 $L(N,D) = E + A/N^\alpha + B/D^\beta$ をラグランジュ乗数法で最適化すると、$N_\text{opt} \propto C^{\beta/(\alpha+\beta)}$, $D_\text{opt} \propto C^{\alpha/(\alpha+\beta)}$ が導かれ、「20倍ルール」（$D \approx 20N$）が得られる
• 実証: 70BパラメータのChinchillaが280BパラメータのGopherを全ベンチマークで上回り、理論の正しさが実証された
• Chinchilla以降: 推論コストを考慮したover-training戦略（LLaMA、Mistral）やデータの壁の問題により、Chinchilla則はさらに拡張されつつある

Chinchillaスケーリング則は「計算予算をどう使うか」という問いに対する出発点です。推論コスト、データの質、マルチモーダル学習など、考慮すべき要素は増え続けていますが、$L(N,D)$ の基本構造とラグランジュ乗数法による最適化というフレームワークは、これらの拡張においても有効です。

次のステップとして、以下の記事も参考にしてください。