# Machine unlearning: data wissen uit netwerkgewichten

[Naar de inhoud](#lm-inhoud)Netwerk/NL[EN](/en/)[Hubhub.llmnet.nlModellen vergelijken op taak, taal, kosten en licentie.](https://hub.llmnet.nl/)[Communitycommunity.llmnet.nlPrompttechnieken, patronen en systeemprompts.](https://community.llmnet.nl/)[APIapi.llmnet.nlLLM's robuust in software: rate limits, routing, structured output.](https://api.llmnet.nl/)[Consultancyconsultancy.llmnet.nlAI invoeren in een organisatie, van pilot tot productie.](https://consultancy.llmnet.nl/)[Nieuwsnieuws.llmnet.nlOntwikkelingen in AI, geduid voor Nederland.](https://nieuws.llmnet.nl/)[Benchmarkbenchmark.llmnet.nlZelf meten wat AI-kwaliteit is, voor jouw taken.](https://benchmark.llmnet.nl/)[Vacaturesvacatures.llmnet.nlAI-rollen, salarissen en carrièrepaden in Nederland.](https://vacatures.llmnet.nl/)[Lerenleren.llmnet.nlAI-concepten in gewoon Nederlands, van beginner tot bouwer.](https://leren.llmnet.nl/)[Gidsgids.llmnet.nlAI privé draaien op eigen Mac, pc, NAS of thuisserver.](https://gids.llmnet.nl/)[Directorydirectory.llmnet.nlHet AI-ecosysteem in kaart: tools, modellen, bedrijven.](https://directory.llmnet.nl/)[Radarradar.llmnet.nlSignalen uit X, onderzoek en communities voor indie developers.](https://radar.llmnet.nl/)[Appsapps.llmnet.nlReviews van AI-apps en open-source repo's, met tips voor wie zelf bouwt.](https://apps.llmnet.nl/)[llmnet.nl — hoofdsite](https://llmnet.nl/)[](https://x.com/intent/post?url=https%3A%2F%2Fleren.llmnet.nl%2Fmachine-unlearning-data-wissen-uit-getrainde-netwerkgewichten&text=Machine%20unlearning%3A%20data%20wissen%20uit%20netwerkgewichten)[](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fleren.llmnet.nl%2Fmachine-unlearning-data-wissen-uit-getrainde-netwerkgewichten)[](https://www.reddit.com/submit?url=https%3A%2F%2Fleren.llmnet.nl%2Fmachine-unlearning-data-wissen-uit-getrainde-netwerkgewichten&title=Machine%20unlearning%3A%20data%20wissen%20uit%20netwerkgewichten)[](#)[](https://x.com/intent/post?url=https%3A%2F%2Fleren.llmnet.nl%2Fmachine-unlearning-data-wissen-uit-getrainde-netwerkgewichten&text=Machine%20unlearning%3A%20data%20wissen%20uit%20netwerkgewichten)[](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fleren.llmnet.nl%2Fmachine-unlearning-data-wissen-uit-getrainde-netwerkgewichten)[](https://www.reddit.com/submit?url=https%3A%2F%2Fleren.llmnet.nl%2Fmachine-unlearning-data-wissen-uit-getrainde-netwerkgewichten&title=Machine%20unlearning%3A%20data%20wissen%20uit%20netwerkgewichten)[](#)

 
# Machine unlearning: data wissen uit getrainde netwerkgewichten

 Door Ivo Donker — samengesteld met AI-ondersteuning (Claude & Gemini) · 20 augustus 2026

 
 
### Wat je hiervoor moet weten

 Dit artikel valt binnen Module 4 — Trainen & afstemmen van de leerlijn. Om de wiskundige ingrepen in gewichtsmatrices te begrijpen, helpt een stevige basiskennis van modelarchitecturen. Lees vooraf de uitleg over [parameters en gewichten in AI-modellen](https://leren.llmnet.nl/parameters-en-gewichten) om te zien hoe numerieke representaties worden opgeslagen. Daarnaast is inzicht in [catastrofaal vergeten bij het finetunen van LLM's](https://leren.llmnet.nl/catastrofisch-vergeten-voorkomen) essentieel, omdat unlearning in essentie een gecontroleerde, selectieve vorm van vergeten is.

 

 Wanneer een neuraal netwerk eenmaal getraind is op miljarden tokens, zitten feiten, namen, programmeercode en tekstfragmenten diffuus verspreid over miljarden drijvende-kommagetallen. Als achteraf blijkt dat een trainingscorpus persoonsgegevens bevatte, auteursrechtelijk beschermde werken insloot of gevaarlijke synthesestappen voor chemische stoffen beschreef, ontstaat een complex probleem. Het traditionele antwoord van databasebeheerders — een simpele DELETE-instructie — bestaat niet binnen een neuraal netwerk. Een taalmodel slaat data immers niet op in rijen en kolommen, maar codeert correlaties in de niet-lineaire interactie tussen modelparameters.

 Hertrainen vanaf nul (retraining from scratch) is de enige methode die absolute wiskundige garanties biedt dat data verdwenen is, maar bij modellen met tientallen of honderden miljarden parameters kost een volledige trainingscyclus miljoenen euro's aan rekenkracht en weken rekentijd. Machine unlearning is het vakgebied dat algoritmes ontwikkelt om specifieke concepten, trainingsvoorbeelden of domeinen chirurgisch uit de netwerkgewichten te verwijderen, zónder dat de algemene taalvaardigheid, logische coherentie en overige kennis van het model instorten.

 
## Het fundamentele probleem: gedistribueerde representaties

 In een relationele database is data gelokaliseerd. Verwijder je rij 402 uit tabel gebruikers, dan zijn de bijbehorende bytes fysiek overschreven of losgekoppeld van de index. In een transformer-model worden gegevens echter opgeslagen via gedistribueerde representaties. Eén enkel trainingsfeit — bijvoorbeeld de geboortedatum en medische geschiedenis van een specifieke patiënt uit een medisch dossier — beïnvloedt tijdens de backpropagation-stap tienduizenden gewichtsmatrices gelijktijdig.

 Tegelijkertijd zijn diezelfde gewichten verantwoordelijk voor algemene syntaxis, grammaticale vervoegingen en feitenkennis over verwante medische concepten. Als we simpelweg de neuronen uitschakelen die vuren bij het zien van de naam van deze patiënt, ontstaat er structurele nevenschade aan de omliggende representatieruimte. Het doel van machine unlearning is het vinden van een gewichtsvector $\theta_{\text{unlearn}}$ die statistisch niet te onderscheiden is van een gewichtsvector $\theta_{\text{retrain}}$, waarbij $\theta_{\text{retrain}}$ verkregen zou zijn door het model volledig opnieuw te trainen op de dataset zónder de te vergeten subset.

 
## Formulering van de unlearning-taak

 Laten we de wiskundige taak formeel definiëren. We beschikken over een volledige trainingsdataset $\mathcal{D}$, die we opdelen in twee disjuncte verzamelingen:
 $$\mathcal{D} = \mathcal{D}_{\text{retain}} \cup \mathcal{D}_{\text{forget}}$$
 Hierbij is $\mathcal{D}_{\text{forget}}$ de data die gewist moet worden (de forget set) en is $\mathcal{D}_{\text{retain}}$ de data die het model foutloos moet behouden (de retain set).

 Zij $\mathcal{M}(\theta)$ het model getraind op $\mathcal{D}$. We zoeken een update-algoritme $\mathcal{U}$ dat opereert op $\theta$, $\mathcal{D}_{\text{forget}}$ en optioneel een fractie van $\mathcal{D}_{\text{retain}}$, zodanig dat voor elke testfunctie of aanvalsmethode $A$ geldt:
 $$P(A(\mathcal{U}(\theta, \mathcal{D}_{\text{forget}}, \mathcal{D}_{\text{retain}})) = 1) \approx P(A(\mathcal{M}(\theta_{\text{retrain}})) = 1)$$
 In de praktijk maken we onderscheid tussen twee hoofdcategorieën: exacte unlearning (met harde theoretische garanties) en benaderende unlearning (heuristieken geoptimaliseerd voor deep learning schaal).

 
## Exacte unlearning via datapartitionering: SISA

 De meest intuïtieve methode om exacte garanties te bieden zonder volledige hertraining is het SISA-framework (Sharded, Isolated, Sliced, Aggregated). In plaats van één groot model te trainen op de volledige dataset $\mathcal{D}$, deelt SISA de data op in $S$ disjuncte shards: $\mathcal{D}_1, \mathcal{D}_2, \dots, \mathcal{D}_S$.

 Elke shard traint een afzonderlijk submodel. Binnen elke shard wordt de data verder opgedeeld in sequentiële slices. Tijdens de training slaat het systeem na elke slice een checkpoint van de modelparameters op. Komt er een verzoek binnen om een datapunt uit $\mathcal{D}_{\text{forget}}$ te verwijderen, dan hoeft alleen het specifieke submodel waarin dit datapunt zat opnieuw getraind te worden, en wel vanaf het checkpoint van de slice net vóórdat het gewiste datapunt werd aangeboden.

 
 
 
 
 Eigenschap | 
 SISA (Exact) | 
 Gradient Ascent (Benaderend) | 
 Gewichtslokalisatie & Editing | 
 

 
 
 
 Garantie | 
 Exact wiskundig (100% bewijsbaar) | 
 Empirisch / Statistisch | 
 Lokaal specifiek (geen formele garantie) | 
 

 
 Rekencomplexiteit | 
 Hoog bij frequente unlearning | 
 Laag (enkele optimalisatiestappen) | 
 Zeer laag (directe matrix-inversie) | 
 

 
 Schaalbaarheid naar LLM's | 
 Zeer slecht (vereist tientallen sub-LLM's) | 
 Uitstekend (werkt direct op bestaande weights) | 
 Goed voor feiten, slecht voor stijl/concepten | 
 

 
 Opslagbehoefte | 
 Enorm (meerdere parameter-checkpoints) | 
 Minimaal (geen extra opslag) | 
 Minimaal | 
 

 
 
 

 Hoewel SISA uitstekend werkt voor traditionele machine learning en kleinschalige neurale netwerken, loopt de methode vast bij moderne taalmodellen. Het trainen van 20 afzonderlijke 70B-parameter LLM's op dataschards en het combineren van hun logits via ensembling levert een onwerkbare latentie en onbetaalbare infrastructuurkosten op tijdens inference.

 
## Benaderende unlearning: Gradient Ascent en Regularisatie

 Voor grootschalige transformermodellen richten onderzoekers zich op benaderende optimalisatiemethoden. De meest directe route is Gradient Ascent (gradiëntstijging) op de forget set. Waar standaard training het verlies (de cross-entropy loss) minimaliseert, maximaliseert gradient ascent het verlies op de data die vergeten moet worden:

 $$\theta_{t+1} = \theta_t + \eta \nabla_\theta \mathcal{L}(\theta_t; \mathcal{D}_{\text{forget}})$$

 Puur gradiëntstijging toepassen leidt echter binnen enkele optimalisatiestappen tot een fenomeen dat vergelijkbaar is met een lobotomie: de gewichtsvectoren worden dermate verstoord dat het model complete wartaal begint te genereren en instort op basisvaardigheden. Om dit te voorkomen, wordt gradient ascent gecombineerd met een behoudsterm op de retain set en een divergentie-boete ten opzichte van het oorspronkelijke model $\theta_0$:

 # Pseudocode: Gecombineerde Unlearning Loss-functie
import torch
import torch.nn.functional as F

def compute_unlearning_loss(model, ref_model, batch_forget, batch_retain, alpha=1.0, beta=0.5):
 # 1. Maximaliseer verlies op de data die vergeten moet worden
 outputs_forget = model(batch_forget['input_ids'], labels=batch_forget['labels'])
 loss_forget = -outputs_forget.loss # Gradiëntstijging via negatie
 
 # 2. Behoud prestaties op de retain set (reguliere cross-entropy)
 outputs_retain = model(batch_retain['input_ids'], labels=batch_retain['labels'])
 loss_retain = outputs_retain.loss
 
 # 3. KL-divergentie om representatiedrift t.o.v. het basismodel te beperken
 with torch.no_grad():
 ref_logits = ref_model(batch_retain['input_ids']).logits
 current_logits = outputs_retain.logits
 
 kl_loss = F.kl_div(
 F.log_softmax(current_logits, dim=-1),
 F.softmax(ref_logits, dim=-1),
 reduction='batchmean'
 )
 
 # Totale gewogen doelfunctie
 total_loss = alpha * loss_forget + loss_retain + beta * kl_loss
 return total_loss

 In plaats van brute gradient ascent kan men ook parameters efficiënt bijstellen met behulp van low-rank adapters. Wie wil zien hoe dergelijke adapters met minimale rekenkracht specifieke gewichtsupdates isoleren, kan de uitleg over [LoRA en adapters bij LLM-training](https://leren.llmnet.nl/lora-en-adapters-uitgelegd) raadplegen om te begrijpen hoe matrices laag-bij-laag worden gemanipuleerd zonder het basismodel integraal te overschrijven.

 
## Wiskundige lokalisatie via de Fisher-informatiematrix

 Een elegantere benadering maakt gebruik van tweede-orde afgeleiden om exact te identificeren wélke individuele gewichten cruciaal zijn voor de retain-dataset en welke primair coderen voor de forget-dataset. Dit gebeurt via de Fisher Information Matrix (FIM).

 De FIM meet hoeveel informatie een willekeurige parameter $\theta_i$ levert over de outputverdeling van het model:

 $$F = \mathbb{E}_{x \sim \mathcal{D}} \left[ \nabla_\theta \log p(x|\theta) \nabla_\theta \log p(x|\theta)^T \right]$$

 Door de diagonale benadering van de Fisher-matrix te berekenen over zowel $\mathcal{D}_{\text{retain}}$ ($F_{\text{retain}}$) als $\mathcal{D}_{\text{forget}}$ ($F_{\text{forget}}$), kunnen we een gerichte storing toevoegen aan parameters die een hoge waarde hebben in $F_{\text{forget}}$ maar een verwaarloosbare waarde in $F_{\text{retain}}$. Hiermee worden de doelgewichten selectief teruggezet naar een willekeurige toestand of verschoven langs de gradiënt van minimale invloed op de overige kennis.

 
## Directe modelbewerking: ROME en MEMIT

 Wanneer de unlearning-taak bestaat uit het wissen van specifieke feitelijke uitspraken (bijvoorbeeld: "Persoon X woont op Adres Y"), biedt model editing een alternatief voor optimalisatielussen. Technieken zoals ROME (Rank-One Model Editing) en MEMIT (Mass-Editing Memory in a Transformer) behandelen de Feed-Forward Networks (FFN) binnen transformer-lagen als expliciete sleutel-waarde-geheugens (key-value stores).

 In een FFN-laag fungeert de eerste lineaire projectie $W_{\text{in}}$ als sleuteldetector (herkent het subject, bijv. "Ivo Donker"), terwijl de tweede projectie $W_{\text{out}}$ de bijbehorende waardevector ophaalt (de eigenschap of het attribuut). ROME lokaliseert eerst via causale mediatie-analyse welke specifieke lagen verantwoordelijk zijn voor het opslaan van het feit. Vervolgens berekent het algoritme via een rank-1 update een directe correctie op $W_{\text{out}}$:

 $$\hat{W} = W + \Lambda (C^{-1} k)^T$$
 Hierin is $k$ de sleutelvector van het te wissen concept, $C$ de covariantie-matrix van eerdere activaties, en $\Lambda$ een correctievector die ervoor zorgt dat de projectie van $k$ resulteert in een neutrale vector of een uniforme outputverdeling. Het voordeel is dat deze matrixbewerking in fracties van een seconde kan worden uitgevoerd zonder trainingslussen.

 
## Hoe meet je of een netwerk écht iets vergeten is?

 De grootste valkuil binnen machine unlearning is schijnsucces: het model genereert het te wissen antwoord niet meer bij een directe vraag, maar de informatie zit nog steeds gecodeerd in de gewichten en kan via alternatieve routes worden geëxtraheerd. Een rigoureuze evaluatie vereist vier complementaire meetmethodes:

 
### 1. Membership Inference Attacks (MIA)

 MIA toetst of een aanvaller statistisch kan bepalen of een specifiek record onderdeel was van de trainingsset. Een getraind model vertoont doorgaans een significant lagere loss en lagere entropie op trainingsdata dan op niet-geziene data. Na een succesvolle unlearning-operatie moet de loss-verdeling van de records uit $\mathcal{D}_{\text{forget}}$ exact samenvallen met de loss-verdeling van records die het model daadwerkelijk nooit heeft gezien (de testset).

 
### 2. Extractie- en Jailbreak-resistentie

 Als een model bij de directe prompt Wie is burger X? antwoordt met "Dat weet ik niet", kan de data via prefix-probing of adversarial jailbreaks (zoals base64-encoding of rollenspellen) vaak alsnog naar buiten komen. Unlearning is pas geslaagd als geavanceerde prompt-optimalisatietechnieken (zoals GCG — Greedy Coordinate Gradients) er niet in slagen de doeltekst te reconstrueren.

 
### 3. Model Utility en Retain Accuracy

 Het wissen van data mag de algemene prestaties van het model niet degraderen. Er wordt gemeten op standaard benchmarks voor logisch redeneren (zoals MMLU, GSM8K) en taalkundige perplexiteit op $\mathcal{D}_{\text{retain}}$. Een daling van meer dan enkele tienden procentpunten duidt op ongewenste nevenschade aan omringende gewichtsstructuren.

 
### 4. Re-learning Speed (Wederleersnelheid)

 Als we het unlearned model opnieuw finetunen op een fractie van $\mathcal{D}_{\text{forget}}$, hoe snel leert het de informatie dan weer aan? Als het model het vergeten feit binnen één enkele gradiëntstap met hoge zekerheid herstelt, was de informatie niet gewist, maar slechts onderdrukt (het 'slapende neuron'-effect). Een werkelijk unlearned model vertoont een leercurve die identiek is aan een model dat vanaf nul begint.

 
## Praktijkuitdagingen en compliance in 2026

 Ondanks aanzienlijke academische vooruitgang kent machine unlearning in productieomgevingen harde beperkingen die ontwikkelaars en data engineers moeten meewegen:

 Ten eerste treedt bij herhaaldelijke unlearning-sessies (bijvoorbeeld dagelijkse AVG-verwijderverzoeken) accumulatieve gewichtsdegradatie op. Elke ingreep via gradiëntstijging of modelbewerking introduceert een kleine afwijking in de orthogonale deelruimtes van het netwerk. Na honderden opeenvolgende ingrepen raakt het model instabiel en nemen hallucinaties progressief toe.

 Ten tweede vereist verantwoorde dataverwerking dat men ook op operationeel en infrastructureel niveau aantoonbaar kan maken dat persoonsdata niet blijft rondzwerven in runtime-omgevingen. Wie verantwoordelijk is voor API-koppelingen en dataverwerkersovereenkomsten doet er verstandig aan om de richtlijnen voor [logbewaring afstemmen op zero data retention](https://api.llmnet.nl/logbewaring-afstemmen-op-zero-data-retention) te implementeren, zodat interactiedata met betrekking tot verwijderverzoeken niet via proxy-logs of audit-trails alsnog reproduceerbaar blijft.

 
 
### Hierna verder met

 Nu duidelijk is hoe trainingsdata selectief uit gewichten kan worden verwijderd, kun je de bredere impact van datahygiëne bestuderen. Lees verder over de invloed van dataverzameling in [trainingsdata en bias bij taalmodellen](https://leren.llmnet.nl/trainingsdata-en-bias) om te zien hoe scheefgroei in de initiële trainingsfase ontstaat, of verdiep je in [mechanistische interpreteerbaarheid](https://leren.llmnet.nl/mechanistisch-interpreteren-uitgelegd) om te begrijpen hoe circuits en neuronen visueel traceerbaar worden gemaakt.