Aanvallen op synthetische-datapipelines

Gevorderd7 min lezenBijgewerkt op 2026-03-13

Aanvallen op pipelines voor het genereren van synthetische data: modelinstorting door synthetische feedbackloops, vergiftiging van synthetische-datageneratoren, omzeiling van kwaliteitscontrole en aanvallen op dataherkomst.

synthetic-data model-collapse data-generation feedback-loop quality-control provenance

Synthetische data is nu een kritiek onderdeel van LLM-trainingspipelines. Modellen worden steeds vaker getraind op data die door andere modellen is gegenereerd -- voor instruction tuning, RLHF-voorkeursdata, evaluatiebenchmarks en domeinspecifieke corpusaugmentatie. Deze afhankelijkheid van synthetische data creëert een nieuw aanvalsoppervlak: compromitteer de datagenerator en je vergiftigt alles wat op zijn output wordt getraind.

De synthetische-datapipeline

┌─────────────┐    Prompts     ┌──────────────┐    Raw Data    ┌────────────┐
│ Prompt       │ ────────────▶ │ Generator    │ ────────────▶ │ Quality    │
│ Templates    │               │ Model (GPT-4,│               │ Filter     │
│              │               │ Claude, etc.)│               │            │
└─────────────┘               └──────────────┘               └─────┬──────┘
                                                                    │
                                                              Filtered Data
                                                                    │
                                                              ┌─────▼──────┐
                                                              │ Training   │
                                                              │ Pipeline   │
                                                              └────────────┘

Aanvalspunten

Aanvalspunt	Vereiste toegang	Impact
Prompt-templates	Toegang tot template-repository	Controle over de generatierichting
Generatormodel	API-toegang of modelgewichten	Onbeperkte vergiftigde data
Kwaliteitsfilter	Filtercode of -config	Adversariële voorbeelden doorlaten
Dataopslag	Toegang tot het opslagsysteem	Data wijzigen na generatie

Aanval 1: Modelinstorting via synthetische feedbackloops

Modelinstorting treedt op wanneer modellen recursief worden getraind op hun eigen (of andermans) synthetische outputs. Elke generatie vernauwt de outputdistributie enigszins, en na meerdere iteraties gaan zeldzame kennis en distributiestaarten verloren.

Het instortingsmechanisme

# Simulatie van modelinstorting over generaties
def simulate_model_collapse(base_model, generations=5, samples_per_gen=10000):
    """Demonstreer progressieve distributie-instorting."""
    current_model = base_model
    metrics = []
 
    for gen in range(generations):
        # Genereer synthetische data van het huidige model
        synthetic_data = [current_model.generate(random_prompt())
                         for _ in range(samples_per_gen)]
 
        # Meet distributie-eigenschappen
        vocab_diversity = len(set(word for text in synthetic_data
                                  for word in text.split()))
        avg_length = sum(len(t) for t in synthetic_data) / len(synthetic_data)
 
        metrics.append({
            "generation": gen,
            "vocab_diversity": vocab_diversity,
            "avg_length": avg_length,
        })
 
        # Train de volgende generatie op synthetische data
        current_model = fine_tune(current_model, synthetic_data)
        print(f"Gen {gen}: vocabulary diversity = {vocab_diversity}")
        # Diversiteit neemt elke generatie af
 
    return metrics

Voortgang van de instorting

Generatie	Vocabulairediversiteit	Zeldzame kennis	Veiligheidsdekking
0 (origineel)	Baseline (100%)	Volledig	Volledig
1	95%	90%	95%
2	85%	70%	85%
3	70%	40%	70%
5	45%	10%	45%

Modelinstorting als wapen inzetten

Een aanvaller kan de instorting versnellen door:

Homogene synthetische data injecteren -- Overspoel trainingspipelines met synthetische inhoud van lage diversiteit
Databronnen contamineren -- Plaats AI-gegenereerde inhoud op webbronnen die voor training worden gescrapet
Circulaire generatie -- Creëer feedbackloops tussen modellen die op elkaars outputs trainen

Aanval 2: Vergiftiging van het generatormodel

Als de aanvaller invloed kan uitoefenen op het model dat wordt gebruikt om synthetische data te genereren, wordt alle downstream-training vergiftigd:

# Vergiftigde synthetische-datagenerator
def poisoned_generator(prompt, base_model, poison_rate=0.05):
    """Genereer synthetische data met subtiele vergiftiging.
    95% van de outputs is schoon; 5% bevat adversariële patronen."""
    if random.random() < poison_rate:
        # Genereer subtiel bevooroordeelde reactie
        poisoned_prompt = inject_bias(prompt)
        response = base_model.generate(poisoned_prompt)
        # Nabewerking om duidelijke bias-markeringen te verwijderen
        response = sanitize_surface(response)
    else:
        response = base_model.generate(prompt)
    return response
 
# De vergiftigde reacties zijn afzonderlijk plausibel maar verschuiven
# collectief het gedrag van het getrainde model

Vergiftigingsvectoren

Vector	Methode	Detectiemoeilijkheid
Manipulatie van de systeemprompt	Wijzig de systeemprompt van de generator om biases in te bedden	Gemiddeld -- prompt is inspecteerbaar
Injectie van LoRA-adapter	Laad een vergiftigde adapter op de generator	Moeilijk -- adapter kan legitiem lijken
API-onderschepping	MITM op API-aanroepen van de generator	Moeilijk -- vereist API-audit
Manipulatie van temperatuur	Wijzig de sampling-temperatuur om diversiteit te verminderen	Makkelijk -- parameter is zichtbaar
Vergiftiging van few-shot-voorbeelden	Neem bevooroordeelde voorbeelden op in generatieprompts	Gemiddeld -- voorbeelden zijn inspecteerbaar

Aanval 3: Omzeiling van kwaliteitscontrole

Kwaliteitsfilters voor synthetische data zijn de laatste verdedigingslinie. Het omzeilen ervan laat adversariële inhoud de trainingspipeline binnenkomen:

# Adversariële voorbeelden ontworpen om kwaliteitsfilters te passeren
def craft_filter_evasive_sample(target_behavior, quality_filter):
    """Genereer synthetische voorbeelden die kwaliteitscontroles passeren
    terwijl ze adversariële patronen coderen."""
    candidate = generate_adversarial_sample(target_behavior)
 
    while not quality_filter.passes(candidate):
        # Wijzig iteratief om het filter te passeren
        candidate = paraphrase_preserve_semantics(candidate)
        candidate = adjust_perplexity(candidate, target_ppl=15.0)
        candidate = fix_formatting(candidate)
 
    return candidate  # Passeert kwaliteitsfilter, bevat adversarieel patroon

Veelvoorkomende kwaliteitsfilters en ontwijkingen

Filter	Wat het controleert	Ontwijking
Perplexiteitsfilter	Natuurlijkheid van de tekst	Parafraseer naar het beoogde perplexiteitsbereik
Deduplicatie	Exacte/bijna-duplicaten	Voeg kleine variaties toe aan elk voorbeeld
Lengtefilter	Grenzen van de reactielengte	Vul aan of kort in tot het beoogde bereik
Toxiciteitsclassifier	Expliciet schadelijke inhoud	Gebruik eufemismen en indirecte taal
Coherentie-scorer	Logische consistentie	Zorg voor oppervlakkige coherentie
LLM-as-judge	Algemene kwaliteitsbeoordeling	Optimaliseer voor de voorkeuren van het judge-model

Verdediging: Herkomst van synthetische data

Tracering van dataverloop

class SyntheticDataRecord:
    """Traceer de herkomst van elk synthetisch voorbeeld."""
    def __init__(self, content, generator_id, prompt, timestamp):
        self.content = content
        self.generator_id = generator_id       # Welk model dit heeft gegenereerd
        self.generator_version = get_version(generator_id)
        self.prompt = prompt                    # Gebruikte invoerprompt
        self.timestamp = timestamp
        self.hash = hashlib.sha256(content.encode()).hexdigest()
        self.quality_scores = {}                # Filterscores
        self.human_reviewed = False
 
    def to_metadata(self):
        return {
            "provenance": {
                "generator": self.generator_id,
                "version": self.generator_version,
                "timestamp": self.timestamp,
                "content_hash": self.hash,
            },
            "quality": self.quality_scores,
            "reviewed": self.human_reviewed,
        }

Contaminatiedetectie

N-gram-overlap -- Detecteer trainingsdata die verdacht overlapt met bekende modeloutputs
Stylometrische analyse -- Identificeer synthetische tekst aan de hand van statistische stijlsignaturen
Watermerkdetectie -- Controleer op ingebedde watermerken van bekende generatormodellen
Distributieanalyse -- Vergelijk de synthetische-datadistributie met bekende natuurlijke datadistributies

Gerelateerde onderwerpen

Geavanceerde aanvalsvectoren voor training -- Overzicht van geavanceerde trainingsaanvallen
Trainings- en fine-tuningaanvallen -- Standaard datavergiftiging
RAG-vergiftiging -- Data-aanvallen tijdens runtime
Watermerkverwijdering -- Generator-watermerken verwijderen

Knowledge Check

Waarom treft modelinstorting door synthetische-datafeedbackloops veiligheidsgedragingen onevenredig?

References

The Curse of Recursion: Training on Generated Data Makes Models Forget (Shumailov et al., 2023) -- Model collapse
Scaling Data-Constrained Language Models (Muennighoff et al., 2023) -- Data scaling and quality

Aanvallen op synthetische-datapipelines

Gevorderd7 min lezenBijgewerkt op 2026-03-13

synthetic-data model-collapse data-generation feedback-loop quality-control provenance

De synthetische-datapipeline

┌─────────────┐    Prompts     ┌──────────────┐    Raw Data    ┌────────────┐
│ Prompt       │ ────────────▶ │ Generator    │ ────────────▶ │ Quality    │
│ Templates    │               │ Model (GPT-4,│               │ Filter     │
│              │               │ Claude, etc.)│               │            │
└─────────────┘               └──────────────┘               └─────┬──────┘
                                                                    │
                                                              Filtered Data
                                                                    │
                                                              ┌─────▼──────┐
                                                              │ Training   │
                                                              │ Pipeline   │
                                                              └────────────┘

Aanvalspunten

Aanvalspunt	Vereiste toegang	Impact
Prompt-templates	Toegang tot template-repository	Controle over de generatierichting
Generatormodel	API-toegang of modelgewichten	Onbeperkte vergiftigde data
Kwaliteitsfilter	Filtercode of -config	Adversariële voorbeelden doorlaten
Dataopslag	Toegang tot het opslagsysteem	Data wijzigen na generatie

Aanval 1: Modelinstorting via synthetische feedbackloops

Het instortingsmechanisme

# Simulatie van modelinstorting over generaties
def simulate_model_collapse(base_model, generations=5, samples_per_gen=10000):
    """Demonstreer progressieve distributie-instorting."""
    current_model = base_model
    metrics = []
 
    for gen in range(generations):
        # Genereer synthetische data van het huidige model
        synthetic_data = [current_model.generate(random_prompt())
                         for _ in range(samples_per_gen)]
 
        # Meet distributie-eigenschappen
        vocab_diversity = len(set(word for text in synthetic_data
                                  for word in text.split()))
        avg_length = sum(len(t) for t in synthetic_data) / len(synthetic_data)
 
        metrics.append({
            "generation": gen,
            "vocab_diversity": vocab_diversity,
            "avg_length": avg_length,
        })
 
        # Train de volgende generatie op synthetische data
        current_model = fine_tune(current_model, synthetic_data)
        print(f"Gen {gen}: vocabulary diversity = {vocab_diversity}")
        # Diversiteit neemt elke generatie af
 
    return metrics

Voortgang van de instorting

Generatie	Vocabulairediversiteit	Zeldzame kennis	Veiligheidsdekking
0 (origineel)	Baseline (100%)	Volledig	Volledig
1	95%	90%	95%
2	85%	70%	85%
3	70%	40%	70%
5	45%	10%	45%

Modelinstorting als wapen inzetten

Een aanvaller kan de instorting versnellen door:

Homogene synthetische data injecteren -- Overspoel trainingspipelines met synthetische inhoud van lage diversiteit
Databronnen contamineren -- Plaats AI-gegenereerde inhoud op webbronnen die voor training worden gescrapet
Circulaire generatie -- Creëer feedbackloops tussen modellen die op elkaars outputs trainen

Aanval 2: Vergiftiging van het generatormodel

Als de aanvaller invloed kan uitoefenen op het model dat wordt gebruikt om synthetische data te genereren, wordt alle downstream-training vergiftigd:

# Vergiftigde synthetische-datagenerator
def poisoned_generator(prompt, base_model, poison_rate=0.05):
    """Genereer synthetische data met subtiele vergiftiging.
    95% van de outputs is schoon; 5% bevat adversariële patronen."""
    if random.random() < poison_rate:
        # Genereer subtiel bevooroordeelde reactie
        poisoned_prompt = inject_bias(prompt)
        response = base_model.generate(poisoned_prompt)
        # Nabewerking om duidelijke bias-markeringen te verwijderen
        response = sanitize_surface(response)
    else:
        response = base_model.generate(prompt)
    return response
 
# De vergiftigde reacties zijn afzonderlijk plausibel maar verschuiven
# collectief het gedrag van het getrainde model

Vergiftigingsvectoren

Vector	Methode	Detectiemoeilijkheid
Manipulatie van de systeemprompt	Wijzig de systeemprompt van de generator om biases in te bedden	Gemiddeld -- prompt is inspecteerbaar
Injectie van LoRA-adapter	Laad een vergiftigde adapter op de generator	Moeilijk -- adapter kan legitiem lijken
API-onderschepping	MITM op API-aanroepen van de generator	Moeilijk -- vereist API-audit
Manipulatie van temperatuur	Wijzig de sampling-temperatuur om diversiteit te verminderen	Makkelijk -- parameter is zichtbaar
Vergiftiging van few-shot-voorbeelden	Neem bevooroordeelde voorbeelden op in generatieprompts	Gemiddeld -- voorbeelden zijn inspecteerbaar

Aanval 3: Omzeiling van kwaliteitscontrole

Kwaliteitsfilters voor synthetische data zijn de laatste verdedigingslinie. Het omzeilen ervan laat adversariële inhoud de trainingspipeline binnenkomen:

# Adversariële voorbeelden ontworpen om kwaliteitsfilters te passeren
def craft_filter_evasive_sample(target_behavior, quality_filter):
    """Genereer synthetische voorbeelden die kwaliteitscontroles passeren
    terwijl ze adversariële patronen coderen."""
    candidate = generate_adversarial_sample(target_behavior)
 
    while not quality_filter.passes(candidate):
        # Wijzig iteratief om het filter te passeren
        candidate = paraphrase_preserve_semantics(candidate)
        candidate = adjust_perplexity(candidate, target_ppl=15.0)
        candidate = fix_formatting(candidate)
 
    return candidate  # Passeert kwaliteitsfilter, bevat adversarieel patroon

Veelvoorkomende kwaliteitsfilters en ontwijkingen

Filter	Wat het controleert	Ontwijking
Perplexiteitsfilter	Natuurlijkheid van de tekst	Parafraseer naar het beoogde perplexiteitsbereik
Deduplicatie	Exacte/bijna-duplicaten	Voeg kleine variaties toe aan elk voorbeeld
Lengtefilter	Grenzen van de reactielengte	Vul aan of kort in tot het beoogde bereik
Toxiciteitsclassifier	Expliciet schadelijke inhoud	Gebruik eufemismen en indirecte taal
Coherentie-scorer	Logische consistentie	Zorg voor oppervlakkige coherentie
LLM-as-judge	Algemene kwaliteitsbeoordeling	Optimaliseer voor de voorkeuren van het judge-model

Verdediging: Herkomst van synthetische data

Tracering van dataverloop

class SyntheticDataRecord:
    """Traceer de herkomst van elk synthetisch voorbeeld."""
    def __init__(self, content, generator_id, prompt, timestamp):
        self.content = content
        self.generator_id = generator_id       # Welk model dit heeft gegenereerd
        self.generator_version = get_version(generator_id)
        self.prompt = prompt                    # Gebruikte invoerprompt
        self.timestamp = timestamp
        self.hash = hashlib.sha256(content.encode()).hexdigest()
        self.quality_scores = {}                # Filterscores
        self.human_reviewed = False
 
    def to_metadata(self):
        return {
            "provenance": {
                "generator": self.generator_id,
                "version": self.generator_version,
                "timestamp": self.timestamp,
                "content_hash": self.hash,
            },
            "quality": self.quality_scores,
            "reviewed": self.human_reviewed,
        }

Contaminatiedetectie

N-gram-overlap -- Detecteer trainingsdata die verdacht overlapt met bekende modeloutputs
Stylometrische analyse -- Identificeer synthetische tekst aan de hand van statistische stijlsignaturen
Watermerkdetectie -- Controleer op ingebedde watermerken van bekende generatormodellen
Distributieanalyse -- Vergelijk de synthetische-datadistributie met bekende natuurlijke datadistributies

Gerelateerde onderwerpen

Geavanceerde aanvalsvectoren voor training -- Overzicht van geavanceerde trainingsaanvallen
Trainings- en fine-tuningaanvallen -- Standaard datavergiftiging
RAG-vergiftiging -- Data-aanvallen tijdens runtime
Watermerkverwijdering -- Generator-watermerken verwijderen

Knowledge Check

Waarom treft modelinstorting door synthetische-datafeedbackloops veiligheidsgedragingen onevenredig?

References

The Curse of Recursion: Training on Generated Data Makes Models Forget (Shumailov et al., 2023) -- Model collapse
Scaling Data-Constrained Language Models (Muennighoff et al., 2023) -- Data scaling and quality

Aanvallen op synthetische-datapipelines

Gerelateerde artikelen

Aanvallen op synthetische-datapipelines

Gerelateerde artikelen