基于 HuggingFace Transformers 的简易自我博弈训练脚本-优快云博客

方案总览与数据流
环境与数据准备
自我博弈生成器：两条推理路径 + 自动裁判
偏好数据构建：DPO 格式（chosen/rejected）
用 TRL 的 DPOTrainer 训练偏好模型
可选：PPO 奖励建模的“端到端在线”自博弈
调参与工程化要点
常见坑与排错清单
总结与下一步

1. 方案总览与数据流（Background → Principle → Practice 的落地）

我们把“自我博弈”落为三件事：

1）双路径生成（Self-Play Generation）：用同一个基座模型（或同架构的两个初始化相同的策略），针对同一道题生成两条不同推理链（Path-A / Path-B）。
2）自动裁判（Auto-Judge）：用可程序化验证与一致性规则给出胜负与得分（数学题可直接验算；开放问答使用关键词覆盖率、事实性判定、引用完整度等启发式指标）。
3）偏好优化（Preference Optimization）：把（A、B）转成 DPO（Direct Preference Optimization）需要的 (chosen, rejected) 数据对，用 trl.DPOTrainer 直接优化策略；或用 PPO（奖励模型/显式 reward）在线更新。

为什么首选 DPO？
RLHF 的 PPO 端到端回传稳定性与工程复杂度更高；DPO 用偏好对即可训练，样本利用率与稳定性兼顾，非常适合“自博弈→筛优路→微调”的闭环。

数据流示意图

flowchart LR
    Q[题目/任务] --> A[路径A: 推理+答案]
    Q --> B[路径B: 推理+答案]
    A --> J{自动裁判/验证}
    B --> J
    J -->|胜者=chosen 败者=rejected| D[DPO 偏好数据集]
    D --> T[DPOTrainer 训练]
    T --> P[新策略模型]

2. 环境与数据准备

硬件建议：单卡 16–24GB 显存可跑 7B–8B 小模型的 LoRA；也可用 CPU + 量化做小规模验证。
依赖：

transformers（文本生成 + 基座模型）
accelerate（分布式/混合精度）
datasets（数据）
trl（DPO/PPO 训练器）
peft（LoRA 等参数高效微调）
einops, numpy, torch

数据：为方便展示，我们以数学推理为主（易程序化验证）。你也可以把 GSM8K（有标准答案）或自定义问答集换进来。
参考：GSM8K 数据集介绍
https://huggingface.co/datasets/gsm8k

3. 自我博弈生成器：两条推理路径 + 自动裁判

思路：

用同一个策略模型，通过随机种子、不同 system prompt、不同解码参数制造分歧路径（A/B）。
设计一个可编程裁判：数学题通过解析最终答案并与 gold 比对；开放问答用启发式规则（关键词覆盖度 + 自洽性检查 + 引用格式等）。

下面这段代码做三件事：
1）定义统一的样本格式与解析器（把 “因此答案是 42” 抽出数值 42）；
2）实现双路径生成（支持不同温度/Top-p/惩罚项）；
3）实现裁判（优先用可验证答案，其次在平局时用次级指标打破僵局），最终输出 DPO 需要的 (chosen, rejected)。

这段代码 180+ 行，已按教学可运行风格编写，可独立保存为 self_play_generate.py。

# self_play_generate.py
# -*- coding: utf-8 -*-
"""
自我博弈生成器：双路径推理 + 自动裁判 → 产出 DPO 偏好对
适配数学题（可程序化验算）+ 通用问答（启发式一致性评分）

依赖:
  pip install transformers datasets accelerate trl peft einops
"""
import os
import re
import json
import math
import random
from dataclasses import dataclass
from typing import List, Dict, Tuple, Optional

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed

# ========== 数据与样本结构 ==========

@dataclass
class QAExample:
    question: str
    answer: Optional[str] = None   # gold，可选
    meta: Optional[dict] = None

def load_demo_data() -> List[QAExample]:
    """示例数据：数学推理题 + 少量开放问答"""
    data = [
        {"question": "计算：27 + 15 = ?", "answer": "42"},
        {"question": "如果 x=5，y=3，求 2*x^2 - y = ?", "answer": "47"},
        {"question": "一个正方形边长为 12 cm，求其面积（单位：cm^2）", "answer": "144"},
        {"question": "简述 HTTP/2 相对 HTTP/1.1 的关键改进点", "answer": None}, # 开放问答
    ]
    return [QAExample(**d) for d in data]

# ========== 推理路径解析与裁判 ==========

def extract_final_number(text: str) -> Optional[float]:
    """
    从推理文本里抽取最终数字答案（适用于数学题），策略：
    1. 匹配常见“最终答案/因此/结果为”等提示
    2. 回退：取文本里最后出现的数字
    """
    patterns = [
        r"(最终答案|因此|所以|结果为|答案为)[:：]?\s*(-?\d+(\.\d+)?)",
        r"=+\s*(-?\d+(\.\d+)?)\s*$",
    ]
    for p in patterns:
        m = re.search(p, text, flags=re.IGNORECASE | re.MULTILINE)
        if m:
            try:
                return float(m.group(2))
            except Exception:
                pass
    # 回退：找最后一个数字
    nums = re.findall(r"-?\d+(?:\.\d+)?", text)
    if nums:
        try:
            return float(nums[-1])
        except Exception:
            return None
    return None

def heuristic_consistency_score(text: str, question: str) -> float:
    """
    针对开放问答的启发式“一致性/覆盖度”打分（0~1）：
    - 关键词覆盖（依据问题分词/关键词表）
    - 结构化表达（是否包含条目/小标题）
    - 引用/术语（是否出现常见技术术语或引用记号）
    """
    # 极简实现：真实应用可接关键词抽取、BM25/向量召回、NER/术语词表
    q_kw = set([w for w in re.split(r"[，。、；：,\s/]+", question) if w and len(w) >= 2])
    hit = sum(1 for w in q_kw if w in text)
    cov = hit / (len(q_kw) + 1e-6)
    has_list = 1.0 if re.search(r"(\n- |\n\d+\.)", text) else 0.0
    has_terms = 1.0 if re.search(r"(多路复用|头部压缩|服务端推送|流优先级|HPACK|ALPN)", text) else 0.0
    score = 0.6 * cov + 0.2 * has_list + 0.2 * has_terms
    return max(0.0, min(1.0, score))

def judge_pair(
    q: QAExample,
    text_a: str,
    text_b: str,
) -> Tuple[str, str, float, float]:
    """
    自动裁判：
    - 若有 gold 答案且可解析数值 → 以数值正确性为主判
    - 否则（开放问答） → 用启发式一致性分数
    返回：(chosen, rejected, score_chosen, score_rejected)
    """
    if q.answer is not None:
        gold = None
        try:
            gold = float(q.answer)
        except Exception:
            pass

        a_num = extract_final_number(text_a)
        b_num = extract_final_number(text_b)

        if (gold is not None) and (a_num is not None) and (b_num is not None):
            # 与 gold 的误差越小越优
            a_err = abs(a_num - gold)
            b_err = abs(b_num - gold)
            if a_err < b_err:
                return text_a, text_b, 1.0, 0.0
            elif b_err < a_err:
                return text_b, text_a, 1.0, 0.0
            else:
                # 平局 → 继续看内容质量
                sa = heuristic_consistency_score(text_a, q.question)
                sb = heuristic_consistency_score(text_b, q.question)
                if sa >= sb:
                    return text_a, text_b, sa, sb
                return text_b, text_a, sb, sa
        else:
            # 解析失败 → 回退启发式
            sa = heuristic_consistency_score(text_a, q.question)
            sb = heuristic_consistency_score(text_b, q.question)
            if sa >= sb:
                return text_a, text_b, sa, sb
            return text_b, text_a, sb, sa
    else:
        # 开放问答：启发式一致性
        sa = heuristic_consistency_score(text_a, q.question)
        sb = heuristic_consistency_score(text_b, q.question)
        if sa >= sb:
            return text_a, text_b, sa, sb
        return text_b, text_a, sb, sa

# ========== 路径生成（两条不同采样策略） ==========

DEFAULT_SYS_PROMPT_A = "你是一名严谨的助教，请逐步推理并在最后一行给出【最终答案：<数值/结论>】。"
DEFAULT_SYS_PROMPT_B = "你是一名细致的评审，请先列出要点再逐步推理，最后一行给出【因此答案为：<数值/结论>】。"

@torch.inference_mode()
def generate_one(
    model,
    tok,
    question: str,
    sys_prompt: str,
    max_new_tokens: int = 256,
    temperature: float = 0.7,
    top_p: float = 0.9,
    top_k: int = 50,
    penalty_alpha: Optional[float] = None
) -> str:
    # 组装提示词（可替换为 chat 模式）
    prompt = f"{sys_prompt}\n\n题目：{question}\n\n请给出带推理过程的答案：\n"
    inputs = tok(prompt, return_tensors="pt").to(model.device)
    gen_kwargs = dict(
        max_new_tokens=max_new_tokens,
        do_sample=True,
        temperature=temperature,
        top_p=top_p,
        top_k=top_k,
        repetition_penalty=1.05,
        eos_token_id=tok.eos_token_id,
        pad_token_id=tok.eos_token_id,
    )
    if penalty_alpha is not None:
        gen_kwargs["penalty_alpha"] = penalty_alpha  # contrastive
    out = model.generate(**inputs, **gen_kwargs)
    text = tok.decode(out[0], skip_special_tokens=True)
    # 只取“回答部分”
    return text.split("请给出带推理过程的答案：")[-1].strip()

def two_path_generate(
    model, tok, q: QAExample, seed_a: int, seed_b: int
) -> Tuple[str, str]:
    # 通过种子 + 不同 sys prompt + 不同采样参数制造差异
    set_seed(seed_a)
    a = generate_one(
        model, tok, q.question, DEFAULT_SYS_PROMPT_A,
        max_new_tokens=256, temperature=0.8, top_p=0.95, top_k=50
    )
    set_seed(seed_b)
    b = generate_one(
        model, tok, q.question, DEFAULT_SYS_PROMPT_B,
        max_new_tokens=256, temperature=0.6, top_p=0.85, top_k=30
    )
    return a, b

# ========== 主流程：生成并写出 DPO 偏好数据集 ==========

def main():
    model_name = os.environ.get("SP_MODEL", "Qwen/Qwen2.5-1.5B-Instruct")
    device = "cuda" if torch.cuda.is_available() else "cpu"
    print(f"[INFO] loading model: {model_name} on {device}")
    tok = AutoTokenizer.from_pretrained(model_name, use_fast=True)
    model = AutoModelForCausalLM.from_pretrained(
        model_name, torch_dtype=torch.float16 if device=="cuda" else torch.float32,
        device_map="auto"
    )
    data = load_demo_data()
    out_path = "dpo_pairs.jsonl"
    f = open(out_path, "w", encoding="utf-8")

    for i, q in enumerate(data):
        a, b = two_path_generate(model, tok, q, seed_a=42+i, seed_b=1234+i)
        chosen, rejected, sc, sr = judge_pair(q, a, b)
        item = {
            "prompt": q.question,
            "chosen": chosen,
            "rejected": rejected,
            "score_chosen": sc,
            "score_rejected": sr,
            "gold": q.answer,
        }
        f.write(json.dumps(item, ensure_ascii=False) + "\n")
        print(f"[PAIR {i}] chosen_score={sc:.3f} rejected_score={sr:.3f}")
    f.close()
    print(f"[DONE] write dpo pairs to {out_path}")

if __name__ == "__main__":
    main()

运行这段脚本后，你会得到一个 dpo_pairs.jsonl，每行都像：

{"prompt":"计算：27 + 15 = ?","chosen":"... 因此答案为：42","rejected":"... 最终答案：41","score_chosen":1.0,"score_rejected":0.0,"gold":"42"}

这正是 DPO 训练所需的偏好对格式。

4. 偏好数据构建：DPO 格式（chosen/rejected）

DPO 的输入通常是 (prompt, chosen, rejected)，可附带元信息（score、gold）。上一步我们已经输出为 jsonl。为什么适合 DPO：

自我博弈天然地产生多个候选（A/B/C…），我们只需选择更优的作为 chosen；
不需要显式 Reward Model，降低复杂度；
对“推理链质量”的提升通常比单纯 SFT 更明显。

相关论文：Direct Preference Optimization (DPO)
https://arxiv.org/abs/2305.18290
TRL 文档：
https://huggingface.co/docs/trl/main/en/dpo_trainer

5. 用 TRL 的 DPOTrainer 训练偏好模型（LoRA）

下方完整脚本做了几件事：

读取 dpo_pairs.jsonl → 转 HuggingFace datasets.Dataset
构建 DPOTrainer（启用 LoRA 以节省显存）
指定训练超参（batch、lr、dpo_beta、max_len）
训练并保存 adapter（LoRA 权重）

这段代码 150+ 行，可保存为 train_dpo.py。

# train_dpo.py
# -*- coding: utf-8 -*-
"""
使用 TRL 的 DPOTrainer 训练偏好微调（推荐 LoRA）
运行前请先准备 dpo_pairs.jsonl
"""
import os
import json
from dataclasses import dataclass
from typing import Dict, Any

import torch
from datasets import Dataset
from transformers import (AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import DPOTrainer, DPOConfig

DATA_PATH = "dpo_pairs.jsonl"
BASE_MODEL = os.environ.get("BASE_MODEL", "Qwen/Qwen2.5-1.5B-Instruct")
OUTPUT_DIR = os.environ.get("OUTPUT_DIR", "./dpo_out")

def load_jsonl(path: str):
    rows = []
    with open(path, "r", encoding="utf-8") as f:
        for line in f:
            rows.append(json.loads(line))
    return rows

def to_hf_dataset(rows):
    return Dataset.from_list(rows)

def build_tokenizer_and_model():
    device = "cuda" if torch.cuda.is_available() else "cpu"
    print(f"[INFO] loading base model: {BASE_MODEL} on {device}")

    tok = AutoTokenizer.from_pretrained(BASE_MODEL, use_fast=True)
    if tok.pad_token is None:
        tok.pad_token = tok.eos_token

    # 如需 4-bit 量化以省显存，可启用下方 quant 配置
    quant = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_compute_dtype=torch.float16,
        bnb_4bit_use_double_quant=True,
        bnb_4bit_quant_type="nf4"
    )
    model = AutoModelForCausalLM.from_pretrained(
        BASE_MODEL,
        quantization_config=quant,
        device_map="auto"
    )
    model = prepare_model_for_kbit_training(model)

    # LoRA 配置（可按需调整 r、alpha、target_modules）
    lora_cfg = LoraConfig(
        r=16, lora_alpha=32, lora_dropout=0.05, bias="none",
        task_type="CAUSAL_LM",
        target_modules=["q_proj", "v_proj", "k_proj", "o_proj"]
    )
    model = get_peft_model(model, lora_cfg)
    model.print_trainable_parameters()
    return tok, model

def format_batch(examples: Dict[str, Any], tok: AutoTokenizer, max_len=768):
    """
    将 (prompt, chosen, rejected) 打包成 DPOTrainer 期望的字段
    """
    prompts = examples["prompt"]
    chosens = examples["chosen"]
    rejecteds = examples["rejected"]

    def encode(texts):
        return tok(
            texts,
            max_length=max_len,
            truncation=True,
            padding=False,
            add_special_tokens=True,
        )

    return {
        "prompt_input_ids": encode(prompts)["input_ids"],
        "prompt_attention_mask": encode(prompts)["attention_mask"],
        "chosen_input_ids": encode(chosens)["input_ids"],
        "chosen_attention_mask": encode(chosens)["attention_mask"],
        "rejected_input_ids": encode(rejecteds)["input_ids"],
        "rejected_attention_mask": encode(rejecteds)["attention_mask"],
    }

def main():
    os.makedirs(OUTPUT_DIR, exist_ok=True)
    rows = load_jsonl(DATA_PATH)
    ds = to_hf_dataset(rows)

    tok, model = build_tokenizer_and_model()

    # map 到 DPO 所需字段
    ds = ds.map(lambda ex: format_batch(ex, tok), batched=True, remove_columns=ds.column_names)

    # 训练配置（核心：beta 越大，偏好差异放大）
    cfg = DPOConfig(
        output_dir=OUTPUT_DIR,
        per_device_train_batch_size=2,
        gradient_accumulation_steps=8,
        learning_rate=1e-5,
        lr_scheduler_type="cosine",
        warmup_ratio=0.05,
        max_steps=300,  # demo
        logging_steps=10,
        save_steps=100,
        beta=0.1,      # DPO 超参，常见范围 0.05-0.2
        max_length=768,
        max_target_length=256,
        max_prompt_length=512,
        report_to="none"
    )

    trainer = DPOTrainer(
        model=model,
        ref_model=None,      # 无需引用模型时可置空，TRL 内部会做处理
        beta=cfg.beta,
        train_dataset=ds,
        tokenizer=tok,
        args=cfg,
    )

    trainer.train()
    trainer.save_model(OUTPUT_DIR)
    tok.save_pretrained(OUTPUT_DIR)
    print(f"[DONE] model saved to {OUTPUT_DIR}")

if __name__ == "__main__":
    main()

训练完成后怎么用？
推理时将 LoRA adapter 合并或以 PEFT 方式加载，再按你的提示模板进行生成。此时模型已经“学会”更偏好被裁判判赢的推理风格与答案模式。

6. 可选：PPO 奖励建模的“端到端在线”自博弈

DPO 的优点是稳定简单；但如果你想要“生成—打分—更新”在线联动，PPO 是最直接的强化学习手段。思路：

策略模型生成推理；
奖励函数来自程序化验证 + 一致性评分（与上文类似，但需要标量 reward）；
使用 trl.PPOTrainer 进行策略更新。

下方脚本展示最小 PPO 闭环（数学优先，开放问答采用启发式奖励）。这段代码 140+ 行，可保存为 train_ppo.py。

# train_ppo.py
# -*- coding: utf-8 -*-
"""
最小 PPO 自博弈训练（演示版）：策略模型生成 → 程序化奖励 → PPO 更新
依赖: trl[ppo], transformers, accelerate
"""
import os
import re
import torch
import random
from dataclasses import dataclass
from typing import List, Dict
from transformers import AutoTokenizer, AutoModelForCausalLM
from trl import PPOTrainer, PPOConfig
from datasets import Dataset

def extract_final_number(text: str):
    m = re.findall(r"-?\d+(?:\.\d+)?", text)
    return float(m[-1]) if m else None

def math_reward(answer_text: str, gold: float) -> float:
    pred = extract_final_number(answer_text)
    if pred is None:
        return -1.0
    err = abs(pred - gold)
    # 误差越小，奖励越高；<=1 视为正确
    if err <= 1e-6:
        return 1.0
    return max(-1.0, 1.0 - err / (abs(gold) + 1.0))

def heuristic_reward(answer_text: str, question: str) -> float:
    # 简化启发式：长度、条理性（是否包含条目）、是否引用术语
    length = min(len(answer_text) / 300, 1.0)
    has_list = 0.5 if re.search(r"(\n- |\n\d+\.)", answer_text) else 0.0
    has_terms = 0.5 if re.search(r"(多路复用|头部压缩|服务端推送|HPACK|ALPN)", answer_text) else 0.0
    return max(0.0, min(1.0, 0.5*length + has_list + has_terms))

def build_toy_dataset():
    rows = [
        {"prompt": "计算：27 + 15 = ?", "gold": 42.0},
        {"prompt": "如果 x=5，y=3，求 2*x^2 - y = ?", "gold": 47.0},
        {"prompt": "一个正方形边长为 12 cm，求其面积（单位：cm^2）", "gold": 144.0},
        {"prompt": "简述 HTTP/2 相对 HTTP/1.1 的关键改进点", "gold": None},
    ]
    return Dataset.from_list(rows)

def main():
    base = os.environ.get("PPO_BASE", "Qwen/Qwen2.5-1.5B-Instruct")
    device = "cuda" if torch.cuda.is_available() else "cpu"

    tok = AutoTokenizer.from_pretrained(base, use_fast=True)
    if tok.pad_token is None:
        tok.pad_token = tok.eos_token
    model = AutoModelForCausalLM.from_pretrained(base, device_map="auto", torch_dtype=torch.float16 if device=="cuda" else torch.float32)

    cfg = PPOConfig(
        model_name=base,
        learning_rate=1e-6,
        batch_size=2,
        mini_batch_size=2,
        ppo_epochs=2,
        optimize_cuda_cache=True,
        seed=42,
        target_kl=0.1,
        adap_kl_ctrl=True,
        cliprange=0.2,
        gradient_accumulation_steps=4,
        log_with=None,
        steps=80  # demo
    )

    trainer = PPOTrainer(cfg, model, tok)
    ds = build_toy_dataset()

    system_prompt = "你是一个严谨的推理助手，请逐步计算并在最后给出明确结论。"
    for step in range(cfg.steps):
        batch = ds.shuffle(seed=42+step).select(range(cfg.batch_size))
        queries, responses, rewards = [], [], []
        for item in batch:
            q = f"{system_prompt}\n\n题目：{item['prompt']}\n请给出带推理的答案："
            queries.append(q)
            input_ids = tok(q, return_tensors="pt").to(model.device)
            with torch.no_grad():
                out = model.generate(
                    **input_ids, max_new_tokens=192, do_sample=True,
                    temperature=0.7, top_p=0.9, repetition_penalty=1.05,
                    eos_token_id=tok.eos_token_id, pad_token_id=tok.eos_token_id
                )
                ans = tok.decode(out[0], skip_special_tokens=True).split("答案：")[-1]
            responses.append(ans)
            if item["gold"] is not None:
                r = math_reward(ans, item["gold"])
            else:
                r = heuristic_reward(ans, item["prompt"])
            rewards.append(torch.tensor(r).to(model.device))

        # PPO 更新
        stats = trainer.step(queries, responses, rewards)
        if step % 10 == 0:
            print(f"[PPO] step={step} reward_mean={torch.stack(rewards).mean().item():.3f}")

    out_dir = "./ppo_out"
    os.makedirs(out_dir, exist_ok=True)
    trainer.save_pretrained(out_dir)
    print(f"[DONE] PPO model saved to {out_dir}")

if __name__ == "__main__":
    main()