Blame for screen_launcher.py

# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# /// script
# dependencies = [
#     "trl",
#     "vllm",
#     "datasets>=3.2",
#     "huggingface_hub",
#     "openenv-opencode-env @ git+https://github.com/huggingface/OpenEnv.git#subdirectory=envs/opencode_env",
# ]
# ///

"""
Measure base vs trained on candidate tasks, in one job, and print the table that picks the task.

Serves the base model, screens the candidates, tears vLLM down, serves the trained model, screens the
same candidates, then merges both results into a comparison table. Two passes in one job because vLLM
holds the GPU, and one job because the answer is the comparison, not either half.

```sh
TASK_INDICES=11,34,39,25 ROLLOUTS=2 \
hf jobs uv run --flavor a100-large --secrets HF_TOKEN --timeout 7200s screen_launcher.py
```

Env vars: `BASE_MODEL`, `TRAINED_MODEL`, `TASK_INDICES`, `ROLLOUTS`, `N_PROMPTS`, `SEED`,
`SANDBOX_FLAVOR`, `PUSH_TO_DATASET`.

Budget: `len(TASK_INDICES) * ROLLOUTS * 2` rollouts, each booting its own remote sandbox, plus two
vLLM starts. Four tasks at two rollouts is sixteen rollouts, roughly an hour. Raise the job timeout
before raising either number.

Index 11 is in the default list as a control: the base model already scored 1.0 on it in a measured
run, so if the screen disagrees about 11, the screen is wrong.
"""

import json
import os
import re
import signal
import subprocess
import sys
import time
import urllib.request


BASE_URL = "https://huggingface.co/datasets/sergiopaniego/opencode-rollout-trace/resolve/main"
SCREEN_URL = f"{BASE_URL}/screen_tasks.py"
EXAMPLE_URL = (
    "https://raw.githubusercontent.com/huggingface/trl/"
    "main/examples/async_grpo_opencode/opencode_hf_sandbox.py"
)
CLOUDFLARED = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64"

BASE_MODEL = os.environ.get("BASE_MODEL", "Qwen/Qwen3-8B")
TRAINED_MODEL = os.environ.get("TRAINED_MODEL", "sergiopaniego/Qwen3-8B-opencode-deepcoder-grpo")
TASK_INDICES = os.environ.get("TASK_INDICES", "11,34,39,25")
ROLLOUTS = os.environ.get("ROLLOUTS", "2")
N_PROMPTS = os.environ.get("N_PROMPTS", "64")
SEED = os.environ.get("SEED", "0")
SANDBOX_FLAVOR = os.environ.get("SANDBOX_FLAVOR", "cpu-basic")


def _log(m):
    print(">>> " + m, flush=True)


def _kill_pg(p):
    if p is None:
        return
    try:
        os.killpg(os.getpgid(p.pid), signal.SIGKILL)
    except Exception:
        try:
            p.kill()
        except Exception:
            pass


def serve(model):
    """Bring up vLLM for one model and a public tunnel to it. Returns (vllm, cloudflared, public_url)."""
    _log(f"serving {model}...")
    vllm = subprocess.Popen(
        ["vllm", "serve", model, "--max-model-len", "40960", "--logprobs-mode", "processed_logprobs",
         "--return-tokens-as-token-ids", "--enable-auto-tool-choice", "--tool-call-parser", "hermes"],
        env={**os.environ, "VLLM_USE_FLASHINFER_SAMPLER": "0"},
        start_new_session=True,
    )
    for _ in range(300):
        if vllm.poll() is not None:
            _log(f"vLLM died early rc={vllm.returncode}")
            return vllm, None, None
        try:
            urllib.request.urlopen("http://localhost:8000/health", timeout=3)
            break
        except Exception:
            time.sleep(2)
    else:
        _log("vLLM never became healthy")
        return vllm, None, None

    logname = f"cf_{re.sub(r'[^a-z0-9]+', '_', model.lower())}.log"
    cflog = open(logname, "w")
    cf = subprocess.Popen(["./cloudflared", "tunnel", "--no-autoupdate", "--url", "http://localhost:8000"],
                          stdout=cflog, stderr=subprocess.STDOUT, start_new_session=True)
    for _ in range(60):
        time.sleep(2)
        m = re.search(r"https://[a-z0-9-]+\.trycloudflare\.com", open(logname).read())
        if m:
            _log(f"public url: {m.group(0)}")
            return vllm, cf, m.group(0)
    _log("cloudflared did not produce a public URL")
    return vllm, cf, None


def screen(which, model, public, out):
    cmd = [sys.executable, "screen_tasks.py",
           "--base-model", BASE_MODEL, "--trained-model", TRAINED_MODEL,
           "--sandbox-vllm-url", public, "--serving", which,
           "--task-indices", TASK_INDICES, "--rollouts", ROLLOUTS,
           "--n-prompts", N_PROMPTS, "--seed", SEED,
           "--sandbox-flavor", SANDBOX_FLAVOR, "--out", out]
    _log(f"screening with the {which} model ({model})...")
    return subprocess.run(cmd).returncode


def table(base, trained):
    """The deliverable: one row per task, and whether the gap is worth recording."""
    lines = ["", "idx  seen?  base    trained  gap", "---  -----  ------  -------  ----------"]
    picks = []
    for idx in sorted(set(base["tasks"]) | set(trained["tasks"]), key=int):
        b = base["tasks"].get(idx, {})
        t = trained["tasks"].get(idx, {})
        bm, tm = b.get("mean"), t.get("mean")
        seen = "yes" if b.get("seen_in_training", t.get("seen_in_training")) else "no"
        if bm is None or tm is None:
            verdict = "unscorable"
        elif bm <= 0.05 and tm >= 0.95:
            verdict = "CLEAN"
            picks.append(idx)
        elif tm - bm >= 0.3:
            verdict = "partial"
        elif tm - bm <= 0.05:
            verdict = "no gap"
        else:
            verdict = "weak"
        lines.append("%-4s %-6s %-7s %-8s %s" % (idx, seen,
                     "n/a" if bm is None else "%.2f" % bm,
                     "n/a" if tm is None else "%.2f" % tm, verdict))
    lines.append("")
    if picks:
        lines.append("record one of these: " + ", ".join(picks))
        unseen = [p for p in picks if not base["tasks"].get(p, {}).get("seen_in_training", True)]
        if unseen:
            lines.append("and prefer an unseen one, which is the stronger story: " + ", ".join(unseen))
    else:
        lines.append("no clean gap. Take the largest partial one and say so out loud in the talk.")
    return "\n".join(lines)


def main():
    urllib.request.urlretrieve(CLOUDFLARED, "cloudflared")
    os.chmod("cloudflared", 0o755)
    urllib.request.urlretrieve(SCREEN_URL, "screen_tasks.py")
    urllib.request.urlretrieve(EXAMPLE_URL, "opencode_hf_sandbox.py")
    _log("downloaded cloudflared + screener + the example it imports")

    for which, model, out in (("base", BASE_MODEL, "screen_base.json"),
                              ("trained", TRAINED_MODEL, "screen_trained.json")):
        vllm = cf = None
        try:
            vllm, cf, public = serve(model)
            if not public:
                return 1
            if screen(which, model, public, out) != 0:
                _log(f"the {which} pass failed")
                return 1
        finally:
            _log(f"tearing down vLLM for {model}...")
            _kill_pg(cf)
            _kill_pg(vllm)
            time.sleep(20)  # let the GPU actually free before the next serve

    base = json.load(open("screen_base.json"))
    trained = json.load(open("screen_trained.json"))
    result = table(base, trained)
    print(result, flush=True)
    with open("screen_table.txt", "w") as fh:
        fh.write(result + "\n")

    if os.environ.get("PUSH_TO_DATASET"):
        from huggingface_hub import HfApi

        repo = os.environ["PUSH_TO_DATASET"]
        api = HfApi()
        api.create_repo(repo, repo_type="dataset", exist_ok=True)
        import glob

        files = ["screen_base.json", "screen_trained.json", "screen_table.txt"]
        files += sorted(glob.glob("fail_*.json"))  # the traces of the rollouts that scored 0
        for f in files:
            api.upload_file(path_or_fileobj=f, path_in_repo=f"screening/{f}", repo_id=repo, repo_type="dataset",
                            commit_message="Screen base vs trained to pick the before/after task")
        _log(f"uploaded {len(files)} files, {len(files) - 3} of them failure traces")
        _log(f"pushed to https://huggingface.co/datasets/{repo}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())