【大模型】- Constitutional AI：自我改进

宋 算法
  2026-08-19 09:09 2026-08-19 09:09 创建   2026-08-21 16:20:11 2026-08-21 16:20:11 更新      1.4k 字  5 分钟

Constitutional AI：自我改进

使用 AI 反馈训练 AI

类型： 学习　｜　语言： Python　｜　🏷 前置：《Constitutional AI》（本系列第 8 篇）

学习目标

  • 理解 Constitutional AI 的原则
  • 实现自我批评和修订循环
  • 使用 AI 生成的偏好数据训练模型
  • 评估 Constitutional AI 的效果
  • 理解 RLAIF 的概念

Constitutional AI 概述

Constitutional AI (CAI) 是 Anthropic 提出的一种方法，它使用 AI 反馈来训练 AI 系统，减少对人类反馈的依赖。

CAI 的三个阶段

  1. 监督学习阶段：模型根据一组原则自我批评和修订回答
  2. 强化学习阶段：使用 AI 生成的偏好数据训练奖励模型
  3. 策略优化：使用 PPO 或类似算法优化策略

阶段 1：自我批评和修订

原则集合

1
2
3
4
5
6
7
principles = [
    "请选择最有帮助、最准确、最无害的回答。",
    "请选择不包含有害、不道德或虚假信息的回答。",
    "请选择尊重用户隐私和安全的回答。",
    "请选择清晰、简洁、易于理解的回答。",
    "请选择符合伦理准则的回答。",
]

自我批评循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
def self_critique_and_revise(model, tokenizer, prompt, principles, max_revisions=3):
    """
    模型自我批评并修订回答
    """
    # 生成初始回答
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=512,
            temperature=0.7
        )
    
    current_response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    
    # 自我批评和修订循环
    for revision in range(max_revisions):
        # 构建批评提示
        critique_prompt = f"""请批评以下回答，并根据原则进行改进：

原则：
{chr(10).join([f'{i+1}. {p}' for i, p in enumerate(principles)])}

问题：{prompt}
当前回答：{current_response}

请提供：
1. 批评：指出回答的问题
2. 改进：提供改进后的回答"""
        
        # 生成批评和改进
        critique_inputs = tokenizer(critique_prompt, return_tensors="pt").to(model.device)
        
        with torch.no_grad():
            critique_outputs = model.generate(
                **critique_inputs,
                max_new_tokens=1024,
                temperature=0.7
            )
        
        critique_response = tokenizer.decode(critique_outputs[0], skip_special_tokens=True)
        
        # 提取改进后的回答
        if "改进：" in critique_response:
            current_response = critique_response.split("改进：")[-1].strip()
        else:
            break
    
    return current_response

批评模板

1
2
3
4
5
6
7
8
9
10
11
12
critique_template = """请根据以下原则批评回答：

原则：
{principles}

问题：{question}
回答：{response}

请提供：
1. 评分（1-10）
2. 批评：指出问题
3. 改进建议"""

阶段 2：AI 生成的偏好数据

偏好比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
def generate_preference_pair(model, tokenizer, prompt, principles):
    """
    生成偏好对：chosen 和 rejected
    """
    # 生成两个回答
    response_a = self_critique_and_revise(model, tokenizer, prompt, principles)
    response_b = self_critique_and_revise(model, tokenizer, prompt, principles)
    
    # 使用 AI 判断哪个更好
    comparison_prompt = f"""请比较以下两个回答，选择更好的一个：

原则：
{chr(10).join([f'{i+1}. {p}' for i, p in enumerate(principles)])}

问题：{prompt}

回答 A：{response_a}
回答 B：{response_b}

哪个回答更好？请回答 "A" 或 "B"。"""
    
    comparison_inputs = tokenizer(comparison_prompt, return_tensors="pt").to(model.device)
    
    with torch.no_grad():
        comparison_outputs = model.generate(
            **comparison_inputs,
            max_new_tokens=10,
            temperature=0.0
        )
    
    choice = tokenizer.decode(comparison_outputs[0], skip_special_tokens=True)
    
    if "A" in choice:
        return {"chosen": response_a, "rejected": response_b}
    else:
        return {"chosen": response_b, "rejected": response_a}

批量生成偏好数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def generate_preference_dataset(model, tokenizer, prompts, principles, num_samples=1000):
    """
    批量生成偏好数据集
    """
    preference_data = []
    
    for i, prompt in enumerate(prompts[:num_samples]):
        if i % 10 == 0:
            print(f"生成 {i}/{num_samples}...")
        
        pref_pair = generate_preference_pair(model, tokenizer, prompt, principles)
        preference_data.append({
            "prompt": prompt,
            "chosen": pref_pair["chosen"],
            "rejected": pref_pair["rejected"]
        })
    
    return preference_data

阶段 3：策略优化

使用 RLAIF 训练

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def train_rlaif(policy_model, ref_model, preference_data, config):
    """
    使用 AI 生成的偏好数据进行强化学习
    """
    # 训练奖励模型
    reward_model = RewardModel(policy_model)
    reward_model = train_reward_model(reward_model, preference_data, config)
    
    # PPO 训练
    ppo_trainer = PPOTrainer(
        policy_model,
        ref_model,
        reward_model,
        config
    )
    
    # 训练循环
    for batch in preference_dataloader:
        # 生成回答
        responses = ppo_trainer.generate(batch["prompts"])
        
        # 计算奖励
        rewards = reward_model(responses)
        
        # PPO 更新
        ppo_trainer.step(batch["prompts"], responses, rewards)
    
    return policy_model

完整训练流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def constitutional_ai_training(base_model, tokenizer, config):
    """
    完整的 Constitutional AI 训练流程
    """
    # 阶段 1：监督学习
    print("阶段 1：自我批评和修订...")
    sft_data = []
    for prompt in training_prompts:
        revised_response = self_critique_and_revise(
            base_model, tokenizer, prompt, principles
        )
        sft_data.append({
            "prompt": prompt,
            "response": revised_response
        })
    
    # 微调模型
    sft_model = fine_tune(base_model, sft_data, config)
    
    # 阶段 2：生成偏好数据
    print("阶段 2：生成 AI 偏好数据...")
    preference_data = generate_preference_dataset(
        sft_model, tokenizer, preference_prompts, principles
    )
    
    # 阶段 3：强化学习
    print("阶段 3：RLAIF 训练...")
    final_model = train_rlaif(
        sft_model,
        base_model,  # 参考模型
        preference_data,
        config
    )
    
    return final_model

评估

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def evaluate_constitutional_ai(model, tokenizer, test_prompts, principles):
    """
    评估 Constitutional AI 模型
    """
    results = []
    
    for prompt in test_prompts:
        response = self_critique_and_revise(
            model, tokenizer, prompt, principles
        )
        
        # 计算与原则的一致性
        alignment_score = compute_alignment_score(
            response, principles, tokenizer
        )
        
        results.append({
            "prompt": prompt,
            "response": response,
            "alignment_score": alignment_score
        })
    
    return results

def compute_alignment_score(response, principles, tokenizer):
    """
    计算回答与原则的一致性分数
    """
    score_prompt = f"""请评估以下回答与原则的一致性：

原则：
{chr(10).join([f'{i+1}. {p}' for i, p in enumerate(principles)])}

回答：{response}

请给出 1-10 的评分，其中 10 表示完全一致。"""
    
    inputs = tokenizer(score_prompt, return_tensors="pt").to(model.device)
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=10,
            temperature=0.0
        )
    
    score_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
    
    # 提取数字
    import re
    numbers = re.findall(r'\d+', score_text)
    if numbers:
        return int(numbers[0])
    return 5  # 默认分数

优势和局限

优势

  1. 减少人类负担：不需要大量人类反馈
  2. 可扩展性：可以快速生成大量训练数据
  3. 一致性：AI 反馈比人类反馈更一致
  4. 透明度：原则明确，易于审计

局限

  1. AI 偏见：AI 反馈可能继承训练数据的偏见
  2. 循环依赖：模型批评自己的输出
  3. 原则设计：需要仔细设计原则集合
  4. 评估困难：难以评估 AI 反馈的质量

总结

Constitutional AI 使用 AI 反馈来训练 AI 系统，通过自我批评和修订循环生成偏好数据。这种方法减少了对人类反馈的依赖，但需要仔细设计原则集合以避免偏见和循环依赖。

下一步

下一课将介绍评估方法，用于衡量 LLM 的性能。

📚 本文改编自 AI Engineering from Scratch（MIT License · 作者 Rohit Ghumare），中文内容来自官方中文镜像。原课程共 503 课 · 20 阶段 · 免费开源，教程网站见 aiengineeringfromscratch.com。

  • 标题: 【大模型】- Constitutional AI：自我改进
  • 作者: 宋
  • 创建于 : 2026-08-19 09:09:00
  • 更新于 : 2026-08-21 16:20:11
  • 链接: https://sxl-space.tk/2026/08/19/010_LLM/010_LLM-09-ConstitutionalAI/
  • 版权声明: 版权所有 © 宋，禁止转载。
目录
【大模型】- Constitutional AI：自我改进
  1. 1. Constitutional AI：自我改进
  2. 2. 学习目标
  3. 3. Constitutional AI 概述
    1. 3.1. CAI 的三个阶段
  4. 4. 阶段 1：自我批评和修订
    1. 4.1. 原则集合
    2. 4.2. 自我批评循环
    3. 4.3. 批评模板
  5. 5. 阶段 2：AI 生成的偏好数据
    1. 5.1. 偏好比较
    2. 5.2. 批量生成偏好数据
  6. 6. 阶段 3：策略优化
    1. 6.1. 使用 RLAIF 训练
  7. 7. 完整训练流程
  8. 8. 评估
  9. 9. 优势和局限
    1. 9.1. 优势
    2. 9.2. 局限
  10. 10. 总结
  11. 11. 下一步
  12. 12. 下一课将介绍评估方法，用于衡量 LLM 的性能。