メインコンテンツへスキップ

【ゼロから創るLLM】第4回:モデルに「対話力」を吹き込む。SFTとDPO(Direct Preference Optimization)の理論とPyTorch完全実装【スタンフォードCS336解説】

    「ただの文章補完マシン」から「優秀なAIアシスタント」へ

    ​連載第1回から第3回にかけて、私たちはLLM(大規模言語モデル)の土台をゼロから築き上げてきました。

    ​・第1回:テキストを数値化する「BPEトークナイザー」の完全自作

    ・第2回:モダンTransformer(RMSNorm, RoPE, GQA, SwiGLU)のPyTorch構築

    ・第3回:GPUメモリ計算・混合精度学習(AMP)・分散学習(DP/TP)の最適化

    ​これらを用いて数千億〜数兆トークンのWEBテキストを学習(事前学習:Pre-training)させると、強力なベースモデル(Base Model)が完成します。

    ​しかし、完成したベースモデルに「東京のおすすめの観光スポットを教えてください」と話しかけても、AIアシスタントのように親切に答えてはくれません。

    ベースモデルは「確率的に最も続きそうな文章を補完する」ことしか学んでいないため、以下のような予期せぬ出力を返してしまうのです。

    ​・入力:「東京のおすすめの観光スポットを教えてください」

    ・ベースモデルの返答例1:「また、京都や大阪のおすすめスポットについても知りたいです。」(質問を連鎖させてしまう)

    ・ベースモデルの返答例2:「質問者:山田太郎 / 投稿日:2026年10月」(掲示板の続きを再現してしまう)

    ​ベースモデルを、人間の指示を正確に理解し、安全かつ親切に回答する「対話型AIアシスタント(Instruction-following AI)」へと進化させるプロセス。それこそが本連載の最終章、アライメント(Alignment:調整)です。

    ​今回は、現代のアライメントの主流手法であるSFT(Supervised Fine-Tuning)と、従来の複雑な強化学習(RLHF)を過去のものにした革新技術DPO(Direct Preference Optimization)の理論およびPyTorchによる完全実装を解説します。

    ​全4回の連載ロードマップ(完結)

    ​第1回:トークナイザー(BPE)の仕組みとゼロからの実装

    ​第2回:モダンTransformer(GQA, RoPE, SwiGLU, RMSNorm)のPyTorch実装

    ​第3回:GPUメモリ計算・混合精度学習・分散学習(DP / TP)のインフラ技術

    ​第4回(本日):対話型AIに進化させるアライメント(SFT / DPO)の実装

    ​第1章:SFT(Supervised Fine-Tuning:教師あり微調整)

    ​1.1 SFTの目的と対話フォーマット(Chat Template)

    ​アライメントの第1段階はSFT(Supervised Fine-Tuning)です。

    ​SFTの目的は、ベースモデルに対して「人間とAIの対話形式(プロンプトとレスポンス)の作法」を叩き込むことです。

    ​事前に作成された数万〜数十万件の高品質な「指示文(Prompt)と模範解答(Response)」のペアデータセットを使ってモデルを微調整します。

    ​この際、モデルが「どこまでがユーザーの発言で、どこからがAIの返答か」を識別できるように、特殊な制御トークン(Special Tokens)を用いたチャットフォーマット(Chat Template)を構成します。

    ​・標準的なチャットフォーマット構造例(ChatML形式など):

    <|im_start|>user

    Pythonで階乗を計算する関数を書いてください。<|im_end|>

    <|im_start|>assistant

    以下がPythonで階乗を計算する再帰関数です。

    ​def factorial(n):

    if n == 0 or n == 1:

    return 1

    return n * factorial(n - 1)

    <|im_end|>

    ​1.2 SFTにおける重要ポイント:「プロンプト部分のLossマスク」

    ​SFTを正しく実装するうえで、最も重要かつ間違いやすい技術的ポイントが「損失計算時のプロンプトマスク(Prompt Masking)」です。

    ​通常の事前学習では、系列内のすべてのトークンに対して予測の損失(Cross-Entropy Loss)を計算します。

    しかし、SFTにおいて「ユーザーの入力文(プロンプト)」は学習データとして与えられたものであり、モデルに予測させたい対象ではありません。

    ​モデルに学習させたいのは「特定のプロンプトが与えられたときの、最適なアシスタントの返答(レスポンス)」だけです。

    ​そのため、プロンプトに該当するトークンのラベル(Target ID)を PyTorch の損失計算無視インデックスである -100 に置き換え、アシスタントの返答部分のトークンだけに勾配を流す(Lossを計算する)処理を行います。

    ​・プロンプトマスクの概念図:

    入力トークン: [User: Pythonで関数書いて] [Assistant: 以下がコードです]

    ターゲットID: [ -100, -100, -100, -100 ] [ 1024, 3812, 491, 8820 ]

           ↑プロンプト部はLoss計算から除外 ↑この部分のみLossを計算

    ​第2章:強化学習(RLHF)の限界と DPO の登場

    ​2.1 SFTだけでは到達できない「好みの壁」

    ​SFTを終えたモデルは、丁寧な対話形式で回答できるようになります。しかし、SFTには限界が存在します。

    ​ハルシネーション(嘘の記述)や冗長性の制御が困難

    SFTは「正解の文章」を丸暗記させる学習に近いため、「言い回しが回りくどい」「少し嘘が混ざっているが文法は正しい」といった微細な出力品質のコントロールが苦手です。

    ​「悪い回答」を学ばせることができない

    SFTは「良い回答」しか学習データに含められません。しかし、「有害な回答」「間違った推論手順」を明確に「やってはいけない」と拒絶させるには、良い回答と悪い回答の比較(人間による選好データ)を与える学習が必要になります。

    ​2.2 従来のRLHF(PPO)が抱えていた巨大な壁

    ​そこで登場したのが、人間のフィードバックによる強化学習(RLHF: Reinforcement Learning from Human Feedback)です。

    OpenAIのChatGPT(InstructGPT)のブレイクスルーを支えた技術として有名になりました。

    ​しかし、従来のRLHF(特にPPOアルゴリズムに基づく手法)は、開発現場において「悪夢のように複雑で不安定」でした。

    ​・従来のRLHF(PPO)で同時にVRAM上に保持・学習が必要なモデル:

    ​Policy Model(アクター): 応答を生成する学習対象モデル

    ​Reference Model: 過度な方針変化を防ぐための固定基本モデル

    ​Reward Model(報酬モデル): 人間の選好度をスコア化するモデル

    ​Value Model(クリティック): 強化学習の価値関数を推定量化するモデル

    ​単一のLLMを動かすだけでも数GB〜数十GBのVRAMが必要な時代に、4つもの巨大モデルを同時にGPUに載せて複雑な強化学習ループ(PPO)を安定して回すことは、一部の超巨大テック企業以外には不可能な芸芸でした。

    ​2.3 DPO(Direct Preference Optimization)の革命

    ​2023年、スタンフォード大学の Rafailov 氏らによって発表された論文『Direct Preference Optimization: Your Language Model is Secretly a Reward Model』が、この状況を劇的に変えました。それがDPO(Direct Preference Optimization)です。

    ​DPOの数学的発見は非常にエレガントです。

    ​「最適制御理論の数学的展開により、強化学習における『報酬関数(Reward Model)』は、ポリシーモデル(Policy Model)自身の出力確率の比率(対数尤度比)を使って直接表現できる」

    ​つまり、独立した報酬モデル(Reward Model)も、複雑な強化学習アルゴリズム(PPO)も一切不要。

    選好データ(「良い回答 y_w」と「悪い回答 y_l」のペア)に対する単純な分類損失関数(Binary Cross-Entropy)を直接最適化するだけで、理論上RLHFと完全に数学的に同等(それ以上)のアライメント結果が得られることが証明されたのです。

    ​第3章:DPOの数学的アプローチと損失関数

    ​3.1 選好データセットの構造

    ​DPOで必要となるデータセットは、1つのプロンプト x に対して、人間の評価によって順位付けされた2つの回答から構成されます。

    ​・プロンプト (x): 「Pythonで配列をソートする方法は?」

    ・選択された良い回答 (y_w: Chosen Response): 「sorted()関数または.sort()メソッドを使用します。具体例は…」

    ・棄却された悪い回答 (y_l: Rejected Response): 「配列はソートできません。自作のループで頑張って並べ替えてください。」

    ​3.2 DPOの損失関数(Loss Function)

    ​DPOの目的関数(Loss Function)の数式は以下のように定義されます。

    ​・DPO損失関数:

    L_DPO(π_θ; π_ref) = - E_(x, y_w, y_l) [ log σ ( β * ( log(π_θ(y_w|x) / π_ref(y_w|x)) - log(π_θ(y_l|x) / π_ref(y_l|x)) ) ) ]

    ​一見複雑に見えるこの数式を分解して理解しましょう。

    ​\pi_\theta と \pi_{\text{ref}}:

    ・\pi_\theta: 現在学習中のポリシーモデル(Policy Model)

    ・\pi_{\text{ref}}: 事前学習/SFT直後の固定参照モデル(Reference Model:変化しすぎを防ぐアンカー)

    ​対数尤度比(Log-Likelihood Ratio):

    ・log( π_θ(y_w|x) / π_ref(y_w|x) ): 良い回答 y_w に対する「参照モデルからの確率の上昇度」

    ・log( π_θ(y_l|x) / π_ref(y_l|x) ): 悪い回答 y_l に対する「参照モデルからの確率の上昇度」

    ​差分とハイパーパラメータ \beta:

    ・差分をとることで、「良い回答の確率上昇度」が「悪い回答の確率上昇度」を上回るようにモデルを誘導します。

    ・\beta(通常 0.1 〜 0.5 に設定): 参照モデル \pi_{\text{ref}} から離れすぎないように制御するKLダイバージェンス正則化の強度パラメータ。

    ​シグモイド関数 \sigma と負の対数:

    ・差分が大きくなる(=良い回答を選択し、悪い回答を退ける傾向が強まる)ほど、損失 L_{\text{DPO}} が 0 に近づきます。

    ​第4章:PyTorchでDPO損失関数をゼロから完全実装する

    ​それでは、このDPOの損失計算をPyTorchの関数として自作してみましょう。

    外部の巨大ライブラリ(trl や alignment-handbook 等)の内部で何が行われているかが一目瞭然になります。

    ​4.1 トークンごとの対数確率(Log Probabilities)の抽出

    ​DPOを計算するためには、モデルが出力したLogits(未正規化の出力確率)から、実際の正解トークン系列に対する「対数確率の和(Sequence Log-Probability)」を算出するヘルパー関数が必要です。


    import torch

    import torch.nn as nn

    import torch.nn.functional as F


    def get_batch_logps(

        logits: torch.Tensor, 

        labels: torch.Tensor, 

        label_pad_token_id: int = -100

    ) -> torch.Tensor:

        """

        モデルのLogitsとラベルから、レスポンス部分の各トークン対数確率の和を計算する

        

        logits: [batch_size, seq_len, vocab_size]

        labels: [batch_size, seq_len] (-100 の位置はマスク対象)

        """

        # 最後のトークンのLogitsは次のトークンを予測するため、1つずらす

        shift_logits = logits[:, :-1, :].contiguous()

        shift_labels = labels[:, 1:].contiguous()


        # マスクの作成 (-100 以外のトークン位置が True)

        loss_mask = (shift_labels != label_pad_token_id)

        

        # マスク用のダミーとして -100 を 0 に置き換える (gatherでのエラー回避)

        dummy_labels = shift_labels.clone()

        dummy_labels[~loss_mask] = 0


        # 各位置の実際のトークンに対応する Log-Softmax 確率を抽出

        # shift_logits: [batch, seq_len, vocab_size] -> log_softmax

        log_probs = F.log_softmax(shift_logits, dim=-1)

        

        # 選択されたトークンの対数確率を取得: [batch, seq_len]

        per_token_logps = torch.gather(

            log_probs, 

            dim=-1, 

            index=dummy_labels.unsqueeze(-1)

        ).squeeze(-1)


        # パディング/プロンプト部分を 0 でマスクして和をとる

        return (per_token_logps * loss_mask).sum(dim=-1)


    4.2 DPO Lossの計算クラス

    ​上記のヘルパー関数を用いて、DPO損失を計算するメイン処理を実装します。

    class DPOLoss(nn.Module):

        def __init__(self, beta: float = 0.1, label_pad_token_id: int = -100):

            super().__init__()

            self.beta = beta

            self.label_pad_token_id = label_pad_token_id


        def forward(

            self,

            policy_chosen_logps: torch.Tensor,

            policy_rejected_logps: torch.Tensor,

            reference_chosen_logps: torch.Tensor,

            reference_rejected_logps: torch.Tensor,

        ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:

            """

            DPO Loss と 報酬インジケーターを計算する

            """

            # ポリシーモデルの対数比 (Chosen - Rejected)

            policy_logratios = policy_chosen_logps - policy_rejected_logps

            # リファレンスモデルの対数比 (Chosen - Rejected)

            ref_logratios = reference_chosen_logps - reference_rejected_logps


            # DPO 内部のロジット差分

            logits = policy_logratios - ref_logratios


            # DPO Loss: -log(sigmoid(beta * logits))

            losses = -F.logsigmoid(self.beta * logits)


            # 暗黙の報酬 (Implicit Reward) の計算 (モニタリング用)

            chosen_rewards = self.beta * (policy_chosen_logps - reference_chosen_logps).detach()

            rejected_rewards = self.beta * (policy_rejected_logps - reference_rejected_logps).detach()


            return losses.mean(), chosen_rewards.mean(), rejected_rewards.mean()



    # ==========================================

    # 動作確認・テストスクリプト

    # ==========================================

    if __name__ == "__main__":

        print("=== DPO Loss 計算テスト開始 ===")


        # ダミーのデータ準備 (バッチサイズ: 2)

        beta = 0.1

        dpo_loss_fn = DPOLoss(beta=beta)


        # 1. 理想的な状況:ポリシーモデルがChosenの確率を高め、Rejectedの確率を下げた場合

        policy_chosen_logps = torch.tensor([-12.5, -15.0]) # 良い回答の対数確率(高め)

        policy_rejected_logps = torch.tensor([-30.0, -35.0]) # 悪い回答の対数確率(低め)


        reference_chosen_logps = torch.tensor([-20.0, -20.0]) # リファレンスモデル

        reference_rejected_logps = torch.tensor([-20.0, -20.0])


        loss, chosen_reward, rejected_reward = dpo_loss_fn(

            policy_chosen_logps,

            policy_rejected_logps,

            reference_chosen_logps,

            reference_rejected_logps

        )


        print(f"計算された DPO Loss: {loss.item():.4f}")

        print(f"Chosen (良い回答) の平均報酬: {chosen_reward.item():.4f}")

        print(f"Rejected (悪い回答) の平均報酬: {rejected_reward.item():.4f}")

        print(f"報酬差分 (Reward Margin): {(chosen_reward - rejected_reward).item():.4f}")


        assert loss.item() < 0.2, "Lossが十分に低くなっていません"

        assert chosen_reward > rejected_reward, "Chosenの報酬がRejectedを下回っています"

        print("\n✅ テスト成功:DPO Lossの正常な計算を確認しました。")


    第5章:連載総括:ゼロからLLMを創り上げたあなたへ

    ​全4回の連載、本当にお疲れ様でした!

    私たちは、スタンフォード大学CS336の本格的なカリキュラムをベースに、LLMの全工程をコードと論理で走破しました。

    ​ここで、私たちが到達した広大なロードマップをもう一度振り返ってみましょう。

    ​トークナイザー自作(第1回)

    ・文字列をUTF-8バイトに分解し、Byte-level BPEによって未知語ゼロの数値を生成する仕組みを習得しました。

    ​モダンTransformer構築(第2回)

    ・2017年のVaswaniスタイルを超え、RMSNorm, RoPE, GQA, SwiGLUといった現代最前線のコンポーネントをPyTorchで組み上げました。

    ​インフラ・GPUメモリ最適化(第3回)

    ・112GBのVRAM計算のカラクリ、混合精度学習(AMP/BF16)、グラディエント・チェックポインティング、そしてZeROやテンソル並列(TP)によるスケールアウト手法をマスターしました。

    ​アライメント(第4回)

    ・プロンプトマスクを用いたSFTと、複雑な強化学習を廃して数学的エレガンスで対話力を与えるDPO(Direct Preference Optimization)の実装を完了しました。

    ​最後に:APIを呼ぶ開発者から「LLMを創造・最適化する開発者」へ

    ​AI技術の進化は目覚ましく、毎月のように新しいモデルやフレームワークが登場します。

    ​しかし、ブラックボックスの裏側にある「トークナイズ」「テンソル演算」「メモリ計算」「アライメントの数学」を自らの手で記述した経験があるあなたにとって、今後登場する新しい技術はもはや「魔法」ではありません。

    ​「この新モデルはGQAのヘッド比率を変えたんだな」

    「この新手法はDPOの損失関数に正則化項を追加したものだな」

    ​そうやって、論文の数式や新しいライブラリの本質をコードレベルで即座に理解し、自らのプロジェクトへ応用・最適化できる真の技術的基盤が、あなたの中に完成したのです。

    ​ぜひ、この知識を胸に、独自の自作モデル開発や高度なAIアプリケーションの構築に挑戦してみてください!

    ​連載を最後までお読みいただき、本当にありがとうございました。

    記事への「スキ」や、SNSでのシェア、感想のコメントをいただけますと大変励みになります。

    ​また次の技術解説記事でお会いしましょう!


    ここまで読んでくれてありがとうございます。

    おそらく専門知識ばかりでよくわからない人がいると思います。

    小学生でもわかるようにまとめた記事があります。

    どうぞこちらへ



     
     
    WebアプリやAIプロダクトを開発・運用する独立系ソフトウェアエンジニア。Next.js/TypeScript/Pythonを活用した開発ノウハウ、AIアライメント、個人開発のマネタイズ実践知を発信しています。

    あなたへのおすすめ