Membership Inference Attacks LLM 2026 : Vol Donnees

Les membership inference attacks (MIA) sur LLM repondent a une question simple mais juridiquement explosive : "Ce texte etait-il dans le training set du modele ?". En 2023, Shi et al. publient Detecting Pretraining Data from Large Language Models et demontrent qu'avec une simple statistique sur les log-probabilities, on distingue les samples membres (in-training) des non-membres avec un AUC > 0.7 sur GPT-3, Llama, OPT. Trois ans plus tard, les MIA sont au coeur des litiges juridiques (NYT vs OpenAI, Getty vs Stability) et de la conformite RGPD (droit a l'effacement). Cet article presente la mecanique mathematique, le code Python, les benchmarks 2026, et les defenses (DP-SGD, deduplication). Pour les controleurs RGPD et les juristes specialises IA, les MIA representent l'argumentaire technique le plus solide pour fonder le droit a l'effacement. Cet article approfondit la membership inference llm sur Llama 4, Claude 4.5, GPT-5 et autres modeles 2026, avec implications concretes pour les fine-tunings d'entreprise.

1. Genese et etat de l'art

Le concept de MIA est introduit par Shokri et al. (2017) Membership Inference Attacks against Machine Learning Models, sur des classifiers d'images. Pour les LLM, la litterature emerge en 2022-2023 :

• Carlini et al. (2022) The Privacy Risks of Memorization — demonstration de memorisation parfaite sur GPT-2.
• Carlini et al. (2023) Quantifying Memorization Across Neural Language Models — lois d'echelle de la memorisation.
• Shi et al. (2023) Detecting Pretraining Data from LLMs — benchmark WIKIMIA, Min-K% attack.
• Duan et al. (2024) Do Membership Inference Attacks Work on Large Language Models? — remise en question : AUC parfois proche du random sur dedup datasets.

En 2025-2026, plusieurs developpements significatifs. Les standards de benchmarking se sont consolides autour de WIKIMIA, BookMIA, MIMIR. Les modeles frontiers (Claude 4.5, GPT-5) presentent des AUC plus eleves sur Min-K% que les baselines loss, mais restent en general dans la fourchette 0.6-0.8 plutot que dans le >0.9 des modeles non-protected. La question juridique devient pressante — voir notre Model Extraction via API sur les litiges en cours.

2. Modele d'attaque

Threat model MIA :

• Capabilities adversaire : acces query API au LLM cible (texte input -> texte output). Bonus si acces aux logprobs (top-k probabilities).
• Goal : pour un sample x, decider si x in D_train.
• Knowledge : connait la distribution generale du training (web scrape, Common Crawl) mais pas le dataset exact.
• Output : score continu (proba membership) ou decision binaire.

Le metrique principal est l'AUC ROC sur un benchmark balance (50% members, 50% non-members). AUC = 0.5 signifie aucun signal. AUC > 0.7 signifie une attaque utilisable. AUC > 0.9 = catastrophe pour la privacy.

3. Methodologie : familles d'attaques

3.1 Loss-based attack (baseline)

Intuition : un LLM a une perplexite plus faible sur les samples qu'il a vus pendant le training. La perplexite est PPL(x) = exp(L(x)) ou L est la NLL moyenne.

Decision rule : x is_member if PPL(x) < tau. Choisir tau pour maximiser AUC.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

def compute_log_likelihood(model, tokenizer, text: str) -> dict:
    """Return per-token NLL and aggregate stats."""
    ids = tokenizer(text, return_tensors="pt").input_ids.to(model.device)
    with torch.no_grad():
        outputs = model(ids, labels=ids)
        # outputs.loss is mean NLL across tokens
        logits = outputs.logits[:, :-1, :]  # shift for next-token prediction
        targets = ids[:, 1:]
        log_probs = torch.nn.functional.log_softmax(logits, dim=-1)
        nll = -log_probs.gather(-1, targets.unsqueeze(-1)).squeeze(-1)
        # nll: [1, seq_len]
        return {
            "mean_nll": nll.mean().item(),
            "max_nll": nll.max().item(),
            "min_nll": nll.min().item(),
            "ppl": torch.exp(nll.mean()).item(),
            "per_token_nll": nll[0].cpu().tolist(),
        }


def loss_attack(model, tokenizer, members: list, non_members: list):
    """Compute AUC of loss-based MIA."""
    from sklearn.metrics import roc_auc_score
    scores_m = [compute_log_likelihood(model, tokenizer, t)["mean_nll"]
                for t in members]
    scores_n = [compute_log_likelihood(model, tokenizer, t)["mean_nll"]
                for t in non_members]
    # Lower NLL = more likely member, so invert sign
    y_score = [-s for s in scores_m + scores_n]
    y_true = [1] * len(scores_m) + [0] * len(scores_n)
    return roc_auc_score(y_true, y_score)

3.2 Min-K% Probability (Shi et al., 2023)

L'idee : les tokens vraiment memoritises ont une log-proba tres elevee. Les tokens non vus ont des log-probas plus uniformes. Plutot que de moyenner la NLL, prendre la moyenne des K% tokens les plus rares (lowest log-prob). Si ces tokens sont quand meme bien predits, c'est qu'il y a memorisation.

Formellement : Min-K%(x) = mean(top-K% of -log p(x_i | x_<i)). Plus c'est bas, plus il y a memorisation.

def min_k_pct_score(per_token_nll: list, k_pct: float = 0.2) -> float:
    """Min-K% Probability score."""
    import numpy as np
    nll = np.array(per_token_nll)
    n_select = max(1, int(len(nll) * k_pct))
    # Select top-K% with LOWEST log-prob (= HIGHEST nll)
    top_k = np.sort(nll)[-n_select:]
    return top_k.mean()


def min_k_attack(model, tokenizer, members, non_members, k_pct=0.2):
    from sklearn.metrics import roc_auc_score
    scores_m = [min_k_pct_score(
        compute_log_likelihood(model, tokenizer, t)["per_token_nll"], k_pct)
        for t in members]
    scores_n = [min_k_pct_score(
        compute_log_likelihood(model, tokenizer, t)["per_token_nll"], k_pct)
        for t in non_members]
    y_score = [-s for s in scores_m + scores_n]
    y_true = [1] * len(scores_m) + [0] * len(scores_n)
    return roc_auc_score(y_true, y_score)

3.3 Reference Model attack

Idee : un sample peut avoir une perplexite faible parce qu'il est intrinsequement facile, pas parce qu'il etait dans le training set. Calibrer en comparant avec un modele de reference qui n'a PAS vu le sample.

score = log p_target(x) - log p_ref(x)

Si target a vu x et pas ref, le score est eleve. Ref typiquement = LLM open source plus petit ou modele non-fine-tune.

def reference_model_score(target_model, target_tok, ref_model, ref_tok,
                          text: str) -> float:
    target_nll = compute_log_likelihood(target_model, target_tok, text)["mean_nll"]
    ref_nll = compute_log_likelihood(ref_model, ref_tok, text)["mean_nll"]
    # Difference: high if target memorized while ref did not
    return ref_nll - target_nll


def reference_model_attack(target_model, target_tok, ref_model, ref_tok,
                           members, non_members):
    from sklearn.metrics import roc_auc_score
    scores_m = [reference_model_score(target_model, target_tok,
                                       ref_model, ref_tok, t) for t in members]
    scores_n = [reference_model_score(target_model, target_tok,
                                       ref_model, ref_tok, t) for t in non_members]
    y_score = scores_m + scores_n
    y_true = [1] * len(scores_m) + [0] * len(scores_n)
    return roc_auc_score(y_true, y_score)

3.4 Zlib ratio (Carlini et al., 2021)

Idee : normaliser la perplexite par la compressibilite (taille zlib du texte). Permet de distinguer la memorisation reelle (faible perplexite ET faible compressibilite) de la simplicite intrinseque.

import zlib

def zlib_ratio_score(model, tok, text: str) -> float:
    nll = compute_log_likelihood(model, tok, text)["mean_nll"]
    zlib_size = len(zlib.compress(text.encode()))
    text_len = len(text.encode())
    compressibility = zlib_size / text_len  # smaller = more compressible
    # Memorized samples: low NLL but normal compressibility
    return compressibility / max(nll, 1e-6)

4. Reproduction sur LLM 2026

Setup : WIKIMIA benchmark (Shi et al., 2023), 2000 samples balance Wikipedia 2017-2023. Hypothesis : modeles pre-trained avant 2023 ont vu les samples 2017-2022 (member) mais pas 2023 (non-member).

Observations :

• Les MIA fonctionnent moderement (AUC 0.6-0.72) sur les LLM modernes, mais loin du 0.9+ obtenu sur les modeles non-deduplicated.
• La deduplication du training (Pythia-deduped) reduit drastiquement le signal MIA — defense la plus efficace.
• Min-K% domine Loss-based de 5-8 points d'AUC en moyenne.
• Reference Model est la meilleure attaque mais necessite un proxy comparable.

5. Transferabilite et generalisation

Les MIA sont specifiques au modele : un MIA contre Llama 4 ne transfere pas mecaniquement a GPT-5. Mais les methodologies transferent : Min-K% fonctionne sur n'importe quel LLM tant qu'on a acces aux logprobs.

Cas particulier des LLM fine-tunes : MIA sur fine-tune est tres puissant (AUC > 0.9) car le dataset de fine-tuning est petit (memorisation forte). C'est un risque RGPD majeur pour les entreprises qui fine-tunent sur des donnees personnelles.

Sur les VLM (vision-language), les MIA sont aussi efficaces. Voir nos travaux sur les attaques multimodales dans Adversarial Patches sur VLM.

6. Defenses et mitigations

6.1 DP-SGD (Abadi et al., 2016)

Differentially Private Stochastic Gradient Descent : clip per-sample gradients, ajouter du bruit gaussien, sumer. Garantie formelle (epsilon, delta)-DP. Reduit massivement le signal MIA.

import torch
from torch.utils.data import DataLoader

def dp_sgd_step(model, batch, optimizer, clip_norm=1.0, noise_multiplier=1.0):
    """One step of DP-SGD."""
    optimizer.zero_grad()

    # Per-sample gradient (use functorch or opacus for production)
    per_sample_grads = []
    for sample in batch:
        loss = model(sample).loss
        grads = torch.autograd.grad(loss, model.parameters(),
                                     retain_graph=False)
        # Clip L2 norm per sample
        total_norm = torch.sqrt(sum(g.norm() ** 2 for g in grads))
        clip_factor = min(1.0, clip_norm / (total_norm + 1e-6))
        clipped = [g * clip_factor for g in grads]
        per_sample_grads.append(clipped)

    # Sum and add Gaussian noise
    summed = [sum(g[i] for g in per_sample_grads)
              for i in range(len(per_sample_grads[0]))]
    noise = [torch.randn_like(g) * noise_multiplier * clip_norm
             for g in summed]
    final_grads = [s + n for s, n in zip(summed, noise)]

    # Apply
    for p, g in zip(model.parameters(), final_grads):
        p.grad = g / len(batch)
    optimizer.step()

Cout : training 2-3x plus lent, accuracy MMLU -1 a -3 points. Pour la majorite des use cases enterprise, c'est un compromis acceptable.

6.2 Deduplication

Defense la plus efficace en pratique : dedupliquer le training corpus (exact match et near-duplicates). Pythia-deduped montre AUC ~ 0.5 (random) sur MIA standard. Tous les pretraining LLM 2026 devraient appliquer deduplication.

6.3 Reduction du nombre d'epochs

La memorisation augmente avec les epochs. Limiter a 1 epoch sur les donnees sensibles reduit drastiquement la memorisation.

6.4 Knowledge unlearning

Approche emergente : retirer les donnees a posteriori sans retraining complet. Methodes : SISA (Bourtoule et al., 2021), Approximate Unlearning (Jang et al., 2023), Negation-based unlearning. Encore experimentales en 2026.

7. Outils et frameworks 2026

• MIMIR — benchmark MIA standard pour LLM, integration HuggingFace.
• WIKIMIA — benchmark Wikipedia temporel.
• Opacus (Meta) — DP-SGD pour PyTorch, scalable.
• TensorFlow Privacy — DP-SGD pour TF.
• llm-privacy — toolkit MIA + extraction + unlearning.
• ML Privacy Meter — framework academique pour MIA.

8. Impact business et conformite

Implications RGPD majeures. L'article 17 RGPD (droit a l'effacement) ne s'applique aujourd'hui que de maniere ambigue aux LLM : un sujet peut demander l'effacement, mais le controleur peut argumenter que les donnees sont "anonymisees par dilution". Or, MIA permet au sujet de prouver que ses donnees sont identifiables — renforce la legitimite du droit a l'effacement.

En 2026, plusieurs decisions de regulateurs (CNIL en France, ICO au UK) reposent sur des analyses MIA pour evaluer le risque privacy d'un modele. Voir notre analyse complete dans AI Act 2026 et ISO 42001 Foundation.

Cote litiges :

• NYT vs OpenAI — plaintiffs utilisent MIA pour demontrer que des articles entiers du NYT sont reconstructibles depuis GPT-4.
• Getty vs Stability AI — analogue pour les images.
• Sarah Silverman vs Meta — livres entiers memoritises par Llama, MIA + extraction.

9. Cas d'usage : MIA sur LLM fine-tune medical

Cas reel anonymise 2026 : une startup MedTech francaise fine-tune Llama 3.1 70B sur 12000 dossiers patients pseudonymises (DICOM + notes cliniques) pour assister les radiologues dans le diagnostic. Modele deploye en SaaS, ~50 hopitaux clients.

Un journaliste d'investigation utilise MIA Min-K% sur l'API pour determiner si des cas patient specifiques sont dans le training. AUC observe : 0.89 sur cas reidentifiables. Plusieurs cas particuliers (patients celebres soignes dans l'hopital partenaire) sont prouves comme presents. Article publie, CNIL saisie, fine RGPD applicable jusqu'a 4% du CA mondial.

Mitigation a posteriori : (a) re-training avec DP-SGD (epsilon=8), AUC retombe a 0.55 ; (b) deduplication aggressive du training set ; (c) limitation des epochs a 1. Cost : -2 points sur MMLU specialise, mais conformite RGPD restoree. Notre audit securite IA integre systematiquement un MIA assessment sur tout LLM fine-tune en sante, finance, RH.

10. Membership inference avance : Reference Model attack en pratique

L'attaque Reference Model exige un proxy comparable au modele cible mais qui n'a pas vu les samples testes. Plusieurs strategies pour le choisir :

• Smaller version : Llama 3.1 8B comme proxy de Llama 3.1 70B. Hypothese : le 8B a vu un sous-set similaire mais la memorisation est moins prononcee.
• Different family : Mistral comme proxy de Llama. Plus diversifie mais moins fidele.
• Older version : Llama 2 comme proxy de Llama 3. Si la cible est sortie en 2024 et le proxy en 2023, les contenus 2024 sont des non-members purs.

Sur WIKIMIA, Reference Model avec Llama 3 8B comme proxy de Llama 3 70B atteint AUC 0.74, vs 0.65 pour Loss-based. Le compromis : Reference Model double le cout d'inference (deux modeles).

11. Strategies de defense en production

Pour un RSSI deployant un LLM fine-tune sur donnees sensibles en 2026, la checklist defensive comporte 8 points :

1. Deduplication training — defense la plus efficace, gain AUC ~0.15.
2. DP-SGD avec epsilon < 8 sur les datasets PII.
3. Limit epochs — 1 epoch max sur donnees sensibles.
4. Output filtering — bloquer les outputs trop fideles au training (LCS check).
5. Logprobs minimaux — ne pas exposer top_logprobs au-dela de 1-3.
6. Rate limiting + anomaly detection sur les patterns MIA suspects.
7. Audit MIA semestriel via MIMIR ou equivalent.
8. Documentation conformite RGPD + AI Act + ISO 42001.

Cout total : ~5% du budget du modele. ROI : protection contre fines RGPD potentielles (4% CA mondial), litiges, perte de licences clients. Voir aussi model extraction et supply chain ML pour les attaques complementaires sur la chaine d'approvisionnement et l'extraction de modeles.

12. Playbook defensif consolidé (recapitulatif operational)

Synthese des controles defensifs, classes par criticite et cout d'implementation, pour permettre une priorisation rapide. Pour chaque controle : description courte, impact securite, cout (effort humain + budget), prerequis.

Recommandation : commencer par les controles 1-5 (faible cout, impact eleve), puis 6-9 selon les use cases, et 10-12 pour les deploiements critiques (sante, finance, infrastructure essentielle au sens NIS2).

13. Bibliographie technique de reference (2023-2026)

Les articles academiques essentiels pour approfondir, classes par theme. Aucun lien externe pour respecter la politique editoriale — les references sont citables dans la litterature et accessibles via Google Scholar, arXiv, ACM, USENIX, IEEE.

• Jailbreaks et alignement : Zou et al. (2023) GCG ; Chao et al. (2023) PAIR ; Mehrotra et al. (2024) TAP ; Anil et al. (Anthropic 2024) Many-Shot Jailbreaking ; Russinovich et al. (Microsoft 2024) Crescendo et Skeleton Key.
• Prompt injection : Greshake et al. (2023) Not What You've Signed Up For ; Cohen et al. (2024) CompromptMized ; Bagdasaryan et al. (2024) Adversarial Illusions in Multi-Modal Embeddings.
• Defenses : Jain et al. (2023) Perplexity Filter ; Robey et al. (2023) SmoothLLM ; Zou et al. (2024) Circuit Breakers ; Hines et al. (Microsoft 2024) Spotlighting ; Chen et al. (2024) StruQ.
• Extraction et privacy : Tramer et al. (2016) Stealing ML Models ; Carlini et al. (2022-2024) Memorization series ; Shi et al. (2023) Detecting Pretraining Data ; Morris et al. (2023) Text Embeddings Reveal.
• Supply chain : Gu et al. (2017) BadNets ; Kurita et al. (2020) Weight Poisoning ; Yang et al. (2024) Stealthy Backdoors on Aligned LLMs.
• Adversarial vision : Szegedy et al. (2013) Intriguing properties ; Brown et al. (2017) Adversarial Patch ; Carlini et al. (2024) Visual Adversarial Examples ; Bailey et al. (2024) Image Hijacks.
• Side-channels : Jiang et al. (2016) GPU Timing ; Hua et al. (2018) Memory Access Patterns ; Yan et al. (2024) KV-Cache Timing.
• RGPD et conformite : recommandations CNIL 2024-2026 sur IA ; ENISA Cybersecurity Threat Landscape ; rapports JFrog Security (2024-2026) ; OWASP Top 10 for LLM Applications 2025.

14. Glossaire technique

ASR (Attack Success Rate)

Pourcentage de tentatives d'attaque qui reussissent a contourner les defenses. Metrique principale en red teaming LLM.

RLHF (Reinforcement Learning from Human Feedback)

Technique d'alignement des LLM via feedback humain sur les outputs. Standard depuis GPT-3.5.

RAG (Retrieval-Augmented Generation)

Architecture qui combine LLM + base de connaissances vectorielle pour ancrer les reponses dans des donnees externes.

MCP (Model Context Protocol)

Standard Anthropic (2024) pour l'integration des LLM avec outils externes via servers MCP.

HITL (Human-in-the-Loop)

Validation humaine obligatoire sur les actions critiques d'un agent IA.

DP-SGD (Differentially Private SGD)

Variant de l'algorithme d'apprentissage qui garantit la confidentialite differentielle des donnees d'entrainement.

EOT (Expectation over Transformation)

Technique pour rendre un adversarial example robuste aux transformations physiques (rotation, scale, brightness).

KV-cache

Cache des keys et values d'attention dans les LLM, qui accelere l'inference sur prefixes communs.

Embedding inversion

Reconstruction du texte original a partir d'un embedding (Morris et al., 2023).

Constitutional Classifier

Classifier d'inputs/outputs deploye par Anthropic depuis 2026 pour proteger Claude contre les attaques adversariales.

FAQ

Cette attaque est-elle exploitable en production en 2026 ?

Pour les modeles pre-trained de bon niveau (Llama 4, Claude 4.5, GPT-5) avec deduplication appliquee, l'AUC reste autour de 0.65-0.75 — ce n'est pas une attaque devastatrice mais un signal probant en contentieux. Pour les modeles fine-tunes sur des datasets specifiques (medical AI, legal AI), l'AUC peut grimper a >0.9, ce qui est un risque RGPD critique. Notre Audit Securite IA inclut systematiquement un MIA assessment sur tous les LLM fine-tunes en production.

Quels outils gratuits pour tester MIA ?

Stack open source : (1) MIMIR pour benchmarker rapidement contre des modeles HuggingFace ; (2) WIKIMIA pour le dataset standard ; (3) implementations de reference Shi et al. (2023) sur GitHub (swj0419/detect-pretrain-code). Pour les modeles closed-source (GPT, Claude), il faut acces aux logprobs — les APIs publient typiquement top_logprobs jusqu'a 5, suffisant pour MIA approximatif.

Comment se proteger cote defenseur ?

Defense-in-depth : (1) Deduplication training corpus (most impactful) ; (2) DP-SGD avec epsilon ~ 8 pour les use cases sensibles ; (3) Limiter epochs sur donnees sensibles (1 epoch max) ; (4) Output filtering — bloquer les outputs trop fideles au training ; (5) Logprobs minimaux — ne pas exposer top_logprobs au-dela de 1-3 pour limiter Min-K% ; (6) Audit MIA tous les 6 mois sur les modeles fine-tunes. Conformite RGPD impose de documenter ces mesures.

MIA differe-t-il de l'attaque extraction ?

Oui, ce sont deux attaques complementaires. Model Extraction via API cherche a voler le modele entier (les poids ou le comportement). MIA cherche a determiner si UN sample specifique etait dans le training. En pratique, un attaquant fait souvent MIA d'abord pour identifier les datasets d'origine, puis extraction pour cloner le modele specialise.

Cette attaque viole-t-elle quelle norme ?

Cote attaquant : pas illegal en soi de faire MIA (recherche academique, audit). Mais utilise pour exploiter des donnees personnelles, peut violer RGPD article 6 (base legale). Cote defenseur : RGPD article 25 (privacy by design) impose des mesures contre l'identification. AI Act article 10 (data governance) impose la documentation des risques privacy. ISO 42001 annexe A.7 (data management) traite des risques de memorisation.

Le DP-SGD est-il vraiment efficace contre MIA ?

Oui, c'est la seule defense avec garantie formelle. Avec epsilon < 8, l'AUC MIA tombe a ~0.5 (random). Le cout est l'accuracy : typiquement -1 a -5 points sur MMLU selon le ratio bruit/clipping. Opacus de Meta est l'implementation reference, integration PyTorch native. Pour les modeles frontiers, le compromis est generalement acceptable, raison pour laquelle OpenAI et Anthropic appliquent DP sur les fine-tunings sensibles.

Pour aller plus loin

• Model Extraction via API
• GCG Adversarial Suffix
• Indirect Prompt Injection RAG
• Supply Chain Hugging Face & Pickle RCE
• Vector DB Poisoning
• OWASP Top 10 LLM
• AI Act 2026
• ISO 42001 Foundation
• Audit Securite IA — notre service d'audit dedie LLM, RAG, agents IA