| |
| """Generalisierungs-Test (Out-of-Distribution) fuer den Hardcore-Adapter, bf16, Greedy, GPU 0. |
| |
| A: Zufall und Sonderzeichen | B: Ueberlaenge (> 45 Zeichen) | C: Code | D: abweichende Prompts. |
| Richtig = 'Das sind N' == Laenge des Strings. Zusaetzlich: Pointer-Liste, Spreizung, Abbruch am Tokenlimit. |
| """ |
| import os |
| os.environ["CUDA_VISIBLE_DEVICES"] = "0" |
|
|
| PLATTE = "/home/david/Schreibtisch/Platte" |
| os.environ.setdefault("HF_HOME", f"{PLATTE}/cache/huggingface") |
| os.environ.setdefault("HF_HUB_CACHE", f"{PLATTE}/cache/huggingface/hub") |
|
|
| import json |
| import random |
| import re |
| import string |
| import time |
|
|
| import torch |
| from peft import PeftModel |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
|
|
| BASE = f"{PLATTE}/models/graf_zahl/qwen_healed_merged" |
| ADAPTER = f"{PLATTE}/models/graf_zahl/qwen_graf_zahl_v3_plain_lora" |
| DATASET = "/mnt/models/graf_zahl/dataset_massive.jsonl" |
| RESULTS = f"{PLATTE}/models/graf_zahl/generalization_results_v3.json" |
| MAX_NEW_TOKENS = 4500 |
|
|
|
|
| def rnd(n, seed, alphabet): |
| rng = random.Random(seed) |
| return "".join(rng.choice(alphabet) for _ in range(n)) |
|
|
|
|
| ALNUM = string.ascii_letters + string.digits |
| LETTERS = string.ascii_letters |
| SYM = string.ascii_letters + string.digits + "!#$%&*+-=?_" |
|
|
| STRING_Q = "Wie viele Zeichen hat der String '{s}'?" |
| WORD_Q = "Wie viele Zeichen hat das Wort '{s}'?" |
|
|
| TESTS = [] |
| for s in ["aB3!x_9P", "---===+++", "3C:5A:B4:9F:12:E7", "Xk9#mL2$pQ7", "@@@###$$$%%%", "192.168.100.254", "Ünïcödé-Tëst"]: |
| TESTS.append(("A Zufall/Sonderzeichen", s, STRING_Q.format(s=s))) |
| for s, q in [(rnd(55, 1, ALNUM), STRING_Q), |
| ("Rindfleischetikettierungsüberwachungsaufgabenübertragungsgesetz", WORD_Q), |
| ("Donaudampfschifffahrtsgesellschaftskapitänsmütze", WORD_Q), |
| (rnd(60, 2, LETTERS), STRING_Q), |
| ("Kraftfahrzeughaftpflichtversicherungsprämienberechnungsstelle", WORD_Q), |
| (rnd(72, 3, SYM), STRING_Q), |
| (rnd(80, 4, ALNUM), STRING_Q)]: |
| assert len(s) > 45 |
| TESTS.append(("B Ueberlaenge", s, q.format(s=s))) |
| for s in ["def count(x): return len(x)", 'print("Hello, World!")', "for i in range(10):", "SELECT * FROM users;", |
| '<div class="box">Hi</div>', "arr[i] = arr[j] + 1;"]: |
| TESTS.append(("C Code", s, STRING_Q.format(s=s))) |
| for s, q in [("Apfelbaum", "Hey Graf, wie lang ist eigentlich das Wort 'Apfelbaum'?"), |
| ("Kühlschrank", "Zähl mal bitte 'Kühlschrank' durch"), |
| ("Zuckerwatte", "Ich brauche die Anzahl der Buchstaben von: Zuckerwatte"), |
| ("Wassermelone", "Wieviele Zeichen? 'Wassermelone'"), |
| ("Schifffahrtskapitän", "Kannst du mir sagen, aus wie vielen Buchstaben 'Schifffahrtskapitän' besteht?"), |
| ("Kaffeetasse", "How many characters are in the word 'Kaffeetasse'?"), |
| ("Bettlaken", "Länge von Bettlaken?"), |
| ("Mississippi", "Mein Sohn fragt mich, wie viele Buchstaben das Wort 'Mississippi' hat. Kannst du helfen?")]: |
| TESTS.append(("D Prompt-Abweichung", s, q)) |
|
|
|
|
| def analyse(s, answer): |
| pointers = re.findall(r"\[Position (\d+): (.)\]", answer) |
| chars = "".join((" " if c == "\u2423" else c) for _, c in pointers) |
| final = re.findall(r"Das sind (\d+)", answer) |
| safety = re.findall(r"Zur Sicherheit nachgezählt:\s*(\d+)", answer) |
| spread = re.search(r"^Spreizung: (.*)$", answer, re.MULTILINE) |
| return { |
| "endzahl": int(final[-1]) if final else None, |
| "sicherheitszahl": int(safety[-1]) if safety else None, |
| "pointer_string": chars, |
| "pointer_exakt": chars == s, |
| "spreizung_exakt": None if not spread else spread.group(1) == " - ".join("\u2423" if c == " " else c for c in s), |
| "letzte_position": int(pointers[-1][0]) if pointers else 0, |
| "hat_think_block": "</think>" in answer, |
| "ah_ah_ah": answer.count("Ah ah ah"), |
| } |
|
|
|
|
| def main(): |
| system = json.loads(open(DATASET, encoding="utf-8").readline())["messages"][0]["content"] |
| tok = AutoTokenizer.from_pretrained(BASE) |
| model = AutoModelForCausalLM.from_pretrained(BASE, dtype=torch.bfloat16, device_map={"": 0}) |
| model = PeftModel.from_pretrained(model, ADAPTER) |
| model.eval() |
| print(f"Modell geladen ({next(model.parameters()).dtype}), {len(TESTS)} Tests, max_new_tokens={MAX_NEW_TOKENS}", flush=True) |
|
|
| results, t0 = [], time.time() |
| for kat, s, prompt in TESTS: |
| messages = [{"role": "system", "content": system}, {"role": "user", "content": prompt}] |
| text = tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) |
| inputs = tok(text, return_tensors="pt", add_special_tokens=False).to("cuda") |
| with torch.no_grad(): |
| out = model.generate(**inputs, max_new_tokens=MAX_NEW_TOKENS, do_sample=False, temperature=0.0, top_p=1.0, |
| eos_token_id=tok.eos_token_id, pad_token_id=tok.pad_token_id) |
| new = out[0][inputs["input_ids"].shape[1]:] |
| truncated = int(new[-1]) != tok.eos_token_id |
| answer = tok.decode(new, skip_special_tokens=True) |
| a = analyse(s, answer) |
| rec = {"kategorie": kat, "text": s, "laenge": len(s), "prompt": prompt, "tokens": len(new), |
| "abgebrochen": truncated, "richtig": a["endzahl"] == len(s), "antwort": answer, **a} |
| results.append(rec) |
| flag = "ABGEBROCHEN" if truncated else ("ok " if rec["richtig"] else "FALSCH") |
| print(f"[{kat:22}] len {len(s):2} -> {str(a['endzahl']):>4} {flag:11} Ptr {'ok' if a['pointer_exakt'] else 'X '} " |
| f"({len(new)} Tok, {time.time() - t0:.0f}s) {s[:40]!r}", flush=True) |
| json.dump(results, open(RESULTS, "w", encoding="utf-8"), ensure_ascii=False) |
|
|
| print("\n===== AUSWERTUNG =====") |
| print(f"{'Kategorie':24} {'n':>2} {'richtig':>9} {'Pointer':>9} {'Spreizung':>10} {'abgebr.':>8}") |
| for kat in dict.fromkeys(r["kategorie"] for r in results): |
| rs = [r for r in results if r["kategorie"] == kat] |
| sp = [r for r in rs if r["spreizung_exakt"] is not None] |
| print(f"{kat:24} {len(rs):>2} {sum(r['richtig'] for r in rs):>4}/{len(rs):<4} {sum(r['pointer_exakt'] for r in rs):>4}/{len(rs):<4} " |
| f"{sum(bool(r['spreizung_exakt']) for r in sp):>4}/{len(sp):<5} {sum(r['abgebrochen'] for r in rs):>5}") |
| print(f"{'Gesamt':24} {len(results):>2} {sum(r['richtig'] for r in results):>4}/{len(results):<4}") |
| print(f"\nErgebnisse: {RESULTS}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
