release v2: add frozen Judge trainer (slime reward, prompts, pool, launch) and heldout_prompts.jsonl

adapter/r2e_local/build_prompts.py

@@ -0,0 +1,110 @@
+"""Build slime prompt JSONL from admitted Harbor task directories.
+
+One record per task:
+    prompt    chat messages (system + user) for --apply-chat-template
+    label     task id
+    metadata  {task_dir, repo_key, base_commit, repo, source_files}
+
+The user message carries the task's instruction.md and, as context, the
+contents at base_commit of every file the oracle patch touches (oracle file
+retrieval, the SWE-RL convention for single-turn patch generation). Files are
+read from the repository mirror at base_commit; nothing from the oracle patch
+itself is shown. Budgets keep the prompt bounded and deterministic.
+
+Usage:
+    python -m r2e_local.build_prompts --tasks <dir with task dirs>... --mirrors <repos root> --out train.jsonl
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+
+SYSTEM = (
+    "You are an expert Python software engineer. You will be given a bug report for a "
+    "repository and the current contents of the relevant source files. Produce a fix as a "
+    "single unified diff against the repository root, inside one ```diff fenced block, and "
+    "nothing else. Do not modify or add tests."
+)
+
+_FILE_RE = re.compile(r"^diff --git a/(\S+) b/(\S+)", re.M)
+
+
+def oracle_files(patch: str) -> list[str]:
+    seen: list[str] = []
+    for m in _FILE_RE.finditer(patch):
+        p = m.group(2)
+        if p not in seen:
+            seen.append(p)
+    return seen
+
+
+def git_show(mirror: Path, commit: str, path: str) -> str | None:
+    r = subprocess.run(["git", "-C", str(mirror), "show", f"{commit}:{path}"], capture_output=True, text=True, errors="replace")
+    return r.stdout if r.returncode == 0 else None
+
+
+def build_record(task_dir: Path, mirrors: Path, *, per_file: int, total: int) -> dict | None:
+    meta = tomllib.loads((task_dir / "task.toml").read_text())
+    r2e = meta["metadata"]["repo2env"]
+    repo = r2e["repo"]
+    key = repo.replace("/", "__")
+    base = r2e["commit_runtime"]["parent_sha"]
+    patch = (task_dir / "solution" / "patch.diff").read_text()
+    files = oracle_files(patch)
+    mirror = mirrors / key
+    parts = [(task_dir / "instruction.md").read_text().strip(), "", "## Relevant files (at the current commit)", ""]
+    used = 0
+    for f in files:
+        content = git_show(mirror, base, f)
+        if content is None:
+            continue
+        if len(content) > per_file:
+            content = content[:per_file] + f"\n... [truncated {len(content) - per_file} chars]\n"
+        block = f"### {f}\n```python\n{content}\n```\n"
+        if used + len(block) > total:
+            break
+        parts.append(block)
+        used += len(block)
+    parts.append("Return the fix as one unified diff in a ```diff block.")
+    return {
+        "prompt": [{"role": "system", "content": SYSTEM}, {"role": "user", "content": "\n".join(parts)}],
+        "label": task_dir.name,
+        "metadata": {
+            "task_dir": str(task_dir.resolve()),
+            "repo_key": key,
+            "repo": repo,
+            "base_commit": base,
+            "source_files": files,
+        },
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--tasks", nargs="+", type=Path, required=True, help="directories containing task dirs")
+    ap.add_argument("--mirrors", type=Path, required=True)
+    ap.add_argument("--out", type=Path, required=True)
+    ap.add_argument("--per-file-chars", type=int, default=16000)
+    ap.add_argument("--total-chars", type=int, default=48000)
+    args = ap.parse_args(argv)
+    n = 0
+    with args.out.open("w") as fh:
+        for root in args.tasks:
+            for td in sorted(p for p in root.iterdir() if (p / "task.toml").exists()):
+                rec = build_record(td, args.mirrors, per_file=args.per_file_chars, total=args.total_chars)
+                if rec is None:
+                    continue
+                fh.write(json.dumps(rec) + "\n")
+                n += 1
+    print(json.dumps({"records": n, "out": str(args.out)}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

adapter/r2e_local/judge_reward.py

@@ -0,0 +1,145 @@
+"""Frozen Judge reward for slime (`--custom-rm-path r2e_local.judge_reward.reward`).
+
+Single-turn patch generation. The sample's response must contain a unified
+diff. The reward applies that diff at the task's base commit inside a pooled
+LocalSandbox checkout and then runs the task's own `tests/test.sh`, the
+verifier Repo2RLEnv emitted with the task (test-patch apply, targeted pytest,
+F2P/P2P grading via tests/verifier.py). Reward is 1.0 when the verifier
+reports resolved, else 0.0. Nothing here is candidate-supplied.
+
+Sample.metadata contract (written by build_prompts.py):
+    task_dir     absolute path of the Harbor task directory
+    repo_key     owner__name
+    base_commit  the task's parent_sha
+
+Environment:
+    R2E_POOL_ROOT   root of sandbox pools: <root>/<repo_key>/<i>/ (make_pool.py)
+    R2E_REWARD_TIMEOUT  seconds per verifier run (default 900)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import re
+import shutil
+import tempfile
+from pathlib import Path
+
+from .sandbox import LocalSandbox
+
+_DIFF_FENCE = re.compile(r"```(?:diff|patch)?\s*\n(.*?)```", re.S)
+_DIFF_START = re.compile(r"^(diff --git |--- (?:a/|/dev/null))", re.M)
+
+_pools: dict[str, asyncio.Queue] = {}
+_pools_lock = asyncio.Lock()
+
+
+def extract_diff(text: str) -> str | None:
+    """Return the unified diff in a model response, or None."""
+    for m in _DIFF_FENCE.finditer(text):
+        body = m.group(1)
+        if _DIFF_START.search(body):
+            return body if body.endswith("\n") else body + "\n"
+    m = _DIFF_START.search(text)
+    if m:
+        body = text[m.start():]
+        return body if body.endswith("\n") else body + "\n"
+    return None
+
+
+async def _pool(repo_key: str) -> asyncio.Queue:
+    async with _pools_lock:
+        q = _pools.get(repo_key)
+        if q is None:
+            root = Path(os.environ.get("R2E_POOL_ROOT", "/rsi-data/pool")) / repo_key
+            slots = sorted(p for p in root.iterdir() if (p / ".git").exists()) if root.exists() else []
+            if not slots:
+                raise RuntimeError(f"no sandbox pool for {repo_key} under {root}")
+            q = asyncio.Queue()
+            for s in slots:
+                q.put_nowait(s)
+            _pools[repo_key] = q
+        return q
+
+
+def _load_rebuild(repo_key: str) -> list[str]:
+    bj = Path(os.environ.get("R2E_BOOTSTRAP_ROOT", "/rsi-data/bootstrap")) / repo_key / "bootstrap.json"
+    try:
+        return list(json.loads(bj.read_text()).get("rebuild_cmds") or [])
+    except OSError:
+        return []
+
+
+def _grade_sync(task_dir: Path, repo_key: str, base_commit: str, diff: str, slot: Path, timeout: int) -> dict:
+    sb = LocalSandbox(slot, post_clean_cmds=_load_rebuild(repo_key))
+    logs = Path(tempfile.mkdtemp(prefix="r2e-judge-"))
+    try:
+        prep = sb.exec(
+            f"git reset -q --hard {base_commit} && git clean -fdxq -e .venv "
+            "-e __pycache__ -e .pytest_cache || true",
+            timeout=300,
+        )
+        if not prep.ok:
+            return {"reward": 0.0, "resolved": False, "status": "reset_failed", "stderr": prep.stderr[-500:]}
+        # Rebuild after the clean, exactly as validation does (rebuild_cmds).
+        if sb.post_clean_cmds:
+            sb.exec("(" + " && ".join(sb.post_clean_cmds) + ") >/dev/null 2>&1 || true", timeout=600)
+        (logs / "candidate.diff").write_text(diff)
+        applied = sb.exec(f"git apply --verbose --reject {logs / 'candidate.diff'}", timeout=120)
+        if not applied.ok:
+            return {"reward": 0.0, "resolved": False, "status": "patch_apply_failed", "stderr": applied.stderr[-500:]}
+        # Run the task's own verifier with /workspace and /logs relocated.
+        test_sh = (task_dir / "tests" / "test.sh").read_text()
+        test_sh = test_sh.replace("/logs/verifier", str(logs / "verifier")).replace("/logs", str(logs))
+        tests_copy = logs / "tests"
+        shutil.copytree(task_dir / "tests", tests_copy)
+        (tests_copy / "test.sh").write_text(test_sh)
+        r = sb.exec(f"bash {tests_copy / 'test.sh'}", timeout=timeout)
+        details: dict = {}
+        try:
+            details = json.loads((logs / "verifier" / "reward-details.json").read_text())
+        except (OSError, json.JSONDecodeError):
+            pass
+        try:
+            scalar = float((logs / "verifier" / "reward.txt").read_text().strip())
+        except (OSError, ValueError):
+            scalar = 0.0
+        resolved = bool(details.get("resolved", scalar >= 1.0))
+        return {
+            "reward": 1.0 if resolved else 0.0,
+            "resolved": resolved,
+            "verifier_scalar": scalar,
+            "status": details.get("parse_status", "graded"),
+            "exit_code": r.exit_code,
+        }
+    finally:
+        sb.exec(f"git reset -q --hard {base_commit} && git clean -fdxq -e .venv || true", timeout=300)
+        shutil.rmtree(logs, ignore_errors=True)
+
+
+async def grade(task_dir: Path, repo_key: str, base_commit: str, response: str) -> dict:
+    diff = extract_diff(response or "")
+    if not diff:
+        return {"reward": 0.0, "resolved": False, "status": "no_diff_in_response"}
+    timeout = int(os.environ.get("R2E_REWARD_TIMEOUT", "900"))
+    q = await _pool(repo_key)
+    slot = await q.get()
+    try:
+        return await asyncio.to_thread(_grade_sync, task_dir, repo_key, base_commit, diff, slot, timeout)
+    finally:
+        q.put_nowait(slot)
+
+
+async def reward(args, sample, **kwargs) -> float:
+    """slime custom reward entry point."""
+    del args, kwargs
+    meta = sample.metadata or {}
+    task_dir = Path(meta["task_dir"])
+    result = await grade(task_dir, meta["repo_key"], meta["base_commit"], sample.response)
+    try:
+        sample.metadata["judge"] = result
+    except Exception:
+        pass
+    return float(result["reward"])

adapter/r2e_local/make_pool.py

@@ -0,0 +1,87 @@
+"""Create K sandbox copies per repository for parallel Judge grading.
+
+Each copy is `git clone --shared` of the mirror (no object duplication) with
+its own `.venv` installed from the repository's requirements.lock, plus the
+build backends needed for offline editable rebuilds. Layout:
+    <pool_root>/<owner__name>/<i>/   i in 0..K-1
+
+Usage:
+    python -m r2e_local.make_pool --mirrors <repos root> --bootstrap <bootstrap root> \
+        --pool <pool root> --copies 2 [--repos owner/name ...] [--python-root <uv python dir>]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+BACKENDS = [
+    "setuptools", "wheel", "setuptools-scm", "hatchling", "hatch-vcs", "hatch-fancy-pypi-readme",
+    "poetry-core", "flit-core", "pdm-backend", "versioningit", "pbr", "editables",
+    "hatch-requirements-txt", "setuptools-git-versioning", "poetry-dynamic-versioning",
+]
+
+
+def make_one(mirror: Path, boot: dict, lock: Path, dest: Path, env: dict) -> str:
+    if (dest / ".venv" / "bin" / "python").exists():
+        return f"exists {dest}"
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    if not (dest / ".git").exists():
+        subprocess.run(["git", "clone", "-q", "--shared", "--no-checkout", f"file://{mirror}", str(dest)], check=True)
+    subprocess.run(["git", "-C", str(dest), "checkout", "-q", "--detach", boot["ref"]], check=True)
+    py = boot.get("extra", {}).get("python_version", "3.12")
+    py = ".".join(py.split(".")[:2])
+    subprocess.run(["uv", "venv", "-q", "--python", py, ".venv"], cwd=dest, env=env, check=True)
+    # The lock is a `uv pip freeze` of the bootstrap venv: drop the editable
+    # self-reference (`-e file:///.../sandboxes/<repo>`) and any other local
+    # path pins; the copy gets its own editable install via rebuild_cmds below.
+    pinned = [
+        line for line in lock.read_text().splitlines()
+        if line.strip() and not line.startswith(("-e ", "#")) and "file://" not in line
+    ]
+    lock_copy = dest / ".venv" / "requirements.pool.txt"
+    lock_copy.write_text("\n".join(pinned) + "\n")
+    subprocess.run(["uv", "pip", "install", "-q", "--python", ".venv/bin/python", "-r", str(lock_copy)], cwd=dest, env=env, check=True)
+    subprocess.run(["uv", "pip", "install", "-q", "--python", ".venv/bin/python", *BACKENDS], cwd=dest, env=env, check=False)
+    for cmd in boot.get("rebuild_cmds") or []:
+        subprocess.run(["bash", "-c", cmd], cwd=dest, env=env, check=False)
+    return f"built {dest}"
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--mirrors", type=Path, required=True)
+    ap.add_argument("--bootstrap", type=Path, required=True)
+    ap.add_argument("--pool", type=Path, required=True)
+    ap.add_argument("--copies", type=int, default=2)
+    ap.add_argument("--repos", nargs="*", default=None)
+    ap.add_argument("--workers", type=int, default=4)
+    args = ap.parse_args(argv)
+    env = dict(os.environ)
+    env.setdefault("UV_LINK_MODE", "hardlink")
+    jobs = []
+    for bdir in sorted(args.bootstrap.iterdir()):
+        bj = bdir / "bootstrap.json"
+        if not bj.exists():
+            continue
+        boot = json.loads(bj.read_text())
+        if args.repos and boot["repo"] not in args.repos:
+            continue
+        if not boot.get("smoke_passed"):
+            continue
+        key = bdir.name
+        for i in range(args.copies):
+            jobs.append((args.mirrors / key, boot, bdir / "requirements.lock", args.pool / key / str(i)))
+    with ThreadPoolExecutor(max_workers=args.workers) as ex:
+        for line in ex.map(lambda j: make_one(*j, env), jobs):
+            print(line, flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

adapter/r2e_local/train_judge_slime.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+# Frozen Judge trainer: slime v0.3.0 (THUDM/slime@bf14dc21), Qwen/Qwen3.5-4B, GRPO,
+# single-turn patch generation graded by r2e_local.judge_reward.reward.
+#
+# Fixed protocol (proposal, Evaluation rows): 50 rollouts x 16 prompts x 8 samples,
+# lr 1e-6, kl 1e-3 (low_var_kl), rollout temperature 1.0, max response 16384, seed 42.
+# Evaluation: the same reward at temperature 0, one sample per held-out task, before
+# training (rollout 0) and after the last rollout.
+#
+# Required env:
+#   SLIME_DIR          checkout of THUDM/slime at bf14dc21 (inside the image: /root/slime)
+#   MODEL_ROOT         contains Qwen3.5-4B/ (HF) and Qwen3.5-4B_torch_dist/ (converted)
+#   TRAIN_JSONL        admitted training tasks (build_prompts.py output)
+#   HELDOUT_JSONL      held-out evaluation prompts (build_prompts.py output)
+#   R2E_POOL_ROOT      sandbox pool root (make_pool.py)
+#   R2E_BOOTSTRAP_ROOT bootstrap.json root
+#   OUTPUT_DIR         run directory
+# Optional: NUM_ROLLOUT (50) ROLLOUT_BATCH (16) N_SAMPLES (8) SEED (42)
+set -euo pipefail
+
+: "${SLIME_DIR:?}" "${MODEL_ROOT:?}" "${TRAIN_JSONL:?}" "${HELDOUT_JSONL:?}" "${R2E_POOL_ROOT:?}" "${R2E_BOOTSTRAP_ROOT:?}" "${OUTPUT_DIR:?}"
+NUM_ROLLOUT="${NUM_ROLLOUT:-50}"
+ROLLOUT_BATCH="${ROLLOUT_BATCH:-16}"
+N_SAMPLES="${N_SAMPLES:-8}"
+SEED="${SEED:-42}"
+ADAPTER_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"   # directory containing r2e_local/
+export PYTHONPATH="${ADAPTER_DIR}:${SLIME_DIR}:/root/Megatron-LM:${PYTHONPATH:-}"
+export WANDB_MODE=disabled
+mkdir -p "${OUTPUT_DIR}"
+
+# Model configuration shipped with the pinned slime commit.
+source "${SLIME_DIR}/scripts/models/qwen3.5-4B.sh"
+
+CKPT_ARGS=(
+   --hf-checkpoint "${MODEL_ROOT}/Qwen3.5-4B"
+   --ref-load "${MODEL_ROOT}/Qwen3.5-4B_torch_dist"
+   --save "${OUTPUT_DIR}/ckpt"
+   --save-interval "${NUM_ROLLOUT}"
+)
+DATA_ARGS=(
+   --prompt-data "${TRAIN_JSONL}"
+   --input-key prompt --label-key label --metadata-key metadata
+   --apply-chat-template
+   --custom-rm-path r2e_local.judge_reward.reward
+   --eval-prompt-data heldout "${HELDOUT_JSONL}"
+   --eval-input-key prompt --eval-label-key label
+   --eval-interval "${NUM_ROLLOUT}"
+   --n-samples-per-eval-prompt 1
+   --eval-temperature 0.0
+   --eval-max-response-len 16384
+)
+ROLLOUT_ARGS=(
+   --num-rollout "${NUM_ROLLOUT}"
+   --rollout-batch-size "${ROLLOUT_BATCH}"
+   --n-samples-per-prompt "${N_SAMPLES}"
+   --rollout-max-response-len 16384
+   --rollout-temperature 1.0
+   --global-batch-size $((ROLLOUT_BATCH * N_SAMPLES))
+   --balance-data
+   --rollout-shuffle
+   --seed "${SEED}"
+)
+GRPO_ARGS=(
+   --advantage-estimator grpo
+   --use-kl-loss
+   --kl-loss-coef 0.001
+   --kl-loss-type low_var_kl
+   --entropy-coef 0.0
+   --eps-clip 0.2
+   --eps-clip-high 0.28
+)
+OPTIMIZER_ARGS=(
+   --optimizer adam
+   --lr 1e-6
+   --lr-decay-style constant
+   --weight-decay 0.1
+   --adam-beta1 0.9
+   --adam-beta2 0.98
+)
+PERF_ARGS=(
+   --tensor-model-parallel-size 2
+   --sequence-parallel
+   --pipeline-model-parallel-size 1
+   --context-parallel-size 2
+   --use-dynamic-batch-size
+   --max-tokens-per-gpu 16384
+   --recompute-granularity full
+   --recompute-method uniform
+   --recompute-num-layers 1
+)
+SGLANG_ARGS=(
+   --rollout-num-gpus-per-engine 1
+   --sglang-mem-fraction-static 0.7
+)
+MISC_ARGS=(
+   --actor-num-nodes 1
+   --actor-num-gpus-per-node 8
+   --colocate
+   --attention-dropout 0.0
+   --hidden-dropout 0.0
+   --bf16
+   --accumulate-allreduce-grads-in-fp32
+   --attention-softmax-in-fp32
+   --attention-backend flash
+)
+
+ray stop --force >/dev/null 2>&1 || true
+ray start --head --num-gpus 8 --disable-usage-stats >/dev/null
+cd "${SLIME_DIR}"
+python train.py \
+   "${MODEL_ARGS[@]}" "${CKPT_ARGS[@]}" "${DATA_ARGS[@]}" "${ROLLOUT_ARGS[@]}" \
+   "${GRPO_ARGS[@]}" "${OPTIMIZER_ARGS[@]}" "${PERF_ARGS[@]}" "${SGLANG_ARGS[@]}" "${MISC_ARGS[@]}" \
+   2>&1 | tee "${OUTPUT_DIR}/train.log"