Upload 2 files

README.md

@@ -182,6 +182,9 @@ in your privacy policy.
   plain-wording rules add more options, the detector ranks them, and Groq checks the 2 most human versions
   (`HUM_GROQ_SHORTLIST`). The most human version Groq accepts is kept; if both are rejected, the next
   version or the original sentence is used. Parrot still does all the rewriting; Groq only checks.
+  It also aims for 70% new wording per sentence (`HUM_AI_CHANGE_TARGET`, same measure as the "Vocabulary
+  changed" gauge): sentences below it get up to 2 extra Parrot rounds with more variation (`HUM_AI_ROUNDS`),
+  versions that reach it are preferred, and Groq's check may not pull the wording back toward the original.
 - Speed: sentences are batched shortest-first and generation stops just past the input length; Groq batches run
   3 at a time (`GROQ_PARALLEL`).
 

humanizer.py

@@ -381,6 +381,10 @@ CANDIDATES = max(1, int(os.getenv("HUM_CANDIDATES", "3")))
 # most human versions of each sentence (default 2) so a rejected best version falls back to a checked one.
 CANDIDATES_AI = max(1, int(os.getenv("HUM_CANDIDATES_AI", "5")))
 GROQ_SHORTLIST = max(1, int(os.getenv("HUM_GROQ_SHORTLIST", "2")))
+# 100% AI mode: target share of new wording per sentence (same measure as the "Vocabulary changed" gauge)
+# and the number of extra Parrot rounds for sentences below it.
+AI_CHANGE_TARGET = float(os.getenv("HUM_AI_CHANGE_TARGET", "70"))
+AI_ROUNDS = max(0, int(os.getenv("HUM_AI_ROUNDS", "2")))
 FULL_AI = contextvars.ContextVar("full_ai", default=False)
 # Kept for compatibility with smart.py / app.py versions that set it per pass. The 100% AI mode is now
 # "5 Parrot versions + Groq check" (Parrot does all rewriting), so this switch has no effect.
@@ -421,53 +425,55 @@ def _paraphrase_local(texts, temperature, progress=None, lo=0.15, hi=0.85, mode=
 
     full_ai = FULL_AI.get()
     k = CANDIDATES_AI if full_ai else CANDIDATES
+    target = AI_CHANGE_TARGET if full_ai else 0.0
+    rounds = 1 + (AI_ROUNDS if full_ai else 0)
+    temp0 = min(1.5, float(temperature) + (0.2 if full_ai else 0.0))
     p_hi = lo + (hi - lo) * (0.7 if G.available() else 0.85)   # room on the bar for scoring / Groq
+    p_gen = lo + (p_hi - lo) * (0.75 if full_ai else 1.0)      # 100% AI: room for the extra rounds
     use_gpu = ON_GPU and not str(mode).lower().startswith("cpu")   # CPU-only hardware: straight to CPU
     fell_back = False
-    cand = [None] * len(flat)                  # cand[i] = list of k paraphrases of flat[i]
-    order = sorted(range(len(flat)), key=lambda x: len(flat[x]))
-    total = max(1, len(flat))
-    step = GPU_CHUNK if use_gpu else CPU_CHUNK
-    i = 0
-    while i < len(order):
-        idx = order[i:i + step]
-        chunk = [flat[x] for x in idx]
-        engine = "GPU" if use_gpu else "CPU"
-        if progress is not None:
-            progress(lo + (p_hi - lo) * i / total,
-                     desc=f"Paraphrasing {i + 1}–{i + len(chunk)} of {total} ({engine}, {k} versions each)")
-        if use_gpu:
-            try:
-                outs = paraphrase_batch_gpu(chunk, temperature, k)
-            except Exception as err:
-                if not _is_gpu_unavailable(err):
-                    raise
-                use_gpu, fell_back, step = False, True, CPU_CHUNK
-                continue  # retry the same chunk on CPU
-        else:
-            outs = paraphrase_batch_cpu(chunk, temperature, k)
-        for n_, x in enumerate(idx):
-            cand[x] = outs[n_ * k:(n_ + 1) * k] or [flat[x]]
-        i += len(chunk)
-
-    if fell_back:
-        note = "⚠️ GPU quota was unavailable, so the remaining text was processed on CPU (slower, same quality)."
-    elif use_gpu:
-        note = "⚡ Processed on GPU."
-    else:
-        note = "🖥️ Processed on CPU."
+    cand = [[] for _ in flat]                  # cand[i] = all paraphrases of flat[i] (k per round)
+
+    def generate(indices, temp, a_, b_, label):
+        nonlocal use_gpu, fell_back
+        order = sorted(indices, key=lambda x: len(flat[x]))
+        total = max(1, len(order))
+        step = GPU_CHUNK if use_gpu else CPU_CHUNK
+        i = 0
+        while i < len(order):
+            idx = order[i:i + step]
+            chunk = [flat[x] for x in idx]
+            engine = "GPU" if use_gpu else "CPU"
+            if progress is not None:
+                progress(a_ + (b_ - a_) * i / total,
+                         desc=f"{label} {i + 1}–{i + len(chunk)} of {total} ({engine}, {k} versions each)")
+            if use_gpu:
+                try:
+                    outs = paraphrase_batch_gpu(chunk, temp, k)
+                except Exception as err:
+                    if not _is_gpu_unavailable(err):
+                        raise
+                    use_gpu, fell_back, step = False, True, CPU_CHUNK
+                    continue  # retry the same chunk on CPU
+            else:
+                outs = paraphrase_batch_cpu(chunk, temp, k)
+            for n_, x in enumerate(idx):
+                got = outs[n_ * k:(n_ + 1) * k] or [flat[x]]
+                cand[x].extend(got + [got[-1]] * (k - len(got)))   # keep k per round so chunks line up
+            i += len(chunk)
 
-    # ---- 2. valid candidates per sentence (terms restored, guard passed)
     glossary = TP.build_glossary(texts) | TP.GLOSSARY.get()
-    options, first_raw = [], []
-    for s, c0, n in sent_map:
+
+    def build(si):
+        """Valid candidates of sentence si (terms restored, guard passed) + first raw paraphrase."""
+        s, c0, n = sent_map[si]
         opts, raw0 = [], None
-        for j in range(k):
-            pieces = [cand[c][j if j < len(cand[c]) else -1] for c in range(c0, c0 + n)]
+        m = min(len(cand[c]) for c in range(c0, c0 + n)) if n else 0
+        for j in range(m):
+            pieces = [cand[c][j] for c in range(c0, c0 + n)]
             new = TP.merge_chunks(flat[c0:c0 + n], pieces) if n > 1 else pieces[0]
             raw0 = raw0 or new
-            fixed = TP.restore_terms(s, new, glossary)
-            ok = TP.guard(s, fixed, glossary)
+            ok = TP.guard(s, TP.restore_terms(s, new, glossary), glossary)
             if ok and ok.strip() != s.strip() and ok not in opts:
                 opts.append(ok)
         # "100% AI-written" mode only: plain-wording versions (chatbot vocabulary / set phrases removed) of each
@@ -478,11 +484,40 @@ def _paraphrase_local(texts, temperature, progress=None, lo=0.15, hi=0.85, mode=
                 ok = TP.guard(s, TP.restore_terms(s, v, glossary), glossary)
                 if ok and ok.strip() != s.strip() and ok not in opts:
                     opts.append(ok)
-        options.append(opts)
-        first_raw.append(raw0 or s)
+        return opts, raw0 or s
+
+    def change(si, o):
+        return words_changed(sent_map[si][0], o)
+
+    # ---- 1–2. Parrot versions; in 100% AI mode, sentences below the new-wording target (or with no safe
+    #           version) go back to Parrot for extra rounds with more variation
+    todo = list(range(len(sent_map)))
+    options, first_raw = [[] for _ in sent_map], [s for s, _, _ in sent_map]
+    extra_rounds = 0
+    for r in range(rounds):
+        if not todo:
+            break
+        a_ = lo if r == 0 else p_gen + (p_hi - p_gen) * (r - 1) / max(1, rounds - 1)
+        b_ = p_gen if r == 0 else p_gen + (p_hi - p_gen) * r / max(1, rounds - 1)
+        chunks = [c for si in todo for c in range(sent_map[si][1], sent_map[si][1] + sent_map[si][2])]
+        generate(chunks, min(1.5, temp0 + 0.25 * r), a_, b_,
+                 "Paraphrasing" if r == 0 else f"Extra rewrite round {r} for")
+        extra_rounds += r > 0
+        for si in todo:
+            options[si], first_raw[si] = build(si)
+        if not target:
+            break
+        todo = [si for si in todo
+                if not options[si] or max(change(si, o) for o in options[si]) < target]
 
-    # ---- 3. most human candidate (AI detector)
-    chosen = [o[0] if o else None for o in options]
+    if fell_back:
+        note = "⚠️ GPU quota was unavailable, so the remaining text was processed on CPU (slower, same quality)."
+    elif use_gpu:
+        note = "⚡ Processed on GPU."
+    else:
+        note = "🖥️ Processed on CPU."
+
+    # ---- 3. most human candidate (AI detector); 100% AI mode: versions meeting the new-wording target first
     score_of = {}
     multi = [(si, o) for si, opts in enumerate(options) if len(opts) > 1 for o in opts]
     if SELECT and multi:
@@ -490,17 +525,19 @@ def _paraphrase_local(texts, temperature, progress=None, lo=0.15, hi=0.85, mode=
             progress(p_hi, desc="Choosing the most human-sounding version of each sentence")
         sc = _detector_scores([o for _, o in multi])
         if sc:
-            best = {}
-            for (si, o), v in zip(multi, sc):
-                score_of[(si, o)] = v
-                if si not in best or v < best[si][0]:
-                    best[si] = (v, o)
-            for si, (v, o) in best.items():
-                chosen[si] = o
+            score_of = {key: v for key, v in zip(multi, sc)}
             note += f" 🎯 Best of {k} Parrot versions per sentence chosen by the AI detector."
-    # candidates of each sentence, most human first (unscored -> original order)
-    ranked = [sorted(opts, key=lambda o, si=si: score_of.get((si, o), 1.0)) if score_of else list(opts)
+
+    def rank_key(si, o):
+        det = score_of.get((si, o), 1.0 if score_of else 0.0)
+        if target:
+            ch = change(si, o)
+            return (0, det) if ch >= target else (1, -ch, det)
+        return (det,)
+
+    ranked = [sorted(opts, key=lambda o, si=si: rank_key(si, o)) if (score_of or target) else list(opts)
               for si, opts in enumerate(options)]
+    chosen = [r_[0] if r_ else None for r_ in ranked]
 
     # ---- 4. Groq: academic-wording check of the chosen sentences + rescue of sentences with no valid version.
     #      100% AI mode: Groq checks the GROQ_SHORTLIST most human versions of each sentence, and the most human
@@ -561,8 +598,11 @@ def _paraphrase_local(texts, temperature, progress=None, lo=0.15, hi=0.85, mode=
                 sc = _detector_scores([ok for _, ok, _ in fixes] + [c for _, _, c in fixes]) if fixes else []
                 m = len(fixes)
                 for n_, (si, ok, cand_) in enumerate(fixes):
-                    if not sc or sc[n_] <= sc[m + n_] + 0.02:   # never trade AI score for polish
-                        chosen[si] = ok
+                    if sc and sc[n_] > sc[m + n_] + 0.02:       # never trade AI score for polish
+                        continue
+                    if target and change(si, ok) < min(target, change(si, cand_) - 10):
+                        continue                                 # 100% AI: Groq must not undo the rewrite
+                    chosen[si] = ok
                 note += (f" ✅ Groq checked the top {shortlist} versions of each sentence." if shortlist > 1
                          else " ✅ Academic wording checked by Groq.")
             except G.Unavailable as err:
@@ -571,7 +611,12 @@ def _paraphrase_local(texts, temperature, progress=None, lo=0.15, hi=0.85, mode=
 
     sentences = [chosen[si] or s for si, (s, _, _) in enumerate(sent_map)]
     changed = sum(1 for si, (s, _, _) in enumerate(sent_map) if sentences[si].strip() != s.strip())
-    note += (f" 🤖 100% AI mode ({k} Parrot versions per sentence)." if full_ai else "") + f" ✍️ {changed} of {len(sent_map)} sentences rewritten."
+    if full_ai:
+        hit = sum(1 for si, (s0, _, _) in enumerate(sent_map)
+                  if sentences[si].strip() != s0.strip() and change(si, sentences[si]) >= target)
+        note += (f" 🤖 100% AI mode: {k} Parrot versions per sentence"
+                 + (f", {extra_rounds} extra round(s)" if extra_rounds else "")
+                 + f"; {hit} of {len(sent_map)} sentences reach {target:.0f}% new wording.") + f" ✍️ {changed} of {len(sent_map)} sentences rewritten."
     if changed < len(sent_map):
         print(f"[humanizer] kept {len(sent_map) - changed} sentences unchanged "
               f"(no safe version: {sum(1 for o in options if not o)})", flush=True)