agentic-eval

エージェント的評価パターン

反復的な評価と洗練による自己改善のためのパターンです。

概要

評価パターンは、エージェントが自身の出力を評価し改善することを可能にし、単発の生成から反復的な洗練ループへと移行します。

Generate → Evaluate → Critique → Refine → Output
    ↑                              │
    └──────────────────────────────┘

使用すべき場面

• 品質が重要な生成: 高い精度が求められるコード、レポート、分析
• 明確な評価基準があるタスク: 定義された成功指標が存在する
• 特定の基準が求められるコンテンツ: スタイルガイド、コンプライアンス、フォーマット

---

パターン 1: 基本的なリフレクション

エージェントが自己批判を通じて自身の出力を評価し改善します。

def reflect_and_refine(task: str, criteria: list[str], max_iterations: int = 3) -> str:
    """Generate with reflection loop."""
    output = llm(f"Complete this task:\n{task}")
    
    for i in range(max_iterations):
        # Self-critique
        critique = llm(f"""
        Evaluate this output against criteria: {criteria}
        Output: {output}
        Rate each: PASS/FAIL with feedback as JSON.
        """)
        
        critique_data = json.loads(critique)
        all_pass = all(c["status"] == "PASS" for c in critique_data.values())
        if all_pass:
            return output
        
        # Refine based on critique
        failed = {k: v["feedback"] for k, v in critique_data.items() if v["status"] == "FAIL"}
        output = llm(f"Improve to address: {failed}\nOriginal: {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"Complete: {task}")
    
    def evaluate(self, output: str, task: str) -> dict:
        return json.loads(llm(f"""
        Evaluate output for task: {task}
        Output: {output}
        Return JSON: {{"overall_score": 0-1, "dimensions": {{"accuracy": ..., "clarity": ...}}}}
        """))
    
    def optimize(self, output: str, feedback: dict) -> str:
        return llm(f"Improve based on feedback: {feedback}\nOutput: {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"Write Python code for: {spec}")
        tests = llm(f"Generate pytest tests for: {spec}\nCode: {code}")
        
        for _ in range(max_iterations):
            result = run_tests(code, tests)
            if result["success"]:
                return code
            code = llm(f"Fix error: {result['error']}\nCode: {code}")
        return code

---

評価戦略

結果ベース

出力が期待される結果を達成しているかどうかを評価します。

def evaluate_outcome(task: str, output: str, expected: str) -> str:
    return llm(f"Does output achieve expected outcome? Task: {task}, Expected: {expected}, Output: {output}")

LLM-as-Judge

LLM を使用して出力を比較し、ランク付けします。

def llm_judge(output_a: str, output_b: str, criteria: str) -> str:
    return llm(f"Compare outputs A and B for {criteria}. Which is better and why?")

ルーブリックベース

重み付けされた評価軸に照らして出力を採点します。

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"Rate 1-5 for each dimension: {list(rubric.keys())}\nOutput: {output}"))
    return sum(scores[d] * rubric[d]["weight"] for d in rubric) / 5

---

ベストプラクティス

プラクティス	根拠
明確な基準	具体的で測定可能な評価基準を事前に定義する
反復回数の上限	無限ループを防ぐため最大反復回数（3〜5）を設定する
収束チェック	反復間で出力スコアが改善しない場合は停止する
履歴の記録	デバッグと分析のために完全な軌跡を保持する
構造化出力	評価結果を確実に解析するために JSON を使用する

---

クイックスタートチェックリスト

## Evaluation Implementation Checklist

### Setup
- [ ] Define evaluation criteria/rubric
- [ ] Set score threshold for "good enough"
- [ ] Configure max iterations (default: 3)

### Implementation
- [ ] Implement generate() function
- [ ] Implement evaluate() function with structured output
- [ ] Implement optimize() function
- [ ] Wire up the refinement loop

### Safety
- [ ] Add convergence detection
- [ ] Log all iterations for debugging
- [ ] Handle evaluation parse failures gracefully