Update app.py

app.py

@@ -1,78 +1,59 @@
 from fastapi import FastAPI, Request
-from pydantic import BaseModel
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import torch
-import re
+import uvicorn
 
-app = FastAPI(title="AI Text Detector API")
+app = FastAPI(title="AI Detector API")
 
-# Device setup
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-# Load model (use small model for Hugging Face to prevent restarts)
+# Load model once at startup
 MODEL_NAME = "roberta-base-openai-detector"
 tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME).to(device)
+model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME)
 model.eval()
- 
-# --- Text Cleaning ---
-def clean_text(text: str) -> str:
-    text = re.sub(r'\s{2,}', ' ', text)
-    text = re.sub(r'\s+([,.;:?!])', r'\1', text)
-    return text.strip()
-
-# --- Paragraph Splitter ---
-def split_paragraphs(text: str):
-    return [p.strip() for p in re.split(r'\n{2,}', text) if p.strip()]
 
-# --- Classification ---
-def analyze_text(text: str):
-    text = clean_text(text)
-    paragraphs = split_paragraphs(text)
 
-    paragraph_results = []
-    total_ai, total_human = 0, 0
+def get_ai_probability(text: str) -> float:
+    """Return the AI probability (0–100%) for a given text."""
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+    with torch.no_grad():
+        logits = model(**inputs).logits
+        probs = torch.softmax(logits, dim=1)
+    ai_score = probs[0][1].item() * 100
+    return round(ai_score, 2)
 
-    for i, p in enumerate(paragraphs, 1):
-        inputs = tokenizer(p, return_tensors="pt", truncation=True, padding=True).to(device)
-        with torch.no_grad():
-            logits = model(**inputs).logits
-            probs = torch.softmax(logits, dim=1)[0]
-            ai_score = float(probs[1].item() * 100)
-            human_score = float(probs[0].item() * 100)
 
-        total_ai += ai_score
-        total_human += human_score
-
-        paragraph_results.append({
-            "paragraph_number": i,
-            "ai_probability": round(ai_score, 2),
-            "human_probability": round(human_score, 2),
-            "text_snippet": p[:150] + ("..." if len(p) > 150 else "")
+@app.post("/analyze")
+async def analyze_text(request: Request):
+    """
+    Example body:
+    {
+      "text": "Your long article text here"
+    }
+    """
+    data = await request.json()
+    text = data.get("text", "").strip()
+    if not text:
+        return {"error": "No text provided"}
+
+    paragraphs = [p.strip() for p in text.split("\n") if p.strip()]
+    results = []
+
+    for i, para in enumerate(paragraphs, start=1):
+        ai_score = get_ai_probability(para)
+        results.append({
+            "paragraph": i,
+            "ai_score": ai_score,
+            "human_score": round(100 - ai_score, 2),
+            "content": para[:200] + ("..." if len(para) > 200 else "")
         })
 
-    avg_ai = total_ai / len(paragraphs)
-    avg_human = total_human / len(paragraphs)
-    overall_label = "AI-generated" if avg_ai > avg_human else "Human-written"
-
+    overall = sum([r["ai_score"] for r in results]) / len(results)
     return {
-        "overall_result": {
-            "ai_percentage": round(avg_ai, 2),
-            "human_percentage": round(avg_human, 2),
-            "label": overall_label
-        },
-        "paragraphs": paragraph_results
+        "overall_ai_score": round(overall, 2),
+        "overall_human_score": round(100 - overall, 2),
+        "paragraphs": results
     }
 
-# --- Request Schema ---
-class TextInput(BaseModel):
-    text: str
 
-# --- API Routes ---
-@app.get("/")
-async def root():
-    return {"status": "ok", "message": "AI Text Detector API is running."}
-
-@app.post("/analyze")
-async def analyze(input_data: TextInput):
-    return analyze_text(input_data.text)
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)