Add AI text detector Gradio app on CPU

README.md

@@ -1,13 +1,52 @@
 ---
-title: Ai Text Detector
-emoji: 🔥
-colorFrom: blue
-colorTo: purple
+title: AI Text Detector
+emoji: 🔍
+colorFrom: gray
+colorTo: red
 sdk: gradio
 sdk_version: 6.27.0
-python_version: '3.12'
 app_file: app.py
 pinned: false
+license: mit
+models:
+- batmac/gradient-ai-text-detector-4bit
+short_description: Estimate whether text was written by a language model
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AI Text Detector
+
+Paste text to estimate the probability it was written by a language model, using
+[`batmac/gradient-ai-text-detector-4bit`](https://huggingface.co/batmac/gradient-ai-text-detector-4bit),
+a 4-bit NF4 quantization of
+[`ShantanuT01/gradient-ai-text-detector`](https://huggingface.co/ShantanuT01/gradient-ai-text-detector)
+(DeBERTa-v3-large, single sigmoid head producing P(AI)).
+
+## What it reports
+
+- The input text with a green-to-red background per sentence
+- An overall score, the mean and max across windows, and a verdict
+- Sentence-level scores, plus the top AI-like passages
+- A JSON summary with the score, threshold, aggregation, and every sentence score
+
+## Controls
+
+**Decision threshold**, 0.50 to 0.99, default 0.50. Upstream documents only the
+0.5 cut, so the default reproduces it; raising the slider trades false positives
+for misses. No false-positive rate is claimed for any other value.
+
+**Window aggregation**, `mean` or `max`. Text longer than 512 tokens is split
+into windows; `mean` averages them and `max` reports the highest-scoring one. They
+are identical for text that fits a single window (~2,500 characters of English).
+
+Text is capped at 20,000 characters, and inference runs on CPU, so a shared Space
+processes one request at a time.
+
+## Caveats
+
+Scores are model probabilities, not proof. The model card warns against using
+this as the sole basis for high-stakes decisions such as academic or employment
+penalties, and notes degraded accuracy on text distributions unlike its training
+data. The model authors and Microsoft do not endorse this Space.
+
+This Space runs the same `app.py` as the local project that produced the
+quantized checkpoint.

app.py

@@ -0,0 +1,393 @@
+"""Gradio app for AI-generated text detection.
+
+Scores text with P(AI) in [0, 1] using
+batmac/gradient-ai-text-detector-4bit, a 4-bit NF4 quantization of
+ShantanuT01/gradient-ai-text-detector (DeBERTa-v3-large, sigmoid head), and
+renders a readable report.
+
+The device is configurable with ``AID_DEVICE``: ``auto`` (default, CUDA > MPS >
+CPU), or one of ``cuda``/``mps``/``cpu``. The model itself always comes from the
+Hub repo below.
+"""
+
+import html
+import os
+import re
+import time
+import warnings
+
+# transformers imports torch.jit, which trips a deprecation warning on torch 2.x.
+warnings.filterwarnings(
+    "ignore",
+    message=r"`torch\.jit\.script` is deprecated.*",
+    category=FutureWarning,
+)
+
+import gradio as gr
+import torch
+from transformers import AutoConfig, AutoModelForSequenceClassification, AutoTokenizer
+
+MODEL_ID = "batmac/gradient-ai-text-detector-4bit"
+MAX_TOKENS = 512
+MAX_CHARS = 20_000
+THRESHOLD = 0.5
+MIN_THRESHOLD = 0.5
+MAX_THRESHOLD = 0.99
+AGGREGATIONS = ("mean", "max")
+BATCH_SIZE = 8
+
+DEVICE_PREF = os.environ.get("AID_DEVICE", "auto").lower()
+
+
+def resolve_device():
+    if DEVICE_PREF != "auto":
+        return DEVICE_PREF
+    if torch.cuda.is_available():
+        return "cuda"
+    if torch.backends.mps.is_available():
+        return "mps"
+    return "cpu"
+
+
+def load_model(device):
+    """Load the quantized detector declared by the repo's own config."""
+    config = AutoConfig.from_pretrained(MODEL_ID)
+    quantization = getattr(config, "quantization_config", None)
+    if not quantization:
+        raise RuntimeError(
+            f"{MODEL_ID} does not declare a quantization_config; it is expected "
+            "to be the 4-bit NF4 checkpoint"
+        )
+    model = AutoModelForSequenceClassification.from_pretrained(
+        MODEL_ID, config=config
+    )
+    model.to(device)
+    return model, "nf4 4-bit"
+
+
+DEVICE = resolve_device()
+STARTED = time.time()
+model, QUANT_LABEL = load_model(DEVICE)
+model.eval()
+LOAD_SECONDS = time.time() - STARTED
+MODEL_MB = model.get_memory_footprint() / 1024**2
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+
+
+SPLIT_RE = re.compile(r"(?<=[.!?])\s+|\n{2,}")
+
+
+def sentence_spans(text):
+    """Return (start, end, sentence) triples, preserving source offsets."""
+    spans = []
+    start = 0
+    for match in SPLIT_RE.finditer(text):
+        chunk = text[start : match.start()]
+        if chunk.strip():
+            spans.append((start, match.start(), chunk))
+        start = match.end()
+    tail = text[start:]
+    if tail.strip():
+        spans.append((start, len(text), tail))
+    return spans
+
+
+def split_sentences(text):
+    return [sentence for _, _, sentence in sentence_spans(text)]
+
+
+def split_for_model(text):
+    """Pack sentences into chunks that fit the model's token window."""
+    chunks = []
+    current = ""
+    for sentence in split_sentences(text):
+        candidate = f"{current} {sentence}".strip()
+        if current and len(tokenizer(candidate)["input_ids"]) > MAX_TOKENS:
+            chunks.append(current)
+            current = sentence
+        else:
+            current = candidate
+    if current:
+        chunks.append(current)
+    return chunks or [text.strip()]
+
+
+@torch.no_grad()
+def score(texts):
+    probs = []
+    for start in range(0, len(texts), BATCH_SIZE):
+        batch = texts[start : start + BATCH_SIZE]
+        encoded = tokenizer(
+            batch,
+            return_tensors="pt",
+            truncation=True,
+            max_length=MAX_TOKENS,
+            padding=True,
+        )
+        encoded = {
+            key: value.to(next(model.parameters()).device)
+            for key, value in encoded.items()
+        }
+        logits = model(**encoded).logits.squeeze(-1)
+        probs.extend(torch.sigmoid(logits).float().cpu().tolist())
+    return probs
+
+
+def verdict(prob, threshold):
+    if prob >= max(threshold, 0.9):
+        return "AI-generated"
+    if prob >= threshold:
+        return "Likely AI-generated"
+    if prob <= 0.1:
+        return "Human-written"
+    return "Likely human-written"
+
+
+def aggregate(probs, mode):
+    """Combine per-window scores into one score.
+
+    ``mean`` averages every window. ``max`` reports the highest-scoring window,
+    so one AI-like passage is not diluted by surrounding human text.
+    """
+    if mode == "max":
+        return max(probs)
+    return sum(probs) / len(probs)
+
+
+def bar(prob, width=24):
+    filled = round(prob * width)
+    return "#" * filled + "-" * (width - filled)
+
+
+def prob_color(prob):
+    """Interpolate a green (P(AI)=0) to red (P(AI)=1) background."""
+    hue = 120 * (1 - min(max(prob, 0.0), 1.0))
+    return f"hsl({hue:.0f}, 85%, 78%)"
+
+
+def highlight_html(text, spans, probs):
+    """Render the input text with a per-sentence colored background."""
+    parts = ['<div class="aid-highlight">']
+    cursor = 0
+    for (start, end, sentence), prob in zip(spans, probs):
+        gap = text[cursor:start]
+        parts.append(html.escape(gap).replace("\n", "<br>"))
+        color = prob_color(prob)
+        parts.append(
+            f'<span title="P(AI) = {prob:.3f}" '
+            f'style="background:{color}; border-radius:3px; padding:1px 2px;" '
+            f'data-p="{prob:.3f}">{html.escape(sentence)}</span>'
+        )
+        cursor = end
+    parts.append(html.escape(text[cursor:]).replace("\n", "<br>"))
+    parts.append("</div>")
+
+    legend = ["<div class='aid-legend'>"]
+    for stop in (0.0, 0.25, 0.5, 0.75, 1.0):
+        legend.append(
+            f'<span style="background:{prob_color(stop)}; border-radius:3px; '
+            f'padding:1px 6px;">P(AI) {stop:.2f}</span>'
+        )
+    legend.append("</div>")
+
+    return (
+        '<style>'
+        ".aid-highlight { line-height: 1.9; white-space: normal; }"
+        ".aid-legend { margin-top: 10px; display: flex; gap: 8px; flex-wrap: wrap; "
+        "font-size: 0.8em; }"
+        "</style>"
+        + "".join(legend)
+        + "".join(parts)
+    )
+
+
+def analyze(text, threshold, aggregation):
+    text = (text or "").strip()
+    if not text:
+        raise gr.Error("Enter some text to analyze.")
+    if len(text) > MAX_CHARS:
+        raise gr.Error(
+            f"Text is {len(text):,} characters; the limit is {MAX_CHARS:,}. "
+            "Analyze it in parts."
+        )
+
+    threshold = float(threshold)
+    aggregation = aggregation if aggregation in AGGREGATIONS else "mean"
+
+    spans = sentence_spans(text)
+    sentences = [sentence for _, _, sentence in spans]
+    chunks = split_for_model(text)
+    chunk_probs = score(chunks)
+    sentence_probs = score(sentences) if sentences else chunk_probs
+    highlighted = highlight_html(text, spans, sentence_probs)
+
+    overall = aggregate(chunk_probs, aggregation)
+    ai_sentences = sum(1 for p in sentence_probs if p >= threshold)
+    flagged = sorted(
+        zip(sentence_probs, sentences), key=lambda item: item[0], reverse=True
+    )[:5]
+    agg_label = "Max" if aggregation == "max" else "Mean"
+    if len(chunks) == 1:
+        agg_note = "one window, so mean and max are identical"
+    elif aggregation == "max":
+        agg_note = "highest-scoring window"
+    else:
+        agg_note = f"average across {len(chunks)} windows"
+
+    lines = [
+        "# AI Text Detection Report",
+        "",
+        f"**Model:** `{MODEL_ID}`",
+        f"**Backend:** {QUANT_LABEL} on {DEVICE} | {MODEL_MB:,.0f} MB resident "
+        f"| loaded in {LOAD_SECONDS:.1f} s",
+        f"**Characters:** {len(text):,}  |  **Sentences:** {len(sentences):,}"
+        f"  |  **Windows scored:** {len(chunks)}",
+        f"**Aggregation:** {agg_label} ({agg_note})  |  "
+        f"**Threshold:** {threshold:.2f}",
+        "",
+        "## Verdict",
+        "",
+        f"### {verdict(overall, threshold)}",
+        "",
+        f"`{bar(overall)}` **score = {overall:.3f}**"
+        f" ({'above' if overall >= threshold else 'below'} {threshold:.2f})",
+        "",
+        "| Metric | Value |",
+        "| --- | --- |",
+        f"| Score ({agg_label} of windows) | {overall:.3f} |",
+        f"| Mean of windows | {sum(chunk_probs) / len(chunk_probs):.3f} |",
+        f"| Max of windows | {max(chunk_probs):.3f} |",
+        f"| Sentences at or above threshold | {ai_sentences}/{len(sentence_probs)} |",
+        f"| Max sentence score | {max(sentence_probs):.3f} |",
+        f"| Min sentence score | {min(sentence_probs):.3f} |",
+        f"| Decision threshold | {threshold:.2f} |",
+        "",
+        "## Sentence-level breakdown",
+        "",
+    ]
+
+    for prob, sentence in zip(sentence_probs, sentences):
+        snippet = sentence if len(sentence) <= 160 else sentence[:157] + "..."
+        lines.append(f"- `{prob:.3f}` `{bar(prob, 12)}` {snippet}")
+
+    lines += [
+        "",
+        "## Most AI-like passages",
+        "",
+    ]
+    for prob, sentence in flagged:
+        snippet = sentence if len(sentence) <= 200 else sentence[:197] + "..."
+        lines.append(f"> **{prob:.3f}** - {snippet}")
+
+    lines += [
+        "",
+        "---",
+        "",
+        "_Scores are model probabilities, not proof. The model card warns against "
+        "using this as the sole basis for high-stakes decisions such as academic "
+        "or employment penalties, and notes degraded accuracy on text "
+        "distributions unlike its training data. The threshold is a display "
+        "choice: only 0.50 is documented upstream, and no false-positive rate is "
+        "claimed for any other value._",
+    ]
+
+    per_sentence = [
+        {"sentence": s, "p_ai": round(p, 4)} for p, s in zip(sentence_probs, sentences)
+    ]
+    summary = {
+        "backend": f"{QUANT_LABEL} on {DEVICE}",
+        "verdict": verdict(overall, threshold),
+        "score": round(overall, 4),
+        "score_max": round(max(chunk_probs), 4),
+        "score_mean": round(sum(chunk_probs) / len(chunk_probs), 4),
+        "aggregation": aggregation,
+        "threshold": round(threshold, 2),
+        "above_threshold": overall >= threshold,
+        "sentences_at_or_above_threshold": ai_sentences,
+        "windows": len(chunks),
+        "sentences": per_sentence,
+    }
+    return highlighted, "\n".join(lines), summary
+
+
+with gr.Blocks(title="AI Text Detector") as demo:
+    gr.Markdown(
+        "# AI-Generated Text Detector\n"
+        "Paste text to estimate the probability it was written by a language "
+        f"model, using `{MODEL_ID}` ({QUANT_LABEL} on {DEVICE})."
+    )
+    with gr.Row():
+        with gr.Column(scale=2):
+            textbox = gr.Textbox(
+                label="Text",
+                lines=14,
+                placeholder="Paste the text you want to analyze...",
+            )
+            with gr.Row():
+                run = gr.Button("Analyze", variant="primary")
+                clear = gr.Button("Clear")
+            with gr.Accordion("Scoring options", open=False):
+                threshold = gr.Slider(
+                    minimum=MIN_THRESHOLD,
+                    maximum=MAX_THRESHOLD,
+                    value=THRESHOLD,
+                    step=0.01,
+                    label="Decision threshold",
+                    info="Upstream suggests 0.5. Raising it trades fewer false "
+                    "positives for more misses.",
+                )
+                aggregation = gr.Radio(
+                    choices=list(AGGREGATIONS),
+                    value="mean",
+                    label="Window aggregation",
+                    info="mean averages every window; max reports the "
+                    "highest-scoring window and is not diluted by human text "
+                    "elsewhere. Identical when the text fits one window.",
+                )
+            gr.Examples(
+                examples=[
+                    [
+                        "I went to the store yesterday and bought three apples. "
+                        "They were a bit bruised, but the price was right, and I "
+                        "figured they'd be fine in a pie."
+                    ],
+                    [
+                        "In today's rapidly evolving digital landscape, "
+                        "organizations must leverage synergistic strategies to "
+                        "unlock unprecedented value. By fostering a culture of "
+                        "continuous innovation, stakeholders can navigate "
+                        "complexity with confidence and drive meaningful outcomes."
+                    ],
+                ],
+                inputs=textbox,
+            )
+        with gr.Column(scale=3):
+            highlighted = gr.HTML(
+                label="Sentence-level highlighting",
+                show_label=True,
+                container=True,
+                padding=True,
+            )
+            report = gr.Markdown(label="Report")
+            raw = gr.JSON(label="Machine-readable summary")
+
+    outputs = [highlighted, report, raw]
+    inputs = [textbox, threshold, aggregation]
+    run.click(analyze, inputs=inputs, outputs=outputs)
+    textbox.submit(analyze, inputs=inputs, outputs=outputs)
+    clear.click(
+        lambda: ("", "", None, None, THRESHOLD, "mean"),
+        outputs=[textbox, *outputs, threshold, aggregation],
+    )
+
+
+if __name__ == "__main__":
+    print(
+        f"[aid] {MODEL_ID} loaded as {QUANT_LABEL} on {DEVICE} "
+        f"({MODEL_MB:,.0f} MB resident, {LOAD_SECONDS:.1f} s)",
+        flush=True,
+    )
+    score(["Warming up the model."])
+    # One inference at a time: on CPU the model saturates the vCPUs it is given.
+    demo.queue(default_concurrency_limit=1).launch()

requirements.txt

@@ -0,0 +1,9 @@
+# CPU-only torch: the default PyPI wheel is the CUDA build, several GB larger.
+--extra-index-url https://download.pytorch.org/whl/cpu
+
+gradio>=5.0
+torch>=2.2
+transformers>=4.48
+sentencepiece
+bitsandbytes>=0.50
+accelerate>=1.1