Add scripts/benchmark.py

scripts/benchmark.py

@@ -0,0 +1,386 @@
+#!/usr/bin/env python
+"""Threshold calibration and retrieval benchmark.
+
+    uv run python scripts/benchmark.py
+
+Runs the 30-question evaluation set (20 answerable, 10 out-of-scope) through the
+real retrieval path and sweeps the cosine similarity threshold to find the value
+that best separates them. Writes a JSON result file and a Markdown report that
+feeds the README's "Threshold Analysis" section.
+
+With ``--with-rag`` it additionally exercises the full LLM path on a couple of
+questions using DEEPSEEK_API_KEY from .env, to prove the generation side works
+end to end. That flag is for the operator only; the web app never reads a key
+from the environment.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+import ehekim  # noqa: F401  (applies the torch/Triton compatibility fix first)
+
+import numpy as np
+
+from ehekim.config import (
+    EMBEDDING_MODEL_ID,
+    PROJECT_ROOT,
+    REFUSAL_MESSAGE_TR,
+    get_settings,
+    operator_secrets,
+)
+from ehekim.embedding import Embedder
+from ehekim.retrieval import build_rag_messages, expand_context, search
+from ehekim.vectorstore import VectorStore
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger("benchmark")
+
+DATA_DIR = PROJECT_ROOT / "data"
+QUESTIONS_PATH = DATA_DIR / "benchmark_questions.json"
+RESULTS_PATH = DATA_DIR / "benchmark_results.json"
+REPORT_PATH = DATA_DIR / "threshold_report.md"
+# Flat, viewer-friendly rendering of the 30-question evaluation set. The JSON
+# above is nested (positive/negative arrays) and therefore does not render in the
+# Hugging Face dataset viewer; this parquet does.
+QUESTIONS_PARQUET_PATH = DATA_DIR / "benchmark_questions.parquet"
+
+# Retrieval depth used for the analysis. Wider than the UI default so the sweep
+# can see what a permissive threshold would have admitted.
+ANALYSIS_TOP_K = 10
+SWEEP = np.round(np.arange(0.20, 0.901, 0.01), 2)
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="e-hekim threshold benchmark")
+    p.add_argument("--top-k", type=int, default=ANALYSIS_TOP_K)
+    p.add_argument("--device", default=None)
+    p.add_argument("--with-rag", action="store_true",
+                   help="Also call the LLM on two questions (needs DEEPSEEK_API_KEY in .env).")
+    return p.parse_args()
+
+
+def evaluate(embedder: Embedder, store: VectorStore, questions: dict, top_k: int) -> list[dict]:
+    """Retrieve once per question; the sweep then reuses these scores."""
+    rows: list[dict] = []
+    for label, items in (("positive", questions["positive"]), ("negative", questions["negative"])):
+        for item in items:
+            outcome = search(
+                embedder=embedder,
+                store=store,
+                query=item["question"],
+                top_k=top_k,
+                threshold=0.0,  # keep everything; the sweep applies the cut
+            )
+            hits = outcome.hits
+            expected_url = item.get("expected_url")
+            expected_rank = None
+            if expected_url:
+                for rank, hit in enumerate(hits, start=1):
+                    if hit.url == expected_url:
+                        expected_rank = rank
+                        break
+            rows.append(
+                {
+                    "id": item["id"],
+                    "label": label,
+                    "question": item["question"],
+                    "expected_url": expected_url,
+                    "expected_rank": expected_rank,
+                    "expected_similarity": (
+                        hits[expected_rank - 1].similarity if expected_rank else None
+                    ),
+                    "best_similarity": hits[0].similarity if hits else 0.0,
+                    "top_url": hits[0].url if hits else None,
+                    "top_title": hits[0].title if hits else None,
+                    "similarities": [round(h.similarity, 4) for h in hits],
+                }
+            )
+    return rows
+
+
+def sweep_thresholds(rows: list[dict]) -> list[dict]:
+    """Score the answer/refuse decision at every candidate threshold."""
+    positives = [r for r in rows if r["label"] == "positive"]
+    negatives = [r for r in rows if r["label"] == "negative"]
+
+    table: list[dict] = []
+    for threshold in SWEEP:
+        # A positive is answered correctly only if the system both decides to
+        # answer AND has the right source document above the cut. That is a
+        # stricter (and more honest) success criterion than "did not refuse".
+        tp = sum(
+            1 for r in positives
+            if r["best_similarity"] >= threshold
+            and r["expected_similarity"] is not None
+            and r["expected_similarity"] >= threshold
+        )
+        answered_positives = sum(1 for r in positives if r["best_similarity"] >= threshold)
+        fn = len(positives) - answered_positives
+        fp = sum(1 for r in negatives if r["best_similarity"] >= threshold)
+        tn = len(negatives) - fp
+
+        precision = tp / (tp + fp) if (tp + fp) else 0.0
+        recall = tp / len(positives) if positives else 0.0
+        f1 = (2 * precision * recall / (precision + recall)) if (precision + recall) else 0.0
+        accuracy = (answered_positives + tn) / len(rows)
+
+        table.append(
+            {
+                "threshold": float(threshold),
+                "answered_positives": answered_positives,
+                "grounded_positives": tp,
+                "missed_positives": fn,
+                "false_answers_on_negatives": fp,
+                "correct_refusals": tn,
+                "precision": round(precision, 4),
+                "recall": round(recall, 4),
+                "f1": round(f1, 4),
+                "accuracy": round(accuracy, 4),
+            }
+        )
+    return table
+
+
+def choose_threshold(table: list[dict]) -> tuple[float, dict]:
+    """Pick the most robust threshold among those achieving the best F1.
+
+    Several adjacent thresholds usually tie at the optimum. Taking the midpoint
+    of the widest tied run keeps the operating point as far as possible from
+    both failure modes, instead of sitting on a cliff edge.
+    """
+    best_f1 = max(row["f1"] for row in table)
+    tied = [row["threshold"] for row in table if row["f1"] == best_f1]
+
+    runs: list[list[float]] = []
+    current = [tied[0]]
+    for value in tied[1:]:
+        if round(value - current[-1], 2) <= 0.011:
+            current.append(value)
+        else:
+            runs.append(current)
+            current = [value]
+    runs.append(current)
+
+    widest = max(runs, key=len)
+    chosen = round(float(np.median(widest)), 2)
+    row = min(table, key=lambda r: abs(r["threshold"] - chosen))
+    return chosen, row
+
+
+def render_report(rows: list[dict], table: list[dict], chosen: float, chosen_row: dict,
+                  stats: dict) -> str:
+    lines: list[str] = []
+    lines.append("# Eşik Analizi (Threshold Analysis)\n")
+    lines.append(f"- Embedding modeli: `{EMBEDDING_MODEL_ID}` (768 boyut, kosinüs)")
+    lines.append(f"- Değerlendirme kümesi: {stats['n_positive']} pozitif + {stats['n_negative']} negatif soru")
+    lines.append(f"- Seçilen eşik: **{chosen:.2f}**\n")
+
+    lines.append("## Ayrışma (separation)\n")
+    lines.append("| Grup | En yüksek benzerlik (ort.) | Min | Maks |")
+    lines.append("|---|---:|---:|---:|")
+    lines.append(f"| Pozitif ({stats['n_positive']}) | {stats['pos_mean']:.4f} | "
+                 f"{stats['pos_min']:.4f} | {stats['pos_max']:.4f} |")
+    lines.append(f"| Negatif ({stats['n_negative']}) | {stats['neg_mean']:.4f} | "
+                 f"{stats['neg_min']:.4f} | {stats['neg_max']:.4f} |")
+    lines.append("")
+    lines.append(f"Ayrışma boşluğu: en düşük pozitif **{stats['pos_min']:.4f}** ile "
+                 f"en yüksek negatif **{stats['neg_max']:.4f}** arasında "
+                 f"**{stats['gap']:.4f}** fark var.\n")
+
+    lines.append("## Eşik taraması\n")
+    lines.append("| Eşik | Yanıtlanan poz. | Doğru kaynakla | Kaçırılan poz. | Negatife yanlış yanıt | F1 | Doğruluk |")
+    lines.append("|---:|---:|---:|---:|---:|---:|---:|")
+    shown = [r for r in table if abs(r["threshold"] * 100 % 5) < 1e-6 or r["threshold"] == chosen]
+    for row in shown:
+        marker = " **←**" if row["threshold"] == chosen_row["threshold"] else ""
+        lines.append(
+            f"| {row['threshold']:.2f}{marker} | {row['answered_positives']}/{stats['n_positive']} | "
+            f"{row['grounded_positives']}/{stats['n_positive']} | {row['missed_positives']} | "
+            f"{row['false_answers_on_negatives']}/{stats['n_negative']} | "
+            f"{row['f1']:.3f} | {row['accuracy']:.3f} |"
+        )
+    lines.append("")
+
+    failures = [r for r in rows if r["label"] == "positive" and r["expected_rank"] is None]
+    lines.append("## Kaynak makale geri çağırma (retrieval)\n")
+    hit_at_1 = sum(1 for r in rows if r["label"] == "positive" and r["expected_rank"] == 1)
+    hit_at_5 = sum(1 for r in rows
+                   if r["label"] == "positive" and r["expected_rank"] is not None and r["expected_rank"] <= 5)
+    lines.append(f"- Beklenen kaynak ilk sırada: **{hit_at_1}/{stats['n_positive']}**")
+    lines.append(f"- Beklenen kaynak ilk 5'te: **{hit_at_5}/{stats['n_positive']}**")
+    lines.append(f"- Beklenen kaynak ilk {ANALYSIS_TOP_K}'da bulunamadı: **{len(failures)}**\n")
+
+    lines.append("## Soru bazında en yüksek benzerlik\n")
+    lines.append("| ID | Tür | Soru | En yüksek benzerlik | Beklenen kaynak sırası |")
+    lines.append("|---|---|---|---:|---:|")
+    for row in rows:
+        rank = row["expected_rank"] if row["expected_rank"] else ("—" if row["label"] == "negative" else "bulunamadı")
+        question = row["question"] if len(row["question"]) <= 62 else row["question"][:59] + "…"
+        lines.append(
+            f"| {row['id']} | {'poz' if row['label'] == 'positive' else 'neg'} | {question} | "
+            f"{row['best_similarity']:.4f} | {rank} |"
+        )
+    lines.append("")
+    return "\n".join(lines)
+
+
+def write_questions_parquet(questions: dict, rows: list[dict], threshold: float) -> int:
+    """Write the 30-question set as one flat table, with measured outcomes.
+
+    One row per question, positives and negatives together, so a reader can see
+    the whole evaluation set and how the system actually scored on it without
+    cloning the repository.
+    """
+    import pandas as pd
+
+    by_id = {row["id"]: row for row in rows}
+    records: list[dict] = []
+
+    for label, items in (("positive", questions["positive"]), ("negative", questions["negative"])):
+        for item in items:
+            measured = by_id.get(item["id"], {})
+            best = measured.get("best_similarity")
+            answered = bool(best is not None and best >= threshold)
+            # A positive is correct when the system answers it; a negative is
+            # correct when the system refuses.
+            correct = answered if label == "positive" else not answered
+            records.append(
+                {
+                    "id": item["id"],
+                    "label": label,
+                    "question": item["question"],
+                    "topic": item.get("topic", ""),
+                    "expected_answer": item.get("expected_answer", ""),
+                    "expected_url": item.get("expected_url", ""),
+                    "rationale": item.get("rationale", ""),
+                    "best_similarity": round(float(best), 4) if best is not None else None,
+                    "expected_source_rank": measured.get("expected_rank"),
+                    "top_match_title": measured.get("top_title") or "",
+                    "top_match_url": measured.get("top_url") or "",
+                    "threshold": threshold,
+                    "system_decision": "answer" if answered else "refuse",
+                    "expected_decision": "answer" if label == "positive" else "refuse",
+                    "correct": correct,
+                }
+            )
+
+    frame = pd.DataFrame.from_records(records)
+    frame.to_parquet(QUESTIONS_PARQUET_PATH, index=False)
+    return len(frame)
+
+
+def run_rag_probe(embedder: Embedder, store: VectorStore, questions: dict, threshold: float) -> list[dict]:
+    """Exercise the generation path once on a positive and once on a negative."""
+    from ehekim import llm
+
+    api_key = operator_secrets().get("DEEPSEEK_API_KEY")
+    if not api_key:
+        logger.warning("DEEPSEEK_API_KEY yok; RAG denemesi atlanıyor.")
+        return []
+
+    probes = [questions["positive"][0], questions["negative"][0]]
+    out: list[dict] = []
+    for item in probes:
+        outcome = search(embedder=embedder, store=store, query=item["question"],
+                         top_k=5, threshold=threshold)
+        if not outcome.grounded:
+            out.append({"id": item["id"], "refused_before_llm": True, "answer": REFUSAL_MESSAGE_TR,
+                        "best_similarity": outcome.best_similarity})
+            logger.info("[%s] eşiğin altında -> LLM çağrılmadı.", item["id"])
+            continue
+        # Same path the API uses: expand after the gate, then generate.
+        passages = expand_context(store, outcome.hits)
+        result = llm.generate(
+            model_key=llm.DEFAULT_MODEL_KEY,
+            api_key=api_key,
+            messages=build_rag_messages(outcome.query, passages),
+            timeout=180.0,
+        )
+        out.append({"id": item["id"], "refused_before_llm": False, "answer": result.content,
+                    "model": result.model, "reasoning_tokens": result.reasoning_tokens,
+                    "context_passages": len(passages),
+                    "best_similarity": outcome.best_similarity})
+        logger.info("[%s] yanıt alındı (%s): %s", item["id"], result.model, result.content[:160])
+    return out
+
+
+def main() -> int:
+    args = parse_args()
+    settings = get_settings()
+    questions = json.loads(QUESTIONS_PATH.read_text(encoding="utf-8"))
+
+    store = VectorStore(settings.chroma_dir, settings.collection_name)
+    if store.count() == 0:
+        logger.error("Koleksiyon boş. Önce scripts/ingest.py çalıştırın.")
+        return 1
+    logger.info("Koleksiyon: %s parça", store.count())
+
+    embedder = Embedder(device=args.device, batch_size=16)
+    started = time.time()
+    rows = evaluate(embedder, store, questions, args.top_k)
+    logger.info("%s soru değerlendirildi (%.1fs)", len(rows), time.time() - started)
+
+    pos = np.array([r["best_similarity"] for r in rows if r["label"] == "positive"])
+    neg = np.array([r["best_similarity"] for r in rows if r["label"] == "negative"])
+    stats = {
+        "n_positive": int(len(pos)),
+        "n_negative": int(len(neg)),
+        "pos_mean": float(pos.mean()), "pos_min": float(pos.min()), "pos_max": float(pos.max()),
+        "neg_mean": float(neg.mean()), "neg_min": float(neg.min()), "neg_max": float(neg.max()),
+        "gap": float(pos.min() - neg.max()),
+    }
+    logger.info("Pozitif ort=%.4f min=%.4f | Negatif ort=%.4f maks=%.4f | boşluk=%.4f",
+                stats["pos_mean"], stats["pos_min"], stats["neg_mean"], stats["neg_max"], stats["gap"])
+
+    table = sweep_thresholds(rows)
+    chosen, chosen_row = choose_threshold(table)
+    logger.info("Seçilen eşik: %.2f (F1=%.3f, doğruluk=%.3f, negatife yanlış yanıt=%s)",
+                chosen, chosen_row["f1"], chosen_row["accuracy"],
+                chosen_row["false_answers_on_negatives"])
+
+    missing = [r["id"] for r in rows if r["label"] == "positive" and r["expected_rank"] is None]
+    if missing:
+        logger.warning("Beklenen kaynağı ilk %s içinde bulunamayan pozitif sorular: %s",
+                       args.top_k, ", ".join(missing))
+
+    rag_probe = run_rag_probe(embedder, store, questions, chosen) if args.with_rag else []
+
+    RESULTS_PATH.write_text(json.dumps(
+        {
+            "embedding_model": EMBEDDING_MODEL_ID,
+            "collection_chunks": store.count(),
+            "analysis_top_k": args.top_k,
+            "chosen_threshold": chosen,
+            "chosen_row": chosen_row,
+            "separation": stats,
+            "per_question": rows,
+            "sweep": table,
+            "rag_probe": rag_probe,
+        }, ensure_ascii=False, indent=2), encoding="utf-8")
+    REPORT_PATH.write_text(render_report(rows, table, chosen, chosen_row, stats), encoding="utf-8")
+    n_questions = write_questions_parquet(questions, rows, chosen)
+    logger.info("Yazıldı: %s, %s ve %s (%s soru)",
+                RESULTS_PATH.name, REPORT_PATH.name, QUESTIONS_PARQUET_PATH.name, n_questions)
+
+    correct = sum(
+        1 for r in rows
+        if (r["label"] == "positive") == (r["best_similarity"] >= chosen)
+    )
+    logger.info("Değerlendirme kümesi doğruluğu @%.2f: %s/%s", chosen, correct, len(rows))
+
+    if chosen_row["false_answers_on_negatives"] > 0:
+        logger.warning("Seçilen eşikte %s negatif soru hâlâ yanıtlanıyor.",
+                       chosen_row["false_answers_on_negatives"])
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())