# 13.3 基准测试

本节介绍学术基准的选择与应用、在自有系统上的复现方法、基准评估报告的生成以及NIST标准化倡议的最新进展。

## 13.3.1 学术基准概览

智能体系统的评估需要接轨学术研究，建立可对标的基准。主要基准包括：

### GAIA

**来源**：Meta-FAIR, Meta-GenAI & Hugging Face(2023)

**特点**：

* 三个难度等级(Level 1-3)
* 强调推理和工具使用的综合能力
* 人类表现远超当前最强模型

**数据分布**：

```
Level 1: 基础任务(简单推理+单工具)
Level 2: 中等任务(多步推理+多工具协作)
Level 3: 困难任务(长链推理+复杂工具组合)
总计: 466个任务
```

**任务类型**：

* 文件系统操作（解压、搜索、分析）
* 网页浏览与信息提取
* 数学计算与推理
* 多步骤问题解决

### WebArena

**来源**：CMU（2023，发表于 ICLR 2024）

**特点**：

* 812个现实网站任务
* 涵盖电商、社交、政府等
* 需要真实交互（不是模拟）

**任务分类**：

```yaml
电商网站:     400+ 任务(购物、支付、评价)
社交媒体:     200+ 任务(发布、搜索、关注)
论坛:         100+ 任务(发帖、编辑、搜索)
政府网站:     50+ 任务(表单填写、信息查询)
```

### SWE-Bench

**来源**：Princeton University（发表于 ICLR 2024；OpenAI 后续合作推出 SWE-bench Verified）

**SWE-bench Verified**：由 OpenAI Preparedness 团队于 2024 年 8 月发布，包含 500 个经过人工验证的高质量 issue-PR 对，从 SWE-Bench 原始 2294 个任务中精选。验证标准包括自动化测试通过、代码质量评审和修复的正确性，是评估 Agent 代码理解和修改能力的重要基准。

**特点**：

* 原始 SWE-Bench：2,294个真实GitHub问题
* Verified版本：500个经人工验证的高质量子集
* 需要修改代码、运行测试
* 评估代码理解与修改能力

**评估维度**：

* 是否通过自动化测试
* 代码质量评分
* 修复的正确性

### AgentBench

**来源**：Tsinghua University（发表于 ICLR 2024）

**特点**：

* 8个多样化领域
* 总计1,447个任务
* 模拟真实工作场景

**领域分布**：

```yaml
知识库操作:   200 任务
数据库操作:   300 任务
Web浏览:      350 任务
文件操作:     200 任务
API调用:      200 任务
邮件管理:     100 任务
日程安排:     97 任务
```

## 13.3.2 在自有系统上复现基准

以上四大基准（GAIA、WebArena、SWE-Bench、AgentBench）提供了多维度的评测标准，但如何在自己的系统上高效地复现这些基准、收集性能指标是后续工作的关键。本节介绍了基准复现的具体方法和工具支持。

### 1. 构建GAIA的子集

GAIA基准的实现代码：

```python
import json
import random
from pathlib import Path

class GAIABenchmark:
    """GAIA基准实现"""

    def __init__(self, data_dir: str = "./data/gaia"):
        self.data_dir = Path(data_dir)
        self.tasks = self._load_tasks()

    def _load_tasks(self) -> dict:
        """加载GAIA任务"""
        tasks = {"level1": [], "level2": [], "level3": []}

        for level in ["level1", "level2", "level3"]:
            level_dir = self.data_dir / level
            if level_dir.exists():
                for task_file in level_dir.glob("*.json"):
                    with open(task_file) as f:
                        task = json.load(f)
                        tasks[level].append(task)

        return tasks

    def get_sample(self, level: str, size: int = 10) -> list:
        """获取该等级的样本"""
        tasks = self.tasks.get(level, [])
        return random.sample(tasks, min(size, len(tasks)))

    async def run_evaluation(self, agent, level: str, size: int = 10):
        """在该等级上运行评估"""
        tasks = self.get_sample(level, size)
        results = []

        for task in tasks:
            try:
                # 执行任务
                result = await agent.execute(
                    instruction=task["instruction"],
                    ground_truth=task.get("ground_truth")
                )

                # 评估
                is_correct = self._evaluate_task(result, task)
                results.append({
                    "task_id": task["id"],
                    "correct": is_correct,
                    "result": result
                })
            except Exception as e:
                results.append({
                    "task_id": task["id"],
                    "correct": False,
                    "error": str(e)
                })

        # 计算成功率
        success_rate = sum(1 for r in results if r["correct"]) / len(results)
        return {
            "level": level,
            "success_rate": success_rate,
            "total": len(results),
            "results": results
        }

    def _evaluate_task(self, result, task) -> bool:
        """评估任务是否正确"""
        # 简化:字符串匹配
        ground_truth = task.get("ground_truth", "")
        return ground_truth.lower() in str(result).lower()

# GAIA基准评估使用示例
benchmark = GAIABenchmark()

# 在Level 1上测试
level1_results = asyncio.run(benchmark.run_evaluation(agent, "level1", size=10))
print(f"Level 1 Success Rate: {level1_results['success_rate']:.1%}")
```

### 2. WebArena子集评估

WebArena基准的实现代码：

```python
class WebArenaBenchmark:
    """WebArena基准实现"""

    def __init__(self, domain: str = "ecommerce"):
        """
        domain: 'ecommerce', 'social_media', 'forum', 'government'
        """
        self.domain = domain
        self.tasks = self._get_sample_tasks()

    def _get_sample_tasks(self) -> list:
        """获取示例任务"""
        tasks = {
            "ecommerce": [
                {
                    "id": "shop_001",
                    "instruction": "在Amazon上搜索'笔记本电脑',按价格从低到高排序",
                    "expected_steps": ["navigate", "search", "sort"],
                    "ground_truth": "sorted by price ascending"
                },
                {
                    "id": "shop_002",
                    "instruction": "添加商品到购物车并查看总价",
                    "expected_steps": ["add_to_cart", "view_cart"],
                    "ground_truth": "total price displayed"
                }
            ],
            "social_media": [
                {
                    "id": "social_001",
                    "instruction": "在Twitter上发布一条包含#AgentBench标签的推文",
                    "expected_steps": ["navigate", "compose", "post"],
                    "ground_truth": "tweet posted"
                }
            ]
        }
        return tasks.get(self.domain, [])

    async def run_evaluation(self, agent, size: int = 5):
        """运行评估"""
        tasks = self.tasks[:size]
        results = []

        for task in tasks:
            try:
                # 模拟网页交互
                trajectory = await agent.interact_with_web(
                    instruction=task["instruction"]
                )

                # 检查是否完成了预期步骤
                completed_steps = [step for step in task["expected_steps"]
                                 if step in [call.tool_name for call in trajectory]]

                success = len(completed_steps) == len(task["expected_steps"])

                results.append({
                    "task_id": task["id"],
                    "success": success,
                    "steps_completed": len(completed_steps),
                    "steps_expected": len(task["expected_steps"])
                })
            except Exception as e:
                results.append({
                    "task_id": task["id"],
                    "success": False,
                    "error": str(e)
                })

        success_rate = sum(1 for r in results if r["success"]) / len(results)
        return {
            "domain": self.domain,
            "success_rate": success_rate,
            "total": len(results),
            "results": results
        }
```

## 13.3.3 基准评估报告生成

实现如下：

```python
import json
from datetime import datetime
import pandas as pd

class BenchmarkReport:
    """基准评估报告"""

    def __init__(self, agent_name: str):
        self.agent_name = agent_name
        self.results = []
        self.timestamp = datetime.now().isoformat()

    def add_result(self, benchmark_name: str, metrics: dict):
        """添加评估结果"""
        self.results.append({
            "benchmark": benchmark_name,
            "metrics": metrics,
            "timestamp": datetime.now().isoformat()
        })

    def generate_report(self, output_file: str = "benchmark_report.json"):
        """生成报告"""
        report = {
            "agent_name": self.agent_name,
            "generated_at": self.timestamp,
            "benchmarks": self.results,
            "summary": self._compute_summary()
        }

        with open(output_file, "w") as f:
            json.dump(report, f, indent=2)

        return report

    def _compute_summary(self) -> dict:
        """计算汇总统计"""
        success_rates = [r["metrics"].get("success_rate", 0) for r in self.results]

        return {
            "avg_success_rate": sum(success_rates) / len(success_rates) if success_rates else 0,
            "best_benchmark": max(self.results, key=lambda x: x["metrics"].get("success_rate", 0))
                             ["benchmark"] if self.results else None,
            "benchmarks_count": len(self.results)
        }

    def to_dataframe(self) -> pd.DataFrame:
        """转为DataFrame用于分析"""
        data = []
        for result in self.results:
            row = {"benchmark": result["benchmark"]}
            row.update(result["metrics"])
            data.append(row)
        return pd.DataFrame(data)

    def print_summary(self):
        """打印汇总"""
        summary = self._compute_summary()
        print(f"\n{'='*60}")
        print(f"Agent: {self.agent_name}")
        print(f"Generated: {self.timestamp}")
        print(f"{'='*60}")
        print(f"\nBenchmark Results:")
        print(f"{'Benchmark':<20} {'Success Rate':<15}")
        print(f"{'-'*35}")

        for result in self.results:
            benchmark = result["benchmark"]
            sr = result["metrics"].get("success_rate", 0)
            print(f"{benchmark:<20} {sr:>6.1%}")

        print(f"\n{'='*60}")
        print(f"Average Success Rate: {summary['avg_success_rate']:.1%}")
        print(f"Best Performing: {summary['best_benchmark']}")
        print(f"{'='*60}\n")

# 综合基准评估使用示例
report = BenchmarkReport("MiniHarness-v1.0")

# 评估GAIA
gaia_benchmark = GAIABenchmark()
level1_result = asyncio.run(gaia_benchmark.run_evaluation(agent, "level1", size=10))
report.add_result("GAIA Level 1", {"success_rate": level1_result["success_rate"]})

# 评估WebArena
web_benchmark = WebArenaBenchmark("ecommerce")
web_result = asyncio.run(web_benchmark.run_evaluation(agent, size=5))
report.add_result("WebArena E-commerce", {"success_rate": web_result["success_rate"]})

# 生成报告
report.generate_report()
report.print_summary()
```

## 13.3.4 NIST AI 智能体标准化倡议

NIST 发起 AI 智能体标准化倡议，当前公开材料聚焦标准制定、开源协议社区、安全与身份研究等方向。下面的维度和代码是本书用于工程评估的示意性映射，不代表 NIST 已发布的合规 API 或标准任务集合。

### 标准化维度

1. **功能分类**：
   * 任务类型（信息检索、事务处理、推理等）
   * 能力等级（基础、中级、高级）
   * 复杂度度量
2. **安全评估**：
   * 对抗鲁棒性
   * 隐私保护
   * 可解释性
3. **性能评估**：
   * 任务成功率
   * 效率指标
   * 成本效益
4. **可靠性评估**：
   * 错误处理能力
   * 恢复能力
   * 一致性

### 合规性检查

具体实现如下：

```python
class AgentStandardsReadiness:
    """示意性的智能体标准化准备度检查"""

    def __init__(self):
        self.requirements = {
            "functional_classification": False,
            "safety_assessment": False,
            "performance_evaluation": False,
            "reliability_assessment": False,
            "documentation": False,
            "testing_coverage": False,
        }

    def check_compliance(self, system) -> dict:
        """检查系统合规性"""

        results = {
            "functional_classification": self._check_function_classification(system),
            "safety_assessment": self._check_safety(system),
            "performance_evaluation": self._check_performance(system),
            "reliability_assessment": self._check_reliability(system),
            "documentation": self._check_documentation(system),
            "testing_coverage": self._check_testing(system),
        }

        compliance_score = sum(results.values()) / len(results)
        results["overall_compliance"] = compliance_score

        return results

    def _check_function_classification(self, system) -> float:
        """功能分类评估"""
        # 检查系统是否有明确的任务分类
        return 0.8 if hasattr(system, "task_categories") else 0.0

    def _check_safety(self, system) -> float:
        """安全评估"""
        # 检查是否有安全防护
        has_permissions = hasattr(system, "permission_engine")
        has_sandboxing = hasattr(system, "sandbox")
        return (has_permissions + has_sandboxing) / 2

    def _check_performance(self, system) -> float:
        """性能评估"""
        # 检查是否有性能指标
        return 0.7 if hasattr(system, "metrics") else 0.0

    def _check_reliability(self, system) -> float:
        """可靠性评估"""
        # 检查是否有错误处理和恢复机制
        has_error_handling = hasattr(system, "error_handler")
        has_recovery = hasattr(system, "recovery_mechanism")
        return (has_error_handling + has_recovery) / 2

    def _check_documentation(self, system) -> float:
        """文档检查"""
        # 检查是否有完整文档
        return 0.8  # 假设有文档

    def _check_testing(self, system) -> float:
        """测试覆盖率检查"""
        # 检查是否有测试套件
        return 0.75 if hasattr(system, "test_suite") else 0.0

# 使用
compliance = AgentStandardsReadiness()
results = compliance.check_compliance(harness_system)

print(f"智能体标准化准备度评分: {results['overall_compliance']:.1%}")
for criterion, score in results.items():
    if criterion != "overall_compliance":
        print(f"  {criterion}: {score:.1%}")
```

## 13.3.5 基准评估的最新动态

智能体评估基准在持续演进，以下是值得关注的最新进展：

**SWE-bench / Terminal-Bench 演进**：SWE-bench Verified 仍是 500 个经过人工筛选的问题子集，适合做软件工程 Agent 的回归参考；OpenAI 发布 GPT-5.2-Codex 时则重点报告了 SWE-Bench Pro 与 Terminal-Bench 2.0 等更贴近真实终端任务的结果。这一趋势再次印证了 Harness 工程的重要性——同一底座模型在不同 Harness、工具权限和执行环境中的表现差异巨大。具体分数应以排行榜或厂商发布页的查询日期为准。

**GAIA Level 3**：作为通用 AI 助手能力的高阶测试，GAIA Level 3 的最高分为 61%（Writer 的 Action Agent），反映出复杂多步骤任务仍然是智能体的瓶颈。

**评估资源整合**：Phil Schmid 整理了 50+ 智能体评估基准的合集，涵盖代码生成、网页导航、工具使用、多步推理等维度。对于 Harness 工程师而言，选择与自身场景匹配的基准进行定期回归测试，比追求单一排行榜排名更有价值。

**行业采用差距**：根据 LangChain《State of Agent Engineering》报告，虽然 89% 的组织已部署可观测性，但系统化评估的采用率仅为 52%。这意味着近半数的生产级智能体缺乏客观的质量度量——这是 Harness 工程亟需填补的空白。

***

**本节总结**：基准测试将自有系统与学术标准对标，GAIA、WebArena、SWE-Bench、AgentBench涵盖了智能体系统的多个维度。NIST标准化倡议标志着该领域走向成熟。


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://yeasy.gitbook.io/harness_engineering_guide/di-si-bu-fen-an-quan-ping-gu-yu-yan-jin/13_evaluation/13.3_benchmarks.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.