Update app.py

app.py

@@ -10,31 +10,24 @@ import gradio as gr
 # -----------------------------
 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()
+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()
 
 # -----------------------------
 # AI DECISION THRESHOLD (80%)
 # -----------------------------
-THRESHOLD = 0.80
+THRESHOLD = 0.80  # AI from 80% and above
 
 # -----------------------------
 # 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
-)
+ABBR_REGEX = re.compile(r"\b(" + "|".join(map(re.escape, ABBR)) + r")\.", flags=re.IGNORECASE)
 
 def _protect(text: str) -> str:
     t = text.strip()
@@ -47,19 +40,16 @@ def _protect(text: str) -> str:
     return t
 
 def _restore(text: str) -> str:
-    return (
-        text.replace("⟨ABBRDOT⟩", ".")
+    return (text
+            .replace("⟨ABBRDOT⟩", ".")
             .replace("⟨DECIMAL⟩", ".")
-            .replace("⟨ELLIPSIS⟩", "...")
-    )
+            .replace("⟨ELLIPSIS⟩", "..."))
 
 def sentence_split(text: str):
     t = _protect(text)
     if not t:
         return []
-
-    # hard sentence boundary detection
-    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):
@@ -75,49 +65,63 @@ def sentence_split(text: str):
 
     return [_restore(s).strip() for s in sentences if s.strip()]
 
+# -----------------------------
+# 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
 
 # -----------------------------
-# CORE ANALYSIS — PER SENTENCE
+# CORE ANALYSIS (3 SENTENCE WINDOWS)
 # -----------------------------
 def analyze(text, max_len=512):
     sents = sentence_split(text)
     if not sents:
         return "—", "—", "<em>Paste some text to analyze.</em>", None
 
-    clean_sents = [re.sub(r"\s+", " ", s).strip() for s in sents]
+    # GROUP sentences (3 at a time)
+    grouped = group_sentences(sents, size=3)
+    clean_grouped = [re.sub(r"\s+", " ", g).strip() for g in grouped]
 
-    # tokenize list of sentences
+    # tokenize grouped chunks
     inputs = tokenizer(
-        clean_sents,
-        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 (per sentence)
+    # model inference
     with torch.no_grad():
         logits = model(**inputs).logits
-        probs = F.softmax(logits, dim=-1)[:, 1].detach().cpu().tolist()
+        chunk_probs = F.softmax(logits, dim=-1)[:, 1].detach().cpu().tolist()
+
+    # EXPAND chunk-level probabilities to per-sentence (each chunk contributes to its 3 sentences)
+    ai_probs = []
+    for idx, prob in enumerate(chunk_probs):
+        start = idx * 3
+        end = min(start + 3, len(sents))
+        for _ in range(start, end):
+            ai_probs.append(prob)
 
     # overall AI score
-    overall_ai = sum(probs) / len(probs)
+    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"
     )
 
-    # highlights + table
+    # HIGHLIGHTS + TABLE
     rows, highlights = [], []
 
-    for i, sentence in enumerate(sents, start=1):
-        ai_p = float(probs[i - 1])
+    for i, orig in enumerate(sents, start=1):
+        ai_p = float(ai_probs[i-1])
         pct = f"{ai_p * 100:.1f}%"
 
         label = "AI" if ai_p >= THRESHOLD else "Human"
 
-        # colors
         if ai_p < 0.30:
             color = "#11823b"
         elif ai_p < 0.70:
@@ -125,7 +129,7 @@ def analyze(text, max_len=512):
         else:
             color = "#b80d0d"
 
-        normalized = re.sub(r"\s+", " ", sentence)
+        normalized = re.sub(r"\s+", " ", orig)
 
         highlights.append(
             "<div style='margin:6px 0; padding:6px 8px; border-radius:6px;"
@@ -134,14 +138,13 @@ def analyze(text, max_len=512):
             f"{normalized}</div>"
         )
 
-        rows.append([i, sentence, round(ai_p, 4), label])
+        rows.append([i, orig, round(ai_p, 4), label])
 
     df = pd.DataFrame(rows, columns=["#", "Sentence", "AI_Prob", "Label"])
     html = "\n".join(highlights)
 
     return overall_label, overall_pct, html, df
 
-
 # -----------------------------
 # GRADIO UI
 # -----------------------------