| |
| """ |
| evaluate_llm.py — LLM-Halluzinations-Benchmark (Ollama) |
| |
| Lädt alle fragen_<thema>.json aus llm_test/, stellt jede Frage einem Modell |
| (Ollama /v1/chat/completions) und wertet aus: |
| - MC: Antwort-Zahl (0-3) wird per Regex extrahiert → volle Punkte bei Treffer |
| - Open: Stichwort-Matching (wörtlich / Präfix ab 6 Zeichen, Umlaut-normalisiert) |
| → anteilige Punkte (wie der _kws_abgleich der Lernapp) |
| |
| Report: Gesamt-Score je Modell, je Thema, je Schwierigkeit, je |
| Halluzinations-Kategorie + Liste der Halluzinationen (falsch beantwortete Fragen). |
| |
| Nutzung: |
| python3 evaluate_llm.py --model llama3.2:3b-64k |
| python3 evaluate_llm.py --model qwen2.5:3b-128k --thema linux --limit 6 |
| python3 evaluate_llm.py --model X --export-sft sft_daten.jsonl |
| |
| Nur Stdlib (keine Abhängigkeiten). Ground Truth = die Fragenbanken selbst; |
| die Dateien dienen zugleich als SFT-Trainingsdaten. |
| """ |
|
|
| import argparse |
| import json |
| import re |
| import sys |
| import time |
| import urllib.request |
| from pathlib import Path |
|
|
| BASE_URL = "http://127.0.0.1:11434/v1" |
| HERE = Path(__file__).resolve().parent |
|
|
| |
| UMLAUT = {"ä": "ae", "ö": "oe", "ü": "ue", "ß": "ss"} |
|
|
|
|
| def norm(s: str) -> str: |
| s = s.lower() |
| for a, b in UMLAUT.items(): |
| s = s.replace(a, b) |
| return re.sub(r"[^a-z0-9 ]", " ", s) |
|
|
|
|
| def stichwort_treffer(antwort: str, stichworte: list[str]) -> tuple[int, int]: |
| """Gefunden/Fehlt für eine offene Antwort. Wörtlich, sonst längstes Wort |
| des Stichworts (>=6 Zeichen) als Präfix-Match.""" |
| ant = norm(antwort) |
| gefunden, fehlt = 0, 0 |
| for sw in stichworte: |
| sw_n = norm(sw) |
| if sw_n in ant: |
| gefunden += 1 |
| continue |
| |
| woerter = [w for w in sw_n.split() if len(w) >= 6] |
| if woerter and any(w in ant for w in woerter): |
| gefunden += 1 |
| continue |
| fehlt += 1 |
| return gefunden, fehlt |
|
|
|
|
| def llm_antwort(model: str, frage: str, system: str = "", timeout: int = 120, |
| temperature: float = 0.0) -> tuple[str, float]: |
| messages = [] |
| if system: |
| messages.append({"role": "system", "content": system}) |
| messages.append({"role": "user", "content": frage}) |
| body = { |
| "model": model, |
| "messages": messages, |
| "temperature": temperature, |
| "stream": False, |
| "max_tokens": 300, |
| } |
| req = urllib.request.Request( |
| BASE_URL + "/chat/completions", |
| data=json.dumps(body).encode(), |
| headers={"Content-Type": "application/json"}, |
| ) |
| t0 = time.time() |
| try: |
| r = json.load(urllib.request.urlopen(req, timeout=timeout)) |
| text = r["choices"][0]["message"].get("content", "").strip() |
| |
| if "<｜end▁of▁thinking｜>" in text: |
| text = text.split("<｜end▁of▁thinking｜>", 1)[1].strip() |
| elif "<｜end▁of▁thinking｜>" in text: |
| text = text.split(" response", 1)[1].strip() |
| return text, time.time() - t0 |
| except Exception as e: |
| return f"<FEHLER: {e}>", 0.0 |
|
|
|
|
| def bewerte_mc(frage: dict, antwort_text: str) -> int: |
| m = re.search(r"\b([0-3])\b", antwort_text) |
| if not m: |
| return 0 |
| return frage["punkte"] if int(m.group(1)) == frage["antwort"] else 0 |
|
|
|
|
| def bewerte_open(frage: dict, antwort_text: str) -> int: |
| gefunden, fehlt = stichwort_treffer(antwort_text, frage.get("stichworte", [])) |
| if gefunden + fehlt == 0: |
| return 0 |
| return round(frage["punkte"] * gefunden / (gefunden + fehlt)) |
|
|
|
|
| def frage_als_prompt(f: dict) -> str: |
| if f["typ"] == "mc": |
| opts = "\n".join(f"{i}. {o}" for i, o in enumerate(f["optionen"])) |
| return (f"{f['frage']}\n{opts}\n\n" |
| "Antworte NUR mit der Zahl der richtigen Option (0, 1, 2 oder 3).") |
| return f"{f['frage']}\n\nAntworte in eigenen Worten auf Deutsch (1-3 Sätze)." |
|
|
|
|
| def lade_fragen(ordner: Path) -> list[dict]: |
| fragen = [] |
| for pfad in sorted(ordner.glob("fragen_*.json")): |
| d = json.loads(pfad.read_text(encoding="utf-8")) |
| fragen.extend(d) |
| return fragen |
|
|
|
|
| def export_sft(fragen: list[dict], out: Path) -> None: |
| """Fragen als SFT-Trainingsdaten exportieren (JSONL, Chat-Format).""" |
| with out.open("w", encoding="utf-8") as fh: |
| for f in fragen: |
| if f["typ"] == "mc": |
| opts = "\n".join(f"{i}. {o}" for i, o in enumerate(f["optionen"])) |
| loesung = f"Die richtige Antwort ist Option {f['antwort']}: {f['optionen'][f['antwort']]}" |
| else: |
| loesung = f["antwort"] |
| eintrag = { |
| "messages": [ |
| {"role": "system", "content": "Du beantwortest technische Fragen korrekt und ohne zu erfinden."}, |
| {"role": "user", "content": f["frage"]}, |
| {"role": "assistant", "content": loesung + " " + f["erklaerung"]}, |
| ], |
| "meta": { |
| "thema": f["id"].split("_")[0], |
| "schwierigkeit": f["schwierigkeit"], |
| "halluzination_kategorie": f.get("halluzination_kategorie", ""), |
| }, |
| } |
| fh.write(json.dumps(eintrag, ensure_ascii=False) + "\n") |
| print(f"SFT-Daten: {len(fragen)} Eintraege -> {out}") |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser(description="LLM-Halluzinations-Benchmark") |
| ap.add_argument("--model", required=True, help="Ollama-Modellname") |
| ap.add_argument("--ordner", type=Path, default=HERE, |
| help="Ordner mit fragen_*.json (default: llm_test/)") |
| ap.add_argument("--thema", help="Nur ein Thema (z.B. linux)") |
| ap.add_argument("--limit", type=int, help="Nur die ersten N Fragen") |
| ap.add_argument("--export-sft", help="Pfad für SFT-JSONL-Export (statt Benchmark)") |
| ap.add_argument("--samples", type=int, default=1, |
| help="Self-Consistency: N Antworten pro Frage, Mehrheitsentscheid (MC) bzw. " |
| "beste Stichwort-Abdeckung (open). Temperatur 0.7 für Diversität.") |
| args = ap.parse_args() |
|
|
| fragen = lade_fragen(args.ordner) |
| if args.thema: |
| fragen = [f for f in fragen if f["id"].startswith(args.thema + "_")] |
| if args.limit: |
| fragen = fragen[: args.limit] |
| if not fragen: |
| print("Keine Fragen gefunden (llm_test/fragen_*.json).") |
| sys.exit(1) |
|
|
| if args.export_sft: |
| export_sft(fragen, Path(args.export_sft)) |
| return |
|
|
| samples = max(1, args.samples) |
| print(f"Benchmark: {args.model} | {len(fragen)} Fragen | Samples: {samples}\n") |
| ergebnisse = [] |
| max_punkte = sum(f["punkte"] for f in fragen) |
|
|
| for i, f in enumerate(fragen, 1): |
| if samples > 1: |
| |
| antworten = [llm_antwort(args.model, frage_als_prompt(f), temperature=0.7) |
| for _ in range(samples)] |
| texte = [a[0] for a in antworten] |
| dt = sum(a[1] for a in antworten) |
| if f["typ"] == "mc": |
| stimmen = [] |
| for t in texte: |
| m = re.search(r"\b([0-3])\b", t) |
| if m: |
| stimmen.append(m.group(1)) |
| if stimmen: |
| mehrheit = max(set(stimmen), key=stimmen.count) |
| text = mehrheit |
| else: |
| text = texte[0] |
| else: |
| text = max(texte, key=lambda t: stichwort_treffer(t, f.get("stichworte", []))[0]) |
| else: |
| text, dt = llm_antwort(args.model, frage_als_prompt(f)) |
| if f["typ"] == "mc": |
| erzielt = bewerte_mc(f, text) |
| else: |
| erzielt = bewerte_open(f, text) |
| ergebnisse.append((f, text, erzielt, dt)) |
| status = "OK " if erzielt == f["punkte"] else ("teil" if erzielt > 0 else "FALSCH") |
| print(f"[{i:02d}/{len(fragen)}] {f['id']:14} {status:5} {erzielt}/{f['punkte']} " |
| f"({dt:4.1f}s)") |
|
|
| |
| gesamt = sum(e[2] for e in ergebnisse) |
| print("\n" + "=" * 60) |
| print(f"GESAMT: {gesamt}/{max_punkte} Punkte ({100*gesamt/max_punkte:.0f}%)") |
| print(f"Zeit gesamt: {sum(e[3] for e in ergebnisse):.0f}s") |
|
|
| |
| print("\n-- je Thema --") |
| themen = {} |
| for f, _, erzielt, _ in ergebnisse: |
| themen.setdefault(f["id"].split("_")[0], [0, 0]) |
| themen[f["id"].split("_")[0]][0] += erzielt |
| themen[f["id"].split("_")[0]][1] += f["punkte"] |
| for t, (e, m) in sorted(themen.items()): |
| print(f" {t:12} {e:3}/{m:3} ({100*e/m:.0f}%)") |
|
|
| |
| print("\n-- je Schwierigkeit --") |
| for sw in ["leicht", "mittel", "schwer"]: |
| e = sum(x[2] for x in ergebnisse if x[0]["schwierigkeit"] == sw) |
| m = sum(x[0]["punkte"] for x in ergebnisse if x[0]["schwierigkeit"] == sw) |
| if m: |
| print(f" {sw:8} {e:3}/{m:3} ({100*e/m:.0f}%)") |
|
|
| |
| print("\n-- je Halluzinations-Kategorie --") |
| kat = {} |
| for f, _, erzielt, _ in ergebnisse: |
| k = f.get("halluzination_kategorie", "?") |
| kat.setdefault(k, [0, 0]) |
| kat[k][0] += erzielt |
| kat[k][1] += f["punkte"] |
| for k, (e, m) in sorted(kat.items()): |
| print(f" {k:14} {e:3}/{m:3} ({100*e/m:.0f}%)") |
|
|
| |
| print("\n-- Halluzinationen (0 Punkte) --") |
| for f, text, erzielt, _ in ergebnisse: |
| if erzielt == 0: |
| print(f"\n [{f['id']}] {f['frage'][:110]}") |
| print(f" LLM: {text[:140]}") |
|
|
| print("\nFertig.") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
