GPT-2→GPT-3→GPT-4の進化 — アーキテクチャとスケーリングの変遷を辿る

1.17億パラメータから1兆超へ — わずか5年の間に、GPTシリーズのパラメータ数は 約1万倍 に膨れ上がりました。驚くべきことに、モデルの基本設計である Transformer Decoder は GPT-1 から GPT-4 までほぼ変わっていません。つまり「同じ設計図を使って、建物の規模だけを桁違いに拡大した」ようなものです。

それなのに、GPT-1 は文法的に正しい文を生成する程度だったものが、GPT-4 では司法試験の上位10%に入り、複雑な数学の証明を行い、画像を理解してコードを書くようになりました。なぜ大きくするだけで「知能」と呼びたくなるような能力が創発するのでしょうか？

この問いに答えるためには、各世代で 何が変わり、何が変わらなかったのか を正確に追う必要があります。GPTシリーズの進化を理解することは、以下の場面で直接役立ちます。

• LLM の開発・ファインチューニング: モデルの設計思想を理解していれば、LoRA の挿入位置やハイパーパラメータの選択に根拠を持てます
• AI の能力限界の理解: スケーリング則を知ることで、「次世代のモデルに何ができて何ができないか」を合理的に予測できます
• 研究動向の把握: GPT の設計判断は後続の LLaMA、Mistral、Gemini などに直接影響しており、GPT の歴史を知ることは LLM 研究全体の文脈を理解する鍵になります

本記事の内容

• GPT-1 の設計思想と「事前学習 + ファインチューニング」パラダイム
• GPT-2 の Zero-shot 学習と Pre-Norm への移行
• GPT-3 の Few-shot / In-context Learning の確立
• InstructGPT / ChatGPT における RLHF の導入
• GPT-4 のマルチモーダル化と安全性強化
• スケーリング則の数学的理解と Chinchilla 最適化
• Python による実験: スケーリング則の可視化とモデルサイズ比較

前提知識

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

まずは全ての始まりとなった GPT-1 のアーキテクチャから見ていきましょう。

GPT-1（2018年）— 事前学習という革命

なぜ GPT-1 が画期的だったのか

2018年以前の自然言語処理（NLP）は、タスクごとに専用モデルを設計し、タスク固有のデータで一から学習するのが主流でした。感情分析には感情分析用のモデル、機械翻訳には機械翻訳用のモデル、というように個別のアーキテクチャと大量のラベル付きデータが必要だったのです。

人間の言語学習を思い出してみてください。私たちは赤ちゃんの頃から膨大な量の言葉を「ただ聞いている」だけで言語の構造を身につけ、その上で少しの指導（ファインチューニング）で読み書きや会話のルールを学びます。まず大量の言語データで「言語そのもの」を学び、その後に個別のタスクに適応する — GPT-1 はこの人間の学習過程をニューラルネットワークで再現した最初の成功例でした。

OpenAI の Radford et al. が 2018 年に発表した論文 “Improving Language Understanding by Generative Pre-Training” は、まさにこのアプローチを提案しました。

アーキテクチャの詳細

GPT-1 のアーキテクチャは、Vaswani et al. (2017) の Transformer のうち Decoder 部分だけ を取り出したものです。具体的な構成は以下の通りです。

各 Transformer ブロックの処理を数式で書くと、入力トークン系列 $\bm{x} = (x_1, x_2, \ldots, x_n)$ に対して、まずトークン埋め込みと位置埋め込みを加算します。

$$ \bm{h}_0 = \bm{W}_e \bm{x} + \bm{W}_p $$

ここで $\bm{W}_e$ はトークン埋め込み行列、$\bm{W}_p$ は学習可能な位置埋め込み行列です。GPT-1 では正弦波ではなく学習で獲得する位置埋め込みを採用しました。

次に、各 Transformer ブロック $l = 1, 2, \ldots, 12$ で以下の処理を適用します。

$$ \bm{a}_l = \text{MultiHead}(\text{LayerNorm}(\bm{h}_{l-1})) + \bm{h}_{l-1} $$

ここでの LayerNorm は Post-Norm 形式です。つまり、実際の計算順序としては、まず Multi-Head Attention を適用し、残差接続の後に Layer Normalization を行います。

$$ \bm{h}_l = \text{FFN}(\text{LayerNorm}(\bm{a}_l)) + \bm{a}_l $$

GPT-1 では Post-Norm 構成（Attention → Add → LayerNorm → FFN → Add → LayerNorm）を採用しています。この構成は学習が深い層では不安定になりやすいという課題があり、後の GPT-2 で改善されることになります。

事前学習: 次トークン予測

GPT-1 の事前学習タスクは極めてシンプルです。テキストの「次の単語を予測する」こと、すなわち 自己回帰言語モデリング です。

与えられたトークン列 $(x_1, x_2, \ldots, x_{k-1})$ から次のトークン $x_k$ を予測する確率を最大化します。

$$ L_\text{LM}(\mathcal{U}) = \sum_{i} \log P(x_i \mid x_{i-k}, \ldots, x_{i-1}; \Theta) $$

ここで $\mathcal{U}$ は教師なしコーパス、$k$ はコンテキストウィンドウサイズ、$\Theta$ はモデルパラメータです。

学習データには BooksCorpus を使用しました。これは約7,000冊の未出版書籍から成る約5GBのテキストデータセットです。書籍データを選んだ理由は、長い連続テキストが含まれているため、モデルが長距離の依存関係を学習しやすいからです。

ファインチューニング

GPT-1 の特徴は、事前学習後に各タスクに合わせた ファインチューニング を行う2段階アプローチにあります。タスクの入力をテキスト形式に変換し、事前学習済みモデルの上に分類ヘッドを追加して追加学習を行います。

ファインチューニング時の損失関数は、タスク固有の損失 $L_\text{task}$ と言語モデルの損失 $L_\text{LM}$ の混合です。

$$ L = L_\text{task} + \lambda \cdot L_\text{LM} $$

$\lambda$ は補助損失の重みで、言語モデルとしての汎化能力を維持しつつタスクに適応する役割を果たします。

GPT-1 は、12のNLPベンチマークのうち9つで当時のState-of-the-Artを達成しました。しかし、GPT-1 にはまだ大きな制約がありました。各タスクごとにファインチューニングが必要だったのです。ファインチューニング用のラベル付きデータが少ないタスクには対応しにくいという問題がありました。

この「タスクごとにファインチューニングが必要」という制約を取り払おうとしたのが、翌年の GPT-2 です。

GPT-2（2019年）— Zero-shot学習の発見

パラダイムシフト: ファインチューニング不要の世界

GPT-1 が示した「事前学習 + ファインチューニング」は強力でしたが、新しいタスクに取り組むたびにラベル付きデータと追加学習が必要でした。人間は「翻訳して」「要約して」と言われれば、特別な訓練なしにそのタスクを実行できます。モデルにもそれができないか — これが GPT-2 の問いでした。

GPT-2 の核心的な発見は、十分に大きなモデルを十分に多様なデータで学習させれば、タスクの指示をテキストとして与えるだけで、ファインチューニングなしにそのタスクを遂行できる というものです。これを Zero-shot学習 と呼びます。

例えば、翻訳タスクを行いたい場合、従来は翻訳用のファインチューニングが必要でした。GPT-2 では、入力テキストに translate English to French: という指示を含めるだけで、モデルが翻訳を実行するのです。モデルは「タスクをテキストの一部として理解する」能力を獲得していました。

アーキテクチャの変更点

GPT-2 のアーキテクチャは GPT-1 の拡大版ですが、いくつかの重要な変更が加えられています。

パラメータ数は約 13倍 に増加しました。しかし、単に大きくしただけではありません。アーキテクチャに2つの重要な変更が加えられました。

変更1: Pre-Norm（Pre-Layer Normalization）

GPT-1 では Post-Norm 構成を採用していました。これは各サブレイヤの出力に残差接続を加えた後に LayerNorm を適用する形式です。

$$ \bm{h}_l = \text{LayerNorm}(\text{SubLayer}(\bm{h}_{l-1}) + \bm{h}_{l-1}) $$

GPT-2 では、これを Pre-Norm 構成に変更しました。LayerNorm をサブレイヤの入力側に移動します。

$$ \bm{h}_l = \text{SubLayer}(\text{LayerNorm}(\bm{h}_{l-1})) + \bm{h}_{l-1} $$

なぜこの変更が重要なのでしょうか。Pre-Norm では残差接続が「直通パス」として機能し、勾配が入力層まで遮られずに流れやすくなります。Post-Norm では LayerNorm が残差パスの途中に挟まるため、深いモデルでは勾配の流れが阻害されやすくなるのです。

イメージとしては、Post-Norm は「各階で検問がある高層ビル」、Pre-Norm は「エレベーターで直通でき、各階でオプションの処理を追加する高層ビル」のようなものです。48層という深いモデルで安定した学習を実現するために、この変更は不可欠でした。

変更2: 最終層への Layer Normalization 追加

GPT-2 では、最終 Transformer ブロックの後にもう1層 LayerNorm を追加しました。

$$ \bm{h}_\text{out} = \text{LayerNorm}(\bm{h}_L) $$

これにより、モデルの最終出力の分散が安定し、48層を通過した後の数値的な不安定性を抑制しています。

学習データ: WebText

GPT-1 の BooksCorpus（約5GB）に対して、GPT-2 は WebText というはるかに大きく多様なデータセットで学習されました。

WebText は Reddit の投稿から収集されたもので、3 karma 以上の外部リンク先のテキストを収集しています。「Reddit ユーザーが有益だと判断したコンテンツ」を品質フィルタとして利用するという巧妙な戦略です。結果として、約 800万ページ、40GB のテキストデータが集められました。

この多様なデータが、Zero-shot 学習能力の鍵です。翻訳、要約、質問応答など多種多様なタスクのテキストがWebには自然に存在しており、モデルはそれらの「タスクパターン」を事前学習の中で暗黙的に学習したのです。

「危険すぎてリリースできない」論争

GPT-2 は当初、OpenAI が「悪用のリスクが高い」として フルモデルの公開を見送った ことで大きな論争を呼びました。まず小さいモデル（117M）から段階的にリリースし、最終的にフルサイズ（1.5B）は数ヶ月後に公開されました。

当時のGPT-2の生成品質は、フェイクニュースの自動生成やスパムの大量生成に悪用される可能性があると懸念されたのです。この判断は AI の安全性に関する重要な前例となり、後の GPT-4 の Red Teaming アプローチにもつながっていきます。

GPT-2 は「大きなモデル + 多様なデータ = Zero-shot能力」という重要な経験則を示しました。しかし、Zero-shot の性能はまだ不十分で、多くのタスクでファインチューニングされた専用モデルには及びませんでした。次のGPT-3では、このギャップをさらにスケールで埋めようとします。

GPT-3（2020年）— スケーリングの極致と In-context Learning

桁違いのスケールアップ

GPT-3 は、GPT-2 からさらに 100倍以上 のスケールアップを行いました。Brown et al. (2020) の論文 “Language Models are Few-Shot Learners” で発表されたこのモデルは、以下のような規模を持ちます。

175B（1,750億）パラメータという規模は、当時としては前例のないものでした。学習にはV100 GPU数千基相当の計算資源が投入され、推定学習コストは 約460万ドル（約5億円） と報告されています。

Few-shot / In-context Learning の確立

GPT-3 の最も重要な貢献は、In-context Learning（文脈内学習） の発見と体系化です。

GPT-2 が見せた Zero-shot 能力は、GPT-3 のスケールでは質的に異なるレベルに達しました。GPT-3 では、プロンプトに 数個の例 を含めるだけで、ファインチューニングなしに多様なタスクを高精度で解けるようになったのです。これが Few-shot Learning です。

In-context Learning を分類すると、以下の3つの形式があります。

Zero-shot: タスクの説明のみを与える。

Translate English to French:
cheese =>

One-shot: タスクの説明と1つの例を与える。

Translate English to French:
sea otter => loutre de mer
cheese =>

Few-shot: タスクの説明と数個の例を与える。

Translate English to French:
sea otter => loutre de mer
peppermint => menthe poivrée
plush giraffe => girafe en peluche
cheese =>

重要なのは、これらの「学習」ではモデルの重み（パラメータ）は一切更新されないということです。モデルは入力として与えられた例のパターンを、推論時のアテンション機構だけで「理解」し、新しい入力に適用しているのです。

なぜ In-context Learning が可能になるのでしょうか。その直感的な理解としては、Transformer の Self-Attention は入力系列内の任意のトークン間の関係をモデル化できます。十分に大きなモデルは、プロンプト内の例示パターンから「タスクの構造」を動的に推論し、それを新しい入力に適用する一種の「暗黙的な学習アルゴリズム」を内部に獲得していると考えられています。

アーキテクチャの変更: Sparse Attention

GPT-3 のアーキテクチャは GPT-2 の Pre-Norm Transformer Decoder をほぼ踏襲していますが、一つ重要な変更が加えられました。Sparse Attention の導入です。

論文では “alternating dense and locally banded sparse attention” と記述されています。具体的には、Transformer の各層で以下の2種類のAttentionパターンを交互に使用します。

• Dense Attention: 通常の Full Attention。全てのトークンペア間のAttentionを計算
• Locally Banded Sparse Attention: 各トークンが近傍のトークンのみに注目する局所的なAttention

Full Attention の計算量は系列長 $n$ に対して $O(n^2)$ ですが、ローカルバンド幅を $w$ とした Sparse Attention は $O(n \cdot w)$ に削減されます。コンテキスト長 2,048 で 96 層という構成では、この計算量の削減が学習効率に大きく寄与します。

直感的には、テキストの理解には「近くの文脈との関係（局所的）」と「文書全体の構造との関係（大域的）」の両方が重要です。Dense 層で大域的な関係を捕捉し、Sparse 層で局所的な関係を効率的に処理するという設計は、人間が文章を読むときの注意の使い分けに似ています。

学習データ

GPT-3 の学習データは、複数のソースを混合したものです。

注目すべきは、Common Crawl が最大のデータソースでありながら、品質の高い WebText2 や書籍データに学習時の重みを大きく配分していることです。単にデータ量を増やすだけでなく、品質と量のバランス を取る工夫が行われています。

GPT-3 は「スケールすれば性能が上がる」というスケーリング仮説を壮大な規模で実証しました。しかし、生成されるテキストは必ずしも人間の意図に沿ったものではありませんでした。有害な内容を生成したり、質問に正直に答えなかったりする問題が残っていたのです。この「人間の意図との整合性」の問題に取り組んだのが、次の InstructGPT です。

InstructGPT / ChatGPT（2022年）— アライメントの時代

なぜアライメントが必要になったのか

GPT-3 は驚異的な言語能力を獲得しましたが、根本的な問題を抱えていました。モデルの学習目標は「次のトークンを予測すること」であり、「ユーザーの質問に正確かつ安全に回答すること」ではなかったのです。

レストランのレビューを書かせると、5つ星のレビューも1つ星のレビューも同じように生成します。「東京タワーの高さは？」と聞くと、正しい答えを返すこともあれば、もっともらしい嘘（ハルシネーション）を自信たっぷりに返すこともあります。有害な指示に対しても、学習データにそのようなパターンがあれば従ってしまいます。

この「モデルが優秀だが言うことを聞かない」問題を解決するために、RLHF（Reinforcement Learning from Human Feedback） が導入されました。

RLHF の3ステップ

InstructGPT（Ouyang et al., 2022）は、以下の3段階の学習プロセスで GPT-3 をアライメントしました。

ステップ1: 教師ありファインチューニング（SFT）

人間のラベラーが理想的な回答を作成し、その回答でGPT-3をファインチューニングします。これにより、モデルは「指示に従って回答する」基本的な振る舞いを学びます。

ステップ2: 報酬モデルの学習

同じプロンプトに対する複数の回答をモデルに生成させ、人間のラベラーがそれらを「良い順」にランキングします。このランキングデータから、回答の品質を数値化する 報酬モデル（Reward Model） $R(\bm{x}, \bm{y})$ を学習します。

報酬モデルの学習には、ペアワイズ比較の損失関数を使用します。回答 $\bm{y}_w$ が $\bm{y}_l$ より良いと判断された場合の損失は以下です。

$$ L_\text{RM} = -\log \sigma(R(\bm{x}, \bm{y}_w) – R(\bm{x}, \bm{y}_l)) $$

ここで $\sigma$ はシグモイド関数です。この損失を最小化することで、人間の選好を反映した報酬モデルが得られます。

ステップ3: PPO による強化学習

SFT モデルを方策（Policy）とし、報酬モデルからの報酬を最大化するように PPO（Proximal Policy Optimization） で最適化します。

最適化する目標関数は以下の形です。

$$ \max_\pi \mathbb{E}_{\bm{x} \sim D, \bm{y} \sim \pi(\cdot|\bm{x})} \left[ R(\bm{x}, \bm{y}) – \beta \cdot D_\text{KL}(\pi(\cdot|\bm{x}) \| \pi_\text{SFT}(\cdot|\bm{x})) \right] $$

ここで重要なのは第2項の KLダイバージェンスペナルティ です。これは、最適化後のモデル $\pi$ が SFT モデル $\pi_\text{SFT}$ から大きく離れすぎないよう制約する役割を果たします。ハイパーパラメータ $\beta$ でこの制約の強さを制御します。KL ペナルティがないと、モデルは報酬を最大化するために「報酬ハッキング」— 報酬モデルの欠陥を突いて高スコアを得るが実際には低品質な出力を生成する — に陥ります。

ChatGPT: インターフェースの革命

2022年11月にリリースされた ChatGPT は、GPT-3.5（GPT-3 の改良版）に RLHF を適用し、対話形式のインターフェースを組み合わせたものです。

技術的には InstructGPT の延長線上にありますが、対話形式のUI が一般ユーザーにも直感的に使えるものだったことで、わずか2ヶ月で1億ユーザーを突破するという爆発的な普及を見せました。

ChatGPT の成功は、モデルの能力だけでなく、ユーザーインターフェースの設計がAI普及の鍵である という重要な教訓を示しました。GPT-3 の API は開発者しか使えませんでしたが、ChatGPT の対話UIは誰でも使えたのです。

RLHF によるアライメントは、モデルを「より人間の意図に沿った」存在にしましたが、モデルの基本的な能力の上限を引き上げたわけではありません。能力の次の飛躍は、さらなるスケールアップとマルチモーダル化によってもたらされます。

GPT-4（2023年）— マルチモーダルと安全性の新境地

テキストから画像へ

2023年3月に発表された GPT-4 は、GPTシリーズ初の マルチモーダルモデル です。テキストだけでなく画像も入力として受け付け、画像の内容を理解してテキストで回答できるようになりました。

例えば、手書きのウェブサイトのスケッチ画像を入力すると、そのデザインを実現する HTML/CSS コードを生成できます。グラフの画像を入力すると、そのデータの傾向を分析して説明できます。

非公開のアーキテクチャ

GPT-4 は、OpenAI がアーキテクチャの詳細を 公開しなかった 最初のGPTモデルです。Technical Report（2023年3月）には、モデルサイズ、学習データ、学習の計算量などの情報が意図的に含まれていません。OpenAI はこの判断について、競争環境と安全性上の懸念を理由として挙げました。

しかし、各種の分析やリーク情報から、以下のような推測が広く共有されています。

• Mixture of Experts（MoE）アーキテクチャ の採用: 複数の専門家ネットワーク（Expert）を持ち、入力に応じて一部の Expert のみを活性化する構造
• 総パラメータ数: 推定で数兆パラメータ規模（ただし MoE の場合、推論時にはその一部のみが活性化される）
• 学習データ: 推定13兆トークン以上

MoE を直感的に理解するために、病院を想像してください。総合病院には内科、外科、眼科など多くの専門科がありますが、一人の患者が来院したとき、全ての科の医師が同時に診察するわけではありません。症状に応じて適切な科にルーティングされます。MoE も同じで、入力トークンに応じて適切な Expert ネットワークにルーティングすることで、全パラメータを活性化するよりもはるかに効率的に推論できます。

MoE における各トークンの処理は、ゲーティングネットワーク $G$ が Expert の選択を行います。$E$ 個の Expert のうち、上位 $k$ 個を活性化する場合の出力は以下です。

$$ \bm{y} = \sum_{i \in \text{TopK}} g_i(\bm{x}) \cdot E_i(\bm{x}) $$

ここで $g_i(\bm{x})$ はゲーティングネットワークの出力（ソフトマックスの上位 $k$ の値）、$E_i(\bm{x})$ は $i$ 番目の Expert の出力です。全パラメータが $N_\text{total}$ でも、推論時に活性化されるのは $N_\text{active} = N_\text{total} \times k / E$ 程度となり、計算効率が大幅に向上します。

ベンチマーク性能

GPT-4 は多数のベンチマークで人間レベルまたはそれ以上の性能を示しました。

特に注目すべきは司法試験の結果です。GPT-3.5 では下位10%だったものが、GPT-4 では上位10%に跳ね上がっています。これは単なる量的改善ではなく、複雑な推論能力における質的な飛躍 を示唆しています。

安全性への取り組み: Red Teaming

GPT-4 の開発過程では、前例のない規模の安全性対策が実施されました。50人以上の外部専門家による Red Teaming（敵対的テスト）が行われ、モデルの危険な出力パターンが体系的に洗い出されました。

Red Teaming で発見されたリスクには、以下のようなものが含まれます。

• 有害な化学物質の合成手順の生成
• サイバー攻撃の支援
• 差別的・偏見的なコンテンツの生成

これらのリスクに対して、RLHF のさらなる強化、出力フィルタリング、利用規約の整備など多層的な安全対策が講じられました。

GPT-4 は「性能の向上」と「安全性の確保」を同時に追求した点で、AI 開発の方法論における重要なマイルストーンです。しかし、なぜスケールを大きくするだけでこのような能力の飛躍が起きるのでしょうか。この問いに数学的に答えようとするのが、次に見るスケーリング則です。

スケーリングの数学

Neural Scaling Laws

GPTシリーズの進化を貫く最も重要な原理が、ニューラルスケーリング則（Neural Scaling Laws） です。Kaplan et al. (2020) は、言語モデルの性能（テスト損失）がモデルサイズ $N$、データサイズ $D$、計算量 $C$ のそれぞれに対して べき乗則（Power Law） に従うことを発見しました。

まず直感的に理解しましょう。料理人（モデル）が料理（言語処理）の腕を上げるには、3つの方法があります。料理人の人数を増やす（パラメータ数 $N$）、レシピ本を増やす（データ量 $D$）、練習時間を増やす（計算量 $C$）。スケーリング則は「どれを増やしても上手くなるが、増やし方には予測可能なパターンがある」ということを数学的に示しています。

モデルサイズと損失の関係

モデルパラメータ数 $N$ とテスト損失 $L$ の関係は以下のべき乗則で記述されます。

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

ここで $N_c$ と $\alpha_N$ は実験的に決定される定数です。Kaplan et al. の実験では、Transformer 言語モデルに対して以下の値が報告されました。

$$ \alpha_N \approx 0.076 $$

対数スケールで見ると、これは損失がモデルサイズの対数に対して線形に減少することを意味します。

$$ \log L(N) = -\alpha_N \log N + \text{const} $$

つまり、パラメータ数を10倍にするたびに、損失は一定量だけ減少します。この関係は 7桁以上 のスケール範囲（$10^3$ から $10^{10}$ パラメータ）にわたって成り立つことが実験的に確認されています。

データサイズと損失の関係

同様に、学習データのトークン数 $D$ に対しても以下のべき乗則が成り立ちます。

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

Kaplan et al. の報告では以下です。

$$ \alpha_D \approx 0.095 $$

$\alpha_D > \alpha_N$ であることは、同じ計算予算の増加に対して、データ量を増やすほうがモデルサイズを増やすよりも効率的に損失を下げられることを示唆しています。ただし、この解釈は後の Chinchilla の研究で修正されることになります。

計算量と損失の関係

計算量 $C$（FLOPs）に対する損失のスケーリングは以下です。

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

$$ \alpha_C \approx 0.050 $$

これら3つの変数を統合した近似式も提案されています。

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

この式は、モデルサイズとデータ量のどちらかがボトルネックになっている場合、もう一方を増やしても損失が下がりにくいことを数学的に表現しています。

Chinchilla 最適化

Kaplan et al. のスケーリング則は「計算予算が増えたらモデルサイズを優先的に大きくすべき」と示唆していました。この方針に従って作られたのがGPT-3（175Bパラメータ、300Bトークン）です。

しかし2022年、DeepMind の Hoffmann et al. が Chinchilla の研究で、この方針を修正しました。Chinchilla の結論は明快です。

計算量に対する最適配分: 計算予算 $C$ が与えられたとき、最適なモデルサイズ $N^\ast$ とデータサイズ $D^\ast$ は以下のように比例します。

$$ N^\ast \propto C^{a}, \quad D^\ast \propto C^{b} $$

Chinchilla の実験結果は $a \approx b \approx 0.5$ を示唆しており、つまり 計算予算が増えたとき、モデルサイズとデータサイズを同じ比率で増やすのが最適 ということです。

実用的な目安として、最適な学習トークン数はパラメータ数の約 20倍 とされています。

$$ D^\ast \approx 20 \times N $$

この基準で GPT-3 を評価してみましょう。GPT-3 は 175B パラメータを 300B トークンで学習しました。Chinchilla 基準では $175B \times 20 = 3.5T$（3.5兆）トークンが必要です。つまり、GPT-3 は 約10倍以上のデータ不足 で学習されていたことになります。

Chinchilla（70Bパラメータ、1.4Tトークン）は、GPT-3（175B）よりもパラメータ数が少ないにもかかわらず、データ量を増やすことで多くのベンチマークで GPT-3 を上回りました。この結果は、その後の LLaMA の設計方針に直接影響を与えています。

Emergent Abilities（創発能力）

スケーリングの最も驚くべき現象は、創発能力（Emergent Abilities） です。Wei et al. (2022) が報告したこの現象は、特定のタスクにおいてモデルサイズがある閾値を超えると、性能が突然ランダムレベルから高精度に跳ね上がるというものです。

通常のスケーリング則では、性能は対数的に滑らかに向上します。しかし、算術推論、複数ステップの論理推論、暗号解読などのタスクでは、小さなモデルではほぼゼロだった正答率が、ある規模を境に急激に上昇する「相転移」のような振る舞いが観察されています。

この創発現象の解釈には議論があります。Schaeffer et al. (2023) は、創発能力の多くは評価指標の非線形性（例えば完全一致率のような不連続な指標）に起因するものであり、連続的な指標で評価すれば滑らかな改善が見られると主張しています。一方、特定のタスクでは真に質的な能力の飛躍が起きているという見方もあります。

いずれにせよ、スケーリングによってモデルの能力が「量的に」だけでなく「質的に」変化しうるという事実は、AIの発展を理解する上で極めて重要です。

スケーリング則を理解したところで、ここまでの全世代を俯瞰する比較年表を見てみましょう。

アーキテクチャの比較年表

GPT-1 から GPT-4 までの進化を一つの表にまとめます。

この表から明確に読み取れるパターンがあります。アーキテクチャの基本構造（Transformer Decoder）は一貫して同じであり、主な変化は スケール（パラメータ数、データ量、計算量の増大）と アライメント（人間の意図との整合性）の2軸に集約されています。

この全体像を踏まえて、次は Python を使ってスケーリング則を実際に可視化し、モデルサイズの違いを数値的に確認してみましょう。

Python での実験

実験1: スケーリング則の可視化

まず、Kaplan et al. (2020) のスケーリング則をプロットし、GPT-1/2/3 の位置を確認します。ここでは、パラメータ数と損失の関係をべき乗則でモデル化し、各世代のモデルがどの位置に来るかを可視化します。

import numpy as np
import matplotlib.pyplot as plt

# スケーリング則: L(N) = (Nc / N)^alpha_N
# Kaplan et al. (2020) の近似パラメータ
alpha_N = 0.076
Nc = 8.8e13  # 参照パラメータ数（フィッティング定数）

# パラメータ数の範囲（10^6 から 10^12）
N = np.logspace(6, 12, 500)

# べき乗則による損失
L = (Nc / N) ** alpha_N

# GPTシリーズの実際のパラメータ数（近似的なテスト損失）
gpt_models = {
    'GPT-1\n(117M)': (117e6, (Nc / 117e6) ** alpha_N),
    'GPT-2\n(1.5B)': (1.5e9, (Nc / 1.5e9) ** alpha_N),
    'GPT-3\n(175B)': (175e9, (Nc / 175e9) ** alpha_N),
}

# プロット
fig, ax = plt.subplots(figsize=(10, 6))

# スケーリング則の曲線
ax.plot(N, L, 'b-', linewidth=2, label='Scaling Law: $L(N) = (N_c/N)^{\\alpha_N}$')

# 各GPTモデルのプロット
colors = ['#e74c3c', '#f39c12', '#2ecc71']
for (name, (n, loss)), color in zip(gpt_models.items(), colors):
    ax.scatter(n, loss, s=200, color=color, zorder=5, edgecolors='black', linewidth=1.5)
    ax.annotate(name, (n, loss), textcoords="offset points",
                xytext=(15, 10), fontsize=11, fontweight='bold', color=color)

ax.set_xscale('log')
ax.set_yscale('log')
ax.set_xlabel('Number of Parameters (N)', fontsize=13)
ax.set_ylabel('Test Loss (L)', fontsize=13)
ax.set_title('Neural Scaling Law: Model Size vs. Test Loss', fontsize=14)
ax.legend(fontsize=11)
ax.grid(True, alpha=0.3, which='both')
ax.set_xlim(1e6, 1e12)

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

このグラフから、以下の重要な特徴が読み取れます。

1. 損失は対数スケールで直線的に減少する — パラメータ数を対数軸で見たとき、損失もほぼ対数軸で直線になっています。これはべき乗則が広い範囲で成り立つことを視覚的に確認しています。
2. GPT-1→GPT-2→GPT-3 はスケーリング則の曲線上に位置する — 各世代のモデルは偶然ではなく、このべき乗則に沿って設計されていることがわかります。スケール拡大の意思決定が理論的根拠に基づいていたことを示唆しています。
3. 改善は対数的に鈍化する — パラメータ数を10倍にしても損失の改善幅は同じです。つまり、117Mから1.5Bへの13倍のスケールアップと、1.5Bから175Bへの117倍のスケールアップで、損失の改善幅はそれほど違いません。これが「スケーリングの収穫逓減」の本質です。

実験2: GPT-2 の各サイズのパラメータ数計算

GPT-2 は small（117M）、medium（345M）、large（774M）、xl（1.5B）の4つのサイズで公開されました。Transformer のパラメータ数を設計パラメータから理論的に計算し、公式値と比較してみましょう。

import numpy as np

def count_transformer_params(n_layers, d_model, n_heads, d_ff, vocab_size, context_len):
    """
    Transformer Decoder のパラメータ数を計算する

    Parameters
    ----------
    n_layers : int
        Transformerブロックの層数
    d_model : int
        隠れ次元
    n_heads : int
        Attentionヘッド数
    d_ff : int
        FFNの内部次元
    vocab_size : int
        語彙サイズ
    context_len : int
        最大コンテキスト長
    """
    # トークン埋め込み: vocab_size x d_model
    token_embed = vocab_size * d_model

    # 位置埋め込み: context_len x d_model
    pos_embed = context_len * d_model

    # 各Transformerブロック
    # Multi-Head Attention: Q, K, V, Output の4つの線形変換
    # 各変換: d_model x d_model + d_model（バイアス）
    attn_params = 4 * (d_model * d_model + d_model)

    # FFN: 2層の線形変換
    # 第1層: d_model x d_ff + d_ff
    # 第2層: d_ff x d_model + d_model
    ffn_params = (d_model * d_ff + d_ff) + (d_ff * d_model + d_model)

    # LayerNorm: 2つ（Attention前とFFN前）、各 2 * d_model（scale + shift）
    ln_params = 2 * (2 * d_model)

    # 1ブロックあたりのパラメータ数
    block_params = attn_params + ffn_params + ln_params

    # 全ブロック
    total_blocks = n_layers * block_params

    # 最終LayerNorm: 2 * d_model
    final_ln = 2 * d_model

    # 出力ヘッド（トークン埋め込みと重み共有の場合はカウントしない）
    # GPT-2は重み共有なので、出力ヘッドの追加パラメータはなし

    total = token_embed + pos_embed + total_blocks + final_ln

    return {
        'token_embed': token_embed,
        'pos_embed': pos_embed,
        'per_block': block_params,
        'all_blocks': total_blocks,
        'final_ln': final_ln,
        'total': total
    }


# GPT-2 の4つのサイズ
gpt2_configs = {
    'GPT-2 Small': {
        'n_layers': 12, 'd_model': 768, 'n_heads': 12,
        'd_ff': 3072, 'vocab_size': 50257, 'context_len': 1024,
        'official_params': 117e6
    },
    'GPT-2 Medium': {
        'n_layers': 24, 'd_model': 1024, 'n_heads': 16,
        'd_ff': 4096, 'vocab_size': 50257, 'context_len': 1024,
        'official_params': 345e6
    },
    'GPT-2 Large': {
        'n_layers': 36, 'd_model': 1280, 'n_heads': 20,
        'd_ff': 5120, 'vocab_size': 50257, 'context_len': 1024,
        'official_params': 774e6
    },
    'GPT-2 XL': {
        'n_layers': 48, 'd_model': 1600, 'n_heads': 25,
        'd_ff': 6400, 'vocab_size': 50257, 'context_len': 1024,
        'official_params': 1542e6
    },
}

# パラメータ数の計算と表示
print(f"{'Model':<16} {'Calculated':>14} {'Official':>14} {'Ratio':>8}")
print("-" * 56)

for name, config in gpt2_configs.items():
    official = config.pop('official_params')
    result = count_transformer_params(**config)
    calculated = result['total']
    ratio = calculated / official

    print(f"{name:<16} {calculated/1e6:>11.1f}M {official/1e6:>11.1f}M {ratio:>7.3f}")

    # 内訳の表示
    print(f"  Token Embed: {result['token_embed']/1e6:.1f}M, "
          f"Pos Embed: {result['pos_embed']/1e6:.1f}M, "
          f"Per Block: {result['per_block']/1e6:.2f}M × {config['n_layers']} layers, "
          f"Final LN: {result['final_ln']}")
    print()

この計算結果から、以下のことがわかります。

1. 理論的な計算値と公式パラメータ数はほぼ一致する — Transformer のパラメータ数は設計パラメータから正確に予測できます。モデルの構成を理解していれば、必要なメモリ量や計算量の見積もりが可能です。
2. パラメータの大部分は Transformer ブロック内にある — トークン埋め込みのパラメータは全体の10-30%程度で、残りはAttentionとFFNが占めます。モデルが大きくなるほど、ブロック内のパラメータの割合が増加します。
3. FFN がパラメータの多数を占める — 各ブロック内では、FFN（$d_\text{model} \times d_\text{ff}$ が2つ）のパラメータがAttention（$d_\text{model} \times d_\text{model}$ が4つ）よりも多いです。$d_\text{ff} = 4 \times d_\text{model}$ の場合、FFNのパラメータはAttentionの約2倍になります。

実験3: Hugging Face GPT-2 を使ったテキスト生成のサイズ比較

最後に、Hugging Face の transformers ライブラリを使って、GPT-2 の異なるサイズでテキスト生成を行い、モデルサイズが生成品質に与える影響を確認します。

from transformers import GPT2LMHeadModel, GPT2Tokenizer
import torch

def generate_text(model_name, prompt, max_new_tokens=100, temperature=0.8, seed=42):
    """
    GPT-2の指定サイズでテキスト生成を行う

    Parameters
    ----------
    model_name : str
        Hugging Faceのモデル名
    prompt : str
        入力プロンプト
    max_new_tokens : int
        生成する最大トークン数
    temperature : float
        サンプリング温度（高いほどランダム）
    seed : int
        乱数シード
    """
    # シード固定
    torch.manual_seed(seed)

    # モデルとトークナイザの読み込み
    tokenizer = GPT2Tokenizer.from_pretrained(model_name)
    model = GPT2LMHeadModel.from_pretrained(model_name)
    model.eval()

    # トークナイズ
    input_ids = tokenizer.encode(prompt, return_tensors='pt')

    # テキスト生成
    with torch.no_grad():
        output = model.generate(
            input_ids,
            max_new_tokens=max_new_tokens,
            temperature=temperature,
            do_sample=True,
            top_p=0.9,
            pad_token_id=tokenizer.eos_token_id,
        )

    # デコード
    generated_text = tokenizer.decode(output[0], skip_special_tokens=True)

    # パラメータ数
    n_params = sum(p.numel() for p in model.parameters())

    return generated_text, n_params


# テスト用のプロンプト
prompt = "The key to understanding artificial intelligence is"

# GPT-2の各サイズで生成
model_sizes = {
    'GPT-2 Small (117M)': 'gpt2',
    'GPT-2 Medium (345M)': 'gpt2-medium',
    'GPT-2 Large (774M)': 'gpt2-large',
    'GPT-2 XL (1.5B)': 'gpt2-xl',
}

print(f"Prompt: \"{prompt}\"\n")
print("=" * 80)

for label, model_name in model_sizes.items():
    generated, n_params = generate_text(model_name, prompt)
    print(f"\n[{label}] (Params: {n_params/1e6:.0f}M)")
    print("-" * 60)
    print(generated)
    print("=" * 80)

この実験から、以下の傾向が観察できます。

1. モデルサイズが大きいほど文章の一貫性が向上する — Small モデルでは話題が途中で逸れやすいのに対し、XL モデルではプロンプトの話題を維持しつつ、より論理的な文章を生成する傾向があります。
2. 語彙の多様性と適切性が向上する — 大きなモデルほど文脈に適した単語を選択し、より自然な表現を生成します。これは、より多くのパラメータによって細かな言語パターンを捕捉できるためです。
3. Small でも文法的には正しい — 117M パラメータでも英語の文法構造はほぼ正確に生成できます。スケーリングで改善されるのは、文法の正しさよりも「意味の一貫性」や「知識の正確性」などの高次の能力です。

実験4: Chinchilla 最適配分の可視化

計算予算に対する最適なモデルサイズとデータサイズの配分を可視化します。

import numpy as np
import matplotlib.pyplot as plt

# 計算予算 C のもとでの最適パラメータ数とトークン数の関係
# Chinchilla: D* ≈ 20 * N (最適データ/パラメータ比率)
# Kaplan: D* ≈ 数 * N (データをもっと少なく見積もり)

# 計算予算の範囲（FLOPs）
# 近似: C ≈ 6 * N * D （Transformer の学習FLOPs）
# Chinchilla最適: D = 20N → C = 6N * 20N = 120N^2 → N = sqrt(C/120)

C_range = np.logspace(18, 26, 500)  # 10^18 ~ 10^26 FLOPs

# Chinchilla 最適配分
N_chinchilla = np.sqrt(C_range / 120)
D_chinchilla = 20 * N_chinchilla

# Kaplan 的な配分（モデルサイズ重視: D ≈ 2N と仮定）
N_kaplan = np.sqrt(C_range / 12)  # C = 6N * 2N = 12N^2
D_kaplan = 2 * N_kaplan

# 実際のモデル
models = {
    'GPT-1': {'N': 117e6, 'D': 1e9, 'color': '#e74c3c'},
    'GPT-2': {'N': 1.5e9, 'D': 10e9, 'color': '#f39c12'},
    'GPT-3': {'N': 175e9, 'D': 300e9, 'color': '#2ecc71'},
    'Chinchilla': {'N': 70e9, 'D': 1.4e12, 'color': '#9b59b6'},
    'LLaMA-65B': {'N': 65e9, 'D': 1.4e12, 'color': '#3498db'},
}

fig, axes = plt.subplots(1, 2, figsize=(14, 6))

# 左: 計算予算 vs 最適パラメータ数
ax = axes[0]
ax.plot(C_range, N_chinchilla, 'b-', linewidth=2, label='Chinchilla optimal')
ax.plot(C_range, N_kaplan, 'r--', linewidth=2, label='Kaplan (model-heavy)')

for name, info in models.items():
    C_approx = 6 * info['N'] * info['D']
    ax.scatter(C_approx, info['N'], s=150, color=info['color'],
               zorder=5, edgecolors='black', linewidth=1.5)
    ax.annotate(name, (C_approx, info['N']),
                textcoords="offset points", xytext=(10, 8),
                fontsize=10, fontweight='bold', color=info['color'])

ax.set_xscale('log')
ax.set_yscale('log')
ax.set_xlabel('Compute Budget C (FLOPs)', fontsize=12)
ax.set_ylabel('Optimal Parameters N', fontsize=12)
ax.set_title('Compute Budget vs. Optimal Model Size', fontsize=13)
ax.legend(fontsize=10)
ax.grid(True, alpha=0.3, which='both')

# 右: データ/パラメータ比率の比較
ax = axes[1]
ratios = []
labels = []
colors_bar = []

for name, info in models.items():
    ratio = info['D'] / info['N']
    ratios.append(ratio)
    labels.append(name)
    colors_bar.append(info['color'])

bars = ax.bar(labels, ratios, color=colors_bar, edgecolor='black', linewidth=1.2)
ax.axhline(y=20, color='blue', linestyle='--', linewidth=1.5,
           label='Chinchilla optimal (D/N ≈ 20)')
ax.set_ylabel('Data-to-Parameter Ratio (D/N)', fontsize=12)
ax.set_title('Training Tokens per Parameter', fontsize=13)
ax.legend(fontsize=10)
ax.set_yscale('log')
ax.grid(True, alpha=0.3, axis='y')

# 棒の上に値を表示
for bar, ratio in zip(bars, ratios):
    ax.text(bar.get_x() + bar.get_width() / 2., bar.get_height() * 1.1,
            f'{ratio:.1f}', ha='center', va='bottom', fontsize=10, fontweight='bold')

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

このグラフから、以下の重要な洞察が得られます。

1. GPT-3 は Chinchilla 最適から大きく乖離している — 左図で GPT-3 は Chinchilla 最適線よりも上（モデルが大きすぎる/データが少なすぎる）に位置しています。右図のデータ/パラメータ比率を見ると、GPT-3 の比率は約1.7で、Chinchilla 最適の20と比べて桁違いに小さいことがわかります。
2. Chinchilla と LLaMA は最適線の近くに位置する — これらのモデルは Chinchilla スケーリング則に基づいて設計されており、パラメータ数に対して十分なデータ量で学習されています。結果として、GPT-3 よりも少ないパラメータ数で同等以上の性能を達成しています。
3. GPT-1 と GPT-2 もデータ不足の傾向がある — 初期のモデルは全て、現在の基準から見るとデータが不足していました。LLM の発展は「モデルを大きくする」方向から「データとモデルのバランスを取る」方向へと進化してきたことがこのグラフから明確に読み取れます。

まとめ

本記事では、GPT-1 から GPT-4 までのGPTシリーズの進化を、アーキテクチャ、スケーリング、学習データ、能力の変遷に沿って詳しく見てきました。

• GPT-1（2018年）: 「事前学習 + ファインチューニング」パラダイムを確立。12層、117Mパラメータで9つのベンチマークでSoTAを達成した
• GPT-2（2019年）: Pre-Norm への変更と規模拡大（48層、1.5B）により Zero-shot 学習能力を獲得。「タスクをプロンプトとして指示する」という新しいパラダイムを開いた
• GPT-3（2020年）: 96層、175B という桁違いのスケールで Few-shot / In-context Learning を確立。スケーリング則の実証モデルとなった
• InstructGPT / ChatGPT（2022年）: RLHF による人間の意図との整合性（アライメント）を実現。対話UIにより AI の一般普及を牽引した
• GPT-4（2023年）: マルチモーダル化と安全性強化。司法試験上位10%など、人間レベルの推論能力を示した
• スケーリング則: モデルサイズ、データ量、計算量に対するべき乗則（$L \propto N^{-\alpha}$）が広い範囲で成立。Chinchilla の研究はデータ量の重要性を明らかにした

GPTシリーズの歴史が示す最も重要な教訓は、アーキテクチャの革新よりもスケーリングの力が大きい ということです。GPT-1 から GPT-4 まで、基本構造は Transformer Decoder のままです。変わったのは規模と、人間との整合性です。

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