この日本語版について

この日本語版は、Haggai Roitman 著 The Hitchhiker's Guide to Agentic AI: From Foundations to Systems（arXiv:2606.24937）を日本語に翻訳・編集した二次的著作物（翻案物）です。原著に対して、日本語への翻訳、mdBook 形式への変換、および表記・レイアウトの調整を行っています。

翻訳・校正には生成AI（GPT-5.6 Luna）を使用しています。AIが生成した訳文には誤りが含まれる可能性があります。訳文に疑義がある場合は、原著を参照してください。

原著はクリエイティブ・コモンズ 表示—継承 4.0 国際（CC BY-SA 4.0）の下で提供されています。この日本語版も同じ CC BY-SA 4.0 の下で提供します。

原著の献辞

最愛の妻ジャンナと、娘たちインバルとエイナブへ。

免責事項

本ドキュメントは、著者個人によって作成された独立した調査および教育用のリソースです。本書で表明されている見解、意見、および結論は著者個人のものであり、著者が現在または過去に所属していたいかなる雇用主、組織、または機関の見解を必ずしも反映するものではありません。

本書には、いかなる独占的、機密、または企業秘密に該当する情報は含まれていません。参照されているすべての資料は、査読付きの出版物、オープンアクセスのプレプリント、公式ドキュメント、オープンソースのリポジトリなど、公に利用可能なソースから取得したものです。

コンテンツは明示的か黙示的かを問わず、いかなる保証もない「現状のまま」で提供されます。著者は、特定の目的における情報の正確性、完全性、または適合性についていかなる表明も行いません。読者は、プロダクションシステムに適用する前に、主張、数式、または実装の詳細を独自に検証する必要があります。

フィードバックを歓迎します。 誤りや不正確な点を発見した場合、または改善の提案がある場合は、[first_name]r@gmail.com までフィードバックを送信することをお勧めします。

AIに関する開示。 調査および起稿の補助として大規模言語モデル（LLM）が使用されました。すべてのコンテンツは、著者が最善を尽くして編集および検証を行っています。

ライセンス。 本書は クリエイティブ・コモンズ 表示 - 継承 4.0 国際 ライセンス （CC BY-SA 4.0）の下でライセンスされています。適切なクレジットの表記、ライセンスへのリンクの提供、変更があったかどうかの表示を行い、二次的著作物を同じライセンスの下で配布することを条件に、営利目的を含め、いかなる目的でもこの素材を自由に共有（複製および再配布）し、改変（リミックス、変換、およびそれに基づく構築）することができます。ライセンスの全文：https://creativecommons.org/licenses/by-sa/4.0/

著者について

ハガイ・ロイトマン（Haggai Roitman） は、AI研究と大規模なプロダクションシステムの交差点で20年以上のキャリアを積んできました。基礎研究の発表から、数百万人のユーザーを抱えるシステムの実装に至るまで、彼の仕事は理論と実践の架け橋となっています。

彼の研究分野は、情報検索、推薦システム、自然言語処理、大規模言語モデル（LLM）、LLM向け強化学習、エージェントAIなど多岐にわたります。これまでに査読付き論文を100本以上執筆し、約100件の特許を保有しています。イスラエル工科大学（Technion）で理学士号（優等学位）および博士号を取得しました。

勾配の流れ（gradient flow）やKVキャッシュについて考えていないときは、ターンテーブルの前に立ち、プログレッシブ・トランスやディープ・ハウスをミックスしている姿が見られます。

まえがき

本ガイドが存在する理由

2026年においてインテリジェントなAIシステムを構築するには、途方もなく幅広い知識を習得する必要があります。これには、Transformerが内部でどのように言語を処理するのかという仕組みから、学習を可能にするハードウェアやシステム、効率化をもたらす最適化技術、モデルに推論を教えて人間の意図にアラインさせる強化学習アルゴリズム、さらには自律型システムを大規模に調整するマルチエージェントアーキテクチャに至るまでが含まれます。

これらの知識は、何百もの論文、ブログ記事、GitHubリポジトリ、そして一握りの研究所内の「暗黙知」として散逸しています。本ガイドが存在するのは、 実践者がスタック全体をカバーする単一の統合されたリファレンスを必要としている からです。そこには理論だけでなく、実際にシステムを動かすための実装の詳細も含まれています。

エージェントAIへの個人的な旅路

私がインテリジェントエージェントに魅了され始めたのは20年前、まだ情報システム工学の学士課程で学んでいた頃でした。私はエージェント指向ソフトウェア工学（AOSE）の講義を受け（Wooldridge et al. 2000）、JADE（Bellifemine et al. 2007）（Java Agent DEvelopment Framework）を使ってマルチエージェントシステムを構築する方法を学びました。これはFIPA準拠の（Intelligent Physical Agents 2002）プラットフォームであり、エージェントは構造化されたプロトコルを介して通信し、共有リソースを巡って交渉し、自律的に連携していました。ほぼ同時期に、Berners-Lee、Hendler、Lassilaによる記念碑的な論文「The Semantic Web」（Berners-Lee et al. 2001）は、エージェントが推論できる機械可読な知識のビジョンを描き出しました。これら2つの系譜――自律型エージェントアーキテクチャとセマンティック知識表現――は、それ以来私のキャリアを導く種となりました。このビジョンを具体化した初期のプロジェクトの1つが、将来の恩師となるアビグドール・ガル（Avigdor Gal）教授の指導の下、OntoBuilder（Gal et al. 2005）を用いて開発した「ショッピングエージェント」の構築でした。これは、オントロジーのマッチングとマッピングを通じて、さまざまな異種Webサイトにまたがるスキーマを理解し、製品の検索クエリや注文を自動的に入力できるシステムでした。セマンティックWebは、こうしたエージェントが構造化された機械可読データの世界で繁栄することを約束していました。しかし実際には、手作りのオントロジーの脆弱性、現実世界の製品データの雑多さ、そして堅牢な自然言語理解の欠如により、このビジョンは永久に「5年先」のものにとどまっていました。

その後の数年間、私は到来するAIの進歩の波を一つひとつ追いかけました。組合せ最適化のためのニューラルネットワークとヒューリスティック探索、ディープラーニングと表現学習、大規模な情報検索とパーソナライズ、そして最近では、大規模言語モデルの革命です。それぞれの波は強力な新しいツールをもたらしましたが、夢は同じままでした。それは、複雑な環境において自律的に「理解」し、「推論」し、「行動」するシステムです。

2024年から2026年にかけてが極めて特筆すべき時代である理由は、これらの系譜がようやく融合した点にあります。LLMが言語の理解と生成を提供し、強化学習がモデルに推論と人間の意図へのアライメントを教え、ツール利用プロトコル（MCP）が世界で行動するための「手」を与え、エージェントオーケストレーションフレームワークが20年前にJADEが構想した協調レイヤーを提供します。しかも、それは手書きのオントロジーではなく、基盤モデルによって駆動されているのです。本ガイドは、多くの意味で、その旅路の各ステップで私自身が欲しかったリファレンスそのものです。

2026年におけるAIの状況

今日のエージェントAIシステムに至る道のりは、アーキテクチャ、学習、デプロイにわたる30年間の画期的な進歩の積み重ねに基づいています。

1. アーキテクチャの基礎 (2017–2020): Transformer（Vaswani et al. 2017）は、汎用的なシーケンス処理のプリミティブとして自己注意機構を導入しました。スケーリング則により、より多くのデータで学習されたより大きなモデルが確実に向上することが明らかになりました。GPT-2とGPT-3は、デコーダーのみのTransformerを十分にスケールさせることで、有能なfew-shot学習器になることを実証しました。

2. システムと効率化 (2020–2023): Flash Attention（Dao et al. 2022）は、メモリのボトルネックを解消することで、学習を2〜4\(\times\)高速化しました。LoRA（Hu et al. 2022a）は、単一ノードで70B以上のモデルのファインチューニングを可能にしました。Mixture-of-Experts（MoE）は、モデルの容量と計算コストを切り離しました。vLLMなどの推論エンジンは、リアルタイムアプリケーションで実用可能なスループットを実現しました。

3. 強化学習によるアライメント (2022–2024): RLHF（Ouyang et al. 2022）は、有能だが役に立たないベースモデルを、有用なアシスタントへと変貌させました。これがChatGPTの背景にあるレシピです。DPO（Rafailov et al. 2023）は、報酬モデルと強化学習ループを単一の教師あり損失に縮小し、アライメントの民主化をもたらしました。その後、多様なバリアントが登場しました：KTO（Ethayarajh et al. 2024）、IPO（Azar et al. 2024）、ORPO（J. Hong et al. 2024）、GRPO（Shao et al. 2024）。

4. 推論と自律性 (2024–2026): DeepSeek-R1（DeepSeek-AI et al. 2025）やOpenAIのo1/o3は、強化学習が「推論そのもの」をモデルに教えられることを実証しました。モデルは自発的に思考の連鎖、バックトラッキング、自己検証を発見します。これと並行して、Model Context Protocol（MCP）がツールのアクセスを標準化し、Agent-to-Agent（A2A）がエージェント間の通信を可能にし、本番環境レベルのオーケストレーションフレームワークが成熟しました。

本ガイドの対象読者

本書は 実際にモノを作る実践者 に向けて書かれています：

• 機械学習（ML）エンジニア — Transformerの内部構造、学習インフラ、最適化手法、および学習が発散する理由を理解したい人。
• 特定のドメインに向けて、アーキテクチャ、ファインチューニング戦略、強化学習手法を評価している 応用研究者 。
• オーケストレーションパターン、メモリ構造、ツール統合（MCP）、およびマルチエージェント調整（A2A）を必要とする、プロダクションシステムを構築する エージェントデベロッパー 。
• 学習インフラ、GPUクラスター、分散学習、および推論デプロイを担当する システムエンジニア 。
• スタック全体にわたるアーキテクチャやリソースの決定を下す 技術リーダー 。

ニューラルネットワークと基本的な確率に関する知識があることを前提としています。 LLM、強化学習、あるいはシステムに関する事前の知識は必要ありません 。本ガイドは第一原理から順を追って構築されています。

本ガイドから得られること

本ガイドを読み終えると、以下のことができるようになります：

• LLMの内部構造の理解: 注意機構、位置エンコーディング、MoEルーティング、Flash Attention、およびアーキテクチャの選択が下流の能力にどのように影響するのか。
• システムについての考察: GPUメモリ容量の計算、分散学習戦略（FSDP、テンソル/パイプライン並列化）、推論の最適化、およびvLLMによるプロダクションデプロイ。
• 効率的な学習とファインチューニング: LoRA/QLoRA、量子化、知識蒸留（knowledge distillation）、最適化アルゴリズムの選択、および学習率のスケジューリング。
• 人間の好みへのモデルのアライメント: RLHF/DPO/GRPO/KTOパイプラインの実装、報酬ハッキング（reward hacking）やモード崩壊（mode collapse）のデバッグ、20以上の手法からの適切なアルゴリズムの選択。
• 推論モデルの構築: DeepSeek-R1、o1/o3、QwQが明示的なデモンストレーションなしに、強化学習を通じてどのように思考の連鎖（Chain-of-Thought）を発見するかの理解。
• エージェントシステムの設計: オーケストレーションパターンの選択、メモリの設計、MCPを介したツールの統合、A2Aによるエージェント間の調整、本番ベンチマークによる評価。
• 厳密な評価: モデルの品質とエージェントの能力の両方に対して、適切なメトリクス、ベンチマーク、およびLLM-as-Judgeパターンの適用。

本ガイドの構成

本ガイドは、6つの部に分かれた29の章で構成されています：

1. 第I部 — 基礎 (第1章〜第3章): LLMアーキテクチャと最適化（Transformer、注意、位置エンコーディング、Flash Attention、LoRA、MoE）、システムの基礎（GPU階層、分散トレーニング、vLLM）、および古典的な強化学習理論（MDP、方策勾配、アクター・クリティック）。
2. 第II部 — LLMのための強化学習手法 (第4章〜第12章): LLM向け強化学習の完全なツールキット。言語モデル向け強化学習の基礎から、PPO、DPO、GRPO、および選好最適化（preference optimization）のバリアント（Online DPO、KTO、IPO、ORPO、SimPO）の数学的解釈、報酬モデルの学習、SFTのベストプラクティス、大規模システムアーキテクチャ、軌跡レベルの強化学習を用いたエージェントの学習まで。
3. 第III部 — 推論 (第13章): 大規模推論モデル（DeepSeek-R1、OpenAI o1/o3/o4-mini、QwQ）における、強化学習による思考の連鎖の自己発見、MCTS、プロセス報酬モデル（PRM）、およびテスト時計算量（test-time compute）のスケーリング。
4. 第IV部 — 評価 (第14章): 包括的なLLM評価手法（パープレキシティ、pass@k、ELOなどのメトリクス）、LLM-as-Judgeパターン、データ汚染検出、ベンチマークスイート、およびエージェント能力の評価手法。
5. 第V部 — エージェントAI (第15章〜第26章): 完全なエージェントスタック（エージェントAIの概要、RAGと情報検索、メモリシステム、オーケストレーションと文脈管理、デザインパターン、エージェント環境とベンチマーク、Model Context Protocol（MCP）、エージェントスキル、Agent-to-Agent通信（A2A）、マルチエージェントシステム、開発フレームワーク、およびエージェントUI）。
6. 第VI部 — 評価とリファレンス (第27章〜第29章): すべてのトピックにわたる詳細な解説付きの108問の確認問題、主要な数式・APIリファレンス・失敗モードの診断をまとめたクイックリファレンス、および結論と今後の方向性。

本ガイドには、すべてのトピックを網羅する包括的な回答付きの100以上の詳細な確認問題が含まれており、さらに主要な数式、API参照、および失敗モードの診断を統合したクイックリファレンスの章が用意されています。

設計思想

本書を導く3つの原則は、以下のとおりです：

1. 直感が先、数式は後: すべての数式の前に、それが何を意味し、なぜ重要であるかを平易な言葉で説明しています。
2. 実装を意識する: 動かし方を知らなければ理論は役に立ちません。本書のいたるところに、コード、ハイパーパラメータの表、メモリ使用量の見積もり、アーキテクチャ図、およびデバッグ戦略を掲載しています。
3. 何が機能するかに誠実であること: どの手法が本番環境で実証済みであり、どれがまだ研究段階の模索であるかを明確に述べています。

対象範囲と意図的な除外事項

本ガイドは、 テキスト入力・テキスト出力の言語モデル と、その周囲に構築される強化学習、システム、およびエージェントインフラストラクチャに焦点を当てています。以下の重要な領域は意図的に除外されています：

• マルチモーダルモデル (画像と言語、音声、動画): マルチモーダルアーキテクチャは、それぞれに特有の学習パイプライン（対照学習を用いた事前学習、モダリティ間のアライメント、モダリティ固有のエンコーダー）、データのキュレーションの課題、および評価プロトコルを必要とし、それぞれ単冊の書籍に値するテーマです。これらを含めると、本書の核である強化学習とエージェントの核心部分を深めることなく、本の範囲が2倍になってしまいます。
• ドメイン固有の展開 (医療、法務、金融、科学的発見): ドメイン適応には、規制の制約、特殊な評価、データアクセスの問題が伴い、これらは本書で提示する一般的な手法とは独立しています。本書で説明するアルゴリズムとアーキテクチャは、実践者がこれらのドメインに適応させるための構成要素ですが、適応の詳細は専用のリファレンスに委ねるのが適切です。
• パーソナライズと推薦システム: パーソナライズは、ユーザーモデリング、協調フィルタリング、およびインタラクション履歴のアーキテクチャに依存しており、これらは並行する別の研究分野を形成しています。推薦システム内でLLMが使用されるケースは増えていますが、その核となる技術（シーケンシャルモデル、バンディットに基づく探索、コールドスタート処理）は十分に異なっており、別途扱うべき領域です。

この境界線を維持することで、モダリティや業界別領域にわたって記述を断片化させることなく、「アーキテクチャの基礎とシステムインフラから、アラインメントと推論能力を備えたモデルを生み出す学習アルゴリズム、および自律型エージェントのオーケストレーションとデプロイに至るまで」という、単一の一貫したストーリーを維持しています。

— ハガイ・ロイトマン, 2026年

はじめに

全体像

本ガイドは、 第一原理からプロダクションシステムまで を案内します。本書は、実践者――研究者、エンジニア、および応用科学者――に向けて書かれており、Transformerアーキテクチャやそれを実行するハードウェアから、モデルを人間の意図にアラインさせ、推論を教える学習アルゴリズム、さらには自律システムとしてデプロイするためのエージェントアーキテクチャに至るまで、現代のAIのフルスタックを理解し、構築したい方を対象としています。

コアとなる主張はシンプルです。優れたAIシステムを構築するには、単一のレイヤーだけでなく、パイプライン全体を理解する必要があるということです。学習の実行をデバッグするエンジニアは、GPUのメモリ階層とオプティマイザのダイナミクスを理解する必要があります。ファインチューニングの実践者は、どのような場合にLoRAで十分であり、どのような場合に全パラメータ学習がコストに見合う価値があるかを知る必要があります。エージェントデベロッパーは、基盤となるモデルがどのように学習されたかを理解する必要があります。フレームワークを評価する技術リーダーは、それぞれがどのようなトレードオフを抱えているかを理解する必要があります。本ガイドは、その全体像を提供します。

エージェントAIへの道：簡単な歴史

今日のエージェントAIシステムは、何もないところから突如として現れたわけではありません。何十年にもわたる画期的なシステムの上に成り立っています。それらはそれぞれ狭い範囲の課題を解決してきましたが、共同で自律型エージェントを実現するための技術、ハードウェア、および大いなる野心を築き上げてきました。

1. Deep Blue (1997) (Campbell et al. 2002) — IBMのチェスエンジンは、手作りの評価関数を用いた総当たり探索（毎秒2億局面）により、世界チャンピオンのガルリ・カスパロフを破りました。これは、明確に定義された対戦ドメインにおいて機械が人間のパフォーマンスを上回り得ることを証明しましたが、他のドメインには一切汎用化できませんでした。

2. IBM Watson — Jeopardy! (2011) (Ferrucci et al. 2010) — Watsonは、情報検索、自然言語処理（NLP）、および大規模並列処理を組み合わせることで、オープンドメインのクイズ番組（Jeopardy!）で人間のチャンピオンたちを破りました。AIが大規模な非構造化テキストを処理できることを証明しましたが、ドメイン固有の開発に何年も要し、人間の多大な努力なしには新しいドメインを学習できませんでした。

3. AlexNetとディープラーニング革命 (2012) (Krizhevsky et al. 2012) — KrizhevskyらによるCNNは、圧倒的な差でImageNetコンテストを制し、GPUで学習された深層ニューラルネットワークが生データから表現を直接学習できることを証明しました。この1つの成果が現代のディープラーニング時代の到来を告げ、最終的にLLMを可能にするハードウェアへの投資を呼び込みました。

4. AlphaGo (2016) (Silver et al. 2016) — DeepMindのシステムは、深層強化学習（方策ネットワーク＋価値ネットワーク＋モンテカルロ木探索）を用いて囲碁の世界チャンピオンであるイ・セドルを破りました。Deep Blueの総当たり探索とは異なり、AlphaGoは囲碁の打ち方を「学習」しました。これは、探索だけでは扱えない領域（\(10^{170}\)通りの局面）を、強化学習で制覇できることを示しました。その後のAlphaGo Zero（2017）（Silver et al. 2017）は、人間の対局データに全く頼らず、完全な自己対戦のみから学習を行いました。

5. GPT-2/GPT-3 (2019–2020) (Brown et al. 2020) — OpenAIは、デコーダーのみのTransformerを数十億パラメータにスケールさせることで、創発的なfew-shot学習能力が生まれることを示しました。GPT-3（1750億パラメータ）は、文脈内のいくつかの例を与えるだけで、翻訳、算術、コード生成など、明示的に学習されたことのないタスクを実行できました。ここに基盤モデル（Foundation Models）の時代が幕を開けました。

6. AlphaFold (2020) (Jumper et al. 2021) — DeepMindは、50年にわたる課題であったタンパク質折り畳み問題を解決し、3Dタンパク質構造を原子レベルの精度で予測しました。AlphaFoldは、以前は数十年先と考えられていた根本的な科学的課題をディープラーニングが攻略できることを証明しました。また、画期的なアーキテクチャ（残基ペアに対する注意）と大規模計算の融合の威力も示しました。

7. ChatGPTとRLHF (2022) (Ouyang et al. 2022) — InstructGPTおよびChatGPTは、有能なベースモデルをRLHF（人間のフィードバックによる強化学習）でアラインさせることで、真に有用なアシスタントになり得ることを証明しました。これが変曲点となりました。AIは研究ツールから、数億人に利用されるコンシューマー向け製品へと進化しました。このアライメント手法（報酬モデル、PPO）は、その後のすべてのLLM事後学習の標準テンプレートとなりました。

8. GPT-4とマルチモーダルモデル (2023) (OpenAI 2023) — マルチモーダル能力（画像＋言語）、より長いコンテキストウィンドウ、および推論能力の向上により、LLMは汎用的な認知機能に近づきました。ツール利用（コードインタープリター、Webブラウジング）は、エージェントとしての能力を示唆し始めました。

9. 推論モデル (2024) (DeepSeek-AI et al. 2025) — OpenAIのo1およびDeepSeek-R1は、強化学習によってモデルに「推論」を教えられることを示しました。思考の連鎖、バックトラッキング、自己検証が報酬シグナルのみから自発的に創発しました。モデルは、競技レベルの数学や複雑なプログラミングタスクを解決し始めました。

10. エージェントAI (2025年〜現在) — 融合点：標準化されたツールアクセス（MCP）、エージェント間通信（A2A）、長期記憶、および洗練されたオーケストレーションフレームワークを備えた、推論能力を持つLLM。現在、エージェントは自律的にコードを書き、調査を行い、ワークフローを管理し、他のエージェントと連携します。これこそが本ガイドのメインテーマです。

Tip

各マイルストーンには共通する流れがあります： アーキテクチャの革新 \(+\) スケール \(+\) 学習シグナル \(=\) 突破口（ブレイクスルー） 。Deep Blueは手作りの探索を利用しました。AlphaGoは自己対戦から学びました。GPT-3はインターネットのテキストから学びました。今日のエージェントシステムは、人間のフィードバック、検証可能な報酬、および環境とのインタラクションから学習します。学習シグナルはゲームの勝敗から、オープンエンドな人間の選好へと拡大し、アーキテクチャもそれに合わせて拡張されてきました。

本ガイドは、基盤モデルの時代からストーリーを引き継ぎ、アライメント、推論、および自律的なエージェント機能へと進めていきます。

本書に期待できること

第I部：基礎 (第1章〜第3章) は、本ガイドの残りの部分が依存する基礎知識を構築します。LLMが内部でどのように機能するのかという能力を決定するアーキテクチャの決定から始め、次に学習と推論を可能にするハードウェアとシステムをカバーし、最後に強化学習を第一原理から導入します。

• 第1章 — LLMアーキテクチャと最適化: Transformerの内部構造（自己注意、マルチヘッドアテンション、RoPE、GQA）、Flash Attention、最適化手法（AdamW、学習率のスケジュール、勾配クリッピング）、混合精度、LoRA/QLoRA、量子化、知識蒸留、およびMixture of Experts。

• 第2章 — システムの基礎: GPUアーキテクチャ（A100/H100/B200）、メモリ階層、NVLink/NVSwitch、分散学習（FSDP、DeepSpeed ZeRO、テンソル/パイプライン並列化）、および高スループット推論のためのvLLM。

• 第3章 — 強化学習への導入: MDP、ベルマン方程式、TD学習、Q学習、方策勾配（REINFORCE）、アクター・クリティック手法、GAEなど、第II部を支えるアルゴリズムツールキット。

第II部：LLMのための強化学習手法 (第4章〜第12章) は、学習とアライメントの核心です。ここでは、詳細な数学的導出から動くコードまで、言語モデルのアライメント、改善、およびファインチューニングを行う方法を学びます。

• 第4章〜第8章: 数学、直感、およびTRLコードを用いた主要なすべての強化学習/選好アルゴリズム — PPO、DPO、GRPO、および選好最適化のバリアント（Online DPO、KTO、IPO、ORPO、SimPO、Best-of-N）。

• 第9章〜第10章: 報酬モデルの学習（Bradley–Terryモデル、スケーリング則、報酬ハッキング）およびSFTのベストプラクティス（データの品質、カリキュラム、フォーマット）。

• 第11章〜第12章: 大規模システムアーキテクチャ（分離された学習、耐障害性、GPU割り当て）およびLLMエージェント学習 — 軌跡レベルの強化学習を用いたエンドツーエンドのエージェント学習方法。

第III部：推論 (第13章) は、複数ステップの問題を通じてLLMに推論を教えるという、モデル能力のフロンティアをカバーします。

• 第13章 — 大規模推論モデル向け強化学習: DeepSeek-R1、OpenAI o1/o3/o4-mini、QwQ — 強化学習が思考の連鎖を発見する仕組み、MCTS、プロセス報酬モデル、およびテスト時計算量（test-time compute）のスケーリング。

第IV部：評価 (第14章) は、これらが実際に機能するかどうかを測定するための方法論を提供します。

• 第14章 — LLM評価: メトリクス（パープレキシティ、pass@k、ELO）、LLM-as-Judgeパターン、データ汚染検出、ベンチマークスイート、およびエージェントの評価手法。

第V部：エージェントAI (第15章〜第26章) は、学習済みモデルからデプロイされた自律システムへと進みます。これが最大のセクションであり、エージェントが現実世界で動作するために必要なすべてをカバーしています。

• 第15章 — エージェントAIへの導入: システムをエージェントたらしめるもの、チャットボットから自律型エージェントまでのスペクトル、および第V部の残りの部分の基礎概念。

• 第16章 — RAG: 検索手法、チャンキング、埋め込みモデル、ハイブリッド検索、リランキング、およびプロダクションアーキテクチャ。

• 第17章 — メモリシステム: 持続的なエージェント知識のためのワーキングメモリ、エピソードメモリ、セマンティックメモリ、およびプロシージャルメモリ。

• 第18章 — オーケストレーション: ReAct、Plan-and-Execute、LLM Compiler、リフレクションパターン、文脈管理、およびハーネス設計。

• 第19章 — デザインパターン: プロンプトの連鎖、ルーティング、並列化、評価主導のオーケストレーション、およびシンプルさの原則。

• 第20章 — 環境とベンチマーク: WebArena、SWE-bench、OSWorld、GAIA — エージェント能力の評価用環境。

• 第21章 — Model Context Protocol (MCP): アーキテクチャ、トランスポート層、ツール/リソース/プロンプトのプリミティブ、セキュリティ、およびデプロイ。

• 第22章 — エージェントスキル: スキルライブラリ、ツールの構成、および能力の抽象化。

• 第23章 — A2A（エージェント間）通信: GoogleのAgent-to-Agentプロトコル — エージェントカード（Agent Card）、タスクライフサイクル、ストリーミング、エンタープライズパターン。

• 第24章 — マルチエージェントシステム: 階層型、ディベート型、マーケットプレイス型、スウォーム（群れ）型アーキテクチャ — 大規模な連携。

• 第25章 — 開発フレームワーク: LangGraph、CrewAI、AutoGen、OpenAI Agents SDK、Google ADK — コード付き比較分析。

• 第26章 — エージェントUI: ストリーミングインターフェース、生成UI、キャンバスパラダイム、ツールの可視化、Human-in-the-Loopパターン。

現代のAIパイプライン

ベースモデルからデプロイされたエージェントまでの完全なパイプライン：

LLMのアーキテクチャと最適化手法

この章では、大規模言語モデルの基礎となるアーキテクチャと、学習・推論を効率化する主要な最適化手法を扱います。内容はカリキュラムとして順序付けられており、まずTransformerそのものを取り上げ、効率的な学習、低コストな適応、圧縮、スケーリング、推論の高速化へと進みます。

LLMの仕組み：直感的な概要

アーキテクチャの詳細に入る前に、大規模言語モデルがどのようにテキストをテキストへ変換するのか、直感を養いましょう。全体の処理は、単純なパイプライン テキスト \(\to\) トークン \(\to\) 表現 \(\to\) トークン \(\to\) テキスト に従います。

Important

4つの主要ステージ

1. トークン化 ：学習済みの語彙を使い、生のテキストをサブワード片（文字でも完全な単語でもない）へ分割します。「unhappiness」は [「un」、「happiness」] または [「unhapp」、「iness」] になることがあります。

2. 埋め込み ：各トークンIDで学習済みの埋め込みテーブルを参照し、\(\mathbb{R}^d\) の密ベクトル（通常は \(d = 4096\)）を生成します。これらのベクトルは意味を捉え、似た単語には似たベクトルが割り当てられます。

3. 文脈処理 ：Transformerスタックは、自己注意を使って各位置が他のすべての位置から「読み取れる」ようにしながら、すべての埋め込みを並列処理します。\(L\) 層後には、各位置の隠れ状態が豊かな文脈情報を符号化します。

4. 予測 ：最後の隠れ状態を語彙全体にわたる確率分布へ射影し、デコーディング戦略で次のトークンを選択します。

トークン化

トークン化は、生のテキストを言語モデルが扱う離散記号へ変換する重要な最初のステップです。トークナイザーの選択は、モデル品質、多言語対応能力、計算効率に直接影響します。

Tip

なぜサブワードなのか？

文字レベルのモデルは非常に長いシーケンスを必要とし、アテンションのコストが高くなります。単語レベルのモデルは、まれな単語や新しい単語を扱えません。サブワードトークン化はこのバランスを理想的に取ります。一般的な単語は単一トークン（「the」 \(\to\) [the]）になり、まれな単語は既知の断片（「cryptocurrency」 \(\to\) [「crypt」、「ocur」、「rency」]）へ分解され、語彙サイズも扱いやすい範囲（32K〜128Kトークン）に収まります。

なぜ文字でも単語でもないのか？

異なるトークン化粒度のトレードオフ。

Byte-Pair Encoding（BPE）

BPE (Sennrich et al. 2016) は、GPT、Llama、Mistral、その他の多くの現代的なLLMで使われる主要なトークン化アルゴリズムです。

Important

BPEアルゴリズム

1. 個々の文字（バイト）からなる語彙を用意する

2. 学習コーパス内の隣接する記号ペアをすべて数える

3. 最も頻度の高いペアを新しい記号へマージする

4. 目的の語彙サイズに達するまで、ステップ2〜3を \(k\) 回繰り返す

その他のトークン化手法

サブワードトークン化アルゴリズムの比較。

トークン化のベストプラクティス

1. 語彙サイズは重要 ：32Kは最小限であり、128Kなら多言語対応とコード処理が向上します。Llama-3は128Kトークンを使用します。

2. 特殊トークン ：<bos>、<eos>、<pad>、<unk> は必ず含めます。指示調整済みモデルでは、役割マーカー（<|user|>、<|assistant|>）を追加します。

3. Fertility（分割度） ：言語ごとに単語あたりのトークン数を測定します。Fertilityが高い（1単語あたりのトークンが多い）場合、その言語のカバレッジが低いことを示します。

4. 境界をまたいでトークン化しない ：空白、句読点、数字は一貫して扱う必要があります。現代の多くのトークナイザーは、単語の先頭トークンと継続トークンを区別するために、空白マーカー（「the」）を前置します。

5. 数字 ：算術タスクでは数字レベルのトークン化を検討します。「2024」を [「2」、「0」、「2」、「4」] とすれば、桁ごとの推論が可能になります。

6. コード ：空白（インデント）が効率的にトークン化されるようにします。Llama-3は連続する空白を単一トークンとしてトークン化します。

実践的なトークン化：HuggingFaceの例

transformersライブラリは、すべてのトークナイザーに統一インターフェースを提供します。以下では、現代的なLLMトークナイザーによるエンコードとデコードを示します。

from transformers import AutoTokenizer

# Load Llama-3 tokenizer (128K vocabulary, byte-level BPE)
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B")

text = "Reinforcement learning optimizes long-term rewards."

# Encode: text -> token IDs
token_ids = tokenizer.encode(text)
print(token_ids)
# [128000, 29934, 262, 11008, 4815, 6900, 1317, 9860, 21845, 13]

# Decode individual tokens to see subword splits
tokens = tokenizer.convert_ids_to_tokens(token_ids)
print(tokens)
# ['<|begin_of_text|>', 'Re', 'inforce', 'ment', ' learning',
#  ' optimizes', ' long', '-term', ' rewards', '.']

# Decode back to text (round-trip)
reconstructed = tokenizer.decode(token_ids, skip_special_tokens=True)
assert reconstructed == text  # Perfect reconstruction

# Tokenize with attention mask (for batched inputs with padding)
batch = tokenizer(
    ["Short text.", "A much longer input sentence for comparison."],
    padding=True, return_tensors="pt"
)
print(batch.keys())  # dict_keys(['input_ids', 'attention_mask'])

特殊トークンと構造化プロンプト

特殊トークンは、言語的な内容ではなく構造的な意味を持つ、予約済みの語彙エントリです。モデルの挙動を制御するうえで不可欠です。

LLMファミリーに共通する特殊トークン。

指示調整済みモデルの役割マーカー

現代のチャットモデルは、会話の構造を区切るために特殊トークンを使います。これらは意味を担うように学習されるのではなく、モデルが解析方法を学習する構造上の区切り記号です。

# Llama-3 chat template
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain PPO in one sentence."},
]

# apply_chat_template handles all special token insertion
prompt = tokenizer.apply_chat_template(messages, tokenize=False)
print(prompt)
# <|begin_of_text|><|start_header_id|>system<|end_header_id|>
#
# You are a helpful assistant.<|eot_id|><|start_header_id|>user<|end_header_id|>
#
# Explain PPO in one sentence.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
#
#

Important

特殊トークンのベストプラクティス

• 特殊トークンを分割しない ：特殊トークンは不可分でなければなりません。トークナイザーが文字列ではなく単一の単位として扱うことを確認します。

• 特殊トークンの損失をマスクする ：SFTでは、構造トークン（役割マーカーや区切り記号）に対する損失を計算しません。モデルに書式の予測を「学習」させるべきではありません。

• 構造にはテンプレートを使う ：自然言語の指示ではなく、特殊トークンでタスクの意味を符号化します。たとえば、<|tool_call|> は「これからツールを呼び出します：」より信頼性が高くなります。

• ツール／関数呼び出し ：<|function|> や <|result|> のような専用トークンを定義し、推論と行動の間に曖昧さのない境界を作ります。

• RLで一貫して扱う ：PPO／GRPOでは、参照モデルと方策モデルが同一のトークン化と特殊トークン処理を使うようにします。不一致があるとKLの計算が壊れます。

• EOSを扱う ：生成時には、EOSが行動空間に含まれるようにします。モデルがEOSを出力できないと、応答が際限なく長くなります（RLでよくある失敗モードです）。

Transformerアーキテクチャ

Transformer (Vaswani et al. 2017) は、現代のLLMすべての基盤です。その構成要素を理解することは、このガイドで扱うあらゆる最適化・学習手法を把握するうえで不可欠です。

全体構造

Decoder-Only Transformerは、埋め込み、繰り返し配置されたアテンション＋FFNブロック、語彙ロジットへの最終射影を通して、トークンを逐次処理します。図1.1にアーキテクチャ全体を示します。

元祖Encoder-Decoder Transformer

Transformerはもともと、系列変換タスク（機械翻訳、要約）向けの Encoder-Decoder アーキテクチャとして導入されました (Vaswani et al. 2017)。現代のLLMは主にDecoder-Only版（GPT形式）を使いますが、完全なアーキテクチャを理解することは重要です。ここで生まれたクロスアテンションとマスク付き自己注意は、今も基本的な構成要素だからです。

エンコーダ

エンコーダは入力シーケンス全体を 双方向に 処理します。つまり各トークンは他のすべてのトークンに注意を向けます（因果マスクはありません）。これにより、各位置が入力全体の情報を符号化する、豊かな文脈表現 \(\mathbf{H}^{\text{enc}} \in \mathbb{R}^{n \times d}\) が得られます。

• 入力 ：トークン埋め込み＋正弦波位置エンコーディング

• 各レイヤー ：マルチヘッド自己注意 \(\to\) Add & Norm \(\to\) FFN \(\to\) Add & Norm

• 因果マスクなし ：位置 \(i\) はすべての位置 \(1, \ldots, n\) に注意を向ける

• 出力 ：入力シーケンス全体の文脈表現

デコーダ — マスク付きマルチヘッド自己注意

デコーダは出力トークンを一度に1つずつ（自己回帰的に）生成します。モデルが「未来を見る」ことを防ぐため、デコーダの自己注意には 因果マスク を使います。

\[ \text{MaskedAttn}(Q, K, V) = \text{softmax}!\left(\frac{QK^T}{\sqrt{d_k}} + M\right) V \]

ここでマスク \(M\) は次のとおりです。

\[ M_{ij} = \begin{cases} 0 & \text{if } i \geq j \text{ (can attend)} \\ -\infty & \text{if } i < j \text{ (future token --- blocked)} \end{cases} \]

Tip

マスキングが重要な理由

学習中、デコーダはターゲットシーケンス全体を並列に処理します（教師強制）。しかし自己回帰性を保つには、各位置が直前までの位置だけに注意を向けなければなりません。このマスクにより、トークン \(t\) の生成にはトークン \(1, \ldots, t{-}1\) の情報だけが使われます。推論時はトークンを1つずつ生成するためマスクは暗黙的ですが、学習時には因果性を保ちながら並列計算を可能にします。

デコーダ — クロスアテンション

マスク付き自己注意の後、各デコーダレイヤーは クロスアテンション を適用します。ここではデコーダがエンコーダの出力表現に注意を向けます。これが、デコーダが入力を「読み取る」仕組みです。

\[ \text{CrossAttn}(Q_{\text{dec}}, K_{\text{enc}}, V_{\text{enc}}) = \text{softmax}!\left(\frac{Q_{\text{dec}} K_{\text{enc}}^T}{\sqrt{d_k}}\right) V_{\text{enc}} \]

• クエリ はデコーダの直前のサブレイヤー（マスク付き自己注意の出力）から来る

• キーとバリュー はエンコーダの最終出力 \(\mathbf{H}^{\text{enc}}\) から来る

• マスクは 適用しない。すべてのデコーダ位置が、すべてのエンコーダ位置に注意を向けられる

• これにより、デコーダは生成ステップごとに入力の異なる部分へ動的に焦点を当てられる（たとえば英語\(\to\)スペイン語の翻訳で「cat」から「gato」へ訳す際に「cat」へ注意を向ける）

完全なデコーダレイヤー

各デコーダレイヤーには、エンコーダの2つに対して3つのサブレイヤーがあります。

1. マスク付きマルチヘッド自己注意＋残差＋LayerNorm

2. マルチヘッドクロスアテンション （エンコーダ出力に対するもの）＋残差＋LayerNorm

3. フィードフォワードネットワーク＋残差＋LayerNorm

Encoder-DecoderからDecoder-Onlyへ

現代のLLM（GPT、Llama、Qwen）はデコーダだけを使い、エンコーダとクロスアテンションレイヤーを完全に取り除いています。重要な洞察は、生成言語モデリングには単一の因果（マスク付き）自己注意スタックで十分だということです。モデルは1回のパスで文脈の符号化と続きの生成を学習します。これによりアーキテクチャ、学習、推論が単純になり、より効果的にスケールできます。Encoder-Decoderモデル（T5、BART）は、入力と出力の構造が分かれるタスク（翻訳、要約）では依然として有用です。また、ビジョンエンコーダが言語デコーダへキー／バリューを提供するマルチモーダルモデルでは、クロスアテンションが再び現れます。

Decoder-OnlyとEncoder-Decoderの比較

現代のLLMはほぼ例外なくDecoder-Onlyアーキテクチャを使いますが、Encoder-Decoder設計とのトレードオフを理解すると、その理由が明確になります。

Warning

Decoder-Onlyが勝った理由

Decoder-Onlyモデルは、構造が単純で（1つのモデル、1つの損失）、よりよくスケールし（すべてのパラメータが生成に寄与し）、統一的な学習（事前学習＝次トークン予測＝ファインチューニングの目的）を実現します。Encoder-Decoderモデルは、純粋な生成タスクではエンコーダに容量を割いてしまいます。

埋め込み：離散トークンから連続空間へ

アテンションや計算を始める前に、Transformerは離散的なトークンIDを、ニューラルネットワークが処理できる連続ベクトルへ変換しなければなりません。これが 埋め込み層 の役割です。

埋め込みとは何か？

埋め込みとは、離散記号を学習された密ベクトルで表現したものです。「king」を、ほとんどがゼロであるサイズ \(\vert \mathcal{V}\vert = 128{,}000\) のone-hotベクトルで表す代わりに、その 意味 を捉える \(\mathbb{R}^d\) 内のコンパクトなベクトル（例：\(d = 4096\)）で表します。

重要な洞察は、 似た概念には近いベクトルが割り当てられる ことです。十分に学習された埋め込み空間では、次のようになります。

• 「king」と「queen」は近い（どちらも王族）

• 「king」と「bicycle」は遠い（無関係）

• ベクトル演算が関係を捉える：\(\vec{\text{king}} - \vec{\text{man}} + \vec{\text{woman}} \approx \vec{\text{queen}}\)

埋め込みテーブル

実際には、埋め込み層は単純な行列 \(\mathbf{E} \in \mathbb{R}^{\vert \mathcal{V}\vert \times d}\) です。行 \(i\) にはトークン \(i\) の埋め込みベクトルが格納されます。

\[ \text{embed}(x_t) = \mathbf{E}[x_t] \in \mathbb{R}^d \]

トークンIDのシーケンス \([x_1, x_2, \ldots, x_n]\) に対する埋め込みは、単純なテーブル参照（インデックス操作）です。

\[ \mathbf{H}_0 = [\mathbf{E}[x_1];; \mathbf{E}[x_2];; \ldots;; \mathbf{E}[x_n]] \in \mathbb{R}^{n \times d} \]

Important

Transformerにおける埋め込みテーブル

• サイズ ：\(\vert \mathcal{V}\vert \times d\)。Llama-3の場合、\(128{,}256 \times 4{,}096 = 525\)Mパラメータ（8Bモデルの6.5%）。

• 初期化 ：ランダム（Xavier／正規分布）で初期化し、その後バックプロパゲーションで学習する。

• 重み共有 ：多くのモデルは、埋め込み行列と出力射影ヘッドを 共有 します：\(W_{\text{head}} = \mathbf{E}^T\)。パラメータを節約し、対称的なエンコード・デコード構造を作ります。

• 入力 ：トークンID（整数）\(\to\) 出力 ：\(\mathbb{R}^d\) 内の密ベクトル。

• 勾配の流れ ：学習中は、現在のバッチに含まれるトークンに対応する行だけが勾配更新を受ける（スパース更新）。

Tip

埋め込みが機能する理由

埋め込みテーブルはモデルの他の部分とエンドツーエンドで学習されます。モデルは次のトークンを予測するよう学習されるため、似た文脈に現れるトークンに似たベクトルを割り当てる表現を学習しなければなりません。これは分布仮説、すなわち「単語は共に現れる語によって知ることができる」という考えです (Firth 1957)。埋め込み層はこの統計的構造を密な幾何へ圧縮します。

異方性の問題

事前学習済み埋め込み（BERTやGPT-2など）を検索（RAG）や推薦システムの初期構築といった下流タスクに使うと、重大な問題が生じます。学習された表現は非常に 異方的 で、全方向に一様に分布するのではなく、埋め込み空間内の狭い円錐に集中します (Ethayarajh 2019)。

これが応用上重要な理由：

• RAG／検索 ：内容に関係なくすべての埋め込みのコサイン類似度が \(>0.7\) なら、検索順位はほぼランダムになります。システムは関連する文章と無関係な文章を区別できません。

• 推薦システム ：事前学習済みLLMの埋め込みでアイテムやユーザーを表すには、幾何構造が意味のある類似性を保っていなければなりません。

• クラスタリング ：異方的な埋め込みではクラスタがつぶれ、自然なグループ分けを見つけられません。

解決策：ホワイトニング

単純で効果的な修正方法が ホワイトニング です (Su et al. 2021)。これは埋め込み分布を等方的（平均0、共分散が単位行列）にする線形変換です。

\[ \tilde{\mathbf{h}} = \mathbf{D}^{-1/2} \mathbf{U}^T (\mathbf{h} - \boldsymbol{\mu}) \]

ここで \(\boldsymbol{\mu}\) は平均埋め込み、\(\mathbf{U}\mathbf{D}\mathbf{U}^T\) は共分散行列 \(\Sigma = \frac{1}{N}\sum_i (\mathbf{h}_i - \boldsymbol{\mu})(\mathbf{h}_i - \boldsymbol{\mu})^T\) の固有値分解です。

Important

ホワイトニングの実践

• 働き ：すべての方向の分散が等しくなるよう、埋め込み空間を回転・スケーリングする（共分散を単位行列にする）。

• 効果 ：コサイン類似度が意味を持つようになる。意味的に似たペアは高く、異なるペアは低くなる。

• 利点 ：上位 \(k\) 個の固有ベクトルだけを残すことで（PCAと同様に）次元削減も同時に行え、検索が高速になる。

• コスト ：代表的なコーパス上で共分散行列を計算する必要がある（1回だけ、\(O(N \cdot d^2)\)）。変換自体は推論時の単純な行列積である。

• 代替手法 ：対照学習によるファインチューニング（SimCSE）、フローベースの正規化、等方性を促す正則化を使った学習。

自己注意機構

自己注意は、各トークンがシーケンス内の他のすべてのトークンに注意を向け、関連度に基づく重み付き結合を計算できるようにする中核演算です。

Important

スケールド・ドット積アテンション

入力シーケンス \(X \in \mathbb{R}^{n \times d}\) に対して、次を計算します。 \[ Q = XW_Q, \quad K = XW_K, \quad V = XW_V \quad (W_Q, W_K, W_V \in \mathbb{R}^{d \times d_k}) \]

\[ \text{Attention}(Q, K, V) = \text{softmax}!\left(\frac{QK^T}{\sqrt{d_k}} + M\right) V \] ここで \(M\) は 因果マスク （自己回帰モデル用）です：\(i \geq j\) なら \(M_{ij} = 0\)、それ以外なら \(-\infty\) です。

直感 ：各トークンはそれ以前のすべてのトークンに「注意を向け」、クエリとキーの類似度に基づいて、それらのバリューの重み付き平均を計算します。

計算量

素朴なアテンション計算のシーケンス長に対するコストは 二次 です。

• 時間 ：\(O(n^2 \cdot d)\)。\(QK^T\) の計算には、次元 \(d_k\) の内積が \(n^2\) 個必要です。

• メモリ ：\(O(n^2)\)。softmaxを適用するには、アテンション行列全体を実体化する必要があります。

\(d = 4096\) の128Kトークン文脈では、アテンション行列だけで \(128\text{K} \times 128\text{K} = 16.4\) 十億エントリ（FP32で64 GB）になります。この二次スケーリングが、長文脈LLMにおける根本的なボトルネックです。

アテンションコストのスケーリング：長いシーケンスで素朴な実装が法外になる理由。

アテンションコストを抑えるアプローチ

この二次ボトルネックには、いくつかの解決策の系統があります。

1. IOを意識した厳密なアテンション（FlashAttention (Dao et al. 2022)） ：計算量は減らしませんが、SRAMに収まるタイルでアテンションを計算することで、HBM上に \(n \times n\) 行列を実体化する必要をなくします。重要なのは、FlashAttentionが 直交する ことです。これはアテンションパターンではなく実行エンジンです。実運用システムでは、FlashAttentionとスライディングウィンドウやブロックスパースマスクを組み合わせ、I/O効率とFLOPs削減の両方を得るのが一般的です。アルゴリズムの詳細は1.6節で扱います。

2. スライディングウィンドウ／局所アテンション ：各トークンは最も近い \(w\) 個のトークン（例：\(w = 4096\)）にだけ注意を向けます。コストは \(O(n \cdot w)\) となり、\(n\) に対して線形です。Mistral (Jiang et al. 2023)（ウィンドウ \(= 4096\)）やLongformer (Beltagy et al. 2020)で使われています。効率性の代わりにグローバルな文脈を一部失いますが、実際には大部分のアテンションが局所的なのでうまく機能します。現代のスタックでは、スライディングウィンドウマスクはFlashAttentionカーネル 内部 で実行されます。

3. スパースアテンションパターン ：局所ウィンドウと周期的なグローバルトークン（例：512個ごとのトークンがすべてに注意を向ける）を組み合わせます。BigBird (Zaheer et al. 2020)やLongT5 (Guo et al. 2022)がこれを使います。コスト \(O(n\sqrt{n})\) で、長距離の接続性を一部保ちます。ここでもFlashAttentionは、ゼロでないアテンションブロックの基盤カーネルとして機能します。

4. 線形アテンション／状態空間モデル ：結合則を使って \(\text{softmax}(QK^T)V\) を \(\phi(Q)(\phi(K)^T V)\) に置き換えるか、漸化式として定式化し直します（Mamba (Gu and Dao 2023)、RWKV (Bo Peng et al. 2023)）。理論上の総コストは \(O(n \cdot d^2)\) です。上の2〜3とは異なり、これらはモデルの表現力を変える アーキテクチャ置換 です。softmaxなしのアテンションは本質的に表現力が低く、正確な長距離検索や複雑な推論を必要とするタスクでは、実証的にもこれらのモデルはTransformerにまだ遅れています。

5. KVキャッシュ圧縮 ：推論時に古いKVペアを圧縮・破棄し、メモリを一定範囲に抑えます。手法には、H\(_2\)O (Z. Zhang et al. 2023)（heavy-hitter oracle：アテンションの高いキーだけを残す）、StreamingLLM (Xiao et al. 2024a)（初期の「アテンションシンク」トークンと直近ウィンドウを残す）、量子化KVキャッシュ (Z. Liu et al. 2024)があります。

Tip

FlashAttention＋スパースパターン＝両方の利点

FlashAttentionはスパースアテンションの 代替 だという誤解があります。そうではありません。これはアテンションカーネルのI/O最適化であり、任意のアテンションマスクと自由に組み合わせられます。現代のプロダクションシステム（Mistral、DeepSeekなど）は、スライディングウィンドウまたはブロックスパースマスクの 下層 の実行エンジンとしてFlashAttentionを使います。これにより、スパース性によるFLOPs削減と、タイル化による最適なメモリアクセスパターンの両方が得られます。RingAttention (H. Liu et al. 2023) はこれをマルチデバイス環境へ拡張し、シーケンス方向にタイル化された計算をGPU間に分散します。

線形アテンションと状態空間モデル（Mamba、RWKV）は、本質的に異なるアーキテクチャ上の選択です。完全なペアごとの相互作用を犠牲にして \(O(n)\) の計算量を得ます。理論的には洗練されていますが、知識集約的なタスクや長距離推論タスクでTransformerの品質に追いついておらず、最先端の研究所は今も厳密なアテンション（FlashAttention＋スパース性）をバックボーンとして使い続けています。

マルチヘッドアテンション

単一のアテンション関数を計算する代わりに、マルチヘッドアテンションは複数のアテンション演算を並列に実行します。各ヘッドは入力の異なる側面（構文、意味、位置など）に焦点を当てるよう学習します。

Important

マルチヘッドアテンション

\(d\) 次元のキー／バリューを持つ1つのアテンション関数の代わりに、次元 \(d_k = d/H\) の \(H\) 個のヘッドを並列に使います。 \[ \text{MultiHead}(X) = \text{Concat}(\text{head}_1, \ldots, \text{head}_H) W_O \] 各ヘッドは異なるアテンションパターンを学習できます（例：構文用、意味用、位置の近さ用にそれぞれ1つのヘッド）。

Grouped Query Attention（GQA） ：Llama-3 (Grattafiori et al. 2024) は、Qヘッドより少ないK、Vヘッドを使います（例：32個のQヘッドで8個のKVヘッドを共有）。品質をほとんど損なわずにKVキャッシュのサイズを \(4\times\) 削減できます。

位置エンコーディング

Transformerは構造上、置換同変です。位置情報がなければ、モデルは「the cat sat on the mat」と「mat the on sat cat the」を区別できません。位置エンコーディングはシーケンス順序のシグナルを注入し、アテンションがトークン間の距離と方向を推論できるようにします。

現代のLLMにおける位置エンコーディング手法。

正弦波（固定）位置エンコーディング

元祖Transformer (Vaswani et al. 2017) で導入されたこの手法は、等比間隔の周波数における固定正弦関数を使います。

\[ \text{PE}(pos, 2i) = \sin!\Bigl(\frac{pos}{10000^{2i/d}}\Bigr), \qquad \text{PE}(pos, 2i{+}1) = \cos!\Bigl(\frac{pos}{10000^{2i/d}}\Bigr) \]

ここで \(pos\) はトークン位置、\(i\) は次元インデックス、\(d\) はモデルの次元です。

動機 ：各周波数は異なるスケールで位置を符号化します（2進数のカウントに似ています）。著者らは、\(\text{PE}(pos+k)\) を \(\text{PE}(pos)\) の線形関数として表せるため、モデルが相対位置へ注意を向けることを学習できると仮定しました。

長所 ：学習パラメータがゼロ。決定的。理論上は任意の長さに対応する。
短所 ：実際には学習時の長さを超えるとうまく外挿できない。モデルは絶対信号から相対位置を間接的に復号する必要があり、現在はほぼ置き換えられている。

学習型絶対位置埋め込み

GPT-2 (Radford et al. 2019) とBERT (Devlin et al. 2019)で使われています。学習可能な埋め込み行列 \(\mathbf{E}_{\text{pos}} \in \mathbb{R}^{L_{\max} \times d}\) をトークン埋め込みに加えます。

\[ h_0^{(pos)} = \text{TokenEmbed}(x_{pos}) + \mathbf{E}_{\text{pos}}[pos] \]

動機 ：固定構造を押し付けるのではなく、タスクに最適な位置表現をモデル自身に学習させる。

長所 ：柔軟性が最大。実装が単純。短いシーケンスでは正弦波を上回ることが多い。
短所 ：最大長 \(L_{\max}\) がハードコードされ、それを超えて一般化できない。\(L_{\max}\) の末尾近くの埋め込みは学習不足になる。\(L_{\max} \times d\) 個のパラメータが増える。

回転位置埋め込み（RoPE）

RoPE (Su et al. 2024) は、2次元部分空間内でクエリとキーベクトルを 回転 させることで位置を符号化します。

\[ \text{RoPE}(x_m, m) = \begin{pmatrix} x_m^{(1)} \\ x_m^{(2)} \\ \vdots \\ x_m^{(d-1)} \\ x_m^{(d)} \end{pmatrix} \odot \begin{pmatrix} \cos m\theta_1 \\ \cos m\theta_1 \\ \vdots \\ \cos m\theta_{d/2} \\ \cos m\theta_{d/2} \end{pmatrix} + \begin{pmatrix} -x_m^{(2)} \\ x_m^{(1)} \\ \vdots \\ -x_m^{(d)} \\ x_m^{(d-1)} \end{pmatrix} \odot \begin{pmatrix} \sin m\theta_1 \\ \sin m\theta_1 \\ \vdots \\ \sin m\theta_{d/2} \\ \sin m\theta_{d/2} \end{pmatrix} \]

ここで \(\theta_i = 10000^{-2i/d}\)、\(m\) は位置インデックスです。重要な性質は、回転後のクエリとキーの内積が相対位置だけに依存することです。

\[ \langle \text{RoPE}(q_m, m),; \text{RoPE}(k_n, n) \rangle = f(q_m, k_n, m-n) \]

動機 ：明示的なバイアス項なしに相対位置の符号化を実現し、線形アテンションやKVキャッシュとの互換性も保つ。

長所 ：自然に相対的。追加パラメータ不要。効率的な推論と互換性がある。NTKを意識したスケーリング (Bowen Peng et al. 2023) やYaRN（\(\theta\) の基底を調整する、または周波数を補間する）で長い文脈へ拡張できる。
短所 ：アテンション演算ごとの計算量がやや増える（回転＋インターリービング）。外挿には明示的なスケーリング戦略が必要。2次元部分空間での回転が構造を課すため、すべてのタスクに最適とは限らない。

Tip

RoPEの長さ拡張

\(L\) で学習したRoPEモデルを文脈長 \(L' > L\) へ拡張するには、次のようにします。

• 位置補間 ：すべての位置が \([0, L]\) に収まるよう、位置を \(L/L'\) 倍にスケールする。単純だが解像度が圧縮される。

• NTKを意識したスケーリング ：\(\theta\) の基底を増やす（例：\(10000 \to 10000 \cdot (L'/L)^{d/(d-2)}\)）。低周波成分を保ちながら高周波成分を実質的に引き伸ばす。

• YaRN (Bowen Peng et al. 2023)：NTKスケーリングとアテンション温度補正 \(t = 0.1 \ln(s) + 1\) を組み合わせ、長距離で増えるエントロピーを補正する。

ALiBi（線形バイアス付きアテンション）

ALiBi (Press et al. 2022) は根本的に異なるアプローチを取ります。位置埋め込みをまったく使いません。その代わり、固定の線形ペナルティをアテンションスコアから差し引きます。

\[ \text{Attention}(Q, K, V) = \text{softmax}!\left(\frac{QK^T}{\sqrt{d_k}} - m \cdot \bigl[|i-j|\bigr]_{i,j}\right) V \]

ここで \(m\) はヘッド固有の傾きです（全 \(H\) 個のヘッドのうちヘッド \(h\) に対して、幾何的に \(m_h = 2^{-8h/H}\) と設定）。バイアス \(-m\vert i-j\vert\) は、幅がヘッドごとに変わる緩やかな局所アテンションウィンドウを作ります。

動機 ：埋め込み空間に干渉せず、位置によって近いトークンへアテンションを偏らせるべきです（新しさの事前分布）。アテンションスコア空間だけで動作するため、ALiBiはトークン表現を位置シグナルで汚しません。

長所 ：長さの外挿性が非常に高い（1Kで学習して8K以上で動作）。パラメータゼロ。実装が容易。ヘッド固有の傾きにより、複数スケールの局所性を持つ。
短所 ：正確な長距離位置推論を必要とするタスク（例：「5番目の単語は何だったか？」）では表現力が低い。線形減衰という強い帰納バイアスがすべての領域に適するとは限らない。近年のモデルでは、短文脈での性能がより高いRoPEにほぼ取って代わられている。

位置エンコーディングの比較：実用上のトレードオフ。

極端に長い文脈へのスケーリング（100K〜1M以上のトークン）

現代の最先端モデル（200K〜1M文脈のClaude (Anthropic 2024c)、1M以上のGemini 1.5 (Gemini Team 2024)、128KのGPT-4 (OpenAI 2023)）には、学習時の長さをはるかに超えても忠実に機能する位置エンコーディングが必要です。現在の主流の解決策は次のとおりです。

1. 周波数スケーリング付きRoPE ：RoPEを学習時の長さを超えて拡張する標準的な方法です。再学習する代わりに、基底周波数 \(\theta\) を再スケーリングします。

   \[ \theta'_i = \theta_i \cdot \left(\frac{L_{\text{target}}}{L_{\text{train}}}\right)^{2i/d} \]

   その派生には次がある。

   • 線形スケーリング（位置補間） (S. Chen et al. 2023)：位置インデックスを係数 \(s\) で単純に割る。安価だが、拡張比が大きいと品質が低下する。

   • NTKを意識したスケーリング (Bowen Peng et al. 2023)：基底周波数を \(\theta = 10000 \to 10000 \cdot s^{d/(d-2)}\) とスケールする。高周波（局所）情報を保ちながら、低周波（グローバル）の範囲を拡張する。

   • YaRN (Bowen Peng et al. 2023)（Yet another RoPE extensioN）：NTKスケーリングとアテンション温度補正、小規模な長文脈コーパスでのファインチューニングを組み合わせる。Llama-3では学習時の8Kからデプロイ時の128Kへ拡張するために使われる。

   • Dynamic NTK (Bowen Peng et al. 2023)：推論時の実際のシーケンス長に応じて、スケーリング係数をオンザフライで調整する。固定の拡張比は不要で、文脈が長くなるとモデルが適応する。

2. 長いデータでの継続事前学習 ：RoPEスケーリングを使っても、長い文書で短期間（1〜5Bトークン）の継続事前学習を行うとモデルは向上します。これにより、位置的に耐えられるだけでなく、遠い文脈を実際に 使う ことを学習します。Llama-3.1では8K \(\to\) 64K \(\to\) 128Kという段階的スケジュールを使いました。

3. Ring Attention／ブロック単位並列 (H. Liu et al. 2023)：単一GPUのメモリを超えるシーケンス（1M以上のトークン）では、Ring Attentionがリング型トポロジーでシーケンスをGPU間に分散します。各GPUが1ブロックを保持し、KVブロックをリングに沿って渡しながら局所アテンションタイルを計算します。厳密なアテンションを保ったまま、GPU数に対してメモリを線形にスケールできます。

4. ハイブリッドアーキテクチャ ：一部のシステムは、大部分のレイヤーで局所的なスライディングウィンドウ（例：4K）を使い、選択したレイヤー（例：4層ごと）では完全なアテンションを組み合わせます。これにより、グローバルな情報の流れを保ちながら、ほとんどの計算を \(O(n \cdot w)\) のコストで行えます。

Warning

長い文脈 $\neq$ 長い文脈利用

コンテキスト長が1Mのモデルが、1Mトークンすべてを必ずしも効果的に使えるとは限らない。「中間で失われる」現象（N. F. Liu et al. 2024a）は、モデルが長いコンテキストの先頭と末尾に集中し、中間の情報を十分に利用しない傾向を示す。長文脈を効果的に利用するには、位置エンコーディングのサポートと長距離検索に報いるタスクでの学習の両方が必要である。

フィードフォワードネットワーク（MLP）

各Transformerブロックには、各位置へ独立に適用されるMLPが含まれる。

\[ \text{FFN}(x) = W_2 \cdot \sigma(W_1 x + b_1) + b_2 \]

ここで \(W_1 \in \mathbb{R}^{d \times 4d}\)、\(W_2 \in \mathbb{R}^{4d \times d}\) です。現代のLLMでは次を使います。

• SwiGLU活性化 ：\(\text{FFN}(x) = W_2 (\text{Swish}(W_1 x) \odot W_3 x)\)。Llama (Grattafiori et al. 2024) やMistral (Jiang et al. 2023)で使われます。重み行列が3つ必要ですが、性能が向上します。

• 隠れ次元は通常 \(8/3 \times d\) です（Tensor Coreの効率のため256の倍数に丸めます）。

Tip

メモリとしてのFFN

近年の研究 (Geva et al. 2021) は、FFNレイヤーが キーバリューメモリ として機能すると示唆しています。\(W_1\) の行はキー（照合するパターン）、\(W_2\) の列はバリュー（出力する情報）です。FFNは現在の隠れ状態に基づき、保存された知識を「取り出します」。

Layer Normalization（層正規化）

Layer Normalizationは特徴次元にわたって活性値を正規化し、学習を安定させます。アテンション／FFNサブレイヤーに対する配置は、学習ダイナミクスに大きな影響を与えます。

LayerNormの仕組み

隠れ状態ベクトル \(\mathbf{x} \in \mathbb{R}^d\)（1つのトークンの表現）に対して、LayerNorm (Ba et al. 2016) は次を計算します。

\[ \text{LayerNorm}(\mathbf{x}) = \gamma \odot \frac{\mathbf{x} - \mu}{\sqrt{\sigma^2 + \epsilon}} + \beta \]

ここで、

• \(\mu = \frac{1}{d}\sum_{i=1}^{d} x_i\)（\(d\) 個の特徴次元にわたる平均）

• \(\sigma^2 = \frac{1}{d}\sum_{i=1}^{d} (x_i - \mu)^2\)（特徴にわたる分散）

• \(\gamma, \beta \in \mathbb{R}^d\) は 学習される スケール・シフトパラメータ（次元ごと）

• \(\epsilon \approx 10^{-5}\) はゼロ除算を防ぐ

BatchNormとの重要な違い ：LayerNormはバッチ全体ではなく、1つの例の 特徴次元 にわたって正規化します。そのためバッチサイズに依存せず、学習時と推論時で同じように動作します。

RMSNorm — 現代的な簡略化

RMSNorm (Zhang and Sennrich 2019) は平均を中心化するステップを省き、二乗平均平方根だけで正規化します。

\[ \text{RMSNorm}(\mathbf{x}) = \gamma \odot \frac{\mathbf{x}}{\text{RMS}(\mathbf{x})}, \qquad \text{RMS}(\mathbf{x}) = \sqrt{\frac{1}{d}\sum_{i=1}^{d} x_i^2} \]

\(\beta\)（シフト）パラメータも平均の減算もなく、スケールだけを行います。トークンごとに1回のリダクション演算を節約でき、同等のモデル品質を保ちながらGPU上で \(\sim\) 5〜10%高速になります。現代のLLM（Llama、Mistral、Qwen）はすべてRMSNormを使います。

Important

Pre-LNとPost-LNの比較

• Post-LN （元祖Transformer）：\(h + \text{LayerNorm}(\text{Attn}(h))\)。慎重なウォームアップが必要で、学習が不安定になり得る。

• Pre-LN （GPT-2以降、現代のLLMすべて）：\(h + \text{Attn}(\text{LayerNorm}(h))\)。学習を安定させ、より高い学習率を可能にする。

• RMSNorm （Llama (Grattafiori et al. 2024)、Mistral (Jiang et al. 2023））：平均中心化を行わない簡略版LayerNorm：\(\text{RMSNorm}(x) = x / \text{RMS}(x) \cdot \gamma\)。やや高速で品質は同じ。

Tip

深いネットワークで正規化が重要な理由

正規化がないと、活性値はレイヤーを通るにつれて指数的に増大・縮小します（活性値の爆発・消失）。LayerNormのない128層Transformerでは、最初と最後のレイヤーで大きさが \(10^{30}\times\) も変わり得ます。正規化は各レイヤーの出力を予測可能な範囲に制限し、安定した勾配の流れと、ネットワーク全体で一貫した学習率の利用を可能にします。

モデルサイズの目安

以下の表は、広く使われているオープンウェイトモデル（2025年時点の最新版）の主要なアーキテクチャパラメータをまとめたもので、規模と設計上の選択を理解するための早見表です。

人気のオープンウェイトLLM（2024〜2025世代）のアーキテクチャパラメータ。

注：「active」と記されたパラメータを持つモデルはMixture-of-Experts（MoE）アーキテクチャを使います。総パラメータ数はモデル容量を示し、activeパラメータはトークンごとの計算コストを表します。DeepSeek-V3は標準GQAの代わりにMulti-head Latent Attention（MLA）を使い、KVを低ランクの潜在空間へ圧縮します。

アテンションの病理

アテンション機構は強力ですが、体系的な失敗モードも示します。特に長い文脈へスケールする場合や、モデルの挙動を解釈する場合には、実務者が理解しておく必要があります。

アテンションシンク

現象

Xiaoら (Xiao et al. 2024b) は、Transformerモデルが意味内容に関係なく、シーケンスの 最初のトークン に不釣り合いに高いアテンションスコアを割り当てることを発見しました。最初のトークンが意味を持たない <BOS> マーカーであっても、全レイヤーのアテンションヘッドが一貫してそこへ注意を向け、総アテンション量の20〜50%に達することさえあります。

なぜ起こるのか

Softmaxアテンションは妥当な確率分布（\(\sum_j \alpha_j = 1\)）を生成しなければなりません。クエリに特に関連するキーがないとき、モデルには未使用のアテンション量を捨てる場所が必要です。学習中、最初のトークンは常に存在し位置的に予測しやすいため、このデフォルトのシンクになります。これは 何もしないアテンションの対象 として機能し、モデルは無関係なアテンションを予測不能に分散させず、そこへ送ることを学習します。

\[ \alpha_{\text{sink}} = \frac{\exp(q^\top k_0 / \sqrt{d})}{\sum_{j} \exp(q^\top k_j / \sqrt{d})} \gg \frac{1}{n} \quad \text{(even when } k_0 \text{ is semantically irrelevant)} \]

結果

• ストリーミング推論の失敗 ：スライディングウィンドウKVキャッシュを使うとき、最初のトークンを破棄するとパープレキシティが壊滅的に急上昇します。モデルがアテンションシンクを失うためです。

• 誤解を招く解釈可能性 ：素朴なアテンション可視化では、単なる数学的な人工物である最初のトークンが「重要」に見えます。

• 文脈ウィンドウの浪費 ：シンクトークンは有用な情報を持たないまま、KVキャッシュのスロットを占有します。

解決策

• StreamingLLM (Xiao et al. 2024b：最近のスライディングウィンドウとともに、最初の\(k\)個のトークン（「アテンションシンク」）を常にKVキャッシュに残す。メモリを一定に保ったまま無限長の生成を可能にする。

• 設計によるシンクトークン ：一部のモデル（Mistralなど）は学習時に専用のシンクトークンを前置します。これは残余アテンションを吸収する目的で明示的に使われます。

• Softmaxの代替 ：softmaxをReLUアテンションやシグモイドゲーティングへ置き換えます。これらではゼロアテンションを表現できるため、捨て先が不要です。

アテンションの希釈

現象

シーケンス長 \(n\) が増えると、各クエリはより多くのキーにアテンション予算を分配しなければなりません。トークンあたりの平均アテンション重みは \(O(1/n)\) で減少し、本当に関連する少数の位置へモデルが集中することが次第に難しくなります。これは アテンションの希釈 または アテンションの拡散 と呼ばれる問題です (N. F. Liu et al. 2024a)。

「中間で失われる」効果

Liuら (N. F. Liu et al. 2024a) は、LLMの検索曲線がU字型になることを示しました。長い文脈の 先頭 または 末尾 に置かれた情報は確実に検索されますが、中間 の情報はしばしば無視されます。これは、RoPE／ALiBiの位置バイアスとアテンション希釈が重なった直接的な結果です。

なぜ起こるのか

• Softmaxの飽和 ：キーが多いとsoftmax温度が実質的に低下し、分布がより一様になります（エントロピーが高くなる）。

• 位置による減衰 ：RoPEの相対位置エンコーディングは距離に応じた自然な減衰を生み、先頭と末尾の両方から遠い中間位置へのアテンションを抑えます。

• 学習分布 ：短いシーケンスで学習したモデルは、直近の文脈に偏ったアテンションパターンを身につけます。

軽減策

• 明示的な検索 ：関連する文脈をプロンプトの先頭または末尾に置き、中間位置に頼らないようRAGを使う。

• 長文脈学習 ：重要情報の位置を変えた長文書で学習する (Yao Fu et al. 2024)。

• 階層的アテンション ：Mamba (Gu and Dao 2024) やRWKVのように、\(O(n^2)\) のアテンションボトルネックを完全に避けるアーキテクチャを使う。

• ランドマークトークン ：アテンションの「道しるべ」となる、検索可能なマーカーを文脈に挿入する。

• 温度スケーリング ：一部の実装では、長いシーケンスの希釈に対抗するためアテンションロジットを \(\log n\) 倍にスケールする。

その他のアテンション現象

大規模Transformerで観測される追加のアテンションパターン。

解釈可能性のためのアテンション可視化

アテンション重みはモデルの推論を覗く窓になりますが、注意深く解釈しなければなりません。

アテンションの可視化手法

生のアテンションマップ

最も単純な方法は、各ヘッドとレイヤーについて、\(n \times n\) のアテンション行列 \(A = \text{softmax}(QK^\top/\sqrt{d})\) をヒートマップとして描画することです。BertViz (Vig 2019) のようなツールは、インタラクティブなマルチヘッド可視化を描画します。

アテンションロールアウト

単一レイヤーの生アテンションだけを見ると誤解を招きます。情報は すべて のレイヤーを通る残差接続を流れるためです。AbnarとZuidema (Abnar and Zuidema 2020) は アテンションロールアウト を提案しました。レイヤー間でアテンション行列を掛け合わせ、入力から出力までの総情報流を近似します。

\[ R^{(l)} = A^{(l)} \cdot R^{(l-1)}, \quad R^{(0)} = I \]

ここで \(A^{(l)}\) はレイヤー \(l\) の（ヘッド間で平均した）アテンション行列で、残差接続を含めるように調整されています：\(A^{(l)} = 0.5 \cdot A^{(l)}_{\text{raw}} + 0.5 \cdot I\)。

勾配重み付きアテンション

アテンション重みと勾配情報を組み合わせ、注意を向けたトークンのうち、実際に出力へ 影響を与える ものを特定します (Barkan et al. 2021)。

\[ \text{Relevance}(i) = \alpha_i \cdot \left|\frac{\partial y}{\partial h_i}\right| \]

これは、高いアテンション \(\neq\) 高い影響力とは限らないという批判に対処します（高いアテンションを受けても、ほぼゼロ重みの経路で処理されるトークンがあり得ます）。

Warning

アテンションは説明ではない

JainとWallace (Jain and Wallace 2019) は、アテンション重みが勾配ベースの特徴重要度と相関しないことが多く、敵対的なアテンション分布が同一の出力を生成できることを示しました。アテンション可視化は忠実な説明ではなく、仮説生成器 として使います。因果的な帰属には、勾配ベースの手法、プロービング、機械論的解釈可能性を優先します。

スパースオートエンコーダー（SAE）による機械論的解釈可能性

解釈可能性の問題

TransformerのMLPや残差ストリームの個々のニューロンは、通常 多義的 です。1つのニューロンが、互いに無関係な複数の概念（例：「青色」かつ「学術引用」かつ単語「the」）に反応します。そのため、ニューロンレベルの直接的な解釈は信頼できません。

スパースオートエンコーダー

Cunninghamら (Cunningham et al. 2024) とBrickenら (Bricken et al. 2023) は、モデルの活性値でスパースオートエンコーダー（SAE）を学習すると、多義的な表現を 単義的特徴 に分解できることを示しました。各特徴は単一の概念に対応する、解釈可能な方向です。

\[ h = W_{\text{dec}} \cdot \text{ReLU}(W_{\text{enc}} \cdot x + b_{\text{enc}}) + b_{\text{dec}} \]

ここで \(W_{\text{enc}} \in \mathbb{R}^{m \times d}\)、\(m \gg d\)（過完備基底）であり、ReLUとスパース性ペナルティにより、入力ごとに少数の特徴だけが活性化します。

SAEの解釈可能性から得られた主な知見

• 特徴は 単義的 である。各特徴が、人間に解釈可能な単一の概念（「Pythonのコード」「ゴールデンゲートブリッジへの言及」「一人称の語り」）を符号化する (Bricken et al. 2023)。

• 特徴は 操縦可能 である。特徴の活性値を高・低に固定すると、モデルの挙動を直接制御できる（例：「ゴールデンゲートブリッジ」特徴を強制的にオンにすると、モデルはすべての応答でそれに言及する） (Templeton et al. 2024)。

• 特徴は合成できる。単純な特徴の組み合わせから複雑な挙動が現れる。

• SAEはスケールする。Templetonら (Templeton et al. 2024) はClaude 3 Sonnet上で最大34M特徴のSAEを学習し、安全性に関わる概念（欺瞞、迎合、危険な要求）について解釈可能な特徴を見つけた。

Important

SAEの学習レシピ

1. 大規模コーパスから、特定のモデルレイヤーの活性値を収集する。

2. 隠れ層に \(L_1\) ペナルティを加えたスパースオートエンコーダーを学習する：\(\mathcal{L} = \\vert x - \hat{x}\\vert _2^2 + \lambda \\vert z\\vert _1\)。

3. 学習されたエンコーダ方向（\(W_{\text{enc}}\) の行）が候補特徴になる。

4. 検証する：各特徴について最大活性化例を見つけ、意味的一貫性を確認する。

5. 必要に応じて、特徴の吸収 と 死んだ特徴 を測定し、SAEの品質を評価する。

自然言語オートエンコーダー（Anthropic、2026年）

SAEは活性値を解釈可能な ベクトル に分解しますが、その特徴を理解するには最大活性化例を人間が調べる必要があります。Anthropicの自然言語オートエンコーダー（NLAE） (Anthropic 2026) は根本的に異なるアプローチを取ります。スパースなボトルネックを 自然言語の説明 に置き換え、解釈可能性を自動化します。

NLAEの仕組み

1. エンコーダ ：言語モデルが隠れ活性値（または入力テキスト）を読み、活性化した概念の自然言語による説明を生成する。例：「このテキストはフランス料理について述べ、形式的な学術調の文体を使っている。」

2. デコーダ ：別の言語モデルが自然言語の説明を読み、元の活性値を再構成する（または次のトークンを予測する）。

3. 学習 ：エンコーダとデコーダを再構成損失が最小になるようエンドツーエンドで学習する。ボトルネックはスパースベクトルではなく、可変長の自然言語文字列になる。

SAEに対する利点

• 自己解釈的 ：特徴が 文字どおり 自然言語なので、手作業のラベル付けが不要。

• 合成的 ：SAEの特徴が単一方向として表せない複雑な関係概念（「事実の主張に対する皮肉な応答」）を表現できる。

• 階層的 ：同じ表現で、細粒度（単語レベル）と粗粒度（文書レベル）の性質を捉えられる。

• 監査可能 ：ボトルネックの説明が人間に読めるため、モデルが存在すると「考えている」情報を直接調べられる。

制限

NLAEは言語モデルをループ内に導入するため計算コストが高く、他のモデル生成説明と同じ忠実性の懸念を受ける可能性があります。また、SAEが活性値の大きさとして自然に扱えるサブシンボリックな特徴（幾何パターン、正確な数値）を簡単には表現できません。

Tip

解釈可能性スタック

解釈可能性ツールを階層として考えます。

1. アテンションマップ ：「モデルは何を見ているか？」（最も安価で、最も忠実性が低い）

2. プロービング分類器 ：「このレイヤーにはどんな情報が符号化されているか？」

3. スパースオートエンコーダー ：「どの単義的特徴が活性化しているか？」（スケール可能だが、人間によるラベル付けが必要）

4. 自然言語オートエンコーダー ：「モデルは何が起こっていると考えているか？」（自己解釈的だが高コスト）

5. 因果トレーシング／パッチング ：「どの構成要素が実際にこの出力を引き起こしたか？」（最も忠実で、最も高コスト）

各レベルは、説明のコスト、スケーラビリティ、忠実性の間でトレードオフを持ちます。

予測ヘッド：Transformerが出力するもの

Transformer本体は各位置について文脈化された隠れ状態 \(\mathbf{h}_t \in \mathbb{R}^d\) を生成します。これらの隠れ状態を どう使うか、つまり 予測ヘッド がタスクを定義します。同じTransformerバックボーンでも、ヘッドを交換するだけでまったく異なる目的に使えます。

言語モデリングヘッド（事前学習）

標準的なLMヘッドは、最後の隠れ状態を語彙ロジットへ射影し、次のトークンに対するクロスエントロピー損失で学習します。

\[ P(x_{t+1} | x_{\leq t}) = \text{softmax}(\mathbf{W}_{\text{head}} \cdot \mathbf{h}_t + \mathbf{b}) \]

ここで \(\mathbf{W}_{\text{head}} \in \mathbb{R}^{\vert \mathcal{V}\vert \times d}\) です（埋め込み行列と共有することが多い：\(\mathbf{W}_{\text{head}} = \mathbf{E}^T\)）。

Important

LMヘッドの性質

• 学習目的 ：因果言語モデリング（すべての位置で次のトークンを予測する）

• 損失 ：\(\mathcal{L}_{\text{LM}} = -\frac{1}{T}\sum_{t=1}^{T} \log P(x_t \vert x_{<t})\)

• ラベル ：すべてのトークンが入力（右にシフト）とターゲット（左にシフト）の両方になる

• 使用段階 ：大規模コーパス（数兆トークン）での事前学習

• 重要な洞察 ：モデルは次トークン予測の副産物として、一般的な言語理解を学習する

条件付き生成ヘッド（SFT／指示追従）

教師ありファインチューニング（SFT）では、アーキテクチャはLMヘッドと 同一 です。語彙ロジットへの同じ線形射影を使います。違いは、どこに対して損失を計算するか だけです。

\[ \mathcal{L}_{\text{SFT}} = -\frac{1}{|y|}\sum_{t=1}^{|y|} \log P(y_t | x_{\text{prompt}}, y_{<t}) \]

Important

条件付きヘッドとLMヘッドの主な違い

• 損失マスキング ：プロンプト／指示ではなく、応答 トークンにだけ損失を計算する。プロンプトは文脈を与えるが、勾配シグナルは与えない。

• 条件付け ：モデルは特定の指示形式（システムプロンプト、ユーザークエリ、ツール呼び出し）を 条件として 応答を生成するよう学習する。

• 形式トークン ：特殊トークン（<|user|>、<|assistant|>）が構造化出力を生成するようモデルを導く。

• 使用段階 ：選別した指示・応答ペアでのSFT、およびRLの方策生成（行動／応答を生成する方策ヘッド）。

Tip

同じヘッド、異なる学習シグナル

LMヘッドとSFTヘッドはアーキテクチャ的に同一です（同じ \(\mathbf{W}_{\text{head}}\)）。違いは、SFT中にプロンプトトークンの損失をマスクすることだけです。この小さな変更が、一般的なテキスト予測器を指示追従アシスタントへ変えます。ヘッドは条件付けされた文脈に基づき、異なる生成モードを「活性化」することを学習します。

価値ヘッド（RLの回帰）

強化学習（PPO、GRPO）では、状態が どれほど良いか を推定する必要があります。そのためには語彙ロジットではなくスカラー出力が必要です。 価値ヘッド はLM射影を単純な回帰層に置き換えます。

\[ V(s_t) = \mathbf{w}_{\text{value}}^T \cdot \mathbf{h}_t + b \in \mathbb{R} \]

ここで \(\mathbf{w}_{\text{value}} \in \mathbb{R}^d\)、\(b \in \mathbb{R}\) です。

Important

価値ヘッドの性質

• 出力 ：単一スカラー（この状態から期待される累積報酬）

• 損失 ：予測リターンと実際のリターンのMSE：\(\mathcal{L}_V = \frac{1}{T}\sum_t (V(s_t) - R_t)^2\)

• アーキテクチャ ：線形層 \(\mathbb{R}^d \to \mathbb{R}^1\)（小さなMLP：\(d \to 256 \to 1\) を使う場合もある）

• バックボーン共有 ：方策とTransformer本体を共有する（別の価値ヘッドを持つ）ことが多いが、完全に別のクリティックネットワークを使う場合もある

• 使用段階 ：PPOのアドバンテージ推定（GAE）、報酬モデルのスコアリング

ヘッド選択のまとめ

本稿全体で使う予測ヘッドと、その学習コンテキスト。

Warning

ヘッドの初期化が重要

事前学習済みLMに価値ヘッドを追加するときは、ゼロ付近（小さなランダム重み）に初期化します。大きな値で初期化すると、初期価値推定が大きく外れ、巨大なアドバンテージと不安定なPPO更新を引き起こします。一般的には最終線形層を \(\mathcal{N}(0, 1/\sqrt{d})\) または単純なゼロで初期化します。

HuggingFaceでの実装

from transformers import (
    AutoModelForCausalLM,          # LM head (pretraining + SFT)
    AutoModelForSequenceClassification,  # Reward head
    AutoTokenizer,
)
from trl import AutoModelForCausalLMWithValueHead  # Value head (PPO)
import torch

model_name = "meta-llama/Llama-3.1-8B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)

# === 1. LM Head (Pretraining / SFT) ===
# The default CausalLM model -- projects hidden states to vocab logits
lm_model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
# lm_model.lm_head: Linear(hidden_size -> vocab_size)
# Output: logits of shape (batch, seq_len, vocab_size)

inputs = tokenizer("The capital of France is", return_tensors="pt")
outputs = lm_model(**inputs)
next_token_logits = outputs.logits[:, -1, :]  # (batch, vocab_size)
probs = torch.softmax(next_token_logits, dim=-1)

# === 2. Conditional Head (SFT) ===
# Architecturally identical to LM head -- difference is in loss masking
# During SFT, we only compute loss on response tokens:
messages = [
    {"role": "user", "content": "What is 2+2?"},
    {"role": "assistant", "content": "4"},
]
formatted = tokenizer.apply_chat_template(messages, return_tensors="pt")
labels = formatted.clone()
# Mask prompt tokens (set to -100 so cross-entropy ignores them)
prompt_len = len(tokenizer.apply_chat_template(messages[:1]))
labels[:, :prompt_len] = -100
loss = lm_model(input_ids=formatted, labels=labels).loss

# === 3. Value Head (PPO Critic) ===
# Adds a Linear(hidden_size -> 1) on top of the LM backbone
value_model = AutoModelForCausalLMWithValueHead.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
# value_model.v_head: Linear(hidden_size -> 1)
# Returns both LM logits AND per-token value estimates

inputs = tokenizer("Explain quantum computing", return_tensors="pt")
lm_logits, loss, values = value_model(
    **inputs, return_dict=False
)
# values shape: (batch, seq_len, 1) -- scalar estimate per token

# === 4. Reward Head (Reward Model) ===
# Classification head: Linear(hidden_size -> 1) on last token
reward_model = AutoModelForSequenceClassification.from_pretrained(
    model_name,
    num_labels=1,              # single scalar output
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
# Scores entire sequence by pooling the last token's hidden state
inputs = tokenizer("Good response here", return_tensors="pt")
reward_score = reward_model(**inputs).logits  # shape: (batch, 1)

Tip

重みの共有：LMヘッド＝埋め込み行列の転置

現代のLLMの大半は、LMヘッドの重みを入力埋め込み行列と共有する：lm_head.weight = model.embed_tokens.weight。つまりLMヘッドは独立に学習される層ではなく、埋め込みテーブルを再利用する。利点は、パラメータが少ない（\(\vert \mathcal{V}\vert \times d\)を節約）、一般化がよい、埋め込み空間の幾何構造がトークン確率を直接決めることである。HuggingFaceでは、model.lm_head.weight is model.model.embed_tokens.weightがほとんどのモデルでTrueを返すことで確認できる。

LLM学習の最適化理論

大規模言語モデルの学習とは、損失関数 \(\mathcal{L}(\theta)\)（通常は次トークンの負の対数尤度）を最小化するパラメータ \(\theta\)（数十億の重み）を見つけることです。これは非常に高次元の空間での最適化問題であり、この空間を探索するアルゴリズムによって、学習が成功するか、発散するか、停滞するかが決まります。

勾配降下法：基礎

勾配とは何か？

勾配 \(\nabla_\theta \mathcal{L}\) は、損失が 最も急に増加する 方向を指すベクトルです。各成分 \(\frac{\partial \mathcal{L}}{\partial \theta_i}\) は、パラメータ \(\theta_i\) を少し増やしたときに損失がどれだけ変わるかを示します。損失を 減らす には、反対方向へ進みます。

\[ \theta_{t+1} = \theta_t - \eta \nabla_\theta \mathcal{L}(\theta_t) \]

ここで \(\eta > 0\) はステップ幅である 学習率 です。これが 勾配降下法 です (Rumelhart et al. 1986)。

完全な勾配降下法が実用的でない理由

厳密な勾配を計算するには、学習データ全体（LLMでは数兆トークン）で損失を評価する必要があります。これは計算量が膨大で、勾配の1ステップだけで全データを1周しなければなりません。

確率的勾配降下法（SGD）

解決策は、データの小さなランダム部分集合（ ミニバッチ ）から勾配を推定することです (Robbins and Monro 1951)。

\[ \nabla_\theta \mathcal{L}(\theta) \approx \frac{1}{B}\sum_{i=1}^{B} \nabla_\theta \ell(\theta; x_i) \]

ここで \(B\) はバッチサイズです（LLMでは通常1K〜4Mトークン）。ミニバッチ勾配は、ノイズを含むが不偏な 真の勾配の推定値です。

Important

ミニバッチSGDが機能する理由

• 計算効率 ：各ステップのコストは \(O(N_{\text{total}})\) ではなく \(O(B)\)。\(B = 4096\) トークン、総計15Tトークンなら、1ステップは \(\sim\) 40億\(\times\)安くなる。

• 正則化としてのノイズ ：確率的ノイズが鋭い局所最小値からの脱出を助け、より汎化する平坦な領域を見つける。

• GPU利用率 ：ミニバッチはGPUの並列性を飽和させるのに十分大きい（行列積がメモリ律速ではなく計算律速になる）。

• 収束 ：理論上は \(O(1/\sqrt{T})\) の速度で局所最小値へ収束する（厳密なGDの \(O(1/T)\) より遅いが、各ステップは数百万倍安い）。

SGDから適応的手法へ

モメンタム付きSGDは視覚モデル（CNN）ではうまく機能しますが、LLMの学習には 適応的オプティマイザー 、つまりパラメータごとの学習率を維持するアルゴリズムが必要です。

Vanilla SGDがLLMで失敗する理由

確率的勾配降下法は、次のように重みを更新する。

\[ \theta_{t+1} = \theta_t - \eta \nabla_\theta \mathcal{L}(\theta_t) \]

Warning

LLMにおけるSGDの問題

• レイヤーごとに異なる勾配スケール ：Transformerの前段レイヤーは後段より勾配がはるかに小さい（勾配消失）。単一の学習率 \(\eta\) は、あるパラメータには大きすぎ、別のパラメータには小さすぎる。

• スパースな勾配 ：埋め込み層は現在のバッチのトークンに対してだけ勾配を受ける。大部分の埋め込み行は勾配ゼロであり、モメンタム付きSGDはゼロ勾配の行にモメンタムを浪費する。

• 鞍点 ：高次元の損失地形には多くの鞍点がある。SGDは停滞し得るが、適応的手法はより速く脱出する。

• 学習率への感度 ：SGDには慎重な調整が必要で、\(\eta\) を2\(\times\)変えるだけで発散する可能性がある。

Adam — 適応的モーメント推定

Adam (Kingma and Ba 2015) は、パラメータごとに1次モーメント（勾配の平均）と2次モーメント（勾配の非中心化分散）の推定値を維持します。

Important

Adamの更新式

勾配 \(g_t = \nabla_\theta \mathcal{L}(\theta_t)\) とハイパーパラメータ \(\beta_1, \beta_2, \epsilon, \eta\) に対して、

ステップ1 — 1次モーメントのバイアス付き推定値を更新 \[ m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t \]

ステップ2 — 2次モーメントのバイアス付き推定値を更新 \[ v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2 \]

ステップ3 — バイアス補正 \[ \hat{m}_t = \frac{m_t}{1 - \beta_1^t}, \qquad \hat{v}_t = \frac{v_t}{1 - \beta_2^t} \]

ステップ4 — パラメータ更新 \[ \theta_{t+1} = \theta_t - \eta \cdot \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} \]

典型的な値 ：\(\beta_1 = 0.9\)、\(\beta_2 = 0.95\) または \(0.999\)、\(\epsilon = 10^{-8}\)、\(\eta = 10^{-4}\)〜\(10^{-5}\)。

Tip

各項の働き

• \(m_t\)（ モメンタム ）：勾配の指数移動平均。ノイズの多い勾配推定を平滑化する。\(\beta_1 = 0.9\) なら、現在の勾配が10%、履歴が90%寄与する。

• \(v_t\)（ 適応的学習率 ）：二乗勾配のEMA。勾配が一貫して大きいパラメータは、より小さい実効学習率（\(\eta / \sqrt{v_t}\)）を得る。勾配が小さいパラメータは、より大きい実効学習率を得る。これがレイヤーごとの異なる勾配スケールを扱う鍵である。

• \(\hat{m}_t, \hat{v}_t\)（ バイアス補正 ）：\(t=1\) では \(m_1 = (1-\beta_1)g_1\) が真の平均よりかなり小さい。\((1-\beta_1^t)\) で割ることで、この初期化バイアスを補正する。これがないと初期ステップが小さすぎる。

• \(\epsilon\)（ 数値安定性 ）：ゼロ除算を防ぐ。また実効学習率の下限としても働く。

AdamW — 分離された重み減衰

AdamW (Loshchilov and Hutter 2019) は、重み減衰と適応的オプティマイザーの相互作用に関する、微妙だが重要な問題を修正します。

Important

AdamでL2正則化 $\neq$ 重み減衰となる理由

L2正則化では損失が\(\mathcal{L} + \frac{\lambda}{2}\\vert \theta\\vert ^2\)となり、勾配は\(g_t + \lambda \theta_t\)になる。Adamでは、この正則化勾配が適応係数\(1/\sqrt{\hat{v}_t}\)でスケールされる。 \[ \theta_{t+1} = \theta_t - \eta \cdot \frac{\hat{m}_t + \lambda \theta_t}{\sqrt{\hat{v}_t} + \epsilon} \] \(v_t\)が大きい（勾配分散が大きい）パラメータほど正則化が弱くなる。これは望ましくない。重み減衰は一様であるべきだ。

Important

AdamW — 分離された重み減衰

AdamW（LoshchilovとHutter、2017）は、適応的スケーリングの外側で、重み減衰をパラメータへ 直接 適用します。 \[ \theta_{t+1} = \theta_t - \eta \cdot \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}

• \eta \lambda \theta_t \] 重み減衰項 \(\eta \lambda \theta_t\) は \(\sqrt{\hat{v}_t}\) で割られません。そのため、勾配履歴に関係なくすべてのパラメータに一様な正則化がかかります。

典型値 ：LLM学習では \(\lambda = 0.1\)。

Warning

LLMでは常にAdamWを使い、通常のAdamは使わない

AdamとAdamWの違いは微妙ですが重要です。Adam＋L2では、実効重み減衰が勾配分散の小さいパラメータ（バイアスやLayerNormパラメータなど）には強く、勾配分散の大きいパラメータ（アテンション重みなど）には弱くなります。AdamWなら意図した一様な正則化になります。多くのフレームワークはAdamWをデフォルトにしていますが、オプティマイザーのクラスを確認してください。

学習率 — 最も重要なハイパーパラメータ

Important

学習段階ごとの典型的な学習率

段階	典型的な学習率	注記
事前学習（ゼロから）	\(1\text{e-}4\)〜\(3\text{e-}4\)	大規模モデル、大規模バッチ
継続事前学習	\(1\text{e-}5\)〜\(1\text{e-}4\)	知識を保つため小さい学習率
SFT（教師ありファインチューニング）	\(1\text{e-}5\)〜\(2\text{e-}5\)	標準的な範囲
LoRAファインチューニング	\(1\text{e-}4\)〜\(3\text{e-}4\)	アダプター重みに対して高い学習率

RLの学習率（PPO、DPO、GRPO）については、§8.15を参照。

学習率ウォームアップ

Important

ウォームアップが必要な理由

学習開始時、\(v_t\)（2次モーメント推定値）はゼロに初期化される。バイアス補正後は\(\hat{v}_t = v_t / (1 - \beta_2^t)\)である。\(\beta_2 = 0.999\)の\(t=1\)では、\(\hat{v}_1 = v_1 / (1 - 0.999) = 1000 v_1\)となる。これは実効学習率が\(\eta / \sqrt{1000 v_1}\)、つまり意図よりはるかに小さくなることを意味する。

ただし、最初の勾配が異常に大きい場合（初期化時によくある）、2次モーメント推定値がこの外れ値に支配され、初期ステップが不規則になります。ウォームアップは非常に小さい学習率から始めて徐々に増やし、\(v_t\) が信頼できる推定値を蓄積する時間を与えることで、これを緩和します。

• 線形ウォームアップ ：\(\eta_t = \eta_{\max} \times t / T_{\text{warmup}}\)

• 典型的なウォームアップ期間 ：事前学習では全ステップの1〜5%、ファインチューニングでは3〜10%（短い実行ほど比例して長いウォームアップが必要）

• SFTの場合 ：50〜200ウォームアップステップが典型的

学習率スケジュール

(a) 一定

最も単純なスケジュール。学習率を減衰させすぎたくない短いファインチューニングに適しています。リスクは、アニーリングがないためモデルが最も鋭い最小値へ収束しない可能性があることです。

(b) コサイン減衰

\[ \eta_t = \eta_{\min} + \frac{1}{2}(\eta_{\max} - \eta_{\min}) \left(1 + \cos!\left(\frac{t - T_{\text{warmup}}}{T - T_{\text{warmup}}} \pi\right)\right) \]

事前学習とSFTの標準です。滑らかな減衰により、学習率の急変を避けます。\(\eta_{\min}\) は通常 \(\eta_{\max} / 10\) です。

(c) 線形減衰

コサインより単純で、実証結果は同程度です。任意のステップで予測可能な学習率が必要な場合に好まれます。

(d) WSD — Warmup-Stable-Decay

大規模事前学習の新しい標準です (S. Hu et al. 2024; Grattafiori et al. 2024)。3つの段階があります。

1. ウォームアップ ：\(\eta_{\max}\) まで線形に増加（ステップの1〜5%）

2. 安定 ：学習の大部分で \(\eta_{\max}\) を一定に保つ

3. 減衰 ：\(\eta_{\min}\) まで高速なコサインまたは線形減衰（最後の10〜20%）

主な利点は、安定段階のどの時点でもチェックポイントを保存して学習を続けられることです。減衰段階は任意の実行の最後に適用できます。

(e) 再起動付きコサイン（SGDR）

周期的な再起動で学習率を \(\eta_{\max}\) に戻します。局所最小値からの脱出に役立つことがあります。LLMではあまり一般的でなく、小規模モデルにより有用です。

勾配クリッピング

Important

勾配クリッピング

勾配クリッピングは、勾配のグローバルノルムがしきい値を超えたときに勾配を再スケールします。 \[ g_t \leftarrow g_t \cdot \min!\left(1,; \frac{\tau}{|g_t|_2}\right) \] ここで\(\tau\)はmax_grad_norm（通常1.0）である。

Tip

勾配クリッピングと学習率削減の比較

勾配クリッピングと学習率の削減は、どちらもパラメータ更新の大きさを制限します。違いは、クリッピングが勾配の 方向 を保つ（大きさだけをスケールする）のに対し、学習率を下げるとすべての更新を一様にスケールすることです。クリッピングは、通常の学習ステップを遅くせずに、ときどき現れる大きな勾配へ対処するのに適しています。

まとめ：HuggingFaceのオプティマイザー設定

次のスニペットは、この節の概念——分離された重み減衰を持つAdamW（§1.6.6）、線形ウォームアップ付きコサイン学習率スケジュール（§1.6.7）、勾配クリッピング（§1.6.8）——を、HuggingFaceのtransformersライブラリで実際に組み合わせる方法を示す。

from transformers import TrainingArguments, Trainer
from transformers import get_cosine_schedule_with_warmup
import torch

# --- Option 1: Using TrainingArguments (recommended) ---
training_args = TrainingArguments(
    output_dir="./checkpoints",

    # AdamW optimizer (decoupled weight decay, S1.6.6)
    optim="adamw_torch",
    learning_rate=2e-5,           # peak LR after warmup
    adam_beta1=0.9,               # first moment decay
    adam_beta2=0.999,             # second moment decay
    adam_epsilon=1e-8,            # numerical stability
    weight_decay=0.01,           # decoupled L2 penalty

    # Learning rate schedule (S1.6.7)
    lr_scheduler_type="cosine",  # cosine decay to 0
    warmup_ratio=0.1,            # 10% of steps = linear warmup

    # Gradient clipping (S1.6.8)
    max_grad_norm=1.0,           # clip by global L2 norm

    # Mixed precision (S1.6.9)
    bf16=True,                   # use BFloat16 on Ampere+ GPUs

    # Training duration
    num_train_epochs=3,
    per_device_train_batch_size=8,
    gradient_accumulation_steps=4,  # effective batch = 8*4 = 32
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
)
trainer.train()

# --- Option 2: Manual control (for custom training loops) ---
from torch.optim import AdamW

# Separate weight-decay groups (don't regularize biases/norms)
no_decay = ["bias", "LayerNorm.weight", "layernorm.weight"]
param_groups = [
    {
        "params": [p for n, p in model.named_parameters()
                   if not any(nd in n for nd in no_decay)],
        "weight_decay": 0.01,
    },
    {
        "params": [p for n, p in model.named_parameters()
                   if any(nd in n for nd in no_decay)],
        "weight_decay": 0.0,
    },
]

optimizer = AdamW(param_groups, lr=2e-5, betas=(0.9, 0.999))

# Cosine schedule with linear warmup
total_steps = len(train_dataloader) * num_epochs
warmup_steps = int(0.1 * total_steps)
scheduler = get_cosine_schedule_with_warmup(
    optimizer,
    num_warmup_steps=warmup_steps,
    num_training_steps=total_steps,
)

# Training loop with gradient clipping
for batch in train_dataloader:
    outputs = model(**batch)
    loss = outputs.loss
    loss.backward()

    # Clip gradients before optimizer step
    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

    optimizer.step()
    scheduler.step()
    optimizer.zero_grad()

Important

実践的なヒント

• 重み減衰から除外 ：バイアス項とLayerNorm重みは正則化しない。パラメータが少なく、正則化すると性能が低下する (Loshchilov and Hutter 2019)。

• ウォームアップ比率 ：全ステップの5〜10%が標準。高い学習率でウォームアップが少なすぎると初期学習が不安定になる。

• 勾配蓄積 ：限られたGPUメモリで大きなバッチをシミュレートする。クリッピングは 蓄積された 勾配に適用する。

• BF16とFP16の比較 ：Ampere以降のGPUではbf16=Trueを優先する（広いダイナミックレンジにより損失スケーリングを避けられる）。古いハードウェアではfp16=Trueへフォールバックする。

混合精度学習

Important

BF16とFP16の比較

形式	指数ビット	仮数ビット	ダイナミックレンジ
FP32	8	23	\(\sim 10^{-38}\)〜\(10^{38}\)
BF16	8	7	FP32と同じ（指数が同じ）
FP16	5	10	\(\sim 6 \times 10^{-5}\)〜\(65504\)

Tip

FP16よりBF16：LLM学習で精度より範囲が重要な理由

BF16はFP32と同じ指数範囲を持つため、仮数の精度は低いものの同じ値の範囲を表現できます。FP16のダイナミックレンジははるかに小さく、65504を超える勾配や活性値はオーバーフローします（NaN／Inf）。そのためFP16学習では 損失スケーリング（勾配をFP16の範囲に保つため損失を大きな定数倍すること）が必要ですが、BF16学習では通常不要です。A100とH100はBF16をネイティブサポートするため、FP16を使う特別な理由がない限りBF16を使います。

損失スケーリング（FP16のみ）

1. 損失にスケール係数\(S\)を掛ける（例：\(S = 2^{15}\)）。

2. FP16で勾配を計算する（\(S\)倍にスケール済み）。

3. オプティマイザーステップの前に、勾配を\(S\)で割る。

4. オーバーフロー（NaN／Inf）を確認し、見つかったらステップをスキップして\(S\)を下げる。

5. \(N\)ステップ連続でオーバーフローがなければ、\(S\)を増やす。

FP32マスター重み

混合精度学習では、重みをFP32（マスターコピー）で保存し、順伝播／逆伝播ではBF16／FP16へキャストする。オプティマイザーステップはFP32で行う。これは次の理由で重要である。

• 小さな勾配更新（\(\Delta\theta \ll \theta\)）はBF16の精度では失われる（仮数7ビット、相対精度\(\approx\)0.8%）。

• FP32マスター重みにより、多数のステップにわたる小さな更新を正確に蓄積できる。

• メモリコスト：重みの保存量が2\(\times\)になる（FP32＋BF16コピー）。

Warning

FP32マスター重みが重要な場面

FP32マスター重みは次の場面で特に重要である。

• 長い学習実行（多数の小さな勾配ステップが蓄積する）

• 小さな学習率（重みの大きさに比べて更新が極めて小さい）

大きな学習率を使う短いSFTでは、BF16だけの学習（FP32マスター重みなし）でもうまく動くことが多く、メモリを節約できる。RL学習ではFP32マスター重みが不可欠である。§8.15を参照。

実践的な混合精度：HuggingFace

# === HuggingFace TrainingArguments (simplest approach) ===
from transformers import TrainingArguments

# BF16 on Ampere+ GPUs (A100, H100, RTX 30xx/40xx)
args_bf16 = TrainingArguments(
    output_dir="./out",
    bf16=True,               # BF16 forward/backward; FP32 master weights
    bf16_full_eval=True,     # also use BF16 during evaluation
    # No loss scaling needed -- BF16 has FP32-equivalent range
)

# FP16 on older GPUs (V100, T4, RTX 20xx)
args_fp16 = TrainingArguments(
    output_dir="./out",
    fp16=True,               # FP16 forward/backward
    fp16_full_eval=False,    # keep eval in FP32 for accuracy
    # Loss scaling is automatic via PyTorch GradScaler
)

# === Manual PyTorch AMP (for custom training loops) ===
import torch

# Setup (PyTorch 2.x API)
use_fp16 = not torch.cuda.is_bf16_supported()
scaler = torch.amp.GradScaler("cuda", enabled=use_fp16)  # only needed for FP16
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)
dtype = torch.float16 if use_fp16 else torch.bfloat16

for batch in train_dataloader:
    optimizer.zero_grad()

    # Autocast: run forward pass in reduced precision
    with torch.autocast("cuda", dtype=dtype):
        outputs = model(**batch)
        loss = outputs.loss

    if use_fp16:
        # FP16 path: scale loss to prevent gradient underflow
        scaler.scale(loss).backward()
        scaler.unscale_(optimizer)          # unscale before clipping
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        scaler.step(optimizer)              # skips step on overflow
        scaler.update()                     # adjust scale factor
    else:
        # BF16 path: no scaling needed
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()

    scheduler.step()

Tip

コードにおけるBF16とFP16の主な違い

• BF16 ：autocast(dtype=torch.bfloat16)でラップするだけでよく、スケーラーは不要。コードが単純で数値的にも安定する。

• FP16 ：勾配のアンダーフローを防ぐためGradScalerが必要。スケーラーは乗数を動的に調整し、オーバーフロー（NaN）が検出されるとオプティマイザーステップをスキップしてスケールを下げる。

• 勾配クリッピング＋FP16 ：clip_grad_norm_の前に必ずscaler.unscale_(optimizer)を呼ぶ。そうしないとスケール済み勾配をクリップしてしまい、しきい値が誤る。

• メモリ削減 ：活性値を16-bitで保存することで活性メモリを%削減する。重みメモリはFP32マスターコピーを保持するかどうかに依存する。

学習段階ごとの実践的なオプティマイザー設定

Important

オプティマイザーハイパーパラメータの参照表

段階	オプティマイザー	LR	WD	ウォームアップ	スケジュール
事前学習	AdamW	\(3\text{e-}4\)	0.1	2000ステップ	WSDまたはコサイン
SFT	AdamW	\(2\text{e-}5\)	0.01	100ステップ	コサイン
LoRA SFT	AdamW	\(2\text{e-}4\)	0.01	100ステップ	コサイン

すべての設定で\(\beta_1{=}0.9\)、\(\beta_2{=}0.95\)、\(\epsilon{=}10^{-8}\)、max_grad_norm=1.0、BF16を使う。RLの設定については§8.15を参照。

Note

学習不安定性の診断

# Monitor these metrics to diagnose optimizer issues:
# 1. Gradient norm -- should be < max_grad_norm most of the time
# 2. Loss scale (FP16) -- should be stable, not constantly decreasing
# 3. Parameter update norm -- should be << parameter norm

import torch

def log_optimizer_stats(model, optimizer, step):
    # Gradient norm (before clipping)
    total_norm = 0.0
    for p in model.parameters():
        if p.grad is not None:
            total_norm += p.grad.data.norm(2).item() ** 2
    total_norm = total_norm ** 0.5

    # Adam second moment stats (proxy for adaptive LR)
    v_norms = []
    for group in optimizer.param_groups:
        for p in group['params']:
            state = optimizer.state[p]
            if 'exp_avg_sq' in state:
                v_norms.append(state['exp_avg_sq'].mean().item())

    print(f"Step {step}: grad_norm={total_norm:.3f}, "
          f"mean_v={sum(v_norms)/len(v_norms):.6f}")

# Red flags:
# grad_norm >> 1.0 repeatedly -> reduce LR or increase warmup
# grad_norm == 0.0 -> gradient vanishing or wrong loss
# loss_scale decreasing -> FP16 overflow, switch to BF16
# v very small -> Adam not warmed up yet, extend warmup

Tip

学習率は最も重要なハイパーパラメータ

実際には、学習率を正しく設定することが他のどのハイパーパラメータより重要である。LLMファインチューニングの経験則は次のとおり。

• 上の表の値から始める。

• 損失が発散する（最初は下がるが、その後増える）なら、LRが高すぎる。

• 損失が非常にゆっくり下がり早く頭打ちになるなら、LRが低すぎる。

• 損失が不安定（振動）なら、LRが高すぎるか、ウォームアップが短すぎる。

2番目に重要なハイパーパラメータはバッチサイズである（線形スケーリング則を通じて勾配ノイズと実効LRに影響する）。その他は二次的である。

Flash Attention — アルゴリズムとハードウェアへの対応

Flash Attention (Dao et al. 2022; Dao 2024) は、Transformerそのもの以来、ディープラーニングで最も影響力のあるアルゴリズム上の革新の1つです。アテンションの数学的結果は変えず、まったく同じ出力 を計算しますが、メモリアクセスパターンを再構成します。GPUの限られた高速SRAMに重い処理を担わせ、HBMフットプリントを \(O(n^2)\) から \(O(n)\) に削減し、典型的なワークロードでエンドツーエンドの実時間を2〜4\(\times\)改善します。

標準アテンションのメモリ問題

標準的なスケールド・ドット積アテンションは次のとおりである。

\[ \text{Attention}(Q, K, V) = \text{softmax}!\left(\frac{QK^T}{\sqrt{d_k}}\right) V \]

Important

標準アテンションのメモリ計算量

シーケンス長 \(n\)、ヘッド次元 \(d\) に対して、

• \(Q, K, V \in \mathbb{R}^{n \times d}\)：メモリ \(O(nd)\)

• \(S = QK^T \in \mathbb{R}^{n \times n}\)： メモリ \(O(n^2)\) — ボトルネック

• \(P = \text{softmax}(S) \in \mathbb{R}^{n \times n}\)：さらに \(O(n^2)\)

• \(O = PV \in \mathbb{R}^{n \times d}\)：\(O(nd)\)

\(n=8192\)、\(d=128\)、BF16では、アテンション行列だけでヘッドあたり \(8192^2 \times 2 \approx 134\) MB です。32ヘッドなら、1レイヤーのアテンションスコアだけで4.3 GBになります。

Tip

$O(n^2)$ が壊滅的な理由

アテンション行列はHBMへ書き込まれ（長いシーケンスではSRAMに収まらない）、softmaxのために読み戻され、さらに \(PV\) 積のために再び読み込まれます。HBMとの往復はどれも低速です。\(n=32768\)（32K文脈）では、アテンション行列はヘッドあたり \(32768^2 \times 2 \approx 2\) GB となり、保存するのは完全に非現実的です。

Flash Attentionの核心 — タイル化とオンラインsoftmax

核心となる洞察は、 完全な \(n \times n\) 行列を一度にメモリへ置く必要はない ということです。オンラインsoftmax のトリックを使えば、出力 \(O\) をブロック単位で計算できます。

オンラインsoftmax

softmaxには数値安定性のためグローバル最大値が必要です。

\[ \text{softmax}(x_i) = \frac{e^{x_i - m}}{\sum_j e^{x_j - m}}, \quad m = \max_j x_j \]

トリックは、新しいブロックを処理しながら最大値と正規化係数を 更新 し、行全体を実体化しないことです。

Important

オンラインsoftmaxの更新則

実行中の状態 \((m_{\text{old}}, \ell_{\text{old}}, O_{\text{old}})\) と新しいスコアブロック \(s_{\text{new}}\) に対して、

1. \(m_{\text{new}} = \max(m_{\text{old}},; \max(s_{\text{new}}))\)

2. [ \ell_{\text{new}} = e^{m_{\text{old}} - m_{\text{new}}} \cdot \ell_{\text{old}} + \sum_j e^{s_{\text{new},j} - m_{\text{new}}} ]

3. [ O_{\text{new}} = \frac{1}{\ell_{\text{new}}} \left( e^{m_{\text{old}} - m_{\text{new}}} \cdot \ell_{\text{old}} \cdot O_{\text{old}} + e^{s_{\text{new}} - m_{\text{new}}} \cdot V_{\text{new}} \right) ]

これはすべてのブロックに対して一度にsoftmaxを計算するのと数学的に等価です。

Flash Attentionアルゴリズム

Note

Flash Attentionのフォワードパス — ブロックタイル化

設定 ：SRAMサイズ \(M\)。ブロックサイズは \(B_r = \lceil M / (4d) \rceil\)、\(B_c = \min(\lceil M / (4d) \rceil, d)\)。

1. \(Q\)を\(T_r = \lceil n / B_r \rceil\)個のブロック\(Q_1, \ldots, Q_{T_r}\)に分割する。

2. \(K, V\)を\(T_c = \lceil n / B_c \rceil\)個のブロック\(K_1, \ldots, K_{T_c}\)に分割する。

3. 出力\(O \in \mathbb{R}^{n \times d}\)、実行中の最大値\(m \in \mathbb{R}^n\)、実行中の和\(\ell \in \mathbb{R}^n\)を初期化する（すべてHBM上）。

4. \(j = 1, \ldots, T_c\)について 外側ループ を行う。

   1. \(K_j, V_j\)をHBMからSRAMへ読み込む。

   2. \(i = 1, \ldots, T_r\)について 内側ループ を行う。

      1. \(Q_i, O_i, m_i, \ell_i\)をHBMからSRAMへ読み込む。

      2. \(S_{ij} = Q_i K_j^T / \sqrt{d}\)を計算する（SRAMに留める）。

      3. オンラインsoftmaxの更新を適用し、新しい\(m_i, \ell_i, O_i\)を得る。

      4. \(O_i, m_i, \ell_i\)をHBMへ書き戻す。

5. \(O\)を返す。

要点 ：\(S_{ij}\)（アテンションタイル）はSRAMで計算して破棄します。HBMへ書き込むことはありません。

Important

Flash Attentionの計算量

	標準アテンション	Flash Attention
メモリ（HBM）	\(O(n^2)\)	\(O(n)\)
HBMの読み書き	\(O(n^2 d)\)	\(O(n^2 d / M)\)
FLOPs	\(O(n^2 d)\)	\(O(n^2 d)\)（同じ）
高速化	1\(\times\)	2〜4\(\times\)

フォワードパスの総FLOPsは \(O(n^2 d)\) のままで、標準アテンションと同じです。Flash Attentionは演算量を減らすのではなく、低速なHBMトラフィックを大幅に削ることで高速化します。（後方パスは再計算のため実際には より多くの FLOPsを行いますが、節約したメモリ帯域幅が支配的なので実時間は短くなります。）

Flash Attention 2 — 並列性の改善

Flash Attention 2 (Dao 2024) は3つの主要な改善を行いました。

1. 行列積以外のFLOPs削減 ：元のFAには内側ループに不要な再スケーリング演算がありました。FA2はこれを最小化するようループを再構成します。A100ではTensor Coreの行列積がスカラー演算を約16\(\times\)上回るため、内側ループで行列積以外の処理が少しあるだけでもレイテンシのボトルネックになります。

2. シーケンス次元の並列性向上 ：FA1はバッチとヘッドだけを並列化しました。FA2はクエリのシーケンス次元も並列化し、小さいバッチサイズの長いシーケンスでGPU利用率を高めます。

3. 因果マスキングの最適化 ：自己回帰（因果）アテンションでは、およそ半分のブロックが完全にマスクされます。FA2はこれらのブロックを完全にスキップし、双方向アテンションに対して因果アテンションを \(\sim\) 2\(\times\)高速化します。

Flash Attention 3 — Hopperアーキテクチャ

Flash Attention 3 (Shah et al. 2024) はH100向けに設計され、Hopper固有の3つの機能を活用します。

• TMA（Tensor Memory Accelerator） ：H100にはHBMとSRAM間の非同期バルクデータ移動専用のハードウェアユニットがあります。FA3はTMAを使い、データ読み込みと計算を重ねてメモリレイテンシを隠します。

• Warp-specialization ：FA3は異なるワープに異なる役割を割り当てます（プロデューサーワープはTMAでデータを読み、コンシューマーワープはMMAを計算）。メモリシステムとTensor Coreを同時に稼働させるソフトウェアパイプライン技法です。

• FP8サポート ：H100はBF16の2\(\times\)のスループットでFP8（E4M3／E5M2）Tensor Core演算をサポートします。FA3は精度維持のためブロックごとの量子化を行うFP8アテンションをサポートします。

FA3はFP16アテンションで H100の理論ピークの最大75% を達成します。FA2は \(\sim\) 35%です。

Flash Attention 4 — Blackwellアーキテクチャ

Flash Attention 4（Zadouri et al. 2026）はNVIDIAのBlackwell GPU（B200／GB200）を対象とする。Tensor Coreのスループットを2.25 PFLOP/s（BF16）へ倍増する一方、行列積以外のユニット（指数演算、共有メモリ帯域）はより遅い割合でしか拡大しない。この非対称なハードウェアスケーリングによりボトルネックが移る。Blackwellでは、アテンションは行列積ではなく、softmaxの指数演算とその周辺の共有メモリトラフィックによって制限される。

FA4は4つの主要な技法でこれに対処する。

• 完全非同期のMMAパイプライン ：BlackwellのMMA命令は完全に非同期である（完了時にまだブロックされるHopperのwgmmaとは異なる）。FA4はより大きなタイルサイズにわたってMMA、TMAロード、softmax再スケーリングを重ね合わせるようパイプラインを再設計し、すべてのハードウェアユニットを飽和させる。

• ソフトウェアによる指数演算エミュレーション ：スループットのボトルネックであるハードウェアのex2ユニットを呼ぶ代わりに、FA4ははるかに高速なTensor Core上で多項式近似を実行し、\(e^x\)をエミュレートする。指数演算ユニットの停止と、追加の行列積命令を交換する。

• 条件付きsoftmax再スケーリング ：標準のFlashAttentionはタイルごとに実行中の\(\max\)を再スケールする。FA4は新しいタイルの最大値が実行中の最大値を超えない場合（実際にはよくある）に再スケーリングを省き、レジスタシャッフルと同期バリアの両方を節約する。

• Tensor Memory＋2-CTA MMAモード（逆伝播） ：逆伝播ではBlackwellのTensor Memory（共有メモリより大きいSMごとのスクラッチパッド）と、2つのスレッドブロッククラスタにまたがる\(dQ\)の蓄積を融合する2-CTA協調モードを使い、共有メモリへの往復を半減する。

Important

FA4の実装：CuTe-DSL

FA4は、GPUカーネル向けのPython組み込みドメイン固有言語（CUTLASS 4.xの一部）である CuTe-DSL で書かれた最初のFlashAttentionバージョンである。CuTe-DSLはレジスタ割り当てとパイプラインスケジューリングを完全に制御しながら、C++のCUTLASSテンプレートより20〜30\(\times\)高速にコンパイルできる。これによりカーネル開発の反復時間が大幅に短くなる。

結果

BF16、ヘッド次元128のB200（因果、系列長8K）では、

• 1613 TFLOP/s ——Blackwellのピーク利用率の71%

• 1.3\(\times\) ——cuDNN 9.13（NVIDIA独自の融合カーネル）より高速

• 2.7\(\times\) ——同じハードウェア上のTritonより高速

Tip

ハードウェアとソフトウェアの共進化

FlashAttentionシリーズは、GPU世代ごとにボトルネックが移り、単なる再コンパイルではなく新しいアルゴリズムの発想が必要になるという原則を示します。A80 \(\to\) メモリ帯域幅律速（FA1／FA2：タイル化＋再計算）。H100 \(\to\) データ移動律速（FA3：TMA＋warp-specialization）。B200 \(\to\) 行列積以外の計算律速（FA4：ソフトウェアによるexpエミュレーション＋条件付き再スケーリング）。ハードウェアのボトルネックがどこにあるか を理解することが、効率的なカーネルを書く前提です。

事前学習：ベストプラクティス

事前学習はLLM開発で最も高コストな段階です。数百万GPU時間を消費し、データ、計算、ハイパーパラメータの慎重な調整が必要です。この節では、Llama-3 (Grattafiori et al. 2024)、Chinchilla (Hoffmann et al. 2022)、GPT-4 (OpenAI 2023)から得られる主な教訓をまとめます。

学習目的

現代のDecoder-Only LLMはすべて 因果言語モデリング （CLM）を使います。

\[ \mathcal{L}_\text{CLM} = -\frac{1}{T}\sum_{t=1}^T \log P_\theta(x_t \mid x_{<t}) \]

この単純な目的は、十分なデータと規模があれば、明示的な教師なしに創発的能力（文脈内学習、推論、指示追従）を生みます (Brown et al. 2020)。

データパイプライン

Important

事前学習データのレシピ

• 規模 ：最先端モデルでは1〜15兆トークン（Llama-3：15Tトークン）

• ソース ：ウェブクロール（80%）、コード（10%）、書籍／論文（5%）、選別データ（5%）

• 重複除去 ：MinHash＋完全な部分文字列重複除去により、記憶を減らす (Lee et al. 2022)

• 品質フィルタリング ：パープレキシティベースの分類器、ヒューリスティックフィルタ（長さ、言語ID、有害性）

• データ混合 ：ドメイン間で温度重み付きサンプリングを行い、推論のためコードと数学を重くする

スケーリング則

Hoffmannら (Hoffmann et al. 2022) は、計算量最適な学習にはモデルサイズ \(N\) とデータサイズ \(D\) のバランスが必要だと示しました：\(N_\text{opt} \propto C^{0.50}\)、\(D_\text{opt} \propto C^{0.50}\)。70Bモデルは \(\sim\) 1.4Tトークンで計算量最適になります。実際には、推論コストが学習トークン数ではなくモデルサイズに比例するため、モデルは 過学習 されます（Chinchilla最適より多くのトークン）。小さく過学習させたモデルの方がデプロイ費用が安くなります。

主要ハイパーパラメータ

公開モデルの事前学習ハイパーパラメータ。

よくある失敗モード

Warning

事前学習の落とし穴

• 損失スパイク ：悪いデータバッチや数値不安定性による突然の損失増加。Llama-3ではチェックポイントへロールバックし、問題のバッチをスキップする。

• 記憶 ：モデルが学習データをそのまま再現する。対策は積極的な重複除去と抽出攻撃の監視。

• 文脈長 ：短いシーケンスで学習して長い文脈へデプロイすると失敗する。長文書での継続事前学習とRoPEスケーリングを使う。

教師ありファインチューニング（SFT）

SFTは選別したプロンプト・応答ペアで学習し、事前学習済み言語モデルを指示追従アシスタントへ変換します。これは生の言語モデリングとRLHFの橋渡しです。

SFTの目的

損失はCLMと同じですが、 応答トークン に対してだけ計算します。

\[ \mathcal{L}_\text{SFT} = -\frac{1}{|y|}\sum_{t=1}^{|y|} \log P_\theta(y_t \mid x_\text{prompt}, y_{<t}) \]

プロンプトトークンは文脈を提供しますが、勾配は受けません（ラベルを \(-100\) に設定）。

データ品質：LIMAの原則

Zhouら (C. Zhou et al. 2023) は、注意深く選別した1,000例で、ノイズの多い50K以上の例で学習したモデルに匹敵できることを示しました。主な要件は次のとおりです。

• 多様性 ：QA、要約、コード、数学、創作、多ターン対話を網羅する

• 正確性 ：すべての応答が事実として正確で、書式も整っている

• 長さのバランス ：短い応答（1文）と長い応答（複数段落）を混ぜる

• デコンタミネーション ：評価ベンチマークとの重複を除去する

学習設定

from trl import SFTTrainer, SFTConfig

sft_config = SFTConfig(
    output_dir="./sft_output",
    max_seq_length=4096,
    packing=True,              # Pack short examples into full sequences
    learning_rate=2e-5,
    lr_scheduler_type="cosine",
    warmup_ratio=0.1,
    weight_decay=0.01,
    max_grad_norm=1.0,
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=8,
    bf16=True,
    gradient_checkpointing=True,
)
trainer = SFTTrainer(model=model, args=sft_config,
                     train_dataset=dataset, processing_class=tokenizer)
trainer.train()

効率的な学習ソリューション

標準的なHuggingFace学習では、かなりの性能が取りこぼされます。いくつかのライブラリはSFTワークロードに、そのまま導入できる効率向上を提供します。

Liger Kernel (Hsu et al. 2024)

LinkedInによるオープンソースの Triton融合カーネル で、学習時に標準PyTorch演算子を置き換えます。主な融合は次のとおりです。

• 融合クロスエントロピー ：最終線形射影、softmax、損失計算を単一カーネルに統合し、完全な \((\text{batch} \times \text{seq} \times \text{vocab})\) ロジットテンソルの実体化を避ける。

• 融合RMSNorm／SwiGLU／RoPE ：一般的なLLM構成要素の中間メモリ割り当てをなくす。

• チャンク演算 ：大きなテンソルをタイルで処理し、ピークメモリを一定に保つ。

結果 ：1行の統合（apply_liger_kernel_to_llama()）でスループットが20%向上し、メモリを最大60%削減する。FSDP、DeepSpeed、LoRAと互換性がある。

Unsloth (Han and Han 2024)

カスタムCUDA／Tritonカーネル と積極的なメモリ最適化を組み合わせた、専門的なファインチューニングライブラリです。

• LoRAレイヤーを通る手動バックプロパゲーション（autogradのオーバーヘッドを避ける）。

• 融合デ量子化付き4-bit QLoRA。単一の48 GB GPUで70Bモデルを学習できる。

• アーキテクチャ（Llama、Mistral、Qwen、Gemma）ごとに最適化したRoPEとアテンションカーネル融合。

結果 ：素のHuggingFace＋PEFTより2〜5\(\times\)高速で、VRAMを60〜70%削減。単一GPUやコンシューマーハードウェアのワークフローで特に効果的です。

torchtune (P. Team 2024)

MetaのネイティブPyTorchファインチューニングライブラリ（開発は2025年に縮小）。モノリシックな抽象化ではなく 合成可能性 を中心に設計されています。

• 純粋なPyTorch。Trainerクラスはなく、レシピは読みやすい単一ファイルのスクリプト。

• torch.compile、FSDP2、アクティベーションチェックポイントとのネイティブ統合。

• QLoRA、完全なファインチューニング、知識蒸留を第一級にサポート。

• 学習後圧縮のための量子化認識学習（QAT）を組み込みで提供。

結果 ：カスタムソリューションと同等の速度を、完全なデバッグ可能性とフレームワークロックインなしで実現します。

Important

効率スタックの選択

• \(\leq\)1 GPUでの迅速なLoRA／QLoRA ：Unsloth（学習時間が最短で、セットアップが最小）。

• マルチGPUの完全なファインチューニング ：TRL／DeepSpeed＋Liger Kernel（大規模で最高のスループット）

• 研究／カスタム学習ループ ：torchtune（透明で改造しやすいネイティブPyTorch）

これらは 相補的 です。LigerカーネルはTRLとtorchtuneの両方のワークフロー内で使えます。

ベストプラクティス

SFT学習のガイドライン。

Tip

SFTだけでは不十分

SFTは書式と基本的な指示追従を教えますが、選好（どの応答がよいか — RLHF／DPOが必要）、拒否（いつ答えないか — 安全性学習が必要）、キャリブレーション（「分からない」と言うこと — 真実性報酬付きRLが必要）、複雑な推論（多段階の連鎖 — 検証可能な報酬付きRLが必要）を確実には教えられません。完全なパイプラインは、事前学習 \(\to\) SFT \(\to\) RLHF／DPOです。

LoRAとパラメータ効率のよいファインチューニング

70Bモデルの完全なファインチューニングには、70B個の学習可能パラメータとオプティマイザー状態を保存する必要があります（メモリ560 GB以上）。LoRA (Hu et al. 2022b)（Low-Rank Adaptation）は、パラメータの \(<\)1% だけで同等の品質を得るファインチューニング方法です。

LoRAの洞察

Important

LoRAの核心

完全な重み行列 \(W \in \mathbb{R}^{d \times d}\) を更新する代わりに、低ランクの摂動を学習します。 \[ W' = W + \frac{\alpha}{r} \cdot BA, \quad B \in \mathbb{R}^{d \times r}, ; A \in \mathbb{R}^{r \times d} \]

• \(W\) は 凍結 される（勾配もオプティマイザー状態もない）

• \(B\) と \(A\) だけを学習する：\(d^2\) ではなく \(2 \times d \times r\) パラメータ

• ランク \(r=16\)、\(d=4096\) では、LoRAはレイヤーあたり \(2 \times 4096 \times 16 = 131K\) パラメータを追加する。完全行列では \(16.8M\)。

• \(\alpha/r\) スケーリングが更新の大きさを制御する

Tip

低ランクが機能する理由

Aghajanyanら (Aghajanyan et al. 2021) は、ファインチューニングが非常に低次元の部分空間で行われることを示しました。ファインチューニングタスクの「内在次元」はモデルのパラメータ数よりはるかに小さいのです。175Bモデルのファインチューニングタスクの内在次元は \(<\)10,000かもしれません。LoRAはこれを直接利用し、ランク \(r\) によって重み行列ごとの更新を \(r\) 次元部分空間に制限します。

Tip

$\alpha/r$ スケーリングが重要な理由

スケーリングがなければ、ランク \(r\) を2倍にすると \(\Delta W = BA\) の大きさもおよそ2倍になります（\(B\) のより多くの列が和に寄与するため）。つまりランクを変えるとモデルへの摂動量も変わり、\(r\) を調整するたびに学習率を再調整する必要があります。

\(\alpha/r\) 係数は、ランクによらず更新の大きさがほぼ一定になるよう 正規化 します。 \[ W' = W + \frac{\alpha}{r} \cdot BA \]

• \(\alpha\) を固定して \(r\) を変える ：実効更新量はランクに関係なく \(\sim\alpha\) に保たれる。学習率を再調整せず \(r \in \{8, 16, 32, 64\}\) を試せる。

• 一般的な設定 ：\(\alpha = r\)（\(\alpha/r = 1\)）または \(\alpha = 2r\)（\(\alpha/r = 2\)）にする。スケーリング係数が小さな整数になる便利なデフォルトです。

• 学習率を調整するだけではだめか？ それも可能ですが、\(\alpha/r\) は ランクに依存しない 調整つまみになります。異なるランクの実験で学習率のレシピを共有できます。

• rsLoRAの洞察 (Kalajdzievski 2023)：高ランク（\(r \geq 64\)）では、\(BA\) の分散が \(r\) ではなく \(\sqrt{r}\) に比例するため、\(\alpha/\sqrt{r}\) の方が \(\alpha/r\) より安定だという実証結果があります。

LoRAのハイパーパラメータ

LoRAのハイパーパラメータを正しく選ぶことは重要です。ランクやalphaを誤ると、アンダーフィット（制約が強すぎる）か、メモリ浪費（表現力が過剰）になります。

LoRAのハイパーパラメータガイド。

Warning

ランク選択の経験則

• r=8 ：単純なタスク（単一ドメインチャット、分類）。非常にメモリ効率がよい。

• r=16 ：汎用ファインチューニング。よいデフォルト。

• r=32〜64 ：複雑なタスク（数学、コード、多ターン推論）。完全なファインチューニング品質に近づく。

• r=128以上 ：収穫逓減。完全なファインチューニングや高ランクQLoRAを検討する。

• 重要な指標 ：学習損失が完全なファインチューニングの損失よりかなり高いところで頭打ちなら、ランクを上げる。

LoRAの派生手法

LoRAの派生手法とその革新。

主な拡張の説明

DoRA — 重み分解低ランク適応

DoRA (S.-Y. Liu et al. 2024) は、完全なファインチューニングでは重みベクトルの大きさより 方向 が変わりやすいことに着目します。標準LoRAでは両者が混ざります。DoRAは各重み列を大きさ \(m = \\vert W\\vert _\text{col}\) と方向 \(\hat{V} = W / \\vert W\\vert _\text{col}\) に分解し、LoRAを方向だけに適用します。

\[ W' = m \odot \hat{V}', \quad \hat{V}' = \frac{W + BA}{|W + BA|_\text{col}} \]

大きさ \(m\) は別の学習可能なベクトル（列ごとに1スカラー）です。追加の推論コストなし（デプロイ時にマージ）で、推論・指示追従ベンチマークにおいてLoRAを一貫して1〜3%上回ります。

LoRA+ — 非対称学習率

Hayouら (Hayou et al. 2024) は、LoRAの行列 \(A\) と \(B\) には異なる最適学習率があることを示しました。\(B\) はゼロで初期化されるため、\(\mathcal{N}(0, \sigma^2)\) で初期化される \(A\) とは異なる状態から始まります。\(\eta_B \approx 16 \times \eta_A\) にすると、収束速度と最終品質が \(\sim\) 2%向上します。設定を1行変えるだけの追加コストなしの改善です。

# LoRA+ in PEFT: set different LRs per matrix
optimizer_grouped_parameters = [
    {"params": [p for n, p in model.named_parameters() if "lora_B" in n],
     "lr": 2e-4 * 16},   # B matrix: higher LR
    {"params": [p for n, p in model.named_parameters() if "lora_A" in n],
     "lr": 2e-4},         # A matrix: base LR
]

VeRA — ベクトルベースのランダム行列適応

VeRA (Kopiczko et al. 2024) はパラメータ効率を極限まで高めます。\(A\) と \(B\) を学習する代わりに、全レイヤーで共有するランダム行列として 凍結 し、2つの対角スケーリングベクトル \(d_b \in \mathbb{R}^r\)、\(d_a \in \mathbb{R}^d\) だけを学習します。

\[ \Delta W = B \cdot \text{diag}(d_b) \cdot A \cdot \text{diag}(d_a) \]

これはLoRAと比べて学習可能パラメータを \(\sim\) 10\(\times\)削減し（レイヤーあたり \(r + d\) パラメータのみ）、LoRA品質の90〜95%を達成します。最小限のストレージで数百のタスク固有アダプターが必要な場面に最適です。

Note

QLoRAによるメモリ削減

70Bモデルの完全なファインチューニング ：140 GB（重み）＋280 GB（オプティマイザー）＋140 GB（勾配）＝560 GB（A100-80GBが7\(\times\)）。

70B QLoRA（r=16、すべての線形層） ：

• NF4のベースモデル：\(70\text{B} \times 0.5 = 35\) GB

• BF16のLoRAアダプター：\(\sim\)160 MB

• オプティマイザー状態（アダプターのみ）：\(\sim\)320 MB

• 活性値（勾配チェックポイント）：\(\sim\)8 GB

• 合計：\(\sim\)44 GB ——48GB GPU 1台に収まる。

# QLoRA configuration with PEFT
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from transformers import BitsAndBytesConfig
import torch

# 4-bit quantization config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",           # NormalFloat4 - optimal for weights
    bnb_4bit_compute_dtype=torch.bfloat16, # Compute in BF16
    bnb_4bit_use_double_quant=True,       # Quantize the quantization constants
)

# LoRA config
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,                        # alpha/r = 2x scaling
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = prepare_model_for_kbit_training(model)  # Prepare for QLoRA
model = get_peft_model(model, lora_config)       # Add LoRA adapters
model.print_trainable_parameters()
# Output: trainable params: 83,886,080 || all params: 70,553,706,496 || 0.12%

その他のPEFT手法

LoRAは現在の実務で主流だが、パラメータ効率のよい手法はこれだけではない。ここでは主な代替手法を挙げる。

PEFT手法の系統。LoRAはLLMファインチューニングの事実上の標準であり、その他は歴史的背景とニッチな用途のために掲載している。

Tip

LoRAが主流になった理由

LoRAが標準になったのは、(1) 推論オーバーヘッドがゼロ ——アダプターをベース重みにマージでき、レイテンシを増やしたりコンテキストを消費したりするAdaptersやPrefix Tuningとは異なる、(2) 合成可能性 ——マルチテナント環境で、サービング時に複数のLoRAアダプターを交換できる、(3) エコシステムのサポート ——HuggingFace PEFT、TRL、vLLM、主要なフレームワークがすべてLoRAを第一級にサポートしている、(4) 大規模運用で実証済み ——Meta、Google、およびHuggingFace上のオープンソースのファインチューニングの大半で本番利用されている、という特徴を独自に兼ね備えるからである。LoRAでは満たせない具体的な制約がない限り、デフォルトの選択肢にすべきだ。

Mixture of Experts（MoE）

Mixture of Expertsモデル（Shazeer et al. 2017、Jiang et al. 2024）は、トークンごとにパラメータの一部だけを活性化することで、計算コストを比例して増やさずにモデル容量を拡大する。

アーキテクチャ

Important

MoE層

MoEトランスフォーマーでは、各ブロックのFFN層を、並列な\(N\)個の「エキスパート」FFNと、どのエキスパートを使うか選ぶ ルーター に置き換える。 \[ \text{MoE}(x) = \sum_{i=1}^{N} g_i(x) \cdot E_i(x), \quad g(x) = \text{TopK}(\text{softmax}(W_r x)) \]

• \(E_i\) はエキスパートネットワーク（標準的なFFN層）

• \(g_i(x)\) はルーターから得られるゲーティング重み（上位\(K\)個だけが非ゼロ）

• 通常、\(N=8\)〜64個のエキスパートのうち\(K=2\)個がトークンごとに活性化される

• 総パラメータ数は\(N\)に比例し、 活性パラメータ数 はFFNサイズの\(K/N\)に比例する

負荷分散

Warning

負荷分散の問題

制約がなければ、ルーターは大半のトークンを同じ1〜2個のエキスパートに送る可能性がある（「エキスパート崩壊」）。これは容量を無駄にし、GPU間の計算負荷の不均衡を生む（通常、各エキスパートは別々のGPUに配置される）。

解決策 ：負荷分散の補助損失を追加する。 \[ \mathcal{L}_{\text{bal}} = \alpha \cdot N \sum_{i=1}^{N} f_i \cdot p_i \] ここで\(f_i\)はエキスパート\(i\)にルーティングされたトークンの割合、\(p_i\)はエキスパート\(i\)に対するルーター確率の平均である。これにより、エキスパートを均等に利用するよう促す。

Noisy Top-Kゲーティング：離散ルーティングを学習可能にする

MoEの中心的な課題は、 top-\(k\)選択が微分不可能 なことである——「上位2個を選ぶ」というハードな操作を通じて逆伝播できない。この問題を解決するため、研究分野では2つの主要な工夫が開発されてきた。

Tip

ルーティングの微分可能性の問題

ルーターは各エキスパートについてロジット\(h(x) = W_r \cdot x\)を計算し、top-\(k\)を選択する。しかし、

• 選択されたエキスパートは、ゲート重み（選択されたものに対するsoftmax）を通じて勾配を受け取る

• 選択の判断そのもの（どの\(k\)個を選ぶか）には勾配がない

• 工夫がなければ、ルーターは行き詰まる可能性がある。あるエキスパートが選ばれない \(\rightarrow\) 勾配信号を受け取れない \(\rightarrow\) その後も選ばれない、という循環に陥るためである

アプローチ1：Noisy Top-Kゲーティング (Shazeer et al. 2017)

top-\(k\)選択の前に、ルーターのロジットへ学習可能なガウスノイズを加える。

\[ \begin{aligned} h(x) &= W_g \cdot x && \text{(clean logits)} \\ H(x) &= h(x) + \epsilon \cdot \text{Softplus}(W_{\text{noise}} \cdot x), \quad \epsilon \sim \mathcal{N}(0, 1) && \text{(noisy logits)} \\ \text{TopK}(v, k)_i &= \begin{cases} v_i & \text{if } v_i \text{ is in the top } k \\ -\infty & \text{otherwise} \end{cases} \\ g(x) &= \text{softmax}\big(\text{TopK}(H(x),, k)\big) && \text{(sparse gates)} \end{aligned} \]

• \(W_{\text{noise}}\) は学習されるノイズの大きさであり、モデルは各エキスパートにどの程度の探索が必要かを学習する

• 学習中はノイズによって「劣勢」のエキスパートがときどきtop-\(k\)に入り、勾配信号を受け取れる

• 推論時にはノイズを除き、決定的なルーティングのためにクリーンなロジット\(h(x)\)を使う

• Softplusにより、ノイズのスケールは常に正になる

アプローチ2：Gumbel-Softmaxトリック（微分可能な離散サンプリング）

変分推論の文献に由来する代替手法である（Jang et al. 2017）。 Gumbel-Maxトリック はカテゴリ分布からの正確なサンプリングを提供する。

\[ z = \arg\max_i \left[ \log \pi_i + G_i \right], \quad G_i \sim \text{Gumbel}(0,1) \]

ここで、Gumbelノイズは\(G_i = -\log(-\log(U_i)),; U_i \sim \text{Uniform}(0,1)\)として生成される。

top-\(k\)ルーティング では、\((\log \pi_i + G_i)\)のtop-\(k\)を取ることで、\(\pi\)が定めるカテゴリ分布からの\(k\)個の非復元サンプルが得られる。

\(\arg\max\)は微分不可能なので、 Gumbel-Softmax 緩和ではこれを温度制御されたsoftmaxに置き換える。

\[ \hat{g}_i = \frac{\exp\left((\log \pi_i + G_i) / \tau\right)}{\sum_j \exp\left((\log \pi_j + G_j) / \tau\right)} \]

• \(\tau \to 0\)：ハードなone-hotに近づく（正確だが微分不可能）

• \(\tau \to \infty\)：一様分布に近づく（微分可能だが情報を持たない）

• 実際には、学習中に\(\tau\)を1.0から0.1〜0.5までアニーリングする

• Straight-through推定量 ：順伝播ではハードなtop-\(k\)を使い、逆伝播ではGumbel-Softmaxの勾配を使う——両者の長所を組み合わせられる

Important

実務ではどの手法を使うか

• Sparsely-Gated MoE (Shazeer et al. 2017)、Mixtral (Jiang et al. 2024)、DeepSeek-V2 (DeepSeek-AI 2024a) ：ガウスノイズを使うNoisy Top-Kを採用する。単純で効果的であり、大規模モデルで十分に実証されている。

• Switch Transformer (Fedus et al. 2022) ：ノイズなしのTop-1に簡略化している（負荷分散損失だけに依存する）。

• 研究用／小規模MoE ：完全に微分可能なルーティングのためGumbel-Softmaxを使う例もある。特に、ルーティング自体の学習が研究目的である場合に用いられる。

• 重要な洞察 ：どちらの手法も、ノイズ注入によって同じ問題（離散選択を学習可能にすること）を解決する。ガウスノイズはより単純であり、Gumbelノイズはカテゴリサンプリングに対する理論的保証がより強い。

代表的なMoEモデル

LLM学習における多様性

学習データ、モデル出力、最適化の軌跡における多様性は、モード崩壊を防ぎ、頑健で汎用的なLLMを実現するうえで重要である。この節では、LLM学習のすべての段階に適用できる主要な多様性の仕組みを扱う。

サンプリングの多様性

Important

多様な生成のためのサンプリング戦略

• 温度 \(\tau\) ：\(P(x_i) \propto \exp(\text{logit}_i / \tau)\)。\(\tau\)が高いほど分布は一様になり、多様性が増す。RLHFでの生成では通常\(\tau=0.7\)〜\(1.0\)。

• Top-\(k\) ：確率が最も高い\(k\)個のトークンだけからサンプリングする。確率の低い退化したトークンを防ぐ。

• Top-\(p\)（nucleus） ：累積確率が\(\geq p\)となる最小のトークン集合からサンプリングする。適応的なので、モデルが不確かなときほど多様になる。

• Min-\(p\) ：\(P \geq p_{\min} \times P_{\max}\)を満たすトークンだけを残す。top-\(k\)より原理に沿った方法である。

• 頻度／存在ペナルティ ：応答中に現れたトークンにペナルティを与える。語彙の多様性を促す。

学習データの多様性

• プロンプトの多様性 ：異なる領域、難易度、形式をカバーする。ゴルディロックス原理に従い、プロンプトの成功率は20〜80%にする。

• 重複除去 ：ほぼ重複する学習例（MinHash、n-gramの重なり）を削除する。重複は特定のパターンへの過学習を招く。

• データ混合 ：温度重み付きサンプリングやカリキュラム戦略を使い、タスクや領域間のバランスを取る。

多様性を促す手法

テキスト生成：デコーディング手法

学習済み言語モデルは各ステップで語彙上の確率分布\(P(x_t \vert x_{<t})\)を出力する。 デコーディング戦略 は、この分布から次のトークンをどう選ぶかを決める。この選択は出力の品質、多様性、一貫性に大きな影響を与える。

貪欲デコーディング

最も単純な戦略であり、常に確率が最も高いトークンを選ぶ。

\[ x_t = \arg\max_{v \in \mathcal{V}} P(v | x_{<t}) \]

直感 ：文中で常に最も明白な次の単語を選ぶようなもの。「The capital of France is...」\(\to\)「Paris」（確率0.92）。

長所 ：決定的で高速、ハイパーパラメータが不要。
短所 ：反復的で一般的なテキストを生成する。序盤の確率が低いトークンが全体としてよりよい出力につながる高品質な系列を逃す。多様性がない。

ビームサーチ

\(B\)個（ビーム幅）の部分仮説を並列に保持し、それぞれをtop-\(k\)トークンで展開しながら、スコアの高い\(B\)個の完成系列を残す。

\[ \text{score}(y_{1:t}) = \sum_{i=1}^{t} \log P(y_i | y_{<i}) \]

短い系列が有利になるのを避けるため、 長さ正規化 を行う。

\[ \text{score}_{\text{norm}}(y) = \frac{1}{|y|^\alpha} \sum_{i=1}^{|y|} \log P(y_i | y_{<i}), \quad \alpha \in [0.6, 1.0] \]

直感 ：迷路で複数の経路を同時に探索し、分岐点ごとに最も有望な\(B\)本だけを残すようなもの。

長所 ：貪欲法より尤度の高い系列を見つける。「正解」が1つに近い翻訳や要約に適する。
短所 ：自由生成では一般的で反復的なテキストに偏りやすい。計算量は\(B \times\)になり、すべてのビームが似た出力に収束することも多い。

多様ビームサーチ

標準的なビームサーチでは、ほぼ重複するビームが生じる。多様ビームサーチ（Vijayakumar et al. 2018）はビームを\(G\)個のグループに分け、グループ間に 非類似度ペナルティ を加える。

\[ \text{score}_g(y_t) = \log P(y_t | y_{<t}) - \lambda \sum_{g'<g} \Delta(y_t, Y_{g'}) \]

ここで\(\Delta\)は先行グループがすでに選んだトークンとの重なり（例えばハミング多様性）を測り、\(\lambda\)は多様性の強さを制御する。

直感 ：ブレインストーミングのグループに異なるアイデアを出させるようなもの。各サブグループは、先行サブグループの発言を繰り返すとペナルティを受ける。

長所 ：本当に異なる候補系列を生成し、再ランキングのパイプラインに有用。
短所 ：多様性ペナルティによって個々のビームの品質が低下しうる。ハイパーパラメータ（\(G\)、\(\lambda\)）も増える。

Top-\(k\) サンプリング

最も確率の高い\(k\)個のトークンだけからサンプリングし、確率質量を再配分する。

\[ P'(v | x_{<t}) = \begin{cases} \dfrac{P(v | x_{<t})}{\sum_{v' \in \text{Top-}k} P(v' | x_{<t})} & \text{if } v \in \text{Top-}k \\[6pt] 0 & \text{otherwise} \end{cases} \]

直感 ：「The cat sat on the...」の後では、もっともらしい上位\(k\)個の続き（「mat」「floor」「couch」など）だけを考え、極端にありそうにないもの（「quantum」「archipelago」など）は無視する。

長所 ：裾のノイズを除き、実装が簡単。
短所 ：固定された\(k\)は、尖った分布では制限が強すぎて確率質量を無駄にし、平坦な分布では緩すぎて不要なトークンを含めてしまう。

Top-\(p\)（Nucleus）サンプリング

累積確率が\(p\)を超える最小のトークン集合からサンプリングする。

\[ \text{Top-}p = \min \left\{ S \subseteq \mathcal{V} : \sum_{v \in S} P(v | x_{<t}) \geq p \right\} \]

トークンを確率の降順に並べ、しきい値\(p\)に達するまで追加する。

直感 ：候補集合の大きさを適応的に変える。モデルが確信している場合（「Paris」が95%）はnucleusが小さくなり、不確かな場合（「The movie was...」）はもっともらしい形容詞を多く含むようnucleusが広がる。

長所 ：分布の形状に適応し、広く使われるデフォルト（\(p=0.9\)〜\(0.95\)）である。
短所 ：nucleusの末尾に低品質なトークンが含まれることがある。しきい値は単一のグローバルなハイパーパラメータである。

Tip

Top-kkとTop-pp

次の単語を予測する場合を考えよう。

• 「2 + 2 =」の後では分布が尖っており、top-1トークン（「4」）が99%の質量を持つ。Top-\(k\)=50では、間違った答え49個まで無駄に検討する。Top-\(p\)=0.9なら「4」だけを正しく選ぶ。

• 「I enjoy eating」の後では分布が平坦で、多くの食べ物がもっともらしい。Top-\(k\)=5では制限が強すぎる。Top-\(p\)=0.9なら50個以上のトークンを含むことがあり、実際の不確かさに合う。

Top-\(p\)は適応するが、top-\(k\)は適応しない。実際には両者を組み合わせ、top-\(p\)とtop-\(k\)の共通部分からサンプリングすることが多い。

Min-\(p\) サンプリング

相対的な 確率の下限を設定する近年の代替手法（Nguyen 2024）：

\[ \text{Min-}p = \left\{ v \in \mathcal{V} : P(v | x_{<t}) \geq p_{\min} \cdot \max_{v'} P(v' | x_{<t}) \right\} \]

最上位トークンの確率の少なくとも\(p_{\min}\)倍の確率を持つトークンだけを残す。

直感 ：「最良のトークンの少なくとも10%の確率を持つトークンだけを考える」。最上位トークンの確率が0.8なら、0.08を超えるトークンだけが残る。最上位トークンの確率が0.05（非常に不確か）なら、0.005を超えるトークンが残り、候補集合は自然に広がる。

長所 ：モデルの確信度に自然に応じて変化する。尖った分布ではtop-\(p\)より退化したサンプルが少なく、直感的な単一パラメータで済む。
短所 ：新しく、十分に実績が蓄積されていない。すべての推論フレームワークで標準になっているわけではない。

温度スケーリング

どのサンプリング戦略を適用する前にも、ロジットを温度\(T\)で割る。

\[ P_T(v | x_{<t}) = \frac{\exp(z_v / T)}{\sum_{v'} \exp(z_{v'} / T)} \]

• \(T < 1\)：分布が尖る \(\to\) より決定的で焦点の合った出力になる。

• \(T = 1\)：モデルの分布をそのまま使う。

• \(T > 1\)：分布が平坦になる \(\to\) よりランダムで創造的な出力になる。

• \(T \to 0\)：貪欲デコーディングになる。\(T \to \infty\)：一様サンプリングになる。

一般的な設定 ：事実に関するタスクでは\(T=0.7\)、創作では\(T=1.0\)〜\(1.2\)、コードや数学では\(T=0.0\)（貪欲法）。

対照的デコーディング

対照的デコーディング（X. Li et al. 2023）は、強いモデル（エキスパート）と弱いモデル（アマチュア）の差を利用して、エキスパート固有の知識を増幅する。

\[ x_t = \arg\max_{v \in \mathcal{V}(x_{<t})} \left[ \log P_{\text{expert}}(v | x_{<t}) - \log P_{\text{amateur}}(v | x_{<t}) \right] \]

ここで\(\mathcal{V}(x_{<t}) = \{v : P_{\text{expert}}(v \vert x_{<t}) \geq \alpha \cdot \max_{v'} P_{\text{expert}}(v' \vert x_{<t})\}\)は適応的な妥当性制約である。

直感 ：アマチュアモデルは一般的で明白なパターン（よくある単語や反復）を捉える。その対数確率を引くことで、この「一般的な信号」を取り除き、エキスパートの特徴的な知識と推論を残す。録音から背景ノイズを除き、信号を聞き取るようなものだ。

長所 ：反復や一般的な言い回しを減らし、追加学習なしに事実性と一貫性を高める。任意のモデルペアで動作する。
短所 ：2つのモデルを実行する必要がある（計算量は2\(\times\)）。アマチュアモデルの選択に敏感で、妥当性しきい値\(\alpha\)の調整も必要である。

反復ペナルティ

サンプリング戦略とは独立に、反復ペナルティはモデルがトークンを繰り返すのを抑制する。トークン\(v\)の生ロジット\(z_v\)（つまりsoftmax前にLMヘッドが出力する正規化前のスコア）が与えられたとき、ペナルティ後のロジットは次のようになる。

\[ z_v' = \begin{cases} z_v / \theta & \text{if } v \in \text{generated tokens and } z_v > 0 \\ z_v \cdot \theta & \text{if } v \in \text{generated tokens and } z_v < 0 \end{cases} \]

ここで\(\theta > 1\)はペナルティ係数（通常1.1〜1.3）である。どちらの場合も、ロジットを0へ近づけることで、以前に生成したトークンの確率を下げる。頻度ペナルティと存在ペナルティは、OpenAI APIで使われるより単純な加算型の変種である。

\[ z_v' = z_v - \alpha \cdot \text{count}(v) - \beta \cdot \mathbf{1}[v \in \text{generated}] \]

ここで\(\alpha\)は頻度ペナルティ（\(v\)が現れた回数に比例）で、\(\beta\)は存在ペナルティ（過去に一度でも現れた場合に一律で課すペナルティ）である。

実用比較

LLMテキスト生成におけるデコーディング手法の比較。

Note

実際のデコーディング：「Once upon a time」

プロンプト「Once upon a time」が与えられた場合：

• 貪欲法 ：「there was a young girl who lived in a small village...」（一般的なおとぎ話）

• Top-\(p\)=0.9、\(T\)=1.0 ：「the rivers ran backwards and the fish learned to fly...」（創造的で意外）

• Top-\(p\)=0.9、\(T\)=0.3 ：「there was a kingdom ruled by a wise and just king...」（一貫していて慣習的）

• 対照的 ：「in the amber-lit corridors of a collapsing star, two minds argued about the nature of time...」（特徴的で、決まり文句を避ける）

同じモデル、同じプロンプトでも、デコーディング戦略が出力の性格を決める。

制約付きデコーディング（構造化生成）

上記の手法はすべて、各ステップで語彙全体からサンプリングする。 制約付きデコーディング は許可されるトークン集合を制限し、出力が形式文法（通常はJSONスキーマ、正規表現、または文脈自由文法（CFG））に従うことを保証する。

中核メカニズム

各デコーディングステップ\(t\)で、現在のパーサ状態から トークンマスク\(M_t \subseteq \mathcal{V}\)を計算する。\(M_t\)内のトークンだけが元のロジットを受け取り、それ以外はsoftmaxの前に\(-\infty\)へ設定する。

\[ P'(v | x_{<t}) = \begin{cases} P(v | x_{<t}) / Z & \text{if } v \in M_t \\ 0 & \text{otherwise} \end{cases} \]

ここで\(Z = \sum_{v \in M_t} P(v \vert x_{<t})\)は再正規化を行う。マスクは各ステップで変化し（それまでに生成された内容に依存する）、制約は逐次的に適用される。そのためモデルはどの時点でも無効な接頭辞を生成できない。

スキーマからマスクへ

コンパイルのパイプラインは次のとおりである。

\[ \text{JSON Schema} ;\xrightarrow{\text{compile}}; \text{Regex} ;\xrightarrow{\text{compile}}; \text{FSM (DFA)} ;\xrightarrow{\text{index}}; \text{Token Mask per State} \]

FSMの状態は正規表現内の位置に対応する。各状態について、文字列をその言語内に保てるすべての語彙トークンをインデックスへ事前計算する（スキーマごとに一度だけ必要なコスト）。実行時のマスク検索は\(O(1)\)のテーブル参照なので、各デコーディングステップへのレイテンシ追加はごくわずかである。

主要ライブラリ

• Outlines (Willard and Louf 2023：JSONスキーマと正規表現をFSMにコンパイルし、FSMに導かれる生成へ組み込む。ロジットインターフェースを持つ任意のモデルをサポートする。

• lm-format-enforcer¹：同様のFSM方式で、サービングフレームワーク（vLLM、TGI）との統合に重点を置く。

• Guidance²（Microsoft）：制約付き生成を制御フロー（ループ、条件分岐）と組み合わせ、単純なスキーマを超える複雑な構造化出力を可能にする。

• XGrammar (Dong et al. 2024：プッシュダウンオートマトンに基づくエンジンで、正規言語だけでなく完全な文脈自由文法をサポートする。MLC-LLMやvLLMで文法モードのデコーディングに使われる。

トレードオフ

制約付きデコーディングは構文的な妥当性を保証し、事後のパース失敗やリトライをなくす。ただし、

• 意味的品質 ：モデルが「正しい」答えに割り当てる確率質量が文法の外にある場合、構造を強制すると内容の品質が低下しうる。適切に設計されたスキーマと十分に学習されたモデルでは、実際にはまれである。

• コンパイルコスト ：FSMインデックスはスキーマごとに構築する必要がある。複雑なスキーマでは1〜5秒かかることがあるが、そのスキーマを使うすべてのリクエストに対して償却される。

• 文法のカバレッジ ：正規表現／FSMはJSON、YAML、SQL断片、その他大半の構造化形式を扱う。完全なCFG（XGrammarやLALRパーサーによるもの）はPythonやXMLのような言語をカバーする。

Important

制約付きデコーディングを使う場面

モデル出力の利用者が人間ではなくプログラムである場合は、制約付きデコーディングを使うとよい。ツール呼び出しエージェント、APIバックエンド、データ抽出パイプラインはいずれも、妥当な構造が保証されることで恩恵を受ける。自由形式の文章や創作テキストには、制約なしのサンプリングが適している。

プロンプトエンジニアリング

プロンプトエンジニアリングとは、モデルの重みを変更せずに、望ましい振る舞いをLLMから安定して引き出す入力を設計する分野である。ファインチューニングがモデルを変更するのに対し、プロンプトエンジニアリングは、適切な枠組み、例、構造によってモデルの既存の能力を引き出す。LLMの出力を改善する最も速く、安価で、利用しやすい手段であり、ファインチューニング済みモデルを使う場合でも不可欠である。

文脈内学習（ICL）

文脈内学習（Brown et al. 2020）は、勾配更新なしに、プロンプトに与えられた例だけから推論時にタスクを学習する大規模言語モデルの注目すべき能力である。モデルは入力と出力のペアのパターンから暗黙にタスクを推測し、新しい入力へ一般化する。

Important

文脈内学習が機能する理由

• 暗黙のベイズ推論 ：モデルは事前学習中に数百万のタスクを見ている。プロンプトの例は、モデルが学習した分布の中で関連するタスクを特定する（Xie et al. 2022）。

• 誘導ヘッド ：特定のアテンションヘッドがパターン（「A is to B as C is to 」）をコピーすることを学び、文脈内での一般化を可能にする（Olsson et al. 2022）。

• タスクベクトル ：ICLは残差ストリームに暗黙のタスク表現を作り、実演された形式と内容へ生成を誘導する（Todd et al. 2024）。

スケーリングの挙動

ICLは主に\(\sim\)1Bパラメータを超えるモデルで現れ、モデル規模とともに対数線形に向上する（Brown et al. 2020）。小規模モデルは例を記憶できても、同じコンテキストウィンドウ内の未知の入力へ一般化するのは難しい。

ゼロショットプロンプティング

ゼロショットプロンプティングでは例を一切与えず、タスクの説明または指示だけを与える。モデルは正しい形式と内容を生成するため、事前学習で得た知識と指示チューニングだけに頼らなければならない。

Note

ゼロショット分類

次の映画レビューをPOSITIVEまたはNEGATIVEに分類せよ。

レビュー：「映像は息をのむほど素晴らしかったが、筋書きは
急ぎ足で予測可能に感じられた。」

感情：

ゼロショットがうまくいく場合

• 事前学習／SFTでモデルが十分に見てきたタスク（翻訳、要約、感情分析）

• 出力形式が曖昧でない、明確に定義された指示

• 指示チューニングされたモデル（ChatGPT、Claude、Llama-3-Instructなど）は、ゼロショットタスクでベースモデルを大きく上回る（Ouyang et al. 2022）

ゼロショットが失敗する場合

新しい形式、領域固有のラベル体系、または指示だけでは正確な要件を推測できない曖昧なタスクでは失敗する。

few-shotプロンプティング

Few-shotプロンプティング（Brown et al. 2020）では、実際のクエリの前に\(k\)個の入出力例（「ショット」）を与える。これは文脈内学習で最も一般的な形であり、現在でも最も効果的なプロンプティング戦略の一つである。

Note

Few-shot固有表現認識

テキストから固有表現を抽出せよ。形式：ENTITY

テキスト：「Apple released the iPhone 15 in Cupertino.」
固有表現：[Apple](ORG)、[iPhone 15](PRODUCT)、[Cupertino](LOC)

テキスト：「Elon Musk announced Tesla's new factory in Berlin.」
固有表現：[Elon Musk](PER)、[Tesla](ORG)、[Berlin](LOC)

テキスト：「OpenAI partnered with Microsoft to deploy GPT-4.」
固有表現：

few-shot例の設計原則

1. 多様性 ：想定される入力の範囲（異なる長さ、エッジケース、カテゴリ）をカバーする。

2. 順序 ：難しい例や代表的な例を最後に置く（新近性バイアス）（Lu et al. 2022）。

3. ラベルのバランス ：分類では、最多クラスへのバイアスを避けるため、すべてのクラスの例を含める。

4. 形式の一貫性 ：すべての例がまったく同じ構造に従うようにする。モデルはそのパターンを模倣する。

5. 関連性 ：最良の結果を得るには、対象クエリと意味的に似た例を使う（J. Liu et al. 2022）。

何ショット必要か？

性能は通常、例が0個から4〜8個になるまで向上し、その後は頭打ちになる。\(\sim\)20例を超えると改善はわずかで、コンテキストウィンドウを埋めるリスクがある。Minら（Min et al. 2022）は、例の形式とラベル空間がラベルの正しさより重要であることを示した。ランダムなラベルでも役に立つ（ただし正しいラベルの方がより有効）。

指示追従プロンプト

指示チューニングされたモデルは、明確で構造化された指示に最もよく応答する。重要なのは、プロンプトを提案ではなく仕様として扱うことである。

Important

効果的な指示プロンプトの構成

1. 役割／ペルソナ ：モデルが何者かを定義する（「あなたはシニアデータサイエンティストです……」）

2. タスク ：何をするかを明確かつ曖昧さなく述べる

3. コンテキスト ：モデルに必要な背景情報

4. 制約 ：長さの上限、語調、避けること、出力形式

5. 例 （任意）：望ましい出力形式を示す

6. 入力 ：処理対象の実データ

Note

制約付き指示プロンプト

役割：あなたは医学文献のレビュアーです。

タスク：次の研究要旨を一般読者向けに要約せよ。

制約：
- 最大3文
- 専門用語を使わない（技術用語は説明する）
- 主要な発見とその臨床的含意を含める
- 要旨に書かれている以上の推測を絶対にしない

Abstract: [...]

システムプロンプトとユーザープロンプト

現代のチャットAPIでは、システムプロンプト（永続的な指示、役割定義）とユーザーメッセージ（ターンごとの入力）を分離する。ほとんどのモデルではシステムプロンプトがより高いアテンション優先度で処理され、役割定義、制約、出力形式の仕様を置く自然な場所となる（OpenAI 2023）。

構造化出力プロンプト（JSON／XML）

プログラムから利用する場合、最も重要なプロンプティング技法は、特にJSONのような構造化出力を強制することである。

Note

JSON出力プロンプト

顧客メールから次の情報を抽出せよ。 有効なJSONだけで応答し、他のテキストは出力しないこと。

Schema:
{
  "intent": "refund|complaint|question|praise",
  "urgency": "low|medium|high",
  "product_mentioned": "string or null",
  "summary": "one sentence summary"
}

Email: [...]

信頼できる構造化出力の技法

• スキーマファースト ：入力より前に正確なJSONスキーマを示す。モデルはそれをテンプレートとして扱う。

• 制約付きデコーディング ：文法ベースのサンプリング（Outlines（Willard and Louf 2023）、Guidanceなど）を使い、トークンレベルで構文的に妥当なJSONを保証する。

• XMLタグ ：入れ子構造や複数部分の出力では、XMLタグ（例：<thinking>...</thinking>）が曖昧さのない区切りとなり、モデルは安定して従える。

• Pydantic／TypeScript型 ：型定義を与えると、モデルがフィールドの制約を理解しやすい（OpenAIの関数呼び出しは内部でJSON Schemaを使う）。

Warning

プロンプト内のJSON——よくある落とし穴

• モデルがMarkdownのフェンス（‘‘‘json ... ‘‘‘）を追加することがある。生のJSONを出力するよう明示する。

• 入れ子のオブジェクトや配列は幻覚のリスクを高める。可能ならスキーマを平坦化する。

• Enumフィールド（選択肢が固定されたフィールド）は自由記述フィールドよりはるかに信頼できる。

• 必ずプログラムで出力を検証する。制約付きデコーディングなしに、100%の遵守を保証するプロンプトはない。

JSONプロンプティング：入力を構造化する

これとは別だが補完的な技法がJSONプロンプティングである。自然言語ではなく、プロンプト自体をJSONとして整形する。これは構造化データ（API、設定、コード）に対するモデルの豊富な事前学習を利用し、指示への遵守を高め、曖昧さを減らし、複数フィールドの要求を決定的にパースできるようにする。

Note

システムプロンプトを使ったJSONプロンプティング

=== SYSTEM === あなたはシニアコードレビュアーです。コードのバグ、 セキュリティ問題、スタイル違反を分析してください。常に 与えられたJSONスキーマで応答してください。

=== USER (JSON prompt) ===
{
  "task": "code_review",
  "language": "python",
  "severity_filter": "high",
  "code": "def login(user, pw):\n    query = ...",
  "output_schema": {
    "issues": [{
      "line": "int",
      "severity": "critical|high|medium|low",
      "category": "security|bug|style|performance",
      "description": "string",
      "fix": "string"
    }],
    "overall_risk": "critical|high|medium|low"
  }
}

JSONプロンプティングが機能する理由：

• 曖昧さのないフィールド境界 ：ある指示が終わり、別の指示が始まる場所を混同しない。

• 型付き制約 ：フィールド"severity_filter": "high"は、「重大度の高い問題だけを表示せよ」より明確である。

• 契約としてのスキーマ ：入力にoutput_schemaを含めることは、モデルが事前学習中に大量に見てきたAPI設計パターンを反映する。

• システムプロンプトは依然として不可欠 ：システムメッセージは、JSONペイロードには自然に収まらない役割、語調、振る舞いの制約を与える。

Chain-of-Thought（CoT）プロンプティング

Chain-of-thoughtプロンプティング（Wei et al. 2022）は、最終回答の前に中間的な推論ステップを生成するようモデルに求める。この単純な技法により、算術、論理、常識推論、コード生成など、複数ステップの推論を必要とするタスクの性能が大きく向上する。

CoTが機能する理由

• 計算を逐次化する ：Transformerの深さは固定だが、生成の長さは可変である。CoTは並列的で難しい問題を逐次的で簡単なステップに変換し、モデルの計算予算を実質的に増やす。

• 誤差の累積を減らす ：各ステップがより単純な部分問題となり、ステップごとの誤り率が下がる。

• 中間状態を露出させる ：推論を監査・デバッグ可能にする。

Important

Chain-of-Thoughtの変種

手法	説明
Zero-shot CoT (Kojima et al. 2022)	任意のプロンプトに「一歩ずつ考えよう」を追加する
Few-shot CoT (Wei et al. 2022)	明示的な推論連鎖を含む例を与える
Self-Consistency (X. Wang, Wei, Schuurmans, Q. Le, et al. 2023)	\(N\)本のCoT経路をサンプリングし、最終回答を多数決する
Tree of Thoughts (S. Yao, Yu, et al. 2023)	バックトラッキングしながら複数の推論分岐を探索する
Plan-and-Solve (L. Wang et al. 2023)	まず手順を計画し、その後各ステップを実行する
ReAct (S. Yao, Zhao, et al. 2023)	推論と行動（ツール利用）を交互に行う

Note

ゼロショットChain-of-Thought

Q：店にリンゴが45個ある。午前にその3/5を売り、 午後に残りの1/3を売った。何個残っているか。

一歩ずつ考えてみよう。

A：午前の販売：45 * 3/5 = 27個を販売。
午前後の残り：45 - 27 = 18。
午後の販売：18 * 1/3 = 6個を販売。
残り：18 - 6 = 12個。

自己整合性

Wangら（X. Wang, Wei, Schuurmans, Q. Le, et al. 2023）は、複数のchain-of-thought推論経路をサンプリングし、最終回答を多数決すると、単一経路のCoTを大きく上回ることを示した。直感的には、正しい推論経路は同じ答えに収束しやすい一方、誤りは個別的である。この方法は、計算量（\(N\)個のサンプル生成）と引き換えに精度を得るもので、レイテンシより正しさが重要な場合に実用的である。

CoTが害になる場合

CoTが常に有益とは限らない。単純なタスク（1ステップの分類、検索、整形）では、CoTは不要なトークンを追加し、レイテンシを増やし、考えすぎによって誤りを生むことさえある。複数ステップの推論が必要だと予想されるタスクに限定してCoTを使うべきである。

高度なプロンプティング技法

検索拡張生成（RAG）

モデルのパラメトリック記憶だけに頼るのではなく、RAG（P. Lewis et al. 2020）は関連文書を検索し、プロンプトに含める。

コンテキスト（検索結果）：[文書の断片]
質問：[ユーザークエリ]
与えられたコンテキストだけに基づいて回答せよ。

これによりモデルの応答を検証可能な情報源に基づかせ、知識集約型タスクでの幻覚を大きく減らせる。

プロンプト連鎖と分解

複雑なタスクは、より単純なプロンプトのパイプラインへ分解すると効果的である。あるプロンプトの出力を次の入力にする。

1. 抽出：文書から重要な事実を取り出す

2. 推論：抽出した事実について推論する

3. 整形：最終回答を整形する

各ステップで異なるプロンプトテンプレート、モデル、温度設定を使える。単一の巨大なプロンプトより制御しやすく、対象を絞ったデバッグも可能になる。

Constitutional AI／自己批評

Baiら（Bai et al. 2022）は、一連の原則に照らして自分の出力を批評・修正するようモデルに求めるプロンプトを導入した。

[初期応答を生成]
批評：この応答は次の原則のいずれかに違反しているか。
[原則の一覧]
修正：批評に対応するよう応答を書き直す。

メタプロンプティングとプロンプト最適化

プロンプトを手作業で作るのではなく、近年の研究では設計を自動化している。

• APE (Y. Zhou et al. 2023：LLMを使って候補プロンプトを自動生成し、スコア付けする。

• DSPy (Khattab et al. 2024：宣言的なタスク記述を、学習されたfew-shot例を持つ最適化済みプロンプトパイプラインへコンパイルする。

• OPRO (C. Yang et al. 2024：LLMをオプティマイザーとして使い、プロンプト最適化を最適化問題として扱う。

注意を向けた推論クエリ（ARQ）

ARQ（Yang et al. 2025）は、標準的なプロンプティングの根本的な弱点に対処する。コンテキストが長くなるほど、モデルはプロンプト中央の重要情報を失いやすくなる（lost-in-the-middle効果）。ARQは複雑なクエリを複数の焦点化されたサブクエリに分解し、それぞれでコンテキストの特定部分へモデルの注意を向けることで、これを緩和する。

1. クエリ分解 ：ユーザーの質問を、狭い側面をそれぞれ対象とする原子的なサブクエリに分ける。

2. 注意を向けた検索 ：各サブクエリについて、関連するコンテキストの一部分だけを検索または強調し、モデルがそこに注意を向けるようにする。

3. 集約 ：サブ回答を一貫した最終応答にまとめる。

これは長文書QA、大規模な検索結果集合に対するマルチホップ推論、コンテキストウィンドウに多数のツール出力が含まれるエージェント型タスクで特に有効である。ARQは、モデルがどのように推論するかだけでなく、どこを見るかを明示的に管理する、構造化されたchain-of-thoughtとみなせる。

ベストプラクティス：効果的なプロンプトの作成

文献の実証的知見と実務経験に基づくと、次の原則はプロンプトの品質を安定して高める。

Important

プロンプトエンジニアリングのチェックリスト

1. 具体的かつ明確にする ：「これを要約して」ではなく、「実行可能な発見に焦点を当て、各20語未満の箇条書き2〜3個で要約して」と書く。

2. 説明するより示す ：良い例1つは指示100語に値する。迷ったらfew-shot例を追加する。

3. 出力形式を明示的に定義する ：JSONスキーマ、箇条書き、表形式、正確な区切り文字などを指定する。形式を解釈任せにしない。

4. 入力データに区切り文字を使う ：ユーザー入力を明確な区切り文字（"""、<input>...</input>、---）で囲み、指示とデータを分ける。

5. 役割を割り当てる ：「あなたは［特定の振る舞い］をする［領域の専門家］です」と書くと、関連する知識と語調が引き出される。

6. してはいけないことを指定する ：「推論を説明しない」「5項目を超えて出力しない」のような否定的制約は、肯定的制約より効果的なことが多い。

7. 推論タスクにはchain-of-thoughtを加える ：「一歩ずつ考えて」と追加するか、数学、論理、マルチホップ問題の解答例を与える。

8. 温度を適切に制御する ：事実的・決定的なタスクには\(T \approx 0\)、創造的・多様な出力には\(T \approx 0.7\)〜\(1.0\)を使う。

9. 実証的に反復する ：プロンプトをコードとして扱い、バージョン管理し、A/Bテストし、代表的な評価セットで性能を測る。

10. 新近性バイアスを活用する ：最も重要な指示と例をプロンプトの末尾（生成位置に最も近い場所）に置く。

プロンプティングでよくある失敗モードと解決策。

Tip

プロンプトエンジニアリングの考え方

プロンプトエンジニアリングを自然言語によるプログラミングと考える。モデルは強力だが字義通りのインタープリターであり、学習分布から最もありそうな形に解釈して、求めたことをそのまま実行する。ソフトウェア工学の一般的な原則が適用できる。

• DRY（Don’t Repeat Yourself） ：長いコンテキストで注意の減衰と戦う場合を除き、同じことを繰り返さない

• 関心の分離 ：役割、制約、例、入力をプロンプトの別々のセクションにする

• テスト駆動開発 ：プロンプトを書く前に期待する出力を定義する

• バージョン管理 ：プロンプトの反復と評価スコアを追跡する

• モジュール性 ：再利用可能なプロンプトテンプレートを作り、可変部分をパラメータ化する

体系的に反復してもプロンプティングで望ましい品質に達しないなら、ファインチューニング（SFT）や強化学習（RLHF／DPO）へ移る合図である。

モデル圧縮手法

モデル圧縮は品質を保ちながら、モデルサイズと推論コストを削減する。主なアプローチは3つある。量子化（精度を下げる）、刈り込み（パラメータを削除する）、蒸留（大きなモデルを模倣する小さなモデルを学習する）である。

量子化

量子化は、重み（必要に応じて活性値も）をより低精度の形式で表現し、モデルサイズと推論コストを削減する。中心となるトレードオフは、圧縮率と品質低下のバランスである。

Important

量子化の概要

量子化は、モデルの重み（必要に応じて活性値も）の数値精度をFP32／BF16から低ビット形式へ下げる。 \[ x_q = \text{round}!\left(\frac{x - z}{s}\right), \quad x_{\text{dequant}} = s \cdot x_q + z \] ここで\(s\)はスケール係数、\(z\)はゼロ点である。

LLMの量子化手法。

Tip

量子化するタイミング

• 推論サービング ：常に量子化する。W4A16（4-bit重み、BF16活性値）が最適点で、70B以上のモデルではメモリを2\(\times\)削減し、品質低下は\(<\)1%に抑えられる。

• 学習 ：H100上のFP8は品質をほとんど損なわずスループットを2\(\times\)にする。小規模モデルでは現在もBF16がデフォルトである。

• エッジ展開 ：民生ハードウェアでのローカル推論にはGGUF Q4_K_Mを使う。

• RLHF ：凍結したモデル（参照モデル、報酬モデル）をINT8／FP8へ量子化する。学習精度のため、方策はBF16のままにする。

刈り込み

なぜ刈り込むのか？

現代のLLMは数十億のパラメータを持つが、実証研究は一貫して、その大部分の重みがモデル出力にほとんど寄与しないことを示している。刈り込みはこの過剰パラメータ化を利用する。冗長な重みを削除することで、 メモリフットプリント （小さなGPUやエッジデバイスへの展開を可能にする）、 推論レイテンシ （順伝播ごとの積和演算を減らす）、 サービングコスト （1ドルあたりのスループットを高める）を削減する。全重みの精度を一様に下げる量子化とは異なり、刈り込みは重みを選択的に除去するため、量子化と組み合わせると乗算的な削減が可能になる（例えば50%スパースな4-bitモデルは、密なBF16ベースラインよりメモリ使用量が\(4\times\)少ない）。生成品質を損なわずに高いスパース性を達成することが課題であり、再学習を必要としない原理的な一括手法の開発につながった。

Important

刈り込み手法

• 非構造化刈り込み ：しきい値未満の個々の重みをゼロにする。高いスパース性（50〜90%）が可能。スパースGEMMカーネル（A100／H100では2:4）が必要。

• 構造化刈り込み ：アテンションヘッド、層、FFNニューロンを丸ごと削除する。特殊なカーネルなしにFLOPSを直接削減できる。

• SparseGPT (Frantar and Alistarh 2023：近似逆ヘッセ行列を使う一括刈り込み。175Bモデルで品質をほとんど損なわず50%の非構造化スパース性を実現する。

• Wanda (Sun et al. 2024：\(\vert w\vert \times \\vert x\\vert\)（重みの大きさと入力活性値ノルムの積）で刈り込む。キャリブレーションデータは不要で、SparseGPTと競合する。

Warning

NVIDIAの2:4構造化スパース性

A100／H100のTensor Coreは2:4スパース性をネイティブにサポートする。4要素ごとに、非ゼロなのは最大2つである。対応する演算ではハードウェアアクセラレーションにより、正確に2\(\times\)の高速化が得られる。制約は、この特定のパターンでちょうど50%のスパース性を達成しなければならず、任意のスパース性に比べて柔軟性が低いことである。

知識蒸留

知識蒸留（Hinton et al. 2015）は、大きな教師モデルが学習した振る舞いを、より小さく安価な生徒モデルへ移す。中心的な考え方は、教師のトークン上の出力分布が、正解のハードラベルだけよりはるかに豊かな信号を持つことである。クラス間の類似性、キャリブレーション、不確実性が明らかになり、生徒はこれらを利用できる。

温度スケールsoftmax

教師のロジットに含まれる「暗黙の知識」を引き出すため、温度\(T > 1\)で分布を軟化する。

\[ p_i^{(T)} = \frac{\exp(z_i / T)}{\sum_j \exp(z_j / T)} \]

高い温度では確率質量がより多くのトークンへ広がり、惜しい代替候補が見えるようになる。学習中は生徒にも同じ温度を適用し、推論時には生徒が\(T=1\)を使う。

一般的な蒸留損失

\[ \mathcal{L}_{\text{distill}} = \alpha , T^2 \cdot \text{KL}!\bigl(P_{\text{teacher}}^{(T)} ;|; P_{\text{student}}^{(T)}\bigr) ;+; (1-\alpha) \cdot \mathcal{L}_{\text{CE}}(y, P_{\text{student}}^{(1)}) \]

\(T^2\)の因子は、軟化された分布で勾配の大きさが小さくなることを補償する。典型的な値は\(T \in [2, 20]\)、\(\alpha \in [0.5, 0.9]\)である（教師の品質が高いほどKLに大きな重みを置く）。

LLMの知識蒸留パラダイム。

オフライン（ホワイトボックス）蒸留

各学習トークンについて、教師の完全なロジットベクトル（またはストレージ効率のためtop-\(k\)ロジット）を記録する。生徒は保存された分布に対するKLダイバージェンスを最小化する。教師へ自由にアクセスできる場合、これは最もデータ効率のよいパラダイムである。

動機 ：教師の推論と生徒の学習を分離する。高性能ハードウェアで教師を一度実行し、その後、多数の生徒を安価に学習する。

長所 ：決定的で再現可能。教師のコストを償却でき、分布全体の信号を利用できる。
短所 ：トークンごとに\(\vert V\vert\)次元のベクトルを保存する必要がある（top-\(k\)刈り込みで緩和可能）。教師は生徒の失敗に適応できない。

オンライン（協調学習）蒸留

教師と生徒を同時に実行し、教師が生徒の現在の学習バッチに対するロジットを生成する。

動機 ：教師が、生徒が現在苦手としている入力に集中できるようにする（カリキュラムに似た仕組み）。

長所 ：新鮮な信号を得られ、生徒が生成した入力をオンポリシー蒸留に使える。
短所 ：GPUコストが倍になる。同期間の複雑さがあり、スケールしにくい。

ブラックボックス（API）蒸留

テキスト出力だけが利用可能な場合（例えば独自APIから蒸留する場合）、生徒を教師の生成結果に対するSFTで学習し、必要に応じてchain-of-thoughtの軌跡を加える。

動機 ：実務上の現実として、最先端モデルの大半はロジットを公開していない。

長所 ：パイプラインが単純で、APIの背後にある任意のモデルで動作する。
短所 ：ソフトラベルの信号がない。幻覚を増幅しやすく、実質的には教師ありファインチューニングである。

自己蒸留

同じアーキテクチャ系列のより大きな版（例えばLlama-3 70B \(\to\) 8B）から、または学習中の自分自身のチェックポイントから蒸留する。

動機 ：別の教師を学習する必要をなくし、異なる規模におけるモデル自身の能力を利用する。

長所 ：アーキテクチャの互換性があり、外部依存がない。
短所 ：教師の上限がモデルの上限と等しく、本当に新しい知識は導入できない。

Tip

暗黙の知識

「The capital of France is」の次の単語を予測する言語モデルを考える。ハードラベルでは「Paris」だけが正解だとする。しかし教師のソフト分布は「Lyon」に5%、「Marseille」に2%、「banana」にほぼ0%を割り当てるかもしれない。これは生徒にどの誤りが妥当かを伝え、キャリブレーションと一般化を大きく改善する。

LLM蒸留の実践的考慮事項

• 系列レベルとトークンレベル ：トークンレベルのKLが標準である。系列全体でKLを最小化する系列レベル蒸留は長距離の一貫性をよりよく捉えるが、最適化は難しい。

• 層ごとのヒント ：中間表現（アテンションマップ、隠れ状態）を一致させると追加の学習信号が得られる。生徒のアーキテクチャが異なる場合に特に有用である。

• データ選択 ：蒸留データの品質は重要である。多様で難しい例を選ぶ方が、ランダムサンプリングよりよい生徒を生む。

• 生徒の容量 ：教師パラメータの\(\sim\)10%未満では収穫逓減が起きる。極端な圧縮では、アーキテクチャの変更（例えばMoE \(\to\)密結合）が必要になる場合がある。

• 量子化との組み合わせ ：蒸留と4-bit量子化（例えばQLoRA蒸留モデル）により、\(20\times\)圧縮で教師に近い品質を達成できる。

Note

圧縮手法の比較——70Bモデル

手法	サイズ	速度	品質	用途
BF16（ベースライン）	140 GB	1\(\times\)	100%	学習、参照
FP8（E4M3）	70 GB	2\(\times\)	99.5%	H100推論
INT8（SmoothQuant）	70 GB	1.8\(\times\)	99%	A100推論
4-bit（AWQ）	35 GB	2.5\(\times\)	97〜98%	大規模サービング
2-bit（AQLM）	17.5 GB	3\(\times\)	90〜93%	エッジ、実験
50%刈り込み（2:4）	70 GB	1.8\(\times\)	97%	構造化高速化
蒸留8B	16 GB	10\(\times\)	80〜85%	モバイル、エッジ

投機的デコーディング手法

投機的デコーディング（Leviathan et al. 2023）は、複数のトークンを同時に予測し、対象モデルの1回の順伝播で検証することで自己回帰生成を高速化する。標準デコーディングと 同一の出力分布 （品質低下なし）を保ちながら、2〜3\(\times\)の高速化を達成する。

基本原理

Important

投機的デコーディングの枠組み

1. 高速な ドラフト機構 が\(k\)個の候補トークン\(\hat{x}_1, \ldots, \hat{x}_k\)を提案する。

2. 大きな 対象モデル が\(k\)個すべてのトークンに対して1回の順伝播を行う（バッチ処理）。

3. 検証 ：\(P_{\text{target}}(\hat{x}_i) \geq r_i \cdot P_{\text{draft}}(\hat{x}_i)\)である間、左から右へトークンを受理する（\(r_i \sim U[0,1]\)）。

4. 位置\(j\)で初めて拒否したら、調整済み分布から\(x_j\)を再サンプリングし、\(\hat{x}_{j+1}, \ldots, \hat{x}_k\)を破棄する。

重要な性質 ：この受理／拒否方式により、最終分布が厳密に\(P_{\text{target}}\)と等しくなることが保証される。

高速化 ：受理率が\(\alpha\)なら、1ステップあたりの期待トークン数は\(\frac{1 - \alpha^{k+1}}{1 - \alpha}\)である。\(\alpha=0.8\)、\(k=5\)では、標準デコーディングの1トークンに対して1ステップあたり3.4トークンが期待される。

手法の比較

現代の推論エンジンがサポートする投機的デコーディング手法。

Medusa：マルチヘッド投機的デコーディング

Important

Medusaの仕組み

MedusaはLLMに\(k\)個の追加「予測ヘッド」を加える（同じバックボーンを共有する）。

• ヘッド0（元のヘッド）：位置\(t+1\)のトークンを予測する（標準的な次トークン予測）

• ヘッド1：位置\(t+2\)のトークンを予測する（1つ飛ばす）

• ヘッド\(i\)：位置\(t+i+1\)のトークンを予測する

• すべてのヘッドを1回の順伝播で並列に実行する

• 木構造の 検証により、複数の候補系列を同時に検証する

学習 ：Medusaヘッドだけをファインチューニングする（バックボーンは凍結）。コストは代表的なデータで\(\sim\)1エポック。

利点 ：別のドラフトモデルが不要で、ヘッドは小さい（各1線形層）。メモリオーバーヘッドは\(<\)1%。

Eagle：特徴レベルのドラフティング

Tip

EagleがMedusaを上回る理由

Medusaのヘッドは各位置を独立に予測するため、自身の過去の予測を条件にできない（\(t+2\)のトークンは\(t+1\)で何が予測されたかを知らない）。Eagleは、対象モデルの隠れ状態上で動作する軽量な自己回帰デコーダによってこれを解決する。

1. 対象モデルの最終層から隠れ状態を抽出する。

2. 小さな（1層の）デコーダへ入力し、過去の隠れ状態を条件として自己回帰的にドラフトトークンを生成する。

3. これにより、Medusaが捉えられないトークン間依存を捉える。

結果：Eagleの受理率は85〜95%で、Medusaの60〜80%を上回る。

N-gram投機的デコーディング

Important

N-gram Lookup法

最も単純な投機的デコーディングであり、追加のモデルも学習も必要としない。

1. プロンプトと過去に生成したテキストのn-gramキャッシュを維持する。

2. 各ステップで、現在のコンテキストの最後の\(n-1\)トークンがキャッシュ済みのn-gramと一致するか確認する。

3. 一致すれば、その続きのトークンをドラフトとして提案する。

4. 通常どおり対象モデルに対して検証する。

適した用途 ：コード生成（反復パターン）、構造化出力（JSON／XML）、要素が繰り返されるプロンプト。 コスト ：実質ゼロ。

vLLMとの統合

from vllm import LLM, SamplingParams

# Standard speculative decoding (separate draft model)
llm = LLM(
    model="meta-llama/Llama-3-70B",
    tensor_parallel_size=4,
    speculative_config={
        "model": "meta-llama/Llama-3-8B",
        "num_speculative_tokens": 5,
    },
)

# N-gram speculation (zero-cost, no draft model needed)
llm = LLM(
    model="meta-llama/Llama-3-70B",
    speculative_config={
        "method": "ngram",
        "num_speculative_tokens": 5,
        "prompt_lookup_max": 4,  # Match up to 4-grams from prompt
    },
)

# EAGLE-style (feature-level draft, high acceptance rate)
llm = LLM(
    model="meta-llama/Meta-Llama-3-8B-Instruct",
    tensor_parallel_size=4,
    speculative_config={
        "model": "yuhuili/EAGLE-LLaMA3-Instruct-8B",
        "num_speculative_tokens": 2,
        "method": "eagle",
        "draft_tensor_parallel_size": 1,
    },
)

# MLP speculator (IBM-style, lightweight head)
llm = LLM(
    model="meta-llama/Meta-Llama-3.1-70B-Instruct",
    tensor_parallel_size=4,
    speculative_config={
        "model": "ibm-ai-platform/llama3-70b-accelerator",
        "draft_tensor_parallel_size": 1,
    },
)

Warning

投機的デコーディングを使わない場面

• 大きなバッチサイズ ：バッチが\(\geq 64\)では、生成はすでに計算効率がよい。投機ではオーバーヘッド（ドラフト生成＋検証）が加わり、効果が得られない。

• 分布が大きく異なる場合 ：ドラフトモデルが対象モデルと大きく異なると、受理率が50%未満に下がり、投機の方が標準デコーディングより遅くなる。

• 短い出力 ：\(<\)20トークンの出力では、投機のセットアップコストが節約分を上回る。

• 経験則 ：投機は、レイテンシが重要な単一ストリーム生成（チャットボット、対話的なコード補完）で最も有効である。

ハルシネーション検出

LLMは流暢だが事実として誤ったテキストを生成することがあり、これは ハルシネーション と呼ばれる（Ji et al. 2023）。この節では、外部検索やマルチエージェント検証を使わず、モデルレベルで検出する基本手法を扱う。

ハルシネーションの種類

Important

ハルシネーションの分類

• 内在的 ：与えられた入力／コンテキストと矛盾する（例えば要約が原文と反対のことを述べる）。

• 外在的 ：入力から検証できず、事実として誤った主張を生成する。

• 忠実性 ：出力が指示や指定された制約から逸脱する。

検出手法（モデルレベル）

モデルレベルで動作する基本的なハルシネーション検出手法。

意味エントロピー

Kuhnら（Kuhn et al. 2023）は、トークンレベルのエントロピーは信頼できないと観察した（言い換えはトークンが異なっても同じ意味を持つ）。そこで複数の応答を生成し、意味的同値性（NLIによる）でクラスタ化し、意味クラスタ上のエントロピーを計算する。

\[ SE = -\sum_{c \in \text{clusters}} P(c) \log P(c) \]

SEが高いとは、モデルが意味的に異なる答えを生成しているということであり、ハルシネーションの強いシグナルとなる。

SelfCheckGPT

Manakulら（Manakul et al. 2023）は、自己一貫性を確認してハルシネーションを検出する。複数の応答を生成し、主応答の主張が別の応答によって支持されるか検証する。モデルが「自分自身と意見が食い違う」なら、その主張はハルシネーションである可能性が高い。外部知識は不要である。

DoLA（層の対照によるデコーディング）

Chuangら（Chuang et al. 2024）は、事実知識がTransformerの後段の層に現れる一方、前段の層にはより一般的で不確かな表現が残ると観察した。DoLAは各デコーディングステップで、後段の「成熟した」層と前段の「未成熟な」層のロジット分布を対照する。

\[ \text{DoLA}(x_t) = \text{softmax}!\bigl(\log P_{\text{late}}(x_t) - \log P_{\text{early}}(x_t)\bigr) \]

DoLAは深い層に符号化された事実知識の信号を増幅することで、再学習なしに推論時のハルシネーションを減らす。必要なのは対照する層を通る追加の順伝播1回だけである。サンプリングベースの手法を補完し、それらと組み合わせられる。

Warning

モデルレベル検出の限界

これらの手法が検出するのは不確実性であって、誤りではない。モデルは確信を持って誤ることがある（エントロピーが低く、応答も一貫しているが、事実として誤っている）。信頼できる検出には、検索ベースの検証（RAG）や外部ファクトチェックツールを組み合わせる。

LLMの安全性と責任あるAI

安全性は後付けではなく、LLM学習パイプラインの不可欠な一部である。この節では、LLMの安全性に関する主要な側面と、責任ある振る舞いを実施する仕組みを扱う。

脅威の分類

LLMの安全性に関する脅威のカテゴリ。

安全性学習パイプライン

主な安全性メカニズム

Important

安全性の技法

• データフィルタリング ：事前学習コーパスから、毒性、バイアス、PIIを含むテキストを除去する。

• 安全性SFT ：適切な拒否の例（「その理由ではお手伝いできません……」）で学習する。

• Constitutional AI (Bai et al. 2022：原則を使って自己批評し、規則の憲法に照らして自分の出力を修正する。

• 安全性報酬モデル ：安全性の注釈付きペアで別のRMを学習し、RLHF中に有用性RMと重み付き和で組み合わせる。

• ガードレール ：サービング時に有害な要求や応答を遮断する入力／出力分類器。

• レッドチーミング (Perez et al. 2022：展開前に失敗モードを見つける体系的な敵対的評価。

有用性と安全性のトレードオフ

Tip

有用性と安全性のバランス

安全性を過度に最適化すると、過剰拒否の問題が生じる。モデルが無害な要求を拒否してしまうためである（例えば教育的な文脈で歴史上の暴力について議論することを拒否する）。目標は、安全性の制約内で最大限に有用なパレート最適方策である。 \[ \max_\theta ; \mathbb{E}[R_\text{helpful}] \quad \text{subject to} \quad \mathbb{E}[R_\text{safety}] \geq \tau \] 実際には、\(R = \alpha R_\text{helpful} + (1-\alpha) R_\text{safety}\)という重み付き報酬として実装し、\(\alpha\)（通常0.6〜0.8）を慎重に調整する。MetaのLlama-3は、マージンベースの重み付けを用いて安全性と有用性に別々の報酬モデルを使うと報告している（Grattafiori et al. 2024）。

評価

• 安全性ベンチマーク ：ToxiGen、RealToxicityPrompts、BBQ（バイアス）、CrowS-Pairs

• ジェイルブレイクへの頑健性 ：GCG攻撃（Zou et al. 2023）、マルチターンのジェイルブレイク、エンコードされたプロンプト

• 過剰拒否率 ：無害なプロンプトに対する誤検知の拒否を測定する（目標\(<\)5%）。

• レッドチーム評価 ：領域専門家（バイオセキュリティ、サイバーセキュリティ）による人手の敵対的テスト

Warning

安全性に終わりはない

どのような技法の組み合わせでも絶対的な安全性は得られない。新しい攻撃経路は継続的に発見される（マルチモーダルなジェイルブレイク、安全性学習を除去するファインチューニング攻撃、多数ショットプロンプティングなど）。安全性には継続的な監視、新たな脅威への迅速な対応、多層防御（複数の独立した層）が必要である。

1. https://github.com/noamgat/lm-format-enforcer ↩

2. https://github.com/guidance-ai/guidance ↩

LLMシステムの基礎

GPUアーキテクチャ — シリコンからLLM学習まで

現代の大規模言語モデルは、ほぼ例外なくGPU（Graphics Processing Unit、画像処理装置）上で学習・提供されます。GPUアーキテクチャを理解することは、並列化戦略、メモリ管理、カーネル最適化、インフラ規模のサイジングについて、情報に基づく判断を行うために不可欠です。ここでは、LLMワークロードに関係するGPUハードウェアを包括的に紹介します。

なぜ深層学習にGPUを使うのか？

GPUとCPUは、根本的に異なるハードウェア設計思想を持っています。この違いを理解すると、LLMの学習がGPU上では100〜1000\(\times\)高速になる理由が分かります。

Tip

CPUとGPU — 根本的な設計思想

• CPU はレイテンシ向けに最適化されています。大容量キャッシュ、分岐予測、アウト・オブ・オーダー実行を備え、少数のスレッドを可能な限り高速に実行します。現代のCPUは8〜96コアです。

• GPU はスループット向けに最適化されています。それぞれが単純な処理を行う数千のスレッドを並列に実行します。現代のGPUには数千の「コア」（実行ユニット）があり、ストリーミング・マルチプロセッサ（SM）にグループ化されています。

深層学習のワークロードは、行列乗算（\(O(n^3)\)の演算を\(O(n^2)\)のデータに対して行う）に支配されます。行列乗算は非常に並列化しやすい処理です。70BモデルのTransformerの1回のフォワードパスは、トークンあたり約\(\sim\)140 TFLOPの計算を必要とするため、GPUのスループットに最適です。

NVIDIA GPUマイクロアーキテクチャの世代

NVIDIAはGPUアーキテクチャを継続的にリリースしており、それぞれが深層学習に重要な革新をもたらしています。

深層学習向けNVIDIA GPUマイクロアーキテクチャのタイムライン。

LLMの学習と推論に使われる主なGPU

Warning

どのGPUを選ぶべきか？

• 70B以上のモデルを学習する場合 ：NVLinkを備えたH100/B200ノード（テンソル並列化には高速なインターコネクトが必要）。1インスタンスあたり最低8\(\times\)H100。

• 推論（レイテンシ重視） ：高帯域幅が必要ならH100/H200、メモリ帯域律速（巨大なKVキャッシュ）ならMI300X。

• 7B〜13Bのファインチューニング ：A100-80GBが費用対効果に優れています。LoRAなら単一GPUで可能です。

• 低予算 ：A100-40GB、あるいは7BモデルのLoRAならA10（24GB）でも可能です。

GPU内部アーキテクチャ — ストリーミング・マルチプロセッサ（SM）

GPUは ストリーミング・マルチプロセッサ（SM） の配列として構成されます。各SMは、専用のレジスタファイル、共有メモリ、実行ユニットを持つ独立したプロセッサです。GPUの性能を理解するには、SMを理解することが重要です。

Important

SMの主要コンポーネント

• CUDAコア ：FP32／INT32演算用のスカラーALU。A100ではSMあたり64個。要素単位の演算、リダクション、行列以外の演算に使われます。

• Tensor Core ：行列積和（MMA）に特化したユニット。各ユニットは1サイクルで\(4{\times}4{\times}4\)の融合積和を実行します。A100ではSMあたり4個で、対応する精度ではCUDAコアの\(16\times\)のスループットを実現します。

• レジスタファイル ：最速の記憶領域（レイテンシ1サイクル）。アクティブな全スレッドで共有されます。L1へのレジスタ・スピルは大幅な低速化を引き起こします。

• 共有メモリ／L1 ：プログラマーが明示的に管理するオンチップSRAM。Flash Attentionの性能の鍵です（タイル全体を共有メモリに収められます）。

• ワープ・スケジューラ ：各SMにはワープ・スケジューラが4個あります（A100）。ワープはロックステップで実行される32スレッドの単位です（SIMTモデル）。スケジューラはワープを切り替えてメモリレイテンシを隠蔽します。

Tip

SIMT実行モデル

GPUはSingle Instruction, Multiple Threads（SIMT）実行を使います。ワープ（32スレッド）の内部では、全スレッドが同じ命令を異なるデータに対して実行します。スレッドが分岐すると（例：if/else）、両方の経路が直列化されます。これをワープ分岐と呼びます。そのため、GPUカーネルでは分岐を最小限に抑える必要があります。

LLMワークロードの主要な演算（GEMM、アテンション、softmax）はスレッド間で制御フローが均一であり、SIMT実行に適しています。

世代をまたぐGPUチップのスケーリング

NVIDIA GPUアーキテクチャの進化では、計算密度、オンチップメモリ、深層学習用の専用ユニットが一貫して拡大してきました。

NVIDIAアーキテクチャにおけるSMレベルのスケーリング。

GPUメモリ階層と帯域幅

現代のGPUにおける学習・推論性能は、メモリ階層をまたぐデータ移動をどれだけうまく管理できるかによって、ほぼ完全に決まります。メモリ階層を理解することは任意ではありません。後の各最適化手法の基盤です。

Important

GPUメモリ階層 — A100 80GBの基準値

レベル	容量	帯域幅	レイテンシ	場所
レジスタ	\(\sim\)256 KB／SM	\(>\)100 TB/s	1サイクル	オンチップ、スレッド単位
SRAM（共有）	164 KB／SM	\(\sim\)19 TB/s	\(\sim\)20サイクル	オンチップ、SM単位
L2キャッシュ	合計40 MB	\(\sim\)5 TB/s	\(\sim\)200サイクル	オンチップ、共有
HBM2e（VRAM）	80 GB	2 TB/s	\(\sim\)200 ns	パッケージ上（5スタック）
CPU DRAM	512 GB以上	\(\sim\)25 GB/s	\(\sim\)10 \(\mu\)s	ホスト（PCIe 4）
NVMe SSD	TB単位	7 GB/s	\(\sim\)100 \(\mu\)s	ホストストレージ

Tip

なぜ差がこれほど大きいのか

階層の各レベルは、その1つ上のレベルに比べておおむね 10\(\times\)遅く、100〜1000\(\times\)大きい ものです。A100はBF16 Tensor Coreで312 TFLOP/sのスループットを持ちますが、HBM帯域幅は2 TB/sしかありません。つまり、HBMからロードした1バイトごとに、次のバイトが到着するまでに\(312 \times 10^{12} / (2 \times 10^{12}) \approx 156\)回の浮動小数点演算を実行できます。カーネルが1バイトあたり156 FLOP未満しか実行しない場合、そのカーネルはメモリ律速です。計算ユニットはデータを待ってアイドル状態になります。

レジスタ

各CUDAスレッドはプライベートなレジスタファイルを利用できます。レジスタはチップ上で最速の記憶領域です。調停なしに1クロックサイクルで読み書きできます。A100にはSMあたり65,536個の32ビットレジスタがあります。レジスタをローカルメモリ（L1／L2）へスピルさせることは、大きな性能上の危険要因です。

SRAM — 共有メモリ／L1

各SMには、A100で192 KB（H100では256 KB）のL1／共有メモリ統合プールがあり、A100では最大164 KBを共有メモリとして構成できます。共有メモリはプログラマー（または新しいCUDAバージョンのコンパイラー）が明示的に管理します。たとえばFlash Attentionは、アテンションのタイル計算をSRAMに収められるという洞察を中心に構築されています。

L2キャッシュ

A100の40 MBのL2は、108個すべてのSMで共有されます。SRAMとHBMの間のステージング領域として機能します。空間的局所性が高いワークロード（たとえばバッチ内で重み行列に繰り返しアクセスする場合）では、L2のヒット率が実効的なHBMトラフィックを大幅に削減します。

HBM — High Bandwidth Memory

HBMはGPUパッケージに直接搭載された積層DRAMで、広いインターポーザーを介して接続されています。A100 SXMは、2 TB/sで80 GBのHBM2eを備えています。H100 SXM5は、3.35 TB/sで80 GBのHBM3を備えています。これは、モデルの重み、KVキャッシュ、アクティベーション、オプティマイザー状態の主要な作業メモリです。

PCIe経由のCPU DRAM

GPUのHBMとCPUのDRAM間のデータ転送は、PCIeバスを通過します。PCIe Gen4 \(\times\)16は、方向あたり約\(\sim\)32 GB/s（双方向で64 GB/s）を提供し、Gen5ではその倍になります。これはHBM（片方向）と比べて約\(\sim\)60\(\times\)帯域幅が小さい値です。CPUオフロード（ZeRO-Infinity、DeepSpeed）はこのリンクを利用しますが、ボトルネックにならないよう注意して使う必要があります。

NVMe

NVMe SSD（Samsung 990 Proなど）は、シーケンシャル読み出しで約\(\sim\)7 GB/sに達します。ZeRO-Infinityはオプティマイザー状態をNVMeへオフロードできますが、これは計算とI/Oの比率が非常に高い場合（大きなバッチサイズ、遅い学習ステップ）に限って実用的です。

算術強度とRooflineモデル

Important

算術強度

\[ I = \frac{\text{FLOPs}}{\text{Bytes accessed from HBM}} \quad \text{(FLOPs / Byte)} \] カーネルは、\(I < I_{\text{ridge}}\)のとき メモリ律速 、\(I > I_{\text{ridge}}\)のとき 計算律速 です。ここで \[ I_{\text{ridge}} = \frac{\text{Peak FLOP/s}}{\text{Peak Bandwidth}} = \frac{312 \times 10^{12}}{2 \times 10^{12}} = 156 \text{ FLOP/Byte (A100 BF16)} \]

Note

アテンションの算術強度

シーケンス長\(n=4096\)、ヘッド次元\(d=128\)の単一アテンションヘッドを考えます。

FLOP ：\(QK^T\)には\(2n^2d\)、softmaxには\(O(n^2)\)、\(\text{Attn} \times V\)には\(2n^2d\)のコストがかかります。合計は\(\approx 4n^2 d = 4 \times 4096^2 \times 128 \approx 8.6\) GFLOPです。

メモリトラフィック （標準的な非Flash実装）：

• \(Q, K\)を読み出す：\(2 \times n \times d \times 2 = 2\) MB

• アテンションスコア\(S = QK^T\)を書き出す：\(n^2 \times 2 = 33.5\) MB

• softmaxのために\(S\)を読み出す：\(n^2 \times 2 = 33.5\) MB

• softmax出力\(P\)を書き出す：\(n^2 \times 2 = 33.5\) MB

• 最終行列乗算のために\(P\)と\(V\)を読み出す：\(n^2 \times 2 + n \times d \times 2 = 34.5\) MB

• 出力\(O\)を書き出す：\(n \times d \times 2 = 1\) MB

総メモリ量 ：\(\approx 138\) MB（\(n^2\)のアテンション行列を4回走査することが支配的です）。

算術強度 ： \[ I = \frac{8.6 \times 10^9}{138 \times 10^6} \approx 62 \text{ FLOP/Byte} \]

これはA100のリッジポイントの\(62/156 = 40%\)であり、 明確にメモリ律速 です。GPUはメモリを待って60%の時間アイドルになります。

Flash Attentionによる解決 ：\(n \times n\)行列を実体化せず（\(Q, K, V\)をSRAMでタイル化する）、Flash AttentionはHBMトラフィックを\(Q, K, V\)の読み出しと\(O\)の書き出しだけに削減します：\(4 \times n \times d \times 2 = 4\) MB。ロードした各バイトは\(O(n)\)回の計算で再利用されます（各クエリがすべてのキーにアテンションするため）。したがって、 \[ I = \frac{4n^2 d}{4 \cdot n \cdot d \cdot 2} = \frac{n}{2} = \frac{4096}{2} = 2048 \text{ FLOP/Byte} \]

これはリッジポイント（156）の\(13\times\)上であり、 深く計算律速 です。GPUはピークの312 TFLOPSに達し、必要な帯域幅は\(312\text{T}/2048 \approx 152\) GB/s（HBM容量の7.6%）にすぎません。もはやメモリはボトルネックではありません。

アテンションはメモリ律速、FFNは計算律速

Tip

Transformerにおける2つの領域

Transformerブロックには、算術強度が大きく異なる2つの主要コンポーネントがあります。

• アテンション ：\(n \times d\)テンソルを処理します。\(QK^T\)積は\(O(n^2 d)\) FLOPを必要としますが、アテンションスコアのために\(O(n^2)\)のメモリを必要とします。長いシーケンスではメモリトラフィックが支配的になり、アテンションはメモリ律速です。

• FFN（MLP） ：形状\([d_{\text{model}}, 4d_{\text{model}}]\)の重み行列を持つ2つの大規模線形層です。これらは算術強度の高い大規模GEMMであり、FFNは計算律速です。

そのため、Flash Attention（メモリ最適化）はアテンションには有効ですがFFNには効きにくく、量子化（重みサイズの削減）はアテンションよりFFNに大きな効果があります。

Tensor Core

Important

Tensor Coreとは何か？

Tensor Coreは、Volta（2017年）で導入された行列積和（MMA）専用ユニットです。各Tensor Coreは、1クロックサイクルで\(4\times4\times4\)の行列乗算を実行します。 \[ D = A \times B + C \quad (4\times4 \text{ matrices}) \] A100には、108個のSM全体で 432個のTensor Core があります（SMあたり4個、各サブパーティションに1個）。BF16精度では312 TFLOP/sを実現し、FP32 CUDAコアのスループットの約\(16\times\)です。

• 対応精度 ：FP64、TF32、BF16、FP16、INT8、FP8（H100以降）。

• 累積 ：BF16入力であっても、内部では常にFP32で累積します。これにより、ドット積での壊滅的な桁落ちを防ぎます。

• 要件 ：Tensor Coreは、行列の次元が8（BF16）または16（FP8）の倍数のときに最も効率的です。こうした倍数に合わせたパディングは、しばしば実施する価値があります。

• WGMMA（H100） ：Hopperでは、より大きなタイル（64\(\times\)256\(\times\)16）を処理するワープグループ単位のMMA命令が導入され、TMA（Tensor Memory Accelerator）によるデータ移動とパイプライン化できます。

Warning

Tensor Coreの落とし穴

Tensor Coreが役立つのは、カーネルが計算律速の場合だけです。小さなバッチ（バッチサイズ1の推論など）ではGEMMのタイルが小さく、Tensor Coreの利用率が低くなり、再びメモリ律速の領域に戻ります。そのため推論エンジンはリクエストを積極的にバッチ化します。

通信アーキテクチャ — NVLink、InfiniBand、PCIe

分散LLMの学習と推論では、GPU、ノード、ストレージ間で膨大なデータを移動する必要があります。大規模学習では、この通信ファブリックがボトルネックになることがよくあります。

PCIe — ホストとデバイスを結ぶリンク

Important

PCIeの世代

世代	x16帯域幅（各方向）	双方向	注記
PCIe Gen3	16 GB/s	32 GB/s	古いサーバーで一般的
PCIe Gen4	32 GB/s	64 GB/s	A100 PCIe、現在の大半のサーバー
PCIe Gen5	64 GB/s	128 GB/s	H100 PCIe、普及途上

PCIeは次の用途に使われます。

• CPU \(\leftrightarrow\) GPU間のデータ転送（モデルの読み込み、CPUオフロード）

• NVLinkが利用できない場合のノード間GPU通信（まれで非常に低速）

• NVMeストレージへのアクセス（CPU経由）

Warning

PCIeはGPU間通信向けではない

NVLinkが利用できる場合は、GPU間通信をPCIe経由にしてはいけません。PCIeの帯域幅（32 GB/s）はNVLink 4（900 GB/s）より28\(\times\)低速です。NVLinkのないマルチGPUサーバー（一般向けGPUなど）ではGPU間帯域幅がPCIeに制限されるため、テンソル並列化は極めて遅くなります。

NVLink — ノード内高速インターコネクト

Important

NVLinkの世代

世代	リンク数	総帯域幅	GPU
NVLink 2	6	300 GB/s	V100
NVLink 3	12	600 GB/s	A100
NVLink 4	18	900 GB/s	H100
NVLink 5	18	1800 GB/s	B200 (Blackwell)

NVLinkは同じノード上のGPU間を結ぶポイント・ツー・ポイントのインターコネクトです。各リンクは双方向です。H100 SXM5にはNVLink 4のリンクが18本あり、1本あたり双方向で50 GB/s、合計900 GB/sを提供します。

NVSwitch

DGX H100システムでは、8枚すべてのGPUがNVSwitchを介して接続されます。NVSwitchは完全二分帯域幅を提供する専用スイッチングチップです。これにより、リング内の隣接GPUだけでなく、任意のGPUが他の任意のGPUと、同時にNVLinkの最大速度で通信できます。

Tip

リングと完全二分帯域幅

リングトポロジ（8 GPU）では、AllReduceのデータはリングを一周する必要があります。各リンクは総データ量の\(\frac{2(N-1)}{N}\)を運ぶため、アルゴリズム上の帯域幅は\(B_{\text{link}} \times \frac{N}{2(N-1)}\)（\(N=8\)では約\(0.57 \times B_{\text{link}}\)）です。NVSwitchの完全二分帯域幅では、AllReduceがツリーベースのアルゴリズムで全リンクを同時に利用でき、ピークに近い帯域幅を達成します。実際のDGX H100では、リングは約\(\sim\)700 GB/sのバス帯域幅、NVSwitchは約\(\sim\)900 GB/sを実現します。

InfiniBand — ノード間通信

ノード（サーバー）間の通信には、InfiniBandがGPUメモリへのダイレクトアクセスを備えた、高帯域幅・低レイテンシのネットワークを提供します。

Important

InfiniBand NDR

• NDR 400Gb/s = ポートあたり50 GB/s（単方向）

• HDR 200Gb/s = ポートあたり25 GB/s（前世代）

• RDMA ：Remote Direct Memory Access（リモート・ダイレクト・メモリアクセス）。GPUはリモートCPUを介さずに、リモートGPUのメモリを読み書きできます。

• GPUDirect RDMA ：データはCPUとシステムDRAMを完全にバイパスし、HBM \(\to\) NIC \(\to\) ネットワーク \(\to\) NIC \(\to\) HBMへ直接流れます。

• レイテンシ ：小さなメッセージでは約\(\sim\)1〜2 \(\mu\)s（TCP/IPでは約\(\sim\)100 \(\mu\)s）。

Fat-Treeトポロジ

大規模GPUクラスターではFat-Treeネットワークトポロジが使われます。\(k\)ポートのスイッチを使う3層Fat-Treeは、完全二分帯域幅で\(k^3/4\)ノードをサポートします。\(k=64\)ポートの400Gb/s NDRスイッチでは、\(64^3/4 = 65{,}536\)ノードです。

レール最適化トポロジ

実際のクラスターでは、各ノード内の各GPUを異なるトップ・オブ・ラックスイッチに接続するレール最適化トポロジが使われます。これにより、すべてのGPUが関係するAllReduce操作で、すべてのネットワークリンクを同時に使い、帯域幅を最大化できます。

分散LLM学習における通信パターン

分散学習は、集合通信プリミティブに依存します。どのプリミティブを選ぶかによって、必要な帯域幅とスケーリングの挙動が決まります。

Important

通信プリミティブ

プリミティブ	用途	通信量
AllReduce	勾配同期（DDP、FSDP）	\(2(N-1)/N \times\)パラメータサイズ
AllGather	シャード化された重みを収集（FSDP）	\((N-1)/N \times\)パラメータサイズ
ReduceScatter	勾配を分散（FSDP）	\((N-1)/N \times\)パラメータサイズ
AllGather	テンソル並列化のアクティベーション	アクティベーションサイズ
Point-to-Point	パイプライン並列化（send／recv）	マイクロバッチのアクティベーション
Broadcast	重みの同期（新しいワーカー）	モデル全体のサイズ

Note

帯域幅の計算 — 70Bモデルの勾配AllReduce

設定 ：70Bパラメータモデル、BF16勾配、8ノード\(\times\)8 GPU = 64 GPU。データ並列度 = 64。

勾配サイズ ：\(70 \times 10^9 \times 2\)バイト\(= 140\) GB。

GPUあたりのAllReduce通信量 （リング）：\(2 \times (64-1)/64 \times 140 \approx 275\) GB。

利用可能なノード間帯域幅 ：ノードあたり8 GPU\(\times\) GPUあたり50 GB/s \(= 400\) GB/s（レール最適化トポロジで8個すべてのNICがアクティブ）。

AllReduce時間 ：\(275 / 400 \approx 0.69\)秒／ステップ。

意味 ：計算ステップが1秒の場合、通信によって0.69秒（ステップ時間全体の41%）が追加されます。これが、勾配圧縮、混合精度、FSDP（通信と計算をオーバーラップさせる）が重要な理由です。

ネットワークトポロジ図

次の図は、ノード内（NVLink）とノード間（InfiniBand）の通信経路を示す、典型的な2ノードGPUクラスターのトポロジを表しています。

Tip

帯域幅に基づく並列化の選択

• テンソル並列化（TP） ：各層でAllReduceが必要です。ノード内でNVLinkを使う場合に限って使用します。TP=8はH100 DGXノードで標準的です。

• パイプライン並列化（PP） ：ステージ間のポイント・ツー・ポイント通信です。ノードをまたげますが、パイプライン・バブルのオーバーヘッドが追加されます。TPだけではモデルを収められない場合に使います。

• データ並列化（DP） ：勾配のAllReduceです。IB経由でノードをまたげます。高速なIBがあれば適切にスケールします。

• FSDP／ZeRO ：AllGather＋ReduceScatterです。DPと似ていますが、オプティマイザー状態をシャード化します。大規模モデルではDPより推奨されます。

vLLM — PagedAttentionと高スループット推論

vLLM (Kwon et al. 2023)は、PagedAttentionを導入しました。これは、オペレーティングシステムがRAMに使うページング抽象化を借用し、GPUのKVキャッシュに適用したものです。LLM推論では、過去のすべてのトークンのキー・テンソルとバリュー・テンソルを保存するKVキャッシュが、メモリ消費の大部分を占めます。これを効率的に管理することが、高スループット推論の中心的な課題です。

KVキャッシュの断片化問題

Important

KVキャッシュのメモリ公式

\(L\)層、\(H\)ヘッド、ヘッド次元\(d\)、\(n\)トークンのシーケンスを持つモデルの場合： \[ \text{KV cache size} = 2 \times L \times H \times d \times n \times \text{bytes_per_element} \] Llama-3 70B（BF16）の場合：\(L=80\)、\(H=8\)（GQA）、\(d=128\)： \[ = 2 \times 80 \times 8 \times 128 \times n \times 2 = 327{,}680 \times n \text{ bytes} \] \(n=4096\)トークンの場合：シーケンスあたり\(\approx 1.3\) GB。

Tip

内部断片化と外部断片化

従来の推論システムは、各シーケンスのKVキャッシュ用に、最大シーケンス長に合わせた連続メモリ領域をあらかじめ確保します。これにより、2種類の無駄が生じます。

内部断片化 ：500トークンしか生成しないシーケンスでも、4096トークン用に予約された領域を保持します。未使用の3596トークン分が無駄になります。

外部断片化 ：多数のシーケンスが完了すると、空きメモリは小さく不連続な隙間に分かれます。空き容量の合計が十分でも、単一の連続領域が十分に大きくないため、新しい長いシーケンスを割り当てられません。

実際には、単純な割り当てでのGPUメモリ利用率は20〜40%にすぎないことがよくあります。

PagedAttention — KVキャッシュの仮想メモリ

PagedAttention（Kwon et al., 2023）は、オペレーティングシステムのページング抽象化を借用します。シーケンスごとに1つの連続領域を持つ代わりに、KVキャッシュを固定サイズの ページ （ブロック）に分割します。そしてCPUのページテーブルに相当する間接参照テーブルが、各シーケンスの論理的なトークン位置を、GPUメモリ上に分散した物理アドレスへ変換します。

Important

PagedAttentionの中核概念

• ブロックサイズ ：通常は1ブロックあたり16トークン（調整可能）。各ブロックには\(16 \times 2 \times L \times H \times d\)個の要素が格納されます。

• ブロックテーブル ：シーケンスごとに、論理ブロックのインデックスをGPUメモリプール内の物理ブロックのインデックスへ対応付けます。

• 物理ブロックプール ：固定サイズのブロックを事前に確保したプール。割り当ては\(O(1)\)で、空きリストから取り出すだけです。

• アテンションカーネル ：アテンション計算中にブロックテーブルを使い、不連続な物理位置からKVブロックを収集するよう変更されています。

Note

ブロックテーブルの例

ブロックサイズを4トークンとし、2つのシーケンスがあるとします。

• シーケンスA（7トークン）：論理ブロック [0,1] \(\to\) 物理ブロック [3, 7]

• シーケンスB（5トークン）：論理ブロック [0,1] \(\to\) 物理ブロック [1, 5]

物理ブロック3にはシーケンスAのトークン0〜3が格納されます。物理ブロック7にはシーケンスAのトークン4〜6が格納されます（部分的に使用）。シーケンスAのアテンションカーネルは、間接参照層としてブロックテーブルを使い、物理ブロック3、7の順に読み出します。

PagedAttentionの利点

ほぼゼロの無駄

内部断片化は、シーケンスごとに最大でも部分的に埋まった最後のブロック1つ分に抑えられます。ブロックサイズが16なら、最悪の場合の無駄はシーケンスあたり15トークンであり、無視できます。ブロックは固定サイズで交換可能なので、外部断片化はなくなります。

動的割り当て

ブロックはシーケンスの成長に応じてオンデマンドで割り当てられます。最終的なシーケンス長を事前に知る必要はありません。出力長が未知である生成処理では、これは非常に重要です。

プレフィックス共有（コピーオンライト）

共通のプレフィックス（システムプロンプトなど）を持つ複数のシーケンスは、そのプレフィックスに対して 同じ物理ブロック を共有できます。ブロックテーブルは、複数のシーケンスを同じ物理ブロックへ指し示すだけです。シーケンスが共有ブロックへの書き込みを必要とするとき（プレフィックスから分岐するとき）、コピーオンライトが発生します。

Tip

プレフィックス共有による節約

1000トークンのシステムプロンプトを128人の同時ユーザーに提供するチャットボットを考えます。

• プレフィックス共有なし：システムプロンプトのKVキャッシュだけで\(128 \times 1000 \times 327{,}680 / 10^9 \approx 42\) GB

• プレフィックス共有あり：\(1 \times 1000 \times 327{,}680 / 10^9 \approx 0.33\) GB

• 節約量：共有プレフィックス部分で約\(\sim\)128\(\times\)

スワップによるプリエンプション

GPUメモリが枯渇すると、vLLMはKVブロックをCPU DRAMへスワップすることで、シーケンスをプリエンプトできます（またはブロックを単純に破棄し、後で再計算できます）。ブロックが自己完結していて不連続であるからこそ可能な方法です。連続領域の割り当てをスワップするには、バッファ全体をコピーしなければなりません。

継続的バッチ処理

従来のバッチ処理（「静的バッチ処理」）は、すべてのシーケンスが完了するまで新しいシーケンスを開始しません。あるシーケンスが500トークン、別のシーケンスが10トークンを生成する場合、短いシーケンスについてGPUは490ステップの間アイドルになります。これは非常に非効率です。

Important

継続的バッチ処理

継続的バッチ処理（イテレーションレベル・スケジューリングとも呼ばれます）は、一度に1つのデコードステップを処理します。各ステップの後に次を行います。

1. 生成されたEOSトークンを確認し、完了したシーケンスを調べる

2. 完了したシーケンスをバッチから削除し、KVブロックを解放する

3. 待機中の新しいシーケンスを追加し、空いたスロットを埋める

4. 更新されたバッチで次のデコードステップを実行する

バッチの構成は各ステップで変わり、シーケンスが動的に参加・離脱します。これによりGPU利用率をほぼ100%に保ち、スループットを大幅に改善できます（静的バッチ処理に比べて1.5〜3\(\times\)）。ここではPagedAttentionが不可欠です。バッチ途中でのシーケンス追加・削除にはKVブロックの動的な割り当て・解放が必要であり、ページ化メモリでのみ効率的に実行できるからです。

vLLMにおける投機的デコーディング

投機的デコーディングは、小さなドラフトモデル（例：1Bパラメータ）を使って\(k\)個の候補トークンを素早く提案し、大きなターゲットモデルが1回のフォワードパスで検証します。最初に拒否されるまでのすべてのトークンが受理されます（検証ステップあたりの期待受理数は3〜5トークン）。これにより、品質を損なわず、レイテンシ重視の単一シーケンス生成を2〜3\(\times\)高速化できます。

vLLMは投機的デコーディングをPagedAttentionと統合しています。

• ドラフトトークンには投機的KVブロックが割り当てられる

• 拒否された場合、投機的ブロックは解放される（ページ化割り当てなら低コスト）

• 受理された場合、投機的ブロックはメインシーケンスへ昇格される

• ブロックテーブルの更新は\(O(k)\)で、数個のテーブルエントリを更新するだけ

大規模環境での具体的なメモリ節約 — 70Bモデル

Note

メモリ予算 — 70B BF16推論

設定 ：Llama-3 70B、BF16、単一のA100 80GBノード（8 GPU、テンソル並列化）。

モデルの重み ：\(70 \times 10^9 \times 2\)バイト\(= 140\) GB \(\div\) 8 GPU \(= 17.5\) GB／GPU。

KVキャッシュ用の残り ：\(80 - 17.5 - 3\)（オーバーヘッド）\(= 59.5\) GB／GPU。

GPUあたりのトークンごとのKVキャッシュ （TP=8で、各GPUはヘッドの\(1/8\)を保持）：\(2 \times 80 \times 1 \times 128 \times 2 = 40{,}960\)バイト\(\approx 40\) KB／トークン。

KVキャッシュ内の最大トークン数 ：\(59.5 \times 10^9 / 40{,}960 \approx 1.45\)百万トークン。

4096トークンのシーケンスを128本同時実行する場合 ：\(128 \times 4096 = 524{,}288\)トークンで、予算内に十分収まります。

PagedAttentionなし （各シーケンスに最大長4096を事前割り当て）：計算は同じですが、平均で約\(\sim\)50%が断片化によって無駄になります \(\to\) 収容できるのは64シーケンスだけです。

Warning

ブロックサイズのトレードオフ

ブロックサイズを大きくすると、ブロックテーブルのオーバーヘッドが減り、メモリアクセスの局所性が改善します（分散した読み出しが減ります）。一方、ブロックサイズを小さくすると、内部断片化が減り、より細粒度のプレフィックス共有が可能になります。vLLMのデフォルトは16トークン／ブロックで、バランスのよい設定です。非常に長いシーケンス（10万トークン以上）では、より大きなブロック（32〜64）が適している場合があります。

vLLM：エンドツーエンドシステム

vLLMは、PagedAttentionを完全なサービングスタックの内部に組み込みます。継続的バッチ処理、プレフィックスキャッシュ、投機的デコーディング、テンソル並列モデルのシャーディングが連携し、GPU 1ドルあたりのスループットを最大化します。

アーキテクチャの概要

中核コンポーネント

• API Server ：OpenAI互換のリクエスト（completion、chat）を受け付けます。入力をトークン化し、ビームサーチや複数サンプルのための「シーケンスグループ」を作成します。

• Scheduler ：vLLMの司令塔です。次の3つのキューを管理します。

  • waiting：まだ開始されていない新しいリクエスト（プリフィル待ち）

  • running：トークンをアクティブに生成しているリクエスト（デコード段階）

  • swapped：KVキャッシュがCPUへオフロードされたプリエンプト済みリクエスト

  各イテレーションで、Schedulerは利用可能なGPUメモリブロックに基づき、どのリクエストを実行するか決定します。

• Block Manager ：KVキャッシュの仮想メモリ抽象化を実装します。論理ブロック（シーケンスごと）を物理ブロック（GPUメモリプール内）へ対応付けます。次を処理します。

  • 割り当て（新しいトークンが生成される \(\rightarrow\) 新しいブロックが必要）

  • コピーオンライト（ビームサーチ用：複数のビームがプレフィックスブロックを共有し、分岐時だけコピー）

  • スワップ（プリエンプト／再開時のGPU \(\leftrightarrow\) CPU移行）

  • プレフィックスキャッシュ（プロンプトが共通プレフィックスを持つとき、キャッシュ済みブロックを再利用）

• Model Executor ：実際のLLMフォワードパスを実行します。GPU間のテンソル並列化を管理し、ページ化KVキャッシュブロックを読み取るアテンションカーネルをディスパッチします。

• KV Cache Pool ：固定サイズのブロックに分割された事前割り当てGPUメモリ（デフォルト：16トークン \(\times\) num_heads \(\times\) head_dim \(\times\) 2バイト／ブロック）。実行時に動的割り当てを行わない \(\rightarrow\) 断片化はゼロです。

リクエストのライフサイクル（エンドツーエンドの流れ）

1. 到着 ：クライアントがプロンプトを送信します。APIサーバーはトークン化し、SequenceGroupを作成してwaitingキューに入れます。

2. スケジューリング ：各ステップでSchedulerは次を実行します。

   1. swappedのシーケンスを再開できるか確認する（空きブロックが十分か）。

   2. waitingのシーケンスがプリフィルを開始できるか確認する（プロンプト全体に十分なブロックがあるか）。

   3. runningのシーケンスに残りのブロックを割り当てる（現在のブロックが満杯なら、ステップごとにシーケンスあたり1つの新しいブロックが必要）。

   4. 予算を超える場合、優先度の低いrunningのシーケンスをプリエンプトする（KVをCPUへスワップするか、後で再計算する）。

3. プリフィル （リクエストの最初のイテレーション）：プロンプト全体を1回のフォワードパスで処理します。すべてのプロンプトトークンのKVキャッシュを計算し、割り当てられたブロックに格納します。これは計算律速です（大量のトークンをまとめて処理するため）。

4. デコード （後続のイテレーション）：各シーケンスについて、ステップごとに新しいトークンを1つ生成します。実行中の全シーケンスをまとめてバッチ化します（継続的バッチ処理）。これはメモリ律速です（KVキャッシュ全体を読み出し、1トークンを生成するため）。

5. ブロック割り当て ：各デコードステップの後、シーケンスの最後のブロックが満杯なら、Block Managerが新しい物理ブロックを割り当て、次の論理ブロックへ対応付けます。

6. 完了 ：シーケンスがEOSまたは最大長に達すると、runningから削除されます。その物理ブロックは直ちに解放されます \(\rightarrow\) 他のシーケンスが利用できるようになります。レスポンスはクライアントへストリーミングされます。

プレフィックスキャッシュ（自動プロンプトキャッシュ）

複数のリクエストが共通プレフィックス（システムプロンプト、few-shot例など）を持つ場合：

1. 各論理ブロックのトークン内容をハッシュする。

2. 新しいリクエストの到着時に、プレフィックスブロックがすでにキャッシュにあるか確認する。

3. ヒットした場合、そのトークンのプリフィルをスキップし、物理KVブロックを直接再利用する。Time-to-first-tokenは大幅に短縮される。

4. 追い出しにはLRUポリシーを使う。メモリ圧迫が必要になるまで、キャッシュ済みブロックは解放しない。

効果 ：長いシステムプロンプト（全ユーザーで共有される2000トークン以上）を持つチャットアプリケーションでは、プレフィックスキャッシュによってTTFTが60〜80%短縮されます。

vLLMにおけるガイド付き（制約付き）デコーディング

vLLMは、プラグイン可能なバックエンドを通じて制約付きデコーディング（セクション1.12.11）をネイティブにサポートしています。これにより、性能オーバーヘッドを最小限に抑えながら、サービング時に 構造化出力を保証 できます。

サポートされる制約の種類

OpenAI互換APIは、guided_*パラメータまたはresponse_formatフィールドを通じて制約を受け付けます。

from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1")

# --- JSON Schema制約 ---
response = client.chat.completions.create(
    model="meta-llama/Llama-3-70B-Instruct",
    messages=[{"role": "user",
               "content": "Extract: name, age, city from: "
                          "'John is 30 and lives in NYC'"}],
    extra_body={
        "guided_json": {
            "type": "object",
            "properties": {
                "name": {"type": "string"},
                "age": {"type": "integer"},
                "city": {"type": "string"}
            },
            "required": ["name", "age", "city"]
        }
    }
)
# スキーマに適合する有効なJSONが保証される

# --- 正規表現制約 ---
response = client.completions.create(
    model="meta-llama/Llama-3-70B-Instruct",
    prompt="Generate an IPv4 address: ",
    extra_body={
        "guided_regex": r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"
    }
)

# --- 選択肢制約 ---
response = client.completions.create(
    model="meta-llama/Llama-3-70B-Instruct",
    prompt="Sentiment: ",
    extra_body={"guided_choice": ["positive", "negative", "neutral"]}
)

バックエンドアーキテクチャ

vLLMはマスク計算をバックエンドエンジンへ委譲します。

• XGrammar （v0.7以降のデフォルト）：JSONスキーマ、正規表現、任意のEBNF文法をサポートするプッシュダウンオートマトンエンジン。効率的なC++コアにより、複雑なスキーマでは最速です。

• Outlines (Willard and Louf 2023)：FSMベースで、JSONと正規表現をサポートします。XGrammarが利用できない場合のフォールバックとして使われます。

マスクは、モデルのフォワードパスがロジットを生成した後、サンプリングの前に適用されます。FSM／PDAの状態遷移と事前計算済みインデックスのルックアップは\(O(1)\)なので、実際のオーバーヘッドは1ステップあたり\(<\)1 msです。

性能への影響

制約はロジットをマスクするだけで、アテンションやFFNの再計算を行わないため、スループットの低下は無視できます（ベンチマークで\(<\)2%）。主なコストは、スキーマをFSM／PDAインデックスへコンパイルすることです。スキーマの複雑さに応じて0.5〜5秒かかります。vLLMはリクエスト間でコンパイル済みスキーマをキャッシュするため、このコストは一意なスキーマごとに1回だけ発生します。

Warning

構造化出力 $\neq$ 正しい出力

制約付きデコーディングは、出力が構文的に有効であること（JSONとして解析でき、スキーマの型に一致すること）を保証します。しかし、意味的な正しさを保証するものではありません。モデルは、正しく解析できるものの事実としては誤った値を、依然としてハルシネーションする可能性があります。下流で必ずビジネスロジックを検証してください。

vLLMと代替手法の性能比較（70Bモデル、A100 \(\times\) 4、TP=4）。

強化学習への導入

強化学習（Reinforcement Learning、RL）は、 エージェント が 環境 との相互作用を通じて逐次的な意思決定を学び、フィードバックとして 報酬 を受け取り、時間の経過に伴う累積報酬を最大化するように 方策 を最適化する枠組みです (Sutton and Barto 2018)。ラベル付きの入出力ペアを必要とする教師あり学習とは異なり、RLは試行錯誤を通じて最適な振る舞いを発見します。

マルコフ決定過程（MDP）

MDPは5つ組 \((S, A, P, R, \gamma)\) です。

• \(S\)：状態空間 — 環境が取りうるすべての構成

• \(A\)：行動空間 — エージェントが利用できるすべての行動

• \(P(s'\vert s, a)\)：遷移関数 — 行動 \(a\) を取った後に状態 \(s\) から状態 \(s'\) に到達する確率

• \(R(s, a, s')\)：報酬関数 — 遷移に対する即時のスカラー・フィードバック

• \(\gamma \in [0, 1]\)：割引率 — 即時の報酬に対して将来の報酬をどの程度重視するか

マルコフ性 ：未来は履歴ではなく現在の状態だけに依存します。

\[ P(s_{t+1} | s_t, a_t, s_{t-1}, a_{t-1}, \ldots) = P(s_{t+1} | s_t, a_t) \]

これにより、問題を扱いやすくできます。

Tip

エージェントと環境の相互作用ループ

各時刻 \(t\) で次を行います。

1. エージェントが状態 \(s_t\) を観測する

2. エージェントが方策 \(\pi(a\vert s)\) に従って行動 \(a_t\) を選択する

3. 環境が \(s_{t+1} \sim P(\cdot\vert s_t, a_t)\) へ遷移する

4. エージェントが報酬 \(r_t = R(s_t, a_t, s_{t+1})\) を受け取る

5. 終端状態またはホライズン \(T\) に達するまで繰り返す

中核概念と定義

方策（Policy） \(\pi(a\vert s)\)：状態から行動確率への写像。決定論的な場合は \(a = \pi(s)\)、確率論的な場合は \(a \sim \pi(\cdot\vert s)\) です。

リターン（Return） （累積割引報酬）：

\[ G_t = \sum_{k=0}^{\infty} \gamma^k r_{t+k} = r_t + \gamma r_{t+1} + \gamma^2 r_{t+2} + \cdots \]

価値関数（Value Function） （方策 \(\pi\) の下で状態 \(s\) から得られる期待リターン）：

\[ V^\pi(s) = \mathbb{E}_\pi\left[G_t \mid s_t = s\right] = \mathbb{E}_\pi\left[\sum_{k=0}^{\infty} \gamma^k r_{t+k} \mid s_t = s\right] \]

行動価値関数（Action-Value Function） （状態 \(s\) で行動 \(a\) を取り、その後 \(\pi\) に従う場合の期待リターン）：

\[ Q^\pi(s, a) = \mathbb{E}_\pi\left[G_t \mid s_t = s, a_t = a\right] \]

アドバンテージ関数（Advantage Function） （行動 \(a\) が平均と比べてどれだけ優れているか）：

\[ A^\pi(s, a) = Q^\pi(s, a) - V^\pi(s) \]

ベルマン方程式（Bellman Equations） （再帰的な関係）：

\[ \begin{aligned} V^\pi(s) &= \sum_a \pi(a|s) \sum_{s'} P(s'|s,a)\left[R(s,a,s') + \gamma V^\pi(s')\right] \\ Q^\pi(s,a) &= \sum_{s'} P(s'|s,a)\left[R(s,a,s') + \gamma \sum_{a'} \pi(a'|s') Q^\pi(s', a')\right] \end{aligned} \]

Important

最適方策とベルマン最適性

最適方策 \(\pi^*\) は次を満たします。 \[ V^*(s) = \max_a \sum_{s'} P(s'|s,a)\left[R(s,a,s') + \gamma V^*(s')\right] \]

\[ Q^*(s,a) = \sum_{s'} P(s'|s,a)\left[R(s,a,s') + \gamma \max_{a'} Q^*(s', a')\right] \] \(Q^*\) が分かれば、最適方策は単純に \(\pi^*(s) = \arg\max_a Q^*(s,a)\) となります。

RL手法の分類

強化学習アルゴリズムは、いくつかの軸に沿って分類できます。この分類を理解すると、問題に適したアプローチを選びやすくなります。

Important

分類における重要な違い

モデルフリー（Model-Free）とモデルベース（Model-Based） ：

• モデルフリー ：経験から方策または価値関数を直接学ぶ。環境ダイナミクスに関する知識は持たない。LLMでは言語ダイナミクスをモデル化するのが困難なため、最も実用的です。

• モデルベース ：環境の遷移 \(P(s'\vert s,a)\) のモデルを学習または利用する。先の計画を立てられるため、サンプル効率は高い一方、正確なモデルが必要です。

価値ベース（Value-Based）と方策ベース（Policy-Based） ：

• 価値ベース ：\(Q(s,a)\) または \(V(s)\) を学び、\(\arg\max_a Q(s,a)\) として方策を導く。離散的で小さな行動空間（例：Atari）ではうまく機能します。連続的または大規模な行動空間では苦戦します。

• 方策ベース ：\(\pi_\theta(a\vert s)\) を直接パラメータ化して最適化する。連続的または高次元の行動空間に自然に適用できます。LLMには不可欠です（語彙が32K〜128K個の行動に相当するため）。

• アクター・クリティック（Actor-Critic） ：両者を組み合わせる。方策（アクター）が行動を提案し、価値関数（クリティック）が評価します。LLM向けのPPOはアクター・クリティックです。

オンポリシー（On-Policy）とオフポリシー（Off-Policy） ：

• オンポリシー ：現在の方策が生成したデータから学ぶ。更新のたびにデータを再生成する必要があります。例：REINFORCE、PPO、A2C。より安定しますが、サンプル効率は低くなります。

• オフポリシー ：任意の方策（古いバージョンや他のエージェントを含む）が生成したデータから学ぶ。過去の経験を再利用できます。例：Q学習、DQN、SAC。サンプル効率は高い一方、安定化が難しくなります。

TD学習（Temporal Difference Learning）

TD学習 (Sutton 1988) はブートストラップを行います。つまり、エピソード全体が終わるのを待たず、別の価値推定を使って価値推定を更新します。

TD誤差を理解する：「驚き」を学習シグナルにする

TD誤差 は、エージェントが持つ将来報酬の 現在の推定 と、1ステップ進んだ後の 新しく更新された推定 とのずれを測ります。簡単に言えば、エージェントが「起こると思っていたこと」と「実際に起こったことに、次に起こると予想することを加えたもの」の差です。これはエージェントの「驚き」を表します。

Note

運転にたとえると

車で自宅に帰るとき、所要時間は30分だと予想しているとします。

• 予測 ：合計30分。

• 現実の変化 ：10分走ったところで、予期せぬ道路工事に遭遇しました。GPSが更新され、残り35分かかると表示しました。

• TD誤差 ：現在の合計予想時間は45分（経過10分＋残り35分）です。新しい推定（45分）と古い推定（30分）の差は、 +15分のTD誤差 です。この「驚き」を使って、次回はルートを変更します。

正のTD誤差 は、結果が予想より良かったことを意味します \(\rightarrow\) この状態の価値を高めます。\ 負のTD誤差 は、結果が予想より悪かったことを意味します \(\rightarrow\) この状態の価値を下げます。

TD誤差の式

\[ \boxed{\delta_t = R_{t+1} + \gamma V(S_{t+1}) - V(S_t)} \]

• \(R_{t+1}\)：行動を取った後に受け取る 即時報酬 。

• \(\gamma V(S_{t+1})\)：次の状態の推定 割引価値 （次の状態以降で得られるとエージェントが予想するものを、割引率 \(\gamma\) でスケールした値）。

• \(V(S_t)\)：現在の状態の価値に対する 元の推定 。

\((R_{t+1} + \gamma V(S_{t+1}))\) の合成項を TDターゲット と呼びます。したがって、次のようになります。

\[ \text{TD Error} = \text{TD Target} - \text{Old Estimate} \]

エージェントはTD誤差をどう使うか

エージェントは、TD誤差をゼロに近づけるように価値関数を調整します。

\[ \boxed{V(S_t) \leftarrow V(S_t) + \alpha \cdot \delta_t} \]

• \(\delta_t > 0\) の場合：結果が予測より良かった \(\rightarrow\) エージェントがこの状態を求めるように \(V(S_t)\) を増やします。

• \(\delta_t < 0\) の場合：結果が予測より悪かった \(\rightarrow\) エージェントがこの状態を避けるように \(V(S_t)\) を減らします。

• \(\delta_t = 0\) の場合：予測が完全だった \(\rightarrow\) 更新は不要です（収束）。

Tip

TDとモンテカルロ法

モンテカルロ法 ：エピソードが終わるまで待ち、実際のリターン \(G_t\) を使います。不偏ですが、分散が大きくなります（1本の軌跡は代表的でない可能性があります）。

TD ：推定した将来価値 \(\gamma V(s_{t+1})\) を使って、各ステップの後に更新します。偏りがあります（\(V\) の精度に依存します）が、分散は大幅に小さくなります（1ステップ更新なので、ノイズが累積しません）。

TD(\(\lambda\)) ：TD(0)とモンテカルロ法の間を補間します。\(\lambda=0\) は純粋なTD、\(\lambda=1\) は純粋なMCです。PPOでGAEが行っていることはまさにこれです（\(\lambda=0.95\)）。

TDターゲット ：\(y_t = r_t + \gamma V(s_{t+1})\) — 近づけていく「より良い推定」。

マルチステップTD （nステップ・リターン）：

\[ G_t^{(n)} = r_t + \gamma r_{t+1} + \cdots + \gamma^{n-1} r_{t+n-1} + \gamma^n V(s_{t+n}) \]

Q学習

Q学習 (Watkins 1989) は、基礎的な オフポリシー・価値ベース アルゴリズムです。実際に従っている方策にかかわらず、最適な \(Q^*\) を直接学びます。

更新則 ：

\[ \boxed{Q(s_t, a_t) \leftarrow Q(s_t, a_t) + \alpha\left[r_t + \gamma \max_{a'} Q(s_{t+1}, a') - Q(s_t, a_t)\right]} \]

Tip

Q学習がオフポリシーである理由

更新では \(\max_{a'} Q(s_{t+1}, a')\) を使います。これは、エージェントが実際にどの行動を取ったかにかかわらず、次の状態での最良の行動の価値です。したがって、振る舞い方策がランダムに探索していても（\(\epsilon\)-greedy）、ターゲットは常に最適方策の下で計算されます。

これが、Q学習がリプレイバッファ、デモンストレーション、その他あらゆる経験源から学べる理由です。データが現在の方策から生成されている必要はありません。

SARSA (Rummery and Niranjan 1994)（オンポリシーの代替手法）は、最大値の代わりに実際に取った行動を使います。

\[ Q(s_t, a_t) \leftarrow Q(s_t, a_t) + \alpha\left[r_t + \gamma Q(s_{t+1}, a_{t+1}) - Q(s_t, a_t)\right] \]

Deep Q-Network（DQN） (Mnih et al. 2015)：表形式の \(Q(s,a)\) をニューラルネットワーク \(Q_\theta(s,a)\) に置き換えます。主な革新は、経験リプレイバッファ（オフポリシーデータの再利用）、ターゲットネットワーク（安定性）、\(\epsilon\)-greedy探索です。

DQNの損失関数 ：リプレイバッファからサンプリングしたミニバッチについて、平均二乗TD誤差を最小化するようネットワークを学習します。

\[ \boxed{\mathcal{L}(\theta) = \mathbb{E}_{(s,a,r,s') \sim \mathcal{B}}\!\left[\left(r + \gamma \max_{a'} Q_{\bar{\theta}}(s', a') - Q_\theta(s, a)\right)^2\right]} \]

ここで \(Q_{\bar{\theta}}\) は ターゲットネットワーク です。これは \(Q_\theta\) の凍結コピーで、\(C\) ステップごとにだけ更新されます（例：\(C = 10{,}000\)）。これにより移動するターゲット問題を防ぎます。ターゲットネットワークがなければ、予測とターゲットが同時に変化し、発散を引き起こします。

勾配更新 ：損失を \(\theta\) について微分します（ターゲット \(y\) は定数として扱い、\(\bar{\theta}\) を通じて勾配は流れないことに注意してください）。

\[ \nabla_\theta \mathcal{L} = -\mathbb{E}\!\left[\underbrace{\left(r + \gamma \max_{a'} Q_{\bar{\theta}}(s', a') - Q_\theta(s, a)\right)}_{\text{TD error } \delta}; \nabla_\theta Q_\theta(s, a)\right] \]

\[ \theta \leftarrow \theta - \alpha \cdot \delta \cdot \nabla_\theta Q_\theta(s, a) \]

学習手順 （学習ステップごと）：

1. 行動 ：\(\epsilon\)-greedyで行動を選択します。確率 \(\epsilon\) でランダムな行動を取り、それ以外では \(a = \arg\max_a Q_\theta(s, a)\) とします。最初の100万ステップで \(\epsilon\) を1.0 \(\rightarrow\) 0.01へアニーリングします。

2. 保存 ：遷移 \((s, a, r, s', d)\) を容量約1Mのリプレイバッファ \(\mathcal{B}\) に保存します。

3. サンプリング ：\(\mathcal{B}\) から32個の遷移を一様にミニバッチとして取り出します。

4. ターゲット計算 ：\(y = r + \gamma(1 - d)\max_{a'} Q_{\bar{\theta}}(s', a')\) とします（終端状態なら将来価値をゼロにする）。

5. 更新 ：\((y - Q_\theta(s,a))^2\) に対して勾配降下を行います。勾配を \([-1, 1]\) にクリップします（Huber損失の変種）。

6. ターゲット同期 ：\(C\) ステップごとに \(\bar{\theta} \leftarrow \theta\) としてコピーします。

リプレイバッファを理解する

リプレイバッファ (Lin 1992)（経験リプレイ）は、過去の経験を保存し、後からエージェントが再び学習できるようにするデータ保存機構です。行動の直後にデータを捨てるのではなく、エージェントは遷移をメモリーバンクに保存し、ランダムなミニバッチをサンプリングして学習します。

保存されるもの ：各遷移は次のタプルです。

\[ e_t = (s_t, a_t, r_t, s_{t+1}, d_t) \]

ここで \(d_t\) は、エピソードが終了したかどうかを示すブール値フラグです。

Important

リプレイバッファが不可欠な理由

• データの相関を断つ ：連続するステップは強く相関しています。ニューラルネットワークは系列データ上でうまく一般化できません。バッファからランダムにサンプリングすると、学習サンプルはおおむね独立同分布（i.i.d.）になります。

• 壊滅的忘却を防ぐ ：バッファがなければ、難しいレベルをクリアしたエージェントが、次のレベルで1万ステップ失敗し続ける間に、そのクリア方法を忘れる可能性があります。バッファにより、過去の状況を練習し続けられます。

• サンプル効率を高める ：環境の実行には時間がかかることがあります。リプレイバッファがあれば、同じ遷移から複数回重みを更新でき、各ステップからより多くの価値を引き出せます。

import random
from collections import deque

class ReplayBuffer:
    def __init__(self, capacity):
        self.buffer = deque(maxlen=capacity)  # 上限付きキュー
    
    def push(self, state, action, reward, next_state, done):
        self.buffer.append((state, action, reward, next_state, done))
        
    def sample(self, batch_size):
        # ランダムな経験を選び、相関を断つ
        return random.sample(self.buffer, batch_size)
        
    def __len__(self):
        return len(self.buffer)

Tip

優先経験リプレイ（PER）

標準的なバッファでは、すべての経験が同じ確率でサンプリングされます。しかし、なかには他よりも多くを学べる経験があります。 PER (Schaul et al. 2016) は、サンプリング確率を TD誤差の大きさ に応じて調整します。ある遷移が大きな「驚き」（高い \(\vert \delta_t\vert\)）を生じさせた場合、エージェントはその遷移をより頻繁にサンプリングし、より速くモデルを修正します。これにより、Atariベンチマークでは学習が2〜3\(\times\)高速化されます。

Warning

Q学習がLLMで失敗する理由

言語生成の行動空間は全語彙（\(\vert A\vert = 32\text{K}\)〜\(128\text{K}\)）であり、状態空間は取りうるすべてのトークン列（無限）です。各トークン位置で128K個の行動について \(\max_a Q(s,a)\) を計算するのは扱いきれません。これが、LLMのRLで方策ベース手法（PPO、GRPO）を使う理由です。

方策勾配法 — REINFORCE

価値関数を学習して方策を導く代わりに、方策パラメータ \(\theta\) を直接最適化して期待リターンを最大化します (Williams 1992)。

目的関数 ：\(J(\theta) = \mathbb{E}_{\tau \sim \pi_\theta}[R(\tau)] = \mathbb{E}_{\pi_\theta}\left[\sum_{t=0}^T r_t\right]\)

方策勾配定理 ：

\[ \boxed{\nabla_\theta J(\theta) = \mathbb{E}_{\pi_\theta}\left[\sum_{t=0}^T \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot G_t\right]} \]

Important

方策勾配定理 — 形式的な導出（5ステップ）

ステップ1 ：目的関数を定義します。期待リターンを最大化したいので、次のようにします。 \[ J(\theta) = \mathbb{E}_{\tau \sim \pi_\theta}!\left[\sum_{t=0}^T r_t\right] = \sum_\tau P(\tau|\theta) R(\tau) \] ここで \(P(\tau\vert \theta) = p(s_0)\prod_{t=0}^T \pi_\theta(a_t\vert s_t), p(s_{t+1}\vert s_t, a_t)\) は軌跡の確率です。

ステップ2 ：勾配を取ります。\(\theta\) に依存するのは \(\pi_\theta\) の項だけです（ダイナミクス \(p\) は依存しません）。 \[ \nabla_\theta J = \sum_\tau \nabla_\theta P(\tau|\theta), R(\tau) \]

ステップ3 ： 対数微分トリック を適用します：\(\nabla_\theta P(\tau\vert \theta) = P(\tau\vert \theta), \nabla_\theta \log P(\tau\vert \theta)\)。 \[ \nabla_\theta J = \mathbb{E}_{\tau \sim \pi_\theta}!\left[\nabla_\theta \log P(\tau|\theta), R(\tau)\right] \]

ステップ4 ：\(\log P(\tau\vert \theta)\) を展開します。\(\log p(s_0)\) と \(\log p(s_{t+1}\vert s_t,a_t)\) の項は \(\nabla_\theta\) によって消えます。 \[ \nabla_\theta \log P(\tau|\theta) = \sum_{t=0}^T \nabla_\theta \log \pi_\theta(a_t|s_t) \]

ステップ5 ：組み合わせます。未来の報酬は過去の行動に依存しないため（因果性）、各 \(\nabla\log\pi\) は未来のリターン \(G_t = \sum_{t'=t}^T r_{t'}\) とのみ組み合わさります。 \[ \boxed{\nabla_\theta J = \mathbb{E}_{\pi_\theta}!\left[\sum_{t=0}^T \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot G_t\right]} \]

Tip

この定理が美しい理由

勾配は 環境ダイナミクス \(p(s'\vert s,a)\) を微分する必要がありません。対数微分トリックにより、単に方策を実行して報酬を観測するだけで推定できる期待値に変換されます。\(G_t\) をアドバンテージ \(\hat{A}_t = G_t - V(s_t)\) に置き換えると、偏りを導入せずに分散を減らせます（任意の状態依存ベースラインについて \(\mathbb{E}[\nabla\log\pi \cdot b(s)] = 0\) だからです）。

REINFORCEアルゴリズム (Williams 1992)（Williams、1992）：

1. \(\pi_\theta\) の下で完全な軌跡 \(\tau = (s_0, a_0, r_0, s_1, a_1, r_1, \ldots)\) をサンプリングする

2. 各時刻についてリターン \(G_t = \sum_{k=0}^{T-t} \gamma^k r_{t+k}\) を計算する

3. 更新する：\(\theta \leftarrow \theta + \alpha \sum_t \nabla_\theta \log \pi_\theta(a_t\vert s_t) \cdot G_t\)

Tip

REINFORCEの直感 — 「報酬重み付き最尤推定」

\(\nabla_\theta \log \pi_\theta(a_t\vert s_t)\) は、行動 \(a_t\) の確率を高める方向です。これに \(G_t\) を掛けると、次のようになります。

• 高報酬の軌跡：取ったすべての行動の確率を高める（\(G_t\) が正）

• 低報酬の軌跡：取った行動の確率を下げる（ベースライン適用後の \(G_t\) が負）

これは、どれだけ良い結果になったかに応じて重み付けした、行動を「ラベル」とする教師あり学習です。

ベースラインによる分散削減 ：

\[ \nabla_\theta J(\theta) = \mathbb{E}_{\pi_\theta}\left[\sum_{t=0}^T \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot (G_t - b(s_t))\right] \]

\(a_t\) に依存しない任意のベースライン \(b(s_t)\) は、勾配を不偏のまま保ちつつ分散を減らします。最良の選択は \(b(s_t) = V^\pi(s_t)\) です。このとき \(G_t - V(s_t) \approx A^\pi(s_t, a_t)\) = アドバンテージとなります。

Warning

REINFORCEの限界

• 高分散 ：各勾配は1本の軌跡を使います。安定した更新には数千のサンプルが必要です。

• ブートストラップなし ：エピソード全体が終わるまで待つ必要があります（途中の貢献を評価できません）。

• サンプル効率が低い ：データは1回使うと破棄されます（オンポリシー）。

• ステップサイズの制御なし ：方策を壊滅的に大きく更新する可能性があります。

これらの限界が、REINFORCE \(\to\) アクター・クリティック \(\to\) TRPO \(\to\) PPO という発展を促しました。

アクター・クリティック法

方策勾配（アクター）と学習した価値関数（クリティック）を組み合わせ、方策最適化の柔軟性を保ちながら分散を減らします。

アーキテクチャ ：

• アクター \(\pi_\theta(a\vert s)\)：方策。行動を提案します。

• クリティック \(V_\phi(s)\) または \(Q_\phi(s,a)\)：状態／行動がどれだけ良いかを評価します。低分散のベースラインを提供します。

アクターの更新 （クリティックから得たアドバンテージを使用）：

\[ \nabla_\theta J = \mathbb{E}\left[\nabla_\theta \log \pi_\theta(a_t|s_t) \cdot \hat{A}_t\right], \quad \hat{A}_t = r_t + \gamma V_\phi(s_{t+1}) - V_\phi(s_t) \]

クリティックの更新 （TD誤差を最小化）：

\[ \mathcal{L}_\text{critic} = \mathbb{E}\left[(r_t + \gamma V_\phi(s_{t+1}) - V_\phi(s_t))^2\right] \]

Important

LLM向けPPOへの発展

1. REINFORCE (Williams 1992)：高分散でブートストラップなし \(\rightarrow\) LLMには実用的でない

2. A2C/A3C (Mnih et al. 2016)（Advantage Actor-Critic）：TDベースのアドバンテージを使います。分散は低下しますが、ステップサイズに上限がありません。

3. TRPO (Schulman et al. 2015)：方策更新間のKLダイバージェンスを制約します。安定しますが、2次最適化のため高コストです。

4. PPO (Schulman et al. 2017)：方策比をクリップし、1次最適化だけでTRPOと同程度の安定性を実現します。LLMのRL学習における標準手法です。

5. GRPO ：クリティックを完全に取り除き、グループ統計をベースラインとして使います。検証可能な報酬に対して、より単純で効果的です。

一般化アドバンテージ推定（GAE）

動機 ：アクター・クリティックの枠組みには、アドバンテージ \(A(s,a) = Q(s,a) - V(s)\) — この行動は平均よりどれだけ良かったのか — の良い推定が必要です。しかし、ここには根本的な緊張関係があります。

• 1ステップTDアドバンテージ （\(r_t + \gamma V(s_{t+1}) - V(s_t)\)）：分散が低い（ランダムなステップは1つだけ）一方、 偏りがある — 価値関数 \(V\) が間違っていれば、アドバンテージ推定も体系的にずれます。

• モンテカルロ・アドバンテージ （\(G_t - V(s_t)\)）：不偏（実際のリターンを使う）ですが、 分散が高い — 多数のランダムな報酬の合計はエピソードごとに大きく変動します。

GAE (Schulman et al. 2016)（Schulmanら、2016）は、単一のパラメータ \(\lambda \in [0, 1]\) によって、この両極端の間を 滑らかに補間 します。すべての \(n\) について、nステップ・アドバンテージ推定を指数重み付き平均し、偏りと分散を原理的にトレードオフできるようにします。

中心となる考え方 ：各時刻で1ステップTD誤差 \(\delta_t\) を計算し、それらを指数的に減衰する重み \((\gamma\lambda)^l\) で混ぜ合わせます。最近のTD誤差には完全な重みを与え、遠いTD誤差の重みは小さくします。

\[ \boxed{\hat{A}_t^{\text{GAE}} = \sum_{l=0}^{T-t} (\gamma\lambda)^l \delta_{t+l}, \quad \delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)} \]

Tip

\(\lambda\) が制御するもの — 偏りと分散のトレードオフ

• \(\lambda = 0\)：\(\hat{A}_t = \delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)\)。価値関数を完全に信頼します。分散は低いですが、\(V\) が不正確だと偏ります。

• \(\lambda = 1\)：\(\hat{A}_t = \sum_l \gamma^l r_{t+l} - V(s_t)\)。完全なモンテカルロ・リターンからベースラインを引きます。不偏ですが、分散は非常に高くなります。

• \(\lambda = 0.95\)（標準値）：最適な中間点です。主に \(V\) を信頼しながら、遠い影響については実際のリターンで補正します。初期学習後に価値ヘッドが正確になるため、うまく機能します。

LLMの場合は特に、\(\gamma = 1.0\)（時間割引なし — 単一ターンではすべてのトークンを等しく重視）および \(\lambda = 0.95\) とします。

GAEにおける偏りと分散の直感的な対応

教師あり学習では、偏りと分散は構造的なモデル仮定から生じます。GAEによる強化学習では、偏りと分散は 不完全なモデルをどれだけ信頼し、混沌とした環境をどれだけ信頼するか から生じます。

• 偏り（体系的なずれ） ：価値ネットワーク \(V_\theta\) の構造的な仮定と不完全な予測に推定器が依存すると生じます。\(\theta\) が十分に学習されていない、または容量が不足している場合、ベースラインの推測は体系的に間違います。

• 分散（サンプルの揺らぎ） ：制約のない長い環境軌跡に推定器が依存すると生じます。確率的な遷移、乱数シード、方策実行時のノイズが長いホライズンにわたって蓄積し、ロールアウト間で実測報酬が大きく揺れます。

アーキテクチャ上のスペクトラム：境界分析

ハイパーパラメータ \(\lambda\) は、2つの基本的な推定パラダイムの間を調整するスライドルールとして機能します。

Important

高い偏り／低い分散の極限（$\lambda = 0$）

\[ \hat{A}_t^{\text{GAE}(\gamma, 0)} = \delta_t^V = r_t + \gamma V_\theta(s_{t+1}) - V_\theta(s_t) \]

• 振る舞い ：アドバンテージは現在のパラメータ \(\theta\) の状態に強く左右されます。

• 直感 ：ネットワークが1ステップの窓で自分の性能を採点しているため、非常に 偏り があります。\(V_\theta\) が不正確なら勾配ステップが壊れます。一方、\(t+1\) より先の確率的なイベントを無視するため、 分散 は低く、パラメータ更新は滑らかで安定します。

• リスク ：方策が最適でない局所最小値に陥り、複雑な遅延報酬の系列を発見できません。

Important

低い偏り／高い分散の極限（$\lambda = 1$）

\(\lambda = 1\) のとき、中間の価値項は望ましい形で相殺され、GAEはベースラインを引いたモンテカルロ・リターンになります。 \[ \hat{A}_t^{\text{GAE}(\gamma, 1)} = \sum_{l=0}^{\infty} \gamma^l r_{t+l} - V_\theta(s_t) \]

• 振る舞い ：ブートストラップによる先読みを捨て、エピソード全体の文字どおりの現実を合計します。

• 直感 ：ニューラルネットワークによる近似ではなく実際の報酬を測るため、真の環境ダイナミクスに対して完全に 不偏 です。しかし、極端な 分散 を示します。エピソード序盤の小さな変化がリターン全体を大きく分岐させ、方策更新が不安定になる可能性があります。

• リスク ：破壊的な勾配更新、学習の爆発。

トレードオフ行列

\(\lambda \in [0.95, 0.99]\) を選ぶと、GAEはアドバンテージ推定の平均二乗誤差全体を最小化します。

GAEのパラメータ選択の実務上の比較。

\(\lambda\) 調整の診断

学習曲線を監視すると、偏りと分散のどちらが支配的かを直接把握できます。

1. 高分散の兆候 ：方策エントロピーが急激に低下する一方、価値関数の説明分散が大きく負になる、または不規則になる \(\rightarrow\) 方策更新がノイジーです。 対策 ：\(\lambda\) を下げてターゲット更新を滑らかにします。

2. 高偏りの兆候 ：エージェントは早期には安定して学習するものの、複雑な遅延報酬の系列をまったく発見できない \(\rightarrow\) ブートストラップにより長期依存を過小評価しています。 対策 ：\(\lambda\) を1.0に近づけ、実際の下流軌跡のシグナルを方策に与えます。

オンポリシーとオフポリシー — 詳細比較

Tip

RLHF手法におけるオン／オフポリシー

PPO／GRPOはオンポリシー ：現在の方策で応答を生成し、アドバンテージを計算し、更新してデータを破棄し、再び生成します。これが生成に計算量の60%が費やされる理由です。各ステップで再生成する必要があります。

DPOはオフポリシー ：固定された選好データセットで学習します。学習中の生成はありません。はるかに安価ですが、方策が変化するとデータが古くなるため、分布シフトの影響を受けます。

Online DPOはハイブリッド ：新しいデータを生成し（オンポリシー生成）、DPOの教師あり損失を使います（オフポリシー型の最適化）。両方の利点を得られます。

PPOの巧妙さ ：クリップ比 \(r = \pi_\text{new}/\pi_\text{old}\) を使い、オンポリシーデータの1つのバッチから複数回の勾配ステップ（4エポック）を引き出します。これにより、制御された形で「少しだけオフポリシー」になります。

モデルベースとモデルフリー

Tip

LLMのRLがモデルフリーである理由

言語生成のダイナミクスは単純です（系列にトークンを追加する — 決定論的な遷移）。環境の「モデル」はボトルネックではありません。難しいのは 報酬 、つまり人間が何を好むかを予測することです。そのため、LLMのRLにはモデルベース手法は不要です。

RLHFの報酬モデルは、ある意味では「モデル」とみなせます（人間の選好を予測するためです）。しかし、報酬シグナルとして使われるのであって、計画やシミュレーションに使われるわけではありません。LLMのRLは本質的にモデルフリーの方策最適化です。

報酬シェーピング

報酬シェーピング (Ng et al. 1999) は、開発者が環境本来の報酬関数を変更または補完する手法です。主な目的は、エージェントが最終的なタスク完了時にしかフィードバックを受け取らない 疎な報酬 の状況を、中間的なフィードバックシグナルを持つ 密な報酬 の状況に変換し、収束を速めることです。

数学的枠組み

時刻 \(t\) における元の報酬を \(R_t(s, a, s')\) とします。報酬シェーピング後の報酬は補助的なシェーピング関数 \(F\) を加えます。

\[ \boxed{R'_t(s, a, s') = R_t(s, a, s') + F(s, a, s')} \]

Warning

素朴なシェーピングのリスク：報酬ハッキング

\(F(s, a, s')\) を恣意的に設計すると、エージェントは全体の目的を無視しながら、補助シグナルを最大化する構造上の抜け道を見つけます。

例 ：中間のランドマークに到達すると報酬を受け取るナビゲーションエージェントは、目的地に到達することなく、1つのチェックポイントの周りを無限にループして報酬を無限に蓄積するよう学習する可能性があります。

LLMの場合、「自信がありそうに聞こえる」ことに報酬を与えると、正確さにかかわらず、常に「Absolutely!」で始めるよう学習する可能性があります。

ポテンシャルベース報酬成形（PBRS）

報酬成形によって最適方策が変わらないことを数学的に保証するには、 ポテンシャルベース報酬成形 を使います。成形関数 \(F\) を、状態間のスカラー・ポテンシャル関数 \(\Phi\) の差に制約します。

\[ \boxed{F(s, a, s') = \gamma\, \Phi(s') - \Phi(s)} \]

ここで \(\Phi: \mathcal{S} \to \mathbb{R}\) は、状態が目標にどの程度近いかを評価する実数値のポテンシャル関数であり、\(\gamma\) は割引率です。

PBRS後の完全な報酬は次のとおりです。

\[ R'(s, a, s') = R(s, a, s') + \gamma\, \Phi(s') - \Phi(s) \]

理論的保証

Important

PBRS方策不変性定理

• 方策不変性 ：シェーピング後の報酬 \(R'\) に対する最適方策 \(\pi^*\) は、元の報酬 \(R\) に対する最適方策と 同一 です。シェーピングによって最適でない振る舞いが導入されることはありません。

• ループ耐性 ：同じ状態から始まり同じ状態で終わる任意の循環軌跡では、ポテンシャルの正味の変化は正確にゼロになります（\(\Phi(s) - \Phi(s) = 0\)）。エージェントはループを利用して報酬をハックできません。

• 収束の高速化 ：最適方策は変わらないまま、シェーピング後の報酬はより密な勾配シグナルを提供するため、疎な報酬の環境でエージェントは5〜50\(\times\)速く収束できます。

言語モデルのためのRLの基礎

教師ありファインチューニング（SFT）は、モデルにデモンストレーションを模倣するよう教えます。しかし、模倣には上限があります。モデルは学習データの品質を超えられないからです。強化学習はこの壁を打ち破ります。新しいテキストを生成し、報酬フィードバックを受け取り、より高い報酬へ向けて更新することで、RLで学習したモデルは、人間のデモンストレーターが書いたことのない戦略を発見できます。その結果、より有用で、より正確で、人間の選好によりよく整合した出力を生成します (Ouyang et al. 2022)。

これは、すべてのフロンティアモデルを支える仕組みです。GPT-4 (OpenAI 2023)、Claude、Llama-3 (Grattafiori et al. 2024)、DeepSeek-R1 (DeepSeek-AI et al. 2025) はいずれもSFT後にRLを適用します。これは、有能だが方向づけられていないモデルを、アラインされたアシスタントへと変える決定的な段階です。

LLMにおけるRLの2つのパラダイム

言語モデルのRL手法は、目的に応じて使い分けられる、2つの大きなパラダイムに分けられます。

パラダイム1：人間の選好によるアラインメント（RLHF/DPO）

LLMにRLを適用する当初の目的は、 アラインメント 、つまりモデルを有用で、無害で、正直にすることでした。 人間のフィードバックからの強化学習（RLHF） (Ouyang et al. 2022; Ziegler et al. 2019; Christiano et al. 2017) は、人間によるペア単位の判断（「どちらの応答が優れているか？」）から報酬モデルを学習し、その学習した報酬を最大化するように方策を最適化します。 DPO (Rafailov et al. 2023) は、報酬モデルを完全に取り除き、選好を直接教師あり損失へ変換することで、この手法を簡略化します。どちらの手法も、指示に従い、安全性の制約を尊重するアラインメント済みアシスタントを生成します。

パラダイム2：検証可能な報酬による能力向上（RLVR）

近年、RLはアラインメントだけでなく、特に推論、数学、コード生成といった 新しい能力の学習 にも使われています。ここで報酬を与えるのは人間の選好ではなく、 検証可能な結果 です。モデルは正しい答えを生成したでしょうか。コードはすべてのテストに合格したでしょうか。DeepSeek-R1 (DeepSeek-AI et al. 2025) は、ルールベースの報酬（形式の正しさ＋解答の正確さ）を用いるGRPOによって、人間の選好データなしで高度なChain-of-thought推論を身につけるようモデルを学習できることを示しました。このパラダイム、すなわち検証可能な報酬からの強化学習（RLVR）は、現在、推論モデルやエージェントシステムを構築するための主流のアプローチです。

Important

共通の基盤

目的は異なりますが、どちらのパラダイムも同じ中核的な仕組みを共有しています。

• LLMが自己回帰的にテキストを生成する 方策 \(\pi_\theta\)

• 報酬シグナル \(r(x, y)\)（選好から学習するか、検証から計算する）

• 退化した解を防ぐための参照方策に対する KL制約

• モデルをより高い報酬へ向けて更新する 方策勾配最適化 （PPOまたはGRPO）

このパートの各章では、それぞれの構成要素を詳しく説明します。

テキスト生成をMDPとして捉える

RLを言語モデルに適用できるようにする重要な洞察は、自己回帰的な生成をマルコフ決定過程として捉え直すことです。

Tip

LLMをエージェントとみなす類推

LLMを、1トークンずつ応答を書く エージェント だと考えてみましょう。各ステップで、これまでに書かれたすべての内容（ 状態 ）を確認し、次の単語（ 行動 ）を選び、ページが1トークンずつ増えていきます（ 遷移 ）。応答が完成すると、判定者がそれを採点します（ 報酬 ）。目標は、一貫して高い点数を得られる書き方の戦略（ 方策 ）を学ぶことです。

形式的には、テキスト生成のMDPは次のようになります。

• 状態 \(s_t = (x, y_1, \ldots, y_{t-1})\)：プロンプトと、これまでに生成されたすべてのトークンを連結したもの。

• 行動 \(a_t \in \{1, \ldots, \vert \mathcal{V}\vert \}\)：語彙から次のトークンを選ぶこと（32K〜128K個の選択肢）。

• 遷移 \(P(s_{t+1}\vert s_t, a_t)\)：決定論的です。選択したトークンを追加するだけであり、環境の確率性はありません。

• 報酬 \(r\)：通常は生成の最後にだけ与えられます（疎な報酬）。RLHFでは報酬モデルのスコア、RLVRでは最終回答の正しさです。

• 方策 \(\pi_\theta(a_t\vert s_t)\)：LLMの次トークン確率分布であり、ソフトマックス出力がすでに計算しているものです。

• 割引率 \(\gamma = 1.0\)：エピソードは有限（1つの応答）なので、割引は必要ありません。

この対応付けが強力なのは、LLMがすでに方策だからです。LLMのソフトマックス出力は、あらゆる状態における \(\pi_\theta(a_t\vert s_t)\) を定義します。別の方策ネットワークを構築する必要はありません。報酬の高いトークン列に対してモデルがより高い確率を割り当てるよう、重み \(\theta\) を調整すればよいのです。

RLHFパイプライン

古典的なRLHFパイプライン (Ouyang et al. 2022) は、4つの段階からなります。

1. 教師ありファインチューニング（SFT） ：高品質なデモンストレーションでベースモデルを学習し、指示に従える方策 \(\pi_{\text{SFT}}\) を作ります。

2. 報酬モデルの学習 ：同じプロンプトに対する人間の選好比較（\(y_w \succ y_l\)）を集め、Bradley-Terry目的関数を使って報酬モデル \(R_\phi(x, y)\) を学習します。

3. RL最適化 ：報酬モデルをシグナルとして、\(\pi_{\text{SFT}}\) に対するKL制約のもとで、PPOまたはGRPOによって方策を最適化します。

4. 評価と反復 ：アラインメント済みモデルを評価し、新たな失敗事例を集め、反復します。

RLVR（推論／エージェント学習）では、1〜2段階が置き換えられます。SFTモデルは推論トレースで学習し、報酬モデルは検証器（たとえば数学的な正しさを確認するもの）に置き換えられます。第3段階は変わらず、報酬シグナルに対してPPOまたはGRPOで最適化します。

Tip

LLMにおけるRLと古典的RLの違い

LLMの設定は、重要な点で古典的RLと異なります。

• 決定論的な遷移 ：「次の状態」は、単に過去のトークンを連結したものです。確率的な環境はありません。

• 疎な報酬 ：フィードバックは通常、生成の最後に1回（結果報酬）、または重要なステップで与えられます（プロセス報酬）。

• 巨大な行動空間 ：各ステップで32K〜128K個のトークンが候補になります。ただし、探索は温度サンプリングによって暗黙的に行われます。

• KLアンカー ：LLMのRLはSFT方策の近くにとどまるよう制約されます。これにより報酬ハッキングを防ぐ一方、探索は縮小します。

• 価値関数は不要 ：GRPOはクリティックネットワークを完全に取り除き、代わりに報酬のグループ相対正規化を使います。

これらの違いが、LLMではPPOとGRPOがDQN系のアプローチより主流となっている理由です。

このパートのロードマップ

これからの章では、LLMのRLに必要なツールキット全体を構築します。

1. PPO （第5章）— クリップ付き代理目的関数、アドバンテージ推定のためのGAE、クリティックネットワーク、そして完全なRLHF学習ループを扱います。GPT-4やClaudeを支える実用的な主力手法です。

2. DPO （第6章）— 選好を対照的な教師あり損失に変換することで、RLを完全に迂回します。オンラインRLより単純ですが、柔軟性は低くなります。

3. GRPO （第7章）— グループレベルの報酬正規化を使う、DeepSeekのクリティック不要アルゴリズムです。DeepSeek-R1を支え、推論モデルの学習で主流となっている手法です。

4. 選好最適化のバリアント （第8章）— Online DPO、KTO、Best-of-N、および手法選択の指針を扱います。

5. 報酬モデリング （第9章）— Bradley-Terryモデル、プロセス報酬と結果報酬、RLVRのルールベース報酬、複数目的の組み合わせを扱います。

6. SFTのベストプラクティス （第10章）— シーケンスパッキング、チャットテンプレート、データ混合、そしてSFTの品質がRLの上限をどのように決めるかを扱います。

7. システムエンジニアリング （第11章）— 大規模な分散学習、並列化戦略、生成と学習の分離、数百GPU向けのインフラを扱います。

PPO — 近接方策最適化

動機と歴史

問題 ：標準的な方策勾配の更新には、ステップ幅の制約がありません。たった1つの不運なバッチによって、方策がゴミを生成する領域へ押し出される可能性があります \(\rightarrow\) ゴミは低い報酬しか得られない \(\rightarrow\) 次の勾配でさらに悪化する \(\rightarrow\) 回復不能な崩壊に至ります。

解決策の歴史 ：

1. TRPO (Schulman et al. 2015)（2015年）：古い方策と新しい方策の間のKLダイバージェンスを制約します。完全に機能しますが、二次最適化（フィッシャー情報行列、共役勾配法）が必要で、計算コストが高くなります。

2. PPO （2017年）(Schulman et al. 2017)：単純な一次のクリップ付き目的関数によって、同程度の安定性を実現します。実装は10\(\times\)単純で、ほぼ同等に機能し、分散学習にも容易にスケールします。

クリップ付き目的関数

PPOの中核的な革新は、破壊的に大きな方策更新を防ぎながら、実装も簡単に保てるクリップ付き代理目的関数です。

\[ \boxed{L^{\text{CLIP}}(\theta) = \mathbb{E}_t\left[\min\left(r_t(\theta)\hat{A}_t,; \text{clip}(r_t(\theta), 1{-}\epsilon, 1{+}\epsilon)\hat{A}_t\right)\right]} \]

ここで、\(r_t(\theta) = \frac{\pi_\theta(a_t\vert s_t)}{\pi_{\theta_\text{old}}(a_t\vert s_t)}\) は確率比です。

Tip

クリッピングの直感 — 核となる洞察

\(\min\) 演算子は 悲観的な上限 を作ります。

• 良い行動（\(\hat{A} > 0\)） ：その確率を高めたいとします。代理目的 \(r\hat{A}\) は \(r\) が増えるにつれて大きくなります。しかし、clipは \(r = 1 + \epsilon\) で利益に上限を設けます。*「1つの良い例で欲張りにならない」*ためです。

• 悪い行動（\(\hat{A} < 0\)） ：その確率を下げたいとします。\(r\hat{A}\) は \(r\) が減るにつれて改善します。しかし、clipは \(r = 1 - \epsilon\) で利益に上限を設けます。*「1つの悪い例を根拠に、過度に忘却しない」*ためです。

結果として、1回の更新ステップでの方策の変化は最大でも\(\pm\)20%になります。これにより、壊滅的な崩壊と、過信した特化の両方を防ぎます。

PPOの完全な損失

\[ L = L^{\text{CLIP}} - c_1 \underbrace{(V_\theta(s_t) - V^{\text{target}}_t)^2}_{\text{value loss}} + c_2 \underbrace{H[\pi_\theta(\cdot|s_t)]}_{\text{entropy bonus}} \]

• 価値損失 （\(c_1 = 0.1\)）：リターンを予測するようにクリティックを学習します。安定性のため、これもクリップされます。

• エントロピー・ボーナス （\(c_2 = 0.01\)）：決定論的な方策への早すぎる収束を防ぎます。探索に不可欠です。

PPOの勾配と更新則の導出

この節では、RLの目的関数からPPOの更新則に至る数学的な道筋をたどり、クリップ付き代理目的関数がなぜ機能するのかを示します。

ステップ1：RLの目的関数

目標は、方策のもとで期待累積報酬を最大化することです。

\[ J(\theta) = \mathbb{E}_{\tau \sim \pi_\theta}\left[\sum_{t=0}^T r_t\right] \]

ステップ2：方策勾配定理

方策パラメータに関する \(J(\theta)\) の勾配は次のとおりです。

\[ \boxed{\nabla_\theta J(\theta) = \mathbb{E}_{\pi_\theta}\left[\sum_{t=0}^T \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot \hat{A}_t\right]} \]

ここで \(\hat{A}_t\) はアドバンテージ関数です（行動 \(a_t\) が状態 \(s_t\) における平均的な行動と比べてどれだけ優れていたか）。分散を減らすため、完全なリターンをアドバンテージに置き換えています。

ステップ3：オフポリシーデータに対する重点サンプリング

PPOは \(\pi_{\theta_{\text{old}}}\) を使ってデータを収集しますが、更新するのは \(\pi_\theta\) です。この分布の不一致を補正するため、重点サンプリングを適用します。

\[ \nabla_\theta J(\theta) = \mathbb{E}_{\pi_{\theta_{\text{old}}}}\left[\frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{\text{old}}}(a_t|s_t)} \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot \hat{A}_t\right] \]

確率比 \(r_t(\theta) = \frac{\pi_\theta(a_t\vert s_t)}{\pi_{\theta_{\text{old}}}(a_t\vert s_t)}\) を定義します。恒等式 \(\nabla_\theta \log f = \frac{\nabla_\theta f}{f}\) を使うと、次が得られます。

\[ \nabla_\theta J(\theta) = \mathbb{E}_{\pi_{\theta_{\text{old}}}}\left[\nabla_\theta, r_t(\theta) \cdot \hat{A}_t\right] \]

これは、次の 代理目的関数 を最大化することを意味します。

\[ L^{\text{CPI}}(\theta) = \mathbb{E}_t\left[r_t(\theta) \cdot \hat{A}_t\right] \]

ステップ4：制約のない代理目的関数の問題

\(L^{\text{CPI}}\) は有効な目的関数ですが、制約がなければ、1回の勾配ステップで \(r_t(\theta)\) が1.0から大きく離れてしまい、次の問題が起こります。

• 重要度の重みが極端になる \(\rightarrow\) 分散が大きくなる

• 方策が未検証の領域に入る \(\rightarrow\) 報酬モデルが信頼できないスコアを返す

• 壊滅的な崩壊：方策がゴミを生成し、回復できなくなる

TRPOの解決策 ：\(D_{\text{KL}}(\pi_{\theta_{\text{old}}} \\vert \pi_\theta) \leq \delta\) を制約します。二次法が必要で、計算コストが高くなります。

ステップ5：PPOのクリップ付き代理目的関数（一次近似）

PPOは厳密なKL制約を、一次勾配だけを使って同様の挙動を実現する クリップ付き目的関数 に置き換えます。

\[ \boxed{L^{\text{CLIP}}(\theta) = \mathbb{E}_t\left[\min!\left(r_t(\theta)\hat{A}_t,;\text{clip}(r_t(\theta), 1{-}\epsilon, 1{+}\epsilon)\hat{A}_t\right)\right]} \]

勾配の導出 ：

\(L_t = \min(r_t \hat{A}_t,; \bar{r}_t \hat{A}_t)\) とし、\(\bar{r}_t = \text{clip}(r_t, 1{-}\epsilon, 1{+}\epsilon)\) とします。

\[ \nabla_\theta L_t = \begin{cases} \nabla_\theta r_t(\theta) \cdot \hat{A}_t & \text{if } r_t \hat{A}_t < \bar{r}_t \hat{A}_t \text{ (unclipped term is smaller)} \\ 0 & \text{if } r_t \hat{A}_t \geq \bar{r}_t \hat{A}_t \text{ (clipped term is smaller, gradient = 0)} \end{cases} \]

条件を展開すると、次のようになります。

• \(\hat{A}_t > 0\) かつ \(r_t < 1+\epsilon\) の場合 ：勾配は通常どおり流れます。方策は \(\pi_\theta(a_t\vert s_t)\) を増やすよう促されます。

• \(\hat{A}_t > 0\) かつ \(r_t \geq 1+\epsilon\) の場合 ：勾配は ゼロ です。方策はすでに十分に増加しているため、それ以上押し上げません。

• \(\hat{A}_t < 0\) かつ \(r_t > 1-\epsilon\) の場合 ：勾配は通常どおり流れます。方策は \(\pi_\theta(a_t\vert s_t)\) を減らすよう促されます。

• \(\hat{A}_t < 0\) かつ \(r_t \leq 1-\epsilon\) の場合 ：勾配は ゼロ です。方策はすでに十分に減少しているため、それ以上押し下げません。

ステップ6：PPOの完全な更新則

クリップ付き方策損失、価値損失、エントロピー・ボーナスを組み合わせます。

\[ \boxed{\theta_{k+1} = \theta_k + \alpha \cdot \nabla_\theta \left[L^{\text{CLIP}}(\theta) - c_1 L^{\text{VF}}(\theta) + c_2 H[\pi_\theta]\right]} \]

ここで、

\[ \begin{aligned} L^{\text{VF}}(\theta) &= \left(V_\theta(s_t) - V_t^{\text{target}}\right)^2 & &\text{(value function regression loss)} \\ H[\pi_\theta] &= -\sum_a \pi_\theta(a|s_t)\log\pi_\theta(a|s_t) & &\text{(entropy of the policy)} \end{aligned} \]

Tip

まとめ：これが機能する理由

1. 方策勾配定理 は、方策を改善する方向を与えます。

2. 重点サンプリング によって、\(\pi_{\theta_{\text{old}}}\) のデータを複数エポックにわたって再利用できます。

3. クリッピング は重要度の重みが極端になるのを防ぎ、更新を安全に保ちます。

4. min演算子 は、常に（クリップされた項とクリップされていない項の）より保守的な方を選びます。改善に対する悲観的な下限です。

5. 結果 ：一次勾配だけを使い、確率1で単調に改善します。ヘッセ行列も、共役勾配も、ラインサーチも必要ありません。

ロールアウトバッファとロールアウト

PPOでは、データ管理に ロールアウトバッファ と呼ばれる専用の短期ストレージシステムを使います。経験をリプレイバッファに無期限に保存するオフポリシーアルゴリズム（DQNなど）とは異なり、PPOではオンポリシーという数学的制約を満たすため、一時的な構造が必要です。

ロールアウトとは何か？

ロールアウト （軌跡）とは、エージェントが現在の方策を環境内で実行することによって生成される相互作用の系列です。

• プロセス ：エージェントは状態を観測し、行動を選択し、報酬を受け取り、次の状態へ移ります。固定されたステップ数、またはエピソードが終了するまで繰り返します。

• LLM/RLHFの場合 ：ロールアウトは、データセットからプロンプトを取り出し、言語モデルにテキスト終了マーカーに到達するまでトークンを1つずつ生成させ、完全なトークン列を作ることです。各トークンが1つの「ステップ」です。

ロールアウトバッファ

ロールアウトバッファは、ロールアウト段階で収集したすべてのデータを一時的に保存します。生成されたトークン／ステップごとに、次を記録します。

\[ \boxed{\mathcal{B} = \left\{ \left(s_t,; a_t,; \log\pi_{\theta_{\text{old}}}(a_t|s_t),; r_t,; V(s_t)\right) \right\}_{t=1}^{T}} \]

• \(s_t, a_t, r_t\)：状態、取った行動、時刻 \(t\) における報酬。

• \(\log\pi_{\theta_{\text{old}}}(a_t\vert s_t)\)：その行動を、実際にデータを生成した方策のもとで取る対数確率（比の計算に必要）。

• \(V(s_t)\)：価値関数によるベースラインの予測（GAEのアドバンテージ計算に必要）。

ロールアウトバッファのライフサイクル

バッファは、厳密な3段階の時計仕掛けのサイクルで動作します。

1. 収集 ：アクティブな方策が環境と相互作用し、新しい軌跡でバッファを満たします（70Bモデル、batch=128、max_tokens=512の場合、1回のロールアウトあたり最大65Kのトークンレベル遷移）。

2. 学習 ：軌跡全体でGAEアドバンテージを計算します。\(K\) エポック（通常3〜10）にわたってミニバッチの勾配降下を実行し、クリップ付き目的関数で方策の重みを更新します。

3. 消去 ：バッファ全体を 完全に消去 します。PPOはオンポリシーなので、古い方策が生成したデータを次の更新サイクルで安全に再利用することはできません。比 \(r_t(\theta)\) が古くなり、クリッピングの保証が壊れるためです。

Warning

ロールアウトバッファとリプレイバッファの違い

リプレイバッファ （DQN、SAC）：オフポリシー。数百万の遷移を無期限に保存します。ランダムサンプリングを行い、データを多くの更新で再利用します。

ロールアウトバッファ （PPO、GRPO）：オンポリシー。1バッチ分の軌跡を保存します。数エポック使った後、完全に破棄します。サイクルごとに新しいデータが必要です。

これが、PPOに継続的な生成が必要な理由です。更新のたびにバッファが空になり、新しいロールアウトが要求されます。そのため、生成ボトルネック（実時間の60〜70%）が特に深刻になります。

Tip

RLHFにおけるvLLM

RLHF学習では、vLLMは 生成段階 （実時間の60〜70%）に使われます。方策モデルがロールアウトを生成し、その後、報酬モデルがスコアを付けます。主な利点は次のとおりです。

• バッチ生成 ：プロンプトをまたいで256個以上の応答を並列生成します。

• メモリ効率 ：より多くの同時生成を収容できるため \(\rightarrow\)、生成ボトルネック中のGPU利用率が高くなります。

• プレフィックス共有 ：プロンプトあたり \(N=8\) 個の応答を生成する場合（GRPO）、プロンプトのKVは一度だけ計算して8個すべてで共有します。冗長なプリフィルはありません。

• 統合 ：OpenRLHFやTRLなどのフレームワークは、vLLMを生成バックエンドとして使用し、生成ワーカー（vLLM）と学習ワーカー（DeepSpeed/FSDP）を分離します。

RLHFのためのPPO：完全なループ

Note

70BチャットモデルにおけるPPOの具体的なステップ

設定 ：128個のプロンプトのバッチ、Llama-3-70B方策、最大512トークン。

ステップ1 — 生成 ：128個の応答をサンプリングします（temperature=0.7、top-p=0.9）。時間の60%を要します。

ステップ2 — スコアリング ：報酬モデルが各（プロンプト、応答）ペアを採点します。範囲は0.2〜0.95です。

ステップ3 — KL ：トークンごとのKLを計算します：\(\text{KL}_t = \log\pi_\theta(y_t\vert y_{<t}) - \log\pi_\text{ref}(y_t\vert y_{<t})\)。トークン全体での平均KLは通常3〜8です。

ステップ4 — 最終報酬 ：\(R = r_\text{RM} - 0.05 \times \text{mean_KL}\)（最後のトークンにだけ与えます）。

ステップ5 — GAE ：価値ヘッドの予測を使って、各トークン位置の \(\hat{A}_t\) を計算します。アドバンテージをホワイトニングします（平均0、分散1）。

ステップ6 — 更新 ：16個のミニバッチでSGDを4エポック実行します。比を \(\epsilon = 0.2\) でクリップします。勾配ノルムは1.0でクリップします。

結果 ：方策は1ステップあたり\(\sim\)0.005の勝率向上を示します。1万ステップ後には、SFTに対して絶対値で5〜10%改善します。

Warning

LLMのRLにおけるトークン化の落とし穴

トークンごとのKLペナルティとアドバンテージを計算するときは、トークン化によって「ステップ」が決まることを忘れないでください。1つの概念的な行動（たとえば「2024」の出力）が、トークナイザーによって1〜4トークンに分かれることがあります。これにより、次のような微妙な問題が生じます。

• KLの集計 ：同じ意味内容でもトークン化が異なると、トークンごとのKLの合計は異なります（たとえば、まれな単語がより多くのサブワードに分割されると、合計KLペナルティが大きくなります）。

• 信用割当 ：GAEはトークン位置ごとにアドバンテージを割り当てますが、意味的な「意思決定」は複数トークンにまたがることがよくあります。モデルが本当に「決定」するのは単語の最初のトークンだけで、その後のサブワードトークンはほぼ決定論的です。

• 報酬の配置 ：最終トークンにだけ報酬を置くと、それより前のすべてのトークンがGAEを通してクレジットを後方へ伝播させなければなりません。長い応答ほど、シグナルが希薄になります。

緩和策 ：システムによっては、KLを系列長で正規化したり、単語レベルの報酬シェーピングを使ったり、最終トークンではなく意味的な境界で報酬を適用したりします。

詳細な仕組み：ロジットと方策の更新

PPOは、メモリ上で2つの異なるパラメータ状態を管理します。両者は同じニューラルネットワーク構造を共有しますが、最適化中は異なる重みの値を保持します。

Important

中核アーキテクチャ：2つのネットワーク

1. 方策ネットワーク（\(\pi_\theta\)） ：重み \(\theta\) でパラメータ化された、アクティブで稼働中のネットワークです。最適化中のバックプロパゲーションによって継続的に更新されます。

2. 古い方策ネットワーク（\(\pi_{\theta_{\text{old}}}\)） ：重み \(\theta_{\text{old}}\) でパラメータ化された、凍結したスナップショットです。1回の最適化サイクルの間、方策が大きく変化しすぎないよう静的なアンカーとして機能します。

フェーズ1：ロールアウト（データ収集）

データ収集中、エージェントは \(T\) ステップにわたって環境と相互作用します。各時刻 \(t\) では次を行います。

1. 環境が現在の状態／観測 \(s_t\) を返します（LLMの場合：プロンプト＋これまでに生成されたトークン）。

2. 状態 \(s_t\) を現在のネットワークスナップショット（\(\theta_{\text{old}}\)）に通します。

3. ネットワークが正規化前の生の値、すなわち ロジット \(z_{\text{old}}\) を出力します。これは \(\vert V\vert\)（語彙サイズ32K〜128K）の大きさのベクトルです。

4. Softmaxで確率を計算します。

\[ \boxed{P(a \mid s_t) = \text{Softmax}(z_{\text{old}}) = \frac{\exp(z_{\text{old}, a})}{\sum_{j=1}^{|V|} \exp(z_{\text{old}, j})}} \]

5. 行動 \(a_t\)（次のトークン）を \(P(a \mid s_t)\) からサンプリングし、遷移タプル \(\langle s_t, a_t, r_t, s_{t+1} \rangle\) と \(\log \pi_{\theta_{\text{old}}}(a_t \mid s_t)\) をロールアウトバッファに保存します。

Tip

なぜ対数確率を保存するのか？

ロールアウト中に \(\log \pi_{\theta_{\text{old}}}(a_t \mid s_t)\) をスカラーとして保存すると、最適化中に凍結したネットワークを再実行せずに済みます。ミニバッチごとにフルフォワードパスを1回省略できるため、70Bモデルでは大きな効果があります。

フェーズ2：最適化ループ（ミニバッチ更新）

ロールアウトバッファが満杯になると、PPOはミニバッチに対して \(K\) エポック（通常3〜10）を実行します。各勾配ステップでは、保存された状態 \(s_t\) を使って両方の方策のロジットを生成します。

古い方策の評価 （凍結）：

\[ z_{\text{old}} = f(s_t; \theta_{\text{old}}) \quad \longrightarrow \quad \log \pi_{\theta_{\text{old}}}(a_t \mid s_t) = \text{LogSoftmax}(z_{\text{old}})[a_t] \]

実装上のショートカット：再計算する代わりに、ロールアウト時に保存したスカラーを再利用します。

現在の方策の評価 （更新対象）：

\[ z_{\text{new}} = f(s_t; \theta) \quad \longrightarrow \quad \log \pi_\theta(a_t \mid s_t) = \text{LogSoftmax}(z_{\text{new}})[a_t] \]

\(\theta\) は各ミニバッチの勾配ステップ後に更新されるため、\(z_{\text{new}}\) は最適化ループ全体で連続的に変化します。一方、\(z_{\text{old}}\) は完全に静的なままです。

ロジットから確率比へ

PPOの中核となる比は、新しい方策のもとで行動が古い方策よりどれだけ起こりやすいか、または起こりにくいかを測ります。

\[ \boxed{r_t(\theta) = \frac{\pi_\theta(a_t \mid s_t)}{\pi_{\theta_{\text{old}}}(a_t \mid s_t)}} \]

生の確率を割ることによる壊滅的な数値アンダーフロー／オーバーフローを避けるため、計算は 対数空間 で行います。

\[ \begin{aligned} \log \pi_\theta(a_t \mid s_t) &= \text{LogSoftmax}(z_{\text{new}})[a_t] \\ \log \pi_{\theta_{\text{old}}}(a_t \mid s_t) &= \text{LogSoftmax}(z_{\text{old}})[a_t] \end{aligned} \]

差を指数関数に入れることで、比を復元します。

\[ \boxed{r_t(\theta) = \exp!\left(\log \pi_\theta(a_t \mid s_t) - \log \pi_{\theta_{\text{old}}}(a_t \mid s_t)\right)} \]

この比をPPOのクリッピング目的関数に組み込みます。

\[ \boxed{\mathcal{L}^{\text{CLIP}}(\theta) = \hat{\mathbb{E}}_t \left[ \min!\left(r_t(\theta)\hat{A}_t, ;\text{clip}(r_t(\theta),, 1{-}\epsilon,, 1{+}\epsilon),\hat{A}_t\right) \right]} \]

Tip

クリッピングの仕組み

• \(\hat{A}_t > 0\)（良い行動）の場合：比は \(1+\epsilon\) でクリップされ、良い行動を過度に利用できません。

• \(\hat{A}_t < 0\)（悪い行動）の場合：比は \(1-\epsilon\) でクリップされ、悪い行動を過度に罰することができません。

• \(\min(\cdot)\) によって、常により保守的な推定値を選びます。

結果として、信頼領域内で単調に改善し、壊滅的な崩壊は起こりません。

PPOの重みのライフサイクル

PPOの学習フェーズにおける \(\theta\) と \(\theta_{\text{old}}\) の推移。

連続行動空間への拡張

連続行動空間（LLMでは一般的ではありませんが、ロボティクスRLでは重要）では、ネットワークは離散的なロジットではなく分布パラメータを出力します。

• 予測平均ベクトル \(\mu\)

• 予測標準偏差ベクトル \(\sigma\)

対数確率はガウス分布の対数PDFで計算します。

\[ \boxed{\log \pi(a_t \mid s_t) = -\frac{1}{2}\left(\frac{a_t - \mu}{\sigma}\right)^{!2} - \log(\sigma) - \frac{1}{2}\log(2\pi)} \]

続いて比 \(r_t(\theta) = \exp(\log \pi_\theta - \log \pi_{\theta_{\text{old}}})\) を同じように計算し、同じクリッピング目的関数に入力します。

TRLによる実装

HuggingFace TRLライブラリ (Werra et al. 2022) は、LLM向けの主要なRL手法をすべて、プロダクションで利用できる形で実装しています。

from trl import PPOConfig, PPOTrainer, AutoModelForCausalLMWithValueHead
from transformers import AutoTokenizer
from peft import LoraConfig

# Model setup
model = AutoModelForCausalLMWithValueHead.from_pretrained(
    "meta-llama/Llama-3.1-8B-Instruct",
    torch_dtype=torch.bfloat16, device_map="auto",
    peft_config=LoraConfig(r=64, lora_alpha=16, target_modules=["q_proj","v_proj","k_proj","o_proj"])
)
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B-Instruct")

# PPO config with all critical hyperparameters
ppo_config = PPOConfig(
    learning_rate=1.5e-6,        # Low LR for stability
    batch_size=128,              # Prompts per step
    mini_batch_size=16,          # Gradient accumulation unit
    ppo_epochs=4,                # Epochs per batch (reuse data)
    gamma=1.0,                   # No discounting (single turn)
    lam=0.95,                    # GAE lambda
    cliprange=0.2,               # PPO epsilon
    cliprange_value=0.2,         # Value function clipping
    vf_coef=0.1,                 # Value loss coefficient
    init_kl_coef=0.05,           # Initial KL penalty
    target_kl=6.0,               # Adaptive KL target
    whiten_rewards=True,         # Normalize advantages
    gradient_accumulation_steps=4,
    max_grad_norm=1.0,
)

ppo_trainer = PPOTrainer(config=ppo_config, model=model, tokenizer=tokenizer,
    dataset=prompt_dataset, data_collator=collator)

# Training loop
for batch in ppo_trainer.dataloader:
    # 1. Generate responses
    query_tensors = batch["input_ids"]
    response_tensors = ppo_trainer.generate(
        query_tensors, max_new_tokens=512, temperature=0.7, top_p=0.9, do_sample=True
    )
    # 2. Score with reward model
    texts = [tokenizer.decode(r, skip_special_tokens=True) for r in response_tensors]
    rewards = [torch.tensor(reward_model.score(q, r)) for q, r in zip(batch["query"], texts)]
    # 3. PPO update (handles KL, GAE, clipping internally)
    stats = ppo_trainer.step(query_tensors, response_tensors, rewards)
    # Monitor: stats["ppo/mean_scores"], stats["ppo/policy/approx_kl"]

重要なハイパーパラメータ

DPO — 直接選好最適化

動機

PPOは、4つのモデル（方策、参照モデル、報酬モデル、価値ヘッド）をメモリ上に必要とし、複雑なRLインフラを要するうえ、悪名高いほど不安定です。DPO (Rafailov et al. 2023) は、次の問いを投げかけます。RLを省略し、選好から直接学習できないか？

重要な洞察 ：RLHFの目的関数（報酬最大化＋KLペナルティ）のもとでの最適方策には、 閉形式の解 があります。この同じ目的関数を暗黙に最適化する教師あり損失を導出できます。

数学的導出

ステップ1 ：RLHFの目的関数：\(\max_\pi \mathbb{E}_{x,y\sim\pi}[r(x,y)] - \beta D_\text{KL}[\pi\\vert \pi_\text{ref}]\)

ステップ2 ：最適解は次のとおりです：\(\pi^*(y\vert x) = \frac{1}{Z(x)} \pi_\text{ref}(y\vert x) \exp\left(\frac{r(x,y)}{\beta}\right)\)

ステップ3 ：報酬を方策で表すように整理します：\(r(x,y) = \beta \log \frac{\pi^*(y\vert x)}{\pi_\text{ref}(y\vert x)} + \beta \log Z(x)\)

ステップ4 ：Bradley-Terry選好モデル \(P(y_w \succ y_l) = \sigma(r(y_w) - r(y_l))\) に代入します。\(Z(x)\) は相殺されます。

\[ \boxed{\mathcal{L}_\text{DPO}(\theta) = -\mathbb{E}_{(x, y_w, y_l)}\left[\log\sigma\left(\beta\log\frac{\pi_\theta(y_w|x)}{\pi_\text{ref}(y_w|x)} - \beta\log\frac{\pi_\theta(y_l|x)}{\pi_\text{ref}(y_l|x)}\right)\right]} \]

Tip

DPOが実際に行っていること

暗黙の報酬 を \(\hat{r}(x,y) = \beta\log\frac{\pi_\theta(y\vert x)}{\pi_\text{ref}(y\vert x)}\) と定義します。

DPOは、「選ばれた応答の暗黙の報酬は、棄却された応答より高い」という「ラベル」を使った交差エントロピー損失を最小化します。マージンは \(\beta\) によって制御されます。

• 大きな \(\beta\)：大きなマージンが必要 \(\rightarrow\) 方策が積極的に移動 \(\rightarrow\) 忘却のリスク

• 小さな \(\beta\)：小さなマージンで十分 \(\rightarrow\) 方策が参照モデルの近くにとどまる \(\rightarrow\) 保守的

参照モデルは正則化器として機能します。方策は、選好への整合を示すことで、参照モデルからのあらゆる逸脱を「正当化」しなければなりません。

勾配の分析

DPOの勾配は次のように分解できます。

\[ \nabla_\theta \mathcal{L} = -\beta \cdot \underbrace{\sigma(-\hat{r}_w + \hat{r}_l)}_{\text{weight: higher when model is wrong}} \cdot \left[\nabla_\theta \log\pi_\theta(y_w|x) - \nabla_\theta \log\pi_\theta(y_l|x)\right] \]

解釈 ：勾配は、選ばれた応答の確率を上げ、棄却された応答の確率を下げます。モデルが現在、誤った答えを好んでいるときに重みが最大になり、「混乱を招く」ペアに学習を集中させます。

Note

DPOの具体例

プロンプト ：「10歳の子どもに量子もつれを説明してください。」

選択された応答 （\(y_w\)）：「2枚の魔法のコインを持っていると想像してください。片方を投げて表が出ると、どれだけ離れていても、もう片方は瞬時に裏になります！」
\(\log\pi_\theta(y_w\vert x) = -15.3\)、\(\log\pi_\text{ref}(y_w\vert x) = -16.1\)

棄却された応答 （\(y_l\)）：「量子もつれとは、2つの粒子が相関した状態になり、一方の粒子の量子状態を独立には記述できなくなる現象です。」
\(\log\pi_\theta(y_l\vert x) = -12.8\)、\(\log\pi_\text{ref}(y_l\vert x) = -12.5\)

暗黙の報酬 ：\(\hat{r}_w = 0.1 \times ((-15.3) - (-16.1)) = 0.08\)、\(\hat{r}_l = 0.1 \times ((-12.8) - (-12.5)) = -0.03\)

損失への入力 ：\(\sigma(0.08 - (-0.03)) = \sigma(0.11) = 0.527\)

損失 ：\(-\log(0.527) = 0.64\) — モデルは選択された応答をわずかに好んでいるだけです。勾配は強く押し上げます。

学習後：マージンが \(1/(2\beta)\) 付近で安定するまで、選択された応答の確率が増加し、棄却された応答の確率が減少します。

TRLによる実装

以下は、HuggingFace TRLを使った最小限の動作例です。

from trl import DPOConfig, DPOTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig
from datasets import load_dataset

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B-Instruct",
    torch_dtype=torch.bfloat16, attn_implementation="flash_attention_2")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B-Instruct")

# Dataset format: {"prompt": str, "chosen": str, "rejected": str}
dataset = load_dataset("argilla/ultrafeedback-binarized-preferences")

lora_config = LoraConfig(r=64, lora_alpha=16, lora_dropout=0.05,
    target_modules=["q_proj","k_proj","v_proj","o_proj","gate_proj","up_proj","down_proj"])

dpo_config = DPOConfig(
    output_dir="./dpo_output",
    beta=0.1,                    # KL regularization strength
    learning_rate=5e-7,          # Very low LR for stability
    loss_type="sigmoid",         # Standard DPO loss
    max_length=2048,             # Max sequence length
    max_prompt_length=1024,      # Truncation for prompts
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,  # Effective batch = 16
    gradient_checkpointing=True,
    bf16=True,
    num_train_epochs=1,          # DPO overfits fast - 1 epoch!
    warmup_ratio=0.1,
    logging_steps=10,
    eval_strategy="steps",
    eval_steps=200,
    save_strategy="steps",
    save_steps=500,
)

trainer = DPOTrainer(
    model=model,
    ref_model=None,             # With LoRA, ref = base model (no copy needed!)
    args=dpo_config,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    tokenizer=tokenizer,
    peft_config=lora_config,
)
trainer.train()
# Key metrics to monitor: train/rewards/chosen, train/rewards/rejected, train/rewards/margins

DPOの仕組み：完全なメカニクス

この節では、DPOの計算の詳細、つまり学習中にトークンレベルで何が起きるのかを完全に説明します。

系列レベルの対数確率

DPOにおける重要な量は、 完全な系列 \(y = (y_1, y_2, \ldots, y_T)\) の、プロンプト \(x\) が与えられたときの対数確率です。これは、 トークンごとの対数確率の合計 として計算します。

\[ \boxed{\log \pi_\theta(y|x) = \sum_{t=1}^{T} \log \pi_\theta(y_t \mid x, y_{<t})} \]

各項 \(\log \pi_\theta(y_t \vert x, y_{<t})\) は、位置 \(t\) における、系列内の実際のトークン \(y_t\) のlog-softmax出力です。これは標準的な言語モデリングで使う交差エントロピー損失と同じですが、ここでは平均ではなく 合計 します。

重要な詳細 ：\(y_w\) と \(y_l\) の両方で、勾配は すべてのトークン位置 を通って流れます。中間トークンのマスクはありません。すべてのトークンが系列レベルの対数確率に寄与します。

DPO損失の分解

損失から始めます。

\[ \mathcal{L}_{\text{DPO}}(\theta) = -\mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}}!\left[\log \sigma!\left(\beta \cdot h_\theta(x, y_w, y_l)\right)\right] \]

ここで「暗黙の報酬マージン」\(h_\theta\) は次のとおりです。

\[ h_\theta(x, y_w, y_l) = \underbrace{\log \frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)}}_{\text{chosen reward proxy}} - \underbrace{\log \frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}}_{\text{rejected reward proxy}} \]

トークンレベルの項に展開すると、次のようになります。

\[ \boxed{h_\theta = \sum_{t=1}^{|y_w|}!\left[\log\pi_\theta(y_w^t | x, y_w^{<t}) - \log\pi_{\text{ref}}(y_w^t | x, y_w^{<t})\right] - \sum_{t=1}^{|y_l|}!\left[\log\pi_\theta(y_l^t | x, y_l^{<t}) - \log\pi_{\text{ref}}(y_l^t | x, y_l^{<t})\right]} \]

フォワードパス：ステップごとの処理

1つの学習例 \((x, y_w, y_l)\) に対して、次を行います。

1. 連結 ：2つの系列 \([x; y_w]\) と \([x; y_l]\) を作ります。バッチ内で長さがそろうようにパディングします。

2. フォワードパス（方策 \(\pi_\theta\)） ：両方の系列をモデルに通します。各応答位置のロジットを収集します。

3. 対数確率の抽出 ：応答の各位置 \(t\) で、\(\log\text{softmax}(\text{logits}_t)[y_t]\)、つまり実際のトークンの対数確率を取得します。

4. トークン上で合計 ：

\[ \begin{aligned} \text{logp_chosen} &= \sum_{t \in \text{response positions}} \log\pi_\theta(y_w^t | x, y_w^{<t}) \\ \text{logp_rejected} &= \sum_{t \in \text{response positions}} \log\pi_\theta(y_l^t | x, y_l^{<t}) \end{aligned} \]

5. 参照モデルを引く （事前計算済み、または2回目のフォワードパスから取得）：

\[ \begin{aligned} \text{ratio_w} &= \text{logp_chosen} - \text{ref_logp_chosen} \\ \text{ratio_l} &= \text{logp_rejected} - \text{ref_logp_rejected} \end{aligned} \]

6. 損失を計算 ：\(\mathcal{L} = -\log\sigma(\beta \cdot (\text{ratio_w} - \text{ratio_l}))\)

7. バックワードパス ：勾配がステップ5 \(\rightarrow\) 4 \(\rightarrow\) 3 \(\rightarrow\) 2 を逆向きに流れ、\(\theta\) を更新します。

トークンレベルの勾配分析

すべてのトークンに勾配が付くのか？ はい。選択された系列の位置 \(t\) におけるロジットに関する勾配は次のとおりです。

\[ \frac{\partial \mathcal{L}}{\partial \text{logits}_t^{(w)}} = -\underbrace{\sigma(-\beta \cdot h_\theta)}_{\text{scaling factor}} \cdot \beta \cdot \frac{\partial \log\pi_\theta(y_w^t | \cdot)}{\partial \text{logits}_t^{(w)}} \]

重要な洞察 ：\(\sigma(-\beta \cdot h_\theta)\) のスケーリング係数は、両方の系列のすべてのトークンで 共有 されます。これは適応的な学習率として機能します。

• \(h_\theta\) が小さい場合（モデルが選択された応答と棄却された応答を区別できない）：スケーリングは \(\approx 0.5\)。勾配が強く、積極的に学習します。

• \(h_\theta\) が大きい場合（モデルがすでに選択された応答を好んでいる）：スケーリングは \(\approx 0\)。勾配は無視できるほど小さくなり、過適合を防ぎます。

選択されたトークンへの効果 ：確率が増加します（対数確率が押し上げられます）。
棄却されたトークンへの効果 ：確率が減少します（対数確率が押し下げられます）。
参照モデルとの相対関係 ：\(\pi_{\text{ref}}\) との差だけが重要です。モデルがすでに選択された応答に高い確率を割り当てている場合（参照モデルと一致している場合）、勾配はほとんどありません。

トークン単位と系列単位：長さの正規化

微妙な問題があります。長い系列は、各項を合計するため自然に対数確率が低くなります（各項は \(\leq 0\)）。\(\vert y_w\vert \gg \vert y_l\vert\) の場合、損失が短い応答を好む方向に偏る可能性があります。

解決策 ：

• 長さを正規化したDPO ：\(\log\pi_\theta(y\vert x)\) を \(\frac{1}{\vert y\vert }\sum_t \log\pi_\theta(y_t\vert \cdot)\) に置き換えます。一部の実装で使われています（SimPOが採用）。

• 標準DPO ：生の合計（正規化なし）を使います。これは暗黙に冗長さを罰します。モデルは、選択された応答のすべてのトークンに高い確率を割り当てなければなりません。

• 実際の影響 ：ベンチマークでは、長さを正規化したDPOは長さの悪用を減らしますが、指示追従品質を損なうことがあります。標準（非正規化）DPOの方がプロダクションでは一般的です。

ラベルマスキング：どのトークンに勾配が付くか

Important

DPOで勾配を受け取るトークン

• プロンプトトークン （\(x\)）： 勾配なし 。損失は応答位置だけで計算されます。プロンプトトークンはコンテキストを提供しますが、そのロジットは \(\log\pi(y\vert x)\) に寄与しません。

• 選択された応答トークン （\(y_w\)）： すべてのトークンに勾配が付きます 。各 \(y_w^t\) が合計に寄与し、その確率を上げる方向に勾配が働きます。

• 棄却された応答トークン （\(y_l\)）： すべてのトークンに勾配が付きます 。各 \(y_l^t\) が合計に寄与し、その確率を下げる方向に勾配が働きます。

• パディングトークン ： 勾配なし 。アテンションマスクで除外されます。

疑似コード：DPO学習ステップ

Note

DPOのフォワード＋バックワード（PyTorch形式）

def dpo_loss(model, ref_model, batch, beta=0.1):
    """One DPO training step."""
    # batch contains: input_ids_chosen, input_ids_rejected,
    #                 labels_chosen, labels_rejected (prompt masked to -100)

    # 1. Forward pass: get per-token log-probs
    logps_chosen = get_sequence_logprob(model, batch["chosen"])
    logps_rejected = get_sequence_logprob(model, batch["rejected"])

    # 2. Reference log-probs (pre-computed or computed here)
    with torch.no_grad():
        ref_logps_chosen = get_sequence_logprob(ref_model, batch["chosen"])
        ref_logps_rejected = get_sequence_logprob(ref_model, batch["rejected"])

    # 3. Compute implicit reward margins
    chosen_rewards = beta * (logps_chosen - ref_logps_chosen)
    rejected_rewards = beta * (logps_rejected - ref_logps_rejected)

    # 4. DPO loss = -log(sigmoid(chosen_reward - rejected_reward))
    loss = -F.logsigmoid(chosen_rewards - rejected_rewards).mean()
    return loss

def get_sequence_logprob(model, sequences):
    """Sum of log-probs over response tokens only."""
    outputs = model(sequences["input_ids"], attention_mask=sequences["mask"])
    logits = outputs.logits[:, :-1, :]  # Shift for next-token prediction

    # Gather log-prob of actual tokens
    labels = sequences["labels"][:, 1:]  # Shifted labels
    log_probs = F.log_softmax(logits, dim=-1)
    token_logps = log_probs.gather(-1, labels.unsqueeze(-1)).squeeze(-1)

    # Mask: only sum over response tokens (labels != -100)
    mask = (labels != -100).float()
    return (token_logps * mask).sum(dim=-1)  # Shape: [batch_size]

よくある落とし穴

Warning

DPO実装の落とし穴

• プロンプトのマスクを忘れる ：プロンプトトークンを対数確率の合計に含めると、モデルはプロンプトの尤度（役に立たないもの）を最適化し、実効的な \(\beta\) が誤ります。

• 合計ではなく平均を使う ：\(\frac{1}{T}\sum_t \log\pi\) と \(\sum_t \log\pi\) では、暗黙の長さペナルティが異なります。\(\pi_\theta\) と \(\pi_{\text{ref}}\) の間で一貫させなければなりません。

• 参照モデルが古い ：\(\pi_{\text{ref}}\) が \(\pi_\theta\) から遠すぎる場合（例：ベースモデル対ファインチューニング済みモデル）、KL項が支配的になり勾配が消えます。解決策は、ベースモデルではなくSFTチェックポイントを参照モデルとして使うことです。

• \(\beta\) が大きすぎる ：対数確率の差を増幅します \(\rightarrow\) sigmoidが飽和します \(\rightarrow\) 勾配がゼロになります。\(\beta = 0.1\) から始め、\([0.05, 0.5]\) の範囲で調整します。

• \(\beta\) が小さすぎる ：理論上は参照モデルからの自由度が増えます（KL制約が弱くなる）が、勾配 \(\propto \beta \cdot \sigma(-\beta h)\) が非常に小さくなります \(\rightarrow\) 損失地形が平坦になります \(\rightarrow\) 収束が極端に遅くなります。モデルには遠くへ移動する「許可」がある一方、どこへ移動すべきかを示すシグナルはほとんどありません。

DPOのバリアントとそれぞれが失敗する場合

Warning

DPOが失敗する場合

1. 分布シフト ：古いモデルから得た選好データを使います。現在の方策は異なるテキストを生成します \(\rightarrow\) 損失が無関係な例を最適化することになります。

2. 探索がない ：データセットにない振る舞いを発見できません。局所最適解にとどまります。

3. 参照モデルの崩壊 ：参照モデルが強すぎると、方策が動けません。弱すぎると、正則化がありません。

4. データ品質 ：ノイズのあるラベルが学習を汚染します。多くのサンプルで平均を取るPPOとは異なり、DPOは個々のペアを記憶します。

5. 選好データの多様性 ：選択／棄却ペアが、品質差の全範囲をカバーするようにします（単に良い対ひどいだけにしない）。品質だけでなくアプローチが異なるペアは、より豊かな方策の区別を教えます。

\(\beta\) の選択ガイド

DPOのバッチサイズ設定とスケーリング

単一系列のトークン予測を行う標準的なSFTとは異なり、DPOは、好ましい系列と好ましくない系列を比較する ペア単位の損失 を利用します。これにより、メモリ使用量と最適化の安定性が根本的に変わります。

グローバルバッチサイズの目標

DPO実装全体の経験的な証拠から、最適なグローバルバッチサイズの範囲が確立されています。

\[ \boxed{B_{\text{global}} \in [32, 128]} \]

• \(B_{\text{global}} < 32\)：暗黙の報酬推定における勾配ノイズが深刻になります \(\rightarrow\) 方策が、（有用性と安全性という）アラインメント目標の間で破壊的に振動します。

• \(B_{\text{global}} > 128\)：収束速度に対する限界効果が小さくなり、分散計算間の通信オーバーヘッドが大きくなります。

数学的分解

DPOは2つのモデルコピー（アクティブな方策 \(\pi_\theta\)＋凍結した参照モデル \(\pi_{\text{ref}}\)）を同時に読み込むため、系列あたりのメモリは2倍になります。グローバルバッチサイズは次のように分解されます。

\[ \boxed{B_{\text{global}} = B_{\text{micro}} \times N_{\text{GPUs}} \times K_{\text{accum}}} \]

• \(B_{\text{micro}}\)：デバイスごとのマイクロバッチサイズ（1回のフォワードパスにおける選好ペア数）。

• \(N_{\text{GPUs}}\)：並列データ処理デバイスの数。

• \(K_{\text{accum}}\)：重みを更新する前の勾配蓄積ステップ数。

ペアリングの倍率 ：1つのDPOデータインスタンスには、プロンプト（\(x\)）、選択された応答（\(y_w\)）、棄却された応答（\(y_l\)）が含まれます。マイクロバッチあたりの実際のテンソル負荷は次のとおりです。

\[ T_{\text{sequences}} = 2 \times B_{\text{micro}} \]

パラメータが\(>\)7Bのモデルを80GB GPU上で、コンテキスト長4096〜8192トークンで動かす場合、物理的な上限によって \(B_{\text{micro}} \in [1, 2]\) に厳しく制限されます。

分散スケーリングの設定

DPO学習の分散スケーリングプロファイル（\(B_{\text{global}} = 64\) を目標）。

VRAM最適化：参照モデルの対数確率を事前計算する

DPO損失は次のとおりです。

\[ \mathcal{L}_{\text{DPO}}(\theta) = -\mathbb{E}_{(x, y_w, y_l)}!\left[\log \sigma!\left(\beta \log \frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - \beta \log \frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}\right)\right] \]

\(\pi_{\text{ref}}\) は学習中 完全に静的 なので、その出力を事前計算できます。

Important

参照モデルを退避する戦略

1. 学習開始前に、データセット \(\mathcal{D}\) 上で \(\pi_{\text{ref}}\) だけを使ってフォワードパスを実行します。

2. スカラー \(\log \pi_{\text{ref}}(y_w\vert x)\) と \(\log \pi_{\text{ref}}(y_l\vert x)\) をディスクにキャッシュします。

3. \(\pi_{\text{ref}}\) をGPUメモリから完全に退避させます。

結果 ：利用可能なGPUメモリが2倍になります \(\rightarrow\) \(B_{\text{micro}}\) を1〜2から4〜8に増やせるため、ハードウェア利用率と学習スループットを最大化できます。

実装：TRLでは、DPOConfig に precompute_ref_log_probs=True を設定します。70Bモデルでは、クラスタ全体で\(\sim\)140GBのGPUメモリを節約できます。

DPOの拡張とバリアント

直接選好最適化（DPO）は、報酬関数と最適方策の間の閉形式の対応関係を導出することで、RLHFを教師あり学習問題として再定式化します。標準DPOの損失は次のとおりです。

\[ \mathcal{L}_{\text{DPO}}(\theta) = -\mathbb{E}_{(q,y_w,y_l)}!\left[ \log \sigma!\left( \beta \log \frac{\pi_\theta(y_w|q)}{\pi_{\text{ref}}(y_w|q)} - \beta \log \frac{\pi_\theta(y_l|q)}{\pi_{\text{ref}}(y_l|q)} \right) \right], \]

ここで \(y_w\) は好ましい（勝った）応答、\(y_l\) は好ましくない（負けた）応答、\(\beta\) はKLペナルティの強さを制御します。以下の小節では、最も重要な拡張とバリアントを扱います。

f-DPO — 一般化されたfダイバージェンスDPO

Tip

逆方向KLを超えて

標準DPOは、方策と参照モデルの間の正則化器として逆方向KLダイバージェンスを使います。逆方向KLはモードを探す性質があり、確率質量を少数の高報酬応答に集中させることを好みます。順方向KLはモードをカバーする性質があり、もっともらしい応答をすべてカバーするよう確率質量を広げます。f-DPO (J. Wang et al. 2024) は任意のfダイバージェンスへ一般化し、実務者がこれらの振る舞いをトレードオフできるようにします。

f-DPOの損失は、対数比をfダイバージェンス生成関数の導関数に置き換えます。

\[ \mathcal{L}_{f\text{-DPO}} = -\mathbb{E}!\left[ f'!\left(\frac{\pi_\theta(y_w|q)}{\pi_{\text{ref}}(y_w|q)}\right) - f'!\left(\frac{\pi_\theta(y_l|q)}{\pi_{\text{ref}}(y_l|q)}\right) \right], \]

ここで \(f'\) はfダイバージェンス生成関数の導関数です。

Important

TRLにおけるfダイバージェンスの選択肢

• reverse_kl ：\(f'(u) = \log u\)。標準DPO。モードを探します。

• forward_kl ：\(f'(u) = -1/u\)。モードをカバーします。多様性が向上します。

• js_divergence ：\(f'(u) = \log(2u/(u+1))\)。モード探索とモードカバーのバランスを取ります。

• alpha_divergence ：\(f'(u) = u^{\alpha-1}\)。順方向KLと逆方向KLの間を補間します。

Note

TRLでのf-DPO

from trl import DPOConfig, DPOTrainer

# Jensen-Shannon divergence (balanced)
config = DPOConfig(
    f_divergence_type="js_divergence",
    beta=0.1,
)

# Alpha divergence (alpha=0: forward KL, alpha=1: reverse KL)
config_alpha = DPOConfig(
    f_divergence_type="alpha_divergence",
    f_alpha_divergence_coef=0.5,   # alpha parameter
    beta=0.1,
)

trainer = DPOTrainer(
    model=model,
    ref_model=ref_model,
    args=config,
    train_dataset=dataset,
)

Important

f-DPOを使う場合

• 多様性と品質のバランスが必要な場合は、 JSダイバージェンス を使います。

• 多様性が最優先の創造的なタスクには、 順方向KL を使います。

• 正解が1つのタスクには、 逆方向KL （標準DPO）を使います。

• alphaダイバージェンス を使うと、連続的に補間してトレードオフを調整できます。

Robust DPO — ロバストDPO

Tip

選好データのノイズのあるラベル

人間による選好のアノテーションにはノイズがあります。アノテーターは意見が一致しなかったり、間違えたり、選好／非選好のラベルを逆にしたりすることがあります。標準DPOはすべてのラベルを正解として扱うため、モデルがノイズに過適合する可能性があります。Robust DPO (Chowdhury et al. 2024) は、既知のノイズモデルのもとで損失を解析的にバイアス補正します。

各ラベルが確率 \(\epsilon\)（ノイズ率）で反転すると仮定します。バイアス補正後の損失は次のとおりです。

\[ \boxed{ \mathcal{L}_{\text{robust}} = \frac{(1-\epsilon),\mathcal{L}_{\text{DPO}}(y_w, y_l) - \epsilon,\mathcal{L}_{\text{DPO}}(y_l, y_w)}{1 - 2\epsilon}, } \]

ここで \(\mathcal{L}_{\text{DPO}}(y_w, y_l)\) は \(y_w\) を選好された応答として扱う標準DPO損失、\(\mathcal{L}_{\text{DPO}}(y_l, y_w)\) はラベルを反転した場合の損失です。この補正によって、ラベルノイズが導入するバイアスを取り除きます。

Important

ロバストDPOの直感

この式は、反転したラベルの寄与を「差し引く」線形結合です。\(\epsilon=0\) では標準DPOに戻ります。\(\epsilon=0.5\) では分母が0に近づきます。ラベルが完全なノイズになり、学習は不可能です。実際には、\(\epsilon \in [0.05, 0.2]\) で現実のアノテーションノイズの大部分をカバーできます。

Note

TRLでのロバストDPO

from trl import DPOConfig, DPOTrainer

config = DPOConfig(
    loss_type="robust",
    label_smoothing=0.1,   # corresponds to epsilon = 0.1
    beta=0.1,
)

trainer = DPOTrainer(
    model=model,
    ref_model=ref_model,
    args=config,
    train_dataset=dataset,
)

TR-DPO — 信頼領域DPO

Tip

古くなった参照モデルの問題

標準DPOは学習中ずっと固定された参照モデル \(\pi_{\text{ref}}\) を使います。方策 \(\pi_\theta\) が改善すると、KLペナルティ \(\beta \log(\pi_\theta/\pi_{\text{ref}})\) が大きくなり、やがて損失を支配して、それ以上の改善を妨げます。TR-DPO (Gorbatenko 2024) は、現在の方策を追跡するよう参照モデルを定期的に更新します。

TR-DPOは指数移動平均（EMA）を使って参照モデルを更新します。

\[ \pi_{\text{ref}}^{(t+1)} \leftarrow \alpha \cdot \pi_\theta^{(t)} + (1-\alpha) \cdot \pi_{\text{ref}}^{(t)}, \]

ここで \(\alpha \in (0,1)\) は混合係数です。これは \(T_{\text{sync}}\) 回の勾配ステップごとに適用します。

Note

TRLでのTR-DPO

from trl import DPOConfig, DPOTrainer

config = DPOConfig(
    loss_type="sigmoid",        # standard DPO loss
    sync_ref_model=True,        # enable TR-DPO
    ref_model_mixup_alpha=0.6,  # alpha: how much of current policy to mix in
    ref_model_sync_steps=512,   # T_sync: sync every 512 steps
    beta=0.1,
)

trainer = DPOTrainer(
    model=model,
    ref_model=ref_model,
    args=config,
    train_dataset=dataset,
)

Important

TR-DPOを使う場合

• 方策が初期参照モデルから大きく離れる長時間の学習。

• KLペナルティの支配によってDPO損失が早期に頭打ちになる場合。

• 現在の方策から新しい選好データを収集する反復的なDPOパイプライン。

• \(\alpha\) を1に近づけると参照モデルを速く更新し、0に近づけるとゆっくり更新します。

EXO — 厳密な最適化

Tip

DPOにおけるKLの方向の問題

DPOは逆方向KL制約のもとで最適方策を解くことから導出されます。しかし、結果として得られる損失は実際には報酬空間で順方向KL目的関数を最適化しており、方向が間違っています。EXO (Ji et al. 2024) は、アラインメントに理論的に正しい目的関数である、逆方向KLの確率マッチングを使ってこれを修正します。

EXOは、モデル分布と目標（報酬最適）分布の間の逆方向KLを最小化します。

\[ \mathcal{L}_{\text{EXO}} = \mathbb{E}_{y \sim \pi_\theta}!\left[ \log \frac{\pi_\theta(y|q)}{p^*(y|q)} \right], \]

ここで \(p^*(y\vert q) \propto \pi_{\text{ref}}(y\vert q) \exp(r(y,q)/\beta)\) は最適方策です。実際には、EXOは利用可能な選好ペアを使って次のように近似します。

\[ \mathcal{L}_{\text{EXO}} \approx -\mathbb{E}!\left[ \log \sigma!\left( \beta \log \frac{\pi_{\text{ref}}(y_w|q)}{\pi_\theta(y_w|q)} - \beta \log \frac{\pi_{\text{ref}}(y_l|q)}{\pi_\theta(y_l|q)} \right) \right]. \]

DPOと比べて、\(\pi_\theta\) と \(\pi_{\text{ref}}\) の役割が入れ替わっていることに注目してください。

Note

TRLでのEXO

from trl import DPOConfig, DPOTrainer

config = DPOConfig(
    loss_type="exo_pair",
    beta=0.1,
)

trainer = DPOTrainer(
    model=model,
    ref_model=ref_model,
    args=config,
    train_dataset=dataset,
)

NCA — ノイズ対照アラインメント

Tip

DPOにおける尤度崩壊

DPOの既知の失敗モードは尤度崩壊です。モデルは負けた応答の確率を下げることを学びますが、損失が気にするのは差だけなので、勝った応答の確率も下げてしまいます。NCA (H. Chen et al. 2024) は、これを防ぐために絶対尤度項を追加します。

NCAはアラインメントをノイズ対照推定として捉え直します。損失は3つの項を持ちます。

\[ \boxed{ \mathcal{L}_{\text{NCA}} = -\log \sigma(r_w) - \tfrac{1}{2}\log \sigma(-r_w) - \tfrac{1}{2}\log \sigma(-r_l), } \]

ここで \(r_y = \beta \log(\pi_\theta(y\vert q)/\pi_{\text{ref}}(y\vert q))\) は暗黙の報酬です。第1項は \(y_w\) に高い報酬を与えるよう促し、第2項と第3項は \(y_w\) と \(y_l\) の両方に高い報酬を与えることを罰します（崩壊を防ぎます）。

Note

TRLでのNCA

from trl import DPOConfig, DPOTrainer

config = DPOConfig(
    loss_type="nca_pair",
    beta=0.01,   # small beta: absolute likelihood term dominates
)

trainer = DPOTrainer(
    model=model,
    ref_model=ref_model,
    args=config,
    train_dataset=dataset,
)

Important

NCAを使う場合

• DPO学習中に勝った応答の確率が下がっている場合。

• 相対的な順位だけでなく、応答の絶対的な品質が重要なタスク。

• 絶対尤度項により大きな重みを与えるため、小さな \(\beta\)（例：0.01）を使います。

SLiC-HF — 系列尤度キャリブレーション

Tip

より単純な代替手段としてのヒンジ損失

DPOのlog-sigmoid損失は滑らかですが、マージンが大きい場合には収束が遅くなることがあります。SLiC-HF (Yao Zhao et al. 2023) はヒンジ損失を使います。これはマージンが閾値を超えると0になり、それ以外では線形になります。単純で高速であり、驚くほど競争力があります。

SLiC-HFの損失は次のとおりです。

\[ \mathcal{L}_{\text{SLiC}} = \max!\left(0,; \delta - \beta\log\frac{\pi_\theta(y_w|q)}{\pi_{\text{ref}}(y_w|q)} + \beta\log\frac{\pi_\theta(y_l|q)}{\pi_{\text{ref}}(y_l|q)} \right), \]

ここで \(\delta\) はマージンの閾値です。モデルが勝った応答と負けた応答の間にすでに \(\delta\) のマージンを割り当てている場合、損失は0になります。

Note

TRLでのSLiC-HF

from trl import DPOConfig, DPOTrainer

config = DPOConfig(
    loss_type="hinge",
    beta=0.1,
)

trainer = DPOTrainer(
    model=model,
    ref_model=ref_model,
    args=config,
    train_dataset=dataset,
)

Iterative RPO — 推論選好最適化

Tip

DPOは生成方法を忘れる

標準DPOは、勝った応答と負けた応答を識別するようモデルを学習します。しかし、推論タスクでは、モデルは正しい推論トレースを生成する必要もあります。識別できても生成できないモデルは、推論時には役に立ちません。RPOは勝った応答にNLL（負の対数尤度）項を追加し、モデルがそれを生成することを学ぶようにします。

RPOの損失は、DPOとSFTを組み合わせたものです。

\[ \mathcal{L}_{\text{RPO}} = \lambda_1 \mathcal{L}_{\text{DPO}}(y_w, y_l) + \lambda_2 \mathcal{L}_{\text{NLL}}(y_w), \]

ここで \(\mathcal{L}_{\text{NLL}}(y_w) = -\log \pi_\theta(y_w\vert q)\) は、勝った応答に対する標準的な言語モデリング損失です。

Note

TRLでのIterative RPO

from trl import DPOConfig, DPOTrainer

config = DPOConfig(
    loss_type="sigmoid",            # Standard DPO loss
    rpo_alpha=1.0,                  # NLL regularisation weight (RPO)
    beta=0.1,
)

trainer = DPOTrainer(
    model=model,
    ref_model=ref_model,
    args=config,
    train_dataset=dataset,
)

Important

RPOを使う場合

• モデルがステップごとの解を生成しなければならない推論タスク（数学、コード、論理）。

• DPO学習によって、モデルの流暢さや生成品質が失われる場合。

• 反復パイプライン：ロールアウトを生成し、ラベルを付け、RPOで学習し、繰り返します。

• NLL項が正則化器として機能し、方策の崩壊を防ぎます。

SimPO — 単純な選好最適化

Tip

参照モデルなしの選好学習

DPOは暗黙の報酬を計算するために参照モデルを必要とします。これによりメモリ使用量が2倍になり、複雑さも増します。SimPO (Meng et al. 2024) は、応答の平均対数確率を暗黙の報酬として使い、モデルが短い応答を好むことを防ぐ長さの正規化項を加えることで、参照モデルを取り除きます。

SimPOは暗黙の報酬を次のように定義します。

\[ r_{\text{SimPO}}(y|q) = \frac{\beta}{|y|} \log \pi_\theta(y|q), \]

損失は次のとおりです。

\[ \boxed{ \mathcal{L}_{\text{SimPO}} = -\mathbb{E}!\left[ \log \sigma!\left( \frac{\beta}{|y_w|}\log\pi_\theta(y_w|q) - \frac{\beta}{|y_l|}\log\pi_\theta(y_l|q) - \gamma \right) \right], } \]

ここで \(\gamma > 0\) は目標報酬マージンです。これにより、勝った応答の報酬が負けた応答より少なくとも \(\gamma\) だけ厳密に高くなることを保証します。

Important

SimPOとDPOとORPOの比較

• DPO ：参照モデルを使う。比に基づく暗黙の報酬。

• ORPO ：参照モデルなし。SFT損失にオッズ比項を追加。

• SimPO ：参照モデルなし。長さを正規化した対数確率の報酬＋マージン。

• SimPOはDPOより単純（参照モデルが不要）で、ORPOより原理に忠実です。

• SimPOの長さの正規化は重要です。これがないと、モデルは長い応答を好みます。

Note

TRLでのSimPO

from trl import DPOConfig, DPOTrainer

config = DPOConfig(
    loss_type="simpo",
    simpo_gamma=0.5,   # target reward margin gamma
    beta=2.5,          # length normalisation coefficient
    # No ref_model needed!
)

trainer = DPOTrainer(
    model=model,
    ref_model=None,    # SimPO is reference-free
    args=config,
    train_dataset=dataset,
)

GRPO — グループ相対方策最適化

グループ相対方策最適化（GRPO） (Shao et al. 2024) は、言語モデル向けに特別に設計された強化学習アルゴリズムです。別個の価値ネットワーク（クリティック）を不要にします。DeepSeekMathの一部としてDeepSeekが導入し、その後DeepSeek-R1 (DeepSeek-AI et al. 2025) へスケールされたGRPOは、LLM学習の主流RL手法へ急速に成長しました。TRL、OpenRLHF、veRLなど、ほとんどのオープンソースのアラインメント・フレームワークがデフォルトアルゴリズムとして採用しています。

中核となる考え方は、単純に見えて実は巧妙です。PPOのクリティックのように期待報酬を予測するニューラルネットワークを学習する代わりに、同じプロンプトへ複数の応答を生成し、グループの報酬統計をベースラインとして使うことで、経験的にそれを推定します。これによりメモリ上のモデルが1つ減り、エンジニアリングの複雑さが半減します。さらに意外なことに、経験的なベースラインは、十分に学習されていない価値関数より正確なため、PPOを上回ることもあります。

GRPOは特に次の用途で有効です。

• 検証可能な報酬を持つ推論タスク （数学、コード）。二値の正誤が明確なシグナルを与えます。

• 大規模モデル （70B以上）。クリティックを取り除くことによるメモリ節約が重要になります。

• マルチターンおよびエージェント環境 。ツール呼び出しをまたいだ価値推定は扱いにくいためです。

この章では、GRPOの動機、アルゴリズム、主要なバリアント（Dr. GRPO、DAPO、2-GRPO、GDPO）、そしてTRLを使った実装を扱います。

動機

PPOの価値モデル（クリティック）には、言語モデルにとって3つの大きな問題があります。

1. メモリ ：価値ヘッドは方策のバックボーンを共有します（70Bでは140GB）。別個に持つとメモリが2倍になります。

2. 正確さ ：部分系列に対する期待報酬の予測は極めて困難です。価値関数はしばしば間違います \(\rightarrow\) 間違ったアドバンテージ \(\rightarrow\) 間違った勾配方向。

3. 学習 ：価値ヘッドの収束には多くのサンプルが必要です。RL初期にはノイズの多い予測を出し、方策学習を不安定にします。

GRPOの重要な洞察 (Shao et al. 2024)：\(V(s)\) を学習する代わりに、サンプルのグループから経験的に推定します。同じプロンプトに対して \(G\) 個の応答を生成し、それらの報酬を計算して、グループ統計をベースラインとして使います。

アルゴリズム

1. 各プロンプト \(x\) について、\(G\) 個の完了をサンプリングします：\(\{y_1, \ldots, y_G\} \sim \pi_\theta(\cdot\vert x)\)

2. それぞれを採点します：\(r_i = R(x, y_i)\)

3. グループ内で正規化します：\(\hat{A}_i = \frac{r_i - \mu_G}{\sigma_G}\)。ここで \(\mu_G = \frac{1}{G}\sum_j r_j\)、\(\sigma_G = \text{std}(\{r_j\})\) です。

4. これらのアドバンテージを使って、PPO形式のクリップ付き更新を適用します。