Hugging Face 在 TRL 推出 RLOO Trainer,作為 PPO 的線上 RLHF 替代方案
Putting RL back in RLHF
Hugging Face 在 TRL 引入 RLOO Trainer,這是一種較 PPO 更易實作、較省 GPU 記憶體的線上 RLHF 訓練方法。測試顯示,RLOO 約比 PPO 少用 50–70% vRAM,1B 模型快 2 倍、6.9B 模型最高快 3 倍;6.9B checkpoint 的 GPT4 評審偏好率為 78.7%(k=2)。
文章對照 RLOO 與 PPO 的 GPU 記憶體用量、訓練速度及回答勝率,並披露 bf16 下 RLOO 有較多批次資料的梯度被清零。
我們很高興在 TRL 推出 RLOO(REINFORCE Leave One-Out)Trainer。RLOO 是 PPO 的替代方案,屬於新型線上 RLHF 訓練演算法,設計上更易上手和實作。特別是,RLOO 所需 GPU 記憶體較少,收斂所需的實際時間也較短。如下圖所示:
- 🤑視乎模型大小,RLOO 使用的 vRAM 約比 PPO 少 50–70%
- 🚀使用 1B 模型時,RLOO 比 PPO 快 2 倍;使用 6.9B 模型時,則快至 3 倍。
- 🔥以回應勝出率(由 GPT4 評判)衡量,RLOO 的表現媲美 PPO,而且持續勝過 DPO 等常見離線方法。
透過 RLOO,我們讓強化學習重回 RLHF,令社羣更容易探索線上 RL 方法。這令人振奮,因為愈來愈多研究顯示,線上 RL 比 DPO 等離線方法更有效(https://arxiv.org/abs/2402.04792、https://arxiv.org/abs/2405.08448)。
本文會説明推出 RLOO Trainer 的動機、運作方式,以及如何在 TRL 中使用。
動機
PPO 是一種有效的線上 RLHF 訓練演算法,用來訓練 GPT-4 等最先進模型。不過,PPO 在實際使用時頗具挑戰,原因是它對 GPU 記憶體的需求很高。具體而言,PPO 需要把模型載入記憶體 4 次:1) 策略模型、2) 參考策略模型、3) 獎勵模型,以及 4) 價值模型,如下圖所示。PPO 還有許多細微的實作細節,容易出錯(Engstrom et al; 2020、Huang et al 2022)。
Cohere 發表的一篇新論文中,Ahmadian et al. (2024) 重新審視 RLHF 訓練的基本原理,提出一種更簡潔的新型線上訓練演算法 RLOO。RLOO 只需把模型載入記憶體 3 次:1) 策略模型、2) 參考策略模型,以及 3) 獎勵模型,如上圖所示。
重要的是,RLOO 所需記憶體較少,因此更容易:
- 在執行時避免 OOM(記憶體不足)錯誤;
- 載入更大的批次;
- 執行得更有效率、更快。
此外,RLOO 把整段生成內容的所有 token 視為單一動作,如下圖所示。下一節會透過程式碼片段進一步説明。
RLOO 的運作方式
RLOO 和 PPO 有幾個共通步驟:
策略模型會生成一些後續 token,並在目前策略和參考策略之下取得每個 token 的對數機率。
接着,我們以目前策略和參考策略的對數機率之差,計算每個 token 的 KL 懲罰。
然後,我們使用獎勵模型,為整段生成內容取得評分。
從這裏開始,標準 PPO 和 RLOO 的做法便有所不同。RLOO 有幾個核心概念。首先,它把整段模型生成內容視為單一動作,而標準 PPO 則把生成內容中的每個 token視為獨立動作。一般只有 EOS token 會獲得實際獎勵,因此獎勵十分稀疏。標準 PPO 會把獎勵歸給 EOS token;RLOO 則會把該 EOS 獎勵歸給整段生成內容,如下所示。
from torch import Tensor
response = Tensor([4., 5., 6.])
per_token_logprobs = Tensor([-12.3, -8.3, -2.3])
reference_per_token_logprobs = Tensor([-11.3, -8.4, -2.0])
kl = per_token_logprobs - reference_per_token_logprobs
score_from_rm = 1.0
print(f"{kl=}") # kl=tensor([-1.0000, 0.1000, -0.3000])
per_token_reward = kl.clone()
per_token_reward[-1] += score_from_rm # assume last token is the EOS token
print(f"{per_token_reward=}") # per_token_reward=tensor([-1.0000, 0.1000, 0.7000])
print(f"{score_from_rm=}") # score_from_rm=1.0
print("#### Modeling each token as an action")
for action, reward in zip(response, per_token_reward):
print(f"{action=}, {reward=}")
# action=tensor(4.), reward=tensor(-1.)
# action=tensor(5.), reward=tensor(0.1000)
# action=tensor(6.), reward=tensor(0.7000)
print("#### Modeling the entire response as an action")
entire_generation_reward = per_token_reward.sum()
print(f"action='entire completion', reward={entire_generation_reward}")
# action='entire completion', reward=-0.2000 (-1 + 0.1 + 0.7)
其次,RLOO 使用 REINFORCE 損失,基本上就是把(獎勵 − 基線)乘以動作的對數機率。這裏我們比較逐 token 的 REINFORCE 損失與整段生成內容的 REINFORCE 損失。請注意,PPO 的損失還需要根據價值模型額外計算優勢值,方法是使用 Generalized Advantage Estimation(GAE,廣義優勢估計)。
from torch import Tensor
response = Tensor([4., 5., 6.])
per_token_logprobs = Tensor([-12.3, -8.3, -2.3])
reference_per_token_logprobs = Tensor([-11.3, -8.4, -2.0])
kl = per_token_logprobs - reference_per_token_logprobs
score_from_rm = 1.0
print(f"{kl=}") # kl=tensor([-1.0000, 0.1000, -0.3000])
per_token_reward = kl.clone()
per_token_reward[-1] += score_from_rm # assume last token is the EOS token
print(f"{per_token_reward=}") # per_token_reward=tensor([-1.0000, 0.1000, 0.7000])
print(f"{score_from_rm=}") # score_from_rm=1.0
print("#### Modeling each token as an action")
for action, reward in zip(response, per_token_reward):
print(f"{action=}, {reward=}")
# action=tensor(4.), reward=tensor(-1.)
# action=tensor(5.), reward=tensor(0.1000)
# action=tensor(6.), reward=tensor(0.7000)
print("#### Modeling the entire response as an action")
entire_generation_reward = per_token_reward.sum()
print(f"action='entire completion', reward={entire_generation_reward}")
# action='entire completion', reward=-0.2000 (-1 + 0.1 + 0.7)
baseline = Tensor([0.2, 0.3, 0.4]) # dummy baseline
print("#### Modeling each token as an action")
advantage = per_token_reward - baseline
per_token_reinforce_loss = per_token_logprobs * advantage
print(f"{advantage=}") # advantage=tensor([-1.2000, -0.2000, 0.3000])
print(f"{per_token_reinforce_loss=}") # per_token_reinforce_loss=tensor([14.7600, 1.6600, -0.6900])
print(f"{per_token_reinforce_loss.mean()=}") # per_token_reinforce_loss.mean()=tensor(5.2433)
print("#### Modeling the entire response as an action")
advantage = entire_generation_reward - baseline.sum()
reinforce_loss = per_token_logprobs.sum() * advantage
print(f"{advantage=}") # advantage=tensor(-1.1000)
print(f"{reinforce_loss=}") # reinforce_loss=tensor(25.1900)
第三,RLOO 會巧妙地計算基線。請留意上圖使用的是虛設基線。實際上,RLOO 會以批次中其他所有樣本的獎勵作為基線。以下例子有 3 個提示,每個提示各有 4 個生成結果。我們會把同一提示下其他生成結果的獎勵取平均,為每個生成結果計算基線。
import torch
local_batch_size = 3
rloo_k = 4
rlhf_reward = torch.tensor([
1, 2, 3, # first rlhf reward for three prompts
2, 3, 4, # second rlhf reward for three prompts
5, 6, 7, # third rlhf reward for three prompts
8, 9, 10, # fourth rlhf reward for three prompts
]).float() # here we have 3 prompts which have 4 completions each
# slow impl
baseline = (rlhf_reward.sum(0) - rlhf_reward) / (rloo_k - 1)
advantages = torch.zeros_like(rlhf_reward)
for i in range(0, len(advantages), local_batch_size):
other_response_rlhf_rewards = []
for j in range(0, len(advantages), local_batch_size):
if i != j:
other_response_rlhf_rewards.append(rlhf_reward[j : j + local_batch_size])
advantages[i : i + local_batch_size] = rlhf_reward[i : i + local_batch_size] - torch.stack(
other_response_rlhf_rewards
).mean(0)
assert (1 - (2 + 5 + 8) / 3 - advantages[0].item()) < 1e-6
assert (6 - (3 + 2 + 9) / 3 - advantages[7].item()) < 1e-6
# vectorized impl
rlhf_reward = rlhf_reward.reshape(rloo_k, local_batch_size)
baseline = (rlhf_reward.sum(0) - rlhf_reward) / (rloo_k - 1)
vec_advantages = rlhf_reward - baseline
torch.testing.assert_close(vec_advantages.flatten(), advantages)
特別感謝 Arash Ahmadian 提供上述優勢值計算的向量化實作。
開始使用 TRL 的 RLOO
要開始使用 RLOO,可以透過 pip install --upgrade trl 安裝最新版 TRL,然後匯入 RLOOTrainer。以下是一段簡短程式碼,展示高階 API 的用法。你也可以參閲説明文件:
- https://huggingface.co/docs/trl/main/en/rloo_trainer
- https://huggingface.co/docs/trl/main/en/ppov2_trainer
from transformers import (
AutoModelForCausalLM,
AutoModelForSequenceClassification,
AutoTokenizer,
)
from trl.trainer.rloo_trainer import RLOOConfig, RLOOTrainer
from trl.trainer.utils import SIMPLE_QUERY_CHAT_TEMPLATE
base_model_name = "EleutherAI/pythia-1b-deduped"
tokenizer = AutoTokenizer.from_pretrained(base_model_name, padding_side="left")
tokenizer.add_special_tokens({"pad_token": "[PAD]"})
if tokenizer.chat_template is None:
tokenizer.chat_template = SIMPLE_QUERY_CHAT_TEMPLATE
reward_model = AutoModelForSequenceClassification.from_pretrained(base_model_name, num_labels=1)
ref_policy = AutoModelForCausalLM.from_pretrained(base_model_name)
policy = AutoModelForCausalLM.from_pretrained(base_model_name)
train_dataset = ... # make sure to have columns "input_ids"
eval_dataset = ...
trainer = RLOOTrainer(
config=RLOOConfig(
per_device_train_batch_size=1,
gradient_accumulation_steps=64,
total_episodes=30000,
),
tokenizer=tokenizer,
policy=policy,
ref_policy=ref_policy,
reward_model=reward_model,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
)
trainer.train()
以下是已追蹤權重與偏差的實驗範例:https://wandb.ai/huggingface/trl/runs/dd2o3g35
編寫 RLOO 和 PPOv2 實作時,我們着重提升模型開發的透明度。具體而言,我們加強了文件內容,加入已記錄指標的説明,以及閲讀和除錯這些指標的實用指南。例如,我們建議訓練期間密切監察 objective/rlhf_reward,這是 RLHF 訓練的最終目標。
為了直觀呈現訓練進度,我們會定期記錄模型生成的部分範例。以下是一個生成結果的例子。在 Weights and Biases 的一個已追蹤執行記錄中(https://wandb.ai/huggingface/trl/runs/dd2o3g35),結果如下,讓你看到模型在訓練不同階段的回應。預設情況下,訓練期間會生成 --num_sample_generations 10 個樣本;你可以自行設定生成數量。
我們如何在 TRL 實作 RLOO Trainer
我們以新的實驗性 PPOv2Trainer 為基礎實作 RLOO Trainer,而 PPOv2Trainer 本身則建基於 https://arxiv.org/abs/2403.17031。有趣的是,我們的 RLOO Trainer 實作仍然使用 PPO 損失,因為 REINFORCE 損失是 PPO 的一個特例(https://arxiv.org/abs/2205.09123)。請注意,雖然 REINFORCE 損失明確包含對數機率,PPO 損失中也隱含了對數機率。眼見為實,讓我們用一個簡單例子來示範。
import torch.nn.functional as F
from torch import LongTensor, Tensor, gather, no_grad
action = LongTensor([1])
advantage = Tensor([1.0])
logits = Tensor([[1.0, 2.0, 1.0, 1.0]])
logits.requires_grad = True
all_logprob = F.log_softmax(logits, dim=-1)
with no_grad():
old_logprob = gather(all_logprob, 1, action.unsqueeze(-1)).squeeze(-1)
logprob = gather(all_logprob, 1, action.unsqueeze(-1)).squeeze(-1)
ratio = (logprob - old_logprob).exp()
ppo_loss = (ratio * advantage).mean() # [πθ(at | st) / πθ_old(at | st) * At]
# when the πθ and πθ_old are the same, the ratio is 1, and PPO's clipping has no effect
ppo_loss.backward()
print(f"{logits.grad=}") # tensor([[-0.1749, 0.5246, -0.1749, -0.1749]])
logits2 = Tensor([[1.0, 2.0, 1.0, 1.0]])
logits2.requires_grad = True
all_logprob2 = F.log_softmax(logits2, dim=-1)
logprob2 = gather(all_logprob2, 1, action.unsqueeze(-1)).squeeze(-1)
reinforce_loss = logprob2 * advantage # [log πθ(at | st) * At]
reinforce_loss.mean().backward()
print(f"{logits2.grad=}") # tensor([[-0.1749, 0.5246, -0.1749, -0.1749]])
實驗
為驗證 RLOO 實作是否正常運作,我們在 Pythia 1B 和 6.9B 模型上進行實驗,並在此發布訓練完成的檢查點:
SFT/RM 模型直接取自 Huang et al., 2024。評估時,我們使用 vLLM 載入檢查點,並以 GPT4 作為評判模型,評估生成的 TL;DR 與參考 TL;DR 是否相符。我們也查看 GPU 記憶體用量和執行時間,結果如本文開首的圖表所示。若要重現我們的工作,歡迎參閲説明文件中的指令:
- https://huggingface.co/docs/trl/main/en/rloo_trainer#benchmark-experiments
- https://huggingface.co/docs/trl/main/en/rloo_trainer#benchmark-experiments
主要結果如下:
- **🚀效能卓越的 RLOO 檢查點:**6.9B 檢查點由 GPT4 評判時,偏好率達 78.7%(k=2),高於原文已報告的最佳表現 77.9%(k=4)和 74.2(k=2);這些結果出自該原始論文。這是個好跡象,顯示我們的 RLOO 訓練正按預期運作。
- RLOO 1B 檢查點的勝出率為 40.1%,SFT 檢查點則為 21.3%。這是個好跡象,顯示 RLOO 訓練正按預期運作。
- 🤑更省 GPU 記憶體,執行也更快:RLOO 訓練所需記憶體較少,執行速度也更快,是非常實用的線上 RL 訓練演算法。
數值穩定性:暗藏的問題
儘管 RLOO 在效能和運算效率方面有優勢,我們仍想指出一些數值問題。具體而言,在 bf16 下,生成期間取得的回應對數機率,與訓練前向傳播期間取得的對數機率略有數值差異。PPO 和 RLOO 都會受此問題影響,但 RLOO 的情況嚴重得多,以下會解釋原因。
例如,假設要為兩個序列生成 10 個 token。在 fp32 精度下,輸出如下;其中 ratio = (forward_logprob - generation_logprob).exp() 是 PPO 用來裁剪的比率。在第一個 epoch 和第一個 minibatch 中,比率理應完全相同,因為模型尚未更新:
generation_logprob=tensor([[ -0.1527, -0.2258, -3.5535, -3.4805, -0.0519,
-2.3097, -2.0275, -0.4597, -0.1687, -0.0000],
[ -0.1527, -0.2258, -5.2855, -0.1686, -8.4760,
-4.3118, -1.0368, -0.8274, -1.6342, -2.6128]],
device='cuda:0')
forward_logprob=tensor([[-0.1527, -0.2258, -3.5535, -3.4805, -0.0519, -2.3097, -2.0275, -0.4597,
-0.1687],
[-0.1527, -0.2258, -5.2855, -0.1686, -8.4760, -4.3118, -1.0368, -0.8274,
-1.6342]], device='cuda:0', grad_fn=<SqueezeBackward1>)
ratio=tensor([[1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],
[1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000]],
device='cuda:0', grad_fn=<ExpBackward0>)
ratio.mean()=0.9999998211860657
ratio.std()=6.592738373001339e-06
ratio.max()=1.0000133514404297
ratio.min()=0.9999887943267822
然而,在 bf16 下,結果是
generation_logprob=tensor([[ -0.1426, -0.1904, -3.5938, -3.4688, -0.0618,
-2.3906, -2.0781, -0.4375, -0.1562, -0.0000],
[ -0.1426, -0.1904, -5.2812, -0.1641, -8.5625,
-4.2812, -1.0078, -0.8398, -1.5781, -2.5781]],
device='cuda:0', dtype=torch.bfloat16)
forward_logprob=tensor([[-0.1445, -0.1670, -3.5938, -3.5156, -0.0554, -2.2969, -1.9688, -0.5273,
-0.1953],
[-0.1445, -0.1670, -5.2812, -0.1533, -8.5625, -4.3125, -1.0000, -0.7852,
-1.6641]], device='cuda:0', dtype=torch.bfloat16,
grad_fn=<SqueezeBackward1>)
ratio=tensor([[1.0000, 0.9766, 1.0000, 1.0469, 0.9922, 0.9102, 0.8945, 1.0938, 1.0391],
[1.0000, 0.9766, 1.0000, 0.9883, 1.0000, 1.0312, 0.9922, 0.9453, 1.0859]],
device='cuda:0', dtype=torch.bfloat16, grad_fn=<ExpBackward0>)
ratio.mean()=1.0
ratio.std()=0.051025390625
ratio.max()=1.09375
ratio.min()=0.89453125
而在 fp16 下,結果是
generation_logprob=tensor([[ -0.1486, -0.2212, -3.5586, -3.4688, -0.0526,
-2.3105, -2.0254, -0.4629, -0.1677, -0.0000],
[ -0.1486, -0.2212, -5.2852, -0.1681, -8.4844,
-4.3008, -1.0322, -0.8286, -1.6348, -2.6074]],
device='cuda:0', dtype=torch.float16)
forward_logprob=tensor([[-0.1486, -0.2212, -3.5586, -3.4805, -0.0529, -2.3066, -2.0332, -0.4629,
-0.1676],
[-0.1486, -0.2212, -5.2852, -0.1682, -8.4766, -4.3008, -1.0322, -0.8281,
-1.6299]], device='cuda:0', dtype=torch.float16,
grad_fn=<SqueezeBackward1>)
ratio=tensor([[1.0000, 1.0000, 1.0000, 1.0117, 1.0000, 0.9961, 1.0078, 1.0000, 1.0000],
[1.0000, 1.0000, 1.0000, 1.0000, 0.9922, 1.0000, 1.0000, 0.9995, 0.9951]],
device='cuda:0', dtype=torch.float16, grad_fn=<ExpBackward0>)
ratio.mean()=1.0
ratio.std()=0.00418853759765625
ratio.max()=1.01171875
ratio.min()=0.9921875
請注意,bf16 的比率因某些原因非常不穩定。當比率變大時,PPO 的裁剪係數 = 0.2 便會生效,將比率高於 1.2 或低於 0.8 的 token 梯度歸零。RLOO 的問題更嚴重,因為我們查看的是 (forward_logprob.sum(1) - generation_logprob.sum(1)).exp() = [ 1.0625, 12.1875],這表示整個第二個序列的梯度都會歸零。
實際上,我們觀察到 PPO 會將批次資料中約 3% 的梯度歸零,而 RLOO 約會將 20–40% 的批次資料梯度歸零。理論上,若不使用 mini-batch,RLOO 應將 0% 的批次資料梯度歸零。重要的是,即使我們透過 num_ppo_epochs 和 num_mini_batches 增加生成新批次前的梯度步數,RLOO 的裁剪比率仍沒有顯著變化。這提供了實證,證明裁剪比率確實源自 bf16 的數值問題,而不像論文所描述,是因為行為策略和最新策略有顯著差異。
如想繼續瞭解最新問題更新,歡迎查看 https://github.com/huggingface/transformers/issues/31267。
總結
RLOO(REINFORCE Leave One-Out)Trainer 在 TRL 推出,為線上 RLHF 訓練帶來令人振奮的新演算法,提供比 PPO 更易上手、更有效率的選擇。RLOO 減少 GPU 記憶體用量並簡化訓練流程,支援更大的批次和更快的訓練。我們的實驗顯示,RLOO 的表現媲美 PPO,而且以回應勝出率衡量,勝過 DPO 檢查點,是有效進行線上 RLHF 的有力工具。歡迎參閲説明文件,立即開始使用!
- https://huggingface.co/docs/trl/main/en/rloo_trainer
- https://huggingface.co/docs/trl/main/en/ppov2_trainer
鳴謝
感謝 Lewis Tunstall、Sara Hooker、Omar Sanseviero 和 Leandro Von Werra 對本文提供寶貴意見。
來源:Hugging Face Blog · huggingface.co





