| """One evaluation harness for the base model (this job) and every training run (in-loop evals and the final |
| test run inside tdprm.rl.train on the trainer's colocated vLLM engine, via run_sets). |
| |
| python -m tdprm.sampling.evaluate --model <hf dir or hub id> --name <run>/<step> \ |
| --sets math500 gsm8k hotpotqa_val [--samples 8] |
| |
| Greedy accuracy on every set (in-domain and cross-domain), plus mean@k / pass@k with k sampled |
| completions at temperature 1.0 when --samples > 0. Writes $TDPRM_HOME/evals/<name>.json and the |
| per-sample generations next to it. |
| """ |
|
|
| import argparse |
| import json |
| from collections import defaultdict |
|
|
| import numpy as np |
|
|
| from .. import paths |
| from ..data.prepare import read_jsonl |
| from ..data.segment import segment |
| from .generate import generate, load_llm, render_prompt_ids, verify_all, write_jsonl_gz |
|
|
| MAX_RESPONSE = {"math500": 1024, "gsm8k": 1024, "hotpotqa_val": 768, "proverqa_val": 1024, "proverqa_easy": 1024, |
| "proverqa_medium": 1024, "proverqa_hard": 1024} |
|
|
|
|
| def summarize(records, samples, results, k): |
| per = defaultdict(list) |
| for (i, j), res in zip(samples, results): |
| per[i].append(res["score"]) |
| scores = [per[i] for i in range(len(records))] |
| out = {"n": len(records), "mean": float(np.mean([np.mean(s) for s in scores]))} |
| if k > 1: |
| out[f"pass@{k}"] = float(np.mean([max(s) for s in scores])) |
| return out |
|
|
|
|
| def run_sets(gen, tok, sets, samples, seed, verify=verify_all, limit=None): |
| """Greedy (+ `samples` sampled at T=1.0) generations on every set, verified and summarized. |
| gen(prompt_ids, n, temperature, max_tokens, seed) -> per prompt [(token_ids, text, finish_reason)]. |
| Returns (report {set: {mode: stats}}, per-sample dump rows).""" |
| report, dump = {}, [] |
| for name in sets: |
| records = read_jsonl(paths.DATA / "eval" / f"{name}.jsonl")[:limit] |
| prompt_ids = [render_prompt_ids(tok, r) for r in records] |
| modes = [("greedy", 1, 0.0)] + ([("sampled", samples, 1.0)] if samples > 0 else []) |
| report[name] = {} |
| for mode, n, temp in modes: |
| outs = gen(prompt_ids, n, temp, MAX_RESPONSE[name], seed) |
| index, texts = [], [] |
| for i, samples_i in enumerate(outs): |
| for j, (ids, text, finish) in enumerate(samples_i): |
| index.append((i, j)) |
| texts.append(text) |
| dump.append({"set": name, "mode": mode, "id": records[i]["id"], "sample": j, "text": text, |
| "finish": finish, "length": len(ids)}) |
| results = verify([records[i]["data_source"] for i, _ in index], texts, |
| [records[i]["answer"] for i, _ in index]) |
| for row, res in zip(dump[-len(texts):], results): |
| row["score"] = res["score"] |
| segs = [segment(t) for t in texts] |
| stats = summarize(records, index, results, n) |
| stats.update({"response_tokens": float(np.mean([d["length"] for d in dump[-len(texts):]])), |
| "steps": float(np.mean([s.num_steps for s in segs])), |
| "marker_rate": float(np.mean([s.marker_found for s in segs])), |
| "answer_rate": float(np.mean([r.get("has_answer", 1.0) for r in results])), |
| "truncated_rate": float(np.mean([d["finish"] == "length" for d in dump[-len(texts):]]))}) |
| report[name][mode] = stats |
| print(name, mode, json.dumps(stats), flush=True) |
| return report, dump |
|
|
|
|
| def write_report(name, report, dump): |
| out = paths.EVALS / f"{name}.json" |
| out.parent.mkdir(parents=True, exist_ok=True) |
| out.write_text(json.dumps(report, indent=2)) |
| write_jsonl_gz(out.with_suffix(".samples.jsonl.gz"), dump) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--model", required=True) |
| parser.add_argument("--name", required=True) |
| parser.add_argument("--sets", nargs="+", default=["math500", "gsm8k", "hotpotqa_val"]) |
| parser.add_argument("--samples", type=int, default=0) |
| parser.add_argument("--seed", type=int, default=1234) |
| parser.add_argument("--tp", type=int, default=1) |
| args = parser.parse_args() |
| from transformers import AutoTokenizer |
| tok = AutoTokenizer.from_pretrained(args.model) |
| llm = load_llm(args.model, 4096, tensor_parallel_size=args.tp, seed=args.seed) |
| report, dump = run_sets(lambda ids, n, temp, max_tokens, seed: generate(llm, ids, n, temp, 1.0, max_tokens, seed), |
| tok, args.sets, args.samples, args.seed) |
| write_report(args.name, {"model": args.model, "name": args.name, **report}, dump) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
