Blame for code/v4_eval.py

#!/usr/bin/env python3
"""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"   # v4_data/v3_data setzen beim Import ''; ohne Reset waere die GPU je nach Importreihenfolge unsichtbar

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