Membership inference attack : a-t-elle servi à l'entraînement ?

La membership inference attack (MIA) est l'attaque qui répond à une question simple et lourde : cette donnée précise a-t-elle servi à l'entraînement de ce modèle ?. Sur un système qui traite des données personnelles, la réponse positive constitue une violation de données au sens RGPD. Sur un modèle entraîné sur de la propriété intellectuelle, c'est la base d'un litige (NYT vs OpenAI 2023+, GitHub Copilot vs développeurs 2022+). Sur un modèle médical ou financier, c'est un risque sectoriel direct. Carlini et al. ont démontré dès 2021 qu'on peut extraire verbatim des morceaux du training set de GPT-2 — emails, téléphones, snippets de code. Les modèles modernes ont des défenses partielles, jamais complètes.

Cet article documente les 5 méthodes principales (loss-based, LiRA, reference model, verbatim extraction, neighbor attack), les cas publics (Shokri 2017, Carlini 2021/2022, procès NYT-OpenAI), et les défenses concrètes (differential privacy, regularization, output filtering, monitoring). Pour le contexte global model attacks : model extraction, data poisoning.

Mental model : le modèle "se souvient"

L'intuition centrale de la MIA : un modèle ML/LLM se comporte différemment sur des données vues à l'entraînement vs des données nouvelles. La différence est statistiquement détectable même quand elle est imperceptible à un humain :

• Loss plus faible sur les exemples vus.
• Confiance plus élevée (probabilité top-1 du token suivant).
• Complétion plus précise sur des prompts qui ressemblent au début du training example.
• Perplexité plus basse.
• Régularité de la sortie (le modèle est plus "fluide" sur ce qu'il connaît).

Plus le modèle est grand et son training set petit, plus le signal est fort. Les LLM frontier (GPT-4, Claude Sonnet, Gemini) ont entraîné sur des trillions de tokens — le signal s'atténue mais ne disparaît jamais. Carlini et al. (2022) ont publié une scaling law claire : plus le modèle est grand, plus il mémorise et plus la MIA est efficace.

Info — Catégorie OWASP : LLM02 Sensitive Information Disclosure + LLM04 Data and Model Poisoning (côté training data). RGPD : Articles 5, 25, 32, 33, 35. Voir audit conformité NIST/ISO/EU AI Act.

Cinq méthodes documentées

Méthode 1 — Loss-based MIA (Shokri et al. 2017)

Référence fondatrice : Shokri et al., "Membership Inference Attacks Against Machine Learning Models" (S&P 2017).

Mécanique : pour un exemple candidat x, calculer la loss du modèle sur x. Si la loss est inférieure à un seuil, classifier x comme membre du training set.

def loss_based_mia(model, candidate: str, threshold: float) -> bool:
    """Renvoie True si le candidat est probablement dans le training set."""
    loss = compute_loss(model, candidate)
    return loss < threshold
 
def compute_loss(model, text: str) -> float:
    tokens = tokenize(text)
    logits = model.forward(tokens[:-1])
    return cross_entropy(logits, tokens[1:]).mean().item()

Le seuil est calibré sur un corpus de validation : 50% de membres connus, 50% de non-membres connus. La performance se mesure en AUC (Area Under the Curve).

Limite : sur les très grands modèles entraînés sur des corpus immenses, le signal individuel s'atténue. Reste pertinent sur LLM petits/moyens et sur LLMs fine-tunés.

Méthode 2 — LiRA (Likelihood Ratio Attack)

Référence : Carlini et al., "Membership Inference Attacks From First Principles" (S&P 2022). État de l'art en MIA classique.

Mécanique : entraîner plusieurs modèles de référence (shadow models) sur des datasets dont on contrôle l'inclusion ou non du candidat x. Comparer la distribution de loss sur x entre modèles "in" (qui ont vu x) et modèles "out" (qui n'ont pas vu x). Le test du rapport de vraisemblance donne la décision.

def lira_mia(target_model, candidate, shadow_models_in, shadow_models_out):
    target_loss = compute_loss(target_model, candidate)
    
    in_losses = [compute_loss(m, candidate) for m in shadow_models_in]
    out_losses = [compute_loss(m, candidate) for m in shadow_models_out]
    
    # Fit deux distributions normales
    in_mean, in_std = np.mean(in_losses), np.std(in_losses)
    out_mean, out_std = np.mean(out_losses), np.std(out_losses)
    
    # Likelihood ratio
    p_in = scipy.stats.norm.pdf(target_loss, in_mean, in_std)
    p_out = scipy.stats.norm.pdf(target_loss, out_mean, out_std)
    
    return p_in / p_out > 1.0

Force : LiRA est plus précise que loss-based simple, particulièrement pour les attaques "chirurgicales" sur un faible nombre d'exemples.

Limite : exige plusieurs shadow models entraînés, donc coûteux à exécuter.

Méthode 3 — Reference model attack

Variante simplifiée de LiRA : utiliser un seul modèle de référence (un modèle public similaire mais entraîné sur des données différentes) pour calibrer.

def reference_model_mia(target_model, reference_model, candidate, threshold):
    """Différence de loss entre modèle cible et modèle référence."""
    target_loss = compute_loss(target_model, candidate)
    ref_loss = compute_loss(reference_model, candidate)
    
    # Si target plus précis que référence sur ce candidat → probable membre
    return (ref_loss - target_loss) > threshold

Utilisable contre des LLMs propriétaires en utilisant un open-weights similaire (Llama, Mistral) comme référence.

Méthode 4 — Verbatim extraction (Carlini et al. 2021)

Référence : Carlini et al., "Extracting Training Data from Large Language Models" (USENIX 2021). Démonstration que GPT-2 mémorise et restitue verbatim des passages du training set.

Mécanique :

def verbatim_extraction(model, num_attempts: int = 10000):
    """Génère des sorties à haute température, filtre par perplexité, vérifie online."""
    candidates = []
    
    # 1. Génération à haute température (diversité)
    for _ in range(num_attempts):
        # Préfixe varié, parfois empty, parfois template "Subject:", "Hello,"
        prefix = sample_prefix()
        completion = model.generate(prefix, temperature=1.0, max_length=200)
        candidates.append(prefix + completion)
    
    # 2. Filtrer par perplexité basse (signe de mémorisation forte)
    candidates_with_perp = [(c, compute_perplexity(model, c)) for c in candidates]
    candidates_with_perp.sort(key=lambda x: x[1])
    top_low_perp = candidates_with_perp[:100]
    
    # 3. Vérifier en ligne (Google search) si fragments correspondent à du contenu réel
    extracted = []
    for c, p in top_low_perp:
        if google_search_returns_match(c[:80]):  # première phrase
            extracted.append(c)
    
    return extracted

Carlini et al. ont extrait noms, emails, téléphones, conversations IRC, code propriétaire de GPT-2. Risque RGPD direct : si un LLM en production peut être amené à restituer verbatim des données personnelles de son training set, on est en zone d'incident à notifier.

Méthode 5 — Neighbor attack et dataset cartography

Variante : au lieu d'attaquer un exemple précis, l'attaquant cherche les voisinages mémorisés — zones du training set particulièrement bien retenues. Souvent les exemples rares, longs, ou ceux qui ont été dupliqués dans le training set.

def neighbor_attack(model, candidate, k: int = 10):
    """Mesure la mémorisation autour de candidate (variations proches)."""
    base_loss = compute_loss(model, candidate)
    
    # Générer k variations proches (paraphrases minimales)
    neighbors = generate_neighbors(candidate, n=k)
    neighbor_losses = [compute_loss(model, n) for n in neighbors]
    
    # Si candidate a une loss plus faible que tous ses voisins → outlier
    # (signe que ce point précis est mémorisé, pas la classe)
    return base_loss < min(neighbor_losses) - DELTA

Utile pour distinguer mémorisation spécifique vs généralisation sur une classe.

Cas publics et procès

Les procès NYT vs OpenAI (déposé décembre 2023) et GitHub Copilot class-action (2022+) sont les références juridiques en cours. Les MIA y sont utilisées comme preuves techniques que des contenus protégés par copyright ont été utilisés à l'entraînement sans licence.

Défenses concrètes

Couche 1 — Differential privacy (DP)

Référence : Dwork, "Differential Privacy" (2006). DP-SGD (Abadi et al. 2016) est la méthode standard pour entraîner des modèles avec garanties DP.

Mécanique : pendant l'entraînement, ajouter du bruit gaussien calibré au gradient + clipping des gradients par exemple, de sorte qu'on ne puisse pas distinguer si un exemple précis était dans le batch.

# DP-SGD simplifié
def dp_sgd_step(model, batch, lr, noise_multiplier, max_grad_norm):
    per_example_grads = []
    for example in batch:
        grad = compute_grad(model, example)
        # Clip per-example
        grad = clip_grad_norm(grad, max_norm=max_grad_norm)
        per_example_grads.append(grad)
    
    # Sum + noise gaussian
    summed_grad = sum(per_example_grads)
    noise = np.random.normal(0, noise_multiplier * max_grad_norm, summed_grad.shape)
    noisy_grad = (summed_grad + noise) / len(batch)
    
    # Update
    update_params(model, noisy_grad, lr)

Trade-off : DP impose une dégradation de qualité significative sur LLM. Pour atteindre epsilon strict (< 1), la qualité chute de 5-30% selon les benchmarks. Anthropic, Google DeepMind, Apple travaillent activement à réduire ce gap (Apple Intelligence utilise une combinaison DP + on-device).

Usage pratique : DP pour les corpus de fine-tuning sur données sensibles (médical, RH), pas (encore) pour le pré-entraînement frontier.

Couche 2 — Régularisation et déduplication

Mémorisation = sur-apprentissage. Régulariser réduit naturellement le risque MIA.

• Déduplication agressive du training corpus (les exemples dupliqués sont les plus mémorisés).
• Dropout, weight decay, label smoothing standards.
• Early stopping : entraîner moins.
• Pas de répétition multiple d'epochs sur le même corpus (1 epoch typique sur LLM frontier).

Couche 3 — Output filtering et detection

Au runtime, intercepter les sorties qui ressemblent à du verbatim training data :

def detect_potential_verbatim(output: str, training_set_hashes: set) -> bool:
    """Détecte si une sortie est probablement issue verbatim du training set."""
    # Hash de chaque n-gram (n=8-10 tokens)
    for ngram in get_ngrams(tokenize(output), n=10):
        if hash(ngram) in training_set_hashes:
            return True
    return False
 
# En pratique : Bloom filters pour scaler aux trillions de tokens
def detect_via_bloom(output: str, bloom_filter):
    for ngram in get_ngrams(tokenize(output), n=10):
        if ngram in bloom_filter:
            return True
    return False

Limites : faux positifs sur les phrases courantes (idiomes, expressions). Réservé aux cas critiques (santé, données personnelles).

Couche 4 — Rate limiting et monitoring extraction

Les attaques verbatim de Carlini-style demandent des milliers de génériques. Le monitoring des patterns d'extraction (haute température, prompts ressemblant à des préfixes mémorisables) signale ce type d'attaque.

SUSPICIOUS_GENERATION_PATTERNS = [
    {"temp": ">0.9", "prompts_per_session": ">1000"},
    {"prompt_pattern": "starts_with_template", "volume": "high"},
    {"prompt_pattern": "common_email_prefix", "volume": "any"},
]

Couche 5 — Output randomization

Ajouter du bruit contrôlé en sortie (cf. model extraction) — perturbation qui dégrade la fidélité de verbatim extraction.

Couche 6 — Documentation et conformité

• Registre des traitements (RGPD Art. 30) : documenter le LLM, les données d'entraînement, les contrôles MIA.
• DPIA (Art. 35) : anticiper le risque MIA dans l'analyse d'impact.
• EU AI Act : pour les modèles à haut risque, traçabilité de la provenance des données.
• Preuve d'audit MIA : produire et conserver les rapports d'audit MIA pour défense légale.

Tests d'audit MIA

Méthodologie en 5 phases :

1. Constituer un corpus de test : 100-1000 exemples connus comme étant dans le training set + autant de contrôles connus comme étant en dehors.
2. Loss-based baseline : appliquer méthode 1, mesurer AUC.
3. LiRA si shadow models disponibles : appliquer méthode 2, comparer.
4. Verbatim extraction test : 1000-10000 prompts à haute température, mesurer taux d'extraction de fragments connus.
5. Documentation et reporting : AUC, exemples extraits, recommandations (DP, dédup, filtering).

def audit_mia_baseline(model, members: list, non_members: list) -> dict:
    """Audit MIA basique (loss-based)."""
    member_losses = [compute_loss(model, m) for m in members]
    non_member_losses = [compute_loss(model, n) for n in non_members]
    
    # AUC : capacité à distinguer
    y_true = [1] * len(member_losses) + [0] * len(non_member_losses)
    y_score = [-l for l in member_losses + non_member_losses]  # loss inverse = score
    auc = roc_auc_score(y_true, y_score)
    
    return {
        "auc": auc,
        "member_loss_mean": np.mean(member_losses),
        "non_member_loss_mean": np.mean(non_member_losses),
        "vulnerable": auc > 0.6,  # baseline simple
    }

Outils de référence : mia-tools (HuggingFace), Garak avec probes mémorisation, scripts custom.

Mapping OWASP LLM Top 10 v2

LLM02 est la catégorie de référence — la mémorisation et le verbatim extraction sont explicitement cités dans la documentation OWASP.

Mapping conformité

RGPD

• Article 5 — minimisation : ne pas entraîner sur données personnelles non nécessaires.
• Article 25 — privacy by design : DP, déduplication, filtering en sortie.
• Article 32 — sécurité du traitement : audits MIA réguliers.
• Article 33 — notification : si MIA réussie révèle données personnelles → CNIL sous 72h.
• Article 35 — DPIA : risque MIA documenté.

EU AI Act

Pour modèles GPAI (general-purpose AI) :

• Documentation du training corpus (Article 53).
• Évaluation du risque (incluant MIA / mémorisation) pour les modèles à haut risque.

Sectoriel

• HDS / HIPAA (santé) : DP souvent obligatoire si entraînement sur données patients.
• Schrems II / Privacy Shield : data residency complique l'audit MIA cross-border.

Points clés à retenir

• La MIA répond à : "cette donnée précise a-t-elle servi à l'entraînement ?". Risque privacy + IP + sectoriel.
• 5 méthodes : loss-based (Shokri 2017), LiRA (Carlini 2022, état de l'art), reference model attack (variante simplifiée), verbatim extraction (Carlini 2021), neighbor attack.
• Carlini et al. ont publiquement extrait verbatim emails, téléphones, code propriétaire de GPT-2 en 2021. Scaling law (2022) : plus le modèle est grand, plus il mémorise.
• Cas juridiques en cours : NYT vs OpenAI (2023+), GitHub Copilot class-action (2022+) — les MIA y sont preuves techniques.
• Défense en 6 couches : differential privacy (DP-SGD), régularisation + déduplication, output filtering (Bloom filter sur n-grams), monitoring extraction, output randomization, documentation + conformité.
• Trade-off DP : 5-30% de dégradation de qualité pour atteindre epsilon strict. Recherche active 2023-2026 pour réduire ce gap.
• OWASP LLM02 Sensitive Information Disclosure = catégorie centrale.
• Conformité : RGPD Art. 5/25/32/33/35, EU AI Act Art. 53 (GPAI), sectoriel (HDS, HIPAA).
• Audit minimum : corpus test (membres + non-membres) → loss-based AUC + verbatim extraction sur 1000-10000 prompts.

La MIA est aujourd'hui à la fois une mesure d'audit que les fournisseurs LLM responsables publient, et une preuve technique mobilisée dans les litiges juridiques. Sur les LLM frontier, le risque ne disparaît jamais — il se mesure, se documente, se mitigate. Pour les déploiements enterprise sur données sensibles : DP + déduplication + audits MIA réguliers ne sont plus optionnels.