| """Eval: nvidia/NVIDIA-Nemotron-Labs-Dory1.0-4B-BF16 on 60 MATH-500 problems at 1/2/4 loops. |
| |
| Serves the model with vLLM (PR #60149) once per loop count, sends the same 60 |
| problems, records accuracy / per-problem latency / generated tokens, pushes |
| incremental results and plots to ysharma/dory1-4b-math500-loop-eval. |
| """ |
| import asyncio |
| import json |
| import os |
| import re |
| import subprocess |
| import sys |
| import time |
| import urllib.request |
|
|
| MODEL = "nvidia/NVIDIA-Nemotron-Labs-Dory1.0-4B-BF16" |
| RESULTS_REPO = "ysharma/dory1-4b-math500-loop-eval" |
| LOOP_COUNTS = [1, 2, 4] |
| N_PROBLEMS = 60 |
| SAMPLE_SEED = 42 |
| CONCURRENCY = 8 |
| MAX_TOKENS = 11264 |
| MAX_MODEL_LEN = 12288 |
| TEMPERATURE = 1.0 |
| TOP_P = 0.95 |
| REQ_SEED = 1234 |
| PORT = 8000 |
| BASE_URL = f"http://127.0.0.1:{PORT}/v1" |
| OUT_DIR = "/app/results" |
| HEALTH_TIMEOUT_S = 900 |
| REQ_TIMEOUT_S = 1500 |
|
|
| os.makedirs(OUT_DIR, exist_ok=True) |
|
|
| |
| import torch |
|
|
| assert torch.cuda.is_available(), "No CUDA GPU visible — refusing to run on CPU" |
| print(f"[env] GPU: {torch.cuda.get_device_name(0)}, " |
| f"{torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB", flush=True) |
|
|
| from datasets import load_dataset |
| ds = load_dataset("HuggingFaceH4/MATH-500", split="test") |
| assert len(ds) == 500, f"expected 500 MATH-500 rows, got {len(ds)}" |
| assert "problem" in ds.column_names and "answer" in ds.column_names |
| sample = ds.shuffle(seed=SAMPLE_SEED).select(range(N_PROBLEMS)) |
| problems = [{"unique_id": r["unique_id"], "problem": r["problem"], "answer": r["answer"], |
| "level": r["level"], "subject": r["subject"]} for r in sample] |
| assert all(p["answer"].strip() for p in problems) |
| levels = {} |
| for p in problems: |
| levels[p["level"]] = levels.get(p["level"], 0) + 1 |
| print(f"[data] {len(problems)} problems (seed {SAMPLE_SEED}), level mix: {levels}", flush=True) |
| with open(f"{OUT_DIR}/sample_problems.json", "w") as f: |
| json.dump(problems, f, indent=2) |
|
|
| |
| from math_verify import parse as mv_parse, verify as mv_verify |
|
|
| BOXED_RE = re.compile(r"\\boxed\{") |
|
|
|
|
| def extract_boxed(text): |
| """Return the last \\boxed{...} with balanced braces, or None.""" |
| best = None |
| for m in BOXED_RE.finditer(text): |
| i = m.end() |
| depth = 1 |
| while i < len(text) and depth > 0: |
| if text[i] == "{": |
| depth += 1 |
| elif text[i] == "}": |
| depth -= 1 |
| i += 1 |
| if depth == 0: |
| best = text[m.end():i - 1] |
| return best |
|
|
|
|
| def grade(pred_text, gold_answer): |
| """True/False/None (None = could not grade).""" |
| try: |
| gold = mv_parse("$" + gold_answer + "$") |
| if not gold: |
| gold = mv_parse(gold_answer) |
| except Exception: |
| return None |
| if not gold: |
| return None |
| for cand in (pred_text, extract_boxed(pred_text)): |
| if not cand: |
| continue |
| try: |
| parsed = mv_parse(cand) |
| if parsed: |
| return bool(mv_verify(gold, parsed)) |
| except Exception: |
| continue |
| return None |
|
|
|
|
| |
| def server_cmd(n_loops, kv_mode): |
| overrides = json.dumps({"n_recurrent_loops": n_loops, |
| "recurrent_kv_cache_mode": kv_mode}) |
| return ["vllm", "serve", MODEL, |
| "--port", str(PORT), |
| "--hf-overrides", overrides, |
| "--max-model-len", str(MAX_MODEL_LEN), |
| "--max-num-seqs", "16", |
| "--gpu-memory-utilization", "0.90", |
| "--reasoning-parser", "nemotron_v3"] |
|
|
|
|
| def dump_log_tail(log_path, nbytes=20000): |
| with open(log_path, "rb") as f: |
| f.seek(0, 2) |
| size = f.tell() |
| f.seek(max(0, size - nbytes)) |
| print(f"[server-log tail {log_path}]\n{f.read().decode(errors='replace')}\n", flush=True) |
|
|
|
|
| def start_server(n_loops, log_path): |
| """Launch vLLM at n_loops. Try per_loop KV (card's benchmarked mode); if the |
| engine fails KV profiling, retry once with last_loop (card: accuracy close, |
| output lengths nearly unchanged) and record which mode was used.""" |
| for kv_mode in ("per_loop", "last_loop"): |
| cmd = server_cmd(n_loops, kv_mode) |
| print(f"[server] launching ({kv_mode}): {' '.join(cmd)}", flush=True) |
| log = open(log_path, "w") |
| proc = subprocess.Popen(cmd, stdout=log, stderr=subprocess.STDOUT) |
| t0 = time.time() |
| while time.time() - t0 < HEALTH_TIMEOUT_S: |
| if proc.poll() is not None: |
| log.close() |
| print(f"[server] vLLM exited early at {n_loops} loops, kv_mode={kv_mode}", flush=True) |
| dump_log_tail(log_path) |
| if kv_mode == "per_loop": |
| print("[server] retrying with recurrent_kv_cache_mode=last_loop", flush=True) |
| break |
| raise RuntimeError(f"vLLM server failed at {n_loops} loops even with last_loop KV") |
| try: |
| with urllib.request.urlopen(f"http://127.0.0.1:{PORT}/health", timeout=5) as r: |
| if r.status == 200: |
| print(f"[server] healthy after {time.time()-t0:.0f}s " |
| f"(n_recurrent_loops={n_loops}, kv_mode={kv_mode})", flush=True) |
| return proc, log, kv_mode |
| except Exception: |
| time.sleep(5) |
| if time.time() - t0 >= HEALTH_TIMEOUT_S: |
| proc.kill() |
| raise RuntimeError(f"vLLM health check timed out after {HEALTH_TIMEOUT_S}s at {n_loops} loops") |
| raise RuntimeError("unreachable") |
|
|
|
|
| |
| async def run_batch(problems, n_loops, kv_mode): |
| from openai import AsyncOpenAI |
| client = AsyncOpenAI(base_url=BASE_URL, api_key="EMPTY") |
| sem = asyncio.Semaphore(CONCURRENCY) |
|
|
| async def one(p): |
| async with sem: |
| t0 = time.perf_counter() |
| try: |
| resp = await asyncio.wait_for( |
| client.chat.completions.create( |
| model=MODEL, |
| messages=[{"role": "user", "content": p["problem"]}], |
| max_tokens=MAX_TOKENS, |
| temperature=TEMPERATURE, |
| top_p=TOP_P, |
| seed=REQ_SEED, |
| ), |
| timeout=REQ_TIMEOUT_S) |
| except Exception as e: |
| return {"unique_id": p["unique_id"], "level": p["level"], |
| "loops": n_loops, "kv_mode": kv_mode, "error": f"{type(e).__name__}: {e}", |
| "latency_s": time.perf_counter() - t0, |
| "completion_tokens": None, "correct": None, |
| "finish_reason": "error", "truncated": False} |
| dt = time.perf_counter() - t0 |
| msg = resp.choices[0] |
| content = msg.message.content or "" |
| reasoning = getattr(msg.message, "reasoning_content", None) or "" |
| n_completion = resp.usage.completion_tokens if resp.usage else None |
| truncated = msg.finish_reason == "length" |
| correct = grade(content, p["answer"]) if not truncated else False |
| if correct is None: |
| correct = grade(reasoning, p["answer"]) |
| return {"unique_id": p["unique_id"], "level": p["level"], "loops": n_loops, |
| "kv_mode": kv_mode, |
| "latency_s": round(dt, 2), "completion_tokens": n_completion, |
| "n_reasoning_chars": len(reasoning), "n_content_chars": len(content), |
| "finish_reason": msg.finish_reason, "truncated": truncated, |
| "predicted": extract_boxed(content), "gold": p["answer"], |
| "correct": correct} |
|
|
| t0 = time.perf_counter() |
| results = await asyncio.gather(*(one(p) for p in problems)) |
| wall = time.perf_counter() - t0 |
| errors = sum(1 for r in results if r.get("error")) |
| print(f"[eval] {n_loops} loops: 60 requests done in {wall:.0f}s " |
| f"({errors} request errors)", flush=True) |
| return results, wall |
|
|
|
|
| def push_to_hub(local_path, path_in_repo): |
| from huggingface_hub import HfApi |
| HfApi().upload_file(path_or_fileobj=local_path, path_in_repo=path_in_repo, |
| repo_id=RESULTS_REPO, repo_type="dataset", |
| commit_message=f"eval results: {path_in_repo}") |
| print(f"[push] {path_in_repo} -> {RESULTS_REPO}", flush=True) |
|
|
|
|
| |
| async def main(): |
| all_results = {} |
| for n_loops in LOOP_COUNTS: |
| log_path = f"{OUT_DIR}/server_loops{n_loops}.log" |
| proc, log, kv_mode = start_server(n_loops, log_path) |
| try: |
| |
| smoke, _ = await run_batch(problems[:2], n_loops, kv_mode) |
| if any(r.get("error") for r in smoke): |
| raise RuntimeError(f"smoke requests failed at {n_loops} loops: {smoke}") |
| results, wall = await run_batch(problems, n_loops, kv_mode) |
| all_results[n_loops] = results |
| with open(f"{OUT_DIR}/results_loops{n_loops}.jsonl", "w") as f: |
| for r in results: |
| f.write(json.dumps(r) + "\n") |
| push_to_hub(f"{OUT_DIR}/results_loops{n_loops}.jsonl", f"results/results_loops{n_loops}.jsonl") |
| acc = [r["correct"] for r in results if r["correct"] is not None] |
| toks = [r["completion_tokens"] for r in results if r["completion_tokens"]] |
| lat = [r["latency_s"] for r in results if not r.get("error")] |
| print(f"[summary] loops={n_loops}: accuracy={sum(acc)}/{len(acc)}" |
| f" mean_tokens={sum(toks)/len(toks):.0f}" |
| f" median_tokens={sorted(toks)[len(toks)//2]}" |
| f" mean_latency={sum(lat)/len(lat):.1f}s" |
| f" batch_wall={wall:.0f}s" |
| f" truncated={sum(1 for r in results if r['truncated'])}", flush=True) |
| finally: |
| proc.terminate() |
| try: |
| proc.wait(timeout=30) |
| except subprocess.TimeoutExpired: |
| proc.kill() |
| log.close() |
| time.sleep(10) |
|
|
| |
| summary = {} |
| for n_loops, results in all_results.items(): |
| acc = [r["correct"] for r in results if r["correct"] is not None] |
| toks = [r["completion_tokens"] for r in results if r["completion_tokens"]] |
| lat = [r["latency_s"] for r in results if not r.get("error")] |
| summary[n_loops] = { |
| "n_graded": len(acc), |
| "accuracy": sum(acc) / len(acc) if acc else None, |
| "mean_completion_tokens": sum(toks) / len(toks) if toks else None, |
| "median_completion_tokens": sorted(toks)[len(toks) // 2] if toks else None, |
| "mean_latency_s": sum(lat) / len(lat) if lat else None, |
| "n_truncated": sum(1 for r in results if r["truncated"]), |
| "n_request_errors": sum(1 for r in results if r.get("error")), |
| } |
|
|
| print("\n===== SUMMARY (60 MATH-500 problems, Dory1.0-4B BF16) =====", flush=True) |
| for n in LOOP_COUNTS: |
| s = summary[n] |
| print(f"loops={n}: accuracy={s['accuracy']*100:.1f}% " |
| f"mean_out_tokens={s['mean_completion_tokens']:.0f} " |
| f"median_out_tokens={s['median_completion_tokens']} " |
| f"mean_latency={s['mean_latency_s']:.1f}s " |
| f"truncated={s['n_truncated']} errors={s['n_request_errors']}", flush=True) |
|
|
| if 1 in summary and 4 in summary and summary[1]["mean_completion_tokens"] and summary[4]["mean_completion_tokens"]: |
| ratio = summary[4]["mean_completion_tokens"] / summary[1]["mean_completion_tokens"] |
| verdict = "card claim SUPPORTED" if ratio < 1 else "card claim NOT supported on this subset" |
| print(f"[claim] mean output tokens, 4 loops vs 1 loop: {ratio:.2f}x ({verdict})", flush=True) |
|
|
| with open(f"{OUT_DIR}/summary.json", "w") as f: |
| json.dump(summary, f, indent=2) |
| push_to_hub(f"{OUT_DIR}/summary.json", "results/summary.json") |
| push_to_hub(f"{OUT_DIR}/sample_problems.json", "results/sample_problems.json") |
|
|
| import matplotlib |
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
|
|
| xs = [n for n in LOOP_COUNTS if n in summary] |
| fig, axes = plt.subplots(1, 3, figsize=(15, 4.5)) |
| axes[0].plot(xs, [summary[n]["accuracy"] * 100 for n in xs], "o-") |
| axes[0].set_ylabel("accuracy (%)") |
| axes[1].plot(xs, [summary[n]["mean_latency_s"] for n in xs], "s-", color="tab:orange") |
| axes[1].set_ylabel("mean latency per problem (s)") |
| axes[2].plot(xs, [summary[n]["mean_completion_tokens"] for n in xs], "^-", color="tab:green") |
| axes[2].set_ylabel("mean output tokens") |
| for ax in axes: |
| ax.set_xlabel("recurrent loops") |
| ax.set_xticks(xs) |
| fig.suptitle("Dory1.0-4B BF16 — 60 MATH-500 problems (seed 42, temp 1.0, top-p 0.95)") |
| fig.tight_layout() |
| fig.savefig(f"{OUT_DIR}/dory_math500_loops.png", dpi=150) |
| push_to_hub(f"{OUT_DIR}/dory_math500_loops.png", "dory_math500_loops.png") |
| print("[done] all results pushed", flush=True) |
|
|
|
|
| asyncio.run(main()) |
|
|
