Update app.py

app.py

@@ -1,129 +1,120 @@
-import torch
-import torch.nn.functional as F
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import re
-import pandas as pd
+from typing import List, Tuple
 import gradio as gr
+from transformers import pipeline
 
 # -----------------------------
-# MODEL (Fakespot 2025)
+# Model & simple pre-processing
 # -----------------------------
-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()
 
-# -----------------------------
-# INTERNAL THRESHOLD for sentence labels/colors
-# -----------------------------
-THRESHOLD = 0.70  # used only for per-sentence "AI/Human" tags & color
+MODEL_ID = "fakespot-ai/roberta-base-ai-text-detection-v1"
+clf = pipeline("text-classification", model=MODEL_ID)
 
-# -----------------------------
-# 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()]
+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
 
 # -----------------------------
-# CORE: overall AI score + highlights
+# Core inference
 # -----------------------------
-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
+
+def detect_ai(text: str) -> Tuple[str, float, str]:
+    """
+    Returns (label, score_float, explanation)
+    """
+    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)]
+    # Run model in batch for speed
+    preds = clf(chunks)
+
+    # Aggregate: average confidence across chunks for the detected class
+    # The model returns a label per chunk; we map AI=1, Human=0 and average
+    ai_probs = []
+    for p in preds:
+        # Some models return 'AI'/'Human' labels; normalize
+        label = 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"
+
+    # Lightweight heuristic explanation (no extra LLM needed)
+    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) + ". "
+        "Remember: detectors can be wrong—use results as a hint, not proof."
+    )
 
 # -----------------------------
-# GRADIO UI (verdict + score, plus highlights)
+# Gradio UI
 # -----------------------------
-with gr.Blocks() as demo:
-    gr.Markdown("### 🕵️ AI Written Text Detector — Fakespot Model")
 
-    text_input = gr.Textbox(label="Paste text", lines=14, placeholder="Your content…")
-    btn = gr.Button("Analyze")
+with gr.Blocks(title="AI Text Detector") as demo:
+    gr.Markdown("## 🕵️ AI Text Detector (Simple)\nPaste text and get an approximate AI-likeness score.\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...")
+    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)
+    explain = gr.Textbox(label="Explanation", lines=6)
 
-    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)
+    def _run(t):
+        label, score, expl = detect_ai(t)
+        return {label_out: {label: 1.0}, score_out: score, explain: expl}
 
-    btn.click(analyze, inputs=[text_input], outputs=[verdict, score, highlights, table])
+    gr.Button("Analyze").click(_run, inputs=inp, outputs=[label_out, score_out, explain])
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)))