initial commit

.gitignore

@@ -0,0 +1,47 @@
+# Byte-compiled / optimized files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# Packaging / build artifacts
+build/
+dist/
+*.egg-info/
+.eggs/
+
+# Testing / coverage / linting caches
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+
+# Gradio runtime artifacts
+.gradio/
+flagged/
+gradio_cached_examples/
+
+# Hugging Face / model caches
+.cache/
+hf_cache/
+
+# IDE / editor
+.idea/
+.vscode/
+*.swp
+
+# OS noise
+.DS_Store
+Thumbs.db
+
+# Local environment
+.env
+
+# Tests (not deployed to the Space)
+tests/

app.py

@@ -0,0 +1,181 @@
+"""GigaCheck demo: classify text and localize AI-written spans.
+
+Two tabs back two Mistral-7B models from the LLMTrace / GigaCheck project:
+a binary human/AI classifier and a fine-grained AI-span detector.
+"""
+
+from __future__ import annotations
+
+import gradio as gr
+from loguru import logger
+
+from models import classify_text, detect_intervals
+from rendering import build_classifier_card, build_detector_card
+from styles import CSS, THEME
+from validation import CONFIG, validate_text
+
+LANG_NOTE = (
+    '<div class="gc-lang-note">⚠️ These models work with <b>English</b> and '
+    f"<b>Russian</b> text only. Enter between {CONFIG.min_words} and "
+    f"{CONFIG.max_words} words.</div>"
+)
+
+CLASSIFIER_EXAMPLES = [
+    # human
+    [
+        "Netflix has laid off around 300 people across a number of departments. The company also laid off 150 workers back in May."
+    ],
+    # ai
+    [
+        "@GOP @PamBondi Maybe we should talk about Gordon Sondland, who had ZERO experience or qualifications to be an Ambassador to the EU but since he donated a million dollars to trump he got the job anyway. I'm outraged!"
+    ],
+    # ai
+    [
+        "В прекрасное утро, поразмыслив о том, как множество радостей приносит нам природа, я вспомнила о своей милой питомице, мадам Леске, и о ее необъяснимой страсти к дыне. \"Как же,\" подумала я, \"этот нежный плод вмещает в себе не только великолепие вкуса, но и целую кладезь полезных веществ\". И вдруг осенило меня: разве не заслуживает моя преданная спутница опробовать хоть крохотный кусочек этого плода?"
+    ],
+]
+
+DETECTOR_EXAMPLES = [
+    [
+       "The critic's review of the recent publication was scathing. The book failed miserably in portraying the harmful subjective discourses associated with the hegemony of the political system."
+
+    ],
+    [
+        "Университет Шеффилд Холлем имеет в Шеффилде два кампуса. Один из них — это Городской кампус, который находится в центре города. Второй кампус, Коллегиальный, расположен на юго-западе Шеффилда. Оба кампуса предлагают современные учебные здания и ресурсы для студентов. История университета Шеффилд Холлем началась в 1843 году с основания Шеффилдской школы дизайна. В 1960-х годах несколько независимых колледжей (включая Школу дизайна) объединились в Шеффилдский Политехникум, с 1976 года — Шеффилдский городской политехникум, с 1992 года — Университет Шеффилд Холлем."
+    ],
+]
+
+
+def update_counter(text: str) -> str:
+    """Render a live word counter, flagging out-of-bounds input in red.
+
+    Args:
+        text: Current textbox content.
+
+    Returns:
+        An HTML snippet showing the word count and any validation message.
+    """
+    result = validate_text(text)
+    bad = (not result.ok) and result.word_count > 0
+    css_class = "gc-counter gc-bad" if bad else "gc-counter"
+    note = f" — {result.message}" if bad else ""
+    return (
+        f'<div class="{css_class}">{result.word_count} / '
+        f"{CONFIG.max_words} words{note}</div>"
+    )
+
+
+def run_classifier(text: str) -> str:
+    """Validate then classify the text, returning a result card.
+
+    Args:
+        text: User-supplied text.
+
+    Returns:
+        HTML for the classifier result card.
+
+    Raises:
+        gr.Error: If the text falls outside the configured word bounds.
+    """
+    result = validate_text(text)
+    if not result.ok:
+        raise gr.Error(result.message)
+    label, p_human, p_ai = classify_text(text)
+    logger.info("classifier: label={} p_human={:.3f}", label, p_human)
+    return build_classifier_card(label, p_human, p_ai)
+
+
+def run_detector(text: str, conf_threshold: float) -> str:
+    """Validate then run AI-span detection, returning a result card.
+
+    Args:
+        text: User-supplied text.
+        conf_threshold: Confidence threshold for keeping a span.
+
+    Returns:
+        HTML for the detector result card.
+
+    Raises:
+        gr.Error: If the text falls outside the configured word bounds.
+    """
+    result = validate_text(text)
+    if not result.ok:
+        raise gr.Error(result.message)
+    intervals = detect_intervals(text, conf_threshold)
+    logger.info("detector: {} interval(s) at thresh={}", len(intervals), conf_threshold)
+    return build_detector_card(text, intervals)
+
+
+def build_classifier_tab() -> None:
+    """Build the classifier tab UI and wire its events."""
+    gr.HTML(LANG_NOTE)
+    text_in = gr.Textbox(
+        label="Text",
+        placeholder="Paste English or Russian text to classify…",
+        lines=8,
+    )
+    counter = gr.HTML(update_counter(""))
+    analyze_btn = gr.Button("Analyze", variant="primary")
+    output = gr.HTML()
+    gr.Examples(examples=CLASSIFIER_EXAMPLES, inputs=[text_in], label="Examples")
+
+    text_in.change(update_counter, inputs=[text_in], outputs=[counter])
+    analyze_btn.click(run_classifier, inputs=[text_in], outputs=[output])
+
+
+def build_detector_tab() -> None:
+    """Build the detector tab UI and wire its events."""
+    gr.HTML(LANG_NOTE)
+    text_in = gr.Textbox(
+        label="Text",
+        placeholder="Paste English or Russian text to scan for AI-written spans…",
+        lines=8,
+    )
+    counter = gr.HTML(update_counter(""))
+    conf = gr.Slider(
+        label="Confidence threshold",
+        minimum=0.0,
+        maximum=1.0,
+        value=CONFIG.default_conf_threshold,
+        step=0.05,
+    )
+    detect_btn = gr.Button("Detect", variant="primary")
+    output = gr.HTML()
+    gr.Examples(examples=DETECTOR_EXAMPLES, inputs=[text_in], label="Examples")
+
+    text_in.change(update_counter, inputs=[text_in], outputs=[counter])
+    detect_btn.click(run_detector, inputs=[text_in, conf], outputs=[output])
+
+
+def build_demo() -> gr.Blocks:
+    """Assemble the full Gradio demo.
+
+    Returns:
+        The configured :class:`gradio.Blocks` application.
+    """
+    with gr.Blocks(theme=THEME, css=CSS, title="GigaCheck") as demo:
+        gr.HTML(
+            '<div id="gc-header"><h1>GigaCheck</h1>'
+            "<p>Detect AI-generated text — binary classification and "
+            "fine-grained span localization</p></div>"
+        )
+        with gr.Tabs():
+            with gr.Tab("Classifier"):
+                gr.Markdown(
+                    "Binary **human / AI** classifier — "
+                    "[GigaCheck-Classifier-Multi]"
+                    "(https://huggingface.co/iitolstykh/GigaCheck-Classifier-Multi)"
+                )
+                build_classifier_tab()
+            with gr.Tab("Detector"):
+                gr.Markdown(
+                    "Fine-grained **AI-span detector** — "
+                    "[GigaCheck-Detector-Multi]"
+                    "(https://huggingface.co/iitolstykh/GigaCheck-Detector-Multi)"
+                )
+                build_detector_tab()
+    return demo
+
+
+if __name__ == "__main__":
+    build_demo().queue(max_size=50).launch()

conftest.py

@@ -0,0 +1,6 @@
+"""Pytest configuration.
+
+The presence of this file at the repository root makes pytest insert this
+directory onto ``sys.path``, so the flat demo modules (``validation``,
+``rendering``) can be imported directly from the test suite.
+"""

models.py

@@ -0,0 +1,102 @@
+"""Model loading and GPU-aware inference wrappers for the GigaCheck demo."""
+
+from __future__ import annotations
+
+import torch
+from loguru import logger
+from transformers import AutoModel
+
+from rendering import AiInterval
+from validation import CONFIG
+
+try:
+    import spaces
+
+    gpu = spaces.GPU
+    HAS_SPACES = True
+except ImportError:
+    HAS_SPACES = False
+
+    def gpu(*args, **kwargs):
+        """No-op stand-in for :func:`spaces.GPU` when ``spaces`` is unavailable.
+
+        Supports both bare ``@gpu`` and parameterized ``@gpu(duration=...)`` usage.
+        """
+        if args and callable(args[0]):
+            return args[0]
+
+        def wrap(fn):
+            return fn
+
+        return wrap
+
+
+def select_device() -> str:
+    """Pick the inference device, preferring GPU when it is reachable.
+
+    On ZeroGPU, CUDA is not visible at import time but is materialized inside the
+    decorated function, so the presence of the ``spaces`` package implies a GPU.
+
+    Returns:
+        ``"cuda:0"`` when a GPU is (or will be) available, otherwise ``"cpu"``.
+    """
+    if torch.cuda.is_available() or HAS_SPACES:
+        return "cuda:0"
+    return "cpu"
+
+
+DEVICE = select_device()
+logger.info("GigaCheck demo device: {} (spaces={})", DEVICE, HAS_SPACES)
+
+logger.info("Loading classifier: {}", CONFIG.classifier_model_id)
+classifier_model = AutoModel.from_pretrained(
+    CONFIG.classifier_model_id,
+    trust_remote_code=True,
+    device_map=DEVICE,
+    torch_dtype=torch.bfloat16,
+)
+
+logger.info("Loading detector: {}", CONFIG.detector_model_id)
+detector_model = AutoModel.from_pretrained(
+    CONFIG.detector_model_id,
+    trust_remote_code=True,
+    device_map=DEVICE,
+    torch_dtype=torch.float32,
+)
+
+
+@gpu(duration=120)
+def classify_text(text: str) -> tuple[str, float, float]:
+    """Classify a text as human-written or AI-generated.
+
+    Args:
+        text: Input text (English or Russian).
+
+    Returns:
+        A tuple ``(label, p_human, p_ai)`` where ``label`` is the raw model
+        label and the probabilities are floats in ``[0, 1]``.
+    """
+    with torch.inference_mode():
+        output = classifier_model([text.replace("\n", " ")])
+    # classification_head_probs: [batch, 2] ordered as [p_ai, p_human].
+    probs = output.classification_head_probs[0].to(torch.float32).tolist()
+    p_ai, p_human = float(probs[0]), float(probs[1])
+    label = classifier_model.config.id2label[int(output.pred_label_ids[0])]
+    return label, p_human, p_ai
+
+
+@gpu(duration=120)
+def detect_intervals(text: str, conf_threshold: float) -> list[AiInterval]:
+    """Detect character spans likely written by an AI model.
+
+    Args:
+        text: Input text (English or Russian).
+        conf_threshold: Confidence threshold for keeping a span.
+
+    Returns:
+        A list of ``(start_char, end_char, score)`` tuples.
+    """
+    with torch.inference_mode():
+        output = detector_model([text], conf_interval_thresh=conf_threshold)
+    raw = output.ai_intervals[0].cpu()
+    return [(int(span[0]), int(span[1]), float(span[2])) for span in raw]

rendering.py

@@ -0,0 +1,160 @@
+"""HTML rendering helpers for classifier and detector results."""
+
+from __future__ import annotations
+
+import html
+
+from validation import CONFIG
+
+AiInterval = tuple[int, int, float]
+
+
+def prettify_label(label: str) -> str:
+    """Convert a raw model label into a display label.
+
+    Args:
+        label: Raw label from the model config (e.g. ``"ai"`` or ``"human"``).
+
+    Returns:
+        A capitalized, human-friendly label (``"AI"`` or ``"Human"``).
+    """
+    mapping = {"ai": "AI", "human": "Human", "mixed": "Mixed"}
+    return mapping.get(label.lower(), label.capitalize())
+
+
+def build_classifier_card(label: str, p_human: float, p_ai: float) -> str:
+    """Render the classifier result as a labeled split probability bar.
+
+    Args:
+        label: Predicted raw label (``"ai"`` or ``"human"``).
+        p_human: Probability that the text is human-written, in ``[0, 1]``.
+        p_ai: Probability that the text is AI-generated, in ``[0, 1]``.
+
+    Returns:
+        An HTML string with the predicted label and a green/red split bar.
+    """
+    human_pct = round(p_human * 100)
+    ai_pct = 100 - human_pct
+    verdict = prettify_label(label)
+    verdict_color = CONFIG.ai_color if verdict == "AI" else CONFIG.human_color
+    return f"""
+<div class="gc-card">
+  <div class="gc-verdict">
+    Predicted: <span style="color:{verdict_color}">{verdict}</span>
+  </div>
+  <div class="gc-bar">
+    <div class="gc-bar-human" style="width:{human_pct}%"></div>
+    <div class="gc-bar-ai" style="width:{ai_pct}%"></div>
+  </div>
+  <div class="gc-bar-legend">
+    <span class="gc-legend-human">Human · {human_pct}%</span>
+    <span class="gc-legend-ai">AI · {ai_pct}%</span>
+  </div>
+</div>
+"""
+
+
+def merge_intervals(intervals: list[AiInterval], text_len: int) -> list[AiInterval]:
+    """Merge AI intervals into non-overlapping segments keeping the max score.
+
+    Overlapping or touching predictions are flattened so that every character
+    is covered at most once, using the highest score among covering intervals.
+
+    Args:
+        intervals: Raw ``(start, end, score)`` predictions.
+        text_len: Length of the source text, used to clip the bounds.
+
+    Returns:
+        Sorted, non-overlapping ``(start, end, score)`` segments.
+    """
+    clipped = [
+        (max(0, start), min(text_len, end), score)
+        for start, end, score in intervals
+        if min(text_len, end) > max(0, start)
+    ]
+    if not clipped:
+        return []
+
+    boundaries = sorted({b for start, end, _ in clipped for b in (start, end)})
+    segments: list[AiInterval] = []
+    for left, right in zip(boundaries, boundaries[1:]):
+        covering = [s for st, en, s in clipped if st <= left and en >= right]
+        if not covering:
+            continue
+        score = max(covering)
+        if segments and segments[-1][1] == left and segments[-1][2] == score:
+            prev_start, _, prev_score = segments[-1]
+            segments[-1] = (prev_start, right, prev_score)
+        else:
+            segments.append((left, right, score))
+    return segments
+
+
+def score_to_alpha(score: float) -> float:
+    """Map a confidence score to a background opacity.
+
+    Args:
+        score: Confidence score in ``[0, 1]``.
+
+    Returns:
+        An opacity in ``[0.15, 1.0]`` so even low scores stay visible.
+    """
+    return round(0.15 + 0.85 * max(0.0, min(1.0, score)), 3)
+
+
+def build_highlighted_text(text: str, intervals: list[AiInterval]) -> str:
+    """Render text with AI spans highlighted by score-scaled red backgrounds.
+
+    Args:
+        text: The source text exactly as passed to the detector.
+        intervals: Raw ``(start, end, score)`` predictions.
+
+    Returns:
+        An HTML string with AI spans wrapped in colored ``<span>`` elements.
+    """
+    segments = merge_intervals(intervals, len(text))
+    parts: list[str] = []
+    cursor = 0
+    for start, end, score in segments:
+        if start > cursor:
+            parts.append(html.escape(text[cursor:start]))
+        alpha = score_to_alpha(score)
+        chunk = html.escape(text[start:end])
+        parts.append(
+            f'<span class="gc-ai-span" '
+            f'style="background-color: rgba(229, 83, 60, {alpha})" '
+            f'title="AI score: {score:.2f}">{chunk}</span>'
+        )
+        cursor = end
+    if cursor < len(text):
+        parts.append(html.escape(text[cursor:]))
+    return "".join(parts)
+
+
+def build_detector_card(text: str, intervals: list[AiInterval]) -> str:
+    """Render the detector result with a header summary and highlighted text.
+
+    Args:
+        text: The source text exactly as passed to the detector.
+        intervals: Raw ``(start, end, score)`` predictions.
+
+    Returns:
+        An HTML string containing a summary line and the highlighted text.
+    """
+    segments = merge_intervals(intervals, len(text))
+    if segments:
+        summary = (
+            f"{len(segments)} AI-written fragment(s) detected — "
+            "darker red means higher confidence."
+        )
+        summary_class = "gc-summary gc-summary-ai"
+    else:
+        summary = "No AI-written fragments detected above the threshold."
+        summary_class = "gc-summary gc-summary-clean"
+    highlighted = build_highlighted_text(text, intervals)
+    return f"""
+<div class="gc-card">
+  <div class="{summary_class}">{summary}</div>
+  <div class="gc-text">{highlighted}</div>
+</div>
+"""

requirements.txt

@@ -0,0 +1,9 @@
+gradio==6.16.0
+transformers==4.50.1
+torch==2.8.0
+accelerate
+sentencepiece
+loguru
+pydantic
+huggingface_hub
+git+https://github.com/ai-forever/gigacheck

styles.py

@@ -0,0 +1,91 @@
+"""Gradio theme and CSS for the GigaCheck demo (pastel orange-red)."""
+
+from __future__ import annotations
+
+import gradio as gr
+
+THEME = gr.themes.Soft(
+    primary_hue=gr.themes.colors.red,
+    secondary_hue=gr.themes.colors.orange,
+    neutral_hue=gr.themes.colors.stone,
+    font=(gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"),
+)
+
+CSS = """
+:root {
+  --gc-peach: #FFE3D5;
+  --gc-coral: #FF8A65;
+  --gc-red: #E5533C;
+  --gc-deep: #C5402B;
+  --gc-green: #2FA66B;
+  --gc-ink: #3A2A24;
+}
+.gradio-container { max-width: 980px !important; }
+
+#gc-header { text-align: center; margin: 0.4rem 0 1.2rem; }
+#gc-header h1 {
+  margin: 0; font-weight: 800; letter-spacing: -0.03em; font-size: 2.2rem;
+  background: linear-gradient(110deg, var(--gc-coral) 0%, var(--gc-red) 55%, var(--gc-deep) 100%);
+  -webkit-background-clip: text; background-clip: text; color: transparent;
+}
+#gc-header p { margin: 0.45rem 0 0; color: var(--gc-ink); opacity: 0.7; font-size: 1.02rem; }
+
+.gc-lang-note {
+  border-radius: 12px;
+  padding: 10px 14px;
+  margin: 0 0 6px;
+  font-size: 0.9rem;
+  color: var(--gc-deep);
+  background: linear-gradient(135deg, rgba(255,227,213,0.85), rgba(255,138,101,0.22));
+  border: 1px solid rgba(229,83,60,0.30);
+}
+.gc-lang-note b { font-weight: 700; }
+
+.gc-counter { font-size: 0.82rem; opacity: 0.7; margin: 2px 4px 0; }
+.gc-counter.gc-bad { color: var(--gc-red); opacity: 1; font-weight: 600; }
+
+.gc-card {
+  padding: 18px 20px;
+  border-radius: 16px;
+  background: #ffffff;
+  border: 1px solid rgba(229,83,60,0.22);
+  box-shadow: 0 6px 22px rgba(229,83,60,0.08);
+}
+
+.gc-verdict { font-size: 1.25rem; font-weight: 700; margin-bottom: 14px; color: var(--gc-ink); }
+
+.gc-bar {
+  display: flex; width: 100%; height: 26px;
+  border-radius: 999px; overflow: hidden;
+  background: #f1ece9;
+}
+.gc-bar-human { background: var(--gc-green); height: 100%; transition: width 0.4s ease; }
+.gc-bar-ai { background: var(--gc-red); height: 100%; transition: width 0.4s ease; }
+.gc-bar-legend {
+  display: flex; justify-content: space-between;
+  margin-top: 8px; font-size: 0.9rem; font-weight: 600;
+}
+.gc-legend-human { color: var(--gc-green); }
+.gc-legend-ai { color: var(--gc-red); }
+
+.gc-summary { font-size: 0.95rem; font-weight: 600; margin-bottom: 12px; }
+.gc-summary-ai { color: var(--gc-deep); }
+.gc-summary-clean { color: var(--gc-green); }
+
+.gc-text {
+  white-space: pre-wrap; word-wrap: break-word; line-height: 1.65;
+  font-size: 1.0rem; color: var(--gc-ink);
+}
+.gc-ai-span { border-radius: 4px; padding: 1px 1px; color: #2a160f; }
+
+button.primary, .gradio-container .primary {
+  background: linear-gradient(135deg, var(--gc-coral), var(--gc-red)) !important;
+  border: none !important;
+  color: #ffffff !important;
+  font-weight: 700 !important;
+  letter-spacing: 0.02em;
+}
+button.primary:hover, .gradio-container .primary:hover {
+  filter: brightness(1.05) saturate(1.08);
+}
+"""

validation.py

@@ -0,0 +1,88 @@
+"""Shared configuration and input validation for the GigaCheck demo."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class DemoConfig(BaseModel):
+    """Static configuration shared across the demo.
+
+    Attributes:
+        classifier_model_id: Hub id of the human/AI classifier model.
+        detector_model_id: Hub id of the AI-span detector model.
+        min_words: Minimum number of words an input must contain.
+        max_words: Maximum number of words an input may contain.
+        human_color: Hex color used for the "human" portion of the bar.
+        ai_color: Hex color used for the "AI" portion of the bar and span highlights.
+        default_conf_threshold: Default confidence threshold for the detector.
+    """
+
+    classifier_model_id: str = "iitolstykh/GigaCheck-Classifier-Multi"
+    detector_model_id: str = "iitolstykh/GigaCheck-Detector-Multi"
+    min_words: int = 15
+    max_words: int = 512
+    human_color: str = "#2FA66B"
+    ai_color: str = "#E5533C"
+    default_conf_threshold: float = 0.5
+
+
+CONFIG = DemoConfig()
+
+
+class ValidationResult(BaseModel):
+    """Outcome of validating a piece of input text.
+
+    Attributes:
+        ok: Whether the text satisfies the word-count bounds.
+        message: Human-readable explanation when ``ok`` is ``False``.
+        word_count: Number of words found in the text.
+    """
+
+    ok: bool
+    message: str
+    word_count: int
+
+
+def count_words(text: str) -> int:
+    """Count whitespace-separated words in a string.
+
+    Args:
+        text: Arbitrary user input.
+
+    Returns:
+        The number of whitespace-separated tokens.
+    """
+    return len(text.split())
+
+
+def validate_text(text: str, config: DemoConfig = CONFIG) -> ValidationResult:
+    """Validate that ``text`` falls within the configured word bounds.
+
+    Args:
+        text: User-supplied text to analyze.
+        config: Demo configuration providing the word bounds.
+
+    Returns:
+        A :class:`ValidationResult` describing whether the text is acceptable.
+    """
+    word_count = count_words(text)
+    if word_count < config.min_words:
+        return ValidationResult(
+            ok=False,
+            message=(
+                f"Text is too short: {word_count} word(s). "
+                f"Please enter at least {config.min_words} words."
+            ),
+            word_count=word_count,
+        )
+    if word_count > config.max_words:
+        return ValidationResult(
+            ok=False,
+            message=(
+                f"Text is too long: {word_count} words. "
+                f"Please keep it under {config.max_words} words."
+            ),
+            word_count=word_count,
+        )
+    return ValidationResult(ok=True, message="", word_count=word_count)