fine-tuning-with-trl

TRL - Transformer 强化学习

快速开始

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()

命令行替代方案：

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()

命令行：

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

何时使用及替代方案

在以下情况使用 TRL：

• 需要将模型与人类偏好对齐
• 拥有偏好数据（选中/拒绝对）
• 希望使用强化学习（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）
• 显存：取决于模型和方法
  • 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

Agent 操作流程

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。