Agentic Evaluation Patterns

反復的な評価と改善を通じた自己改善のためのパターン。

概要

評価パターンにより、エージェント自身の出力を評価および改善できるようになり、単一の生成を超えて反復的な改善ループへ移行します。

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を使用する

---

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

## 評価実装チェックリスト

### セットアップ
- [ ] 評価基準/ルーブリックを定義する
- [ ] 「十分」なスコア閾値を設定する
- [ ] 最大反復回数を設定する（デフォルト: 3）

### 実装
- [ ] generate()関数を実装する
- [ ] 構造化出力を備えたevaluate()関数を実装する
- [ ] optimize()関数を実装する
- [ ] 改善ループを配線する

### セキュリティ
- [ ] 収束検出を追加する
- [ ] すべての反復をログに記録してデバッグする
- [ ] 評価解析の失敗を適切に処理する