Aanvallen op machine unlearning
Het uitbuiten van machine unlearning-processen: het herstellen van zogenaamd vergeten data, aanvallen op unlearning-verificatie, uitbuiting van gedeeltelijke unlearning, en de fundamentele grenzen van vergeten in neurale netwerken.
Machine unlearning -- het proces van het verwijderen van de invloed van specifieke trainingsdata uit een getraind model -- is een regelgevende noodzaak geworden. Het recht op gegevenswissing van de EU-AVG, de Californische CCPA en vergelijkbare privacyregelgeving verplichten organisaties om gebruikersgegevens op verzoek te verwijderen. Voor AI-systemen betekent verwijdering niet alleen het verwijderen van data uit opslag, maar ook het verwijderen van de invloed ervan uit de modelgewichten. Dit proces is het aanvalsoppervlak.
Hoe unlearning werkt
Exacte unlearning
De gouden standaard: train het model vanaf nul opnieuw zonder de te vergeten data. Dit garandeert volledige verwijdering, maar is onpraktisch voor grote modellen.
Cost of exact unlearning:
- GPT-4 class model: ~$100M+ per retraining run
- Time: weeks to months
- Frequency: potentially thousands of deletion requests per day
- Verdict: economically impossible for individual deletion requestsMethoden voor benaderende unlearning
| Methode | Mechanisme | Snelheid | Volledigheid |
|---|---|---|---|
| Gradient ascent | Verhoog de loss op vergeten data | Snel | Gedeeltelijk -- laat residu achter |
| Fisher forgetting | Gebruik Fisher-informatie om relevante gewichten selectief te wijzigen | Matig | Beter dan gradient ascent |
| SISA training | Train op datashards; train alleen de getroffen shard opnieuw | Matig | Goed (binnen de shard) |
| Knowledge distillation | Distilleer het model in een nieuw model zonder de vergeten kennis | Langzaam | Goed maar imperfect |
| Benadering van influence functions | Schat en verwijder de invloed van specifieke voorbeelden | Snel | Benaderend |
import torch
import torch.nn.functional as F
def gradient_ascent_unlearn(
model: torch.nn.Module,
forget_dataloader,
learning_rate: float = 1e-5,
epochs: int = 5
):
"""Benaderende unlearning via gradient ascent op de te vergeten data."""
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
for epoch in range(epochs):
for batch in forget_dataloader:
inputs, targets = batch
outputs = model(inputs)
loss = F.cross_entropy(outputs, targets)
# Gradient ASCENT -- maximaliseer de loss op vergeten data
# Dit duwt het model weg van correcte voorspellingen
# op de vergeten voorbeelden
(-loss).backward()
optimizer.step()
optimizer.zero_grad()
return modelAanval 1: Dataherstel na unlearning
De primaire aanval tegen unlearning: bepalen of data die zogenaamd is vergeten, nog steeds uit het model kan worden geëxtraheerd of afgeleid.
Membership inference tegen un-gelearnde modellen
Membership inference-aanvallen kunnen verifiëren of unlearning de invloed van een datapunt daadwerkelijk heeft verwijderd.
def membership_inference_post_unlearn(
model,
forgotten_samples: list,
retained_samples: list,
non_member_samples: list
):
"""Test of unlearning de data-invloed daadwerkelijk heeft verwijderd."""
results = {"forgotten": [], "retained": [], "non_member": []}
for category, samples in [
("forgotten", forgotten_samples),
("retained", retained_samples),
("non_member", non_member_samples)
]:
for sample in samples:
output = model(sample["input"])
loss = F.cross_entropy(output, sample["target"])
confidence = torch.softmax(output, dim=-1).max().item()
results[category].append({
"loss": loss.item(),
"confidence": confidence,
"top_prediction": output.argmax().item()
})
# Analyse: vergeten voorbeelden zouden zich als non-members moeten gedragen
forgotten_losses = [r["loss"] for r in results["forgotten"]]
non_member_losses = [r["loss"] for r in results["non_member"]]
retained_losses = [r["loss"] for r in results["retained"]]
avg_forgotten = sum(forgotten_losses) / len(forgotten_losses)
avg_non_member = sum(non_member_losses) / len(non_member_losses)
avg_retained = sum(retained_losses) / len(retained_losses)
return {
"avg_loss_forgotten": avg_forgotten,
"avg_loss_non_member": avg_non_member,
"avg_loss_retained": avg_retained,
"unlearning_effective": abs(avg_forgotten - avg_non_member) < abs(avg_retained - avg_non_member) * 0.1,
"residual_signal": avg_forgotten < avg_non_member # Lagere loss = model herinnert zich nog
}Als het gedrag van het model op vergeten voorbeelden te onderscheiden is van zijn gedrag op echte non-members, is de unlearning onvolledig.
Extractieaanvallen op resterende informatie
Zelfs wanneer membership inference suggereert dat unlearning effectief was, kan gerichte extractie gedeeltelijke informatie herstellen.
def extract_residual_information(
unlearned_model,
original_model,
probe_prompts: list
):
"""Probeer resterende informatie uit een un-gelearnd model te extraheren."""
residuals = []
for prompt in probe_prompts:
# Genereer vanuit beide modellen
unlearned_output = unlearned_model.generate(prompt, temperature=0.0)
original_output = original_model.generate(prompt, temperature=0.0)
# Vergelijk outputs -- overeenkomsten wijzen op resterende kennis
# Gebruik verschillende gelijkenismetrieken
overlap = _compute_token_overlap(unlearned_output, original_output)
residuals.append({
"prompt": prompt,
"unlearned_response": unlearned_output,
"original_response": original_output,
"token_overlap": overlap,
"residual_detected": overlap > 0.3
})
return residualsAanval 2: Uitbuiting van bijwerkingen van unlearning
Unlearning wijzigt modelgewichten, en deze wijzigingen kunnen onbedoelde bijwerkingen hebben die aanvallers uitbuiten.
Uitbuiting van capaciteitsdegradatie
Benaderende unlearning degradeert vaak de modelprestaties op taken die verband houden met de vergeten data. Een aanvaller kan deze degradatiepatronen observeren om af te leiden wat er is vergeten.
def detect_unlearning_fingerprint(
model_before_unlearning,
model_after_unlearning,
test_tasks: list
):
"""Detecteer wat er is un-gelearnd door capaciteitsveranderingen te observeren."""
fingerprint = []
for task in test_tasks:
score_before = evaluate_task(model_before_unlearning, task)
score_after = evaluate_task(model_after_unlearning, task)
degradation = score_before - score_after
fingerprint.append({
"task": task["name"],
"domain": task["domain"],
"score_before": score_before,
"score_after": score_after,
"degradation": degradation,
"likely_related_to_forgotten_data": degradation > 0.1
})
# Taken met significante degradatie houden waarschijnlijk verband met vergeten data
affected_domains = [
f["domain"] for f in fingerprint
if f["likely_related_to_forgotten_data"]
]
return {
"fingerprint": fingerprint,
"affected_domains": affected_domains,
"inference": f"Forgotten data likely related to: {', '.join(set(affected_domains))}"
}Analyse van modelverschillen
Als een aanvaller toegang heeft tot modelgewichten van vóór en na de unlearning (bijv. bij open-weight-modellen met geversioneerde releases), onthullen de gewichtsverschillen rechtstreeks welke neuronen en lagen zijn gewijzigd, wat informatie geeft over de vergeten data.
def analyze_weight_diff(
model_before: dict,
model_after: dict,
top_k: int = 100
):
"""Analyseer gewichtsverschillen om unlearning-doelen af te leiden."""
diffs = {}
for layer_name in model_before:
if layer_name in model_after:
diff = torch.abs(model_before[layer_name] - model_after[layer_name])
diffs[layer_name] = {
"mean_diff": diff.mean().item(),
"max_diff": diff.max().item(),
"num_modified": (diff > 1e-6).sum().item(),
"total_params": diff.numel()
}
# Sorteer lagen op modificatie-intensiteit
sorted_layers = sorted(
diffs.items(),
key=lambda x: x[1]["mean_diff"],
reverse=True
)
return sorted_layers[:top_k]Aanval 3: Uitbuiting van unlearning-verificatie
Organisaties moeten verifiëren dat unlearning succesvol was. Het verificatieproces zelf kan worden aangevallen.
Adversariële verificatie
Als de entiteit die de unlearning uitvoert het verificatieproces beheerst, kan deze verificatietests ontwerpen die hun unlearning-methode doorstaat, terwijl er aanzienlijke resterende informatie achterblijft.
| Verificatiemethode | Wat het test | Wat het mist |
|---|---|---|
| Outputvergelijking | Of het model dezelfde output produceert als voorheen | Latente kennis die specifieke prompts vereist |
| Membership inference | Of de loss/betrouwbaarheid van het model verschilt voor vergeten data | Gecodeerde informatie in tussenliggende representaties |
| Canary-extractie | Of geplante canary-strings kunnen worden geëxtraheerd | Informatie opgeslagen in impliciete associaties |
| Benchmarkevaluatie | Of de modelprestaties op standaardtaken zijn veranderd | Degradatie van domeinspecifieke kennis |
Verificatie door derden
Robuuste unlearning-verificatie vereist onafhankelijke tests door derden met toegang tot zowel de vergeten data als het un-gelearnde model.
class UnlearningVerifier:
"""Onafhankelijke verificatie van de volledigheid van machine unlearning."""
def __init__(self, forgotten_data, model, reference_non_member_data):
self.forgotten_data = forgotten_data
self.model = model
self.non_member_data = reference_non_member_data
def full_verification(self) -> dict:
"""Draai uitgebreide verificatiesuite voor unlearning."""
results = {}
# Test 1: Membership inference
results["membership_inference"] = self._test_membership_inference()
# Test 2: Pogingen tot data-extractie
results["extraction"] = self._test_extraction()
# Test 3: Gedragsconsistentie met opnieuw getraind model
results["behavioral"] = self._test_behavioral_consistency()
# Test 4: Representatieanalyse
results["representation"] = self._test_representation_residuals()
# Algeheel oordeel
all_passed = all(r.get("passed", False) for r in results.values())
results["verdict"] = "PASS" if all_passed else "FAIL"
return results
def _test_membership_inference(self):
# Vergelijk modelgedrag op vergeten versus non-member data
pass
def _test_extraction(self):
# Probeer vergeten data te extraheren via prompting
pass
def _test_behavioral_consistency(self):
# Vergelijk gedrag met een model dat opnieuw is getraind zonder vergeten data
pass
def _test_representation_residuals(self):
# Controleer tussenliggende representaties op signaturen van vergeten data
passAanval 4: Strategische unlearning-verzoeken
Een aanvaller die strategisch unlearning-verzoeken kan indienen, kan modelcapaciteiten op gerichte manieren degraderen.
Gerichte capaciteitsdegradatie
Door verwijdering van zorgvuldig geselecteerde datapunten te verzoeken, kan een aanvaller onevenredig capaciteitsverlies in specifieke domeinen veroorzaken. Als de kennis van het model over een onderwerp berust op een klein aantal trainingsvoorbeelden met grote invloed, vernietigt het verwijderen van die voorbeelden de capaciteit.
Veiligheids-unlearning
Een aanvaller kan verzoeken om verwijdering van data die bijdraagt aan de veiligheidstraining van het model. Als veiligheidsgedragingen afhankelijk zijn van specifieke trainingsvoorbeelden, kan het un-learnen van die voorbeelden de veiligheids-guardrails verzwakken.
Verdedigingen tegen unlearning-aanvallen
Voor modelaanbieders
-
Gebruik SISA training: Verdeel de trainingsdata in shards. Unlearning vereist alleen het opnieuw trainen van de getroffen shard, waardoor exacte unlearning haalbaar wordt voor redelijke shardgroottes.
-
Differential privacy: Trainen met differential privacy beperkt de invloed van elk individueel datapunt, waardoor unlearning minder impactvol en resterende informatie minder uitbuitbaar wordt.
-
Onafhankelijke verificatie: Schakel externe auditors in om de volledigheid van unlearning te verifiëren met gestandaardiseerde testsuites.
-
Rate limiting van unlearning-verzoeken: Monitor op patronen van strategische unlearning-verzoeken die zijn ontworpen om specifieke capaciteiten te degraderen.
Voor red teamers
Identificeer unlearning-claims
Bepaal of het doelsysteem beweert dataverwijdering of unlearning te ondersteunen. Controleer privacybeleid en documentatie over naleving van regelgeving.
Test baseline membership inference
Stel vóór enige unlearning de nauwkeurigheid van membership inference tegen het model vast. Dit biedt een baseline ter vergelijking.
Verzoek unlearning en verifieer
Dien legitieme unlearning-verzoeken in en test vervolgens of de invloed van de data volledig is verwijderd met membership inference, extractiepogingen en gedragsanalyse.
Test op bijwerkingen
Evalueer of unlearning-verzoeken capaciteitsdegradatie, verzwakking van de veiligheid of andere onbedoelde bijwerkingen veroorzaken.
Beoordeel de robuustheid van de verificatie
Evalueer of het unlearning-verificatieproces van de aanbieder rigoureus genoeg is om onvolledige unlearning op te vangen.
Samenvatting
Machine unlearning is een regelgevende vereiste die een nieuw aanvalsoppervlak creëert. Benaderende unlearning-methoden laten resterende informatie achter die kan worden hersteld via membership inference, extractieaanvallen en analyse van gewichtsverschillen. Het unlearning-proces zelf kan worden uitgebuit -- via strategische verwijderingsverzoeken die capaciteiten degraderen of de veiligheid verzwakken. Effectieve verdediging vereist een verschuiving naar exacte unlearning-methoden (zoals SISA training), differential privacy en onafhankelijke verificatie door derden. De fundamentele spanning tussen het recht om vergeten te worden en modelintegriteit blijft een open uitdaging.