强化学习RLHF详解

贝塔西塔

于 2025-04-11 10:14:20 发布

阅读量1k

点赞数 16

分类专栏：强化学习大模型文章标签：人工智能深度学习机器学习算法语言模型

本文链接：https://blog.youkuaiyun.com/sjtu_wyy/article/details/147136810

版权

强化学习同时被 2 个专栏收录

18 篇文章

订阅专栏

大模型

4 篇文章

订阅专栏

RLHF（Reinforcement Learning from Human Feedback）模型详解

一、背景

1. 传统强化学习的局限性

传统的强化学习（Reinforcement Learning, RL）依赖于预定义的奖励函数（Reward Function），但在复杂任务（如自然语言生成、机器人控制）中，设计精确的奖励函数极为困难。例如：

模糊目标：生成“高质量文本”难以量化，无法用简单的指标（如BLEU、ROUGE）完全衡量。
奖励误导：错误的奖励设计可能导致模型优化错误目标（如生成冗余内容以增加长度得分）。
稀疏奖励问题：关键行为缺乏即时反馈信号（例：围棋中只有终局胜负奖励）
安全问题：模型可能利用奖励漏洞，产生有害但符合奖励规则的行为（如生成虚假信息但语法正确，清洁机器人通过阻挡传感器伪造"干净"环境）。

方法	问题描述	典型案例
监督微调(SFT)	无法捕捉复杂偏好，易过拟合标注数据	GPT-2在对话场景中的不一致性
规则系统	难以处理开放域问题，维护成本高	早期客服机器人的人工规则库
纯RL方法	奖励函数设计困难，易出现奖励破解	文本游戏AI中的分数刷取行为

2. 人类反馈的必要性

人类能直观判断输出是否符合期望（如真实性、安全性、流畅性），但将主观判断转化为可计算的奖励函数是一大挑战。RLHF通过直接利用人类反馈，绕过传统奖励函数设计的瓶颈，使模型更贴近人类价值观。

3. 相关技术演进

技术路线	核心思想	局限性
逆强化学习 (IRL)	从专家演示中逆向推导奖励函数	依赖完整专家轨迹
偏好学习	通过二元比较学习隐式奖励	信息量低、收敛速度慢
协同训练	人机交互式策略优化	实时反馈成本高昂

4. RLHF的里程碑突破

2017年 DeepMind《Deep Reinforcement Learning from Human Preferences》 首次系统提出框架
2020年 OpenAI 在GPT-3微调中应用RLHF 实现可控文本生成
2022年 Anthropic Constitutional AI 将RLHF与价值观对齐结合

二、原理

1. 系统工作流程

RLHF分为三阶段，核心是将人类偏好转化为可优化的目标：

1. 监督微调（Supervised Fine-Tuning, SFT）

目的：用高质量数据初始化模型，为后续强化学习提供基础策略。
方法：在预训练模型（如GPT-3）上，使用人类标注的示例（如“问题-理想回答”对）进行微调。
示例：对于指令遵循任务，标注者编写符合要求的回答，模型通过交叉熵损失学习。

2. 奖励建模（Reward Modeling, RM）

目标：训练一个神经网络（RM），将模型输出映射为标量奖励值，反映人类偏好。
数据收集：
- 给定输入（如用户提问），模型生成多个候选输出。
- 人类对输出进行排序（如A > B > C）或评分（如1-5分）。
训练方法：
- 成对排序法：将排序转化为概率（如Bradley-Terry模型），最大化偏好对的似然函数。
- 损失函数示例：
  $\mathcal{L}(\theta) = -\mathbb{E}_{(x,y_w,y_l)\sim D} \left[ \log \sigma(R_\theta(x,y_w) - R_\theta(x,y_l)) \right]$
  其中 $y_w$ 为偏好输出， $y_l$ 为较差输出， $R_\theta$ 为奖励模型。

3. 强化学习优化（RL Fine-Tuning）

目标：使用RM提供的奖励信号优化策略模型（即LLM生成模型）。
算法选择：
- 近端策略优化（PPO）：通过限制策略更新幅度，确保训练稳定性。
- 关键步骤：
  1. 当前策略生成输出，RM计算奖励。
  2. 计算优势函数（Advantage Function）以评估动作的优劣，一般选择SFT模型作为基线。
  3. 最大化奖励的同时，添加KL散度惩罚项，防止策略偏离初始SFT模型过远。
  - 目标函数：
    $\max_\pi \mathbb{E}_{x\sim D, y\sim \pi(\cdot|x)} \left[ R_\theta(x,y) - \beta \text{KL}(\pi(\cdot|x) || \pi_{\text{SFT}}(\cdot|x)) \right]$
    其中 $\beta$ 是KL惩罚系数，用于平衡奖励最大化和策略稳定性。

三、优势

1. 解决复杂目标对齐问题

直接利用人类偏好，避免手动设计奖励函数的偏差。例如，在道德对齐任务中，模型能学习拒绝生成有害内容，即使未明确编程规则。

2. 提升生成质量

实验显示，RLHF使模型在开放域对话、指令遵循等任务中的输出更相关、连贯且符合用户意图（如InstructGPT比GPT-3的生成质量提高50%以上）。

3. 数据效率提升

相较于纯监督学习，RLHF通过少量高质量反馈即可引导模型优化方向。例如，ChatGPT的RLHF阶段仅需数万条人类反馈数据。

4. 安全性与可控性

通过显式偏好标注，可引导模型避免输出偏见、虚假信息。例如，标注者被要求优先选择无害且真实的回答。

四、劣势与挑战

1. 人类标注成本高

需要大量标注者对输出进行排序或评分，成本随任务复杂度指数增长。例如，训练ChatGPT的RM阶段需雇佣数百名标注者，耗时数月。

2. 反馈偏差问题

主观性：不同标注者的标准可能冲突（如文化差异）。
短期偏好陷阱：人类可能偏好表面流畅但内容空洞的回答，导致模型“讨好”标注者而非解决实际问题。

3. 奖励模型的局限性

过拟合：RM在训练数据外的分布上表现可能下降。
对抗漏洞：模型可能学会生成欺骗RM的高奖励但低质量的输出（如添加无意义关键词）。

4. 训练复杂度与不稳定性

PPO需要精细调参（如KL系数、学习率），否则易陷入局部最优或崩溃。
多阶段训练（SFT→RM→RL）导致流程冗长，调试困难。

5. 评估困难

缺乏客观指标衡量对齐效果，仍需依赖人类评估，形成闭环依赖。

五、典型应用场景

对话系统（如ChatGPT）：提升回答的有用性、诚实性和无害性。
代码生成（如GitHub Copilot）：生成更符合程序员意图的代码。
内容安全过滤：自动识别并拒绝生成有害内容。
机器人控制：通过人类演示优化复杂动作策略。

六、未来方向

降低标注成本：利用半监督学习或主动学习选择高价值样本。
多模态反馈：结合文本、语音、图像等多种反馈形式。
对抗鲁棒性：设计更健壮的奖励模型，防止对抗攻击。
自动化对齐：探索无需人类干预的自我对齐方法（如基于规则的奖励模型）。

总结

RLHF通过将人类偏好融入强化学习框架，显著提升了模型对齐复杂目标的能力，但其成功依赖于高质量标注数据、稳定的训练流程以及对奖励模型的深入理解。随着技术进步，RLHF有望在更多领域实现安全、可控的AI系统部署。

代码demo

RM训练

import torch
from torch.utils.data import Dataset, DataLoader
from transformers import AutoModelForSequenceClassification, AutoTokenizer, AutoConfig

class PreferenceDataset(Dataset):
    """人类偏好数据集加载器"""
    def __init__(self, data_path, tokenizer, max_length=128):
        self.tokenizer = tokenizer
        self.max_length = max_length
        # 示例数据结构：每行包含prompt, chosen_response, rejected_response
        self.data = self.load_data(data_path)  
    
    def load_data(self, path):
        # 实际应替换为真实数据加载逻辑
        return [
            {
                "prompt": "Explain quantum physics",
                "chosen": "Quantum physics studies subatomic particles...", 
                "rejected": "It's something about tiny invisible things..."
            },
            # 更多数据样本...
        ]
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        item = self.data[idx]
        # 对chosen和rejected响应分别编码
        chosen = self.tokenizer(
            item["prompt"] + self.tokenizer.sep_token + item["chosen"],
            max_length=self.max_length,
            padding="max_length",
            truncation=True,
            return_tensors="pt"
        )
        
        rejected = self.tokenizer(
            item["prompt"] + self.tokenizer.sep_token + item["rejected"],
            max_length=self.max_length,
            padding="max_length",
            truncation=True,
            return_tensors="pt"
        )
        
        return {
            "chosen_input_ids": chosen["input_ids"].squeeze(),
            "chosen_attention_mask": chosen["attention_mask"].squeeze(),
            "rejected_input_ids": rejected["input_ids"].squeeze(),
            "rejected_attention_mask": rejected["attention_mask"].squeeze()
        }

class RewardModelTrainer:
    def __init__(self, model_name="roberta-base", lr=1e-5):
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        
        # 初始化模型
        config = AutoConfig.from_pretrained(model_name)
        config.num_labels = 1  # 回归任务，输出单个奖励值
        self.model = AutoModelForSequenceClassification.from_pretrained(
            model_name, 
            config=config
        ).to(self.device)
        
        # 冻结底层参数（可选）
        for param in self.model.roberta.parameters():  # 根据实际模型结构调整
            param.requires_grad = False
            
        # 替换最后的分类层
        self.model.classifier = torch.nn.Sequential(
            torch.nn.Linear(config.hidden_size, 256),
            torch.nn.ReLU(),
            torch.nn.Linear(256, 1)
        ).to(self.device)
        
        self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=lr)
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        
    def compute_loss(self, chosen_rewards, rejected_rewards):
        """对比损失函数：确保chosen奖励 > rejected奖励"""
        # 使用pairwise ranking loss
        margin = 1.0  # 控制奖励差异的幅度
        return torch.mean(
            torch.clamp(rejected_rewards - chosen_rewards + margin, min=0)
        )
    
    def train_epoch(self, dataloader):
        self.model.train()
        total_loss = 0
        
        for batch in dataloader:
            # 前向传播计算奖励
            chosen_outputs = self.model(
                input_ids=batch["chosen_input_ids"].to(self.device),
                attention_mask=batch["chosen_attention_mask"].to(self.device)
            )
            chosen_rewards = chosen_outputs.logits.squeeze()
            
            rejected_outputs = self.model(
                input_ids=batch["rejected_input_ids"].to(self.device),
                attention_mask=batch["rejected_attention_mask"].to(self.device)
            )
            rejected_rewards = rejected_outputs.logits.squeeze()
            
            # 计算对比损失
            loss = self.compute_loss(chosen_rewards, rejected_rewards)
            
            # 反向传播
            self.optimizer.zero_grad()
            loss.backward()
            torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)
            self.optimizer.step()
            
            total_loss += loss.item()
        
        return total_loss / len(dataloader)
    
    def evaluate(self, dataloader):
        """计算验证集准确率"""
        self.model.eval()
        correct = 0
        total = 0
        
        with torch.no_grad():
            for batch in dataloader:
                chosen_rewards = self.model(
                    input_ids=batch["chosen_input_ids"].to(self.device),
                    attention_mask=batch["chosen_attention_mask"].to(self.device)
                ).logits.squeeze()
                
                rejected_rewards = self.model(
                    input_ids=batch["rejected_input_ids"].to(self.device),
                    attention_mask=batch["rejected_attention_mask"].to(self.device)
                ).logits.squeeze()
                
                correct += (chosen_rewards > rejected_rewards).sum().item()
                total += len(chosen_rewards)
        
        return correct / total

# 训练流程示例
if __name__ == "__main__":
    trainer = RewardModelTrainer(model_name="roberta-base", lr=1e-5)
    dataset = PreferenceDataset("data/", trainer.tokenizer)
    dataloader = DataLoader(dataset, batch_size=8, shuffle=True)
    
    # 划分训练集和验证集
    val_size = int(0.1 * len(dataset))
    train_set, val_set = torch.utils.data.random_split(dataset, [len(dataset)-val_size, val_size])
    train_loader = DataLoader(train_set, batch_size=8, shuffle=True)
    val_loader = DataLoader(val_set, batch_size=8)
    
    for epoch in range(5):
        train_loss = trainer.train_epoch(train_loader)
        val_acc = trainer.evaluate(val_loader)
        print(f"Epoch {epoch+1}:")
        print(f"  Train Loss: {train_loss:.4f}")
        print(f"  Val Accuracy: {val_acc:.2%}\n")
    
    # 保存最终模型
    torch.save(trainer.model.state_dict(), "reward_model.pth")

RLHF训练大模型

import torch
import torch.nn as nn
from torch.optim import AdamW
from transformers import AutoModelForCausalLM, AutoTokenizer

class RLHFTrainer:
    def __init__(self, config):
        # 初始化所有组件
        self.device = config.device
        
        # 策略模型（待训练）
        self.policy = AutoModelForCausalLM.from_pretrained(config.policy_path).to(self.device)
        
        # 参考模型（冻结）
        self.ref_model = AutoModelForCausalLM.from_pretrained(config.ref_path).to(self.device)
        for param in self.ref_model.parameters():
            param.requires_grad = False
            
        # 奖励模型（示例简化版）
        self.reward_model = AutoModelForCausalLM.from_pretrained(config.reward_path).to(self.device)
        for param in self.reward_model.parameters():
            param.requires_grad = False
            
        # 优化器仅更新策略模型
        self.optimizer = AdamW(self.policy.parameters(), lr=config.lr)
        
        # 关键超参数
        self.kl_coef = config.kl_coef
        self.clip_epsilon = config.clip_epsilon
        self.gamma = config.gamma

    def compute_reward(self, responses):
        """计算奖励分数（简化版，实际需替换为完整RM逻辑）"""
        # 获取奖励模型的隐藏状态
        with torch.no_grad():
            outputs = self.reward_model(responses, output_hidden_states=True)
        last_hidden = outputs.hidden_states[-1]
        
        # 简单线性层计算奖励值
        reward = torch.mean(last_hidden, dim=1)  
        return reward.squeeze()

    def compute_kl(self, policy_logits, ref_logits):
        """计算策略模型与参考模型的KL散度"""
        policy_probs = torch.softmax(policy_logits, dim=-1)
        ref_probs = torch.softmax(ref_logits, dim=-1)
        kl_div = torch.sum(policy_probs * torch.log(policy_probs / ref_probs), dim=-1)
        return torch.mean(kl_div)

    def train_step(self, queries):
        # 阶段1：生成响应
        policy_outputs = self.policy.generate(
            queries, max_length=128, do_sample=True, top_k=50
        )
        with torch.no_grad():
            ref_outputs = self.ref_model.generate(
                queries, max_length=128, do_sample=True, top_k=50
            )

        # 阶段2：计算奖励
        policy_rewards = self.compute_reward(policy_outputs)
        ref_rewards = self.compute_reward(ref_outputs)
        
        # 归一化奖励（提升稳定性）
        policy_rewards = (policy_rewards - policy_rewards.mean()) / (policy_rewards.std() + 1e-8)
        ref_rewards = (ref_rewards - ref_rewards.mean()) / (ref_rewards.std() + 1e-8)
        
        # 计算优势（核心改进点）
        advantages = policy_rewards - ref_rewards
        
        # 阶段3：获取模型输出logits
        policy_logits = self.policy(policy_outputs).logits
        with torch.no_grad():
            ref_logits = self.ref_model(policy_outputs).logits
        
        # 阶段4：计算策略损失
        ratio = torch.exp(policy_logits - ref_logits.detach())
        clipped_ratio = torch.clamp(ratio, 1 - self.clip_epsilon, 1 + self.clip_epsilon)
        
        policy_loss = -torch.min(ratio * advantages, clipped_ratio * advantages).mean()
        
        # 阶段5：KL散度惩罚
        kl_penalty = self.kl_coef * self.compute_kl(policy_logits, ref_logits)
        
        # 总损失
        total_loss = policy_loss + kl_penalty
        
        # 阶段6：反向传播
        self.optimizer.zero_grad()
        total_loss.backward()
        torch.nn.utils.clip_grad_norm_(self.policy.parameters(), 1.0)
        self.optimizer.step()
        
        return {
            "total_loss": total_loss.item(),
            "policy_loss": policy_loss.item(),
            "kl_penalty": kl_penalty.item(),
            "avg_reward": policy_rewards.mean().item()
        }

# 配置类示例
class Config:
    device = "cuda" if torch.cuda.is_available() else "cpu"
    policy_path = "gpt2"
    ref_path = "gpt2"
    reward_path = "gpt2"
    lr = 1e-5
    kl_coef = 0.1
    clip_epsilon = 0.2
    gamma = 1.0

# 训练流程示例
if __name__ == "__main__":
    trainer = RLHFTrainer(Config())
    tokenizer = AutoTokenizer.from_pretrained("gpt2")
    
    # 模拟训练数据
    queries = tokenizer(["Explain quantum physics", "Write a poem about AI"], 
                       return_tensors="pt", padding=True).to(Config.device)
    
    for step in range(100):
        metrics = trainer.train_step(queries.input_ids)
        print(f"Step {step}:")
        print(f"  Loss: {metrics['total_loss']:.4f}")
        print(f"  Reward: {metrics['avg_reward']:.4f}")
        print(f"  KL: {metrics['kl_penalty']:.4f}\n")

关键代码解析：
‌模型架构‌

self.policy = ...  # 可训练的策略模型
self.ref_model = ...  # 冻结的参考模型
self.reward_model = ...  # 提供奖励信号的模型

三模型结构是RLHF标准配置
参考模型和奖励模型均冻结，仅策略模型更新

‌优势计算‌

advantages = policy_rewards - ref_rewards

直接使用策略模型与参考模型的奖励差值
替代传统PPO中的Critic价值函数
以上实现取消了Critic网络，采用了蒙特卡洛方法，基于完整回合的回报（Return）更新策略，直接关联最终奖励。蒙特卡洛方法和Critic TD混合方法各有优劣，后续会针对这个问题进行分析对比

‌策略损失核心‌

ratio = torch.exp(policy_logits - ref_logits.detach())
clipped_ratio = torch.clamp(ratio, 1 - self.clip_epsilon, 1 + self.clip_epsilon)
policy_loss = -torch.min(ratio * advantages, clipped_ratio * advantages).mean()

ratio计算新旧策略差异
clipped_ratio防止单步更新过大
min()操作构建PPO的保守目标函数

‌KL散度惩罚‌

kl_penalty = self.kl_coef * self.compute_kl(policy_logits, ref_logits)

显示控制策略模型的更新幅度
防止与初始策略（参考模型）偏离过多

改进点说明

‌优势计算简化‌

直接使用R_policy - R_ref替代传统PPO中的广义优势估计(GAE)，因为：

文本生成是单回合任务，无需考虑多步回报
参考模型的奖励作为天然基线(baseline)

‌无Critic模型‌
省略价值函数网络：

减少50%以上的参数更新量
避免价值函数与策略网络的耦合训练问题
实际效果参考Anthropic论文结论（节省30%训练时间）

‌动态奖励归一化‌

policy_rewards = (policy_rewards - mean)/std

控制奖励尺度在合理范围
防止不同batch的奖励差异导致训练不稳定