| |
| """A/B-Test: Hardcore-Adapter gegen v3-Adapter (plain). |
| |
| bf16, transformers + peft, Greedy, dieselben 50 Woerter in 3 Kategorien. Genauigkeit = |
| ausgegebene Endzahl == Zeichenlaenge (zusaetzlich: Pointer-Liste zeichengenau). |
| """ |
| 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 re |
| import time |
| from itertools import groupby |
|
|
| import torch |
| from peft import PeftModel |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
|
|
| BASE = f"{PLATTE}/models/graf_zahl/qwen_healed_merged" |
| ADAPTERS = { |
| "A (hardcore)": f"{PLATTE}/models/graf_zahl/qwen_graf_zahl_hardcore_lora", |
| "B (v3)": 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/ab_test_results_v3.json" |
| MAX_NEW_TOKENS = 2000 |
|
|
| CATS = { |
| "1 Normal": ["Apfelkuchen", "Schreibtisch", "Fensterbank", "Gartenzaun", "Blumentopf", "Regenschirm", |
| "Bleistift", "Kühlschrank", "Fahrkarte", "Zahnbürste", "Wörterbuch", "Briefkasten", |
| "Handtuch", "Geburtstag", "Weihnachtsbaum"], |
| "2 Doppelt": ["Kaffeemaschine", "Bettdecke", "Wasserball", "Kartoffelsalat", "Teddybär", "Schnellzug", |
| "Sommerkleid", "Wollsocke", "Sonnenblume", "Rollkoffer", "Lippenstift", "Himmelbett", |
| "Schwimmbad", "Hammerschlag", "Mittagessen", "Brillenglas", "Zuckerrübe", "Waffeleisen", |
| "Klassenzimmer", "Tannenzapfen"], |
| "3 Dreifach": ["Brennnessel", "Schifffahrt", "Sauerstoffflasche", "Donaudampfschifffahrt", "Betttuch", |
| "Stillleben", "Kaffeeersatz", "Seeelefant", "Balletttänzer", "Schwimmmeister", |
| "Flussschifffahrt", "Nussschale", "Kunststoffflasche", "Schlammmasse", "Fußballliga"], |
| } |
|
|
|
|
| def max_run(w): |
| return max(len(list(g)) for _, g in groupby(w.lower())) |
|
|
|
|
| def extract(answer): |
| pointers = re.findall(r"\[Position (\d+): (.)\]", answer) |
| final = re.findall(r"Das sind (\d+)", answer) |
| spread = re.search(r"^Spreizung: (.+)$", answer, re.MULTILINE) |
| spread = "".join(c.strip() for c in spread.group(1).split(" - ")) if spread else None |
| return "".join(c for _, c in pointers), (int(final[-1]) if final else None), spread |
|
|
|
|
| def main(): |
| assert sum(len(v) for v in CATS.values()) == 50 |
| assert all(max_run(w) == 1 for w in CATS["1 Normal"]) |
| assert all(max_run(w) == 2 for w in CATS["2 Doppelt"]) |
| assert all(max_run(w) >= 3 for w in CATS["3 Dreifach"]) |
|
|
| 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}) |
| first = True |
| for name, path in ADAPTERS.items(): |
| aid = name[0] |
| if first: |
| model = PeftModel.from_pretrained(model, path, adapter_name=aid) |
| first = False |
| else: |
| model.load_adapter(path, adapter_name=aid) |
| model.eval() |
| print(f"Modell geladen ({next(model.parameters()).dtype}), Adapter: {list(model.peft_config)}, " |
| f"VRAM {torch.cuda.memory_allocated() / 1e9:.1f} GB", flush=True) |
|
|
| results = [] |
| t0 = time.time() |
| for name in ADAPTERS: |
| model.set_adapter(name[0]) |
| print(f"\n===== Durchlauf {name} =====", flush=True) |
| for cat, words in CATS.items(): |
| for w in words: |
| messages = [{"role": "system", "content": system}, |
| {"role": "user", "content": f"Wie viele Zeichen hat das Wort '{w}'?"}] |
| 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]:] |
| answer = tok.decode(new, skip_special_tokens=True) |
| pointers, final, spread = extract(answer) |
| rec = {"adapter": name, "kategorie": cat, "wort": w, "soll": len(w), "endzahl": final, |
| "richtig": final == len(w), "pointer_string": pointers, |
| "pointer_exakt": pointers == w, "spreizung": spread, |
| "spreizung_exakt": None if spread is None else spread == w, "tokens": len(new), |
| "tokenisierung": tok.tokenize(w), "antwort": answer} |
| results.append(rec) |
| print(f"[{name}] {cat:10} {w:22} soll {len(w):2} -> {str(final):>4} " |
| f"{'ok ' if rec['richtig'] else 'FALSCH'} ({time.time() - t0:.0f}s)", flush=True) |
| json.dump(results, open(RESULTS, "w", encoding="utf-8"), ensure_ascii=False) |
|
|
| print("\n===== AUSWERTUNG =====") |
| print(f"{'Kategorie':12} {'n':>3} " + " ".join(f"{a:>22}" for a in ADAPTERS)) |
| for cat in list(CATS) + ["Gesamt"]: |
| row = [] |
| for a in ADAPTERS: |
| rs = [r for r in results if r["adapter"] == a and (cat == "Gesamt" or r["kategorie"] == cat)] |
| ok = sum(r["richtig"] for r in rs) |
| px = sum(r["pointer_exakt"] for r in rs) |
| row.append(f"{ok:2}/{len(rs):2} = {ok / len(rs) * 100:5.1f} % (Ptr {px / len(rs) * 100:3.0f} %)") |
| n = len(CATS[cat]) if cat in CATS else 50 |
| print(f"{cat:12} {n:>3} " + " ".join(f"{c:>22}" for c in row)) |
| print("\nSpreizung zeichengenau (nur Adapter mit Spreizungs-Format):") |
| for a in ADAPTERS: |
| rs = [r for r in results if r["adapter"] == a] |
| sp = [r for r in rs if r["spreizung_exakt"] is not None] |
| print(f" {a}: {sum(r['spreizung_exakt'] for r in sp)}/{len(sp)} Antworten mit Spreizung exakt") |
| print(f"\nErgebnisse: {RESULTS}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
