| """ResearchBench command line interface.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import sys |
| import threading |
| import time |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
| from pathlib import Path |
| from typing import Any, Callable |
|
|
| from .builders import build_all, validate_data_dir |
| from .clients import ModelClient, make_client |
| from .data_io import iter_jsonl, read_json, write_json, write_jsonl |
| from .generation import estimate_generation_model_calls, generation_score_prompt, parse_matched_score, run_generation_record |
| from .ranking import run_ranking_record, score_ranking |
| from .retrieve import run_retrieve_record, score_retrieve |
|
|
|
|
| RANKING_ORDER_ALIASES = { |
| "res": "res", |
| "gold-first": "res", |
| "fan_1_res": "fan_1_res", |
| "negative-first": "fan_1_res", |
| "both": "both", |
| } |
|
|
|
|
| def _load_jsonl(path: str | Path) -> list[dict[str, Any]]: |
| return list(iter_jsonl(path)) |
|
|
|
|
| def _progress(label: str, done: int, total: int, started_at: float) -> None: |
| if total <= 0: |
| return |
| width = 28 |
| ratio = done / total |
| filled = int(width * ratio) |
| elapsed = max(time.time() - started_at, 1e-6) |
| rate = done / elapsed if done else 0.0 |
| eta = (total - done) / rate if rate else 0.0 |
| bar = "#" * filled + "." * (width - filled) |
| sys.stderr.write(f"\r{label} [{bar}] {done}/{total} {ratio:6.1%} | {rate:5.2f}/s | ETA {eta:5.1f}s") |
| if done >= total: |
| sys.stderr.write("\n") |
| sys.stderr.flush() |
|
|
|
|
| class ProgressTracker: |
| def __init__(self, label: str, total: int, *, min_interval: float = 0.1) -> None: |
| self.label = label |
| self.total = max(total, 1) |
| self.done = 0 |
| self.started_at = time.time() |
| self.min_interval = min_interval |
| self._last_rendered_at = 0.0 |
| self._last_rendered_done = -1 |
| self._last_rendered_total = -1 |
| self._lock = threading.Lock() |
| self._render(force=True) |
|
|
| def _render(self, *, force: bool = False) -> None: |
| now = time.time() |
| if not force and self.done < self.total and now - self._last_rendered_at < self.min_interval: |
| return |
| if not force and self.done == self._last_rendered_done: |
| return |
| _progress(self.label, self.done, self.total, self.started_at) |
| self._last_rendered_at = now |
| self._last_rendered_done = self.done |
| self._last_rendered_total = self.total |
|
|
| def advance(self, amount: int = 1) -> None: |
| with self._lock: |
| self.done += amount |
| if self.done > self.total: |
| self.total = self.done |
| self._render(force=self.done >= self.total) |
|
|
| def finish(self) -> None: |
| with self._lock: |
| if self.done < self.total: |
| self.total = self.done or self.total |
| if self.done != self._last_rendered_done or self.total != self._last_rendered_total: |
| self._render(force=True) |
|
|
|
|
| class ProgressModelClient(ModelClient): |
| def __init__(self, get_client: Callable[[], ModelClient], tracker: ProgressTracker, *, is_mock: bool = False) -> None: |
| self._get_client = get_client |
| self._tracker = tracker |
| self.is_mock = is_mock |
|
|
| def generate(self, prompt: str, *, temperature: float = 0.0) -> str: |
| try: |
| return self._get_client().generate(prompt, temperature=temperature) |
| finally: |
| self._tracker.advance() |
|
|
|
|
| def _run_with_progress( |
| rows: list[dict[str, Any]], |
| worker: Callable[[dict[str, Any]], dict[str, Any]], |
| *, |
| label: str, |
| concurrency: int, |
| ) -> list[dict[str, Any]]: |
| total = len(rows) |
| if total == 0: |
| return [] |
| concurrency = max(1, concurrency) |
| started_at = time.time() |
| _progress(label, 0, total, started_at) |
| results: list[dict[str, Any] | None] = [None] * total |
| if concurrency == 1: |
| for idx, row in enumerate(rows): |
| try: |
| results[idx] = worker(row) |
| except Exception as exc: |
| sample_id = row.get("sample_id", f"row-{idx}") |
| raise RuntimeError(f"{label} failed on sample {sample_id}") from exc |
| _progress(label, idx + 1, total, started_at) |
| else: |
| with ThreadPoolExecutor(max_workers=concurrency) as executor: |
| future_to_item = {executor.submit(worker, row): (idx, row) for idx, row in enumerate(rows)} |
| done = 0 |
| for future in as_completed(future_to_item): |
| idx, row = future_to_item[future] |
| try: |
| results[idx] = future.result() |
| except Exception as exc: |
| sample_id = row.get("sample_id", f"row-{idx}") |
| raise RuntimeError(f"{label} failed on sample {sample_id}") from exc |
| done += 1 |
| _progress(label, done, total, started_at) |
| return [item for item in results if item is not None] |
|
|
|
|
| def _run_ordered_concurrent( |
| rows: list[dict[str, Any]], |
| worker: Callable[[dict[str, Any]], dict[str, Any]], |
| *, |
| label: str, |
| concurrency: int, |
| ) -> list[dict[str, Any]]: |
| total = len(rows) |
| if total == 0: |
| return [] |
| concurrency = max(1, concurrency) |
| results: list[dict[str, Any] | None] = [None] * total |
| if concurrency == 1: |
| for idx, row in enumerate(rows): |
| try: |
| results[idx] = worker(row) |
| except Exception as exc: |
| sample_id = row.get("sample_id", f"row-{idx}") |
| raise RuntimeError(f"{label} failed on sample {sample_id}") from exc |
| else: |
| with ThreadPoolExecutor(max_workers=concurrency) as executor: |
| future_to_item = {executor.submit(worker, row): (idx, row) for idx, row in enumerate(rows)} |
| for future in as_completed(future_to_item): |
| idx, row = future_to_item[future] |
| try: |
| results[idx] = future.result() |
| except Exception as exc: |
| sample_id = row.get("sample_id", f"row-{idx}") |
| raise RuntimeError(f"{label} failed on sample {sample_id}") from exc |
| return [item for item in results if item is not None] |
|
|
|
|
| def _thread_local_client_getter(model: str, api_key: str | None, base_url: str | None): |
| local = threading.local() |
|
|
| def get_client(): |
| client = getattr(local, "client", None) |
| if client is None: |
| client = make_client(model, api_key=api_key, base_url=base_url) |
| local.client = client |
| return client |
|
|
| return get_client |
|
|
|
|
| def _format_ratio(value: float) -> str: |
| return f"{value:.4f} ({value:.2%})" |
|
|
|
|
| def _print_retrieve_summary(summary: dict[str, Any]) -> None: |
| label_names = { |
| "gold": "Gold inspiration hit ratio", |
| "negative_t1": "Negative tier 1 selection ratio", |
| "negative_t2": "Negative tier 2 selection ratio", |
| "negative_t3": "Negative tier 3 selection ratio", |
| "negative_unknown": "Unknown-label candidate selection ratio", |
| } |
| round_names = { |
| "round1": "Round 1: kept 15 of 75 candidates", |
| "round2": "Round 2: kept 3 of 75 candidates", |
| } |
| print("Retrieve score summary") |
| for round_id in ("round1", "round2"): |
| if round_id not in summary: |
| continue |
| print(f"- {round_names.get(round_id, round_id)}") |
| for label, value in sorted(summary[round_id].items()): |
| name = label_names.get(label, label) |
| print(f" - {name}: {_format_ratio(float(value))}") |
|
|
|
|
| def _print_generation_summary(summary: dict[str, Any]) -> None: |
| print("Hypothesis generation score summary") |
| print(f"- Scored samples: {summary.get('count', 0)}") |
| print(f"- Average matched score (0-5): {float(summary.get('average_score', 0.0)):.4f}") |
| print(f"- Generation accuracy (average score / 5): {_format_ratio(float(summary.get('accuracy', 0.0)))}") |
|
|
|
|
| def _print_ranking_summary(summary: dict[str, Any]) -> None: |
| order_names = { |
| "res": "Gold-first order accuracy (gold is candidate 1)", |
| "fan_1_res": "Negative-first order accuracy (gold is candidate 2)", |
| } |
| sum_names = { |
| "0": "Gold wins in neither order", |
| "1": "Gold wins in exactly one order", |
| "2": "Gold wins in both orders", |
| } |
| pair_names = { |
| "both_correct": "Both orders choose gold", |
| "self_contradictory": "Orders disagree", |
| "both_wrong": "Both orders choose negative", |
| } |
| print("Hypothesis ranking score summary") |
| print(f"- Overall directional accuracy: {_format_ratio(float(summary.get('overall_accuracy', 0.0)))}") |
| for order, value in summary.get("order_accuracy", {}).items(): |
| print(f"- {order_names.get(order, order)}: {_format_ratio(float(value))}") |
| if summary.get("sum_ratios"): |
| print("- Sample-level two-order outcomes") |
| for key in ("0", "1", "2"): |
| if key in summary["sum_ratios"]: |
| count = summary.get("sum_counts", {}).get(int(key), summary.get("sum_counts", {}).get(key, 0)) |
| print(f" - {sum_names[key]}: {_format_ratio(float(summary['sum_ratios'][key]))}; count={count}") |
| if summary.get("pair_ratios"): |
| print("- Pair-level order-consistency outcomes") |
| for key in ("both_correct", "self_contradictory", "both_wrong"): |
| if key in summary["pair_ratios"]: |
| count = summary.get("pair_counts", {}).get(key, 0) |
| print(f" - {pair_names[key]}: {_format_ratio(float(summary['pair_ratios'][key]))}; count={count}") |
|
|
|
|
| def _print_build_summary(summary: dict[str, Any], out_dir: str | Path) -> None: |
| print("Data build summary") |
| print(f"- Papers: {summary.get('papers', 0)}") |
| print(f"- Retrieve tasks: {summary.get('retrieve', 0)}") |
| print(f"- Generation tasks: {summary.get('generation', 0)}") |
| print(f"- Ranking tasks: {summary.get('ranking', 0)}") |
| print(f"- Retrieve build issues: {summary.get('retrieve_issues', 0)}") |
| print(f"- Ranking build issues: {summary.get('ranking_issues', 0)}") |
| print(f"- Validation reports: {Path(out_dir) / 'validation'}") |
|
|
|
|
| def cmd_build_data(args: argparse.Namespace) -> int: |
| summary = build_all(args.source_root, args.out) |
| _print_build_summary(summary, args.out) |
| return 0 |
|
|
|
|
| def cmd_validate(args: argparse.Namespace) -> int: |
| ok, issues = validate_data_dir(args.data_dir) |
| if ok: |
| print("Validation passed.") |
| return 0 |
| report = Path(args.data_dir) / "validation" / "validation_issues.csv" |
| print(f"Validation failed with {len(issues)} issue(s). See {report}.") |
| return 1 |
|
|
|
|
| def cmd_run_retrieve(args: argparse.Namespace) -> int: |
| rows = _load_jsonl(args.data) |
| get_client = _thread_local_client_getter(args.model, args.api_key, args.base_url) |
| preds = _run_with_progress( |
| rows, |
| lambda row: {**run_retrieve_record(row, get_client()), "model": args.model}, |
| label="retrieve samples", |
| concurrency=args.concurrency, |
| ) |
| write_jsonl(args.out, preds) |
| print(f"Wrote {len(preds)} retrieve predictions to {args.out}") |
| return 0 |
|
|
|
|
| def cmd_score_retrieve(args: argparse.Namespace) -> int: |
| result = score_retrieve(_load_jsonl(args.pred), _load_jsonl(args.data)) |
| out = args.out or Path(args.pred).with_suffix(".score.json") |
| write_json(out, result) |
| _print_retrieve_summary(result["summary"]) |
| return 0 |
|
|
|
|
| def cmd_run_generate(args: argparse.Namespace) -> int: |
| rows = _load_jsonl(args.data) |
| get_client = _thread_local_client_getter(args.model, args.api_key, args.base_url) |
| estimated_calls = sum( |
| estimate_generation_model_calls( |
| row, |
| num_mutations=args.num_mutations, |
| num_itr_self_refine=args.num_itr_self_refine, |
| max_inspiration_search_steps=args.max_inspiration_search_steps, |
| num_screening_window_size=args.num_screening_window_size, |
| num_screening_keep_size=args.num_screening_keep_size, |
| recom_num_beam_size=args.recom_num_beam_size, |
| ) |
| for row in rows |
| ) |
| tracker = ProgressTracker("generation API calls", estimated_calls) |
|
|
| def make_progress_client() -> ModelClient: |
| return ProgressModelClient(get_client, tracker, is_mock=args.model == "mock") |
|
|
| def worker(row: dict[str, Any]) -> dict[str, Any]: |
| return { |
| **run_generation_record( |
| row, |
| make_progress_client(), |
| num_mutations=args.num_mutations, |
| num_itr_self_refine=args.num_itr_self_refine, |
| max_inspiration_search_steps=args.max_inspiration_search_steps, |
| use_background_survey=args.use_background_survey, |
| num_screening_window_size=args.num_screening_window_size, |
| num_screening_keep_size=args.num_screening_keep_size, |
| recom_num_beam_size=args.recom_num_beam_size, |
| inner_concurrency=args.inner_concurrency, |
| client_factory=make_progress_client, |
| ), |
| "model": args.model, |
| } |
|
|
| try: |
| preds = _run_ordered_concurrent(rows, worker, label="generate", concurrency=args.concurrency) |
| finally: |
| tracker.finish() |
| write_jsonl(args.out, preds) |
| print(f"Wrote {len(preds)} generation predictions to {args.out}") |
| return 0 |
|
|
|
|
| def cmd_score_generate(args: argparse.Namespace) -> int: |
| predictions = _load_jsonl(args.pred) |
| data = _load_jsonl(args.data) |
| result = _score_generation_concurrent( |
| predictions, |
| data, |
| judge_model=args.judge_model, |
| api_key=args.api_key, |
| base_url=args.base_url, |
| concurrency=args.concurrency, |
| ) |
| out = args.out or Path(args.pred).with_suffix(".score.json") |
| write_json(out, result) |
| _print_generation_summary(result["summary"]) |
| return 0 |
|
|
|
|
| def cmd_run_rank(args: argparse.Namespace) -> int: |
| rows = _load_jsonl(args.data) |
| get_client = _thread_local_client_getter(args.model, args.api_key, args.base_url) |
| order = RANKING_ORDER_ALIASES[args.order] |
| preds = _run_with_progress( |
| rows, |
| lambda row: {**run_ranking_record(row, get_client(), order=order), "model": args.model}, |
| label="ranking samples", |
| concurrency=args.concurrency, |
| ) |
| write_jsonl(args.out, preds) |
| print(f"Wrote {len(preds)} ranking predictions to {args.out}") |
| return 0 |
|
|
|
|
| def _score_generation_concurrent( |
| predictions: list[dict[str, Any]], |
| data: list[dict[str, Any]], |
| *, |
| judge_model: str, |
| api_key: str | None, |
| base_url: str | None, |
| concurrency: int, |
| ) -> dict[str, Any]: |
| data_by_id = {row["sample_id"]: row for row in data} |
| get_client = _thread_local_client_getter(judge_model, api_key, base_url) |
|
|
| def worker(pred: dict[str, Any]) -> dict[str, Any]: |
| record = data_by_id.get(pred.get("sample_id")) |
| if not record: |
| return {} |
| score = pred.get("matched_score") |
| reason = pred.get("matched_score_reason", "") |
| if score is None: |
| key_points = record.get("gold_key_points") or record["gold_hypothesis"] |
| response = get_client().generate( |
| generation_score_prompt(pred.get("final_hypothesis", ""), record["gold_hypothesis"], key_points), |
| temperature=0.0, |
| ) |
| score = parse_matched_score(response) |
| reason = response |
| if score is None: |
| return {} |
| score = float(score) |
| return { |
| "sample_id": pred["sample_id"], |
| "matched_score": score, |
| "accuracy": score / 5.0, |
| "reason": reason, |
| } |
|
|
| per_sample = [ |
| item |
| for item in _run_with_progress(predictions, worker, label="generation scoring", concurrency=concurrency) |
| if item |
| ] |
| scores = [item["matched_score"] for item in per_sample] |
| average_score = sum(scores) / len(scores) if scores else 0.0 |
| return { |
| "summary": { |
| "count": len(scores), |
| "average_score": average_score, |
| "accuracy": average_score / 5.0, |
| }, |
| "per_sample": per_sample, |
| } |
|
|
|
|
| def cmd_score_rank(args: argparse.Namespace) -> int: |
| result = score_ranking(_load_jsonl(args.pred)) |
| out = args.out or Path(args.pred).with_suffix(".score.json") |
| write_json(out, result) |
| _print_ranking_summary(result["summary"]) |
| return 0 |
|
|
|
|
| def build_parser() -> argparse.ArgumentParser: |
| parser = argparse.ArgumentParser(prog="researchbench") |
| sub = parser.add_subparsers(dest="command", required=True) |
|
|
| build = sub.add_parser("build-data") |
| build.add_argument("--source-root", required=True) |
| build.add_argument("--out", required=True) |
| build.set_defaults(func=cmd_build_data) |
|
|
| validate = sub.add_parser("validate") |
| validate.add_argument("data_dir") |
| validate.set_defaults(func=cmd_validate) |
|
|
| def add_model_args(p: argparse.ArgumentParser) -> None: |
| p.add_argument("--model", "--model-name", dest="model", required=True) |
| p.add_argument("--api-key") |
| p.add_argument("--base-url") |
| p.add_argument("--concurrency", type=int, default=15, help="number of samples to evaluate concurrently") |
| p.add_argument("--out", required=True) |
|
|
| run_retrieve = sub.add_parser("run-retrieve") |
| run_retrieve.add_argument("--data", required=True) |
| add_model_args(run_retrieve) |
| run_retrieve.set_defaults(func=cmd_run_retrieve) |
|
|
| score_retrieve_parser = sub.add_parser("score-retrieve") |
| score_retrieve_parser.add_argument("--pred", required=True) |
| score_retrieve_parser.add_argument("--data", required=True) |
| score_retrieve_parser.add_argument("--out") |
| score_retrieve_parser.set_defaults(func=cmd_score_retrieve) |
|
|
| run_generate = sub.add_parser("run-generate") |
| run_generate.add_argument("--data", required=True) |
| run_generate.add_argument("--num-mutations", type=int, default=2) |
| run_generate.add_argument("--num-itr-self-refine", type=int, default=2) |
| run_generate.add_argument("--max-inspiration-search-steps", type=int, default=3) |
| run_generate.add_argument("--use-background-survey", action="store_true") |
| run_generate.add_argument("--num-screening-window-size", type=int, default=12) |
| run_generate.add_argument("--num-screening-keep-size", type=int, default=3) |
| run_generate.add_argument("--recom-num-beam-size", type=int, default=15) |
| run_generate.add_argument( |
| "--inner-concurrency", |
| type=int, |
| default=1, |
| help="within-sample concurrency for independent generation branches", |
| ) |
| add_model_args(run_generate) |
| run_generate.set_defaults(func=cmd_run_generate) |
|
|
| score_generate_parser = sub.add_parser("score-generate") |
| score_generate_parser.add_argument("--pred", required=True) |
| score_generate_parser.add_argument("--data", required=True) |
| score_generate_parser.add_argument("--judge-model", required=True) |
| score_generate_parser.add_argument("--api-key") |
| score_generate_parser.add_argument("--base-url") |
| score_generate_parser.add_argument("--concurrency", type=int, default=15, help="number of samples to judge concurrently") |
| score_generate_parser.add_argument("--out") |
| score_generate_parser.set_defaults(func=cmd_score_generate) |
|
|
| run_rank = sub.add_parser("run-rank") |
| run_rank.add_argument("--data", required=True) |
| run_rank.add_argument( |
| "--order", |
| choices=["gold-first", "negative-first", "res", "fan_1_res", "both"], |
| default="both", |
| help=( |
| "comparison order: gold-first means gold is candidate 1; " |
| "negative-first means the negative hypothesis is candidate 1; both runs both orders" |
| ), |
| ) |
| add_model_args(run_rank) |
| run_rank.set_defaults(func=cmd_run_rank) |
|
|
| score_rank_parser = sub.add_parser("score-rank") |
| score_rank_parser.add_argument("--pred", required=True) |
| score_rank_parser.add_argument("--out") |
| score_rank_parser.set_defaults(func=cmd_score_rank) |
|
|
| return parser |
|
|
|
|
| def main(argv: list[str] | None = None) -> int: |
| parser = build_parser() |
| args = parser.parse_args(argv) |
| return args.func(args) |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
