Claude Watermark: Statistische Wortverteilung & Quick Check

Der Begriff suggeriert ein physisches Merkmal wie auf einer Banknote, sichtbar für das blosse Auge. Tatsächlich beschreibt Anthropic selbst den Gegenteil-Fall: Das Wasserzeichen ist für Leser komplett ununterscheidbar und verändert weder Bedeutung noch Qualität des Texts.

Es gibt keine Zeichenkette zu suchen, keine verdächtigen Leerzeichen zu messen und nichts, was ein manuelles Auffinden erlauben würde. Der eigentliche Mechanismus ist eine Manipulation der Zufallsquelle, mit der das Modell zwischen bedeutungsgleichen Kandidatenwörtern wählt, etwa «schnell», «rasch» und «flott» in einem Kontext, in dem alle drei denselben Sinn ergeben.

«KI-Wasserzeichen» ist ein Sammelbegriff für drei technisch völlig verschiedene Ebenen. Wer sie vermischt, sucht an der falschen Stelle.

Der Checker oben deckt Spur 1 und Spur 3 verifizierbar ab, Spur 2 nur methodisch, weil Anthropics Schlüssel nicht öffentlich ist. Metadaten in Dateien sind nicht Teil dieser Seite und laufen über den text-humanizer-Skill.

Anthropic bestätigt, dass Claudes Ansatz eine Variante von Google DeepMinds SynthID-Text ist, welches auf die 2022 von Scott Aaronson vorgeschlagene Designidee zurückgeht. Diese Familie von Verfahren, zu der auch die 2023 veröffentlichte KGW-Methode (Kirchenbauer, Geiping, Wen et al.) gehört, funktioniert nach folgendem Muster:

1. 01Bei jedem Generierungsschritt besitzt das Modell mehrere Kandidatentokens mit nahezu identischer Wahrscheinlichkeit.
2. 02Ein geheimer Schlüssel wird mit den vorherigen Tokens kombiniert und per Hash-Funktion pseudorandom genutzt, um das gesamte Vokabular in eine Green List und eine Red List zu splitten.
3. 03Green-List-Tokens erhalten einen kleinen positiven Bonus auf ihre Auswahlwahrscheinlichkeit, bevor das Modell den nächsten Token zieht.
4. 04Dieser Bonus wirkt nur dort, wo Kandidaten ohnehin nahezu gleichwertig waren; er überschreibt keine starke Modellpräferenz, weshalb Grammatik und Fakteninhalt unverändert bleiben.
5. 05Über einen langen Text hinweg summiert sich die Verzerrung zu einem statistisch messbaren Muster, obwohl jede einzelne Wortwahl für sich genommen unauffällig wirkt.

Formal sampelt ein wasserzeichenfreies Modell den nächsten Token w_t aus einer bedingten Verteilung P_t über das Vokabular W. Ein wasserzeichenbehaftetes Modell koppelt diese Auswahl zusätzlich an eine pseudorandome Variable ζ_t, die nur der Prüfer kennt, sodass w_t = S(P_t, ζ_t) gilt, wobei S eine deterministische Dekoderfunktion ist.

Die Erkennung läuft in umgekehrter Richtung: Der Prüfer wendet mit demselben geheimen Schlüssel dasselbe Hashing-Schema auf den zu prüfenden Text an, zählt den Anteil der Tokens, die in die Green List fallen, und vergleicht diesen Anteil mit dem Erwartungswert bei reinem Zufall, typischerweise 50 Prozent bei γ = 0,5. Weicht der beobachtete Anteil signifikant nach oben ab, gilt der Text als wahrscheinlich Claude-generiert. Der Test funktioniert ohne Zugriff auf das Modell, benötigt aber zwingend den Schlüssel.

Ein positiver Treffer beweist zudem nur, dass Claude an dem Text mitgewirkt hat, nicht wer die Inhalte oder Ideen geliefert hat. Ein selbst verfasster Text, der lediglich von Claude Korrektur gelesen oder übersetzt wurde, kann exakt dieselbe Markierung auslösen wie ein komplett KI-generierter Text. Umgekehrt ist das Fehlen einer Markierung kein Beweis für menschliche Autorenschaft.

Anthropic hat zum Zeitpunkt der Ankündigung noch keine öffentliche Detection-API veröffentlicht; die Firma arbeitet an Tools für Nutzer und Dritte, ohne verbindlichen Zeitplan. Ohne den echten Anthropic-Schlüssel lässt sich das Originalverfahren also nicht nachbauen oder extern verifizieren.

Kommerzielle «AI-Detektoren», die heute schon Claude-Text erkennen wollen, arbeiten stattdessen mit generischer stilistischer Analyse: vorhersagbare Formulierungen, gleichförmiger Satzrhythmus, wiederkehrende Struktur. Michael Wades Analyse ordnet das ausdrücklich als grundverschiedene und deutlich unzuverlässigere Technik ein. Der regulatorische Treiber der Massnahme ist Artikel 50(2) des EU AI Act, den Anthropic mit dem Code of Practice formell unterzeichnet hat.

Das Grundprinzip ist offen dokumentiert und lässt sich für eigene Zwecke nachbauen, etwa zum Wasserzeichnen selbst betriebener LLM-Pipelines, auch wenn Anthropics konkreter Schlüssel unzugänglich bleibt. Das folgende Python-Modul implementiert die Kernlogik: pseudorandome Green-List-Erzeugung pro vorherigem Token plus Schlüssel, und einen z-Test-Detektor, der die beobachtete Trefferquote gegen den Zufallserwartungswert prüft.

"""
Claude / LLM Text-Watermark Checker (KGW-Stil / Green-Red-List)
-----------------------------------------------------------------
Implementiert das statistische Grundprinzip, das Anthropic fuer
Claude-Wasserzeichen beschreibt (SynthID-Text / KGW-Familie):
Bei jedem Generierungsschritt wird das Vokabular pseudorandom -
gesteuert durch einen Secret Key + die vorherigen Tokens - in eine
"Green List" und eine "Red List" gesplittet. Ein wasserzeichen-
behaftetes Modell bevorzugt statistisch die Green-List-Tokens.
Ohne den Key ist dieser Bias fuer Menschen unsichtbar, aber mit
genuegend Text statistisch nachweisbar (z-Test).

WICHTIG: Ohne Anthropics echten Secret Key kann dieses Skript
Claude-Wasserzeichen NICHT verifizieren. Es demonstriert die
Methodik und kann fuer eigene, selbst erzeugte Wasserzeichen
(z.B. in eigenen LLM-Pipelines) produktiv genutzt werden.
"""

import hashlib
import math
import re
from typing import List, Dict, Optional


def _hash_token(seed_str: str, token: str) -> int:
    return int(hashlib.sha256(f"{seed_str}:{token.lower()}".encode()).hexdigest(), 16)


def get_green_list(prev_token: str, key: str, vocab: List[str], gamma: float = 0.5) -> set:
    """Pseudorandomer Split des Vokabulars in Green/Red, seeded durch prev_token + Key."""
    seed_str = f"{key}:{prev_token.lower()}"
    scored = sorted(vocab, key=lambda w: _hash_token(seed_str, w))
    n_green = int(len(vocab) * gamma)
    return set(scored[:n_green])


def tokenize(text: str) -> List[str]:
    """Einfache Wort-Tokenisierung (fuer Produktionseinsatz: echten LLM-Tokenizer verwenden)."""
    return re.findall(r"[A-Za-zÀ-ÿ]+(?:'[a-z]+)?", text)


def detect_watermark(
    tokens: List[str],
    key: str,
    gamma: float = 0.5,
    vocab: Optional[List[str]] = None,
    z_threshold: float = 4.0,
) -> Dict:
    """
    Fuehrt den z-Test auf der Green-List-Traefferquote durch.

    - gamma: Erwarteter Anteil Green-Tokens unter Nullhypothese (kein Wasserzeichen).
    - z_threshold: Klassischer Schwellenwert (~4.0) fuer "wahrscheinlich wasserzeichenbehaftet".
    """
    if vocab is None:
        vocab = list(set(t.lower() for t in tokens))
    if len(tokens) < 2:
        return {"error": "Zu wenige Tokens fuer verlaessliche Erkennung (mind. ~75-100 empfohlen)."}

    green_hits = 0
    n = 0
    for i in range(1, len(tokens)):
        prev_tok, cur_tok = tokens[i - 1], tokens[i]
        green = get_green_list(prev_tok, key, vocab, gamma)
        if cur_tok.lower() in green:
            green_hits += 1
        n += 1

    observed_frac = green_hits / n
    se = math.sqrt(gamma * (1 - gamma) / n) if n > 0 else 0
    z = (observed_frac - gamma) / se if se > 0 else 0.0
    p_value = 0.5 * math.erfc(z / math.sqrt(2))

    return {
        "tokens_tested": n,
        "green_hits": green_hits,
        "observed_fraction": round(observed_frac, 4),
        "expected_fraction_null": gamma,
        "z_score": round(z, 3),
        "p_value_one_sided": round(p_value, 6),
        "likely_watermarked": z > z_threshold,
        "reliability_note": (
            "Ausreichend Text (>=100 Woerter empfohlen)."
            if n >= 100 else
            "Warnung: Textmenge unter empfohlenem Minimum, Ergebnis unsicher."
        ),
    }


def check_text(text: str, key: str, gamma: float = 0.5) -> Dict:
    """High-Level-Funktion: Text -> Tokenisierung -> Watermark-Check."""
    tokens = tokenize(text)
    return detect_watermark(tokens, key, gamma=gamma)


if __name__ == "__main__":
    # Beispieltext (menschlich verfasst, kein echtes Anthropic-Wasserzeichen)
    demo_key = "beispiel-secret-key"
    demo_text = (
        "Der Regen fiel leise auf das Dach, waehrend die Katze am Fenster sass "
        "und nach draussen schaute. Es war ein ruhiger Nachmittag, an dem nichts "
        "Aussergewoehnliches geschah, ausser dem gleichmaessigen Klang des Wassers."
    )
    result = check_text(demo_text, demo_key)
    for k, v in result.items():
        print(f"{k}: {v}")

Der Detektor liefert für jeden Text: die Anzahl geprüfter Tokens, die Green-List-Trefferquote, den z-Score und einen einseitigen p-Wert. Als Faustregel aus der Literatur gilt ein z-Score über etwa 4 als starkes Indiz für ein vorhandenes Wasserzeichen, während unter 100 Wörtern die Zuverlässigkeit stark abnimmt. Für den produktiven Einsatz gegen echte Modelle braucht es zusätzlich den exakten Tokenizer des Zielmodells statt einer einfachen Wort-Tokenisierung, den tatsächlichen Secret Key des Anbieters sowie Kenntnis des Gamma-Parameters und der Kontextfenstergrösse für die Hash-Seed-Bildung.

Ergänzend dazu steht das Modul ki_text_evidenz.py zum Download. Es ist bewusst kein Prozent-Detektor, sondern ein transparenter Evidenzschlüssel: messbare Merkmale ergeben je 0 bis 3 Punkte, gruppiert und gewichtet zu einem Index samt ausgewiesener Aussagekraft. Der Modus «Typische KI-Floskeln» oben nutzt genau diese Logik – ohne die tokenstatistischen Merkmale, weil dafür ein lokal betriebenes Sprachmodell nötig wäre.

Wer die andere Richtung braucht, also Provenienz-Marker in eigenen Dateien prüfen und entfernen, findet auf skills.fragroger.ai meinen Skill dafür. Die ausführliche Anleitung steht auf KI-Wasserzeichen entfernen.

• Anthropic

  Primärquelle zur Ankündigung und zu den Rahmenbedingungen des Wasserzeichens.

• Kirchenbauer et al., A Watermark for Large Language Models

  Die KGW-Methode: Green-List, Bias auf Logits und der z-Test, den auch der Detektor oben nutzt.

• Kirchenbauer et al., On the Reliability of Watermarks

  Belastbarkeit gegen Paraphrasierung, Übersetzung und menschliche Bearbeitung.

• Sadasivan et al., Can AI-Generated Text be Reliably Detected?

  Theoretische und praktische Grenzen von Detektion, inklusive Spoofing.

• Dathathri et al., SynthID-Text (Nature 2024)

  Googles produktiv eingesetztes Textwasserzeichen mit Tournament-Sampling.

• C2PA Specification

  Standard für signierte Herkunftsmetadaten, ergänzend zu statistischen Wasserzeichen.