【ゼロから創る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でのシェア、感想のコメントをいただけますと大変励みになります。
また次の技術解説記事でお会いしましょう!
ここまで読んでくれてありがとうございます。
おそらく専門知識ばかりでよくわからない人がいると思います。
小学生でもわかるようにまとめた記事があります。
どうぞこちらへ