/* MD / 富文本中的 .toc(含博客园搬家等嵌套结构);.toc-box 在侧栏,不受影响 */
#content_views .toc,
/* 编辑器常在目录前后插入空 p(:empty 仍占 20px),一并去掉避免顶空隙 */
#content_views.markdown_views > p:empty:has(+ .toc),
#content_views.markdown_views > .toc + p:empty,
/* 富文本旧版目录标记 */
#content_views.htmledit_views #main-toc,
#content_views.htmledit_views #hr-toc,
#content_views.htmledit_views p[id*=\”-toc\”] {
display: none !important;
}
/* 目录去掉后,紧跟的首个标题不再多出一块上边距 */
#content_views.markdown_views > .toc + h1,
#content_views.markdown_views > .toc + h2,
#content_views.markdown_views > .toc + h3,
#content_views.markdown_views > .toc + h4,
#content_views.markdown_views > .toc + p:empty + h1,
#content_views.markdown_views > .toc + p:empty + h2,
#content_views.markdown_views > .toc + p:empty + h3,
#content_views.markdown_views > .toc + p:empty + h4 {
margin-top: 0 !important;
}
Day 68:多智能体深度实战 —— 投资辩论赛收敛机制优化(三)组合策略
欢迎来到第六十八天!前两天我们分别实现了新论据检测和多裁判投票。新论据检测效率高但只判断“有没有新内容”,可能过早终止;多裁判投票裁决质量高但成本也高,如果每轮都投会浪费 Token。今天我们把两者组合起来:用新论据检测作为“触发信号”,连续无新论据时才启动多裁判投票;投票若决定继续,则让裁判提出关键问题,引导下一轮辩论。最后对比四种策略:基线、新论据、投票、组合策略。
一、今日学习目标

二、详细实现步骤
步骤 1:回顾前两天的结论
| 基线 | 14 | 否 | 0.45 | 3.0 | 0 |
| 新论据检测 | 8 | 是 | 0.15 | 3.5 | 论据提取 N 次 |
| 多裁判投票 | 10 | 是 | 0.20 | 4.2 | 投票 2-3 次 × 3 裁判 |
结论:
- 新论据检测便宜、收敛快,但裁决质量一般,可能过早终止。
- 投票裁决质量高,但每 2 轮投票一次成本高。
- 组合思路:新论据检测做“触发器”,只在连续无新论据时投票,既省成本又保证裁决质量。
步骤 2:设计组合收敛控制器
状态机设计:
辩论进行中
│
▼
每轮发言后 → 新论据检测
│
├── 有新论据 → 继续辩论(不投票)
│
└── 连续 N 轮无新论据 → 触发多裁判投票
│
├── ≥2/3 投 terminate → 汇总裁决,终止
│
└── <2/3 投 terminate → 裁判提问,注入下一轮,继续辩论
│
└── 连续 M 次投票仍不终止 → 强制裁决(兜底)
参数设计:
- no_novelty_threshold = 2:连续 2 轮无新论据触发投票。
- terminate_votes = 2:至少 2/3 裁判投 terminate 才终止。
- max_vote_rounds = 2:最多触发 2 次投票,避免无限投票。
- max_round = 14:最终兜底。
步骤 3:实现组合控制器
新建 debate_combo_controller.py,复用 Day 66 的 NoveltyTracker 和 Day 67 的 collect_votes。
import os
import json
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
load_dotenv()
llm = ChatOpenAI(
model="deepseek-chat",
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com",
temperature=0.2
)
embeddings = OpenAIEmbeddings(
model="embedding-2",
api_key=os.getenv("ZHIPU_API_KEY"),
base_url="https://open.bigmodel.cn/api/paas/v4"
)
class ComboDebateController:
"""组合收敛控制器:新论据检测触发投票,裁判提问引导继续"""
def __init__(
self,
topic: str,
no_novelty_threshold: int = 2,
terminate_votes: int = 2,
max_vote_rounds: int = 2,
max_round: int = 14,
min_round: int = 4,
):
self.topic = topic
self.no_novelty_threshold = no_novelty_threshold
self.terminate_votes = terminate_votes
self.max_vote_rounds = max_vote_rounds
self.max_round = max_round
self.min_round = min_round
# 状态
self.seen_arguments = []
self.seen_vectors = []
self.no_novelty_streak = 0
self.vote_rounds = 0
self.should_terminate = False
self.final_verdict = None
self.logs = []
# ———- 新论据检测 ———-
def _extract_arguments(self, content: str) –> list:
prompt = ChatPromptTemplate.from_messages([
("system", "从以下辩论发言中提取 1-3 个核心论据,每个论据一句话,每行一个,不要编号。"),
("human", "{content}")
])
chain = prompt | llm | StrOutputParser()
try:
result = chain.invoke({"content": content})
return [line.strip() for line in result.split("\\n") if line.strip()]
except Exception:
return []
def _cosine(self, v1, v2):
import numpy as np
v1, v2 = np.array(v1), np.array(v2)
return float(np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2)))
def check_novelty(self, content: str) –> dict:
args = self._extract_arguments(content)
new_args = []
for arg in args:
vec = embeddings.embed_query(arg)
is_new = all(self._cosine(vec, sv) <= 0.85 for sv in self.seen_vectors)
if is_new:
new_args.append(arg)
self.seen_arguments.append(arg)
self.seen_vectors.append(vec)
if new_args:
self.no_novelty_streak = 0
else:
self.no_novelty_streak += 1
result = {
"new_arguments": new_args,
"no_novelty_streak": self.no_novelty_streak,
"trigger_vote": self.no_novelty_streak >= self.no_novelty_threshold,
}
self.logs.append({"type": "novelty_check", **result})
return result
# ———- 多裁判投票 ———-
def _judge_vote(self, role: str, debate_text: str) –> dict:
prompt = ChatPromptTemplate.from_messages([
("system", """你是一位{role}。请判断辩论是否已充分,是否可以终止裁决。
只输出 JSON:
{{"decision": "terminate 或 continue", "reason": "一句话理由", "verdict": "看多/看空/观望(terminate 时填)", "suggested_question": "continue 时必须提出一个关键遗漏问题"}}"""),
("human", "标的:{topic}\\n\\n辩论记录:\\n{debate_text}\\n\\n请投票:")
])
chain = prompt | llm | StrOutputParser()
try:
raw = chain.invoke({
"role": role,
"topic": self.topic,
"debate_text": debate_text[–6000:]
})
cleaned = raw.strip().strip("`").strip()
if cleaned.startswith("json"):
cleaned = cleaned[4:].strip()
return json.loads(cleaned)
except Exception as e:
print(f"[投票解析失败] {role}: {e}")
return {"decision": "continue", "reason": "解析失败", "verdict": "", "suggested_question": ""}
def collect_votes(self, messages: list) –> dict:
debate_text = "\\n".join([
f"{m.get('name')}: {m.get('content')}"
for m in messages
if m.get("name") in ["死多头", "大空头"]
])
votes = {
"乐观裁判": self._judge_vote("偏乐观的裁判,关注成长性和机会是否充分展开", debate_text),
"保守裁判": self._judge_vote("偏保守的裁判,关注风险和估值是否充分讨论", debate_text),
"中立裁判": self._judge_vote("中立裁判,关注双方论据是否平衡、是否有遗漏", debate_text),
}
terminate_count = sum(1 for v in votes.values() if v.get("decision") == "terminate")
result = {
"votes": votes,
"terminate_count": terminate_count,
"should_terminate": terminate_count >= self.terminate_votes,
"suggested_questions": [
v.get("suggested_question") for v in votes.values()
if v.get("decision") == "continue" and v.get("suggested_question")
],
}
self.logs.append({"type": "vote", **result})
return result
# ———- 主循环 ———-
def run(self, max_rounds_per_turn: int = 2):
"""分段辩论:每轮跑 2 个回合,然后检查收敛"""
import autogen
config_list = [{
"model": "deepseek-chat",
"api_key": os.getenv("DEEPSEEK_API_KEY"),
"base_url": "https://api.deepseek.com",
}]
llm_config = {"config_list": config_list, "temperature": 0.7}
bull = autogen.AssistantAgent(
name="死多头",
llm_config=llm_config,
system_message="你是死多头分析师,每次发言不超过 120 字,提出新论据,不要重复。"
)
bear = autogen.AssistantAgent(
name="大空头",
llm_config=llm_config,
system_message="你是大空头分析师,每次发言不超过 120 字,提出新论据,不要重复。"
)
user_proxy = autogen.UserProxyAgent(
name="投资者",
human_input_mode="NEVER",
max_consecutive_auto_reply=0,
code_execution_config=False,
)
messages = []
while len(messages) < self.max_round:
# 跑一小段辩论
groupchat = autogen.GroupChat(
agents=[user_proxy, bull, bear],
messages=messages,
max_round=max_rounds_per_turn,
speaker_selection_method="round_robin",
)
manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=llm_config)
msg = self.topic if not messages else "请继续辩论,提出新论据。"
user_proxy.initiate_chat(manager, message=msg)
messages = groupchat.messages
# 对最新发言做新论据检测
for m in messages[–max_rounds_per_turn:]:
if m.get("name") in ["死多头", "大空头"]:
novelty = self.check_novelty(m.get("content", ""))
print(f"[新论据] {m['name']} 新论据={len(novelty['new_arguments'])}, "
f"连续无新论据={novelty['no_novelty_streak']}")
# 未达到最小轮数,不触发投票
if len(messages) < self.min_round:
continue
# 连续无新论据 → 触发投票
if self.no_novelty_streak >= self.no_novelty_threshold and self.vote_rounds < self.max_vote_rounds:
self.vote_rounds += 1
print(f"\\n[触发投票] 第 {self.vote_rounds} 次投票,当前轮数={len(messages)}")
vote_result = self.collect_votes(messages)
if vote_result["should_terminate"]:
# 汇总裁决
final = self._judge_vote(
"中立裁判,请综合三方投票给出最终裁决(看多/看空/观望)并说明理由",
"\\n".join([m.get("content", "") for m in messages])
)
self.final_verdict = final.get("verdict", "观望")
messages.append({
"name": "汇总裁判",
"content": f"最终裁决:{self.final_verdict}。理由:{final.get('reason', '')}"
})
self.should_terminate = True
print(f"[终止] 最终裁决:{self.final_verdict}")
break
else:
# 裁判提问,注入下一轮
questions = ";".join(vote_result["suggested_questions"]) or "请补充新的关键论据。"
messages.append({
"name": "主持人",
"content": f"裁判建议补充:{questions}"
})
# 重置连续无新论据计数,给双方机会回应
self.no_novelty_streak = 0
print(f"[继续] 裁判提问:{questions}")
# 兜底:达到 max_round 仍未终止
if not self.should_terminate:
print("\\n[兜底] 达到最大轮数,强制裁决")
final = self._judge_vote(
"中立裁判,请给出最终裁决(看多/看空/观望)并说明理由",
"\\n".join([m.get("content", "") for m in messages])
)
self.final_verdict = final.get("verdict", "观望")
messages.append({
"name": "汇总裁判",
"content": f"最终裁决:{self.final_verdict}。理由:{final.get('reason', '')}"
})
self.should_terminate = True
return {
"messages": messages,
"total_rounds": len(messages),
"vote_rounds": self.vote_rounds,
"final_verdict": self.final_verdict,
"logs": self.logs,
}
步骤 4:跑四组对比实验
4.1 实验设置
统一条件:标的“特斯拉(TSLA)”、DeepSeek-chat、max_round=14。
| Baseline | 无 | 仅 max_round |
| Exp1 | 新论据检测 | 连续 2 轮无新论据直接终止 |
| Exp2 | 多裁判投票 | 每 2 轮投票一次,≥2/3 终止 |
| Exp3 | 组合策略 | 连续 2 轮无新论据触发投票,≥2/3 终止,裁判提问引导继续 |
4.2 评估指标
| 总轮数 | 终止时消息数 |
| 自然终止 | 是否在 max_round 前由裁决终止 |
| 观点重复率 | 重复论据 / 总论据 |
| 新论据率 | 新论据 / 总轮数 |
| 投票次数 | 组合策略和投票策略的投票次数 |
| 裁决质量(1-5) | LLM-as-Judge + 人工抽检 |
| 额外 LLM 调用 | 论据提取 + 投票 + 裁决的总调用次数 |
4.3 实验结果表(示例)
| 总轮数 | 14 | 8 | 10 | 9 |
| 自然终止 | 否 | 是 | 是 | 是 |
| 观点重复率 | 0.45 | 0.15 | 0.20 | 0.12 |
| 新论据率 | 0.40 | 0.75 | 0.65 | 0.78 |
| 投票次数 | 0 | 0 | 3 | 2 |
| 裁决质量(1-5) | 3.0 | 3.5 | 4.2 | 4.5 |
| 额外 LLM 调用 | 0 | 约 16 次 | 约 12 次 | 约 10 次 |
4.4 结论(示例)
- 组合策略最优:总轮数 9,比新论据检测多 1 轮,但裁决质量从 3.5 提升到 4.5。
- 成本可控:组合策略投票 2 次(新论据触发),比纯投票策略的 3 次更少;额外 LLM 调用约 10 次,低于纯新论据检测的 16 次(因为裁判提问后双方补充了高质量新论据,减少了无效轮次)。
- 新论据率最高:裁判提问引导双方补充关键遗漏,论据质量提升。
- 推荐方案:组合策略作为默认收敛机制;对成本极敏感场景可退化为纯新论据检测。
步骤 5:裁判提问机制的效果分析
5.1 提问质量检查
查看 logs 中的 suggested_questions,检查是否具体:
| 1 | “请补充特斯拉的估值与同业对比” | 是 | 是 |
| 2 | “请讨论自动驾驶监管风险” | 是 | 是 |
优化 Prompt:要求裁判提问必须包含“具体维度 + 期望数据/论据”,禁止“请继续讨论”这类空泛问题。
5.2 提问后的辩论质量
对比“裁判提问后”和“无提问”两种情况下,下一轮发言的新论据数量。通常提问后新论据更多,因为问题聚焦。
步骤 6:调参实验
对组合策略的关键参数做网格实验:
| no_novelty_threshold | 1 / 2 / 3 | 太小投票频繁,太大收敛慢 |
| terminate_votes | 2 / 3 | 3 更保守,轮数更多 |
| max_vote_rounds | 1 / 2 / 3 | 限制投票次数,控制成本 |
| min_round | 4 / 6 | 太小辩论不充分 |
实验记录:每组参数跑 1 次(条件允许跑 3 次取平均),记录总轮数、裁决质量、额外调用次数。选出“裁决质量 ≥4 且总轮数 ≤10 且调用次数 ≤12”的组合。
步骤 7:写最终报告并写回项目
新建 debate_optimization_final.md:
# 投资辩论赛收敛机制优化:最终报告
## 四种策略对比
(粘贴对比表)
## 推荐方案:组合策略
– 新论据检测(连续 2 轮无新论据)触发多裁判投票(≥2/3 终止)
– 投票未终止时,裁判提出关键遗漏问题,引导下一轮
– 最多投票 2 次,max_round=14 兜底
## 关键参数
no_novelty_threshold=2, terminate_votes=2, max_vote_rounds=2, min_round=4
## 效果
– 总轮数 9(基线 14)
– 裁决质量 4.5/5(基线 3.0)
– 额外 LLM 调用约 10 次(纯新论据 16 次)
## 取舍与反思
– 组合策略在质量、成本、轮数之间取得较好平衡。
– 裁判提问质量依赖 Prompt,需持续优化。
– 评估基于单次实验,建议多次运行取平均,并扩大标的数量。
写回项目:把 ComboDebateController 集成到 investment_debate.py,更新 README,保存辩论记录(JSON + Markdown)。
三、常见问题与调试
Q1:分段辩论导致上下文丢失或重复开场。
→ 每次小群聊传入完整 messages;第一轮用 topic,后续用“请继续辩论,提出新论据”;检查 groupchat.messages 是否累积正确。
Q2:裁判提问后,双方没有回应提问。
→ 在注入提问时,明确要求“下一位发言者必须首先回应主持人的问题”;也可以在 system_message 中要求“每轮发言先回应裁判提问,再提出自己的论据”。
Q3:投票次数超过 max_vote_rounds 仍未终止。
→ 兜底逻辑确保达到 max_round 时强制裁决;也可以在最后一次投票后,无论结果如何都让汇总裁判裁决。
Q4:新论据检测把“回应裁判提问”误判为无新论据。
→ 回应提问通常包含新信息,不应被误判。检查论据提取 Prompt 是否把“回应”也提取为论据;如果双方只是重复提问内容,则确实无新论据。
Q5:组合策略比纯新论据检测还慢。
→ 检查 no_novelty_threshold 是否太小导致频繁投票;投票后是否重置了 no_novelty_streak;裁判提问是否过于宽泛导致无效轮次。
Q6:成本仍然偏高。
→ 减少论据提取频率(每 2 轮提取一次);用更便宜的模型做论据提取和投票;只对“死多头/大空头”发言检测,不检测主持人。
Q7:裁决质量评分主观。
→ 用 LLM-as-Judge 辅助评分,标准包括:是否引用双方论据、是否明确裁决、是否有理由、是否平衡。人工抽检 3-5 条校准。
四、今日总结与作业
今天你完成了:
- ✅ 理解了“信号触发 + 投票决策”的组合设计。
- ✅ 实现了 ComboDebateController:新论据检测触发投票,裁判提问引导继续。
- ✅ 实现了裁判提问机制,并要求提问具体、可回应。
- ✅ 跑了四组对比实验,从轮数、重复率、裁决质量、成本四个维度评估。
- ✅ 输出了最终报告,确定组合策略为推荐方案。
今日作业(必做):
明日预告: Day 69 我们将把优化后的辩论系统工程化落地:用 FastAPI 包装成“辩论即服务”(Debate-as-a-Service),支持提交标的、异步运行辩论、查询辩论记录和最终裁决,并加上 Day 63 的可观测性(Trace ID、指标)。这是把多智能体项目变成可展示作品的最后一步。
有任何问题欢迎评论交流。
网硕互联帮助中心





评论前必须登录!
注册