Add files using upload-large-folder tool

22decf5 verified 13 days ago

6.68 kB

"""Evaluation phase: score a model on a benchmark with upstream's `evaluate.py` in the sandbox."""

import contextlib
import json
import os
import shutil
import subprocess
import sys
from pathlib import Path

from . import config, sandbox

# Upstream's retry protocol (`src/run_task.sh`): vLLM occasionally fails on long generations,
# so after 4 failed attempts the generation budget is lowered, first to the left value
# (3 attempts), then to the right one (2 attempts). Tasks not listed get 9 plain attempts.
REDUCED_MAX_TOKENS = {
    "aime2025": ("--max-tokens", 12000, 8000),
    "arenahardwriting": ("--max-new-tokens", 12288, 8192),
    "bfcl": ("--max-tokens", 12000, 8000),
    "gpqamain": ("--max-tokens", 12000, 8000),
    "gsm8k": ("--max-tokens", 3000, 2000),
    "healthbench": ("--max-new-tokens", 12288, 8192),
    "humaneval": ("--max-tokens", 3000, 2000),
}


def attempts(task: str) -> list[list[str]]:
    """Extra `evaluate.py` arguments for each successive attempt."""
    if task not in REDUCED_MAX_TOKENS:
        return [[]] * 9
    flag, first, second = REDUCED_MAX_TOKENS[task]
    return [[]] * 4 + [[flag, str(first)]] * 3 + [[flag, str(second)]] * 2


@contextlib.contextmanager
def judge_balancer(pool: list[str]):
    """Spread grading calls over every replica of the judge pool.
    Yields an OpenAI-style base URL for a loopback balancer, or "" when there is no pool. A
    healthbench cell is ~1900 grading calls and arenahardwriting ~500; sending them all to one
    replica would leave the rest of the pool's GPUs idle.
    """
    if not pool:
        yield ""
        return
    process = subprocess.Popen(
        [sys.executable, str(config.REPO_ROOT / "scripts/ptb_uds_bridge.py"), "balance",
         "--targets", ",".join(pool)],
        stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
    try:
        port = process.stdout.readline().strip()
        if not port.isdigit():
            process.terminate()
            raise RuntimeError(f"Judge balancer did not start: {port!r}")
        print(f"Judge balancer on 127.0.0.1:{port} -> {', '.join(pool)}")
        yield f"http://127.0.0.1:{port}/v1"
    finally:
        process.terminate()
        process.wait(timeout=30)


def evaluate(out_dir: Path, task: str, model: str, limit: int = -1) -> dict | None:
    """Evaluate `model` (a local directory or a HF model id); returns the metrics, or None on failure.
    Writes `metrics.json` and one `final_eval_<n>.txt` log per attempt to `out_dir`.
    """
    out_dir = out_dir.resolve()
    out_dir.mkdir(parents=True, exist_ok=True)
    metrics_file = out_dir / "metrics.json"
    task_src = config.UPSTREAM / "src/eval/tasks" / task
    binds = {config.UPSTREAM: f"{config.UPSTREAM}:ro", out_dir: str(out_dir)}
    if Path(model).is_dir():
        model = str(Path(model).resolve())
        binds[Path(model)] = f"{model}:ro"
    scratch = out_dir / "eval_sandbox"
    timeout_minutes = int(os.environ.get("PTB_EVAL_TIMEOUT_MINUTES", 8 * 60))
    if timeout_minutes <= 0:
        raise ValueError("PTB_EVAL_TIMEOUT_MINUTES must be a positive integer")

    # arenahardwriting's evaluate.py opens its question set as the relative path
    # `evaluation_code/data/arena-hard-v2.0/question.jsonl`, and writes model answers and
    # judgments back under the same tree -- so it needs a writable copy next to the cwd we give
    # it, not the read-only upstream bind. Upstream gets this for free because run_task.sh copies
    # the task directory into the agent's workspace and runs there; our evaluation phase runs
    # from out_dir. The other benchmarks pull their data from the HF cache and do not care.
    if (evaluation_code := task_src / "evaluation_code").is_dir():
        shutil.copytree(evaluation_code, out_dir / "evaluation_code", dirs_exist_ok=True)

    # OPENAI_BASE_URL points the LLM-graded benchmarks at the local vLLM judge pool
    # (scripts/ptb_judge_pool.sbatch) because api.openai.com is unreachable from the aws cluster.
    # Both graders build their client with no explicit base_url -- healthbench's
    # evaluation_code/grader.py `OpenAI(api_key=...)` and arenahardwriting's `openai.OpenAI()` --
    # so the SDK picks the variable up and no upstream code has to change. This sandbox runs
    # without `--net`, so it shares the host's network namespace and can reach a loopback
    # balancer directly; the agent phase has to tunnel the same traffic over a unix socket.
    # The variable is dropped when empty: the SDK treats "" as a real base URL and every request
    # would fail, whereas an absent variable falls back to the public API.

    # arenahardwriting's evaluate.py calls tiktoken.encoding_for_model("gpt-4o") to count tokens,
    # which on a cache miss fetches o200k_base.tiktoken from openaipublic.blob.core.windows.net --
    # unreachable from the aws login node (same Azure blob host as huggingface.co; SSL EOF, 9/9 attempts
    # failed). tiktoken keys its on-disk cache by sha1(blobpath), so dropping the file in under
    # that name short-circuits the fetch entirely; scripts/tiktoken_cache holds a copy recovered
    # from an earlier run's cache dir, content-hash-verified against the known-good file.
    tiktoken_cache = out_dir / "tiktoken_cache"
    shutil.copytree(config.REPO_ROOT / "scripts/tiktoken_cache", tiktoken_cache, dirs_exist_ok=True)

    with judge_balancer(config.judge_pool_targets()) as pool_url:
        base_url = os.environ.get("OPENAI_BASE_URL") or pool_url
        env = {"OPENAI_API_KEY": os.environ.get("OPENAI_API_KEY", "") or ("EMPTY" if base_url else ""),
               "OPENAI_BASE_URL": base_url,
               "HF_TOKEN": os.environ.get("HF_TOKEN", ""),
               "TIKTOKEN_CACHE_DIR": str(tiktoken_cache)}
        env = {k: v for k, v in env.items() if v or k == "OPENAI_API_KEY"}

        for n, extra_args in enumerate(attempts(task), start=1):
            print(f"Evaluation attempt {n} {' '.join(extra_args)}")
            sandbox.run(
                ["python", str(task_src / "evaluate.py"), "--model-path", model, "--limit", str(limit),
                 "--templates-dir", str(config.UPSTREAM / "src/eval/templates"),
                 "--json-output-file", str(metrics_file), *extra_args],
                scratch=scratch, hf_cache=config.HF_CACHE, binds=binds, workdir=str(out_dir),
                container=config.EVAL_CONTAINER, env=env,
                timeout_minutes=timeout_minutes, log=out_dir / f"final_eval_{n}.txt",
            )
            if metrics_file.is_file():
                break
    shutil.rmtree(scratch)
    return json.loads(metrics_file.read_text()) if metrics_file.is_file() else None

	"""Evaluation phase: score a model on a benchmark with upstream's `evaluate.py` in the sandbox."""

	import contextlib
	import json
	import os
	import shutil
	import subprocess
	import sys
	from pathlib import Path

	from . import config, sandbox

	# Upstream's retry protocol (`src/run_task.sh`): vLLM occasionally fails on long generations,
	# so after 4 failed attempts the generation budget is lowered, first to the left value
	# (3 attempts), then to the right one (2 attempts). Tasks not listed get 9 plain attempts.
	REDUCED_MAX_TOKENS = {
	"aime2025": ("--max-tokens", 12000, 8000),
	"arenahardwriting": ("--max-new-tokens", 12288, 8192),
	"bfcl": ("--max-tokens", 12000, 8000),
	"gpqamain": ("--max-tokens", 12000, 8000),
	"gsm8k": ("--max-tokens", 3000, 2000),
	"healthbench": ("--max-new-tokens", 12288, 8192),
	"humaneval": ("--max-tokens", 3000, 2000),
	}


	def attempts(task: str) -> list[list[str]]:
	"""Extra `evaluate.py` arguments for each successive attempt."""
	if task not in REDUCED_MAX_TOKENS:
	return [[]] * 9
	flag, first, second = REDUCED_MAX_TOKENS[task]
	return [[]] * 4 + [[flag, str(first)]] * 3 + [[flag, str(second)]] * 2


	@contextlib.contextmanager
	def judge_balancer(pool: list[str]):
	"""Spread grading calls over every replica of the judge pool.

	Yields an OpenAI-style base URL for a loopback balancer, or "" when there is no pool. A
	healthbench cell is ~1900 grading calls and arenahardwriting ~500; sending them all to one
	replica would leave the rest of the pool's GPUs idle.
	"""
	if not pool:
	yield ""
	return
	process = subprocess.Popen(
	[sys.executable, str(config.REPO_ROOT / "scripts/ptb_uds_bridge.py"), "balance",
	"--targets", ",".join(pool)],
	stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
	try:
	port = process.stdout.readline().strip()
	if not port.isdigit():
	process.terminate()
	raise RuntimeError(f"Judge balancer did not start: {port!r}")
	print(f"Judge balancer on 127.0.0.1:{port} -> {', '.join(pool)}")
	yield f"http://127.0.0.1:{port}/v1"
	finally:
	process.terminate()
	process.wait(timeout=30)


	def evaluate(out_dir: Path, task: str, model: str, limit: int = -1) -> dict \| None:
	"""Evaluate `model` (a local directory or a HF model id); returns the metrics, or None on failure.

	Writes `metrics.json` and one `final_eval_<n>.txt` log per attempt to `out_dir`.
	"""
	out_dir = out_dir.resolve()
	out_dir.mkdir(parents=True, exist_ok=True)
	metrics_file = out_dir / "metrics.json"
	task_src = config.UPSTREAM / "src/eval/tasks" / task
	binds = {config.UPSTREAM: f"{config.UPSTREAM}:ro", out_dir: str(out_dir)}
	if Path(model).is_dir():
	model = str(Path(model).resolve())
	binds[Path(model)] = f"{model}:ro"
	scratch = out_dir / "eval_sandbox"
	timeout_minutes = int(os.environ.get("PTB_EVAL_TIMEOUT_MINUTES", 8 * 60))
	if timeout_minutes <= 0:
	raise ValueError("PTB_EVAL_TIMEOUT_MINUTES must be a positive integer")

	# arenahardwriting's evaluate.py opens its question set as the relative path
	# `evaluation_code/data/arena-hard-v2.0/question.jsonl`, and writes model answers and
	# judgments back under the same tree -- so it needs a writable copy next to the cwd we give
	# it, not the read-only upstream bind. Upstream gets this for free because run_task.sh copies
	# the task directory into the agent's workspace and runs there; our evaluation phase runs
	# from out_dir. The other benchmarks pull their data from the HF cache and do not care.
	if (evaluation_code := task_src / "evaluation_code").is_dir():
	shutil.copytree(evaluation_code, out_dir / "evaluation_code", dirs_exist_ok=True)

	# OPENAI_BASE_URL points the LLM-graded benchmarks at the local vLLM judge pool
	# (scripts/ptb_judge_pool.sbatch) because api.openai.com is unreachable from the aws cluster.
	# Both graders build their client with no explicit base_url -- healthbench's
	# evaluation_code/grader.py `OpenAI(api_key=...)` and arenahardwriting's `openai.OpenAI()` --
	# so the SDK picks the variable up and no upstream code has to change. This sandbox runs
	# without `--net`, so it shares the host's network namespace and can reach a loopback
	# balancer directly; the agent phase has to tunnel the same traffic over a unix socket.
	# The variable is dropped when empty: the SDK treats "" as a real base URL and every request
	# would fail, whereas an absent variable falls back to the public API.

	# arenahardwriting's evaluate.py calls tiktoken.encoding_for_model("gpt-4o") to count tokens,
	# which on a cache miss fetches o200k_base.tiktoken from openaipublic.blob.core.windows.net --
	# unreachable from the aws login node (same Azure blob host as huggingface.co; SSL EOF, 9/9 attempts
	# failed). tiktoken keys its on-disk cache by sha1(blobpath), so dropping the file in under
	# that name short-circuits the fetch entirely; scripts/tiktoken_cache holds a copy recovered
	# from an earlier run's cache dir, content-hash-verified against the known-good file.
	tiktoken_cache = out_dir / "tiktoken_cache"
	shutil.copytree(config.REPO_ROOT / "scripts/tiktoken_cache", tiktoken_cache, dirs_exist_ok=True)

	with judge_balancer(config.judge_pool_targets()) as pool_url:
	base_url = os.environ.get("OPENAI_BASE_URL") or pool_url
	env = {"OPENAI_API_KEY": os.environ.get("OPENAI_API_KEY", "") or ("EMPTY" if base_url else ""),
	"OPENAI_BASE_URL": base_url,
	"HF_TOKEN": os.environ.get("HF_TOKEN", ""),
	"TIKTOKEN_CACHE_DIR": str(tiktoken_cache)}
	env = {k: v for k, v in env.items() if v or k == "OPENAI_API_KEY"}

	for n, extra_args in enumerate(attempts(task), start=1):
	print(f"Evaluation attempt {n} {' '.join(extra_args)}")
	sandbox.run(
	["python", str(task_src / "evaluate.py"), "--model-path", model, "--limit", str(limit),
	"--templates-dir", str(config.UPSTREAM / "src/eval/templates"),
	"--json-output-file", str(metrics_file), *extra_args],
	scratch=scratch, hf_cache=config.HF_CACHE, binds=binds, workdir=str(out_dir),
	container=config.EVAL_CONTAINER, env=env,
	timeout_minutes=timeout_minutes, log=out_dir / f"final_eval_{n}.txt",
	)
	if metrics_file.is_file():
	break
	shutil.rmtree(scratch)
	return json.loads(metrics_file.read_text()) if metrics_file.is_file() else None