第4章 策略与投票

学习目标

• 掌握多 Agent 共识机制与多投票决策的原理与实现
• 理解专家评审（Evaluator）模式与辩论机制的设计要点
• 能够设计质量评估流程，对多 Agent 产出进行客观打分
• 使用 Python 实现多 Agent 投票、评审与辩论的最小系统
• 识别群体思维与策略操控等风险并提出缓解方案

问题导入

某投资决策系统让三个分析师 Agent 各自给出"买入/持有/卖出"建议。结果三个 Agent 都基于同一份财报给出"买入"，但事后证明这份财报数据有误——三个 Agent 同时出错，"全票通过"反而放大了风险。问题在于：简单多数投票假设各 Agent 独立判断，但若它们共享同一信息源、同一模型，"共识"只是幻觉。如何设计投票与评审机制，让决策既可靠又能暴露分歧？本章给出答案。

核心概念

1. 共识机制

共识（Consensus）指多 Agent 就某一决策达成一致。常见共识算法：

机制	描述	适用场景
多数投票（Majority）	票数过半即通过	二选一/多选一的快速决策
加权投票（Weighted）	按专家权重计票	Agent 能力差异大
一致同意（Unanimous）	全票通过	高风险决策需谨慎
多轮投票（Iterative）	多轮收敛，每轮淘汰低票选项	选项多、需收敛
拜占庭容错（BFT）	容忍少数恶意/错误 Agent	高可靠分布式系统

共识的前提：各 Agent 应尽量独立判断——使用不同模型、不同信息源、不同 Prompt 视角，否则"共识"只是同一错误的放大。

2. 多投票决策

当选项多于两个时，简单多数可能无法得出过半结果。常用方法：

• 绝对多数（>50%）：第一轮无人过半则淘汰末位，进入下一轮。
• 偏好投票（Ranked Voting）：每个 Agent 给选项排序，按偏好积分决出胜者。
• 赞成投票（Approval Voting）：每个 Agent 可投多个"可接受"选项，得票最多者胜。
• 孔多塞（Condorcet）：两两对决，能击败所有其他选项者胜。

3. 专家评审（Evaluator）模式

Evaluator 模式把"产出"与"评审"分离：

执行 Agent（产出方案） → 评审 Agent（打分/挑错） → 反馈 → 修订

• 单评审：一个评审 Agent 打分，低于阈值则打回重做。
• 多评审：多个评审 Agent 各自打分，取均值或加权值。
• 对抗评审（Red Team）：专门挑刺的 Agent，模拟攻击者找漏洞。

关键设计：评审 Agent 的 Prompt 与执行 Agent 不同，关注"是否符合规范、有无错误、是否遗漏"，而非"重新做一遍"。

4. 辩论机制

辩论（Debate）让持不同观点的 Agent 公开交锋，通过论证与反驳逼近更优结论：

1. 正方 Agent 提出论点与证据。
2. 反方 Agent 针对论点反驳。
3. 裁判 Agent 评估双方论证质量，判定胜方或要求继续。
4. 设置最大轮次（如 3 轮），避免无休止辩论。

价值：暴露单 Agent 未考虑的反面论据，降低"自信但错误"的风险。研究表明，辩论机制能显著提升 LLM 在推理任务上的准确率。

5. 质量评估

对多 Agent 产出的质量评估需多维度：

维度	评估方式	示例
正确性	与标准答案/事实比对	代码能否通过测试
完整性	是否覆盖所有要点	报告是否含必要章节
一致性	多次产出是否稳定	同输入重复运行结果差异
相关性	是否切题	答案是否回答了问题
安全性	是否含有害内容	经毒性/偏见检测

评估方法：①基于规则（正则、单测）；②基于 LLM 评审（GPT-4 当裁判）；③基于人工抽样；④基于用户反馈（点赞/点踩）。

6. 群体思维与策略操控风险

• 群体思维（Groupthink）：Agent 为"达成共识"而压抑异议，导致次优决策。缓解：引入"魔鬼代言人" Agent 强制提出反对意见。
• 策略操控：Agent 为使自己的偏好胜出而策略性投票（如不投真实偏好）。缓解：匿名投票、限制通信。
• 信息级联：先发言的 Agent 影响后续 Agent。缓解：并行独立投票后再汇总。

原理图

flowchart TB
    Task[待决策任务] --> Split[分发]

    Split --> A1[Agent 1\n独立判断]
    Split --> A2[Agent 2\n独立判断]
    Split --> A3[Agent 3\n独立判断]

    A1 --> Vote[投票汇总]
    A2 --> Vote
    A3 --> Vote

    Vote -->|过半| Pass[通过]
    Vote -->|未过半| Runoff[多轮淘汰]
    Runoff --> Vote

    Pass --> Evaluator[评审 Agent\n打分]
    Evaluator -->|达标| Final[最终决策]
    Evaluator -->|不达标| Revise[返回修订]

    subgraph 辩论机制
        D1[正方 Agent] -->|论点| D2[反方 Agent]
        D2 -->|反驳| D1
        D1 --> Judge[裁判 Agent]
        D2 --> Judge
        Judge --> Winner[判定胜方]
    end

图：多 Agent 投票、评审与辩论决策流程

示例代码

实现一个支持多数投票、加权投票与评审的多 Agent 决策系统。

from collections import Counter
from dataclasses import dataclass
from typing import Callable


@dataclass
class Voter:
    """投票 Agent。"""
    agent_id: str
    weight: float = 1.0
    decide: Callable = None  # 输入问题，返回选项


class VotingSystem:
    """多 Agent 投票决策系统。"""

    def __init__(self, voters: list):
        self.voters = voters

    def majority_vote(self, question: str, options: list) -> tuple:
        """简单多数投票。返回 (胜出选项, 票数明细)。"""
        ballots = []
        for v in self.voters:
            choice = v.decide(question, options) if v.decide else options[0]
            ballots.append(choice)
        tally = Counter(ballots)
        winner = tally.most_common(1)[0][0]
        return winner, dict(tally)

    def weighted_vote(self, question: str, options: list) -> tuple:
        """加权投票：按 Agent 权重计票。"""
        scores = Counter()
        for v in self.voters:
            choice = v.decide(question, options) if v.decide else options[0]
            scores[choice] += v.weight
        winner = scores.most_common(1)[0][0]
        return winner, dict(scores)

    def runoff_vote(self, question: str, options: list, max_rounds=3) -> tuple:
        """多轮淘汰投票：每轮淘汰末位，直至有人过半。"""
        remaining = list(options)
        for rnd in range(max_rounds):
            ballots = [v.decide(question, remaining) for v in self.voters]
            tally = Counter(ballots)
            total = len(ballots)
            top, top_votes = tally.most_common(1)[0]
            if top_votes * 2 > total:
                return top, dict(tally)
            # 淘汰票数最少的
            if len(remaining) > 2:
                loser = tally.most_common()[-1][0]
                remaining.remove(loser)
            else:
                return top, dict(tally)
        return remaining[0], dict(tally)


@dataclass
class Evaluator:
    """评审 Agent：对产出打分。"""
    agent_id: str
    evaluate: Callable  # 输入 (任务, 方案)，返回 0-100 分


class ReviewPipeline:
    """执行→评审→修订 流水线。"""

    def __init__(self, executor: Callable, evaluators: list,
                 threshold: float = 80.0, max_revisions: int = 2):
        self.executor = executor
        self.evaluators = evaluators
        self.threshold = threshold
        self.max_revisions = max_revisions

    def run(self, task: str):
        """产出方案并评审，不达标则修订。"""
        proposal = self.executor(task)
        for i in range(self.max_revisions + 1):
            scores = [e.evaluate(task, proposal) for e in self.evaluators]
            avg = sum(scores) / len(scores)
            print(f"[评审] 第 {i+1} 轮平均分: {avg:.1f} (阈值 {self.threshold})")
            if avg >= self.threshold:
                return proposal, avg
            # 修订：把评审意见反馈给执行 Agent
            proposal = self.executor(f"{task}\n[评审反馈] 当前得分 {avg}，请改进质量。")
        return proposal, avg


# 使用示例
if __name__ == "__main__":
    def decide_a(q, opts): return opts[0]
    def decide_b(q, opts): return opts[1]
    def decide_c(q, opts): return opts[0]

    voters = [
        Voter("A", weight=1.0, decide=decide_a),
        Voter("B", weight=2.0, decide=decide_b),  # 专家权重更高
        Voter("C", weight=1.0, decide=decide_c),
    ]

    vs = VotingSystem(voters)
    q = "是否上线新功能 X？"
    opts = ["上线", "不上线"]
    print("多数投票:", vs.majority_vote(q, opts))
    print("加权投票:", vs.weighted_vote(q, opts))

    def exec_draft(task): return f"关于『{task}』的方案 v1"
    def eval_1(t, p): return 75 if "v1" in p else 85
    def eval_2(t, p): return 78 if "v1" in p else 88

    pipe = ReviewPipeline(exec_draft,
                          [Evaluator("E1", eval_1), Evaluator("E2", eval_2)],
                          threshold=85)
    result, score = pipe.run("接口设计方案")
    print("最终方案:", result, "得分:", round(score, 1))

辩论机制示例：

from openai import OpenAI
client = OpenAI()

def debate(question: str, max_rounds: int = 3) -> str:
    """正反方辩论，裁判判定。"""
    history = f"议题：{question}\n"
    for rnd in range(max_rounds):
        pro = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "system", "content": "你是正方，提出支持论点。"},
                      {"role": "user", "content": history}]).choices[0].message.content
        con = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "system", "content": "你是反方，针对正方反驳。"},
                      {"role": "user", "content": history + "\n正方：" + pro}]).choices[0].message.content
        history += f"\n[第{rnd+1}轮] 正方：{pro}\n反方：{con}"
    verdict = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "system", "content": "你是裁判，基于辩论判定胜方并总结。"},
                  {"role": "user", "content": history}]).choices[0].message.content
    return verdict

企业案例

案例 1：投资决策的多 Agent 投票

某基金公司构建"多分析师 Agent 投票"决策系统。三个 Agent 分别用价值、成长、技术分析视角给出建议，加权投票（价值分析权重 0.5）决出最终建议。引入"魔鬼代言人" Agent 强制提出看空论据后，避开了 2 次"全票看多"的群体思维陷阱，回测显示决策准确率提升 12%。

案例 2：代码评审的 Evaluator 模式

某团队在研发流水线中加入评审 Agent：开发 Agent 提交 PR 后，两个评审 Agent 分别从"功能正确性"与"代码规范"打分，均分低于 80 分则打回修订。设置最大修订 2 次防死循环。上线后 PR 一次通过率从 55% 升至 78%。

案例 3：医疗诊断的辩论机制

某医疗 AI 系统针对疑难病例让"诊断 Agent A"与"诊断 Agent B"基于不同医学指南辩论，由"主任医师 Agent"裁判并综合两方论据给出最终诊断。辩论机制让 8% 的病例在初诊被推翻，最终诊断与多学科会诊结论的一致性达 91%。

常见问题

Q1：投票和评审有什么区别？ A：投票是从多个方案中"选一个"，评审是对单个方案"打分判断是否合格"。投票用于决策选择，评审用于质量把关，常组合使用：先投票选方案，再评审把关质量。

Q2：几个 Agent 投票比较合适？ A：奇数避免平票，3-5 个为宜。过多会增加成本且边际收益递减。关键是保证 Agent 的独立性（不同模型/信息源），而非单纯增加数量。

Q3：辩论机制会不会很贵？ A：会。每轮辩论需要多次 LLM 调用，3 轮辩论约 7 次调用。建议：仅对高风险/高价值决策启用辩论；用小模型承担正反方、大模型当裁判；设置最大轮次。

Q4：如何检测群体思维？ A：①监测共识度过高（如全票通过率 >80%）的决策；②引入"魔鬼代言人"强制反对；③让 Agent 并行独立判断后再汇总；④定期审计"全票错误"案例。

面试题

1. 设计一个多 Agent 投票决策系统，需要考虑哪些要素？ 答题要点：选项设计、投票规则（多数/加权/多轮）、Agent 独立性（不同模型/信息源）、权重分配、平票处理、最大轮次、群体思维防范、审计日志。

2. 简述 Evaluator 模式及其与投票的区别。 参考答案：Evaluator 把产出与评审分离，由独立评审 Agent 对方案打分，不达标则修订。区别：投票是"多选一"的决策，评审是"单方案质量判断"的把关，二者常组合使用。

3. 辩论机制如何提升 LLM 决策质量？有哪些代价？ 参考答案：辩论让正反方公开交锋，暴露单 Agent 未考虑的反面论据，降低"自信但错误"风险，研究表明能提升推理准确率。代价是 token 消耗大（多轮多 Agent）、延迟高、需裁判 Agent 综合判断。适合高风险高价值决策。

练习题

1. 投票实操：实现一个"偏好投票"（Ranked Voting）算法，让 3 个 Agent 对 4 个选项排序，按 Borda 计分法决出胜者。
2. 评审设计：为"自动生成营销文案"场景设计评审 Agent，定义至少 4 个评审维度（如吸引力、合规性、准确性、品牌一致性）并实现打分逻辑。
3. 思考题：如果投票的三个 Agent 都基于同一个 LLM，"共识"还有意义吗？如何提升 Agent 的独立性？

小结

投票、评审与辩论是多 Agent 决策的三大工具。投票用于多方案选择，评审用于质量把关，辩论用于暴露盲区。关键前提是 Agent 的独立性——否则共识只是同一错误的放大。群体思维是主要风险，"魔鬼代言人"与并行独立投票是有效缓解手段。决策机制的选择应与决策重要性匹配：日常用多数投票，关键链路用评审+辩论。下一章将讲解如何让多 Agent 系统安全、可扩展地运行在生产环境。延伸阅读：论文《Improving Factuality and Reasoning in Language Models through Multiagent Debate》、社交选择理论（Arrow 不可能性定理）。