fine-tuning-with-trl

TRL - Transformer Reinforcement Learning

クイックスタート

TRL は、言語モデルを人間の選好に合わせるためのポストトレーニング手法を提供します。

インストール:

pip install trl transformers datasets peft accelerate

教師ありファインチューニング（インストラクションチューニング）:

from trl import SFTTrainer

trainer = SFTTrainer(
    model="Qwen/Qwen2.5-0.5B",
    train_dataset=dataset,  # Prompt-completion pairs
)
trainer.train()

DPO（選好に合わせる）:

from trl import DPOTrainer, DPOConfig

config = DPOConfig(output_dir="model-dpo", beta=0.1)
trainer = DPOTrainer(
    model=model,
    args=config,
    train_dataset=preference_dataset,  # chosen/rejected pairs
    processing_class=tokenizer
)
trainer.train()

一般的なワークフロー

ワークフロー 1: 完全な RLHF パイプライン（SFT → 報酬モデル → PPO）

ベースモデルから人間に合わせたモデルまでの完全なパイプラインです。

このチェックリストをコピーしてください:

RLHF Training:
- [ ] Step 1: Supervised fine-tuning (SFT)
- [ ] Step 2: Train reward model
- [ ] Step 3: PPO reinforcement learning
- [ ] Step 4: Evaluate aligned model

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

インストラクションに従うデータでベースモデルを学習させます:

from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset

# Load model
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B")

# Load instruction dataset
dataset = load_dataset("trl-lib/Capybara", split="train")

# Configure training
training_args = SFTConfig(
    output_dir="Qwen2.5-0.5B-SFT",
    per_device_train_batch_size=4,
    num_train_epochs=1,
    learning_rate=2e-5,
    logging_steps=10,
    save_strategy="epoch"
)

# Train
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    tokenizer=tokenizer
)
trainer.train()
trainer.save_model()

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

人間の選好を予測するモデルを学習させます:

from transformers import AutoModelForSequenceClassification
from trl import RewardTrainer, RewardConfig

# Load SFT model as base
model = AutoModelForSequenceClassification.from_pretrained(
    "Qwen2.5-0.5B-SFT",
    num_labels=1  # Single reward score
)
tokenizer = AutoTokenizer.from_pretrained("Qwen2.5-0.5B-SFT")

# Load preference data (chosen/rejected pairs)
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

# Configure training
training_args = RewardConfig(
    output_dir="Qwen2.5-0.5B-Reward",
    per_device_train_batch_size=2,
    num_train_epochs=1,
    learning_rate=1e-5
)

# Train reward model
trainer = RewardTrainer(
    model=model,
    args=training_args,
    processing_class=tokenizer,
    train_dataset=dataset
)
trainer.train()
trainer.save_model()

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

報酬モデルを使ってポリシーを最適化します:

python -m trl.scripts.ppo \
    --model_name_or_path Qwen2.5-0.5B-SFT \
    --reward_model_path Qwen2.5-0.5B-Reward \
    --dataset_name trl-internal-testing/descriptiveness-sentiment-trl-style \
    --output_dir Qwen2.5-0.5B-PPO \
    --learning_rate 3e-6 \
    --per_device_train_batch_size 64 \
    --total_episodes 10000

ステップ 4: 評価

from transformers import pipeline

# Load aligned model
generator = pipeline("text-generation", model="Qwen2.5-0.5B-PPO")

# Test
prompt = "Explain quantum computing to a 10-year-old"
output = generator(prompt, max_length=200)[0]["generated_text"]
print(output)

ワークフロー 2: DPO によるシンプルな選好アライメント

報酬モデルを使わずに、モデルを選好に合わせます。

このチェックリストをコピーしてください:

DPO Training:
- [ ] Step 1: Prepare preference dataset
- [ ] Step 2: Configure DPO
- [ ] Step 3: Train with DPOTrainer
- [ ] Step 4: Evaluate alignment

ステップ 1: 選好データセットの準備

データセットの形式:

{
  "prompt": "What is the capital of France?",
  "chosen": "The capital of France is Paris.",
  "rejected": "I don't know."
}

データセットを読み込みます:

from datasets import load_dataset

dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
# Or load your own
# dataset = load_dataset("json", data_files="preferences.json")

ステップ 2: DPO の設定

from trl import DPOConfig

config = DPOConfig(
    output_dir="Qwen2.5-0.5B-DPO",
    per_device_train_batch_size=4,
    num_train_epochs=1,
    learning_rate=5e-7,
    beta=0.1,  # KL penalty strength
    max_prompt_length=512,
    max_length=1024,
    logging_steps=10
)

ステップ 3: DPOTrainer による学習

from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import DPOTrainer

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")

trainer = DPOTrainer(
    model=model,
    args=config,
    train_dataset=dataset,
    processing_class=tokenizer
)

trainer.train()
trainer.save_model()

CLI による代替方法:

trl dpo \
    --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
    --dataset_name argilla/Capybara-Preferences \
    --output_dir Qwen2.5-0.5B-DPO \
    --per_device_train_batch_size 4 \
    --learning_rate 5e-7 \
    --beta 0.1

ワークフロー 3: GRPO によるメモリ効率の高いオンライン RL

最小限のメモリで強化学習による学習を行います。

このチェックリストをコピーしてください:

GRPO Training:
- [ ] Step 1: Define reward function
- [ ] Step 2: Configure GRPO
- [ ] Step 3: Train with GRPOTrainer

ステップ 1: 報酬関数の定義

def reward_function(completions, **kwargs):
    """
    Compute rewards for completions.

    Args:
        completions: List of generated texts

    Returns:
        List of reward scores (floats)
    """
    rewards = []
    for completion in completions:
        # Example: reward based on length and unique words
        score = len(completion.split())  # Favor longer responses
        score += len(set(completion.lower().split()))  # Reward unique words
        rewards.append(score)
    return rewards

または報酬モデルを使用します:

from transformers import pipeline

reward_model = pipeline("text-classification", model="reward-model-path")

def reward_from_model(completions, prompts, **kwargs):
    # Combine prompt + completion
    full_texts = [p + c for p, c in zip(prompts, completions)]
    # Get reward scores
    results = reward_model(full_texts)
    return [r["score"] for r in results]

ステップ 2: GRPO の設定

from trl import GRPOConfig

config = GRPOConfig(
    output_dir="Qwen2-GRPO",
    per_device_train_batch_size=4,
    num_train_epochs=1,
    learning_rate=1e-5,
    num_generations=4,  # Generate 4 completions per prompt
    max_new_tokens=128
)

ステップ 3: GRPOTrainer による学習

from datasets import load_dataset
from trl import GRPOTrainer

# Load prompt-only dataset
dataset = load_dataset("trl-lib/tldr", split="train")

trainer = GRPOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=reward_function,  # Your reward function
    args=config,
    train_dataset=dataset
)

trainer.train()

CLI:

trl grpo \
    --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
    --dataset_name trl-lib/tldr \
    --output_dir Qwen2-GRPO \
    --num_generations 4

使用すべき場合と代替手段

TRL を使うべき場合:

• モデルを人間の選好に合わせる必要がある
• 選好データ（chosen/rejected のペア）がある
• 強化学習（PPO、GRPO）を使いたい
• 報酬モデルの学習が必要である
• RLHF（完全なパイプライン）を実施している

手法の選択:

• SFT: プロンプトと補完のペアがあり、基本的なインストラクションへの追従を獲得させたい場合
• DPO: 選好データがあり、シンプルなアライメントを行いたい場合（報酬モデルは不要）
• PPO: 報酬モデルがあり、RL を最大限に制御したい場合
• GRPO: メモリに制約があり、オンライン RL を行いたい場合
• 報酬モデル: RLHF パイプラインを構築し、生成結果をスコア化する必要がある場合

代わりに使うべきツール:

• HuggingFace Trainer: RL を使わない基本的なファインチューニング
• Axolotl: YAML ベースの学習設定
• LitGPT: 教育用途、最小限のファインチューニング
• Unsloth: 高速な LoRA 学習

よくある問題

問題: DPO 学習中の OOM

バッチサイズとシーケンス長を減らします:

config = DPOConfig(
    per_device_train_batch_size=1,  # Reduce from 4
    max_length=512,  # Reduce from 1024
    gradient_accumulation_steps=8  # Maintain effective batch
)

または勾配チェックポイントを使用します:

model.gradient_checkpointing_enable()

問題: アライメントの品質が低い

beta パラメータを調整します:

# Higher beta = more conservative (stays closer to reference)
config = DPOConfig(beta=0.5)  # Default 0.1

# Lower beta = more aggressive alignment
config = DPOConfig(beta=0.01)

問題: 報酬モデルが学習されない

損失の種類と学習率を確認します:

config = RewardConfig(
    learning_rate=1e-5,  # Try different LR
    num_train_epochs=3  # Train longer
)

選好データセットに明確な勝者があることを確認します:

# Verify dataset
print(dataset[0])
# Should have clear chosen > rejected

問題: PPO 学習が不安定

KL 係数を調整します:

config = PPOConfig(
    kl_coef=0.1,  # Increase from 0.05
    cliprange=0.1  # Reduce from 0.2
)

応用トピック

SFT 学習ガイド: データセットの形式、チャットテンプレート、パッキング戦略、マルチ GPU 学習については references/sft-training.md を参照してください。

DPO のバリアント: IPO、cDPO、RPO などの DPO 損失関数と推奨ハイパーパラメータについては references/dpo-variants.md を参照してください。

報酬モデリング: 結果報酬とプロセス報酬、Bradley-Terry 損失、報酬モデルの評価については references/reward-modeling.md を参照してください。

オンライン RL 手法: PPO、GRPO、RLOO、OnlineDPO の詳細な設定については references/online-rl.md を参照してください。

ハードウェア要件

• GPU: NVIDIA（CUDA が必要）
• VRAM: モデルと手法によって異なります
  • SFT 7B: 16GB（LoRA 使用時）
  • DPO 7B: 24GB（参照モデルを保持するため）
  • PPO 7B: 40GB（ポリシーモデルと報酬モデル）
  • GRPO 7B: 24GB（よりメモリ効率が高い）
• マルチ GPU: accelerate を介してサポート
• 混合精度: BF16 を推奨（A100/H100）

メモリの最適化:

• すべての手法で LoRA/QLoRA を使用する
• 勾配チェックポイントを有効にする
• 勾配累積を使い、バッチサイズを小さくする

リソース

• ドキュメント：https://huggingface.co/docs/trl/
• GitHub：https://github.com/huggingface/trl
• 論文：
  • "Training language models to follow instructions with human feedback"（InstructGPT、2022）
  • "Direct Preference Optimization: Your Language Model is Secretly a Reward Model"（DPO、2023）
  • "Group Relative Policy Optimization"（GRPO、2024）
• 例：https://github.com/huggingface/trl/tree/main/examples/scripts

エージェントの作業手順

1. 環境を確認します。 GPU の種類、メモリ、ドライバー／CUDA のバージョン（nvidia-smi）、フレームワークのバージョン、データセットの場所とサイズを確認します。
2. 入力を明確にします。 データまたはユーザーから、形式、識別子、パラメーターを確認します。結果に影響する値は推測せず、質問してください。
3. まず小規模に実行します。 スモークテストとして、小さなモデルまたはサブセットを使い、少ないステップ数で実行して、損失が減少しチェックポイントが保存されることを確認します。
4. 上記の手順と参照情報を使って、タスク全体を実行します。
5. 結果を検証します。 保留データでメトリクスを追跡し、ベースラインと比較して、シード、設定、ハードウェアを記録します。
6. 報告します。 実行した内容（バージョン、コマンド、パラメーター）、確認した内容、まだ不確かな点を明記します。

発生した事象	対応
CUDA のメモリ不足	バッチサイズを小さくする、勾配累積／チェックポイント化または混合精度を有効にする、あるいはモデルを分割します。
損失が NaN になる、または発散する	学習率を下げ、データに無効な値がないか確認し、勾配クリッピングを有効にします。
これらの手順に記載された関数、フラグ、エンドポイントがインストール済みバージョンに存在しない	インストール済みバージョンのドキュメント（help()、--help、公式ドキュメント）を確認して適宜対応し、ユーザーに伝えます。API をでっち上げてはいけません。
必須の入力、識別子、パラメーターが曖昧	ユーザーに質問するか、実行前に前提を明示します。

誠実性に関するルール

• 結果、パラメーター、識別子、引用、統計情報を捏造してはいけません。実行または検証できない場合は、その旨をはっきり伝えます。
• ログなしに学習結果を主張してはいけません。大規模なジョブを開始する前に、計算コストを見積もります。
• ここにあるバージョン固有の情報は古くなっている可能性があるものとして扱い、インストール済みバージョンの公式ドキュメントで確認します。
• 費用が発生する、共有 GPU やクラウドのクォータを消費する、個人データまたは患者データに触れる、あるいは取り消せない操作を行う場合は、事前に確認します。

関連スキル

• grpo-rl-training：TRL ライブラリを使った言語モデルの GRPO（Group Relative Policy Optimization）ファインチューニングをガイドします。GRPOTrainer の設定などを含みます…
• simpo-training：LLM アライメントのための Simple Preference Optimization。
• verl-rl-training：verl（Volcano Engine RL）を使った強化学習による LLM のトレーニングをガイドします。