DPO（Direct Preference Optimization）論文深掘り分析 — RLHFなしでLLMをアラインメントする

• はじめに: なぜ DPO なのか
• 1. RLHF の構造と限界
  • 1.1 RLHF の 3 段階パイプライン
  • 1.2 RLHF の実務上の限界
• 2. DPO の数学的原理
  • 2.1 出発点: RLHF 目的関数の Closed-Form 解
  • 2.2 報酬関数の再パラメータ化 (Reward Reparameterization)
  • 2.3 Bradley-Terry モデルと DPO 損失関数の導出
  • 2.4 DPO 損失関数の直観的な解釈
• 3. RLHF vs DPO の学習パイプライン比較
  • 3.1 パイプライン構造の比較
  • 3.2 学習フローの比較コード
• 4. DPO の PyTorch 実装
  • 4.1 DPO 損失関数を自前で実装する
  • 4.2 Log Probability 計算のユーティリティ
  • 4.3 Hugging Face TRL を活用した実践的な DPO 学習
• 5. DPO の派生手法の比較: IPO, KTO, ORPO
  • 5.1 IPO (Identity Preference Optimization)
  • 5.2 KTO (Kahneman-Tversky Optimization)
  • 5.3 ORPO (Odds-Ratio Preference Optimization)
  • 5.4 総合比較テーブル
• 6. 実験結果の分析とベンチマーク
  • 6.1 DPO 論文の主な実験結果
  • 6.2 分布シフト (Distribution Shift) の実験
  • 6.3 ベンチマーク結果のまとめ
• 7. 実務適用時の注意点
  • 7.1 データセット構成の戦略
  • 7.2 ハイパーパラメータのチューニングガイド
  • 7.3 よくある失敗パターンと解決策
• 8. DPO の限界と今後の研究の方向
  • 8.1 知られている限界
  • 8.2 今後の研究の方向
• 9. 結論
• References

はじめに: なぜ DPO なのか

2023 年に ChatGPT が世界を変えたことで、LLM を人間の意図に合わせる alignment(整合)技術が中心的な課題として浮上した。OpenAI の InstructGPT が確立した RLHF(Reinforcement Learning from Human Feedback)パイプラインは強力だが、別途の報酬モデル学習と PPO 強化学習という複雑な 2 段階を経る必要がある。この過程では 4 個のモデルを同時に GPU メモリへ載せなければならず、数多くのハイパーパラメータをチューニングする必要があり、学習の不安定さにも悩まされる。

Rafailov et al. が 2023 年の NeurIPS で発表した Direct Preference Optimization(DPO)は、この問題に数学的に優雅な解法を示した。中心的な洞察は単純である。RLHF の報酬関数の最適化問題には closed-form 解が存在し、これを使えば報酬モデルなしに選好データから直接ポリシーを最適化できる。論文のタイトルそのままに、「あなたの言語モデルは実は報酬モデルである(Your Language Model is Secretly a Reward Model)」というわけだ。

本記事では、DPO 論文の数学的な導出過程を最初から最後まで追いながら、RLHF との構造的な違い、PyTorch での実装、派生手法(IPO, KTO, ORPO)の比較、実験結果の分析、そして実務適用時の注意点まで漏れなく扱う。

1. RLHF の構造と限界

1.1 RLHF の 3 段階パイプライン

RLHF は次の三つの段階で構成される。

ステップ 1 - SFT(Supervised Fine-Tuning): 高品質な instruction-response の対で base model をファインチューニングし、基本的な instruction following 能力を与える。

ステップ 2 - Reward Model の学習: 同じプロンプト $x$ に対して二つの応答 $y_w$(chosen), $y_l$(rejected) を収集し、Bradley-Terry モデルに基づいて報酬関数 $r_\phi(x, y)$ を学習する。

ステップ 3 - PPO の最適化: 学習された報酬モデルのスコアを最大化しつつ、reference policy $\pi_{\text{ref}}$ との KL divergence で制約する。

1.2 RLHF の実務上の限界

70B モデル基準で、RLHF パイプラインには A100 80GB GPU が最低 8 枚以上必要になる。こうした限界が、DPO など RL-free なアラインメント手法が登場した背景である。

2. DPO の数学的原理

2.1 出発点: RLHF 目的関数の Closed-Form 解

DPO の導出は、RLHF 目的関数の解析的な解法から始まる。RLHF の KL 制約付き報酬最大化問題を書き直すと次のようになる。

この問題の最適ポリシー $\pi^*$ は解析的に求められる。

ここで $Z(x) = \sum_y \pi_{\text{ref}}(y|x) \exp\left(\frac{r(x,y)}{\beta}\right)$ は正規化定数(partition function)である。

2.2 報酬関数の再パラメータ化 (Reward Reparameterization)

上の最適ポリシーの式の両辺に対数を取り、$r(x,y)$ について整理すると次のようになる。

これが DPO の中心的な洞察である。報酬関数を最適ポリシーと参照ポリシーの対数比で表現できる。つまり、報酬モデルを明示的に学習しなくても、ポリシー自体が報酬関数を暗黙的に含んでいる。

2.3 Bradley-Terry モデルと DPO 損失関数の導出

人間の選好をモデリングする Bradley-Terry モデルは次のとおりである。

ここで $\sigma$ はシグモイド関数である。ここで、再パラメータ化された報酬関数を Bradley-Terry モデルへ代入する。

驚くべきことに $\beta \log Z(x)$ の項が相殺される。この相殺こそが DPO を可能にする数学的な核心だ。扱いにくい partition function が取り除かれ、選好確率がポリシーの比だけで表現される。

これを最尤推定(MLE)として学習すると、最終的な DPO 損失関数が導かれる。

2.4 DPO 損失関数の直観的な解釈

DPO 損失関数の勾配を分析すると次のようになる。

ここで $\hat{r}_\theta(x, y) = \beta \log \frac{\pi_\theta(y|x)}{\pi_{\text{ref}}(y|x)}$ は暗黙的な報酬である。

この勾配は二つの役割を同時に果たす。

1. chosen 応答の確率を高め、rejected 応答の確率を下げる (角括弧の中の項)
2. モデルがすでに正しく区別できている対には小さい重みを、誤って区別している対には大きい重みを与える (シグモイドの項)

この動的な重み付けが、naive な確率比の最適化で生じるモデルの退化(degeneration)を防ぐ中心的な仕掛けである。

3. RLHF vs DPO の学習パイプライン比較

3.1 パイプライン構造の比較

3.2 学習フローの比較コード

RLHF パイプラインの学習ループ (概念的な擬似コード):

# RLHF (PPO) 学習ループの擬似コード
import torch

# 4 個のモデルを同時にロードする必要がある
policy_model = load_model("sft_checkpoint")
reference_model = load_model("sft_checkpoint")  # frozen
reward_model = load_model("reward_model_checkpoint")
value_model = load_model("value_head_checkpoint")

for batch in dataloader:
    prompts = batch["prompt"]

    # 1. ポリシーモデルで応答を生成 (オンライン生成が必要)
    responses = policy_model.generate(prompts)

    # 2. 報酬モデルでスコアを算出
    rewards = reward_model(prompts, responses)

    # 3. Value function で advantage を推定 (GAE)
    values = value_model(prompts, responses)
    advantages = compute_gae(rewards, values, gamma=0.99, lam=0.95)

    # 4. PPO のクリッピング目的関数を最適化
    ratio = policy_model.log_prob(responses) - reference_model.log_prob(responses)
    clipped_ratio = torch.clamp(ratio, 1 - clip_eps, 1 + clip_eps)
    policy_loss = -torch.min(ratio * advantages, clipped_ratio * advantages).mean()

    # 5. KL ペナルティを追加
    kl_penalty = beta * kl_divergence(policy_model, reference_model, responses)
    total_loss = policy_loss + kl_penalty

    total_loss.backward()
    optimizer.step()

DPO の学習ループ (概念的な擬似コード):

# DPO 学習ループの擬似コード
import torch
import torch.nn.functional as F

# 2 個のモデルだけで済む
policy_model = load_model("sft_checkpoint")
reference_model = load_model("sft_checkpoint")  # frozen

for batch in dataloader:
    # オフラインデータから直接学習 (オンライン生成は不要)
    prompts = batch["prompt"]
    chosen = batch["chosen"]
    rejected = batch["rejected"]

    # 1. 各モデルの log probability を計算
    pi_chosen = policy_model.log_prob(chosen, prompts)
    pi_rejected = policy_model.log_prob(rejected, prompts)
    ref_chosen = reference_model.log_prob(chosen, prompts)
    ref_rejected = reference_model.log_prob(rejected, prompts)

    # 2. DPO 損失関数 (わずか 3 行!)
    log_ratio_chosen = pi_chosen - ref_chosen
    log_ratio_rejected = pi_rejected - ref_rejected
    loss = -F.logsigmoid(beta * (log_ratio_chosen - log_ratio_rejected)).mean()

    loss.backward()
    optimizer.step()

違いは明確である。RLHF は 4 個のモデルと複雑な advantage estimation を必要とするが、DPO は 2 個のモデルと 3 行の損失計算で同じ目的を達成する。

4. DPO の PyTorch 実装

4.1 DPO 損失関数を自前で実装する

DPO 損失関数を PyTorch で直接実装すると、内部の動作を明確に理解できる。

import torch
import torch.nn.functional as F
from torch import nn


def dpo_loss(
    policy_chosen_logps: torch.Tensor,
    policy_rejected_logps: torch.Tensor,
    reference_chosen_logps: torch.Tensor,
    reference_rejected_logps: torch.Tensor,
    beta: float = 0.1,
    label_smoothing: float = 0.0,
) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
    """
    DPO 損失関数の実装。

    Args:
        policy_chosen_logps: ポリシーモデルの chosen 応答の log probability
        policy_rejected_logps: ポリシーモデルの rejected 応答の log probability
        reference_chosen_logps: 参照モデルの chosen 応答の log probability
        reference_rejected_logps: 参照モデルの rejected 応答の log probability
        beta: KL 制約の強さ (temperature)
        label_smoothing: ラベルスムージング係数 (0 なら標準の DPO)

    Returns:
        loss: DPO の損失値
        chosen_rewards: chosen 応答の暗黙的な報酬
        rejected_rewards: rejected 応答の暗黙的な報酬
    """
    # 暗黙的な報酬の計算: r(x,y) = beta * log(pi/pi_ref)
    chosen_rewards = beta * (policy_chosen_logps - reference_chosen_logps)
    rejected_rewards = beta * (policy_rejected_logps - reference_rejected_logps)

    # 報酬マージンの計算
    reward_margin = chosen_rewards - rejected_rewards

    # ラベルスムージングの適用 (任意)
    if label_smoothing > 0:
        loss = (
            -F.logsigmoid(reward_margin) * (1 - label_smoothing)
            - F.logsigmoid(-reward_margin) * label_smoothing
        )
    else:
        loss = -F.logsigmoid(reward_margin)

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


# 使用例
batch_size = 4
seq_len = 128

# 模擬的な log probability の値
policy_chosen_logps = torch.randn(batch_size) * 0.1 - 2.0
policy_rejected_logps = torch.randn(batch_size) * 0.1 - 2.5
reference_chosen_logps = torch.randn(batch_size) * 0.1 - 2.0
reference_rejected_logps = torch.randn(batch_size) * 0.1 - 2.5

loss, chosen_r, rejected_r = dpo_loss(
    policy_chosen_logps,
    policy_rejected_logps,
    reference_chosen_logps,
    reference_rejected_logps,
    beta=0.1,
)
print(f"DPO Loss: {loss.item():.4f}")
print(f"Chosen Reward: {chosen_r.item():.4f}")
print(f"Rejected Reward: {rejected_r.item():.4f}")

4.2 Log Probability 計算のユーティリティ

DPO で最も重要な計算要素は、シーケンスの log probability を正確に計算することである。

import torch
import torch.nn.functional as F


def compute_log_probs(
    logits: torch.Tensor,
    labels: torch.Tensor,
    attention_mask: torch.Tensor,
) -> torch.Tensor:
    """
    トークン単位の log probability を計算し、シーケンス単位で合算する。

    Args:
        logits: モデル出力のロジット (batch_size, seq_len, vocab_size)
        labels: 正解トークン ID (batch_size, seq_len)
        attention_mask: アテンションマスク (batch_size, seq_len)

    Returns:
        シーケンス単位の log probability (batch_size,)
    """
    # ロジットを 1 トークン前へずらす (next token prediction)
    shift_logits = logits[:, :-1, :]
    shift_labels = labels[:, 1:]
    shift_mask = attention_mask[:, 1:]

    # トークン単位の log probability
    log_probs = F.log_softmax(shift_logits, dim=-1)
    per_token_logps = torch.gather(
        log_probs, dim=2, index=shift_labels.unsqueeze(2)
    ).squeeze(2)

    # マスクされたトークンは 0 として扱い、シーケンスで合算する
    per_token_logps = per_token_logps * shift_mask
    return per_token_logps.sum(dim=-1)

4.3 Hugging Face TRL を活用した実践的な DPO 学習

実務では TRL ライブラリの DPOTrainer を使うことが推奨される。

from datasets import load_dataset
from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import DPOConfig, DPOTrainer
from peft import LoraConfig

# 1. モデルとトークナイザのロード
model_name = "Qwen/Qwen2.5-7B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="bfloat16",
    attn_implementation="flash_attention_2",
)
tokenizer = AutoTokenizer.from_pretrained(model_name)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

# 2. LoRA の設定 (メモリ節約)
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    task_type="CAUSAL_LM",
)

# 3. 選好データのロード (prompt, chosen, rejected の構造)
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

# 4. DPO 学習の設定
training_args = DPOConfig(
    output_dir="./dpo-qwen2.5-7b",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    learning_rate=5e-6,         # SFT に比べて 10~100 倍低く
    beta=0.1,                   # KL 制約の強さ
    max_length=1024,
    max_prompt_length=512,
    num_train_epochs=1,
    bf16=True,
    logging_steps=10,
    save_strategy="steps",
    save_steps=500,
    warmup_ratio=0.1,
    gradient_checkpointing=True,
    remove_unused_columns=False,
)

# 5. DPO Trainer の作成と学習
trainer = DPOTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    processing_class=tokenizer,
    peft_config=peft_config,
)
trainer.train()
trainer.save_model("./dpo-qwen2.5-7b-final")

学習を始める前の環境設定:

# 必要なパッケージのインストール
pip install trl>=0.12.0 transformers>=4.46.0 peft>=0.13.0 \
    datasets accelerate bitsandbytes flash-attn

# マルチ GPU での学習実行 (DeepSpeed ZeRO-3)
accelerate launch --config_file deepspeed_zero3.yaml \
    --num_processes 4 \
    train_dpo.py

# 学習のモニタリング
tensorboard --logdir ./dpo-qwen2.5-7b/runs

5. DPO の派生手法の比較: IPO, KTO, ORPO

DPO の成功以降、さまざまな派生手法が提案されてきた。それぞれ DPO の特定の限界を解決するか、異なるデータ要件に対応する。

5.1 IPO (Identity Preference Optimization)

論文: A General Theoretical Paradigm to Understand Learning from Human Preferences (Azar et al., 2024, AISTATS)

IPO は、DPO の中心的な仮定である Bradley-Terry モデルに疑問を投げかける。Bradley-Terry モデルは対ごとの選好を pointwise reward へ変換するが、この過程で情報の損失が生じ、過学習のリスクが高まる。IPO は squared loss を使ってこれを解決する。

DPO では chosen の確率を無限に高める方向へ最適化が進みうるが、IPO は目標マージン $\frac{1}{2\beta}$ へ収束するよう制約される。

5.2 KTO (Kahneman-Tversky Optimization)

論文: KTO: Model Alignment as Prospect Theoretic Optimization (Ethayarajh & Jurafsky, 2024, ICML)

KTO の最大の革新は、ペアワイズ(pairwise)なデータなしに二値信号だけでアラインメントが可能な点である。Kahneman と Tversky のプロスペクト理論(Prospect Theory)に基づき、人間が利得より損失に敏感に反応する損失回避(loss aversion)の現象を目的関数に反映している。

ここで $\lambda \approx 1.33$ は、プロスペクト理論の実験結果に由来する損失回避係数である。

5.3 ORPO (Odds-Ratio Preference Optimization)

論文: ORPO: Monolithic Preference Optimization without Reference Model (Hong et al., 2024)

ORPO は SFT と選好最適化を一つの目的関数へ統合し、reference model を完全に取り除く。

odds-ratio ベースの選好損失 $\mathcal{L}_{\text{OR}}$ は、chosen と rejected の応答の odds ratio を直接最適化することで、別途の SFT 段階と reference model なしに一度の学習でアラインメントを達成する。

5.4 総合比較テーブル

6. 実験結果の分析とベンチマーク

6.1 DPO 論文の主な実験結果

DPO 論文は三つのタスクで実験を行っている。

感情制御 (Controlled Sentiment Generation): IMDb データセットで肯定的なレビューを生成するよう GPT-2 をアラインした実験では、DPO は PPO ベースの RLHF より高い報酬を達成しつつ、KL divergence をより低く保った。これは DPO が報酬と多様性のトレードオフをより効率的に管理できることを示している。

要約 (TL;DR Summarization): Reddit TL;DR の要約タスクで GPT-J 6B を学習させた結果、DPO は temperature 0.0 で約 61% の GPT-4 判定勝率を達成し、PPO の 57% を上回った。また DPO は sampling temperature に対して PPO よりはるかに頑健な性能を示した。

単一ターン対話 (Single-Turn Dialogue): Anthropic HH データセットで Pythia 2.8B を学習させた結果、DPO は PPO と同等かそれ以上の応答品質を示した。

6.2 分布シフト (Distribution Shift) の実験

DPO の重要な実験として、Reddit TL;DR で学習したモデルを CNN/DailyMail のニュースデータセットで評価した結果がある。DPO のポリシーは PPO のポリシーより、分布シフトの状況でも有意に高い性能を保った。これは DPO が学習したアラインメントが特定ドメインに留まらず一般化することを示唆する。

6.3 ベンチマーク結果のまとめ

ただし 2024 年の研究(Xu et al., "Is DPO Superior to PPO for LLM Alignment?")では、適切にチューニングされた PPO が DPO を上回りうることが示されており、RLHF の潜在力が DPO によって完全に置き換わったわけではないことを示唆している。特にコード生成のような複雑な推論タスクでは PPO の優位が観察された。

7. 実務適用時の注意点

7.1 データセット構成の戦略

DPO の性能は選好対データの品質に大きく依存する。実務で注意すべき点は次のとおりである。

データ品質 > データ量: 少量の高品質なデータの方が、大量の低品質なデータより良い。人間の評価者間の同意率(inter-annotator agreement)が低いデータは学習を妨げる。

合成データの活用: GPT-4 や Claude を使って選好対を生成する方法が広く使われている。UltraFeedback データセットが代表的な例である。

# 合成的な選好データ生成パイプラインの例
from openai import OpenAI

client = OpenAI()

def generate_preference_pair(prompt: str, model_response_a: str, model_response_b: str) -> dict:
    """GPT-4 を使って選好判定を行う"""
    judge_prompt = f"""次の二つの応答を比較して、どちらがより役に立ち、
正確で、安全かを判断してください。

プロンプト: {prompt}

応答 A: {model_response_a}

応答 B: {model_response_b}

より良い応答の記号だけを出力してください (A または B):"""

    result = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": judge_prompt}],
        max_tokens=1,
    )
    choice = result.choices[0].message.content.strip()

    if choice == "A":
        return {"prompt": prompt, "chosen": model_response_a, "rejected": model_response_b}
    else:
        return {"prompt": prompt, "chosen": model_response_b, "rejected": model_response_a}

chosen/rejected 間の品質差: 二つの応答の品質差が大きすぎると学習信号が弱く、小さすぎるとノイズが多くなる。中程度の差が理想的である。

7.2 ハイパーパラメータのチューニングガイド

beta のチューニング戦略: beta が高すぎると(0.5+)参照モデルに近づきすぎてアラインメントの効果が薄れる。低すぎると(0.01)ポリシーが不安定になり chosen 応答へ過学習する。学習中に chosen/rejected の暗黙的な報酬の差をモニタリングし、報酬マージンが大きくなりすぎたり小さくなりすぎたりしない beta 値を選ぶ。

学習モニタリングの中心的な指標:

# DPO 学習中にモニタリングすべき中心的な指標
def log_dpo_metrics(chosen_rewards, rejected_rewards, loss):
    """学習中の中心的な指標をロギングする関数"""
    reward_margin = (chosen_rewards - rejected_rewards).mean()
    accuracy = (chosen_rewards > rejected_rewards).float().mean()

    metrics = {
        "dpo/loss": loss.item(),
        "dpo/reward_margin": reward_margin.item(),
        "dpo/accuracy": accuracy.item(),
        "dpo/chosen_reward_mean": chosen_rewards.mean().item(),
        "dpo/rejected_reward_mean": rejected_rewards.mean().item(),
    }
    # reward_margin が継続的に増加していれば過学習の兆候
    # accuracy が 1.0 に到達したら学習の打ち切りを検討する
    return metrics

7.3 よくある失敗パターンと解決策

8. DPO の限界と今後の研究の方向

8.1 知られている限界

分布シフト (Distribution Shift): DPO はオフラインデータで学習するため、学習中にポリシーが参照モデルから次第に離れるにつれ、学習データの分布と実際の生成分布の乖離が大きくなる。これは DPO の最も根本的な限界であり、オンライン DPO や iterative DPO といった派生手法で解決しようとする試みが進んでいる。

暗黙的な報酬モデルの一般化の限界: Apple Research の研究によれば、DPO の暗黙的な報酬は in-distribution なデータでは RLHF の報酬モデルと同等の性能を示すが、out-of-distribution な設定では最大 7% まで精度が低下する。明示的な報酬モデルの方が高い一般化能力を持つという点は、DPO の構造的な弱点である。

Likelihood Displacement: DPO の学習中に、chosen でも rejected でもない応答の確率が意図せず増加する現象が報告されている。これはモデル容量の限界と、多数の学習サンプル間の相互作用によって生じる。

Bradley-Terry 仮定の脆弱さ: 人間の選好が常に transitive で pointwise reward として表現できるという仮定は、現実と異なりうる。IPO はこの問題を指摘したが、根本的な解決には至っていない。

8.2 今後の研究の方向

Online/Iterative DPO: 学習中にモデル自身の生成結果を使って選好データを継続的に更新する方法である。オフライン DPO の分布シフト問題を解決しつつ、RLHF より単純なパイプラインを保てる。

ハイブリッドなアプローチ: DPO の単純さと PPO のオンライン探索能力を組み合わせる研究が活発である。初期のアラインメントに DPO を使い、その後 RLHF で微調整する 2 段階のアプローチが複数の研究で効果を示している。

検証可能な報酬に基づくアラインメント: 数学やコーディングなど結果を自動で検証できるタスクでは、GRPO や verifier-driven RL が DPO より効果的である。DeepSeek-R1 の成功がこの方向の可能性を示している。

Multi-Objective なアラインメント: 単一の選好軸ではなく、安全性、有用性、正直さなど複数の目標を同時に最適化する DPO の派生が研究されている。

9. 結論

DPO は LLM アラインメントのパラダイムを変えた論文である。RLHF の複雑な 3 段階パイプラインを数学的に優雅に単純化し、報酬モデルの学習と PPO の最適化を単一の分類損失で置き換えた。中心は報酬関数の再パラメータ化によって partition function を相殺させることにあり、これによって実装の複雑さと計算コストが大きく減る。

しかし DPO が RLHF を完全に置き換えるわけではない。分布シフトの問題、暗黙的な報酬の一般化の限界、Bradley-Terry 仮定の脆弱さといった構造的な限界が存在し、適切にチューニングされた PPO が特定のタスクで DPO を上回る結果も報告されている。実務では、タスクの特性、データの可用性、計算資源を総合的に考慮して、DPO、KTO、ORPO、あるいはハイブリッドなアプローチの中から最適な戦略を選ぶ必要がある。

References

1. Direct Preference Optimization: Your Language Model is Secretly a Reward Model (Rafailov et al., NeurIPS 2023)
2. A General Theoretical Paradigm to Understand Learning from Human Preferences - IPO (Azar et al., AISTATS 2024)
3. KTO: Model Alignment as Prospect Theoretic Optimization (Ethayarajh & Jurafsky, ICML 2024)
4. Is DPO Superior to PPO for LLM Alignment? A Comprehensive Study (Xu et al., 2024)
5. Hugging Face TRL - DPO Trainer 公式ドキュメント
6. DPO Reference Implementation (Eric Mitchell, GitHub)
7. On the Limited Generalization Capability of the Implicit Reward Model Induced by DPO (Apple ML Research)
8. How to Align Open LLMs in 2025 with DPO & Synthetic Data (Philipp Schmid)
9. Towards Analyzing and Understanding the Limitations of DPO: A Theoretical Perspective (2024)
10. A Comprehensive Survey of Direct Preference Optimization (2024)