Update app.py

app.py

@@ -1,184 +1,148 @@
 import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM
-import re
 import numpy as np
 import pandas as pd
+import re
 import gradio as gr
 
-# ----------------------------------------------------
-# LOAD CAUSAL LM (distilGPT2 = FAST + LIGHT)
-# ----------------------------------------------------
+# ----------------------------------------------
+# LOAD FAST MODEL (DistilGPT2)
+# ----------------------------------------------
 MODEL_NAME = "distilgpt2"
 
 tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
 model = AutoModelForCausalLM.from_pretrained(MODEL_NAME).to(device).eval()
 
 
-# ----------------------------------------------------
+# ----------------------------------------------
 # SENTENCE SPLITTER
-# ----------------------------------------------------
+# ----------------------------------------------
 def sentence_split(text):
     text = text.replace("\n", ". ")
-    sentences = re.split(r'(?<=[.!?])\s+', text)
-    return [s.strip() for s in sentences if s.strip()]
+    s = re.split(r'(?<=[.!?])\s+', text)
+    return [x.strip() for x in s if x.strip()]
 
 
-# ----------------------------------------------------
-# PERPLEXITY FUNCTION
-# ----------------------------------------------------
+# ----------------------------------------------
+# PERPLEXITY
+# ----------------------------------------------
 def perplexity(sentence):
-    inputs = tokenizer(sentence, return_tensors="pt").to(device)
+    enc = tokenizer(sentence, return_tensors="pt").to(device)
     with torch.no_grad():
-        out = model(**inputs, labels=inputs["input_ids"])
+        out = model(**enc, labels=enc["input_ids"])
     return float(torch.exp(out.loss))
 
 
-# ----------------------------------------------------
-# SIMPLE TEXT PERTURBATION (DetectGPT trick)
-# ----------------------------------------------------
-def perturb(text):
-    words = text.split()
-    if len(words) < 4:
-        return text
-    idx = np.random.randint(0, len(words))
-    words[idx] += " "
-    return " ".join(words)
-
-
-# ----------------------------------------------------
-# BASE PERPLEXITY + DETECTGPT SCORE
-# ----------------------------------------------------
-def detectgpt_base_and_score(sentence, perturbations=3):
-    """
-    Returns:
-      base_perplexity, detectgpt_score
-    """
-    try:
-        base = perplexity(sentence)
-    except Exception:
-        return None, 0.0
-
-    pert_scores = []
-    for _ in range(perturbations):
-        p = perturb(sentence)
-        try:
-            pert_scores.append(perplexity(p))
-        except Exception:
-            continue
-
-    if not pert_scores:
-        return base, 0.0
-
-    score = float(np.mean(pert_scores) - base)
-    return base, score
-
-
-# ----------------------------------------------------
-# MAIN CLASSIFIER
-# ----------------------------------------------------
+# ----------------------------------------------
+# TOKEN-LEVEL ENTROPY
+# ----------------------------------------------
+def token_entropy(sentence):
+    enc = tokenizer(sentence, return_tensors="pt").to(device)
+    input_ids = enc["input_ids"][0]
+
+    with torch.no_grad():
+        outputs = model(enc["input_ids"], labels=enc["input_ids"])
+        logits = outputs.logits[0]
+
+    entropies = []
+    for i in range(1, len(input_ids)):
+        probs = torch.softmax(logits[i-1], dim=-1)
+        entropy = -torch.sum(probs * torch.log(probs + 1e-10))
+        entropies.append(float(entropy))
+
+    return np.mean(entropies), np.std(entropies)
+
+
+# ----------------------------------------------
+# TURNITIN-STYLE SCORING PIPELINE
+# ----------------------------------------------
+def analyze_sentence(sentence):
+    perp = perplexity(sentence)
+    mean_ent, std_ent = token_entropy(sentence)
+    length = len(sentence.split())
+    punct = sum([sentence.count(p) for p in ".,;:!?"])
+
+    return {
+        "sentence": sentence,
+        "perplexity": perp,
+        "entropy_mean": mean_ent,
+        "entropy_std": std_ent,
+        "length": length,
+        "punctuation": punct
+    }
+
+
+# ----------------------------------------------
+# MAIN TURNITIN STYLE DETECTOR
+# ----------------------------------------------
 def classify_text(text):
-    if not text.strip():
-        return "⚠️ Please enter some text.", None, None
 
     sentences = sentence_split(text)
-    if not sentences:
-        return "⚠️ No valid sentences found.", None, None
-
-    perps = []
-    scores = []
-    tmp_results = []
-
-    # 1. Compute base perplexity & DetectGPT score per sentence
-    for s in sentences:
-        base_perp, score = detectgpt_base_and_score(s)
-        if base_perp is None:
-            base_perp = float("nan")
-
-        perps.append(base_perp)
-        scores.append(score)
-        tmp_results.append({"sentence": s, "perp": base_perp, "score": score})
-
-    # Handle NaNs if any
-    perps_clean = [p for p in perps if not np.isnan(p)]
-    if perps_clean:
-        median_perp = float(np.median(perps_clean))
-    else:
-        median_perp = np.nan
-
-    # 2. Classify using calibrated rule
-    results = []
+    stats = [analyze_sentence(s) for s in sentences]
+
+    df = pd.DataFrame(stats)
+
+    # ---------- TURNITIN STYLE METRICS ----------
+    perplexity_mean = df["perplexity"].mean()
+    perplexity_std  = df["perplexity"].std()
+
+    entropy_mean = df["entropy_mean"].mean()
+    entropy_std  = df["entropy_std"].mean()
+
+    length_std = df["length"].std()
+    punct_std  = df["punctuation"].std()
+
+    # ---------- NORMALIZED SCORES ----------
+    # Low variance = AI-like
+    burstiness_score = np.exp(-perplexity_std)
+
+    entropy_smoothness = np.exp(-entropy_std)
+
+    length_uniformity = np.exp(-length_std / (df["length"].mean() + 1e-5))
+    punct_uniformity  = np.exp(-punct_std / (df["punctuation"].mean() + 1e-5))
+
+    # ---------- ENSEMBLE SCORE (Turnitin-like) ----------
+    ai_score = (
+        0.35 * burstiness_score +
+        0.25 * entropy_smoothness +
+        0.20 * length_uniformity +
+        0.20 * punct_uniformity
+    )
+
+    ai_percent = float(ai_score * 100)
+
+    # ---------- PER-SENTENCE LABELS ----------
     highlighted = []
-    ai_count = 0
-    total = len(tmp_results)
-
-    SCORE_THRESHOLD = 0.05  # Require meaningful positive signal
-
-    for item in tmp_results:
-        s = item["sentence"]
-        perp = item["perp"]
-        score = item["score"]
-
-        # Default label is Human
-        label = "Human"
-
-        # Conditions for AI-like:
-        # - score significantly positive
-        # - perplexity lower than median (more predictable)
-        if not np.isnan(perp) and not np.isnan(median_perp):
-            if (score > SCORE_THRESHOLD) and (perp < median_perp):
-                label = "AI"
-
-        if label == "AI":
-            ai_count += 1
-            highlighted.append(
-                f"<p style='color:red;font-weight:bold'>{s}</p>"
-            )
+    for i, row in df.iterrows():
+        is_ai = row["perplexity"] < perplexity_mean * 0.75 and row["entropy_std"] < entropy_std * 0.8
+        if is_ai:
+            highlighted.append(f"<p style='color:red;font-weight:bold'>{row['sentence']}</p>")
         else:
-            highlighted.append(
-                f"<p style='color:green;font-weight:bold'>{s}</p>"
-            )
-
-        results.append([
-            s,
-            label,
-            f"{perp:.2f}" if not np.isnan(perp) else "NaN",
-            f"{score:.4f}"
-        ])
-
-    # 3. Document-level AI percentage = fraction of AI sentences
-    if total > 0:
-        doc_ai_percent = (ai_count / total) * 100.0
-    else:
-        doc_ai_percent = 0.0
-
-    df = pd.DataFrame(
-        results,
-        columns=["Sentence", "Label", "Perplexity", "DetectGPT Score"]
-    )
+            highlighted.append(f"<p style='color:green;font-weight:bold'>{row['sentence']}</p>")
+
     html = "\n".join(highlighted)
 
-    return f"⚖️ Document AI Likelihood (approx): {doc_ai_percent:.1f}%", html, df
+    # Display readable columns
+    df_display = df[["sentence", "perplexity", "entropy_mean", "entropy_std", "length", "punctuation"]]
+
+    return f"⚖️ Estimated AI Probability (Turnitin-style): {ai_percent:.1f}%", html, df_display
 
 
-# ----------------------------------------------------
+
+# ----------------------------------------------
 # GRADIO UI
-# ----------------------------------------------------
+# ----------------------------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("## 🧠 Writenix DetectGPT (Calibrated, distilgpt2)")
+    gr.Markdown("## 🧠 Writenix — Turnitin-Style AI Detector")
 
-    text_input = gr.Textbox(
-        label="Enter text",
-        lines=14,
-        placeholder="Paste your essay here…"
-    )
+    text_input = gr.Textbox(label="Enter text", lines=10, placeholder="Paste your essay...")
 
-    classify_btn = gr.Button("🚀 Detect AI")
+    classify_btn = gr.Button("🚀 Analyze")
 
-    ai_score = gr.Label(label="Overall AI Likelihood")
+    ai_score = gr.Label(label="Turnitin-Style AI Likelihood")
     highlighted = gr.HTML()
-    table = gr.Dataframe(headers=["Sentence", "Label", "Perplexity", "DetectGPT Score"], wrap=True)
+    table = gr.Dataframe(headers=["Sentence", "Perplexity", "Entropy Mean", "Entropy Std", "Length", "Punctuation"], wrap=True)
 
     classify_btn.click(classify_text, text_input, [ai_score, highlighted, table])