update

backend/lesbarkeit.py

@@ -0,0 +1,115 @@
+"""Deterministisches Lesbarkeits-Gate für Guide-Sections.
+
+Ein kleines deutsches Komplexitäts-Modell (DistilBERT, GermEval 2022, Skala 1–7)
+bewertet die Verständlichkeit der Fließtext-Prosa. guide.py meldet zu schwere
+Sections in die bestehende Lese-Prüfungs-/Überarbeitungs-Schleife — kein Prompt,
+kein Raten.
+
+Optional: fehlen `transformers`/`torch` oder lädt das Modell nicht, ist das Gate
+stumm deaktiviert (das Backend läuft unverändert weiter). CPU genügt; der Aufrufer
+wrappt die Bewertung in `asyncio.to_thread` (blockierende Modell-Inferenz).
+"""
+
+import logging
+import re
+
+from config import (
+    LESBARKEIT_AKTIV, LESBARKEIT_HART, LESBARKEIT_HART_ANTEIL, LESBARKEIT_MAX, LESBARKEIT_MODELL,
+)
+
+log = logging.getLogger("creator.lesbarkeit")
+
+_modell_cache = None      # (tokenizer, model, torch) — Singleton
+_ladeversuch = False      # schon versucht zu laden?
+
+# Markup raus → reiner Fließtext (Code zählt nicht zur Lesbarkeit).
+_CODE_FENCE = re.compile(r"```.*?```", re.DOTALL)
+_COMMENT = re.compile(r"<!--.*?-->", re.DOTALL)
+_INLINE_CODE = re.compile(r"`[^`]*`")
+_LINK = re.compile(r"\[([^\]]*)\]\([^)]*\)")
+_MD_MARK = re.compile(r"^[ \t]*([#>]+|[-*+]\s)|[*_~|]", re.MULTILINE)
+_WS = re.compile(r"\s+")
+_SATZ = re.compile(r"(?<=[.!?])\s+")
+
+
+def _modell():
+    """Lädt das Modell einmalig. None = Gate aus (deaktiviert oder Lade-Fehler)."""
+    global _modell_cache, _ladeversuch
+    if _ladeversuch:
+        return _modell_cache
+    _ladeversuch = True
+    if not LESBARKEIT_AKTIV:
+        return None
+    try:
+        import torch
+        from transformers import AutoModelForSequenceClassification, AutoTokenizer
+        tok = AutoTokenizer.from_pretrained(LESBARKEIT_MODELL)
+        model = AutoModelForSequenceClassification.from_pretrained(LESBARKEIT_MODELL)
+        model.eval()
+        _modell_cache = (tok, model, torch)
+        log.info("Lesbarkeits-Modell geladen: %s (num_labels=%d)", LESBARKEIT_MODELL, model.config.num_labels)
+    except Exception as e:
+        log.warning("Lesbarkeits-Gate deaktiviert (Modell nicht ladbar): %s", e)
+        _modell_cache = None
+    return _modell_cache
+
+
+def _prosa(md: str) -> str:
+    """Markdown/Code strippen → reiner Fließtext für die Bewertung."""
+    t = _CODE_FENCE.sub(" ", md)
+    t = _COMMENT.sub(" ", t)
+    t = _INLINE_CODE.sub(" ", t)
+    t = _LINK.sub(r"\1", t)
+    t = _MD_MARK.sub(" ", t)
+    return _WS.sub(" ", t).strip()
+
+
+def _saetze(text: str) -> list[str]:
+    """Fließtext in Sätze splitten; sehr kurze Fragmente verwerfen."""
+    return [s.strip() for s in _SATZ.split(text) if len(s.strip()) >= 15]
+
+
+def _scores(saetze: list[str]) -> list[float]:
+    """Komplexität je Satz (1–7). Regression (num_labels=1) oder Erwartungswert über Klassen."""
+    tok, model, torch = _modell_cache
+    werte: list[float] = []
+    n = model.config.num_labels
+    for i in range(0, len(saetze), 16):
+        batch = saetze[i:i + 16]
+        enc = tok(batch, return_tensors="pt", truncation=True, max_length=256, padding=True)
+        with torch.no_grad():
+            logits = model(**enc).logits
+        if n == 1:
+            vals = logits.reshape(-1).tolist()
+        else:
+            probs = torch.softmax(logits, dim=-1)
+            stufen = torch.arange(1, n + 1, dtype=probs.dtype)
+            vals = (probs * stufen).sum(-1).reshape(-1).tolist()
+        werte.extend(vals)
+    return werte
+
+
+def bewerte_sections(md_by_num: dict[int, str]) -> dict[int, str]:
+    """{num: section_md} → {num: Hinweis} nur für zu schwere Sections.
+
+    Leeres dict, wenn das Gate aus ist. Blockierend (CPU) — in to_thread aufrufen.
+    """
+    if _modell() is None:
+        return {}
+    out: dict[int, str] = {}
+    for num, md in md_by_num.items():
+        saetze = _saetze(_prosa(md or ""))
+        if len(saetze) < 2:  # fast nur Code / zu kurz → überspringen
+            continue
+        werte = _scores(saetze)
+        if not werte:
+            continue
+        schnitt = sum(werte) / len(werte)
+        hart = sum(1 for w in werte if w > LESBARKEIT_HART) / len(werte)
+        # Zu schwer = hoher Schnitt ODER zu viele harte Einzelsätze (Ausreißer-Nester).
+        if schnitt > LESBARKEIT_MAX or hart >= LESBARKEIT_HART_ANTEIL:
+            out[num] = (
+                f"Zu schwer lesbar (Ø {schnitt:.1f}/7, {hart * 100:.0f}% harte Sätze): "
+                "kürzere Sätze, einfachere Wörter, weniger Schachtelsätze, mehr Beispiele."
+            )
+    return out