Download code/train/eval_synth.py from KeremTT/OPUS-5.5-DATABASE: direct link, hf CLI and curl.
- Browser
- Download file 6.02 kB
-
https://huggingface.co/datasets/KeremTT/OPUS-5.5-DATABASE/resolve/main/code/train/eval_synth.py
- Command line
-
hf download hf://datasets/KeremTT/OPUS-5.5-DATABASE/code/train/eval_synth.py
-
curl -L -o eval_synth.py https://huggingface.co/datasets/KeremTT/OPUS-5.5-DATABASE/resolve/main/code/train/eval_synth.py
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() | |