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个现实网站任务

• 涵盖电商、社交、政府等

• 需要真实交互（不是模拟）

任务分类：

电商网站:     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个任务

• 模拟真实工作场景

领域分布：

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

13.3.2 在自有系统上复现基准

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

1. 构建GAIA的子集

GAIA基准的实现代码：

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基准的实现代码：

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 基准评估报告生成

实现如下：

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智能体标准化倡议，提出以下建议：

标准化维度

1. 功能分类：

   • 任务类型（信息检索、事务处理、推理等）

   • 能力等级（基础、中级、高级）

   • 复杂度度量

2. 安全评估：

   • 对抗鲁棒性

   • 隐私保护

   • 可解释性

3. 性能评估：

   • 任务成功率

   • 效率指标

   • 成本效益

4. 可靠性评估：

   • 错误处理能力

   • 恢复能力

   • 一致性

合规性检查

具体实现如下：

class NISTCompliance:
    """NIST标准化合规检查"""

    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 = NISTCompliance()
results = compliance.check_compliance(harness_system)

print(f"NIST标准化合规评分: {results['overall_compliance']:.1%}")
for criterion, score in results.items():
    if criterion != "overall_compliance":
        print(f"  {criterion}: {score:.1%}")

13.3.5 基准评估的最新动态

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

SWE-bench Verified v2.0.0 （2026 年 2 月）：SWE-bench 进行了重大升级，更新了测试脚手架、执行环境和令牌限制。在新版基准上，GPT-5.2 以 80% 的解决率领跑排行榜，显著拉开了与其他系统的差距。同时，OpenAI Codex + GPT-5.2 在 Terminal-Bench 2.0 上达到 64% 的解决率。这一结果再次印证了 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标准化倡议标志着该领域走向成熟。