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()