跳到主内容
快讯直播
AI智模界
教程

复现 1200 任务 RL:从构造到 Terminal-Bench 评测

这篇能做出什么

按这篇走完,你会得到一条能重复跑的流水线:1200 个带自动验证的终端任务 → 沙箱批量 rollout → 规则奖励驱动的强化学习训练 → Terminal-Bench 上可比较的通过率数字。

具体产出是四个可交付物:

1. tasks/:1200 个任务目录,每个含 Dockerfile、任务描述、验证脚本、参考解法,全部能被程序调用、能自动判对错。

2. rollout/:一套隔离沙箱执行器,能并行跑几百条终端轨迹,单条超时可控、容器用完即销毁。

3. train/:一份 RL 训练配置(GRPO + LoRA 起步),输入任务池、输出模型权重/adapter。

4. eval/:把训练前后模型接到 Terminal-Bench 上跑同一套评测,得到 pass@1 对比。

关于 5.6% → 12% 这个跨度:这是参照目标,来自别人的复现报告数值,不是承诺。你实际拿到的数字会随基座模型、任务质量、算力预算波动。这篇的重点是把流水线跑通、做出干净的 baseline,让"涨了多少"这件事可被你自己验证,而不是对齐某个具体百分比。

为什么这件事值得做:终端任务天然适合 RL——成功与否是客观的(命令跑通没跑通、文件改对没改对),不需要训练奖励模型,也不会像开放式对话那样奖励信号模糊。代价是工程量大:沙箱、任务、验证、训练框架要串起来。

前置条件清单

硬件

  • 27B 级别模型做全参数 GRPO 需要多机多卡:bf16 权重约 54GB,加上梯度、Adam 优化器状态、以及 rollout 侧常驻的推理引擎,单机 8 卡 80GB 很难同时装下训练和推理。务实路线是 LoRA 微调 + 独立 rollout 引擎(vLLM/SGLang),单机 8×80GB 可以跑起来。
  • 如果只有 1–2 张卡,把基座换成 4B–8B 级别先跑通流程,任务和代码完全复用,只是最终数字不能和 27B 对比。

存储与内存

  • 每个任务一个镜像,1200 个镜像哪怕每个 500MB 也是数百 GB,再加上 rollout 日志、轨迹、checkpoint,建议预留 2TB 以上。
  • 宿主机内存要能撑住并发沙箱,按"每容器 2GB + 并发数"估算。

软件栈

  • Linux 宿主机(内核支持容器)、Docker 或兼容的容器运行时
  • Python 3.10+、PyTorch、CUDA(版本按你的驱动和官方文档当前版本对齐)
  • 一个支持多轮 rollout 的 RL 框架(verl / TRL / SkyRL 一类,选一个你团队最熟的)
  • Terminal-Bench 官方评测工具(其运行器、数据集、agent 接口以官方文档当前版本为准)

其他

  • 一个能力尚可的基座模型(Qwen 系列同量级模型是常见选择,具体用哪个以官方文档当前版本为准)
  • 至少 2–3 天不间断的机器时间做一次完整训练
  • 一份"任务从哪来"的素材来源:内部仓库的 issue/PR、运维手册、常见故障工单

第 0 步:先把整个回路画清楚,再动手

```

┌─────────────┐ 采样 8 条/任务 ┌──────────────┐

│ 任务池 1200 │ ─────────────────► │ 沙箱 rollout │

└─────────────┘ └──────┬───────┘

▲ │ 执行验证脚本

│ 难度过滤/去重 ▼

┌──────┴──────┐ 规则奖励 0/1 ┌──────────────┐

│ 过滤后任务池 │ ◄───────────────── │ 奖励计算 │

└─────────────┘ └──────┬───────┘

│ 分组优势

▼

┌──────────────┐

│ GRPO 策略更新 │

└──────┬───────┘

▼

┌──────────────┐

│ Terminal-Bench│

└──────────────┘

```

三个关键判断先定下来,后面所有代码都围绕它们写:

  • 奖励用"命令退出码 + 验证脚本",不用 RM 模型。这样奖励不可被语言模型"说服",只能靠真把活儿干成。
  • rollout 是多轮的:模型输出一条命令 → 沙箱执行 → 把 stdout/stderr 拼回上下文 → 模型输出下一条。不是单轮问答。
  • 训练集和评测集必须物理隔离:Terminal-Bench 的任务一个都不能进训练池,否则数字没意义。

第 1 步:搭一个能安心跑任意命令的沙箱

这是整套东西里最容易出安全事故和资源事故的一环。原则是:默认断网、强制非 root、限内存限进程数、强制超时、用完即毁。

先看一个任务镜像的骨架(tasks/<task_id>/Dockerfile):

```dockerfile

基础镜像请以官方镜像仓库当前可用的 LTS tag 为准

FROM ubuntu:22.04

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y \

curl git python3 python3-pip vim procps iproute2 \

&& rm -rf /var/lib/apt/lists/*

任务所需依赖(示例:一个会"坏掉"的 Web 服务环境)

RUN pip3 install --no-cache-dir pytest requests

WORKDIR /app

COPY app/ /app/

注意:参考解法 solution.sh 绝不能 COPY 进镜像

CMD ["sleep", "infinity"]

```

启动沙箱时把它约束死:

```bash

docker run --rm -d \

--name "task-$(uuidgen)" \

--network none \

--memory 2g --memory-swap 2g \

--cpus 2 \

--pids-limit 256 \

--read-only=false \

--cap-drop ALL \

--security-opt no-new-privileges \

-v "$PWD/tests:/tests:ro" \

task-image:latest

```

几个点必须解释清楚:

  • --network none:断网是防作弊的第一道墙,也防止模型在里面下载东西导致行为不可复现。少数确实需要网络的任务单独打标签、单独跑。
  • -v .../tests:/tests:ro:验证脚本以只读方式挂载,不进镜像,模型改不了它。
  • --pids-limit:防止 fork 炸弹 把宿主机打死。
  • --rm:容器退出即删,避免跑一天下来磁盘被写满。

Python 侧封装一层执行器:

```python

import subprocess, uuid, time, shlex

def run_cmd(container: str, cmd: str, timeout: int = 60) -> dict:

"""在已启动的沙箱里执行一条命令,返回截断后的观测。"""

try:

p = subprocess.run(

["docker", "exec", container, "bash", "-lc", cmd],

capture_output=True, text=True, timeout=timeout,

)

out = (p.stdout + p.stderr)[:8000] # 观测必须截断,否则上下文爆掉

return {"output": out, "returncode": p.returncode, "timeout": False}

except subprocess.TimeoutExpired:

return {"output": f"[timeout after {timeout}s]", "returncode": 124, "timeout": True}

```

8000 这个截断长度不是随便定的:终端任务里 cat 一个大文件、pip install 打几百行日志都很常见,不截断的话两三轮就把上下文塞满了。截断时保留头尾各一半比只保留开头有用,因为报错通常在最后几行。

第 2 步:把任务定义成统一的 schema

统一结构是后面所有工具(过滤、采样、训练、评测)能复用同一个 loader 的前提。目录长这样:

```

tasks/fix-nginx-upstream-0007/

├── task.yaml

├── Dockerfile

├── app/ # 初始(有问题的)环境

├── tests/test_fix.py # 验证脚本

└── solution.sh # 参考解法,只在镜像外保存

```

task.yaml:

```yaml

id: fix-nginx-upstream-0007

instruction: |

容器内 /app/nginx.conf 里的 upstream 配置指向了一个不存在的后端端口,

导致 nginx -t 报错、服务无法启动。

请修复配置,使 nginx -t 通过,并且 8080 端口能正常代理到本地 3000 端口。

你可以使用 shell 命令查看和修改文件。

difficulty: medium # easy / medium / hard

tags: [ops, nginx, config-fix]

timeout_sec: 600 # 整条轨迹的总时限

max_turns: 30 # 最多允许的交互轮数

test_command: pytest -q /tests/test_fix.py

```

验证脚本要写成"只认结果,不认过程"——允许模型用任何方式达成目标:

```python

tests/test_fix.py

import subprocess, requests

def test_nginx_config_valid():

r = subprocess.run(["nginx", "-t"], capture_output=True)

assert r.returncode == 0, r.stderr.decode()

def test_proxy_works():

subprocess.run(["nginx"], check=True)

r = requests.get("http://127.0.0.1:8080/health", timeout=5)

assert r.status_code == 200

```

这样写的好处是:模型可以改配置、可以换端口转发方式、可以写启动脚本,只要最终行为对就给分。验证"行为"而不是"文件内容",是避免奖励僵化的关键。

第 3 步:构造 1200 个任务——配比比数量重要

1200 这个量级,靠手工写不现实;全靠模板生成又会高度同质化让 RL 学不到东西。实践中的做法是四路来源混合,并控制配比:

来源做法建议数量特点
真实缺陷反推从内部仓库的历史 commit 里取"修复前"状态做环境,用修复后的测试做验证约 450最真实,难度自然分布
运维/配置类按手册构造:坏掉的 systemd unit、错的权限、写坏的 crontab、挂了的环境变量约 300可模板化,覆盖广
数据管道类给一个有 bug 的脚本 + 输入数据,要求产出符合预期格式的结果约 300验证容易(比对输出文件)
长程多步需要 10 步以上才能完成:装依赖 → 改代码 → 跑测试 → 修复约 150训练多轮能力,最贵

第一类任务的提取脚本骨架:

```python

import subprocess, pathlib, yaml

def extract_from_commit(repo, commit, out_root, task_id):

"""把一次真实修复反推成一个任务:commit 之前 = 环境,commit 的测试 = 验证。"""

dst = pathlib.Path(out_root) / task_id

(dst / "tests").mkdir(parents=True, exist_ok=True)

1. 导出修复前的代码树

subprocess.run(

f"git -C {repo} archive {commit}^ | tar -x -C {dst}/app",

shell=True, check=True,

)

2. 导出修复中新增/修改的测试文件

changed = subprocess.run(

["git", "-C", repo, "diff", "--name-only", f"{commit}^", commit],

capture_output=True, text=True, check=True,

).stdout.split()

tests = [f for f in changed if "test" in f.lower()]

for t in tests:

content = subprocess.run(

["git", "-C", repo, "show", f"{commit}:{t}"],

capture_output=True, text=True, check=True,

).stdout

(dst / "tests" / pathlib.Path(t).name).write_text(content)

3. 参考解法 = 这次 commit 的 diff

diff = subprocess.run(

["git", "-C", repo, "diff", f"{commit}^", commit],

capture_output=True, text=True, check=True,

).stdout

(dst / "solution.sh").write_text(f"cd /app && git apply <<'EOF'\n{diff}\nEOF\n")

4. 任务描述需要人或强模型补写:见下一段

return dst

```

任务描述(instruction)不能省事。它是模型唯一的输入,写不好任务就废了。三条硬要求:

  • 说清在哪里(文件路径、服务名)、坏了什么现象(报错文本、退出码)、验收标准是什么(哪条命令要跑通、哪个端口要能访问)。
  • 不说怎么修。写了"把 upstream 的端口从 8081 改成 3000",任务就退化成抄写。
  • 长度控制在几段以内。太长的描述会让模型把预算花在读题上。

用强模型批量起草描述、再人工抽检 10%,是数量和质量之间比较实际的平衡点。

第 4 步:把奖励写死、把作弊路堵上

奖励函数尽量简单、可解释:

```python

import subprocess

def compute_reward(task, container, traj) -> float:

1. 超时 / 轮次耗尽 / 模型主动放弃 → 0

if traj.timed_out or traj.turns == 0:

return 0.0

2. 反作弊检查

if traj_tampered(container, task):

return 0.0

3. 跑验证脚本

r = subprocess.run(

["docker", "exec", container, "bash", "-lc", task["test_command"]],

capture_output=True, text=True, timeout=300,

)

return 1.0 if r.returncode == 0 else 0.0

def traj_tampered(container, task) -> bool:

checks = [

"test -w /tests", # 验证目录必须只读

"pgrep -f 'pytest' > /dev/null", # 不该有残留的假进程

"test -f /app/solution.sh", # 参考解法不能出现在镜像里

]

for c in checks:

r = subprocess.run(["docker", "exec", container, "bash", "-lc", c])

if r.returncode == 0:

return True

return False

```

为什么先给 0/1 而不是部分分:部分分(比如"pytest 过了 3/5 个用例给 0.6")看起来信号更密,实际上非常容易被钻——模型会去猜哪几个用例简单、或者写个空实现骗过 import 检查。0/1 奖励在 GRPO 里靠组内相对优势也能提供足够梯度(同一任务采样 8 条,只要有对有错,信号就有了)。等流程稳定、通过率卡住了,再考虑加细粒度奖励。

必须堵的作弊路径(这几条都是真实踩过的):

  • 网络:--network none 已经堵了大半,但要检查模型有没有自己起本地代理。
  • 改测试:/tests 只读挂载,且验证前重新 docker cp 一份覆盖。
  • 读答案:solution.sh 绝不进镜像,构建上下文里也要排除。
  • 伪造输出:验证脚本直接调用被测程序(nginx -t、requests.get),不读模型打印的文本。
  • 杀测试进程:在容器内以独立进程跑验证,并检查验证前后 PID 空间。

第 5 步:难度过滤——把"太简单"和"不可能"的任务剔掉

直接用 1200 个任务训练是浪费算力。先用基座模型跑一遍,只留中等难度的:

```python

import json

def keep_medium(records, low=0.1, high=0.9):

"""records: [{"task_id":..., "pass_rate": 0~1}, ...]

全错的学不到东西,全对的没有梯度。"""

kept = [r for r in records if low <= r["pass_rate"] <= high]

dropped_easy = [r for r in records if r["pass_rate"] > high]

dropped_hard = [r for r in records if r["pass_rate"] < low]

print(f"保留 {len(kept)} / 剔除简单 {len(dropped_easy)} / 剔除过难 {len(dropped_hard)}")

return kept

```

每个任务采样 8 条估计 pass_rate。经验上,一个健康的 1200 任务池经过滤后大概剩下 400–700 个——这是正常现象,不是数据浪费。被剔除的"过难"任务留着,等模型变强之后回炉再训,这是持续提升的主要来源。

再去一次重:任务描述做 embedding,相似度高于阈值的只留一条。模板生成的任务最容易在这里暴露同质化问题——如果 300 个"修 crontab"任务聚成一个大簇,说明模板变量太少。

第 6 步:接上 RL 训练

多轮终端任务的标准做法是 GRPO(组内相对优势,不需要 critic 模型,省一大块显存)。一个配置骨架(字段名随框架版本变化,以官方文档当前版本为准):

```yaml

data:

train_files: data/tasks_filtered.parquet

prompt_key: instruction

max_prompt_length: 4096

max_response_length: 8192

max_turns: 30

actor_rollout_ref:

model:

path: /models/base-model # 本地路径,按实际修改

rollout:

name: vllm

n: 8 # 每任务采样条数 = GRPO 组大小

temperature: 1.0

top_p: 0.95

gpu_memory_utilization: 0.55

tensor_model_parallel_size: 2

actor:

lora_rank: 32

lora_alpha: 64

ppo_mini_batch_size: 32

learning_rate: 1e-6

kl_loss_coef: 0.001

grad_clip: 1.0

trainer:

total_epochs: 2

save_freq: 50

project_name: terminal-rl

```

几个参数的作用,方便你调:

  • n: 8:组大小。太小(2/4)优势估计噪声大,太大显存和 rollout 时间吃不消。8 是常见起点。
  • temperature: 1.0:要保证组内有对有错,温度太低会让 8 条轨迹几乎一样,优势全为 0,这一批就白跑了。
  • learning_rate: 1e-6 + LoRA:终端任务的奖励是稀疏的 0/1,学习率偏大会让策略在"偶尔成功一次"之后迅速过拟合到那条轨迹。先小后大。
  • kl_loss_coef:KL 惩罚别设太大,否则模型不敢偏离基座,学不出新行为;也别设 0,否则会退化成一堆无意义的长命令。

多轮轨迹的 loss mask 是最容易写错的地方:模型生成的 token 算 loss,工具返回的 observation(命令输出)不算。伪代码:

```python

def build_trajectory(messages):

"""messages 里 role 为 assistant 的部分算 loss,tool/observation 部分 mask 掉。"""

input_ids, labels = [], []

for m in messages:

ids = tokenize(m["content"])

input_ids += ids

labels += ids if m["role"] == "assistant" else [-100] * len(ids)

return input_ids, labels

```

如果这里 mask 错了,模型会学着去"预测命令输出",训练几分钟就能看到 reward 不升反降、输出越来越像日志。

第 7 步:训练时盯这五个指标

不用盯一堆,这五个足够判断训练是否健康:

指标健康表现异常信号与对策
平均 reward缓慢上升,有波动一直 0 → 检查奖励函数和沙箱是否真的跑起来了
组内奖励方差大于 0恒为 0 → 温度太低或任务太简单,换任务或调温度
平均轮次先升后稳一直 1–2 轮 → 模型在瞎试一条命令就放弃,检查超时和观测截断
平均回复长度平稳暴涨 → 奖励黑客(在输出里灌垃圾),立刻停下做错误分析
无效 rollout 比例< 5%高 → 沙箱镜像坏了或超时太短

每次保存 checkpoint 都跑一次小评测(比如 50 个留出任务),不要等训完再看。终端任务的 RL 很容易在某个点突然崩掉——reward 看着还行,实际模型学会了"只输出 ls 然后退出"这种保底行为。

第 8 步:上 Terminal-Bench 做正式评测

Terminal-Bench 的评测方式和你训练时的沙箱不完全一样,必须用它自己的运行器,否则数字没有可比性。整体流程是:把你的模型包成一个 agent(对外暴露"给定终端历史和当前屏幕,输出下一条命令"的接口),再让运行器把你的 agent 接到它的任务集上。

```bash

先跑 oracle(参考解法)确认环境本身没问题

命令名与参数随版本变化,以下为形态示意,以官方文档当前版本为准

<bench-cli> run --dataset terminal-bench --agent oracle --output-dir runs/oracle

跑基座模型的 baseline

<bench-cli> run --dataset terminal-bench --agent my-agent \

--agent-kwarg model_path=/models/base-model \

--output-dir runs/baseline

跑训练后的模型

<bench-cli> run --dataset terminal-bench --agent my-agent \

--agent-kwarg model_path=/models/rl-ckpt-100 \

--output-dir runs/rl-100

```

三条纪律:

  • 先跑 oracle。oracle 跑不到接近 100%,说明你的运行环境(Docker、依赖、超时)有问题,后面所有数字都不可信。
  • 每个配置跑多次。终端任务的方差很大(同一个模型同一题,换个随机种子结果就变),单次 pass@1 的噪声可能有几个百分点。至少跑 3 次取均值,报告里写清采样次数和温度。
  • 训练/评测的任务不能重叠。跑之前用任务 id 和描述做一次交集检查,重叠了就重做训练集。

对比时除了总通过率,一定看分类通过率(按 tag 分组)。你会看到很有意思的现象:配置修复类可能涨了很多,长程多步类几乎没动——这直接告诉你下一轮该补什么数据。

常见坑与排错

容器泄漏把宿主机撑爆

症状:训练跑几小时后磁盘满、docker ps 里几百个 Up 状态的容器。

原因:rollout 中途异常退出,--rm 只在容器正常退出时生效。

对策:外层加 try/finally 强制 docker rm -f;加一个定时清理脚本,删掉运行超过 N 分钟的容器;给 Docker 的 data-root 单独挂一块盘。

奖励恒为 0

按顺序查:① 手动 docker exec 进去跑一遍 test_command,看是不是本来就过不了;② 验证脚本的路径、依赖在镜像里存不存在;③ --network none 是不是把需要本地回环的测试也掐了(127.0.0.1 不受影响,但有的测试会去连外网 DNS);④ 观测截断是不是把关键报错切掉了。

奖励虚高、模型明显在作弊

症状:训练中期通过率突然跳到很高,但把 checkpoint 拿去 Terminal-Bench 一跑就露馅。

对策:把 /tests 改成构建时 COPY 进镜像再 chmod 500,比挂载更难改;验证脚本里加一条"当前工作目录没有 solution.sh"的断言;每次评测前重新构建镜像。

rollout 太慢,GPU 一直在等

终端任务的瓶颈通常在 CPU 侧(起容器、跑 apt、跑 pytest),不在 GPU。

对策:容器池化预热(提前起好 N 个容器循环使用,用完 docker commit 或重建);把 max_turns 从 30 降到 15 看效果损失多少;rollout 和训练用不同的机器。

上下文超限

症状:跑到第 5、6 轮就开始报长度错误,后面的轨迹全被截断。

对策:观测截断到 4–8K 字符;长的 apt install / pip install 输出直接替换成 [输出过长已折叠];把 max_prompt_length 和 max_response_length 分开配置,别用一个总量卡死。

训练前后数字对不上

症状:训练时留出集通过率 20%,Terminal-Bench 只有 8%。

原因通常是环境差异:超时时间不同、镜像基础依赖不同、agent 的 prompt 模板不同。

对策:把 Terminal-Bench 用的 agent prompt 直接搬到训练里用,两边保持同一套系统提示词;评测超时按 bench 的默认值配,不要用训练时的短超时。

下一步建议

流水线跑通、拿到第一批对比数字之后,按投入产出比排序,往下推的方向是:

1. 补长程任务。做完分类分析你会发现,简单配置类涨得最快、多步任务几乎不动。下一步该把配额往"需要 10 步以上"的任务倾斜,这类任务的构造最贵,但也是通过率进一步提升的主要空间。

2. 做失败轨迹的归因。把训练后仍然失败的轨迹捞出来分类:是"没读懂题"、"命令写错"、"中途放弃"还是"改错了地方"。前两类补数据,后两类调 prompt 和奖励。

3. 迭代式数据回流。把当前模型失败的任务,用更强的模型生成参考解法、人工校验后加入训练池。这是持续提升最稳的路径,比调超参有效得多。

4. 换更小的基座做消融。用 4B/8B 模型跑同一条流水线,能快速验证"是方法有效还是模型本身强",成本低很多,也是对外解释结果时最有说服力的对照。

5. 把评测做成 CI。每次出 checkpoint 自动跑一遍小规模 Terminal-Bench 子集并记到表里,避免"训完才发现这轮白训"。

一句话总结这套方法的要点:奖励靠真跑、任务靠配比、难度靠过滤、提升靠回流。1200 这个数字本身不重要,重要的是你有没有一条能把"任务 → 训练 → 评测 → 补数据"转起来的流水线。

AI 生成本文由 AI 基于公开信息自动生成,仅供参考。