Update app.py

app.py

@@ -1,133 +1,129 @@
-import os
+import torch
+import torch.nn.functional as F
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import re
-from typing import List, Tuple
-
+import pandas as pd
 import gradio as gr
-from transformers import pipeline
 
 # -----------------------------
-# Model & simple pre-processing
+# MODEL (Fakespot 2025)
 # -----------------------------
-
-MODEL_ID = "fakespot-ai/roberta-base-ai-text-detection-v1"
-
-# Explicitly use CPU on Spaces
-clf = pipeline("text-classification", model=MODEL_ID, device=-1)
-
-def clean_text(s: str) -> str:
-    s = s.strip()
-    s = re.sub(r"\s+", " ", s)
-    return s
-
-def chunk_text(text: str, max_words: int = 300) -> List[str]:
-    words = text.split()
-    if len(words) <= max_words:
-        return [" ".join(words)]
-    chunks = []
-    for i in range(0, len(words), max_words):
-        chunks.append(" ".join(words[i : i + max_words]))
-    return chunks
+MODEL_NAME = "fakespot-ai/roberta-base-ai-text-detection-v1"
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+dtype = torch.bfloat16 if (device.type=="cuda" and torch.cuda.is_bf16_supported()) else torch.float32
+model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME, dtype=dtype).to(device).eval()
 
 # -----------------------------
-# Core inference
+# INTERNAL THRESHOLD for sentence labels/colors
 # -----------------------------
-
-def detect_ai(text: str) -> Tuple[str, float, str]:
-    """
-    Returns (label, score_float, explanation)
-    - label: "AI" or "Human"
-    - score_float: mean AI likelihood in [0,1]
-    - explanation: short narrative with a few heuristic cues
-    """
-    if not text or not text.strip():
-        return "—", 0.0, "Please paste some text to analyze."
-
-    chunks = [clean_text(c) for c in chunk_text(text, max_words=300)]
-    preds = clf(chunks)
-
-    ai_probs = []
-    for p in preds:
-        label = str(p.get("label", "")).upper()
-        score = float(p.get("score", 0.0))
-        ai_prob = score if label.startswith("AI") else (1.0 - score)
-        ai_probs.append(ai_prob)
-
-    mean_ai = sum(ai_probs) / len(ai_probs)
-    label = "AI" if mean_ai >= 0.5 else "Human"
-
-    explanation = build_explanation(text, mean_ai, len(chunks))
-    return label, float(mean_ai), explanation
-
-def build_explanation(text: str, ai_prob: float, n_chunks: int) -> str:
-    words = re.findall(r"\w+", text)
-    sentences = re.split(r"[.!?]+", text)
-    words = [w for w in words if w.strip()]
-    sentences = [s for s in sentences if s.strip()]
-
-    avg_len = (
-        sum(len(s.split()) for s in sentences) / max(1, len(sentences))
-        if sentences else 0
-    )
-    vocab = set(w.lower() for w in words)
-    ttr = len(vocab) / max(1, len(words))  # type-token ratio
-
-    cues = []
-    if ai_prob >= 0.75:
-        cues.append("very strong statistical signal matching AI-generated patterns")
-    elif ai_prob >= 0.6:
-        cues.append("moderate signal matching AI-generated patterns")
-    elif ai_prob <= 0.25:
-        cues.append("very low likelihood of AI, text patterns align with human writing")
-    else:
-        cues.append("mixed indicators, borderline case")
-
-    if avg_len > 25:
-        cues.append("longer-than-usual sentences")
-    elif avg_len < 10:
-        cues.append("very short, choppy sentences")
-
-    if ttr < 0.35:
-        cues.append("lower lexical variety")
-    elif ttr > 0.6:
-        cues.append("high lexical variety")
-
-    cues.append(f"analyzed in {n_chunks} chunk(s)")
-
-    return (
-        f"Overall this text is estimated to be {ai_prob:.2%} likely AI-generated. "
-        f"Notable cues: " + "; ".join(cues) + ". "
-        "Reminder: detectors can be wrong—use results as a hint, not proof."
-    )
+THRESHOLD = 0.70  # used only for per-sentence "AI/Human" tags & color
 
 # -----------------------------
-# Gradio UI
+# SENTENCE SPLITTER (protect → split → restore; no lookbehinds)
 # -----------------------------
+ABBR = [
+    "e.g", "i.e", "mr", "mrs", "ms", "dr", "prof", "vs", "etc", "fig", "al",
+    "jr", "sr", "st", "no", "vol", "pp", "mt", "inc", "ltd", "co", "u.s", "u.k",
+    "a.m", "p.m"
+]
+ABBR_REGEX = re.compile(r"\b(" + "|".join(map(re.escape, ABBR)) + r")\.", flags=re.IGNORECASE)
+
+def _protect(text: str) -> str:
+    t = text.strip()
+    if not t:
+        return ""
+    t = re.sub(r"\s*\n+\s*", " ", t)            # normalize newlines
+    t = t.replace("...", "⟨ELLIPSIS⟩")          # ellipses
+    t = re.sub(r"(?<=\d)\.(?=\d)", "⟨DECIMAL⟩", t)  # decimals like 3.14
+    t = ABBR_REGEX.sub(r"\1⟨ABBRDOT⟩", t)       # abbreviations' dot
+    return t
+
+def _restore(text: str) -> str:
+    return (text
+            .replace("⟨ABBRDOT⟩", ".")
+            .replace("⟨DECIMAL⟩", ".")
+            .replace("⟨ELLIPSIS⟩", "..."))
+
+def sentence_split(text: str):
+    t = _protect(text)
+    if not t:
+        return []
+    # split on [.?!] followed by whitespace and likely sentence start or end
+    parts = re.split(r"([.?!])\s+(?=(?:[\"“”‘’']?\s*[A-Z(])|$)", t)
+    sentences, buf = [], ""
+    for i, chunk in enumerate(parts):
+        if i % 2 == 0:
+            buf += chunk
+        else:
+            buf += chunk
+            sentences.append(buf.strip()); buf = ""
+    if buf.strip():
+        sentences.append(buf.strip())
+    return [_restore(s).strip() for s in sentences if s.strip()]
 
-with gr.Blocks(title="AI Text Detector") as demo:
-    gr.Markdown(
-        "## 🕵️ AI Text Detector (Simple)\n"
-        "Paste text and get an approximate AI-likeness score.\n\n"
-        "> Model: `fakespot-ai/roberta-base-ai-text-detection-v1`"
-    )
-
-    with gr.Row():
-        inp = gr.Textbox(label="Input Text", lines=14, placeholder="Paste your text here...")
+# -----------------------------
+# CORE: overall AI score + highlights
+# -----------------------------
+def analyze(text, max_len=512):
+    sents = sentence_split(text)
+    if not sents:
+        return "—", "—", "<em>Paste some text to analyze.</em>", None
+
+    # light clean (per model card vibe)
+    clean_sents = [re.sub(r"\s+", " ", s).strip() for s in sents]
+
+    inputs = tokenizer(
+        clean_sents, return_tensors="pt", padding=True, truncation=True, max_length=max_len
+    ).to(device)
+
+    with torch.no_grad():
+        logits = model(**inputs).logits
+        probs = F.softmax(logits, dim=-1)  # [:,0]=Human, [:,1]=AI
+
+    ai_probs = probs[:, 1].detach().cpu().tolist()
+    overall_ai = sum(ai_probs) / len(ai_probs)
+    overall_pct = f"{overall_ai * 100:.1f}%"
+    overall_label = "🤖 Likely AI Written" if overall_ai >= THRESHOLD else "🧒 Likely Human Written"
+
+    # Per-sentence highlights (use THRESHOLD only for the tag/color)
+    rows, highlights = [], []
+    for i, orig in enumerate(sents, start=1):
+        ai_p = float(ai_probs[i-1])
+        label = "AI" if ai_p >= THRESHOLD else "Human"
+        pct = f"{ai_p*100:.1f}%"
+        if ai_p < 0.30:
+            color = "#11823b"      # green
+        elif ai_p < 0.70:
+            color = "#b8860b"      # amber
+        else:
+            color = "#b80d0d"      # red
+        normalized = re.sub(r"\s+", " ", orig)
+        highlights.append(
+            "<div style='margin:6px 0; padding:6px 8px; border-radius:6px; background:rgba(0,0,0,0.03)'>"
+            f"<strong style='color:{color}'>[{pct} {label}]</strong> {normalized}</div>"
+        )
+        rows.append([i, orig, round(ai_p, 4), label])
+
+    html = "\n".join(highlights)
+    df = pd.DataFrame(rows, columns=["#", "Sentence", "AI_Prob", "Label"])
+    return overall_label, overall_pct, html, df
 
-    with gr.Row():
-        label_out = gr.Label(label="Predicted Class")
-        score_out = gr.Slider(label="AI Likelihood", minimum=0.0, maximum=1.0, step=0.001, interactive=False)
+# -----------------------------
+# GRADIO UI (verdict + score, plus highlights)
+# -----------------------------
+with gr.Blocks() as demo:
+    gr.Markdown("### 🕵️ AI Written Text Detector — Fakespot Model")
 
-    explain = gr.Textbox(label="Explanation", lines=6)
+    text_input = gr.Textbox(label="Paste text", lines=14, placeholder="Your content…")
+    btn = gr.Button("Analyze")
 
-    def _run(t: str):
-        label, score, expl = detect_ai(t)
-        return {label_out: {label: 1.0}, score_out: score, explain: expl}
+    verdict = gr.Label(label="Verdict (Overall)")
+    score = gr.Label(label="AI Score (Average across sentences)")
+    highlights = gr.HTML(label="Per-Sentence Highlights")
+    table = gr.Dataframe(headers=["#", "Sentence", "AI_Prob", "Label"], wrap=True)
 
-    gr.Button("Analyze").click(_run, inputs=inp, outputs=[label_out, score_out, explain])
+    btn.click(analyze, inputs=[text_input], outputs=[verdict, score, highlights, table])
 
 if __name__ == "__main__":
-    # For Spaces, PORT is provided by the environment
-    demo.queue().launch(
-        server_name="0.0.0.0",
-        server_port=int(os.getenv("PORT", 7860))
-    )
+    demo.launch()