LoRR: 用重置重放机制提升 LLM 偏好优化的样本效率

ArXiv ID: 2508.06412
作者: Zichuan Liu, Jinyu Wang, Lei Song, Jiang Bian
机构: Microsoft Research
发布日期: 2025-08-08

---

摘要

LLM 的后训练（RLHF、DPO 等）普遍面临低样本效率问题：每批数据只用一次就丢弃，导致数据利用率极低。如果尝试提高数据复用率，又会导致初始偏差（primacy bias）——模型过拟合早期经验，损害后续学习能力。

本文提出的 LoRR（LLM optimization with Reset Replay） 是一个通用插件，通过三个核心组件解决这个问题：

1. 高重放训练：每批数据复用多次（replay ratio 高达 3-10x）
2. 周期性重置：使用 Shrink & Perturb 策略定期重置网络参数
3. 混合优化：SFT 损失 + 偏好损失联合训练

在数学推理基准上，LoRR 提升各种偏好优化方法6.54%-16.99%，使迭代 DPO 达到与复杂 RL 算法可比的性能。

---

问题背景

样本效率危机

当前 LLM 后训练的数据利用率：

┌─────────────────────────────────────────────┐
│  典型 DPO 训练流程                          │
│                                             │
│  收集 100K 偏好对                            │
│  ↓                                          │
│  训练 1 个 epoch（每个样本只用 1 次）            │
│  ↓                                          │
│  丢弃所有数据                               │
│                                             │
│  数据利用率：< 1%                           │
└─────────────────────────────────────────────┘

对比监督学习：
- ImageNet 分类：每个样本使用 100+ 次
- LLM 预训练：每个 token 使用 3-10 次
- LLM 后训练：每个样本使用 1 次 ← 效率极低

为什么不能简单增加数据复用？

初始偏差（Primacy Bias）问题：

高 replay ratio 训练的问题：

训练步数
  │
  │  早期数据 ─────●────●────
  │                │    │
  │  后期数据 ─────┼────●────
  │                │
  │  性能 ─────────▼
  │
  └───────────────────────────
    低 replay    高 replay

问题：早期数据主导模型行为

根本原因：

1. 模型参数逐渐适应早期数据分布
2. 后期数据难以改变已形成的表示
3. 导致灾难性遗忘或性能下降

---

LoRR 方法

整体架构

┌─────────────────────────────────────────────────────────┐
│                    LoRR Framework                        │
│                                                         │
│  ┌───────────────┐    ┌───────────────┐                │
│  │  高重放训练    │    │  周期性重置    │                │
│  │  Replay       │    │  Reset        │                │
│  │  ratio=3-10x  │    │  & Perturb    │                │
│  └───────────────┘    └───────────────┘                │
│           │                    │                        │
│           └────────┬───────────┘                        │
│                    │                                    │
│                    ▼                                    │
│          ┌─────────────────┐                           │
│          │  混合优化损失    │                           │
│          │  SFT + DPO      │                           │
│          └─────────────────┘                           │
│                    │                                    │
│                    ▼                                    │
│          ┌─────────────────┐                           │
│          │  偏好优化方法    │                           │
│          │  DPO/PPO/IPO    │                           │
│          └─────────────────┘                           │
└─────────────────────────────────────────────────────────┘

组件 1：高重放训练

核心思想：每批数据复用多次，但采用滑动窗口策略

def lorrr_training(dataset, model, replay_ratio=5):
    """
    LoRR 高重放训练

    Args:
        dataset: 偏好数据集
        model: 待训练模型
        replay_ratio: 重放比例（每个样本使用次数）
    """
    for epoch in range(num_epochs):
        for batch in dataset:
            # 每个 batch 使用 replay_ratio 次
            for replay in range(replay_ratio):
                # 前向传播
                loss = compute_preference_loss(model, batch)

                # 反向传播
                loss.backward()

                # 梯度累积后更新
                if replay == replay_ratio - 1:
                    optimizer.step()
                    optimizer.zero_grad()

重放比例选择：

replay_ratio	适用场景	数据量
1x (基线)	数据充足	100K+
3x	中等数据	50K-100K
5x	推荐默认	20K-50K
10x	数据稀缺	<20K

组件 2：周期性重置

Shrink & Perturb 策略：

def shrink_and_perturb(model, reset_interval=500, shrink_factor=0.9, noise_std=0.01):
    """
    周期性重置网络参数

    Args:
        model: 模型
        reset_interval: 重置间隔（步数）
        shrink_factor: 收缩因子（0.8-0.95）
        noise_std: 噪声标准差
    """
    if step % reset_interval == 0:
        with torch.no_grad():
            for param in model.parameters():
                # 收缩：将参数向零靠近
                param.mul_(shrink_factor)

                # 扰动：添加高斯噪声
                noise = torch.randn_like(param) * noise_std
                param.add_(noise)

        print(f"Step {step}: 参数重置完成")

重置的作用：

效果	描述
打破初始偏差	防止早期数据主导
保持可塑性	模型能继续学习新数据
正则化	类似 Dropout 的效果
逃离局部最优	噪声帮助探索

组件 3：混合优化

联合损失函数：

def combined_loss(model, batch, alpha=0.3):
    """
    SFT + 偏好优化 联合损失

    Args:
        model: 模型
        batch: 数据批
        alpha: SFT 损失权重
    """
    # SFT 损失（保持基础能力）
    sft_loss = compute_sft_loss(model, batch.chosen)

    # 偏好损失（DPO/IPO/PPO）
    pref_loss = compute_dpo_loss(model, batch.chosen, batch.rejected)

    # 联合优化
    total_loss = alpha * sft_loss + (1 - alpha) * pref_loss

    return total_loss

alpha 参数作用：

alpha	SFT 权重	偏好权重	适用场景
0.0	0%	100%	纯偏好优化
0.3	30%	70%	推荐（平衡）
0.5	50%	50%	数据质量低
1.0	100%	0%	纯 SFT

---

实验结果

实验设置

基准任务：

• GSM8K：小学数学题
• MATH：高中数学竞赛
• AIME：数学奥林匹克

基线方法：

• DPO（直接偏好优化）
• PPO（强化学习）
• IPO（间接偏好优化）
• Iterative DPO（迭代 DPO）

评估指标：

• 准确率：解题正确率
• 样本效率：达到相同性能所需数据量
• 训练稳定性：性能波动标准差

主要结果

GSM8K 数学推理

方法	准确率	提升	样本效率
DPO	78.2%	-	1x
DPO + LoRR	84.8%	+6.6%	3.5x
PPO	81.5%	-	1x
PPO + LoRR	87.3%	+5.8%	4.2x
Iterative DPO	82.1%	-	1x
Iterative DPO + LoRR	89.1%	+7.0%	5.1x

MATH 竞赛题

方法	简单题	中等题	困难题	平均
DPO	45.2%	32.1%	18.5%	31.9%
DPO + LoRR	52.8%	39.7%	24.3%	38.9%
PPO	48.1%	35.4%	21.2%	34.9%
PPO + LoRR	55.3%	42.1%	27.8%	41.7%

关键发现：

• LoRR 在所有方法上都有效提升 6-9%
• 困难题目提升更明显（+5.8% 平均）
• 样本效率提升 3-5 倍

消融实验

Replay Ratio 影响

replay_ratio	GSM8K	MATH	训练时间
1x (基线)	78.2%	31.9%	1x
3x	82.1%	36.2%	1.8x
5x	84.8%	38.9%	2.5x
10x	83.5%	37.1%	4.2x

最优选择：replay_ratio=5x 效果最佳

重置间隔影响

reset_interval	GSM8K	MATH	稳定性
无重置	79.5%	33.2%	低
250 步	83.2%	37.1%	中
500 步	84.8%	38.9%	高
1000 步	82.9%	36.5%	高

最优选择：reset_interval=500 步

混合损失 alpha 影响

alpha	GSM8K	MATH	语言质量
0.0 (纯 DPO)	82.1%	35.8%	下降
0.3	84.8%	38.9%	保持
0.5	83.5%	37.2%	提升
1.0 (纯 SFT)	79.2%	32.1%	最优

最优选择：alpha=0.3 平衡性能和语言质量

与 RL 方法对比

方法	GSM8K	MATH	训练成本	实现难度
PPO	81.5%	34.9%	高	困难
DPO	78.2%	31.9%	低	简单
DPO + LoRR	87.3%	41.7%	低	简单

关键结论：DPO + LoRR 以简单方法达到超越 PPO 的效果

---

实践指南

代码实现

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import DPOTrainer

class LoRRTrainer:
    """LoRR 偏好优化训练器"""

    def __init__(
        self,
        model_name,
        replay_ratio=5,
        reset_interval=500,
        shrink_factor=0.9,
        noise_std=0.01,
        alpha=0.3
    ):
        self.model = AutoModelForCausalLM.from_pretrained(model_name)
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)

        self.replay_ratio = replay_ratio
        self.reset_interval = reset_interval
        self.shrink_factor = shrink_factor
        self.noise_std = noise_std
        self.alpha = alpha

        self.step = 0

    def train(self, dataset, num_epochs):
        """执行 LoRR 训练"""
        for epoch in range(num_epochs):
            for batch in dataset:
                # 高重放训练
                for replay in range(self.replay_ratio):
                    self._train_batch(batch)
                    self.step += 1

                    # 周期性重置
                    if self.step % self.reset_interval == 0:
                        self._reset_parameters()

    def _train_batch(self, batch):
        """训练单个 batch"""
        self.model.train()

        # 计算 SFT 损失
        sft_loss = self._compute_sft_loss(batch.chosen)

        # 计算 DPO 损失
        dpo_loss = self._compute_dpo_loss(batch.chosen, batch.rejected)

        # 联合损失
        total_loss = self.alpha * sft_loss + (1 - self.alpha) * dpo_loss

        # 反向传播
        total_loss.backward()
        optimizer.step()
        optimizer.zero_grad()

    def _reset_parameters(self):
        """Shrink & Perturb 重置"""
        with torch.no_grad():
            for param in self.model.parameters():
                param.mul_(self.shrink_factor)
                noise = torch.randn_like(param) * self.noise_std
                param.add_(noise)
        print(f"Step {self.step}: 参数重置完成")

超参数推荐

参数	推荐值	说明
replay_ratio	5	数据复用次数
reset_interval	500	重置间隔步数
shrink_factor	0.9	收缩因子
noise_std	0.01	噪声强度
alpha	0.3	SFT 权重
batch_size	32-64	根据显存调整
learning_rate	5e-7	较小学习率

训练成本

规模	数据量	训练时间	GPU
7B	10K	2 小时	8×A100
13B	20K	4 小时	8×A100
70B	50K	12 小时	16×A100

---

与相关工作对比

数据高效方法

方法	核心思想	样本效率	实现难度
Iterative DPO	多轮迭代	2-3x	中
Online DPO	在线采样	1.5-2x	中
LoRR	重置重放	3-5x	低
QLoRA	量化微调	1.5x	低

正则化方法

方法	目的	与 LoRR 关系
Weight Decay	防止过拟合	互补
Dropout	正则化	互补
Shrink & Perturb	保持可塑性	LoRR 核心组件

---

总结

LoRR 通过简单的重置重放机制，显著提升了 LLM 偏好优化的样本效率：

核心贡献：

1. 发现并解决了偏好优化中的初始偏差问题
2. 提出 Shrink & Perturb 周期性重置策略
3. 实现 3-5 倍样本效率提升
4. 通用插件设计，适用于 DPO/PPO/IPO

实际意义：

• 降低数据收集成本
• 使小团队能进行高效后训练
• 挑战”DPO vs PPO”的传统认知

适用场景：

• 数据量有限的偏好优化
• 计算资源受限的团队
• 需要快速迭代的场景

---

资源

• arXiv 论文
• Microsoft Research 博客

---

评分: 4.0/5.0 ⭐⭐⭐⭐

推荐度: 推荐。样本效率提升显著，实现简单。