File size: 6,023 Bytes
c02657c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 | """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()
|