Update app.py

app.py

@@ -17,19 +17,23 @@ model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME, dtype=dty
 # -----------------------------
 # AI DECISION THRESHOLD (80%)
 # -----------------------------
-THRESHOLD = 0.80  # AI from 80% and above
+THRESHOLD = 0.80
 
 # -----------------------------
 # SENTENCE SPLITTING UTILITIES
 # -----------------------------
 ABBR = [
     "e.g", "i.e", "mr", "mrs", "ms", "dr", "prof", "vs", "etc", "fig", "al",
-    "jr", "sr",    "st", "no", "vol", "pp", "mt", "inc", "ltd", "co",
+    "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:
+ABBR_REGEX = re.compile(
+    r"\b(" + "|".join(map(re.escape, ABBR)) + r")\.",
+    flags=re.IGNORECASE
+)
+
+def _protect(text):
     t = text.strip()
     if not t:
         return ""
@@ -39,17 +43,21 @@ def _protect(text: str) -> str:
     t = ABBR_REGEX.sub(r"\1⟨ABBRDOT⟩", t)
     return t
 
-def _restore(text: str) -> str:
-    return (text
-            .replace("⟨ABBRDOT⟩", ".")
+def _restore(text):
+    return (
+        text.replace("⟨ABBRDOT⟩", ".")
             .replace("⟨DECIMAL⟩", ".")
-            .replace("⟨ELLIPSIS⟩", "..."))
+            .replace("⟨ELLIPSIS⟩", "...")
+    )
 
-def sentence_split(text: str):
+def sentence_split(text):
     t = _protect(text)
     if not t:
         return []
-    parts = re.split(r"([.?!])\s+(?=(?:[\"“”‘’']?\s*[A-Z(])|$)", t)
+
+    parts = re.split(
+        r"([.?!])\s+(?=(?:[\"“”‘’']?\s*[A-Z(])|$)", t
+    )
 
     sentences, buf = [], ""
     for i, chunk in enumerate(parts):
@@ -65,39 +73,76 @@ def sentence_split(text: str):
 
     return [_restore(s).strip() for s in sentences if s.strip()]
 
+
+# -----------------------------
+# PARAGRAPH UTILITIES
+# -----------------------------
+def split_paragraphs(text):
+    paragraphs = [p.strip() for p in text.split("\n") if p.strip()]
+    return paragraphs
+
+def map_sentences_to_paragraphs(paragraphs):
+    all_sentences = []
+    mapping = []
+
+    for p_idx, para in enumerate(paragraphs):
+        sents = sentence_split(para)
+        for s_idx, s in enumerate(sents):
+            all_sentences.append(s)
+            mapping.append((p_idx, s_idx))
+
+    return all_sentences, mapping
+
+def combine_paragraph_scores(paragraphs, mapping, sentence_probs):
+    bucket = [[] for _ in paragraphs]
+
+    for (p_idx, _), prob in zip(mapping, sentence_probs):
+        bucket[p_idx].append(prob)
+
+    final_scores = [
+        (sum(scores) / len(scores)) if scores else 0
+        for scores in bucket
+    ]
+
+    return final_scores
+
+
 # -----------------------------
 # GROUP SENTENCES (TURNITIN STYLE)
 # -----------------------------
 def group_sentences(sents, size=3):
-    grouped = []
-    for i in range(0, len(sents), size):
-        grouped.append(" ".join(sents[i:i+size]))
-    return grouped
+    return [" ".join(sents[i:i + size]) for i in range(0, len(sents), size)]
+
 
 # -----------------------------
-# CORE ANALYSIS (3 SENTENCE WINDOWS)
+# CORE ANALYSIS
 # -----------------------------
 def analyze(text, max_len=512):
-    sents = sentence_split(text)
-    if not sents:
+    paragraphs = split_paragraphs(text)
+    if not paragraphs:
         return "—", "—", "<em>Paste some text to analyze.</em>", None
 
-    # GROUP sentences (3 at a time)
-    grouped = group_sentences(sents, size=3)
+    # map paragraphs → sentences
+    sents, mapping = map_sentences_to_paragraphs(paragraphs)
+
+    # group sentences in 3s
+    grouped = group_sentences(sents, 3)
     clean_grouped = [re.sub(r"\s+", " ", g).strip() for g in grouped]
 
-    # tokenize grouped chunks
+    # tokenize chunks
     inputs = tokenizer(
-        clean_grouped, return_tensors="pt",
-        padding=True, truncation=True, max_length=max_len
+        clean_grouped,
+        return_tensors="pt",
+        padding=True,
+        truncation=True,
+        max_length=max_len
     ).to(device)
 
-    # model inference
     with torch.no_grad():
         logits = model(**inputs).logits
-        chunk_probs = F.softmax(logits, dim=-1)[:, 1].detach().cpu().tolist()
+        chunk_probs = F.softmax(logits, dim=-1)[:, 1].cpu().tolist()
 
-    # EXPAND chunk-level probabilities to per-sentence (each chunk contributes to its 3 sentences)
+    # expand chunk probability to each sentence
     ai_probs = []
     for idx, prob in enumerate(chunk_probs):
         start = idx * 3
@@ -105,59 +150,59 @@ def analyze(text, max_len=512):
         for _ in range(start, end):
             ai_probs.append(prob)
 
-    # overall AI score
-    overall_ai = sum(ai_probs) / len(ai_probs)
-    overall_pct = f"{overall_ai * 100:.1f}%"
+    # final paragraph-level scores
+    paragraph_ai = combine_paragraph_scores(paragraphs, mapping, ai_probs)
 
+    # overall score
+    overall = sum(ai_probs) / len(ai_probs)
+    overall_pct = f"{overall * 100:.1f}%"
     overall_label = (
-        "🤖 Likely AI Written" if overall_ai >= THRESHOLD else "🧒 Likely Human Written"
+        "🤖 Likely AI Written" if overall >= THRESHOLD else "🧒 Likely Human Written"
     )
 
-    # HIGHLIGHTS + TABLE
-    rows, highlights = [], []
-
-    for i, orig in enumerate(sents, start=1):
-        ai_p = float(ai_probs[i-1])
-        pct = f"{ai_p * 100:.1f}%"
+    # paragraph-based HTML output
+    final_html = ""
+    for idx, (para, ai) in enumerate(zip(paragraphs, paragraph_ai), start=1):
+        pct = f"{ai * 100:.1f}%"
+        label = "AI" if ai >= THRESHOLD else "Human"
 
-        label = "AI" if ai_p >= THRESHOLD else "Human"
-
-        if ai_p < 0.30:
+        # color
+        if ai < 0.30:
             color = "#11823b"
-        elif ai_p < 0.70:
+        elif ai < 0.70:
             color = "#b8860b"
         else:
             color = "#b80d0d"
 
-        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> "
-            f"{normalized}</div>"
-        )
+        final_html += f"""
+        <div style='margin:12px 0; padding:12px; border-radius:8px; background:#fafafa'>
+            <strong style='color:{color}'>[Paragraph {idx}: {pct} {label}]</strong>
+            <div style='margin-top:8px; white-space:pre-wrap'>{para}</div>
+        </div>
+        """
 
-        rows.append([i, orig, round(ai_p, 4), label])
+    # sentence table (still available if needed)
+    rows = []
+    for i, s in enumerate(sents, start=1):
+        rows.append([i, s, round(ai_probs[i-1], 4)])
+    df = pd.DataFrame(rows, columns=["#", "Sentence", "AI_Prob"])
 
-    df = pd.DataFrame(rows, columns=["#", "Sentence", "AI_Prob", "Label"])
-    html = "\n".join(highlights)
+    return overall_label, overall_pct, final_html, df
 
-    return overall_label, overall_pct, html, df
 
 # -----------------------------
 # GRADIO UI
 # -----------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("### 🕵️ AI Written Text Detector — Fakespot Model (80% Threshold)")
+    gr.Markdown("### 🕵️ AI Written Text Detector — Fakespot Model (Turnitin-style Paragraph Mode)")
 
     text_input = gr.Textbox(label="Paste text", lines=14, placeholder="Your content…")
     btn = gr.Button("Analyze")
 
-    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)
+    verdict = gr.Label(label="Overall Verdict")
+    score = gr.Label(label="Overall AI Score")
+    highlights = gr.HTML(label="Paragraph Highlights (Original Format)")
+    table = gr.Dataframe(headers=["#", "Sentence", "AI_Prob"], wrap=True)
 
     btn.click(analyze, inputs=[text_input], outputs=[verdict, score, highlights, table])