Update app.py

app.py

@@ -10,24 +10,31 @@ 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  # 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)
+ABBR_REGEX = re.compile(
+    r"\b(" + "|".join(map(re.escape, ABBR)) + r")\.",
+    flags=re.IGNORECASE
+)
 
 def _protect(text: str) -> str:
     t = text.strip()
@@ -40,16 +47,19 @@ 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 []
-    parts = re.split(r"([.?!])\s+(?=(?:[\"“”‘’']?\s*[A-Z(])|$)", t)
+
+    # hard sentence boundary detection
+    parts = re.split(r"([.?!])\s+(?=[\"“”‘’']?\s*[A-Z(]|$)", t)
 
     sentences, buf = [], ""
     for i, chunk in enumerate(parts):
@@ -65,74 +75,57 @@ 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
+# CORE ANALYSIS — PER SENTENCE
 # -----------------------------
 def analyze(text, max_len=512):
     sents = sentence_split(text)
     if not sents:
         return "—", "—", "<em>Paste some text to analyze.</em>", None
 
-    # GROUP sentences (3 at a time)
-    grouped = group_sentences(sents, size=3)
-    clean_grouped = [re.sub(r"\s+", " ", g).strip() for g in grouped]
+    clean_sents = [re.sub(r"\s+", " ", s).strip() for s in sents]
 
-    # tokenize grouped
+    # tokenize list of sentences
     inputs = tokenizer(
-        clean_grouped, return_tensors="pt",
-        padding=True, truncation=True, max_length=max_len
+        clean_sents,
+        return_tensors="pt",
+        padding=True,
+        truncation=True,
+        max_length=max_len
     ).to(device)
 
-    # model inference
+    # model inference (per sentence)
     with torch.no_grad():
         logits = model(**inputs).logits
-        chunk_probs = F.softmax(logits, dim=-1)[:, 1].detach().cpu().tolist()
-
-    # EXPAND chunk-level probabilities to per-sentence
-    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)
+        probs = F.softmax(logits, dim=-1)[:, 1].detach().cpu().tolist()
 
     # overall AI score
-    overall_ai = sum(ai_probs) / len(ai_probs)
+    overall_ai = sum(probs) / len(probs)
     overall_pct = f"{overall_ai * 100:.1f}%"
 
-    # UPDATED THRESHOLD (80%)
     overall_label = (
         "🤖 Likely AI Written" if overall_ai >= THRESHOLD else "🧒 Likely Human Written"
     )
 
-    # HIGHLIGHTS + TABLE
+    # highlights + table
     rows, highlights = [], []
 
-    for i, orig in enumerate(sents, start=1):
-        ai_p = float(ai_probs[i-1])
+    for i, sentence in enumerate(sents, start=1):
+        ai_p = float(probs[i - 1])
         pct = f"{ai_p * 100:.1f}%"
 
-        # UPDATED → label decided by 80%
         label = "AI" if ai_p >= THRESHOLD else "Human"
 
-        # color logic (unchanged)
+        # colors
         if ai_p < 0.30:
-            color = "#11823b"   # green
+            color = "#11823b"
         elif ai_p < 0.70:
-            color = "#b8860b"   # amber
+            color = "#b8860b"
         else:
-            color = "#b80d0d"   # red
+            color = "#b80d0d"
 
-        normalized = re.sub(r"\s+", " ", orig)
+        normalized = re.sub(r"\s+", " ", sentence)
 
         highlights.append(
             "<div style='margin:6px 0; padding:6px 8px; border-radius:6px;"
@@ -141,13 +134,14 @@ def analyze(text, max_len=512):
             f"{normalized}</div>"
         )
 
-        rows.append([i, orig, round(ai_p, 4), label])
+        rows.append([i, sentence, 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
 # -----------------------------