Upload app.py

app.py

@@ -0,0 +1,523 @@
+"""
+groundlens — Geometric LLM Hallucination Detection Demo
+
+Plain-language interface: paste a question and the AI's answer,
+optionally upload context (PDF, Excel, or plain text).
+Compares groundlens (embedding geometry) vs Vectara HHEM-2.1-Open.
+
+Models load once at module level to avoid cold-start on Space wake.
+"""
+
+import logging
+import time
+import os
+
+import gradio as gr
+from groundlens import compute_sgi, compute_dgi
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# FILE EXTRACTION — PDF and Excel support
+# ─────────────────────────────────────────────────────────────────────────────
+
+def extract_pdf_text(file_path: str, max_chars: int = 8000) -> str:
+    """Extract text from a PDF file."""
+    try:
+        import pdfplumber
+        text_parts = []
+        with pdfplumber.open(file_path) as pdf:
+            for page in pdf.pages[:20]:
+                page_text = page.extract_text()
+                if page_text:
+                    text_parts.append(page_text)
+        full_text = "\n\n".join(text_parts)
+        return full_text[:max_chars] if len(full_text) > max_chars else full_text
+    except Exception as e:
+        return f"[Could not read PDF: {e}]"
+
+
+def extract_excel_text(file_path: str, max_chars: int = 8000) -> str:
+    """Extract text from an Excel file."""
+    try:
+        import openpyxl
+        wb = openpyxl.load_workbook(file_path, data_only=True)
+        text_parts = []
+        for sheet_name in wb.sheetnames[:5]:
+            ws = wb[sheet_name]
+            text_parts.append(f"--- {sheet_name} ---")
+            for row in ws.iter_rows(max_row=200, values_only=True):
+                cells = [str(c) if c is not None else "" for c in row]
+                line = " | ".join(cells).strip()
+                if line and line != " | ".join([""] * len(cells)):
+                    text_parts.append(line)
+        full_text = "\n".join(text_parts)
+        return full_text[:max_chars] if len(full_text) > max_chars else full_text
+    except Exception as e:
+        return f"[Could not read Excel file: {e}]"
+
+
+def extract_file_to_text(file) -> str:
+    """Extract text from an uploaded file and return it for the textbox."""
+    if file is None:
+        return ""
+
+    file_path = file.name if hasattr(file, 'name') else str(file)
+    ext = os.path.splitext(file_path)[1].lower()
+    basename = os.path.basename(file_path)
+
+    if ext == ".pdf":
+        text = extract_pdf_text(file_path)
+    elif ext in (".xlsx", ".xls"):
+        text = extract_excel_text(file_path)
+    elif ext in (".txt", ".md", ".csv"):
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                text = f.read(8000)
+        except Exception as e:
+            text = f"[Could not read file: {e}]"
+    else:
+        text = f"[Unsupported file type: {ext}. Use PDF, Excel, TXT, or CSV.]"
+
+    if text and not text.startswith("["):
+        return f"[Extracted from {basename}]\n\n{text}"
+    return text
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# HHEM-2.1-Open — baseline comparison
+# ─────────────────────────────────────────────────────────────────────────────
+
+logger.info("Loading HHEM-2.1-Open...")
+from transformers import AutoModelForSequenceClassification
+
+_hhem = AutoModelForSequenceClassification.from_pretrained(
+    "vectara/hallucination_evaluation_model",
+    trust_remote_code=True,
+)
+logger.info("HHEM loaded.")
+
+# Warm up groundlens embedding model
+logger.info("Warming up groundlens...")
+compute_dgi(question="warmup", response="warmup")
+logger.info("groundlens ready.")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# SCORING
+# ─────────────────────────────────────────────────────────────────────────────
+
+def score_groundlens(question: str, response: str, context: str) -> dict:
+    start = time.perf_counter()
+    has_context = bool(context.strip())
+
+    if has_context:
+        result = compute_sgi(
+            question=question,
+            context=context,
+            response=response,
+        )
+        method = "SGI (with context)"
+        raw_score = result.value
+        grounded = not result.flagged
+        threshold = 0.95
+        mode_note = (
+            "Measured how much the AI's answer used your source document "
+            "vs. just rephrasing the question."
+        )
+    else:
+        result = compute_dgi(
+            question=question,
+            response=response,
+        )
+        method = "DGI (without context)"
+        raw_score = result.value
+        grounded = not result.flagged
+        threshold = 0.30
+        mode_note = (
+            "Measured whether the AI's answer follows patterns typical "
+            "of grounded, factual responses."
+        )
+
+    elapsed_ms = (time.perf_counter() - start) * 1000
+
+    return {
+        "method": method,
+        "raw_score": round(raw_score, 4),
+        "grounded": grounded,
+        "threshold": threshold,
+        "elapsed_ms": round(elapsed_ms, 1),
+        "mode_note": mode_note,
+    }
+
+
+def score_hhem(question: str, response: str, context: str) -> dict:
+    has_context = bool(context.strip())
+    premise = (
+        f"{context.strip()}\n\n{question}".strip()
+        if has_context
+        else question
+    )
+    if len(premise) > 1800:
+        premise = premise[:1800]
+
+    start = time.perf_counter()
+    scores = _hhem.predict([(premise, response)])
+    raw_score = float(scores[0])
+    elapsed_ms = (time.perf_counter() - start) * 1000
+
+    return {
+        "method": "HHEM-2.1-Open",
+        "raw_score": round(raw_score, 4),
+        "grounded": raw_score >= 0.5,
+        "elapsed_ms": round(elapsed_ms, 1),
+        "label": "consistent" if raw_score >= 0.5 else "hallucinated",
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# MAIN COMPARISON — now takes only text inputs (no file object)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def run_comparison(
+    question: str, context_text: str, response: str
+) -> tuple[str, str, str]:
+
+    if not question.strip():
+        return "⚠️ Enter the question you asked the AI.", "", ""
+    if not response.strip():
+        return "⚠️ Enter the AI's response.", "", ""
+
+    # Strip the "[Extracted from ...]" header if present
+    context = context_text.strip()
+    if context.startswith("[Extracted from "):
+        newline_pos = context.find("\n")
+        if newline_pos > 0:
+            context = context[newline_pos:].strip()
+
+    gl = score_groundlens(question, response, context)
+    hhem = score_hhem(question, response, context)
+
+    # groundlens result
+    if gl["grounded"]:
+        gl_verdict = "🟢 Looks grounded"
+        gl_explain = "The AI's answer appears to be based on real information."
+    else:
+        gl_verdict = "🔴 Possible hallucination"
+        gl_explain = "The AI's answer shows signs of being fabricated or not grounded in the source."
+
+    gl_md = f"""### groundlens
+
+**{gl_verdict}**
+
+{gl_explain}
+
+| | |
+|---|---|
+| **Method** | {gl["method"]} |
+| **Score** | {gl["raw_score"]} (threshold: {gl["threshold"]}) |
+| **Time** | {gl["elapsed_ms"]} ms |
+
+*{gl["mode_note"]}*"""
+
+    # HHEM result
+    if hhem["grounded"]:
+        hhem_verdict = "🟢 Looks consistent"
+        hhem_explain = "The classifier considers this answer consistent with the input."
+    else:
+        hhem_verdict = "🔴 Possible hallucination"
+        hhem_explain = "The classifier flagged this answer as potentially hallucinated."
+
+    hhem_md = f"""### Vectara HHEM-2.1-Open
+
+**{hhem_verdict}**
+
+{hhem_explain}
+
+| | |
+|---|---|
+| **Method** | {hhem["method"]} |
+| **Score** | {hhem["raw_score"]} ({hhem["label"]}) |
+| **Time** | {hhem["elapsed_ms"]} ms |
+
+*Fine-tuned flan-T5 classifier.*"""
+
+    # Agreement
+    agree = gl["grounded"] == hhem["grounded"]
+    if agree and gl["grounded"]:
+        agreement_md = "### 🔵 Both methods agree: the answer looks reliable."
+    elif agree and not gl["grounded"]:
+        agreement_md = "### 🔴 Both methods agree: this answer is likely hallucinated."
+    else:
+        agreement_md = """### 🟠 The two methods disagree.
+
+This often happens with **subtle factual errors** — the answer sounds right and
+uses the correct vocabulary, but gets specific facts wrong. Embedding geometry
+(groundlens) measures the shape of the answer; the classifier (HHEM) evaluates
+its content differently. When they disagree, it's worth checking the facts manually.
+
+[Learn more about hallucination types →](https://docs.groundlens.dev/theory/hallucination-taxonomy/)"""
+
+    return gl_md, hhem_md, agreement_md
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# EXAMPLES
+# ─────────────────────────────────────────────────────────────────────────────
+
+EXAMPLES = [
+    [
+        "What does the water damage policy cover?",
+        "Coverage includes burst pipes and sudden appliance failure up to "
+        "$50,000. Flood damage requires a separate NFIP policy. "
+        "Deductible is $1,500 per occurrence.",
+        "The policy covers burst pipes and sudden appliance failure up to "
+        "$50,000 per occurrence, with a $1,500 deductible.",
+    ],
+    [
+        "What does the water damage policy cover?",
+        "Coverage includes burst pipes and sudden appliance failure up to "
+        "$50,000. Flood damage requires a separate NFIP policy. "
+        "Deductible is $1,500 per occurrence.",
+        "The policy covers all water damage including floods "
+        "with no deductible required.",
+    ],
+    [
+        "What causes seasons on Earth?",
+        "",
+        "Seasons are caused by Earth's 23.5-degree axial tilt, which "
+        "changes how directly sunlight hits each hemisphere.",
+    ],
+    [
+        "What causes seasons on Earth?",
+        "",
+        "Seasons are regulated by the Atmospheric Regulation Committee, "
+        "a UN body established in 1952 that adjusts global temperature "
+        "through orbital satellites.",
+    ],
+]
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# THEME — dark, matching groundlens.dev
+# ─────────────────────────────────────────────────────────────────────────────
+
+_orange = gr.themes.Color(
+    c50="#fff7ed",
+    c100="#ffedd5",
+    c200="#fed7aa",
+    c300="#fdba74",
+    c400="#fb923c",
+    c500="#fc7604",
+    c600="#ea580c",
+    c700="#c2410c",
+    c800="#9a3412",
+    c900="#7c2d12",
+    c950="#431407",
+)
+
+theme = gr.Theme.from_hub("Bruhn/CrimsonNight").set(
+    # Override crimson red → groundlens orange
+    button_primary_background_fill="#fc7604",
+    button_primary_background_fill_dark="#fc7604",
+    button_primary_background_fill_hover="#fb923c",
+    button_primary_background_fill_hover_dark="#fb923c",
+    button_primary_text_color="#0a0a0a",
+    button_primary_text_color_dark="#0a0a0a",
+    border_color_primary="#fc7604",
+    border_color_primary_dark="#fc7604",
+)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# INTERFACE
+# ─────────────────────────────────────────────────────────────────────────────
+
+css = """
+.gradio-container {
+    max-width: 1200px !important;
+    margin: 0 auto !important;
+    padding: 1.5rem !important;
+}
+h1 { color: #fc7604 !important; font-size: 2.2rem !important; font-weight: 700 !important; margin-bottom: 0.2rem !important; }
+h3 { font-size: 1.15rem !important; }
+.subtitle { color: #94a3b8 !important; font-size: 1.1rem !important; margin-top: 0 !important; }
+a { color: #fd9a42 !important; }
+a:hover { color: #fec08a !important; }
+.step-label { color: #fc7604; font-weight: 600; font-size: 1.05rem; }
+.links-bar { font-size: 0.9rem; color: #64748b; margin-top: 0.5rem; }
+.links-bar a { color: #64748b !important; }
+.links-bar a:hover { color: #fd9a42 !important; }
+footer { display: none !important; }
+
+/* Upload button — small, dashed secondary style */
+.upload-btn { margin-top: 0.25rem !important; }
+.upload-btn button {
+    background: transparent !important;
+    border: 1px dashed #475569 !important;
+    color: #94a3b8 !important;
+    font-size: 0.85rem !important;
+    padding: 0.4rem 1rem !important;
+    border-radius: 6px !important;
+}
+.upload-btn button:hover {
+    border-color: #fc7604 !important;
+    color: #fc7604 !important;
+}
+.upload-status p {
+    color: #94a3b8 !important;
+    font-size: 0.85rem !important;
+    margin: 0.25rem 0 0 0 !important;
+    font-style: italic;
+}
+@media (max-width: 768px) {
+    .gradio-container { padding: 0.75rem !important; }
+    h1 { font-size: 1.6rem !important; }
+}
+"""
+
+with gr.Blocks(
+    title="groundlens — Check if your AI is hallucinating",
+    theme=theme,
+    css=css,
+) as demo:
+
+    gr.Markdown("""
+# groundlens
+
+<p class="subtitle">Check if an AI gave you a real answer or made something up.</p>
+""")
+
+    gr.Markdown("""
+You asked an AI a question and got an answer. Was it real or hallucinated?
+Paste both below and we'll check using two independent methods: **groundlens**
+(geometric analysis) and **Vectara HHEM** (neural classifier).
+""")
+
+    gr.Markdown("""<p class="links-bar">
+<a href="https://github.com/groundlens-dev/groundlens">GitHub</a> ·
+<a href="https://docs.groundlens.dev">Docs</a> ·
+<a href="https://pypi.org/project/groundlens/">PyPI</a> ·
+<a href="https://arxiv.org/abs/2512.13771">SGI paper</a> ·
+<a href="https://arxiv.org/pdf/2602.13224v3">Taxonomy</a> ·
+<a href="https://arxiv.org/abs/2603.13259">Mechanistic paper</a>
+</p>""")
+
+    # ── Step 1: Question ──
+    gr.Markdown('<p class="step-label">1. What did you ask the AI?</p>')
+    q_in = gr.Textbox(
+        show_label=False,
+        placeholder="e.g. What does our insurance policy cover for water damage?",
+        lines=2,
+    )
+
+    # ── Step 2: Context ──
+    gr.Markdown(
+        '<p class="step-label">2. Did you give the AI any source material? (optional)</p>'
+    )
+    gr.Markdown(
+        "If you gave the AI a document, a webpage, an Excel file, or any reference "
+        "material to base its answer on, paste the text below. "
+        "If you just asked a question with no source, skip this step.",
+    )
+
+    ctx_in = gr.Textbox(
+        show_label=False,
+        placeholder="Paste the source text here, or use the upload button below to extract text from a file...",
+        lines=5,
+    )
+
+    # Hidden file input + visible upload button
+    file_in = gr.File(
+        file_types=[".pdf", ".xlsx", ".xls", ".csv", ".txt"],
+        file_count="single",
+        visible=False,
+    )
+    upload_status = gr.Markdown("", elem_classes=["upload-status"])
+
+    upload_btn = gr.UploadButton(
+        "📄 Upload a file (PDF, Excel, CSV, TXT)",
+        file_types=[".pdf", ".xlsx", ".xls", ".csv", ".txt"],
+        file_count="single",
+        elem_classes=["upload-btn"],
+    )
+
+    def handle_upload(file, existing_text):
+        """Extract file text and append to context textbox."""
+        extracted = extract_file_to_text(file)
+        if not extracted:
+            return existing_text, ""
+        if extracted.startswith("[Could not") or extracted.startswith("[Unsupported"):
+            return existing_text, f"⚠️ {extracted}"
+
+        basename = os.path.basename(file.name if hasattr(file, 'name') else str(file))
+        # Replace existing content or append
+        if existing_text and existing_text.strip():
+            new_text = existing_text.strip() + "\n\n" + extracted
+        else:
+            new_text = extracted
+        return new_text, f"✓ Extracted text from **{basename}**"
+
+    upload_btn.upload(
+        fn=handle_upload,
+        inputs=[upload_btn, ctx_in],
+        outputs=[ctx_in, upload_status],
+    )
+
+    # ── Step 3: Response ──
+    gr.Markdown('<p class="step-label">3. What did the AI answer?</p>')
+    r_in = gr.Textbox(
+        show_label=False,
+        placeholder="Paste the AI's response here...",
+        lines=4,
+    )
+
+    # ── Evaluate button ──
+    run_btn = gr.Button(
+        "Check for hallucination",
+        variant="primary",
+        size="lg",
+    )
+
+    # ── Results ──
+    with gr.Row(equal_height=True):
+        gl_out = gr.Markdown()
+        hhem_out = gr.Markdown()
+
+    agreement_out = gr.Markdown()
+
+    # ── Examples ──
+    gr.Markdown("---")
+    gr.Markdown("### Try an example")
+
+    gr.Examples(
+        examples=EXAMPLES,
+        inputs=[q_in, ctx_in, r_in],
+        label="",
+    )
+
+    # ── Footer ──
+    gr.Markdown("""
+---
+
+<p style="color:#475569; font-size:0.85rem; text-align:center;">
+<strong>groundlens</strong> is open source (MIT). Built by
+<a href="https://jmarin.info" style="color:#64748b !important;">Javier Marin</a>.
+This demo runs the same library available via <code>pip install groundlens</code>.<br>
+groundlens is verification triage, not a truth oracle. It tells you which answers
+deserve trust and which need a closer look.
+</p>
+""")
+
+    # ── Event binding ──
+    run_btn.click(
+        fn=run_comparison,
+        inputs=[q_in, ctx_in, r_in],
+        outputs=[gl_out, hhem_out, agreement_out],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()