| |
| """v4-Abnahmetest (ohne System-Prompt, Greedy, bf16, Standard-Chat-Template, gemergtes Modell). |
| |
| VOR dem Training festgelegte Kriterien (alle muessen erfuellt sein, sonst bleibt v4 privat): |
| C1 Zaehlen unabhaengig (45 handgeschriebene Strings, ohne 'Grenzfall' = 40): >= 32/40 und Wiederholungen >= 4/6 |
| C2 Zaehlen frisch (heldout 42 + Generalisierung 28 + 50 Woerter): >= 85 % gesamt |
| C3 Buchstabenhaeufigkeit (40 handgeschrieben, nie im Training): >= 80 % |
| C4 Woerter zaehlen (12): >= 9/12 |
| C5 Chat-Sanity (30 normale Fragen): keine <think>-/Persona-Reste, Antwort passt >= 27/30 |
| C6 Format: >= 95 % aller Zaehlantworten mit <think>...</think> UND regulaerem Ende (kein Abbruch/Endlosschleife) |
| Groesse der Stichproben ist klein; Einzelergebnisse sind ein Indiz, kein Beweis. Aufruf: v4_eval.py [pfad_zum_modell] |
| """ |
| import os |
| os.environ["CUDA_VISIBLE_DEVICES"] = "0" |
| PLATTE = "/home/david/Schreibtisch/Platte" |
| os.environ.setdefault("HF_HOME", f"{PLATTE}/cache/huggingface") |
| os.environ["HF_HUB_OFFLINE"] = "1" |
|
|
| import json |
| import re |
| import sys |
| import time |
| from pathlib import Path |
|
|
| import torch |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
|
|
| sys.path.insert(0, "/mnt/models/graf_zahl") |
| import v4_tests |
| from test_v3_independent import TESTS as INDEP, quote |
| from v4_data import final_number |
|
|
| os.environ["CUDA_VISIBLE_DEVICES"] = "0" |
|
|
| MODEL = sys.argv[1] if len(sys.argv) > 1 else f"{PLATTE}/models/graf_zahl/qwen_graf_zahl_v4_merged" |
| G = f"{PLATTE}/models/graf_zahl" |
| RESULTS = f"{G}/v4/eval_v4_results.json" |
| BATCH = 8 |
|
|
| PERIODIC = ["abababababab", "xyxyxyxyxyxyxyxy", "ha ha ha ha ha", "aaaaaaaaaa", "1212121212", "abcabcabcabcabc", "lalalalalalalalala", "ABABABABABABABABABAB"] |
|
|
|
|
| def build_items(): |
| items = [] |
| for cat, ss in INDEP.items(): |
| for s in ss: |
| items.append({"gruppe": "unabhaengig", "kategorie": cat, "text": s, "soll": len(s), "prompt": f"Wie viele Zeichen hat der String {quote(s)}?", "max_new": 3200}) |
| for r in json.load(open(f"{G}/v3/heldout_v3.json", encoding="utf-8")): |
| items.append({"gruppe": "frisch", "kategorie": "heldout " + r["kategorie"], "text": r["text"], "soll": len(r["text"]), "prompt": r["prompt"], "max_new": 3200}) |
| seen = set() |
| for r in json.load(open(f"{G}/generalization_results.json", encoding="utf-8")): |
| items.append({"gruppe": "frisch", "kategorie": "gen " + r["kategorie"], "text": r["text"], "soll": len(r["text"]), "prompt": r["prompt"], "max_new": 3200}) |
| for r in json.load(open(f"{G}/ab_test_results.json", encoding="utf-8")): |
| if r["wort"] not in seen: |
| seen.add(r["wort"]) |
| items.append({"gruppe": "frisch", "kategorie": "ab Wort", "text": r["wort"], "soll": len(r["wort"]), "prompt": f"Wie viele Zeichen hat das Wort {r['wort']}?", "max_new": 3200}) |
| for s in PERIODIC: |
| items.append({"gruppe": "periodisch", "kategorie": "periodisch", "text": s, "soll": len(s), "prompt": f"Wie viele Zeichen hat '{s}'?", "max_new": 3200}) |
| for it in v4_tests.letter_items(): |
| items.append({"gruppe": "buchstabe", "kategorie": "Buchstabe", "text": it["text"], "soll": it["soll"], "prompt": it["prompt"], "max_new": 3200}) |
| for it in v4_tests.word_items(): |
| items.append({"gruppe": "woerter", "kategorie": "Woerter", "text": it["text"], "soll": it["soll"], "prompt": it["prompt"], "max_new": 1500}) |
| for it in v4_tests.chat_items(): |
| items.append({"gruppe": "chat", "kategorie": "Chat", "text": it["prompt"], "erwartet": it["erwartet"], "prompt": it["prompt"], "max_new": 700}) |
| return items |
|
|
|
|
| def main(): |
| items = build_items() |
| train_texts = set() |
| for l in open(f"{G}/v4/counting_v4.jsonl", encoding="utf-8"): |
| train_texts.add(json.loads(l)["text"]) |
| leak = [i["text"] for i in items if i["gruppe"] != "chat" and i["text"] in train_texts and i["kategorie"] != "periodisch"] |
| assert not leak, f"Teststrings im v4-Training: {leak}" |
| chat_train = {json.loads(l)["messages"][0]["content"] for l in open(f"{G}/v4/dataset_v4.jsonl", encoding="utf-8")} |
| assert not [i for i in items if i["gruppe"] == "chat" and i["prompt"] in chat_train], "Chat-Testprompt im Training" |
| print(f"{len(items)} Testaufgaben, keine Ueberschneidung mit dem v4-Training (geprueft)", flush=True) |
|
|
| tok = AutoTokenizer.from_pretrained(MODEL) |
| tok.padding_side = "left" |
| model = AutoModelForCausalLM.from_pretrained(MODEL, dtype=torch.bfloat16, device_map={"": 0}).eval() |
| im_end = tok.convert_tokens_to_ids("<|im_end|>") |
| print(f"Modell {MODEL} geladen ({len(tok)} Tokens)", flush=True) |
|
|
| texts = [tok.apply_chat_template([{"role": "user", "content": it["prompt"]}], tokenize=False, add_generation_prompt=True) for it in items] |
| order = sorted(range(len(items)), key=lambda i: (items[i]["max_new"], len(items[i].get("text", "")))) |
| t0 = time.time() |
| for b in range(0, len(order), BATCH): |
| idx = order[b:b + BATCH] |
| enc = tok([texts[i] for i in idx], return_tensors="pt", padding=True, add_special_tokens=False).to("cuda") |
| with torch.no_grad(): |
| out = model.generate(**enc, max_new_tokens=max(items[i]["max_new"] for i in idx), do_sample=False, temperature=None, top_p=None, top_k=None, |
| pad_token_id=tok.pad_token_id, eos_token_id=[im_end, tok.eos_token_id]) |
| for j, i in enumerate(idx): |
| ids = out[j][enc["input_ids"].shape[1]:].tolist() |
| fin = im_end in ids or tok.eos_token_id in ids |
| items[i]["antwort"] = tok.decode(ids, skip_special_tokens=True) |
| items[i]["fertig"] = fin |
| print(f" {min(b + BATCH, len(order))}/{len(order)} ({time.time() - t0:.0f}s)", flush=True) |
|
|
| for it in items: |
| a = it["antwort"] |
| it["think"] = "<think>" in a and "</think>" in a |
| after = a.split("</think>")[-1] if "</think>" in a else a |
| if it["gruppe"] == "chat": |
| reply = a |
| miss_leak = [m for m in v4_tests.LEAK_MARKERS if m.lower() in reply.lower()] |
| ok_txt = (not it["erwartet"]) or any(e.lower() in reply.lower() for e in it["erwartet"]) |
| it["leak"] = miss_leak |
| it["richtig"] = it["fertig"] and not miss_leak and ok_txt and len(reply.strip()) > 0 |
| else: |
| it["endzahl"] = final_number(after) |
| m = re.findall(r"Zur Sicherheit nachgezählt:\s*(\d+)", a) |
| it["think_zahl"] = int(m[-1]) if m else None |
| it["richtig"] = it["fertig"] and it["endzahl"] == it["soll"] |
| json.dump(items, open(RESULTS, "w", encoding="utf-8"), ensure_ascii=False, indent=1) |
|
|
| def acc(sel): |
| rs = [i for i in items if sel(i)] |
| return sum(i["richtig"] for i in rs), len(rs) |
| print("\n===== ERGEBNISSE =====") |
| cats = sorted({(i["gruppe"], i["kategorie"]) for i in items}) |
| for g, c in cats: |
| k, n = acc(lambda i: i["gruppe"] == g and i["kategorie"] == c) |
| print(f" {g:12} {c:34} {k:>3}/{n:<3}") |
| c1, n1 = acc(lambda i: i["gruppe"] == "unabhaengig" and not i["kategorie"].startswith("7")) |
| rep, nrep = acc(lambda i: i["gruppe"] == "unabhaengig" and i["kategorie"].startswith("5")) |
| c2, n2 = acc(lambda i: i["gruppe"] == "frisch") |
| c3, n3 = acc(lambda i: i["gruppe"] == "buchstabe") |
| c4, n4 = acc(lambda i: i["gruppe"] == "woerter") |
| c5, n5 = acc(lambda i: i["gruppe"] == "chat") |
| cnt = [i for i in items if i["gruppe"] != "chat"] |
| fmt = sum(i["think"] and i["fertig"] for i in cnt) |
| gr = acc(lambda i: i["gruppe"] == "unabhaengig" and i["kategorie"].startswith("7")) |
| per = acc(lambda i: i["gruppe"] == "periodisch") |
| crit = [("C1 Zaehlen unabhaengig >= 32/40 und Wiederholungen >= 4/6", c1 >= 32 and rep >= 4, f"{c1}/{n1}, Wiederholungen {rep}/{nrep}"), |
| ("C2 Zaehlen frisch >= 85 %", c2 / n2 >= 0.85, f"{c2}/{n2} = {100 * c2 / n2:.1f} %"), |
| ("C3 Buchstabenhaeufigkeit >= 80 %", c3 / n3 >= 0.80, f"{c3}/{n3} = {100 * c3 / n3:.1f} %"), |
| ("C4 Woerter zaehlen >= 9/12", c4 >= 9, f"{c4}/{n4}"), |
| ("C5 Chat-Sanity >= 27/30", c5 >= 27, f"{c5}/{n5}"), |
| ("C6 Format >= 95 %", fmt / len(cnt) >= 0.95, f"{fmt}/{len(cnt)} = {100 * fmt / len(cnt):.1f} %")] |
| print(f"\n Zusatz: periodische Strings {per[0]}/{per[1]}, Grenzfall (nicht-lateinisch/Doppel-Leerzeichen) {gr[0]}/{gr[1]}") |
| print("\n===== VORAB FESTGELEGTE KRITERIEN =====") |
| for name, ok, val in crit: |
| print(f" [{'OK ' if ok else 'FAIL'}] {name}: {val}") |
| allok = all(ok for _, ok, _ in crit) |
| print(f"\n GESAMT: {'ALLE KRITERIEN ERFUELLT' if allok else 'NICHT ALLE KRITERIEN ERFUELLT'}") |
| json.dump({"kriterien": [{"name": n, "ok": bool(o), "wert": v} for n, o, v in crit], "alle_ok": bool(allok)}, open(f"{G}/v4/eval_v4_criteria.json", "w", encoding="utf-8"), ensure_ascii=False, indent=1) |
| print(f"Details: {RESULTS}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
