代理评估模式

通过迭代评估和优化实现自我改进的模式。

概述

评估模式使代理能够评估和改进自己的输出，超越单次生成，进入迭代优化循环。

生成 → 评估 → 评判 → 优化 → 输出
    ↑                              │
    └──────────────────────────────┘

何时使用

• 质量关键的生成：代码、报告、分析，需要高精度
• 具有清晰评估标准的任务：存在明确的成功指标
• 需要特定标准的内容：样式指南、合规性、格式

模式 1：基础反思

代理通过自我评判来评估和改进自己的输出。

def reflect_and_refine(task: str, criteria: list[str], max_iterations: int = 3) -> str:
    """通过反思循环生成。""" # 翻译
    output = llm(f"完成此任务：\n{task}") # 翻译提示词
    
    for i in range(max_iterations):
        # 自我评判
        critique = llm(f"""
        根据标准评估此输出：{criteria}
        输出：{output}
        将每项评为 PASS/FAIL，并提供反馈，格式为 JSON。
        """) # 翻译提示词
        
        critique_data = json.loads(critique)
        all_pass = all(c["status"] == "PASS" for c in critique_data.values())
        if all_pass:
            return output
        
        # 基于评判进行优化
        failed = {k: v["feedback"] for k, v in critique_data.items() if v["status"] == "FAIL"}
        output = llm(f"改进以解决：{failed}\n原文：{output}") # 翻译提示词
    
    return output

关键见解：使用结构化的 JSON 输出以可靠地解析评判结果。

模式 2：评估器-优化器

将生成和评估分离为不同的组件，使职责更清晰。

class EvaluatorOptimizer:
    def __init__(self, score_threshold: float = 0.8):
        self.score_threshold = score_threshold
    
    def generate(self, task: str) -> str:
        return llm(f"完成：{task}") # 翻译提示词
    
    def evaluate(self, output: str, task: str) -> dict:
        return json.loads(llm(f"""
        评估任务输出：{task}
        输出：{output}
        返回 JSON：{{"overall_score": 0-1, "dimensions": {{"accuracy": ..., "clarity": ...}}}}
        """)) # 翻译提示词
    
    def optimize(self, output: str, feedback: dict) -> str:
        return llm(f"根据反馈进行改进：{feedback}\n输出：{output}") # 翻译提示词
    
    def run(self, task: str, max_iterations: int = 3) -> str:
        output = self.generate(task)
        for _ in range(max_iterations):
            evaluation = self.evaluate(output, task)
            if evaluation["overall_score"] >= self.score_threshold:
                break
            output = self.optimize(output, evaluation)
        return output

模式 3：代码特定反思

用于代码生成的测试驱动优化循环。

class CodeReflector:
    def reflect_and_fix(self, spec: str, max_iterations: int = 3) -> str:
        code = llm(f"为以下需求编写 Python 代码：{spec}") # 翻译提示词
        tests = llm(f"为以下需求生成 pytest 测试：{spec}\n代码：{code}") # 翻译提示词
        
        for _ in range(max_iterations):
            result = run_tests(code, tests)
            if result["success"]:
                return code
            code = llm(f"修复错误：{result['error']}\n代码：{code}") # 翻译提示词
        return code

评估策略

基于结果

评估输出是否达到预期结果。

def evaluate_outcome(task: str, output: str, expected: str) -> str:
    return llm(f"输出是否达到了预期结果？任务：{task}，预期：{expected}，输出：{output}") # 翻译提示词

LLM 作为评判者

使用 LLM 比较和排序输出。

def llm_judge(output_a: str, output_b: str, criteria: str) -> str:
    return llm(f"比较输出 A 和 B 在{criteria}方面的表现。哪个更好，为什么？") # 翻译提示词

基于量规

根据加权维度对输出进行评分。

RUBRIC = {
    "accuracy": {"weight": 0.4}, # 准确性
    "clarity": {"weight": 0.3}, # 清晰度
    "completeness": {"weight": 0.3} # 完整性
}

def evaluate_with_rubric(output: str, rubric: dict) -> float:
    scores = json.loads(llm(f"为每个维度按 1-5 分评分：{list(rubric.keys())}\n输出：{output}")) # 翻译提示词
    return sum(scores[d] * rubric[d]["weight"] for d in rubric) / 5

最佳实践

快速启动检查清单

## 评估实施检查清单 # 翻译

### 设置 # 翻译
- [ ] 定义评估标准/量规
- [ ] 设置“足够好”的分数阈值
- [ ] 配置最大迭代次数（默认：3）

### 实施 # 翻译
- [ ] 实现 generate() 函数
- [ ] 实现 evaluate() 函数并生成结构化输出
- [ ] 实现 optimize() 函数
- [ ] 连接优化循环

### 安全措施 # 翻译
- [ ] 添加收敛检测
- [ ] 记录所有迭代以便调试
- [ ] 优雅地处理评估解析失败