Watermarking & detectie van AI-gegenereerde tekst

import hashlib
import numpy as np
 
class WatermarkLogitsProcessor:
    """Vereenvoudigde watermerkinjectie tijdens LLM-inferentie."""
 
    def __init__(self, secret_key: bytes, gamma: float = 0.5, delta: float = 2.0):
        self.secret_key = secret_key
        self.gamma = gamma  # fractie van de woordenschat in de groene lijst
        self.delta = delta  # logit-bias toegevoegd aan groene-lijst-tokens
 
    def get_green_list(self, prev_token_id: int, vocab_size: int) -> set:
        """Verdeel de woordenschat deterministisch in groene/rode lijsten."""
        seed = hashlib.sha256(
            self.secret_key + prev_token_id.to_bytes(4, "big")
        ).digest()
        rng = np.random.RandomState(
            int.from_bytes(seed[:4], "big")
        )
        green_count = int(vocab_size * self.gamma)
        green_list = set(rng.choice(vocab_size, green_count, replace=False))
        return green_list
 
    def __call__(self, prev_token_id: int, logits: np.ndarray) -> np.ndarray:
        """Voeg delta-bias toe aan de logits van groene-lijst-tokens."""
        green_list = self.get_green_list(prev_token_id, len(logits))
        modified = logits.copy()
        for token_id in green_list:
            modified[token_id] += self.delta
        return modified

from scipy import stats
 
def detect_watermark(
    text_token_ids: list[int],
    secret_key: bytes,
    vocab_size: int,
    gamma: float = 0.5,
) -> dict:
    """Test of de tekst een statistisch watermerk bevat."""
    green_count = 0
    total = len(text_token_ids) - 1  # eerste token overslaan (geen voorganger)
 
    for i in range(1, len(text_token_ids)):
        prev_id = text_token_ids[i - 1]
        green_list = get_green_list(prev_id, vocab_size, secret_key, gamma)
        if text_token_ids[i] in green_list:
            green_count += 1
 
    # Onder de nulhypothese (geen watermerk) is de groene fractie ~ gamma
    z_score = (green_count - gamma * total) / np.sqrt(total * gamma * (1 - gamma))
    p_value = 1 - stats.norm.cdf(z_score)
 
    return {
        "green_fraction": green_count / total,
        "z_score": z_score,
        "p_value": p_value,
        "watermarked": z_score > 4.0,  # drempelwaarde
    }

def detect_gpt_score(
    text: str,
    scoring_model,
    mask_model,
    n_perturbations: int = 100,
) -> float:
    """
    DetectGPT: AI-tekst bevindt zich op lokale maxima van de log-waarschijnlijkheid.
    Verstoringen zouden de log-waarschijnlijkheid voor AI-tekst moeten verlagen,
    maar hebben een willekeurig effect op menselijke tekst.
    """
    original_ll = scoring_model.log_likelihood(text)
    perturbation_lls = []
 
    for _ in range(n_perturbations):
        # Maskeer willekeurige spans en vul met mask_model (bijv. T5)
        perturbed = mask_and_fill(text, mask_model)
        perturbation_lls.append(scoring_model.log_likelihood(perturbed))
 
    mean_perturbed_ll = np.mean(perturbation_lls)
    std_perturbed_ll = np.std(perturbation_lls)
 
    # Genormaliseerde verstoringsdiscrepantie
    score = (original_ll - mean_perturbed_ll) / std_perturbed_ll
    return score  # hoge score -> waarschijnlijk AI-gegenereerd

def paraphrase_attack(watermarked_text: str, paraphraser) -> str:
    """Gebruik een afzonderlijk model om het watermerk via parafrasering te verwijderen."""
    prompt = f"""Rewrite the following text to convey the same meaning
using different words and sentence structures. Preserve all
factual content but change the phrasing completely.
 
Text: {watermarked_text}
 
Rewritten:"""
    return paraphraser.generate(prompt)

def synonym_substitution_attack(
    text: str,
    substitution_rate: float = 0.25,
    synonym_dict: dict = None,
) -> str:
    """Vervang ~25% van de inhoudswoorden door synoniemen."""
    words = text.split()
    for i, word in enumerate(words):
        if random.random() < substitution_rate and word.lower() in synonym_dict:
            words[i] = random.choice(synonym_dict[word.lower()])
    return " ".join(words)

ZERO_WIDTH_CHARS = ["​", "‌", "‍", ""]
 
def unicode_injection_attack(text: str, injection_rate: float = 0.15) -> str:
    """Voeg tekens met breedte nul in om het token-keten-watermerk te verstoren."""
    chars = list(text)
    positions = random.sample(range(len(chars)), int(len(chars) * injection_rate))
    for pos in sorted(positions, reverse=True):
        chars.insert(pos, random.choice(ZERO_WIDTH_CHARS))
    return "".join(chars)

def cross_model_transfer(watermarked_text: str, clean_model) -> str:
    """Draag inhoud over via een niet-gewatermerkt model."""
    prompt = f"""Based on the following information, write a comprehensive
response covering the same topics and conclusions:
 
{watermarked_text}"""
    return clean_model.generate(prompt)