想象一位米其林评委想给全世界的厨师排名次。最公平的做法,是把 2294 道真实顾客曾经投诉过的菜全部端上灶台,让每位厨师现场重做一遍——牛排煎老了、汤咸了、摆盘塌了,这些都是真实后厨里发生过的难题。可问题是,把 2294 道菜全考一遍,食材要烧掉一个季度的预算,评委要喝掉一缸水漱口。等考试结束,第一名的菜早就凉透了。于是评委团推出了一套“精选品鉴套餐”:从海量考题中挑出 500 道经过资深评委反复验证、覆盖各大菜系且难度适中的代表菜,菜量缩到五分之一,但考出来的排名却和全量考试几乎一致。这套精选套餐,就是 SWE-bench Lite——一个由 500 个真实 GitHub issue 修复任务组成的轻量级 AI 编程能力评测基准。它让任何团队都能在几小时内,给“AI 厨师”(代码 Agent)打出一份客观、可复现的成绩单,既看清它的真本事,也为模型选型和 Agent 调优提供统一标尺。

岗位关联

掌握 SWE-bench Lite,等于拿到一把给 AI 编程能力做体检的标准化尺子:模型选型、Agent 调优、版本追踪都能有据可依,不再凭感觉拍板。

目录
  1. 可视化演示
  2. 基准由来:从“满汉全席”到“精选套餐”
  3. 数据构建:500 道“代表菜”怎么选
  4. 评测设计:后厨考试怎么考
  5. 评分机制:评委的硬标准
  6. 价值优势:省钱、省时、结论还靠谱
  7. 应用前景:从考场到练兵场
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

展示SWE-bench中代码修复验证流程:从问题报告到补丁生成、测试执行到通过/失败判定的完整评测管线。

本节配有交互动效(进入视口后自动加载,约 3KB)。

修复验证流程 问题报告:GitHub Issue描述缺陷 补丁生成:Agent生成代码修复补丁 测试验证:运行测试套件验证修复正确性 Result = Test(patch) → Pass | Fail 修复必须通过全部测试方可判定成功

基准由来:从“满汉全席”到“精选套餐”

想象米其林协会想给全球厨师排座次。最公平的方案是把 2294 道真实顾客投诉过的菜品全部拿出来,让每位厨师在后厨实操一遍。可这样一来,光是准备食材就要花掉一个季度的预算,评委每尝一道菜就要喝一大杯水漱口——等全部考完,第一名的菜早凉了。这就是 SWE-bench 全量基准遇到的尴尬:考题绝对真实,但“考不起”。

SWE-bench 是评测 AI 编程能力的“满汉全席”,由普林斯顿研究团队从 12 个广受欢迎的开源 Python 仓库(如 Django、SymPy)中收集了 2294 个真实 GitHub issue 修复任务。每个任务就是把一位开发者在真实项目中遇到的问题,原封不动地交给 AI 来解,而不是出题人拍拍脑袋编出来的算法题。这正是它能成为行业标杆的原因——考的就是真刀真枪的工程问题。

但全量评测诚然最接近真实,代价却很高:每个任务都要拉起独立的仓库环境、运行测试套件、等待模型生成补丁,跑完一轮往往要耗费数天算力和大量 token。研究者们发现,并非所有任务都能有效区分模型强弱,于是对全量任务做了系统筛选,推出只有 500 个人工验证任务的子集——SWE-bench Lite。它像侍酒师从酒单里挑出的品鉴杯:风味跨度不变,预算却大幅下降。

从 2294 到 500,就像把一桌满汉全席换成了一套品鉴套餐——客人不用扶着墙走出去,却能对厨师的手艺给出同样靠谱的评价。SWE-bench Lite 的意义首先就在这个“少而精”的规模控制上。

R=NLiteNFull=5002294≈0.218\displaystyle R = \frac{N_{\text{Lite}}}{N_{\text{Full}}} = \frac{500}{2294} \approx 0.218
任务数量砍到约 21.8%,意味着评测开销在理想情况下同步降到原来的五分之一左右。
  1. 分子 N_Lite精简集保留的任务数,即 500 道“经过人工验证的代表菜”。
    NLite=500\displaystyle N_{\text{Lite}} = 500
  2. 分母 N_FullSWE-bench 全量任务数,也就是 2294 道“真实后厨考题”。
    NFull=2294\displaystyle N_{\text{Full}} = 2294
  3. 比值 R评测规模保留系数,约 0.218,换算成节省就是约 78.2% 的开销下降。
    R=5002294≈0.218\displaystyle R = \frac{500}{2294} \approx 0.218

数据构建:500 道“代表菜”怎么选

如果只是把 2294 道菜随机切掉四分之三,万一全切掉了川菜,擅长麻辣的厨师就要冤死。真正的品鉴套餐在设计菜单时,一定先请资深评委一道一道试吃,剔除信息不全、口味无法复现、甚至本身就是坏菜的题目,再按菜系(仓库)、难度、菜品种类(缺陷修复 vs 新功能)分层保留。这样才能保证“考什么”不偏科。

对应到数据构建上,SWE-bench Lite 的每个任务都经过人工验证:issue 描述必须足够清晰,仓库环境必须能稳定复现,并且存在至少一份可验证的正确答案(黄金补丁)。这些标准把“连题目都读不懂”的噪音任务淘汰掉了,留下的每一道题都经得起推敲。

筛选不是简单随机抽样,而是分层保留:12 个仓库各自按比例保留约 21.8% 的任务,同时兼顾 issue 类型——既要有“这个函数崩了”的缺陷修复(bug fix),也要有“请增加某某功能”的新需求实现(feature),避免 Agent 只擅长某一类题型。正因如此,在这 500 道题上的模型排名,才能与全量 2294 道题上的排名高度一致。

精选套餐的菜单上,川菜、粤菜、甜品、汤羹都还在,只是每道都限量供应——厨师擅长的每一个方向都有了被检验的机会。这种“分层保留 + 人工验证”的构建方式,是 Lite 版可信度的根基。

NLite,j=⌊R×NFull,j⌋,j=1,2,…,12\displaystyle N_{\text{Lite},j} = \lfloor R \times N_{\text{Full},j} \rfloor, \quad j = 1,2,\dots,12
对第 j 个仓库,保留 ⌊0.218 × 全量任务数⌋ 个任务,保证每个“菜系”都有代表。
  1. 仓库索引 j12 个开源仓库构成 12 个“菜系窗口”,每个窗口独立配比。
    j∈{1,2,…,12}\displaystyle j \in \{1,2,\dots,12\}
  2. 按比例取整对每个仓库,乘上全局保留率 R 后向下取整,得到该仓库最终保留数。
    NLite,j=⌊R×NFull,j⌋\displaystyle N_{\text{Lite},j} = \lfloor R \times N_{\text{Full},j} \rfloor
  3. 求和验证12 个仓库的保留数之和等于总精简规模,确保整体仍是 500 道题。
    ∑j=112NLite,j=500\displaystyle \sum_{j=1}^{12} N_{\text{Lite},j} = 500

评测设计:后厨考试怎么考

品鉴会怎么考厨师?不是让厨师交一份菜谱,而是把一间完整的后厨交给他:食材在冰箱里,灶台点火待用,顾客的投诉条贴在案板上。厨师可以翻菜谱(读代码)、试刀工(搜索)、颠勺试味(跑命令),在规定时间内端出一份全新的菜式(补丁)。整个过程无人旁观、无提示,全靠临场发挥。

SWE-bench Lite 的“后厨”就是这个设计思路的复刻。每个任务给 Agent 一个真实 GitHub 仓库的完整快照、一段 issue 正文(相当于顾客投诉条)。Agent 被允许自由操作:读取文件、搜索符号、运行构建命令,最终输出一个 git diff 格式的补丁。它不能只写一段“解题思路”,必须交付能落地的代码改动。

评测过程中,Agent 通常还要依赖工具调用框架:文件浏览器、grep 检索、终端执行,每一步操作都被记录在案。为保证有限预算内完成考试,任务一般设时间上限(如 30 分钟)或工具调用次数上限。这里的关键纪律是:不给 Agent 任何“题目范围提示”,它必须自己定位 bug、自己设计方案——这和真实开发中接手一个陌生故障几乎没有区别。

正如品鉴师不会在考前告诉厨师“这道菜考的是火候”,评测系统也不会给 Agent 任何人工提示。正是这种“黑箱实操”,才能测出代码 Agent 真实的后厨功力。

fAgent:(Ri, Ii)⟶Δi\displaystyle f_{\text{Agent}}: (R_i,\, I_i) \longrightarrow \Delta_i
Agent 被抽象成一个函数:输入第 i 个任务的仓库快照 R_i 和 issue 描述 I_i,输出补丁 Δ_i。
  1. 输入仓库快照R_i 是第 i 个任务锁定的代码仓库,固定在 issue 提出的那个时间点。
    Ri=snapshot(repoi,tissuei)\displaystyle R_i = \text{snapshot}(\text{repo}_i, t_{\text{issue}_i})
  2. 输入问题描述I_i 是 issue 正文,包含复现步骤、报错信息与期望行为。
    Ii=issue_bodyi\displaystyle I_i = \text{issue\_body}_i
  3. Agent 行为映射f_Agent 代表“模型 + 工具调用”的整体策略,把仓库与问题映射为补丁。
    Δi=git diff(patchi)\displaystyle \Delta_i = \text{git diff}(\text{patch}_i)

评分机制:评委的硬标准

怎么判断厨师端出来的菜及格?米其林评委的做法不是“我觉得还行”,而是让一群带着“电子舌”的刁钻食客(测试用例)来投票:修复前尝一口必骂娘的菜(FAIL_TO_PASS),必须变得可口;原本就满意的菜(PASS_TO_PASS),不能因为这次改动变难吃。两道坎都过了,这道菜才及格。

对应到评分上,每个 SWE-bench Lite 任务都预置两类测试:FAIL_TO_PASS(修复前必然失败、修复后必须通过的测试)和 PASS_TO_PASS(修复前就通过、修复后也必须继续保持通过的测试)。系统把 Agent 生成的补丁应用到干净仓库后,自动运行这两类测试,全程不需要人工阅卷。

评分是“全或无”的严格模式:当且仅当所有 FAIL_TO_PASS 测试全部通过、且所有 PASS_TO_PASS 测试全部保持通过,该任务才计 1 分,否则计 0 分。最终正确率等于得分任务数除以 500。这种一刀切的设计杜绝了“半吊子修复”——Agent 不能靠修好三分之二的问题拿部分分数,必须交付真正可用的补丁,这和真实研发中“一个测试挂了 PR 就不能合入”的逻辑完全一致。

就像厨师的菜必须让所有挑剔食客都点头才算过关,SWE-bench Lite 用“电子舌”投票替代了人工打分,既保证了客观性,也让每一分都有明确的测试依据。

Scorei={1,if ∀t∈F2P:pass(t) and ∀t∈P2P:pass(t)0,otherwise\displaystyle \text{Score}_i = \begin{cases} 1, & \text{if } \forall t \in \text{F2P}: \text{pass}(t) \text{ and } \forall t \in \text{P2P}: \text{pass}(t) \\ 0, & \text{otherwise} \end{cases}
全通过才得 1 分,任何一项测试失败都是 0 分——这是“达标制”,不是“计分制”。
  1. FAIL_TO_PASS 集合F2P 是“修复前红、修复后必须绿”的测试集合,代表 bug 真的被修好。
    F2Pi={t:passbefore(t)=0, passafter(t)=1}\displaystyle \text{F2P}_i = \{t : \text{pass}_{\text{before}}(t) = 0,\ \text{pass}_{\text{after}}(t) = 1\}
  2. PASS_TO_PASS 集合P2P 是“修复前后都必须绿”的回归保护测试,代表没有引入新故障。
    P2Pi={t:passbefore(t)=1, passafter(t)=1}\displaystyle \text{P2P}_i = \{t : \text{pass}_{\text{before}}(t) = 1,\ \text{pass}_{\text{after}}(t) = 1\}
  3. 判定与汇总两类测试全部通过才计 1 分,最终正确率为 500 个任务得分的平均。
    Acc=1500∑i=1500Scorei\displaystyle \text{Acc} = \frac{1}{500} \sum_{i=1}^{500} \text{Score}_i

价值优势:省钱、省时、结论还靠谱

品鉴套餐之所以流行,不只是因为它便宜——还因为评审团做过对照实验:让同一批厨师分别走完 2294 道全量考试和 500 道精选考试,两份排名几乎一模一样。省下的钱是甜的,但结果一致才是真正的核心竞争力。

SWE-bench Lite 的价值同理。第一是成本:全量评测动辄耗费数天算力与大量 token,而 Lite 版把规模压缩到约 21.8%,多数团队半天就能跑完一轮;第二是稳定:实验表明 Lite 上的模型排序与全量版高度相关,减少任务数量没有牺牲排名的可信度。

同时,500 个任务全部经过人工验证,意味着每个任务都有清晰的问题陈述与可复现的环境,评测流程可以做成自动化流水线。对中小团队或开源社区来说,这意味着不需要昂贵的集群,就能获得一份有说服力的能力画像。它真正拉低了“给 AI 编程能力打分”的门槛——这也是它迅速成为社区默认评测集之一的原因。

菜单薄了、账单瘦了,评委手里的排名表还是那张排名表——这正是 SWE-bench Lite 被众多团队当作“默认考场”的原因:花五分之一的钱,得到同等可信的结论。

Saving=1−CLiteCFull≈1−5002294≈78.2%\displaystyle \text{Saving} = 1 - \frac{C_{\text{Lite}}}{C_{\text{Full}}} \approx 1 - \frac{500}{2294} \approx 78.2\%
若开销近似与任务数成正比,Lite 版理论上能节省约 78% 的评测成本。
  1. 全量成本归一以全量评测成本 C_Full 为基准,其值与 2294 成正比。
    CFull∝2294\displaystyle C_{\text{Full}} \propto 2294
  2. Lite 成本占比C_Lite 近似与 500 成正比,约为全量的 0.218 倍。
    CLite=0.218×CFull\displaystyle C_{\text{Lite}} = 0.218 \times C_{\text{Full}}
  3. 节省比例用 1 减去占比,得到约 78.2% 的成本节省。
    Saving=1−0.218≈78.2%\displaystyle \text{Saving} = 1 - 0.218 \approx 78.2\%

应用前景:从考场到练兵场

品鉴会不只是发一张“米其林星级”证书,聪明的厨师还会用评委的点评调整自己的菜谱:上次鹅肝太腻,这次就少放黄油;上次摆盘太慢,这次就提前备好酱汁。SWE-bench Lite 正是这样一个可以反复使用的“练兵场”——考完不是终点,而是改进的起点。

对 AI 从业者来说,SWE-bench Lite 的用法主要有三类。第一是模型选型:在引入新的代码大模型或开源替代品时,先在 500 个任务上跑一轮,得到可对比的准确率;第二是 Agent 开发调优:调整提示词、工具调用策略、检索增强模块后,用同一套题反复评测,验证改动是提升还是回退;第三是能力追踪:随着模型版本迭代,跟踪它在基准上的持续进步,形成团队内部的能力基线。

评测生态还围绕 Lite 衍生出排行榜、复现框架与可视化工具,进一步降低了新团队的接入成本。对一个每天要面对“该不该升级模型”“该不该换 Agent 框架”的团队来说,SWE-bench Lite 提供了一根相对客观、可复测的标尺,让决策从“感觉”变成“数据”。

定期回考场、反复对照评分,厨师才能在下一季拿到更高的星级——而 SWE-bench Lite,就是 AI 编程团队那间便宜又好用的“标准厨房”。

Δ=Accafter−Accbefore\displaystyle \Delta = \text{Acc}_{\text{after}} - \text{Acc}_{\text{before}}
同一套题先测旧版本、再测新版本,差值 Δ 就是本次改动的净收益。
  1. 前测基线改动前跑一遍 500 题,得到 Acc_before。
    Accbefore=count of solved500\displaystyle \text{Acc}_{\text{before}} = \frac{\text{count of solved}}{500}
  2. 后测结果改动后重跑同一套题,得到 Acc_after。
    Accafter=count of solved500\displaystyle \text{Acc}_{\text{after}} = \frac{\text{count of solved}}{500}
  3. 做差比较Δ 为正说明改动有效,为负则应及时回滚调整。
    Δ=Accafter−Accbefore\displaystyle \Delta = \text{Acc}_{\text{after}} - \text{Acc}_{\text{before}}

AI 应用场景

场景1:代码大模型选型前的“快速比武”

阶段:模型评估与选型

解决的问题:选型时要对比多个候选模型,全量评测周期长、算力成本高;靠人工编写测试题又脱离真实工程场景。SWE-bench Lite 用 500 个真实 GitHub issue 在几小时内给出可对比的修复率,把“谁更强”从争论变成数据。

具体案例:某 AI 研发工具团队要在 GPT 系、Claude 系与一个开源模型之间定选型。三支小分队各领一套 Lite 评测环境,模型各自读仓库、改代码、提补丁,半天后得到 39.2%、44.8%、15.3% 的准确率,再结合失败样例逐类分析,最终敲定性价比最优的方案。

场景2:Agent 工具链调优的“回归测试”

阶段:Agent 开发与迭代

解决的问题:代码 Agent 调整检索策略、提示词模板或工具调用顺序时,改动效果难以量化。把 Lite 当成回归测试集,跑出“改动前 vs 改动后”的分数差,就能精准定位哪些改动真正有效。

具体案例:某个代码补全 Agent 初版在 500 题上只修好 34 题。工程师分析失败样本后发现,大量失败源于找不到目标函数,于是加入符号索引与路径优先召回。改完重跑一轮,通过数升到 58 题,Δ = +4.8%,据此确认了改动的价值并固化到正式版本。

场景3:季度能力追踪的“成绩单”

阶段:效果追踪与汇报

解决的问题:团队向上汇报模型能力进展时,缺少一个可复现、可历史对比的量化指标。SWE-bench Lite 提供标准化的 500 题考场,每季度重跑一次即可得到同口径的成长曲线。

具体案例:某大模型部门每季度跑一轮 Lite,把通过率画成折线:Q1 28% → Q2 35% → Q3 41%。配合典型失败样例的归因分析,向管理层清晰展示了迭代投入的回报,也为下季度重点攻关方向提供了依据。

Python 演示

python58 行
"""MiniSwebenchLite: a simplified SWE-bench Lite evaluation simulator."""import random  class Task:    """One task from the benchmark: F2P tests plus P2P tests."""     def __init__(self, task_id, repo, n_f2p, n_p2p):        self.task_id = task_id        self.repo = repo        self.f2p = [False] * n_f2p   # FAIL_TO_PASS: fail before fix        self.p2p = [True] * n_p2p    # PASS_TO_PASS: keep passing  class Agent:    """A fake coding agent with a per-test fix probability."""     def __init__(self, name, fix_rate):        self.name = name        self.fix_rate = fix_rate     def solve(self, task, rng):        # Each F2P test is fixed with probability fix_rate        for i in range(len(task.f2p)):            task.f2p[i] = rng.random() < self.fix_rate        # Each P2P test has a 5% chance to be broken by the patch        for i in range(len(task.p2p)):            task.p2p[i] = rng.random() >= 0.05  def build_bench(size=500, n_repos=12):    """Build a dummy benchmark: tasks spread across 12 repos by rotation."""    tasks = []    for i in range(size):        repo = "repo_%d" % (i % n_repos)        n_f2p = random.Random(i).randint(1, 5)        n_p2p = random.Random(i + 1).randint(2, 6)        tasks.append(Task("task_%d" % i, repo, n_f2p, n_p2p))    return tasks  def evaluate(agent, tasks, seed=42):    """Run the all-or-nothing scoring rule on every task."""    rng = random.Random(seed)    solved = 0    for task in tasks:        agent.solve(task, rng)        # Score 1 only if all F2P pass and all P2P stay green        if all(task.f2p) and all(task.p2p):            solved += 1    return solved / len(tasks)  if __name__ == "__main__":    bench = build_bench()    for agent in (Agent("Agent-A", 0.35), Agent("Agent-B", 0.45)):        acc = evaluate(agent, bench)        print("%s accuracy: %.2f%%" % (agent.name, acc * 100))
目的:用 60 行代码模拟 SWE-bench Lite 的评测流程——所有任务按 12 个仓库分层构建,Agent 以概率修复 FAIL_TO_PASS 测试,评分采用“全或无”规则,最终输出每个 Agent 的准确率。
  1. self.f2p = [False] * n_f2p用列表存放测试状态,F2P 初始全是“失败红”,等待 Agent 去修复。
  2. self.p2p = [True] * n_p2pP2P 初始都是“通过绿”,用来检验 Agent 是否引入新故障。
  3. task.f2p[i] = rng.random() < self.fix_rate模拟 Agent 以固定概率修好每条失败测试,固定概率对应模型的真实能力。
  4. task.p2p[i] = rng.random() >= 0.05模拟补丁有 5% 概率误伤原本通过的测试,体现“改坏东西”的回归风险。
  5. repo = "repo_%d" % (i % n_repos)任务轮转分配到 12 个仓库,模拟真实基准的“分层保留”。
  6. if all(task.f2p) and all(task.p2p)全或无评判:两类测试全部通过才把 solved 加一。
  7. return solved / len(tasks)用解出任务数除以总任务数,得到该 Agent 在 500 题上的准确率。

常见误区

误区“500 道题就是从 2294 道里随机抽的吧?考什么全看运气,分数说明不了问题。”

正解筛选绝不是抽签。每条任务都要经过人工验证——issue 描述必须清晰、环境必须可复现、必须存在可验证的黄金补丁;同时按仓库和 issue 类型(缺陷修复 vs 功能实现)分层配额保留。正因如此,Lite 上的模型排名才能与全量基准高度一致。

为何常见:人们习惯性把“子集”等同于“随机抽样”,忽略了构建基准时的人工质检与分层设计。

误区“Agent 在 SWE-bench Lite 上考到 50%,直接派去公司改生产代码肯定没问题。”

正解benchmark 是“可控考场”:任务有明确 issue、仓库可复现、评分只看测试是否通过。真实生产环境充满历史包袱、模糊需求和跨系统依赖,考场的分数不能直接外推。Lite 分数高只说明基础修复能力强,还需要在真实工程中逐步验证。

为何常见:成绩单最容易让人过度自信——就像驾校满分不等于能应对早高峰路况。

误区“修好了 8 个测试中的 6 个,至少该给 0.75 分,直接 0 分太不公平。”

正解“全或无”是有意设计,模拟的是真实研发的合入逻辑:一个测试挂了,PR 就不能合入。如果给部分分,Agent 就会学会“修大部分、留个小尾巴”,产出的补丁无法真正落地。严格评分反而倒逼 Agent 交付完整方案。

为何常见:人的直觉倾向“按比例奖励”,但没意识到工程验收本身就是“一票否决”。

误区“才 500 道题,样本这么小,换个随机种子分数就会大起大落,排名不可信。”

正解500 个任务是经过人工验证的真实工程问题,彼此独立且来源多样,样本代表性远大于同数量级的“编造题”。更重要的是,Lite 与全量 2294 题的模型排名经过验证高度一致——如果结论靠运气,这种一致性根本不可能出现。

为何常见:人数直觉认为“全量才准”,忽略了抽样质量比样本数量更决定结论可靠性。

面试题

Q1. SWE-bench Lite 的任务规模是多少?

单选题 · easy

  • A.2294 个人工验证任务
  • B.500 个人工验证任务← 正确答案
  • C.1000 个测试用例任务
  • D.12 个仓库的全部任务

答案:B。SWE-bench Lite 是从全量 SWE-bench 的 2294 个任务中筛出的 500 个人工验证任务。选项 A 是全量基准规模,C 混淆了“任务”与“测试用例”,D 是仓库数量而非任务数。

Q2. SWE-bench 全量基准的数据来源是什么?

单选题 · easy

  • A.在线编程题库的静态题目
  • B.面试官虚构的算法题目
  • C.真实开源仓库的 GitHub issue← 正确答案
  • D.论文里摘录的代码片段

答案:C。SWE-bench 从 12 个热门 Python 开源仓库收集真实 GitHub issue 修复任务,考的是真实工程问题。A、B、D 都与“真实项目实战”的定位不符。

Q3. FAIL_TO_PASS 测试的含义是什么?

单选题 · mid

  • A.修复前失败修复后必须通过← 正确答案
  • B.修复前后都应该保持失败
  • C.修复前后都应该保持通过
  • D.仅在修复成功之后才运行

答案:A。FAIL_TO_PASS 字面即“修复前失败、修复后必须通过”,它验证 bug 真的被修好。C 描述的是 PASS_TO_PASS 的含义,B 与评测目标相反,D 不存在这种孤立运行的测试。

Q4. 一个 SWE-bench Lite 任务得 1 分的条件是什么?

单选题 · mid

  • A.至少一半 FAIL_TO_PASS 通过
  • B.F2P 全过且 P2P 全部保持← 正确答案
  • C.F2P 全过即可忽略 P2P
  • D.Agent 能成功完成编译运行

答案:B。评分是“全或无”:所有 FAIL_TO_PASS 测试通过,且所有 PASS_TO_PASS 测试保持通过,才计 1 分。A 允许部分分不符合设计,C 忽略回归保护,D 编译成功不等于行为正确。

Q5. 为什么 Lite 版不采用随机抽样构建?

单选题 · mid

  • A.随机抽样的评测成本更高
  • B.需人工验证并分层保留题目← 正确答案
  • C.随机抽样无法复现评测结果
  • D.随机抽样违反开源许可证

答案:B。Lite 要求每条任务题面清晰、环境可复现,并按仓库与 issue 类型分层保留,确保覆盖面。随机抽样无法保证这些性质。A 说反了(抽样更便宜),C、D 与事实不符。

Q6. SWE-bench Lite 的主要价值包括哪些?

多选题 · mid

  • A.评测成本大幅下降← 正确答案
  • B.排名结果与全量高度一致← 正确答案
  • C.完全取代真实代码评审
  • D.降低团队评测使用门槛← 正确答案

答案:ABD。Lite 把规模缩到约 21.8%,成本大幅下降;实验验证其排序与全量高度一致;500 个人工验证任务让小团队也能轻松跑评测。但它测的是可控考场,无法完全取代真实代码评审,C 过度外推。

Q7. 全或无评分的主要设计动机是什么?

单选题 · hard

  • A.简化评分计算并提升运行速度
  • B.防止半吊子修复获得部分奖励← 正确答案
  • C.刻意压低所有模型的最终分数
  • D.避免使用测试用例进行自动判断

答案:B。给部分分会鼓励 Agent 只修好部分测试就交差,而真实研发中“一个测试挂了 PR 就不能合入”。全或无评分确保交付的补丁真正可用。A、C、D 都不是设计初衷。

Q8. 关于 SWE-bench Lite 与全量版本,说法正确的有哪些?

多选题 · hard

  • A.Lite 是全量的人工验证子集← 正确答案
  • B.两者的模型排名高度相关← 正确答案
  • C.Lite 任务约为全量的两成← 正确答案
  • D.Lite 包含更多额外训练数据

答案:ABC。Lite 是研究者对全量任务人工验证后筛选出的子集;验证表明两者排名高度一致;500 / 2294 ≈ 21.8%,约两成。Lite 是评测集而非训练集,不增加训练数据,D 错。

Q9. 评测中 Agent 端出的“菜”具体指什么?

单选题 · mid

  • A.一段自然语言解题思路
  • B.一个 git diff 格式的补丁← 正确答案
  • C.一份完整的项目文档
  • D.一段模型训练的日志

答案:B。Agent 的交付物是可落地应用的 git diff 补丁,评测系统把它应用到干净仓库后再跑测试。自然语言思路、项目文档、训练日志都不是可执行的代码改动。

Q10. 哪些场景适合使用 SWE-bench Lite?

多选题 · extreme

  • A.对比多个代码模型进行选型← 正确答案
  • B.调优 Agent 工具调用策略← 正确答案
  • C.追踪模型版本迭代的效果← 正确答案
  • D.替代线上流量的 A/B 实验

答案:ABC。模型选型、Agent 调优、版本追踪都是 Lite 的典型用途——它提供标准化、可复测的考场。D 线上 A/B 涉及真实用户流量和业务指标,benchmark 分数无法替代线上实验的结论。