"""Score a chat model on the OPUS-5.5-DATABASE `synth_eval` config (verifiable answers). python train/eval_synth.py --model HuggingFaceTB/SmolLM2-360M-Instruct --limit 300 Every item has a programmatically computed ground truth, so scoring is exact: numbers are compared numerically, JSON structurally, orderings/word lists as sequences, code is executed against unit tests, and "unanswerable" items must be refused. """ import argparse import json import os import re import subprocess import sys import tempfile from fractions import Fraction NUM = re.compile(r"-?\d+(?:[.,]\d+)?(?:/\d+)?") UNANSWERABLE = ("cannot be determined", "can't be determined", "not enough information", "insufficient information", "not possible to determine", "impossible to determine", "missing", "not given", "not specified", "cevaplanamaz", "bilinemez", "yeterli bilgi", "belirtilmemiş", "hesaplanamaz", "eksik") def final_segment(text): for marker in ("**Answer:**", "**Cevap:**", "Answer:", "Cevap:", "####", "\\boxed{"): if marker in text: return text.rsplit(marker, 1)[1] return text[-300:] def to_num(s): s = s.replace(",", ".") if s.count(",") == 1 and "." not in s else s.replace(",", "") try: return Fraction(s) except (ValueError, ZeroDivisionError): return None def numbers(s): return [x for x in (to_num(t) for t in NUM.findall(s)) if x is not None] def run_tests(code, tests): with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as fh: fh.write(code + "\n\n" + tests + "\n") try: return subprocess.run([sys.executable, "-I", fh.name], capture_output=True, timeout=10).returncode == 0 except subprocess.TimeoutExpired: return False finally: os.unlink(fh.name) def score(item, response): fam, ans = item["family"], item["answer"] seg = final_segment(response) if fam.startswith("code/"): blocks = re.findall(r"```(?:python)?\n(.*?)```", response, re.S) return any(run_tests(b, ans) for b in blocks[:2]) if fam.startswith("unanswerable/"): return any(p in response.lower() for p in UNANSWERABLE) if fam.startswith("json/"): m = re.search(r"\{.*\}", response, re.S) try: return json.dumps(json.loads(m.group(0)), ensure_ascii=False, sort_keys=True) == ans except (AttributeError, ValueError): return False if fam.startswith(("logic/", "strings/reverse", "strings/sort")): want = re.findall(r"\w+", ans.lower()) got = re.findall(r"\w+", seg.lower()) return " ".join(want) in " ".join(got) if fam.startswith("dates/weekday"): return all(w in seg.lower() for w in re.findall(r"\w+", ans.lower())) want = numbers(ans) got = numbers(seg) if not want: return ans.strip().lower() in seg.lower() if len(want) == 1: return bool(got) and any(abs(g - want[0]) <= Fraction(1, 100) for g in got[-3:]) return all(any(abs(g - w) <= Fraction(1, 100) for g in got) for w in want) def main(): ap = argparse.ArgumentParser() ap.add_argument("--model", required=True) ap.add_argument("--dataset", default="KeremTT/OPUS-5.5-DATABASE") ap.add_argument("--data-files", default=None, help="local parquet instead of the Hub dataset") ap.add_argument("--limit", type=int, default=0) ap.add_argument("--max-new-tokens", type=int, default=384) ap.add_argument("--batch", type=int, default=8) ap.add_argument("--out", default=None) a = ap.parse_args() import torch from datasets import load_dataset from transformers import AutoModelForCausalLM, AutoTokenizer ds = (load_dataset("parquet", data_files=a.data_files, split="train") if a.data_files else load_dataset(a.dataset, "synth_eval", split="test")) if a.limit: ds = ds.shuffle(seed=0).select(range(min(a.limit, len(ds)))) tok = AutoTokenizer.from_pretrained(a.model) tok.padding_side = "left" if tok.pad_token is None: tok.pad_token = tok.eos_token model = AutoModelForCausalLM.from_pretrained(a.model, torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32) model.to("cuda" if torch.cuda.is_available() else "cpu").eval() rows, correct = [], 0 items = list(ds) for i in range(0, len(items), a.batch): chunk = items[i:i + a.batch] prompts = [tok.apply_chat_template([{"role": "user", "content": it["prompt"]}], tokenize=False, add_generation_prompt=True) for it in chunk] enc = tok(prompts, return_tensors="pt", padding=True, add_special_tokens=False).to(model.device) with torch.no_grad(): out = model.generate(**enc, max_new_tokens=a.max_new_tokens, do_sample=False, pad_token_id=tok.pad_token_id) for it, seq in zip(chunk, out): resp = tok.decode(seq[enc["input_ids"].shape[1]:], skip_special_tokens=True) ok = score(it, resp) correct += ok rows.append({"id": it["id"], "family": it["family"], "language": it["language"], "correct": bool(ok), "response": resp}) print(f"{len(rows)}/{len(items)} acc={correct / len(rows):.3f}", flush=True) by_family = {} for r in rows: f = r["family"].split("/")[0] by_family.setdefault(f, []).append(r["correct"]) summary = {"model": a.model, "n": len(rows), "accuracy": correct / max(1, len(rows)), "by_family": {k: sum(v) / len(v) for k, v in sorted(by_family.items())}, "by_language": {lang: sum(r["correct"] for r in rows if r["language"] == lang) / max(1, sum(r["language"] == lang for r in rows)) for lang in ("en", "tr")}} print(json.dumps(summary, indent=2)) if a.out: json.dump({"summary": summary, "rows": rows}, open(a.out, "w"), indent=2, ensure_ascii=False) if __name__ == "__main__": main()