Update app.py

app.py

@@ -6,26 +6,22 @@ import pandas as pd
 import gradio as gr
 import os
 
+# 1. OPTIMIZE CPU PERFORMANCE
+torch.set_num_threads(os.cpu_count() or 4) # Use all cores
+
 # -----------------------------
 # MODEL INITIALIZATION
 # -----------------------------
 MODEL_NAME = "desklib/ai-text-detector-v1.01"
 tokenizer = None
 model = None
-
-# Force CPU if CUDA is not properly initialized to prevent crash
-if torch.cuda.is_available():
-    device = torch.device("cuda")
-    dtype = torch.float16  # Half precision for GPU speed/memory
-else:
-    device = torch.device("cpu")
-    dtype = torch.float32  # Full precision for CPU stability
+device = torch.device("cpu") # Hardcoding CPU as requested
+dtype = torch.float32
 
 def get_model():
     global tokenizer, model
     if model is None:
-        print(f"Loading Specialized Model: {MODEL_NAME} on {device}")
-        # Added low_cpu_mem_usage to prevent Build Exit Code 1 (OOM)
+        print(f"Loading Model: {MODEL_NAME} on CPU...")
         tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, use_fast=False)
         model = AutoModelForSequenceClassification.from_pretrained(
             MODEL_NAME, 
@@ -73,48 +69,57 @@ def split_preserving_structure(text):
     return final_blocks
 
 # -----------------------------
-# ANALYSIS
+# ANALYSIS (With Batching & Progress)
 # -----------------------------
 @torch.inference_mode()
-def analyze(text):
+def analyze(text, progress=gr.Progress(track_tqdm=True)):
     text = text.strip()
     if not text:
         return "—", "—", "<em>Please enter text...</em>", None
             
     word_count = len(text.split())
     if word_count < 300:
-        warning_msg = f"⚠️ <b>Insufficient Text:</b> Your input has {word_count} words. Please enter at least 300 words for an accurate analysis."
-        return "Too Short", "N/A", f"<div style='color: #b80d0d; padding: 20px; border: 1px solid #b80d0d; border-radius: 8px;'>{warning_msg}</div>", None
+        warning_msg = f"⚠️ <b>Insufficient Text:</b> {word_count} words. Min 300 required."
+        return "Too Short", "N/A", f"<div style='color: #b80d0d; border: 1px solid #b80d0d; padding: 10px;'>{warning_msg}</div>", None
 
     try:
         tok, mod = get_model()
     except Exception as e:
-        return "ERROR", "0%", f"Failed to load model: {str(e)}", None
+        return "ERROR", "0%", f"Load Error: {str(e)}", None
 
     blocks = split_preserving_structure(text)
     pure_sents_indices = [i for i, b in enumerate(blocks) if b.strip() and not b.startswith("\n")]
     pure_sents = [blocks[i] for i in pure_sents_indices]
     
     if not pure_sents:
-        return "—", "—", "<em>No sentences detected.</em>", None
+        return "—", "—", "No sentences found.", None
 
+    # Windows for context
     windows = []
     for i in range(len(pure_sents)):
         start = max(0, i - 1)
         end = min(len(pure_sents), i + 2)
         windows.append(" ".join(pure_sents[start:end]))
 
-    inputs = tok(windows, return_tensors="pt", padding=True, truncation=True, max_length=512).to(device)
-    output = mod(**inputs)
-    probs = torch.sigmoid(output.logits).cpu().numpy().flatten().tolist()
-
+    # 2. BATCHED INFERENCE (Crucial for CPU)
+    probs = []
+    batch_size = 4 # Small batches so CPU doesn't hang
+    
+    progress(0, desc="Starting Analysis...")
+    for i in range(0, len(windows), batch_size):
+        batch = windows[i : i + batch_size]
+        inputs = tok(batch, return_tensors="pt", padding=True, truncation=True, max_length=512).to(device)
+        output = mod(**inputs)
+        batch_probs = torch.sigmoid(output.logits).cpu().numpy().flatten().tolist()
+        probs.extend(batch_probs)
+        progress((i + batch_size) / len(windows), desc=f"Analyzing sentences {i+1}-{min(i+batch_size, len(windows))}...")
+
+    # Statistics
     lengths = [len(s.split()) for s in pure_sents]
     total_words = sum(lengths)
     weighted_avg = sum(p * l for p, l in zip(probs, lengths)) / total_words if total_words > 0 else 0
 
-    # -----------------------------
-    # HTML RECONSTRUCTION
-    # -----------------------------
+    # 3. HTML GENERATION
     highlighted_html = "<div style='font-family: sans-serif; line-height: 1.8;'>"
     prob_map = {idx: probs[i] for i, idx in enumerate(pure_sents_indices)}
     
@@ -125,45 +130,37 @@ def analyze(text):
             
         if i in prob_map:
             score = prob_map[i]
-            if score >= THRESHOLD:
-                color, bg = "#b80d0d", "rgba(184, 13, 13, 0.15)" # RED
-            else:
-                color, bg = "#11823b", "rgba(17, 130, 59, 0.15)" # GREEN
-            
+            color, bg = ("#b80d0d", "rgba(184, 13, 13, 0.15)") if score >= THRESHOLD else ("#11823b", "rgba(17, 130, 59, 0.15)")
             highlighted_html += (
-                f"<span style='background:{bg}; padding:2px 4px; border-radius:4px; border-bottom: 2px solid {color};' "
-                f"title='Raw Model Score: {score:.4f}'>"
+                f"<span style='background:{bg}; padding:2px 4px; border-radius:4px; border-bottom: 2px solid {color};'>"
                 f"<b style='color:{color}; font-size: 0.8em;'>[{score:.1%}]</b> {block}</span>"
             )
         else:
             highlighted_html += block
 
     highlighted_html += "</div>"
-    label = f"{weighted_avg:.1%} AI Probability"
-    display_score = f"{weighted_avg:.2%}"
     
     df = pd.DataFrame({"Sentence": pure_sents, "AI Confidence": [f"{p:.2%}" for p in probs]})
-    return label, display_score, highlighted_html, df
+    return f"{weighted_avg:.1%} AI Probability", f"{weighted_avg:.2%}", highlighted_html, df
 
 # -----------------------------
 # GRADIO INTERFACE
 # -----------------------------
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("## 🕵️ AI Detector Pro: Raw Mode")
-    gr.Markdown(f"Visual highlight triggers at **{THRESHOLD*100:.0f}%**.")
+    gr.Markdown("## 🕵️ AI Detector Pro (CPU Optimized)")
     
     with gr.Row():
         with gr.Column(scale=3):
             text_input = gr.Textbox(label="Paste Text", lines=12, placeholder="Min 300 words...")
-            run_btn = gr.Button("Analyze", variant="primary")
+            run_btn = gr.Button("Run Analysis", variant="primary")
         with gr.Column(scale=1):
-            verdict_out = gr.Label(label="Model Verdict (Raw)")
-            score_out = gr.Label(label="Exact Weighted Probability")
+            verdict_out = gr.Label(label="Weighted Verdict")
+            score_out = gr.Label(label="Exact Score")
             
     with gr.Tabs():
         with gr.TabItem("Visual Heatmap"):
             html_out = gr.HTML()
-        with gr.TabItem("Raw Data Breakdown"):
+        with gr.TabItem("Detailed Breakdown"):
             table_out = gr.Dataframe(headers=["Sentence", "AI Confidence"], wrap=True)
             
     run_btn.click(analyze, inputs=text_input, outputs=[verdict_out, score_out, html_out, table_out])