feat: 0.3.0 – pix2text zuerst, Qwen bestätigt, Gemma nur bei Uneinigkeit

Neue Standardregel p2t (GLM/Cloud wird nicht mehr benutzt):
- pix2text liest zuerst; übernommen wird immer seine Lesart, wenn Qwen sie
  bestätigt oder – nur bei Uneinigkeit gefragt – Gemma. Qwen = Gemma gegen
  pix2text geht an einen Menschen. Schlusspunkt muss bestätigt sein; Bild-Veto
  und Pandoc auf pix2texts Lesart. Alte Regel als consensus_rule=vlm3 wählbar.
- pix2text auf der GPU (onnxruntime-gpu, FORMULA_P2T_DEVICE=auto/cpu/cuda:N)
- Ausgabe bereinigt: post_process aus pix2tex, Fettschreibweisen \boldmath/\bf
  -> \boldsymbol/\mathbf; an 400 Lesarten gleiches gesetztes Bild
- Normalform: \mathop, \begin{array}[t]
- calibrate: --engines, Regel-Tabelle, --reuse; wahre Formeln aus dem alt-Text
  bereinigt (aligned, \mathop{}\!, upgreek)
- tools/zeittest.py, tools/regeltest.py (--reuse, --exclude)

Messung: Göllmann Band 1 (2 x 150) 86 % / 85 % automatisch, 0 falsch
(bisher 78 % / 70 %); Band 2, zwei Stichproben zu 50: 78 % und 86 %, 0 falsch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tools/regeltest.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""Run the standard consensus rule on formulas whose TeX is known and show every case for review.
+
+    python3 tools/regeltest.py EPUB [--n 50] [--name regeltest] [--reuse vergleich/regeltest/ergebnis.json]
+                                    [--exclude vergleich/regeltest/ergebnis.json ...]
+
+Like `run`: pix2text reads every formula first, then Qwen (local); Gemma (local2) only where they
+disagree; then the rough image check on pix2text's reading and decide_pair_tiebreak. Writes
+vergleich/<name>/index.html (not versioned): summary, then per formula the original, the true
+formula and every reading set with pdflatex, the decision and whether the result is right.
+--reuse takes the readings (and their times) of an earlier run instead of asking the models again;
+--exclude leaves out the formulas of earlier runs, so a new sample has none of them.
+"""
+
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import random
+import statistics
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from konsens_bericht import orig_img, png_uri  # noqa: E402
+
+from formula_img2latex.calibrate import _best_preset, corpus  # noqa: E402
+from formula_img2latex.checks import pandoc_mathml_ok  # noqa: E402
+from formula_img2latex.consensus import same_reading  # noqa: E402
+from formula_img2latex.decide import consensus_thresholds, decide_pair_tiebreak  # noqa: E402
+from formula_img2latex.engines import make_engine  # noqa: E402
+from formula_img2latex.engines.p2t import tidy_p2t  # noqa: E402
+from formula_img2latex.imageio import load_ink  # noqa: E402
+from formula_img2latex.render import render_many  # noqa: E402
+from formula_img2latex.tex import strip_delimiters  # noqa: E402
+from formula_img2latex.verify import verify  # noqa: E402
+
+TOOLS = [("local", "Qwen"), ("p2t", "pix2text"), ("local2", "Gemma")]
+
+
+def agreements(texes: list[str | None], display: bool, preset: str) -> list[tuple[int, int, str]]:
+    """Pairs (Qwen, pix2text), (pix2text, Gemma), (Qwen, Gemma) as in pipeline.decide_all_consensus (strict)."""
+    out = []
+    for i, j in ((0, 1), (1, 2), (0, 2)):
+        a, b = texes[i], texes[j]
+        if a is None or b is None:
+            continue
+        how = same_reading(a, b, display, preset)
+        if how:
+            out.append((i, j, how))
+    return out
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("epub", type=Path)
+    ap.add_argument("--n", type=int, default=50)
+    ap.add_argument("--name", default="regeltest")
+    ap.add_argument("--reuse", type=Path, default=None, help="Lesarten aus einem früheren ergebnis.json")
+    ap.add_argument("--exclude", type=Path, action="append", default=[],
+                    help="Formeln aus diesem früheren ergebnis.json auslassen (mehrfach möglich)")
+    args = ap.parse_args()
+    cached = {}
+    if args.reuse:
+        cached = {c["name"]: c["readings"] for c in json.loads(args.reuse.read_text(encoding="utf-8"))["cases"]}
+        for rs in cached.values():   # earlier runs stored pix2text's raw spaced output
+            if rs[1] and rs[1].get("tex"):
+                rs[1]["tex"] = tidy_p2t(rs[1].get("raw") or rs[1]["tex"])
+    excluded = {c["name"] for x in args.exclude for c in json.loads(x.read_text(encoding="utf-8"))["cases"]}
+
+    items = [it for it in corpus(args.epub) if it[0] not in excluded]
+    smp = random.Random(42).sample(items, min(args.n + 1, len(items)))
+    formulas, warm = smp[:args.n], smp[args.n]
+    preset = _best_preset(smp[:12])
+    th = consensus_thresholds()
+    eng = {}
+    for key, label in ([] if cached else TOOLS):
+        e = make_engine(key)
+        t0 = time.time()
+        e.check()
+        e.recognize(warm[1], warm[0], "", warm[3])   # warm-up, not counted
+        eng[key] = e
+        print(f"{label}: {e.model}, bereit in {time.time() - t0:.1f} s", file=sys.stderr, flush=True)
+
+    cases = []
+    for k, (name, data, truth, disp) in enumerate(formulas, 1):
+        old = cached.get(name)
+        if cached and old is None:
+            raise SystemExit(f"{name} fehlt in {args.reuse} (andere Stichprobe?)")
+        reads: list[dict | None] = [None, None, None]
+        for pos in (1, 0):   # pix2text first, then Qwen
+            reads[pos] = old[pos] if old else eng[TOOLS[pos][0]].recognize(data, name, "", disp).to_json()
+        texes = [r and r.get("tex") for r in reads]
+        agree = agreements(texes, disp, preset)
+        if not any((i, j) == (0, 1) for i, j, _ in agree):   # disputed: ask Gemma
+            reads[2] = old[2] if old else eng["local2"].recognize(data, name, "", disp).to_json()
+            texes = [r and r.get("tex") for r in reads]
+            agree = agreements(texes, disp, preset)
+        _st, _why, use = decide_pair_tiebreak(reads, agree, None, True, None, th)
+        veto = None
+        pandoc = True
+        if use is not None and texes[use]:
+            v = verify(load_ink(data, name), texes[use], disp, preset, check_variants=False)
+            veto = {"ok": v.ok, "reason": v.reason, "metrics": v.metrics}
+            pandoc = pandoc_mathml_ok([(texes[use], disp)])[0]
+        status, reason, use = decide_pair_tiebreak(reads, agree, veto, pandoc, None, th)
+        ok = [bool(t) and bool(same_reading(t, truth, disp, preset)) for t in texes]
+        accepted = status == "auto_accepted"
+        cases.append({"name": name, "truth": truth, "display": disp, "readings": reads, "ok": ok, "agree": agree,
+                      "status": status, "reason": reason, "use": use, "veto": veto,
+                      "right": bool(accepted and ok[use])})
+        mark = ("✓" if ok[use] else "✗ FALSCH") if accepted else "Review"
+        print(f"{k:3d} {status:13s} {mark:8s} {reason[:110]}", file=sys.stderr, flush=True)
+
+    n = len(cases)
+    acc = [c for c in cases if c["status"] == "auto_accepted"]
+    wrong = [c for c in acc if not c["right"]]
+    review = [c for c in cases if c["status"] == "needs_review"]
+    gemma = sum(c["readings"][2] is not None for c in cases)
+    secs = {key: [c["readings"][p]["seconds"] for c in cases if c["readings"][p]] for p, (key, _l) in enumerate(TOOLS)}
+    per_formula = [sum(r["seconds"] for r in c["readings"] if r) for c in cases]
+    summary = {"formulas": n, "accepted": len(acc), "wrong": len(wrong), "review": len(review),
+               "other": n - len(acc) - len(review), "gemma_asked": gemma,
+               "mean_s_per_formula": statistics.mean(per_formula),
+               "mean_s": {k: statistics.mean(v) if v else None for k, v in secs.items()},
+               "correct_alone": {key: sum(c["ok"][p] for c in cases if c["readings"][p])
+                                 for p, (key, _l) in enumerate(TOOLS)}}
+
+    out = Path(__file__).resolve().parents[1] / "vergleich" / args.name
+    out.mkdir(parents=True, exist_ok=True)
+    (out / "ergebnis.json").write_text(json.dumps({"epub": args.epub.name, "preset": preset, "summary": summary,
+                                                   "cases": cases}, ensure_ascii=False, indent=1, default=str),
+                                       encoding="utf-8")
+
+    def order(c: dict) -> int:
+        return 0 if c["status"] == "auto_accepted" and not c["right"] else 1 if c["status"] != "auto_accepted" else 2
+
+    shown = sorted(cases, key=order)
+    texes = []
+    for c in shown:
+        texes.append((strip_delimiters(c["truth"]), c["display"]))
+        texes += [((r or {}).get("tex") or "\\text{–}", c["display"]) for r in c["readings"]]
+    rendered = render_many(texes, preset)
+    by_name = {f[0]: f[1] for f in formulas}
+    lab = dict(TOOLS)
+    head = (f"<h1>Regeltest: {html.escape(args.epub.name[:70])}</h1>"
+            "<p>Regel: pix2text liest zuerst, Qwen bestätigt → annehmen. Sonst fragt Gemma; Gemma = pix2text → annehmen; "
+            "Qwen = Gemma gegen pix2text → Mensch. Übernommen wird immer pix2texts Lesart (Leerzeichen bereinigt). "
+            "Annahme nur mit Pandoc und Bild-Veto. "
+            "✓/✗ = gleiche Zeichen an gleicher Stelle wie die wahre Formel (Abstände, kursiv/aufrecht, Fettdruck egal).</p>"
+            "<table class=sum>"
+            f"<tr><th>Formeln</th><td>{n}</td></tr>"
+            f"<tr><th>automatisch angenommen</th><td>{len(acc)} ({len(acc) / n:.0%})</td></tr>"
+            f"<tr><th>davon FALSCH</th><td><b>{len(wrong)}</b></td></tr>"
+            f"<tr><th>Review (Mensch)</th><td>{len(review)} ({len(review) / n:.0%})</td></tr>"
+            f"<tr><th>Gemma gefragt</th><td>{gemma} ({gemma / n:.0%})</td></tr>"
+            f"<tr><th>Ø Zeit pro Formel (alle Tools nacheinander)</th><td>{summary['mean_s_per_formula']:.2f} s</td></tr>"
+            + "".join(f"<tr><th>Ø {lab[k]}</th><td>{v:.2f} s</td></tr>" for k, v in summary["mean_s"].items() if v)
+            + "".join(f"<tr><th>{lab[k]} allein richtig</th><td>{v}/{len(secs[k])}</td></tr>"
+                      for k, v in summary["correct_alone"].items())
+            + "</table>")
+    parts = [head]
+    per = 4
+    for i, c in enumerate(shown):
+        imgs = []
+        for rr in rendered[per * i: per * (i + 1)]:
+            if rr.ok:
+                g = (rr.rasterize(2.0) * 255).astype(np.uint8)
+                imgs.append(f"<img src='{png_uri(Image.fromarray(255 - g))}'>")
+            else:
+                imgs.append("<i>nicht setzbar</i>")
+        if c["status"] == "auto_accepted":
+            cls, verdict = ("good", "angenommen, richtig") if c["right"] else ("bad", "angenommen, FALSCH")
+        elif c["status"] == "needs_review":
+            cls, verdict = "rev", "Review"
+        else:
+            cls, verdict = "rev", c["status"]
+        ncc = (c["veto"] or {}).get("metrics", {}).get("ncc")
+        rows = [f"<tr><th>Original</th><td><img src='{png_uri(orig_img(by_name[c['name']], 2))}'></td><td></td></tr>",
+                f"<tr><th>richtig</th><td>{imgs[0]}</td><td><code>{html.escape(c['truth'])}</code></td></tr>"]
+        for p, (key, label) in enumerate(TOOLS):
+            r = c["readings"][p]
+            if r is None:
+                rows.append(f"<tr><th>{label}</th><td><i>nicht gefragt</i></td><td></td></tr>")
+                continue
+            mark = "<b class=ok>✓</b>" if c["ok"][p] else "<b class=no>✗</b>"
+            used = " <b>← verwendet</b>" if c["use"] == p and c["status"] == "auto_accepted" else ""
+            rows.append(f"<tr><th>{mark} {label}{used}<br><small>{r['seconds']:.2f} s</small></th><td>{imgs[p + 1]}</td>"
+                        f"<td><code>{html.escape(r.get('tex') or r.get('error') or '–')}</code>"
+                        + (f"<br><small>roh: <code>{html.escape(r.get('raw') or '')}</code></small>"
+                           if key == "p2t" and r.get("raw") and r.get("raw") != r.get("tex") else "")
+                        + "</td></tr>")
+        parts.append(f"<section class={cls}><div class=v>{verdict} · {html.escape(c['reason'])}"
+                     f"{f' · Bild-Ähnlichkeit {ncc:.2f}' if ncc is not None else ''}</div>"
+                     f"<small>{html.escape(c['name'])}</small><table>{''.join(rows)}</table></section>")
+    (out / "index.html").write_text(
+        "<!doctype html><meta charset=utf-8><title>Regeltest</title><style>"
+        "body{font:14px system-ui,sans-serif;margin:16px;background:#f6f6f3}section{background:#fff;border:1px solid #ddd;"
+        "border-left:6px solid #999;border-radius:6px;padding:6px 10px;margin:10px 0}section.good{border-left-color:#1f7a3a}"
+        "section.bad{border-left-color:#a32020;background:#fff5f5}section.rev{border-left-color:#c88a00}"
+        ".v{font-weight:600;font-size:13px}table.sum{border-collapse:collapse;background:#fff}"
+        "table.sum td,table.sum th{border:1px solid #ccc;padding:4px 10px}"
+        "th{text-align:left;font-weight:400;color:#555;width:190px;vertical-align:middle}td{padding:3px 8px;vertical-align:middle}"
+        ".ok{color:#1f7a3a}.no{color:#a32020}code{font-size:12px}img{max-width:640px}</style>" + "".join(parts),
+        encoding="utf-8")
+    print(json.dumps(summary, ensure_ascii=False, indent=1))
+    print(out / "index.html")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tools/zeittest.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Time and accuracy per recognition tool on formulas whose TeX is known (serial, one at a time).
+
+    python3 tools/zeittest.py EPUB [--n 15] [--tools local,local2,cloud,p2t-cpu,p2t-gpu] [--gpu cuda:0]
+
+Same sample as `calibrate --consensus` (seed 42, real images). Every tool reads every formula alone,
+one request after the other, after one uncounted warm-up on another formula. Writes
+vergleich/zeittest/index.html (not versioned): table per tool, then per formula the original, the
+true formula and every reading set with pdflatex, with time and verdict; plus ergebnis.json.
+"""
+
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import random
+import statistics
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from konsens_bericht import orig_img, png_uri  # noqa: E402
+
+from formula_img2latex.calibrate import _best_preset, corpus  # noqa: E402
+from formula_img2latex.consensus import same_reading  # noqa: E402
+from formula_img2latex.engines import make_engine  # noqa: E402
+from formula_img2latex.engines.p2t import Pix2TextEngine  # noqa: E402
+from formula_img2latex.render import render_many  # noqa: E402
+from formula_img2latex.tex import strip_delimiters  # noqa: E402
+
+LABELS = {"local": "Qwen3-VL-30B (lokal, GPU)", "local2": "Gemma-4-26B (lokal, GPU)", "cloud": "GLM-4.6V (Cloud)",
+          "p2t-cpu": "pix2text MFR 1.5 (CPU)", "p2t-gpu": "pix2text MFR 1.5 (GPU)"}
+
+
+def engine_for(tool: str, gpu: str):
+    if tool == "p2t-cpu":
+        return Pix2TextEngine(device="cpu")
+    if tool == "p2t-gpu":
+        return Pix2TextEngine(device=gpu)
+    return make_engine(tool)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("epub", type=Path)
+    ap.add_argument("--n", type=int, default=15)
+    ap.add_argument("--tools", default="local,local2,cloud,p2t-cpu,p2t-gpu")
+    ap.add_argument("--gpu", default="cuda", help="Gerät für p2t-gpu (Index relativ zu CUDA_VISIBLE_DEVICES)")
+    ap.add_argument("--name", default="zeittest")
+    args = ap.parse_args()
+    tools = [t.strip() for t in args.tools.split(",") if t.strip()]
+
+    items = corpus(args.epub)
+    smp = random.Random(42).sample(items, min(150, len(items)))   # as calibrate_consensus
+    formulas, warm = smp[:args.n], smp[args.n]
+    preset = _best_preset(smp[:12])
+
+    runs: dict[str, dict] = {}
+    for tool in tools:
+        eng = engine_for(tool, args.gpu)
+        t0 = time.time()
+        eng.check()
+        load = time.time() - t0
+        eng.recognize(warm[1], warm[0], "", warm[3])   # warm-up, not counted
+        reads = []
+        for name, data, truth, disp in formulas:
+            r = eng.recognize(data, name, "", disp)
+            ok = bool(r.tex) and bool(same_reading(r.tex, truth, disp, preset))
+            reads.append({"tex": r.tex, "seconds": r.seconds, "ok": ok, "error": r.error,
+                          "tokens_in": r.tokens_in, "tokens_out": r.tokens_out})
+            print(f"{tool:8s} {r.seconds:6.2f}s {'✓' if ok else '✗'} {r.tex or r.error}", file=sys.stderr, flush=True)
+        secs = [x["seconds"] for x in reads]
+        runs[tool] = {"label": LABELS.get(tool, tool), "model": eng.model, "load_s": load, "reads": reads,
+                      "mean_s": statistics.mean(secs), "median_s": statistics.median(secs),
+                      "correct": sum(x["ok"] for x in reads), "errors": sum(bool(x["error"]) for x in reads),
+                      "tokens_in": sum(x["tokens_in"] for x in reads), "tokens_out": sum(x["tokens_out"] for x in reads)}
+
+    out = Path(__file__).resolve().parents[1] / "vergleich" / args.name
+    out.mkdir(parents=True, exist_ok=True)
+    (out / "ergebnis.json").write_text(json.dumps(
+        {"epub": args.epub.name, "preset": preset, "truth": [f[2] for f in formulas], "runs": runs},
+        ensure_ascii=False, indent=1), encoding="utf-8")
+
+    n = len(formulas)
+    rows = "".join(
+        f"<tr><td>{html.escape(r['label'])}</td><td>{r['mean_s']:.2f}</td><td>{r['median_s']:.2f}</td>"
+        f"<td>{r['correct']}/{n} ({r['correct'] / n:.0%})</td><td>{r['load_s']:.1f}</td>"
+        f"<td>{r['tokens_in'] + r['tokens_out'] or '–'}</td></tr>" for r in runs.values())
+    parts = [f"<h1>Zeittest: {html.escape(args.epub.name[:70])}</h1>",
+             f"<p>{n} Formeln mit bekanntem TeX (alt-Text), jedes Tool seriell, eine Formel nach der anderen, "
+             "nach einem nicht gezählten Aufwärmlauf. Alle Formeln mit pdflatex gesetzt. ✓ = gleiche Zeichen an "
+             "gleicher Stelle wie die wahre Formel (Abstände, kursiv/aufrecht, Fettdruck egal).</p>",
+             "<table class=sum><tr><th>Tool</th><th>Ø s/Formel</th><th>Median s</th><th>richtig</th>"
+             f"<th>Laden s</th><th>Tokens</th></tr>{rows}</table>"]
+
+    texes = []
+    for i, (_n, _d, truth, disp) in enumerate(formulas):
+        texes.append((strip_delimiters(truth), disp))
+        texes += [(runs[t]["reads"][i]["tex"] or "\\text{–}", disp) for t in tools]
+    rendered = render_many(texes, preset)
+    per = 1 + len(tools)
+    for i, (name, data, truth, _disp) in enumerate(formulas):
+        imgs = []
+        for rr in rendered[per * i: per * (i + 1)]:
+            if rr.ok:
+                g = (rr.rasterize(2.0) * 255).astype(np.uint8)
+                imgs.append(f"<img src='{png_uri(Image.fromarray(255 - g))}'>")
+            else:
+                imgs.append("<i>nicht setzbar</i>")
+        body = [f"<tr><th>Original</th><td><img src='{png_uri(orig_img(data, 2))}'></td><td></td></tr>",
+                f"<tr><th>richtig</th><td>{imgs[0]}</td><td><code>{html.escape(truth)}</code></td></tr>"]
+        for k, t in enumerate(tools):
+            r = runs[t]["reads"][i]
+            mark = "<b class=ok>✓</b>" if r["ok"] else "<b class=no>✗</b>"
+            body.append(f"<tr><th>{mark} {html.escape(runs[t]['label'])}<br><small>{r['seconds']:.2f} s</small></th>"
+                        f"<td>{imgs[k + 1]}</td><td><code>{html.escape(r['tex'] or r['error'] or '–')}</code></td></tr>")
+        parts.append(f"<section><div class=v>Formel {i + 1} · {html.escape(name)}</div><table>{''.join(body)}</table></section>")
+    (out / "index.html").write_text(
+        "<!doctype html><meta charset=utf-8><title>Zeittest</title><style>"
+        "body{font:14px system-ui,sans-serif;margin:16px;background:#f6f6f3}section{background:#fff;border:1px solid #ddd;"
+        "border-radius:6px;padding:6px 10px;margin:10px 0}.v{font-weight:600;font-size:13px;margin-bottom:4px}"
+        "table.sum{border-collapse:collapse;background:#fff}table.sum td,table.sum th{border:1px solid #ccc;padding:4px 10px}"
+        "th{text-align:left;font-weight:400;color:#555;width:210px;vertical-align:middle}td{padding:3px 8px;vertical-align:middle}"
+        ".ok{color:#1f7a3a}.no{color:#a32020}code{font-size:12px}img{max-width:640px}</style>" + "".join(parts),
+        encoding="utf-8")
+
+    print(f"\n| Tool | Ø s/Formel | Median s | richtig (n={n}) | Laden s |")
+    print("|---|---|---|---|---|")
+    for r in runs.values():
+        print(f"| {r['label']} | {r['mean_s']:.2f} | {r['median_s']:.2f} | {r['correct']}/{n} | {r['load_s']:.1f} |")
+    if "p2t-cpu" in runs and "p2t-gpu" in runs:
+        same = sum(a["tex"] == b["tex"] for a, b in zip(runs["p2t-cpu"]["reads"], runs["p2t-gpu"]["reads"]))
+        print(f"\npix2text CPU und GPU gleicher Text: {same}/{n}")
+    print(out / "index.html")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())