OPUS-5.5-DATABASE / code /train /eval_synth.py
KeremTT's picture
Update code
c02657c verified
Raw History Blame Contribute Delete
6.02 kB
"""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()