Update app.py

app.py

@@ -1,9 +1,7 @@
 from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 import torch, gradio as gr, re, random
 
-# ------------------------
-# Load Model (Parrot T5)
-# ------------------------
+# --- Load Model ---
 model_name = "prithivida/parrot_paraphraser_on_T5"
 tokenizer = AutoTokenizer.from_pretrained(model_name)
 model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
@@ -12,14 +10,12 @@ device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 model = model.to(device)
 model.eval()
 
-# ------------------------
-# Helpers
-# ------------------------
+# --- Helpers ---
 def split_paragraphs(text):
     return [p.strip() for p in text.split("\n") if p.strip()]
 
-def split_sentences(paragraph):
-    return re.split(r'(?<=[.!?])\s+', paragraph.strip())
+def split_sentences(text):
+    return re.split(r'(?<=[.!?])\s+', text.strip())
 
 def clean_sentence(sent):
     sent = re.sub(r'\s+', ' ', sent).strip()
@@ -27,75 +23,55 @@ def clean_sentence(sent):
         sent += "."
     return sent
 
-FILLERS = ["actually", "indeed", "essentially", "remarkably", "interestingly", "notably"]
-
-def maybe_add_filler(sentence, add=False):
-    """Insert a filler only if flagged."""
-    if not add:
-        return sentence
-    words = sentence.split()
-    if len(words) > 6:
-        insert_pos = random.randint(2, min(len(words) - 2, 8))
-        filler = random.choice(FILLERS)
-        words.insert(insert_pos, filler)
-    return " ".join(words)
-
-# ------------------------
-# Main Humanizer
-# ------------------------
-def humanize_text(text, temperature=1.0, top_p=0.92):
+FILLERS = ["in fact", "notably", "interestingly", "remarkably", "as a matter of fact"]
+
+def inject_filler(paragraph):
+    sentences = split_sentences(paragraph)
+    if len(sentences) > 2:
+        idx = random.randint(1, len(sentences)-1)
+        sentences[idx] = FILLERS[random.randint(0, len(FILLERS)-1)].capitalize() + ", " + sentences[idx][0].lower() + sentences[idx][1:]
+    return " ".join(sentences)
+
+# --- Main function ---
+def humanize_text(text):
     if not text.strip():
         return "⚠️ Please enter some text"
 
     paragraphs = split_paragraphs(text)
-    final_output = []
-
-    for paragraph in paragraphs:
-        sentences = split_sentences(paragraph)
-        paraphrased_sentences = []
+    final_paragraphs = []
 
-        for i, sent in enumerate(sentences):
-            if not sent.strip():
-                continue
+    for para in paragraphs:
+        sentences = split_sentences(para)
+        out_sentences = []
 
-            # Run through model
+        for sent in sentences:
             input_text = "paraphrase: " + sent + " </s>"
             inputs = tokenizer([input_text], return_tensors="pt", truncation=True, padding=True).to(device)
 
             outputs = model.generate(
                 **inputs,
-                max_new_tokens=80,
-                do_sample=True,
-                top_p=float(top_p),
-                temperature=float(temperature)
+                max_new_tokens=64,
+                num_beams=3,          # Faster & more stable than sampling
+                do_sample=False       # Deterministic, no temp needed
             )
 
             decoded = tokenizer.decode(outputs[0], skip_special_tokens=True)
-            decoded = clean_sentence(decoded)
-
-            # Add filler only to one sentence per paragraph
-            add_filler_here = (i == random.randint(0, max(0, len(sentences)-1)))
-            final_sentence = maybe_add_filler(decoded, add=add_filler_here)
-
-            paraphrased_sentences.append(final_sentence)
+            out_sentences.append(clean_sentence(decoded))
 
-        final_output.append(" ".join(paraphrased_sentences))
+        # Rebuild paragraph + add filler once
+        new_para = " ".join(out_sentences)
+        new_para = inject_filler(new_para)
+        final_paragraphs.append(new_para)
 
-    return "\n\n".join(final_output)
+    return "\n\n".join(final_paragraphs)
 
-# ------------------------
-# Gradio Interface
-# ------------------------
+# --- Gradio Interface ---
 iface = gr.Interface(
     fn=humanize_text,
-    inputs=[
-        gr.Textbox(lines=8, placeholder="Paste text here..."),
-        gr.Slider(0.5, 2.0, step=0.1, value=1.0, label="Temperature"),
-        gr.Slider(0.6, 1.0, step=0.01, value=0.92, label="Top-p"),
-    ],
-    outputs=gr.Textbox(label="Final Humanized Text"),
-    title="⚡ Writenix Humanizer (Balanced)",
-    description="Parrot paraphraser + subtle filler words. Injects fillers only once per paragraph for natural variation."
+    inputs=gr.Textbox(lines=10, placeholder="Paste text here..."),
+    outputs=gr.Textbox(label="Humanized Output"),
+    title="⚡ Writenix Fast Humanizer",
+    description="Stable & fast humanizer: deterministic paraphrasing + light filler once per paragraph."
 )
 
 iface.launch()