1.5.llm_alignment | collections

☄️

collections

RLHF & InstructGPT

OpenAI魔改大模型，参数减少100倍！13亿参数InstructGPT碾压GPT-3

https://openai.com/blog/deep-reinforcement-learning-from-human-preferences/

Training language models to follow instructions with human feedback

https://huggingface.co/blog/zh/rlhf

预训练一个语言模型 (LM) ；
聚合问答数据并训练一个奖励模型 (Reward Model，RM)，也叫偏好模型；
用强化学习 (RL) 方式微调 LM。

sft

确保任务多样性的情况下，由标注人员编写prompt和一些生成式任务的期望输出。

openai：instructGPT使用小版本的GPT-3，并对“更可取”（preferable）的人工生成文本微调
Anthropic：1000w-520亿参数的transformer，并按“有用、诚实和无害”的标准在上下文线索上蒸馏原始LM
DeepMind：在Teaching language models to support answers with verified quotes提出的GopherCite模型中，用的是2800亿的模型Gopher(Scaling language models: Methods, analysis & insights from training gopher)

剖析大模型Pretrain和SFT阶段的Loss差异

不管是PreTraining阶段还是SFT阶段，loss函数都是一样的，只是计算的方式存在差异，PreTraining阶段计算的是整段输入文本的loss，而SFT阶段计算的是response部分的loss。

rm

接收一系列文本并返回一个标量奖励，数值上对应人的偏好。我们可以用端到端的方式用LM建模，或者用模块化的系统建模 (比如对输出进行排名，再将排名转换为奖励) 。

模型选择：RM可以是另一个经过微调的LM，也可以是根据偏好数据从头开始训练的LM。Anthropic 提出了一种特殊的预训练方式，即用偏好模型预训练 (Preference Model Pretraining，PMP) 来替换一般预训练后的微调过程，PMP对样本的利用率更高。
训练文本：RM 的提示 - 生成对文本是从预定义数据集中采样生成的，并用初始的 LM 给这些提示生成文本。Anthropic 的数据主要是通过 Amazon Mechanical Turk 上的聊天工具生成的，并在 Hub 上可用，而 OpenAI 使用了用户提交给 GPT API 的 prompt。
训练奖励数值：人工对 LM 生成的回答进行排名。起初我们可能会认为应该直接对文本标注分数来训练 RM，但是由于标注者的价值观不同导致这些分数未经过校准并且充满噪音，通过排名可以比较多个模型各自的输出并构建更好的规范数据集，这些不同的排名结果将被归一化为用于训练的标量奖励值。

目前成功的RLHF使用了和要对齐的LM具有不同大小的LM：

OpenAI：175B的LM和6B的RM
Anthropic：使用的 LM 和 RM 从 10B 到 52B 大小不等
DeepMind：使用了 70B 的 Chinchilla 模型分别作为 LM 和 RM

rl

直接微调整个 10B～100B+ 参数的成本过高，参考低秩自适应LoRA和DeepMind的Sparrow LM。目前多个组织找到的可行方案是使用策略梯度强化学习 (Policy Gradient RL) 算法、近端策略优化 (Proximal Policy Optimization，PPO) 微调初始 LM 的部分或全部参数。

策略 (policy)：一个接受提示并返回一系列文本 (或文本的概率分布) 的 LM
行动空间（action space）： LM 的词表对应的所有词元 (一般在 50k 数量级)
观察空间 (observation space)：是可能的输入词元序列，也比较大 (词汇量^输入标记的数量)
奖励函数：偏好模型和策略转变约束 (Policy shift constraint) 的结合。

ppo确定的奖励函数如下：

惩罚项的好处：

用于惩罚策略在每个训练batch中生成大幅偏离初始模型，以确保模型输出合理连贯的文本。
如果没有这一项，可能导致模型在优化中生成乱码文本，以愚弄奖励模型提供高奖励值。

根据PPO，按当前batch的奖励进行优化。PPO是置信域优化（TRO，Trust Region Optimization）算法，用梯度约束确保更新步骤不会破坏学习过程的稳定性。

DeepMind对Gopher用了类似的奖励设置，但用的是A2C来优化梯度。

rl流程概述

https://zhuanlan.zhihu.com/p/635757674

Fine-Tuning Language Models from Human Preferences

Secrets of RLHF in Large Language Models Part I: PPO

Rollout and Evaluation：从prompt库里抽样，使用语言模型生成response，然后使用奖励模型（Reward Model, RM）给出奖励得分。这个得分反映了生成的response的质量，比如它是否符合人类的偏好，是否符合任务的要求等。
Make experience：收集了一系列的“经验”，即模型的行为和对应的奖励。这些经验包括了模型生成的response以及对应的奖励得分。这些经验将被用于下一步的优化过程。
Optimization：使用收集到的经验来更新模型的参数。具体来说，我们使用PPO算法来调整模型的参数，使得模型生成的response的奖励得分能够增加。PPO算法的一个关键特性是它尝试保持模型的行为不会发生太大的改变，这有助于保证模型的稳定性。

官方代码example

from tqdm import tqdm

for epoch, batch in tqdm(enumerate(ppo_trainer.dataloader)):
    query_tensors = batch["input_ids"]

    #### Get response from SFTModel
    response_tensors = ppo_trainer.generate(query_tensors, **generation_kwargs)
    batch["response"] = [tokenizer.decode(r.squeeze()) for r in response_tensors]

    #### Compute reward score
    texts = [q + r for q, r in zip(batch["query"], batch["response"])]
    pipe_outputs = reward_model(texts)
    rewards = [torch.tensor(output[1]["score"]) for output in pipe_outputs]

    #### Run PPO step
    stats = ppo_trainer.step(query_tensors, response_tensors, rewards)
    ppo_trainer.log_stats(stats, batch, rewards)

#### Save model
ppo_trainer.save_model("my_ppo_model")

Rollout：根据策略（LM）生成轨迹（文本）。
- 输入：Batch Prompt、LM
- 输出：Prompt+Response
Evaluate：对生成的轨迹进行评估（RM）。
- 输入：Prompt+Response、RM
- 输出：Reward
Old Policy Sampling：计算并存储旧策略的概率、价值等值，
- 输入：Ref_model、Actor、Critic、Prompt+Response
- 输出：Ref Logprobs、Old Logprobs、Old Values
KL Penalty：计算当前策略和原始LM之间的KL散度，用作对策略改变过快的惩罚项。
- 输入：Ref Logprobs、Old Logprobs、Reward
- 输出：Token Reward
Generalized Advantage Estimation (GAE)：G。基于old value(shape是(batch_size, response_length))和reward估计优势函数A，它结合了所有可能的n-step 进行advantage估计
- 输入：Token Reward、Old Values
- 输出：Advantages、Returns
New Policy Sampling：
- 输入ref_model、actor、critic，从新的策略中采样概率等信息，
- 输出new logprobs、new values和logits，供actor loss、critic loss以及entropy loss用。
Critic Loss：Critic的目标是估计状态的价值函数，Critic loss就是价值函数预测值和实际回报之间的差距。
- 输入：New Values、Returns
- 输出：critic梯度更新
Actor Loss：Actor的目标是优化策略，Actor loss就是基于优势函数的策略梯度。
- 输入：Old Logprobs，New Logprobs、Advantages
- 输出：actor梯度更新
Entropy Loss：为了增加探索性，通常会添加一个基于策略熵的正则项，它鼓励策略保持多样性。
- 输入：Logits
- 输出：entropy loss
Policykl：这是对策略迭代过程的一个度量，它度量新策略和旧策略之间的差距。
- 输入：Old Logprobs、New Logprobs
- 输出：是否early stop

在PPO中，策略优化的过程涉及到两个策略：一个是"旧的"策略，这是我们在开始每次优化迭代时使用的策略，另一个是"新的"策略，这是我们在优化过程中不断更新的策略。

自己整理重画的

几个重要的loss

actor & actor loss

Actor 是策略，它决定文本会被怎么样生成，是从策略网络拷贝来的模拟整个智能体在环境中行动的网络。

优势函数表示在给定的状态下采取某个行动比遵循当前策略的期望回报要好多少。

Actor Loss如下，用重要性采样比较在旧策略和新策略下行动的概率（Old Logprobs，New Logprobs），然后将这个比值（也就是 Importance Sampling 的权重）与优势函数Advantages相乘，得到了对 Actor Loss 的一个估计。

# 计算新旧策略下概率的比值
ratio = torch.exp(logprobs - old_logprobs)

# 计算未截断的策略梯度损失
pg_losses = -advantages * ratio

# 计算截断的策略梯度损失
pg_losses2 = -advantages * torch.clamp(ratio, 1.0 - self.config.cliprange,
     1.0 + self.config.cliprange)

# 选择两者中较大的作为最终的策略梯度损失
pg_loss = masked_mean(torch.max(pg_losses, pg_losses2), mask)

# 计算因为截断导致策略梯度损失改变的比例
pg_clipfrac = masked_mean(torch.gt(pg_losses2, pg_losses).double(), mask)

critic & critic loss

critic是专门用来预测actor轨迹每一步价值的网络，actor上加几个线性层能够给每个token预测一个值。任务是估计状态的价值函数，也就是预测从当前状态开始，通过遵循某个策略，期望能得到的总回报。

Critic Loss是最小化它的预测价值与实际回报之间的差距，常用mse

通过最小化Critic Loss，Critic的预测能力会逐渐提升。因为Critic的预测结果会被用来估计每个行动的优势（Advantage），这个优势值又会被用来计算策略的更新（Actor Loss）。

# 将价值函数的预测值裁剪到一个范围内
vpredclipped = clip_by_value(
            vpreds, values - self.config.cliprange_value, values + self.config.cliprange_value
        )

# 计算裁剪前和裁剪后的价值函数损失
vf_losses1 = (vpreds - returns) ** 2
vf_losses2 = (vpredclipped - returns) ** 2

# 最终的价值函数损失是裁剪前和裁剪后损失的最大值的平均值的一半
vf_loss = 0.5 * masked_mean(torch.max(vf_losses1, vf_losses2), mask)

# 计算裁剪操作实际发生的频率
vf_clipfrac = masked_mean(torch.gt(vf_losses2, vf_losses1).double(), mask)

KL Penalty

用于保证经过强化学习后的模型（新策略actor）不会过于偏离原始预训练模型（ref model）。

# 初始化两个列表来分别存储奖励和非得分奖励
rewards, non_score_rewards = [], []

# 使用 zip 函数并行遍历输入的得分、对数概率、参考模型的对数概率以及mask
for score, logprob, ref_logprob, mask in zip(scores, logprobs, 
        ref_logprobs, masks):
    # 计算 KL 散度，即模型的对数概率与参考模型的对数概率之间的差值
    kl = logprob - ref_logprob

    # 计算非得分奖励，即 KL 散度乘以 KL 控制器值的负值
    non_score_reward = -self.kl_ctl.value * kl
    non_score_rewards.append(non_score_reward)

    # 复制非得分奖励为新的奖励
    reward = non_score_reward.clone()

    # 找到mask中最后一个非零元素的索引，这表示输入序列的实际长度
    last_non_masked_index = mask.nonzero()[-1]

    # 对于最后一个非mask部分的token，其奖励是偏好模型的得分加上 KL 散度
    reward[last_non_masked_index] += score

    # 将计算的奖励添加到奖励列表中
    rewards.append(reward)

# 返回包含所有奖励的张量以及包含所有非得分奖励的张量
return torch.stack(rewards), torch.stack(non_score_rewards)

GAE

# 从后往前遍历整个生成的序列
for t in reversed(range(gen_len)):
    # 计算下一个状态的价值，如果当前状态已经是最后一个状态，则下一个状态的价值为0
    nextvalues = values[:, t + 1] if t < gen_len - 1 else 0.0

    # 计算 delta，它是奖励加上衰减后的下一个状态的价值，然后减去当前状态的价值
    delta = rewards[:, t] + self.config.gamma * nextvalues - values[:, t]

    # 使用 delta 更新 lastgaelam，这是 GAE 公式的一部分
    lastgaelam = delta + self.config.gamma * self.config.lam * lastgaelam

    # 将计算的优势值添加到优势值列表中
    advantages_reversed.append(lastgaelam)

# 将优势值列表反向并转换为张量
advantages = torch.stack(advantages_reversed[::-1]).transpose(0, 1)

# 计算回报值，它是优势值加上状态值
returns = advantages + values

entropy loss

一个策略的熵越大，意味着这个策略选择各个动作的概率更加“平均”。在actor的loss里加熵，使得策略的熵尽可能大，从而有更多机会探索可能带来更好奖励的文本轨迹。

entropy = -torch.sum(logits* torch.log(logits + 1e-9), dim=-1).mean()

新实现：

    pd = torch.nn.functional.softmax(logits, dim=-1)
    entropy = torch.logsumexp(logits, axis=-1) - torch.sum(pd * logits, axis=-1)

Policy kl

在PPO中，KL散度被用作一种约束，以确保在优化过程中新策略不会偏离旧策略太远。这是为了防止过度优化，因为过度优化可能会导致策略性能的大幅下降。

我们希望在优化目标函数的同时，满足以下的KL散度约束：

# 计算旧策略和新策略之间的KL散度
policykl = masked_mean(old_logprobs - logprobs, mask) 
# old_logprobs 是旧策略下行为的概率的对数，logprobs 是新策略下的对数概率
# masked_mean 函数计算差异（old_logprobs - logprobs）的平均值，
# 但只考虑mask中对应元素为True的元素

# 检查计算出的KL散度（policykl）是否大于目标KL散度（self.config.target_kl）的1.5倍
if policykl > 1.5 * self.config.target_kl: 
    self.optimizer.zero_grad()  
    # 如果实际的KL散度超过了目标的1.5倍，那么策略改变过多，这步的梯度也不更新了。
    early_stop = True  
    # 并设置early_stop标志为True，表示应提前停止优化，以防止策略从旧策略进一步偏离

两个采样

Old Policy Sampling（无bp）

是make experience的过程，计算并存储旧策略的概率、价值等值，来为后面更新的过程服务。

Old Logprobs：从“旧的”策略[即在这个batch数据中初始的LM（initial actor）]中计算每个token在旧的策略下的概率Old Logprobs。
Old Values：旧策略中每个时间步（每个token的预测结果）的价值，这个值由critic网络进行预测，critic网络就是需要这个值的原因是advantage的计算依赖于Old Values。
Ref Logprobs：最最原始的LM对于每个时间步的概率预测，一般就是固定不变的gpt3，计算这个值的目的是限制actor的更新，防止其偏离原始gpt3太远，他的实现在下一个步骤中。

all_logprobs, _, values, masks = self.batched_forward_pass(self.model, queries, 
    responses, model_inputs)
ref_logprobs, _, _, _ = self.batched_forward_pass(self.ref_model, queries, 
    responses, model_inputs)

New Policy Sampling（有bp）

在新的策略（更新后的actor）下对轨迹（文本）计算概率的过程，计算Actor Loss，即策略梯度的损失。

Old Logprobs是一次性一个batch的数据计算的，这是因为在一个batch中旧策略都是不变的；而New Logprobs是一个mini batch计算一次，这是因为新策略每个mini batch变一次。

开源rlhf库

https://iclr-blog-track.github.io/2022/03/25/ppo-implementation-details/

影响PPO算法性能的10个关键技巧（附PPO算法简洁Pytorch实现）

openai的lm-human-preferences(gpt2的finetune)

https://github.com/openai/lm-human-preferences

huggingface的TRL

https://github.com/huggingface/trl

CarperAI的trlx

https://github.com/CarperAI/trlx

allenai的RL4LMs

https://github.com/allenai/RL4LMs

RLHF workflow

仅靠开源数据复刻出LLaMA3指令学习效果，在线迭代RLHF全流程解决方案来了

Iterative Preference Learning from Human Feedback: Bridging Theory and Practice for RLHF under KL-Constraint

RLHF Workflow: From Reward Modeling to Online RLHF

对应代码：

openrlhf

这个团队做了OpenAI没Open的技术，开源OpenRLHF让对齐大模型超简单

OpenRLHF: An Easy-to-use, Scalable and High-performance RLHF Framework

https://github.com/OpenLLMAI/OpenRLHF

Alignment：RLHF变种

Alignment综述

大模型微调（八）：SFT for Alignment 总结纪要

2024年大模型Alignment偏好优化技术：从PPO, SPO到MCTS-DPO

https://alignmentsurvey.com/

中文版

AI Alignment: A Comprehensive Survey

DPO

Direct preference optimization: Your language model is secretly a reward model

https://github.com/eric-mitchell/direct-preference-optimization

在contextual bandit的设定下，DPO 通过数学推导，得到了奖励函数与最优策略之间的直接映射，消除了RLHF过程中的奖励建模阶段，

代入Bradley-Terry模型，可以得到

其中：

具体实现：

def preference_loss(policy_chosen_logps: torch.FloatTensor,
                    policy_rejected_logps: torch.FloatTensor,
                    reference_chosen_logps: torch.FloatTensor,
                    reference_rejected_logps: torch.FloatTensor,
                    beta: float,
                    label_smoothing: float = 0.0,
                    ipo: bool = False,
                    reference_free: bool = False) -> Tuple[torch.FloatTensor, 
                        torch.FloatTensor, torch.FloatTensor]:

    pi_logratios = policy_chosen_logps - policy_rejected_logps
    ref_logratios = reference_chosen_logps - reference_rejected_logps

    if reference_free:
        ref_logratios = 0

    logits = pi_logratios - ref_logratios  # also known as h_{\pi_\theta}^{y_w,y_l}

    if ipo:
        # Eq. 17 of https://arxiv.org/pdf/2310.12036v2.pdf
        losses = (logits - 1/(2 * beta)) ** 2  
    else:
        # Eq. 3 https://ericmitchell.ai/cdpo.pdf; 
        # label_smoothing=0 gives original DPO 
        # (Eq. 7 of https://arxiv.org/pdf/2305.18290.pdf)
        losses = -F.logsigmoid(beta * logits) * (1 - label_smoothing) - 
            F.logsigmoid(-beta * logits) * label_smoothing

    chosen_rewards = beta * (policy_chosen_logps - reference_chosen_logps).detach()
    rejected_rewards = beta * (policy_rejected_logps - reference_rejected_logps).detach()

    return losses, chosen_rewards, rejected_rewards

RLHF与DPO对比：

RLHF优化的是token-level的value functions，对应的是terminate state的sparse reward。
DPO则是在context bandit的设定下，将整个response看成一个arm。虽然token是一个个生成的，但在RL里一般dense rewards效果更好。

CriticGPT依旧是自回归模型。标注者先向ChatGPT的响应输出中人为注入一些微妙的错误，CriticGPT针对这些有错误的答案生成批评意见，之后再由人类训练师为批评意见进行打分排名。

DeRa

ICML 2024 Spotlight | 在解码中重新对齐，让语言模型更少幻觉、更符合人类偏好

Decoding-time Realignment of Language Models

https://github.com/liutianlin0121/decoding-time-realignment

Step-DPO

贾佳亚团队新作：10k数据让大模型数学能力超GPT-4

https://github.com/dvlab-research/Step-DPO

Step-DPO: Step-wise Preference Optimization for Long-chain Reasoning of LLMs

超越DPO！大模型精细化对齐之Step-DPO

RBR

RLHF不够用了，OpenAI设计出了新的奖励机制

Rule Based Rewards for Language Model Safety

https://openai.com/index/improving-model-safety-behavior-with-rule-based-rewards/

https://github.com/openai/safety-rbr-code-and-data

RLLR

ACL2024 | RLHF在腾讯广告自然语言理解任务上的优化及应用

Enhancing Reinforcement Learning with Label-Sensitive Reward for Natural Language Understanding

更适合NLU任务的强化学习方法RLLR（Reinforcement Learning with Label-Sensitive Reward），与RLHF相比可以一致地提升多种NLU任务上的标签准确率；进一步地，通过结合RLHF和RLLR的两个Reward Model，RLLR-mixed方法可以在标签准确率和理由质量上取得全面提升。

原始RLHF直接用在NLU

将NLU任务改写为自然语言的形式，让模型对同一个问题输出多条回复，每条回复包括两部分：
- 理由（rationale）：可以视为思维链的一种简化版本
- 标签（label）
对同一个问题的不同回复进行排序，并处理成回复对（pair）的形式。
- 标签敏感对（label-sensitive pair）：标签不同的回复对
- 理由敏感对（rationale-sensitive pair）：标签相同、理由不同的回复对

在7个公开数据集上，理由敏感对的占比都超过75%。在理由敏感对中，两个不同的理由会导向相同的标签，理论上说，模型在这些数据上进行训练只会使理由更符合标注者的偏好，但对标签的准确性没有帮助；而在NLU任务上，我们实际更关心标签的准确性，因此存在模型训练目标与评估指标不一致的问题。

RLLR

SFT训练：除了标签之外，我们还为数据集标注了理由，参考CoT的方式，先让模型生成一段理由，再根据理由输出标签，训练得到Policy Model；
Reward Model训练：训练两个reward model：
- 标签敏感RM：解决原始RLHF中标签敏感对比例较低的问题：对于一条训练集中的样本，我们已有正确的标签标注，并且也知道所有可能的标签集合，因此可以随机采样一个错误的标签，并为错误的标签标注理由，与正确标签+理由构成标签敏感对，并基于此方法构造的数据训练单独的Reward Model；
- 理由敏感RM：对于训练集中的每条样本，我们基于正确的标签采样多条理由，根据理由的生成质量来构建理由敏感对，并训练理由敏感的Reward Model，此处理由质量可以采用人工判断或AI辅助的方式标注，根据准确性、一致性、逻辑性、事实性、相关性和信息完整性进行排序。
PPO训练：使用Reward Model和的Policy Model进行强化学习训练。
- RLLR：只用标签敏感RM训练