本文提供了一个在 4060 消费级 8G 显卡上实现大语言模型后训练（Post-training）中人类对齐行为的奖励模型（Reward Model, RM）训练的完整实践指南。文章涵盖详细的参数设置与简明的理论介绍，并提供了开箱即用的代码，助你直接“一键运行”，在本地跑通大模型微调的核心链路。GitHub 链接见附录🔗

1. 大模型为什么要进行人类对齐行为？

大语言模型（LLM）的构建始于预训练（Pre-training）。在这个阶段，模型通过在海量无标注文本上进行 Next-token Prediction（下一个词预测），学习了语法、逻辑、数学、代码与百科知识。

然而，这只是一种基于“统计规律”的学习方式，并不等同于理解了“人类意图”。预训练得到的基座模型（Base Model）可以视为刚打好地基的高楼，骨架虽已成型，却尚未进行功能分区。如果此时直接投入使用，你会发现它虽然能“说话”，但往往答非所问、充满幻觉甚至带有偏见（Bias）。这源于预训练固有的三大缺陷：

• 幻觉问题（Hallucination）：模型倾向于生成看似流畅，但事实错误或无中生有的内容。
• 指令遵循困难（Instruction Following）：难以理解复杂的约束条件，或无法按照指定格式（如 JSON、代码）进行输出。
• 价值观未对齐（Value Misalignment）：由于缺乏显式的人类价值引导，可能产生有害、有毒或违背伦理道德的回复。

因此，为了将统计模型转化为能说“人话”的助手，我们需要在基座之上进行后训练（Post-training）。目前业界主要划分为两大路径：

• 1. 监督微调（SFT, Supervised Fine-Tuning）：这是所有后训练的基础步骤。通过选取高质量的指令-响应对进行有监督训练，无论后续采用何种先进算法，模型都需要先通过 SFT 学会基本的对话格式和指令遵循，解决“怎么答”的问题。
• 2. 偏好对齐（Preference Alignment）：这是让模型从“会说话”进阶到“会说人话”的关键。目前主流方案分为两类：
  • 基于强化学习（RL-based）：以 RLHF 为代表，包含 SFT → RM → PPO 的完整链路，是当前对齐能力的黄金标准。
  • 非强化学习（Non-RL）：以 DPO 及其变体（如 GRPO）为代表，通过直接优化偏好数据来简化训练流程，是目前开源社区的高效替代方案。

本文作为 RLHF 系列的第一篇，将聚焦于上述链路中承上启下的关键环节——奖励模型（Reward Model, RM）的训练与实现。

2. RLHF 核心三步曲概览

RLHF（基于人类反馈的强化学习）最初由 OpenAI 在 InstructGPT 中提出，它彻底改变了大模型的发展方向。传统的“大力出奇迹”（Scaling Law）认为模型参数越大能力越强，但 InstructGPT 的实验却揭示了一个反直觉的结论：经过人类对齐（RLHF）的小模型，其实际表现可以超越未经对齐的超大模型。

Ouyang L, Wu J, Jiang X, et al. Training language models to follow instructions with human feedback[J]. Advances in neural information processing systems, 2022, 35: 27730-27744.

正如文献中所提到的，当 1.3B 的小模型经过 奖励模型（RM）+近端策略优化（PPO） 的强化学习对齐后，其在人类评估中的胜率已经接近甚至超越了 175B 的大模型（即 SFT 175B）。这一发现证明了“对齐”的价值远超单纯的算力堆叠。
在经过高质量的SFT后，将经历RM+PPO阶段。如图中所示分为

• RM（裁判）： 它不再依赖昂贵的人工标注标准答案，而是通过少量的成对排序数据（Pairwise Ranking），将模糊的人类偏好转化为具体的数值分数。它充当了“裁判”的角色，负责判定模型的回答是否算是“人话”。
• PPO（运动员）： 它是模型的自我迭代过程。模型作为“运动员”生成回答，RM 作为裁判即时打分。PPO 算法依据这个分数更新策略，并通过引入 KL 散度惩罚项 来防止模型为了高分而“走火入魔”（产生幻觉或偏离原始知识），从而在“生成-打分-更新”的闭环中逐步内化人类价值观。

3. RM 模型实现原理

奖励模型（Reward Model, RM）的核心任务是将人类模糊的“好恶”转化为机器可理解的“数值信号”。我们需要理解其背后的输入输出规范、结构改造以及最核心的数学原理。

3.1 输入与输出：从文本到标量

• 输入（Input）：Prompt + Response。模型接收一段上下文（用户的问题）和对应的回答。
• 输出（Output）：一个 Scalar（标量值）。不同于生成式任务输出词表分布，RM 输出一个浮点数，数值越大代表该回答越符合人类偏好。

3.2 模型结构：去掉“猜词”，留下“评分”

这里以消费级显卡为例，我们通常基于较小的基座模型（如 GPT-2 Small）进行改造：

1. 移除 LM Head：去掉原语言模型用于预测下一个词的线性分类层（Vocab Size 维度）。
2. 添加 Value Head：在 backbone 的最后一层后接一个简单的 Linear 层，将隐藏状态（Hidden States）直接映射到维度为 1 的空间。
3. 提取特征：我们通常使用 最后一个有效 Token 的 Hidden State 作为整个序列的代表，送入 Linear 层计算得分。

3.3 求解了什么问题：从回归到排序

RM 训练最大的误区是将其视为“回归问题”（直接预测 1-10 分的绝对分数）。这在实践中极其困难，因为不同标注员的打分标准千差万别。判断哪个回答更好要比量化一个回答为几分更容易。

实际上，RM 解决的是一个 对比学习（Contrastive Learning）/ 排序问题。

1. Bradley-Terry 模型与概率表示
该模型将人类对 $y_w$（被选中的好回答）和 $y_l$（被拒绝的坏回答）的偏好转化为概率。给定同一个 Prompt $x$，人类偏好 $y_w$ 的概率为：
$$P(y_w\succ y_l|x)=\sigma (r_{\theta }(x,y_w)-r_{\theta }(x,y_l))$$
(注：$\sigma$ 是 Sigmoid 函数，$r_{\theta }$ 是模型输出的标量分数)

2. 极大似然估计（Maximum Likelihood Estimation, MLE）
假设我们的训练数据集 $D$ 中包含 $N$ 个独立同分布的样本。为了找到一组最优的模型参数 $\theta$，使得模型预测出的概率分布最接近真实的人类偏好，我们需要最大化观测到这组数据的联合概率（似然函数）：

$$L(\theta )=\prod _{(x,y_w,y_l)\in D}P(y_w\succ y_l|x)$$
$$L(\theta )=\prod _{(x,y_w,y_l)\in D}\sigma (r_{\theta }(x,y_w)-r_{\theta }(x,y_l))$$

3. 等价负对数似然损失（Negative Log-Likelihood Loss）
直接求解这个连乘的最大值在数学上非常困难（容易下溢），因此我们通常会取对数（Log），将连乘转化为连加。同时，为了方便梯度下降求解极小化损失函数，我们在对数似然函数前加上负号，最终得到我们实际使用的 Loss 函数：

$$L_{RM}(\theta )=-\sum _{(x,y_w,y_l)\in D}\log \left(\sigma (r_{\theta }(x,y_w)-r_{\theta }(x,y_l))\right)$$

扩展到数学期望的形式（用 $\mathbb{E}$ 表示），就是我们常见的公式：
$$L_{RM}(\theta )=-{\mathbb{E}}_{(x,y_w,y_l)\sim D}[\log (\sigma (r_{\theta }(x,y_w)-r_{\theta }(x,y_l)))]$$
因此，从RM的目的可以直观看到，损失函数$L_{RM}(\theta )$本质上是“希望好的回答概率大于坏的回答”，这也是训练“裁判”的过程：

• 理想情况：当 $r_{\theta }(x,y_w)\gg r_{\theta }(x,y_l)$（好回答分极高，坏回答分极低），差值趋于正无穷，$\sigma (\cdot )$ 输出趋于 1，$\log (1)=0$，Loss 最小。
• 失败情况：当 $r_{\theta }(x,y_w)<r_{\theta }(x,y_l)$（模型把坏回答当成了好回答），差值趋于负数，$\sigma (\cdot )$ 输出趋于 0，$\log (0)$ 趋近于无穷大，Loss 激增，模型参数被严厉惩罚。

通过这种机制，RM 无需纠结于“绝对分数”，只需专注于“拉开差距”，从而低成本地习得人类评判的标准。
(注：RM也是一种监督微调，排序也是人为构建的数据集，训练参数直接与模型规模相关。)

4. 实践：RTX 4060 本地化实现轻量 RM 训练

在消费级显卡上复现 RLHF 流程，最大的困难不在于算法逻辑，而在于显存限制。本节将以 RTX 4060 (8GB) 为例，提供一个“乞版”实践流程。可以直接迁移至 Llama、Qwen 等更大规模的模型。

4.1 模型选取

我们选取GPT-2 small 124M作为基座模型。结构简单，参数规模足够小。

#拉取 GPT-2 权重，优先本地缓存，不存在时下载
def _load_gpt2_backbone(model_name: str, attn_implementation: str | None) -> GPT2Model:
    """Load GPT2Model; prefer SDPA (`scaled_dot_product_attention`) when supported."""
    if not attn_implementation:
        return GPT2Model.from_pretrained(model_name)
    try:
        return GPT2Model.from_pretrained(
            model_name,
            attn_implementation=attn_implementation,
        )
    except (TypeError, ValueError, OSError):
        return GPT2Model.from_pretrained(model_name)
#训练入口默认模型名
def parse_args() -> argparse.Namespace:
    p = argparse.ArgumentParser(description="Train GPT-2 reward model (Bradley-Terry).")
    p.add_argument("--model-name", type=str, default="gpt2")
    p.add_argument("--max-length", type=int, default=512)

4.2 权重更新

为了降低显存占用，我们采用 PEFT (Parameter-Efficient Fine-Tuning) 策略。通过引入 LoRA（低秩适配矩阵），我们冻结主干网络的所有参数，仅训练极少量的旁路参数。这意味着反向传播时无需计算和存储绝大部分参数的梯度。

if use_lora:
    if get_peft_model is None or LoraConfig is None:
        raise ImportError("LoRA requires `peft`. Install with: pip install peft")
    # FEATURE_EXTRACTION -> PeftModelForFeatureExtraction (no
    # prepare_inputs_for_generation). CAUSAL_LM targets GPT2LMHeadModel only.
    lora_config = LoraConfig(
        r=lora_r,
        lora_alpha=lora_alpha,
        lora_dropout=lora_dropout,
        bias="none",
        task_type=TaskType.FEATURE_EXTRACTION,
        target_modules=["c_attn", "c_fc", "c_proj"],
        fan_in_fan_out=True,
    )
    self.backbone = get_peft_model(backbone, lora_config)
else:
    self.backbone = backbone

Lora相关细节可参考：【大模型微调】Lora、Dola和Pissa的实践与优化

4.3 数据集准备

我们选择经典的 Anthropic/hh-rlhf 数据集。该数据集包含了人类对于不同回答的偏好标签（chosen 和 rejected）。

数据集下载：https://huggingface.co/datasets/Anthropic/hh-rlhf/tree/main

为了准确提取序列末尾的表征，我们统一采用 Right Padding 策略。

#数据集拉取入口，直接从 HF datasets 拉 Anthropic/hh-rlhf 的 train/test split
def _load_and_maybe_trim_split(
    split: str,
    cache_dir: str | None,
    *,
    debug_mode: bool,
    debug_max_samples: int | None,
) -> Dataset:
    _drop_invalid_ssl_bundle_paths()
    ds = load_dataset(
        "Anthropic/hh-rlhf",
        split=split,
        cache_dir=cache_dir,
    )
    if debug_mode and debug_max_samples is not None:
        n = min(debug_max_samples, len(ds))
        ds = ds.select(range(n))
    return ds
#在 dataloader 构建时分别拉 train 和 test
	train_raw = _load_and_maybe_trim_split(
    "train",
    cache_dir,
    debug_mode=debug_mode,
    debug_max_samples=DEBUG_TRAIN_MAX_SAMPLES if debug_mode else None,
)
val_raw = _load_and_maybe_trim_split(
    "test",
    cache_dir,
    debug_mode=debug_mode,
    debug_max_samples=DEBUG_VAL_MAX_SAMPLES if debug_mode else None,
)

4.4 混合精度技术

在大模型训练中，显存主要被模型权重、梯度和优化器状态占据。如果全用 FP32，一张 8G 显卡加载一个 1B 的模型可能就直接 OOM（显存溢出）了。引入 FP16 或BF16 后，仅仅是在前向传播和激活值存储上，显存占用就能直接降低 50%。这多出来的空间，足够你把 Batch Size 调大，或者塞进更长的上下文，甚至去跑参数量更大的模型。

# train.py 中混合精度（BF16 autocast）开启逻辑的最小闭环

# 1) 命令行开关（默认不开 --no-bf16，所以默认允许 BF16）
p.add_argument(
    "--no-bf16",
    action="store_true",
    help="Disable BF16 autocast (default: BF16 on when CUDA is available).",
)

# 2) 运行时判定：必须是 CUDA 且没有传 --no-bf16
use_bf16 = not args.no_bf16 and device.type == "cuda"

# 3) 训练时启用 autocast
use_amp = use_bf16 and device.type == "cuda"
if use_amp:
    with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
        loss = _forward_loss(model, batch)
else:
    loss = _forward_loss(model, batch)

# 4) 验证时同样启用 autocast
if use_amp:
    with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
        r_w = model(batch.winner_input_ids, batch.winner_attention_mask)
        r_l = model(batch.loser_input_ids, batch.loser_attention_mask)
        loss = bradley_terry_loss(r_w, r_l)
else:
    r_w = model(batch.winner_input_ids, batch.winner_attention_mask)
    r_l = model(batch.loser_input_ids, batch.loser_attention_mask)
    loss = bradley_terry_loss(r_w, r_l)

# 5) 控制台会打印当前是否开启
print(f"BF16 autocast: {use_bf16}")

# 结论：
# - 默认在 CUDA 上自动开启 BF16 混合精度
# - 传 --no-bf16 可关闭

混合精度有效提高了计算效率。但是单精度表示范围较小，在损失函数梯度非常小时，容易梯度下溢出，即四舍五入成0，因此需要混合精度。
(注：现代GPU，如RTX40系列支持混合精度才可使用混合精度)

4.5 优化器选取与设置

优化器（Optimizer） 的选择直接决定了损失函数的收敛速度以及最终模型的对齐准确率。在本项目中，我们默认采用 AdamW (Adam with Weight Decay) 作为基线优化器：

# 以 AdamW 为例：train.py -> optimizer.py 的调用链

# ===== train.py =====
from optimizer import get_optimizer

# 1) 命令行参数（可指定 adamw）
p.add_argument(
    "--optim-name",
    type=str,
    default="adam",
    help="adam, adamw, sgd, rmsprop, adamwpid, adan, lion, or muon.",
)
p.add_argument("--lr", type=float, default=5e-5)
p.add_argument("--weight-decay", type=float, default=0.01)

# 2) 收集可训练参数（LoRA 场景下通常是 adapter + value head）
trainable_params = [p for p in model.parameters() if p.requires_grad]

# 3) 构造优化器
optimizer = get_optimizer(
    model,
    args.optim_name,         
    lr=args.lr,               # 学习率
    weight_decay=args.weight_decay,
    params=trainable_params,  # 训练参数集合
)

# 4) 训练循环中标准调用
optimizer.zero_grad(set_to_none=True)
loss.backward()
torch.nn.utils.clip_grad_norm_(trainable_params, args.max_grad_norm)
optimizer.step()


# ===== optimizer.py=====
import torch

def get_optimizer(model, optim_name, lr, weight_decay, params=None, **kwargs):
    params = params if params is not None else model.parameters()
    name = optim_name.strip().lower()

    if name == "adamw":
        return torch.optim.AdamW(params, lr=lr, weight_decay=weight_decay)
    elif name == "adam":
        return torch.optim.Adam(params, lr=lr, weight_decay=weight_decay)
    elif name == "sgd":
        return torch.optim.SGD(params, lr=lr, weight_decay=weight_decay, momentum=0.9)
    # ... 其他优化器分支
    else:
        raise ValueError(f"Unknown optimizer: {optim_name}")

虽然 AdamW 表现稳健，但在单卡GPU上，优化器的显存占用（需要存储一阶矩和二阶矩）依然是不可忽视的开销。因此，在 LightRLHF-Optimizer-Bench 中，本文也测试了以下新兴优化器，探索更高效的训练路径：

• Lion (EvoLved Sign Momentum)：Google Brain 提出的优化器。它去除了 AdamW 中的二阶矩（方差）计算，仅保留符号函数和动量。这不仅减少了 50% 的显存占用，还常常带来更快的收敛速度。
• Adan (Adaptive Nesterov Momentum)：针对大批量训练设计的优化器。它引入了 Nesterov 动量和自适应更新策略，在有限的显存下，能有效提升训练的稳定性。
• Muon (Momentum Orthogonalized Update)：近期备受关注的优化器。它通过正交化（Orthogonalization）技术更新权重，特别适用于 Transformer 架构中的矩阵乘法层，在理论上能保证更新的方向更加高效。

Adan 优化器：https://arxiv.org/pdf/2208.06677
Muon 优化器：https://kellerjordan.github.io/posts/muon/

5. 关键参数设置与踩坑指南

5.1参数设置表

参数	默认值	推荐区间	调参建议
--lr	5e-5	2e-5 ~ 1e-4	先试 5e-5；不稳降到 3e-5/2e-5，收敛慢可升到 8e-5/1e-4
--batch-size	4	1 ~ 8	先以“不 OOM”为准，能大则大；OOM 优先减这个
--max-length	512	256 / 384 / 512	长度越大越耗显存；先 256/384 验证，再升 512
--epochs	1	1 ~ 3	先跑 1 看趋势，再决定是否加轮次
--weight-decay	0.01	0.001 ~ 0.05	常用 0.01；欠拟合可降，过拟合可升
--max-grad-norm	1.0	0.5 ~ 1.0	建议保留梯度裁剪；loss 抖动大可降到 0.5
--no-bf16	关闭（即默认开 BF16）	建议默认不开该开关	CUDA 下默认 BF16，省显存且更快；仅异常时关闭
--no-lora	关闭（即默认用 LoRA）	建议默认不开该开关	优先 LoRA；做全参对照再加 --no-lora
--lora-r	8	8 / 16	8 稳妥，16 表达力更强但开销更高
--lora-alpha	16	16 / 32	常与 r 成比例，常见 alpha=2*r
--lora-dropout	0.0	0.0 ~ 0.1	过拟合时试 0.05
--attn-implementation	sdpa	sdpa（优先）	一般保持默认即可
--num-workers	0	0 ~ 4	Windows 先 0，稳定后再试 2/4
--debug_mode	关闭	开/关	强烈建议先开一次做冒烟测试

注：以4060为例，学习率需要开调度器（余弦预热），epoch一般1~2即可，batch size不要超过4。

5.2 运行示例

# A. 推荐起步（AdamW + LoRA + BF16）
python train.py --optim-name adamw --lr 5e-5 --batch-size 4 --max-length 512 --epochs 1

# B. 小显存优先（先跑通）
python train.py --optim-name adamw --lr 5e-5 --batch-size 1 --max-length 256 --epochs 1

# C. 稳定收敛（更保守学习率）
python train.py --optim-name adamw --lr 3e-5 --batch-size 4 --max-length 512 --epochs 2

# D. LoRA增强尝试
python train.py --optim-name adamw --lr 3e-5 --batch-size 4 --max-length 512 --epochs 2 --lora-r 16 --lora-alpha 32 --lora-dropout 0.05

# E. 全参微调对照（显存压力大）
python train.py --optim-name adamw --no-lora --no-bf16 --lr 2e-5 --batch-size 1 --max-length 256 --epochs 1

# F. 先做快速冒烟检查
python train.py --debug_mode --optim-name adamw --lr 5e-5 --batch-size 2 --max-length 256 --epochs 1

6. 模型评估以及实验结果

6.1 评估指标

在 Reward Model 的训练中，Accuracy（准确率） 是最直观的指标。它衡量的是：对于给定的同一 Prompt，模型是否能正确地给 Chosen 回答打出比 Rejected 回答更高的分数。

然而，RM 训练有一个著名的陷阱——“分数幻觉”（Reward Hacking / Over-optimization）。

• 现象：如果你对 RM 进行过多次迭代（Epoch > 2），或者训练步数过多，模型往往会过度学习训练集中的“高分回答”模式。这会导致 RM 对所有回答都打出虚高的分数，失去区分度。
• 后果：这种“分数通胀”在后续的 DPO 或 PPO 阶段会被进一步放大。模型会误以为只要模仿这些“高分模板”就能获得奖励，从而导致生成内容的多样性丧失或产生严重的过拟合。
• 合格标准：因此，通常训练 1-2 个 Epoch 即可停止。0.65 ~ 0.75 的验证集准确率 是一个合格的 RM 模型。对于 124M 的小模型，0.7 的 Acc 已经足以支撑后续的 DPO 对齐任务，过高的 Acc 反而可能是过拟合的前兆。

6.2 实验结果

我们在 RTX 4060 (8G) 上，基于 LightRLHF-Optimizer-Bench 框架，对 GPT-2 Small 进行了 RM 训练。训练 1 个 Epoch（约 40,000 次迭代）。

#运行命令
python benchmark.py --optimizers adan --model-name gpt2 --batch-size 4 --learning-rate 5e-5 --warmup-ratio 0.05 --weight-decay 0.01 --train-log-interval 50 --log-interval 2000 --plot-interval 10000 --seed 42

优化器	Acc	收敛稳定性
Lion	0.602	高：后期损失最低梯队，整体下行明显；有噪声但EMA趋势最稳、最终段较平滑
AdamW	0.599	高：曲线持续缓慢下降，后期平台稳定，波动幅度小于多数方法
Adan	0.579	中-高：总体能收敛到较低损失，但中后期抖动和尖峰略多于 AdamW/Lion
RMSprop	0.529	中：早期下降后进入平台，后期改善有限，波动中等
SGD	0.512	中（偏弱）：曲线较平滑但长期停在较高损失平台，收敛“稳但慢且上限低”

7. 总结与展望

7.1 本文小结

本文在单块 RTX 4060（8GB 显存）这一极度受限的硬件条件下，通过 GPT-2 Small + LoRA + 混合精度 的技术组合，成功搭建并跑通了人类反馈强化学习（RLHF）中的奖励模型（RM）训练流程。

我们不仅在理论上分析了 Bradley-Terry 偏好模型与成对排序损失（Pairwise Ranking Loss）的数学联系[cite: 1]，更在工程上验证了消费级 GPU 进行大模型后训练（Post-training）的可行性。通过 LightRLHF-Optimizer-Bench 框架，初学者可以低成本地实验不同的优化算法（如 Adan, Lion, Muon 等），观察它们在对齐任务中的收敛特性。

7.2 为什么要学习“过时”的 RM 训练？

随着 DPO（直接偏好优化）和 GRPO 等算法的兴起，许多开源实践开始选择绕过显式的奖励模型训练阶段[cite: 1]。然而，深入理解并掌握 RM 训练依然具有不可替代的价值：

• 安全性的核心护城河：尽管新技术层出不穷，但诸如 Claude 等顶级商用模型依然在深度沿用并改进 RLHF 框架。显式的奖励模型能够对回答进行更细粒度的安全性建模，在防御越狱攻击、过滤有毒内容方面具有极强的鲁棒性。
• 强化学习的底层逻辑：RM 是连接监督学习（SFT）与强化学习（PPO）的桥梁[cite: 1]。掌握了 RM，才真正理解了如何将模糊的人类感官转化为机器可调优的数学信号。
• 构建自动化“评测裁判”：在 LLM-as-a-judge 的趋势下，训练一个垂直领域的 RM 实际上是在构建一个自动化的质量评估工具，这对于私有化部署的模型优化意义重大。

7.3 展望

RLHF 并非终点，而是对齐技术的起点。在本文实现的轻量化 RM 基础上，下一步我们可以利用训练好的裁判模型进入 PPO 阶段，让模型在打分与反馈中完成自我进化。随着算力门槛的进一步降低，这种“本地对齐”的实践将让每一位开发者都能定义属于自己的大模型价值观。

---

🔗 开源项目地址

本实践案例及所有优化器测试代码已同步至 GitHub，支持一键运行：
auguste805/LightRLHF-Optimizer-Bench
(欢迎 Star 交流，让我们在消费级显卡上榨干大模型的每一分潜力！)