SWE-bench 怎么用：评测流程与本仓 S1-S7

概览

§ 1 5 步评测流程

SWE-bench 评测可以抽象成 5 步——本仓 answer_evaluator 严格按这 5 步实现。

┌─────────────────────────────────────────────────────────────────┐
│  Step 1: 拉 base_commit                                            │
│  →  git clone https://github.com/<repo>.git                      │
│  →  git checkout <base_commit>                                  │
│  →  状态：干净的 issue 时刻仓库代码                                │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 2: 跑 pre-fix 测试（不 apply model_patch）                    │
│  →  apply test_patch（让 F2P 测试在当前状态 fail）                │
│  →  pytest run(test_ids = fail_to_pass + pass_to_pass)             │
│  →  记录 pre[test_id] = pass / fail                                │
│  →  期望：fail_to_pass 的测试全 fail，pass_to_pass 的测试全 pass   │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 3: apply model_patch（agent 产出的 patch）                   │
│  →  git apply model_patch.diff（3 段回退：直接 apply / --reject /    │
│     patch -p1）                                                    │
│  →  如果都失败 → 判 resolve=False（agent patch 格式错）            │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 4: 跑 post-fix 测试（已 apply model_patch）                   │
│  →  pytest run(test_ids = fail_to_pass + pass_to_pass)             │
│  →  记录 post[test_id] = pass / fail                               │
│  →  期望：fail_to_pass 全 pass，pass_to_pass 仍全 pass              │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 5: 判分                                                        │
│  →  resolved = (∀F2P: pre=fail ∧ post=pass) ∧                      │
│              (∀P2P: pre=pass ∧ post=pass)                          │
│  →  写 report.json / run_report.json                                │
└─────────────────────────────────────────────────────────────────┘

def run_instance(test_spec, pred, ...):
    container = build_container(test_spec, ...).start()
    write_to_container(container, "/tmp/patch.diff", pred.model_patch)

    # Step 3: 三段回退 apply patch
    applied = try_apply_patch(container, GIT_APPLY_CMDS)
    if not applied:
        return {"completed": False, "resolved": False}

    # Step 4: 跑测试
    write_to_container(container, "/eval.sh", test_spec.eval_script)
    log = exec_run_with_timeout(container, "bash /eval.sh", timeout=1800)

    # Step 5: 判分
    return grading.get_eval_report(test_spec, pred, log_path)

§ 2 评分公式详解

从单 instance 的 F2P/P2P 判分，到整个数据集的 %Resolved 指标——有 4 个层级。

第 1 层：单测试判定

第 2 层：单 instance 判定（4 个状态）

第 3 层：单 instance 评分

def get_resolution_status(test_spec, pred, log):
    # 1. 解析 pytest 日志
    test_results = parse_log(log)
    # → {test_id: PASSED / FAILED}

    # 2. 计算 F2P / P2P 状态
    f2p_passed = all(test_results[t] == "PASSED" for t in test_spec.fail_to_pass)
    p2p_passed = all(test_results[t] == "PASSED" for t in test_spec.pass_to_pass)

    # 3. 4 个状态
    if test_spec.eval_type == EvalType.FAIL_ONLY:
        # 特殊 repo：只检查 F2P
        if f2p_passed: return "FULL"
        elif any(...): return "PARTIAL"
        else: return "NO"
    else:
        # 标准 repo
        if f2p_passed and p2p_passed: return "FULL"
        elif (0 < f2p_pass_rate < 1) and p2p_passed: return "PARTIAL"
        else: return "NO"

第 4 层：整个数据集的主指标

%Resolved = count(instances where status == "FULL") / count(instances) * 100%

§ 3 Docker 3 层镜像机制（内容哈希缓存）

评测要跑大量测试，需要隔离环境。SWE-bench 用3 层 Docker 镜像构建环境，每层用内容哈希做缓存——重复 instance 跑 100 次也只构建 1 次。

┌────────────────────────────────────────────────────┐
│  base 镜像（操作系统 + Python 解释器）                │
│  →  OS（Ubuntu 22.04 等）+ Python 3.10/3.11 + Conda │
│  →  内容：Dockerfile 模板 + 系统包 + pip             │
│  →  缓存键：docker_specs 哈希                        │
└────────────────────────────────────────────────────┘
                          ↓
┌────────────────────────────────────────────────────┐
│  env 镜像（拉仓库 + 装依赖）                          │
│  →  git clone <repo> → git checkout <env_commit>   │
│  →  pip install -e .（装仓库依赖）                  │
│  →  内容：完整仓库 + 已装依赖                       │
│  →  缓存键：env_script_list + repo + version 哈希   │
└────────────────────────────────────────────────────┘
                          ↓
┌────────────────────────────────────────────────────┐
│  instance 镜像（checkout base_commit + apply test）  │
│  →  在 env 之上 git checkout <base_commit>          │
│  →  apply test_patch                                  │
│  →  准备 eval.sh（跑测试的 shell 脚本）             │
│  →  内容：可立即跑 pytest 的环境                    │
│  →  缓存键：base_commit + test_patch 哈希           │
└────────────────────────────────────────────────────┘

try:
    git apply /tmp/patch.diff
    return True
except:
    try:
        git apply --reject /tmp/patch.diff
        return True
    except:
        try:
            patch -p1 < /tmp/patch.diff
            return True
        except:
            return False

§ 4 本仓 S1-S7 pipeline：评测流程的工程化

本仓把 SWE-bench 5 步评测流程工程化为 7 个 stage（S1-S7），用 experiment_modules/orchestration/ 统一调度。

S1 (0.1s)  →  S2 (17s)  →  S3 (5s)  →  S4 (420s)  →  S5 (0.01s)  →  S6 (162s)  →  S7 (0.1s)
出题         拉镜像       跑基线     跑 agent     抽 patch      跑 F2P/P2P    写库
                                            (model 输出)                (F2P/P2P)
                                            
                                    ─────── 不是 SWE-bench 原生 ────────
                                            
───────────────────────────────────── SWE-bench 5 步在这里 ────────────
                                            Step 1-2    Step 3    Step 4-5
                                            
合计 ~10 分钟/instance（Lite 子集 300 题 ≈ 50 小时，但 S4/S6 可并行多 instance）

§ 5 agent_runtime 5 种 adapter（S4_solve 的可选选手）

S4_solve 阶段可以选不同 agent 跑——本仓 experiment_modules/solving/agent_runtime/ 提供 5 种 adapter，按需选。

# experiment_modules/solving/agent_runtime/registry.py
RUNNERS = {
    "kimi-agent":        KimiAgentRunner,         # 云端 + tool_call
    "kimi-fast":         KimiOneShotRunner,       # 云端 one-shot
    "qwen-agent":        QwenAgentRunner,         # 云端 + tool_call
    "qwen-one-shot":     QwenOneShotRunner,       # 云端 one-shot
    "mimo-agent":        MiMoAgentRunner,         # 云端 + tool_call
    "opencode-agent":    OpenCodeAgentRunner,     # 云端 + tool_call
    "codebuddy-agent":   CodeBuddyAgentRunner,    # 云端 + tool_call
    "ollama-one-shot":   OllamaOneShotRunner,     # 本地 one-shot
    "ollama-pipeline":   OllamaPipelineRunner,    # 本地多候选
    "ollama-shell":      OllamaShellRunner,       # 本地 + 纯文本 bash
    "replay-agent":      ReplayAgentRunner,       # 重放历史轨迹
}

§ 6 完整实战示例：跑一次 Lite 评测

从 CLI 命令到结果文件——一次 Lite 子集评测的完整流程。

# 1. 确保 SWE-bench Lite 数据集已下载
ls -la swe_bench_warehouse/raw/swe-bench-lite.jsonl
# -rw-r--r-- 1 user user 50M Sep  2 12:00 swe-bench-lite.jsonl

# 2. 确认 API key 已设
export KIMI_API_KEY="sk-..."
# 或 OPENAI_API_KEY（如果用 openai 兼容的云端 API）

# 3. 确认 Docker 可用
docker ps

python -m answer_evaluator.harness.run_evaluation \
    --dataset_name princeton-nlp/SWE-bench_Lite \
    --predictions_path ./output/predictions.jsonl \
    --max_workers 4 \
    --run_id my-lite-run \
    --timeout 1800 \
    --cache_level env      \
    --clean false         \
    --namespace swebench

# predictions.jsonl 格式（SWE-agent / Kimi / 本仓 orchestrator 都用此格式）
{"instance_id": "astropy__astropy-12907", "model_name_or_path": "kimi-k2-0905", "model_patch": "diff --git a/..."}
{"instance_id": "django__django-10914", "model_name_or_path": "kimi-k2-0905", "model_patch": "diff --git a/..."}
...
（每行一条，含 instance_id + model_name + model_patch）

output/my-lite-run-20260902/
├── report.json                    # 单 instance 报告（每个 instance 一行）
├── run_report.json                # 汇总报告（%Resolved 等主指标）
├── evaluation_results/
│   ├── astropy__astropy-12907.json   # 单 instance 详细结果
│   ├── django__django-10914.json
│   └── ...
└── s4_worker.log                  # agent 跑题日志（如果有）

{
  "instance_id": null,             // 汇总报告 instance_id 为 null
  "run_id": "my-lite-run-20260902",
  "model": "kimi-k2-0905",
  "dataset": "princeton-nlp/SWE-bench_Lite",
  "split": "test",
  "resolved": true,                // 整个 run 是否跑成功
  "resolved_pct": 23.33,          // ★ 主指标：%Resolved
  "outcome": "resolved",           // "resolved" / "partial" / "no"
  "soft_failed_count": 2,
  "killed_by_timeout_count": 1,
  "adapter_attempts": [...],
  "stages": ["S1_build", "S2_prepare", "S4_solve", "S5_patch", "S6_score", "S7_record"],
  "stage_timings": {
    "S1_build": 0.1, "S2_prepare": 17.2,
    "S4_solve": 420.5,             // ★ 420s ≈ 7 分钟
    "S6_score": 162.3             // ★ 162s ≈ 2.7 分钟
  },
  "generated_at": "2026-09-02T19:30:00+08:00"
}

§ 7 资源与硬件需求

引用与配套资料