Model inversion : reconstruire les données d'entraînement

Le model inversion est l'attaque qui répond à : "que peut-on apprendre du training set en n'ayant que le modèle ?". À la différence de la membership inference (qui confirme une suspicion sur une donnée précise), l'inversion reconstitue des données — visages reconnaissables, fragments de texte verbatim, inputs entiers depuis des gradients. Référence fondatrice : Fredrikson et al. ont reconstruit en 2015 des visages identifiables à partir de modèles de reconnaissance faciale, démontrant qu'un modèle ML est porteur de signaux exploitables sur ses données d'entraînement. Sur LLMs et systèmes IA modernes, la classe s'est diversifiée : verbatim extraction (Carlini 2021), gradient leakage en federated learning (Zhu 2019), embedding inversion (Vec2Text, Morris 2023). Tous ces vecteurs touchent à des risques privacy et IP majeurs.

Cet article documente les 5 vecteurs principaux (class representative, verbatim, gradient leakage FL, embedding inversion, generative inversion), les cas publics de référence, et les défenses concrètes (DP, secure aggregation, output filtering). Pour le pendant membership inference : membership inference attack. Pour l'embedding inversion en pratique : pentester base vectorielle.

Mental model : le modèle comme oracle inversible

Un modèle ML/LLM est, du point de vue théorique, une fonction apprise sur un dataset. La question de l'inversion est : peut-on inverser cette fonction pour remonter aux données d'entraînement ?

Pour la majorité des modèles ML et LLMs en 2026, la réponse est partiellement oui, avec des nuances importantes selon :

• L'accès : black-box (API uniquement) vs white-box (poids accessibles) vs gray-box (logits/gradients).
• La taille du training set : plus petit = plus de mémorisation par exemple = inversion plus facile.
• La taille du modèle : plus grand = plus de capacité de mémorisation (Carlini 2022 scaling law).
• Les défenses appliquées : DP, regularization, secure aggregation, etc.

Info — Catégorie OWASP : LLM02 Sensitive Information Disclosure. RGPD : Articles 5, 25, 32, 33, 35. ANSSI / EU AI Act intègrent explicitement le risque dans les exigences de sécurité IA pour systèmes à haut risque.

Distinction avec classes voisines

L'inversion est plus puissante que la MIA : elle ne demande pas de candidat a priori. Elle est plus ciblée que l'extraction : elle vise les données, pas le modèle.

Cinq vecteurs documentés

Vecteur 1 — Class representative inversion (Fredrikson 2015)

Référence fondatrice : Fredrikson et al., "Model Inversion Attacks that Exploit Confidence Information and Basic Countermeasures" (CCS 2015).

Mécanique : pour un modèle de classification, l'attaquant cherche l'input qui maximise la confiance pour une classe donnée. Sur un modèle de reconnaissance faciale, cela produit un visage représentatif de la classe — souvent reconnaissable comme une personne réelle du training set.

# Pseudocode class representative attack (vision-style, transposable LLM)
def class_representative_inversion(model, target_class: int, iterations: int = 1000):
    """Reconstruit un input représentatif d'une classe via gradient ascent."""
    # Init avec input random
    x = init_random_input(model.input_shape)
    
    optimizer = AdamOptimizer(lr=0.01)
    
    for step in range(iterations):
        logits = model.forward(x)
        # Maximiser la probabilité de la classe cible
        loss = -logits[target_class] + lambda_reg * regularization(x)
        grad = compute_grad_wrt_input(loss, x)
        x = optimizer.step(x, grad)
    
    return x  # input reconstruit qui "ressemble" à la classe cible

Sur LLMs, l'équivalent existe : reconstituer un prompt type qui force le modèle à produire une catégorie de réponse mémorisée.

Vecteur 2 — Verbatim extraction (Carlini 2021)

Référence : Carlini et al., "Extracting Training Data from Large Language Models" (USENIX 2021). Détaillé dans notre article membership inference — c'est aussi un vecteur d'inversion (ne demande pas de candidat a priori).

Méthodologie : génération à haute température + filtrage par perplexité + vérification online. Permet d'extraire verbatim des fragments mémorisés.

Carlini et al. (2023) ont étendu à des modèles plus grands en exploitant les prompts répétés dans le training (le modèle mémorise mieux les répétitions). Pratique sur LLMs commerciaux par requêtes massives.

Vecteur 3 — Gradient inversion (federated learning)

Référence : Zhu et al., "Deep Leakage from Gradients" (DLG, NeurIPS 2019). Geiping et al., "Inverting Gradients - How easy is it to break privacy in federated learning?" (NeurIPS 2020).

Contexte : en federated learning (FL), chaque client calcule un gradient sur ses données locales et le transmet au serveur. Si le serveur est curieux, il peut tenter de reconstituer les données depuis les gradients reçus.

Mécanique :

def deep_leakage_from_gradients(model, target_grad, iterations=300):
    """DLG attack : reconstituer les inputs depuis les gradients."""
    # Init avec inputs aléatoires
    x_dummy = init_random_input(model.input_shape)
    y_dummy = init_random_label()
    
    optimizer = LBFGSOptimizer()
    
    for step in range(iterations):
        # Forward + backward sur les inputs candidats
        out = model.forward(x_dummy)
        loss = criterion(out, y_dummy)
        candidate_grad = compute_grads_wrt_params(loss, model)
        
        # Distance entre gradients candidats et gradients cibles
        distance = sum((g_c - g_t).pow(2).sum() for g_c, g_t in zip(candidate_grad, target_grad))
        
        # Optimiser x_dummy et y_dummy pour matcher les gradients
        x_dummy, y_dummy = optimizer.step([x_dummy, y_dummy], distance)
    
    return x_dummy, y_dummy

Zhu et al. ont démontré la reconstruction parfaite d'images individuelles. Geiping et al. ont étendu à des batches plus larges et au texte.

Mitigation principale : secure aggregation (Bonawitz et al. 2017). Le serveur ne reçoit jamais les gradients individuels — seulement leur somme cryptographiquement masquée. Combiné avec DP sur les gradients.

Vecteur 4 — Embedding inversion (Vec2Text)

Référence : Morris et al., "Text Embeddings Reveal (Almost) As Much As Text: Vec2Text" (EMNLP 2023).

Mécanique : entraîner un modèle inverse qui prend un embedding en entrée et produit le texte source. Iteratif : génération initiale + raffinement basé sur la distance d'embeddings.

# Schéma simplifié Vec2Text
def vec2text_invert(target_embedding, embedder, corrector_model, iterations=20):
    """Reconstruit le texte depuis son embedding."""
    # Génération initiale
    text = corrector_model.initial_generate(target_embedding)
    
    for _ in range(iterations):
        # Embedding du texte courant
        current_emb = embedder.embed(text)
        # Distance à la cible
        delta = target_embedding - current_emb
        # Correction du texte
        text = corrector_model.correct(text, delta)
        
        if cosine_similarity(current_emb, target_embedding) > 0.99:
            break
    
    return text

Morris et al. mesurent >90% de tokens corrects sur des textes courts (32-128 tokens) pour OpenAI ada-002 et BERT. Implication directe sur les vector DB : un dump équivaut au dump du corpus en clair.

Voir pentester base vectorielle pour le contexte vector DB.

Vecteur 5 — Generative inversion via réseau inverse

Variante moderne : entraîner un réseau d'attaque qui apprend explicitement l'inversion. Le réseau prend en entrée des outputs/logits/embeddings du modèle cible et produit des reconstructions plausibles.

Particulièrement efficace sur les modèles multi-modaux (text-to-image, image-to-text) où le réseau inverse peut exploiter la structure jointe.

# Pattern : entraîner un inverter conditionné sur les outputs
class InverterNetwork(nn.Module):
    def __init__(self, target_model_output_dim, original_input_shape):
        super().__init__()
        self.layers = nn.Sequential(
            # ... architecture qui mappe output → input
        )
    
    def forward(self, target_output):
        return self.layers(target_output)
 
# Entraînement : utiliser un dataset publique pour générer (input, output) pairs
# via le modèle cible, puis entraîner inverter sur ces paires

Recherche très active 2023-2025, particulièrement sur les attaques contre les modèles cloud propriétaires.

Cas publics et littérature

Les procès NYT vs OpenAI et GitHub Copilot class-action s'appuient en partie sur des démonstrations d'inversion verbatim : montrer qu'un modèle peut restituer des passages quasi-identiques à des contenus protégés par copyright = base technique pour litige.

Défenses concrètes

Sept couches indépendantes selon le contexte (training centralisé, FL, exposition embedding, etc.).

Couche 1 — Differential privacy

Référence : Dwork (2006), DP-SGD (Abadi et al. 2016). Mécanique détaillée dans membership inference.

Pour l'inversion :

• DP-SGD sur l'entraînement borne l'influence individuelle.
• DP sur les gradients en federated learning évite la reconstruction.
• DP sur les embeddings (récents 2023-2025) commence à apparaître.

Trade-off qualité/privacy reste le défi sur LLM frontier.

Couche 2 — Secure aggregation (federated learning)

Bonawitz et al., "Practical Secure Aggregation for Privacy-Preserving Machine Learning" (CCS 2017).

Mécanique : les gradients individuels sont masqués cryptographiquement de sorte que seule la somme soit visible au serveur. Le serveur curieux ne peut plus exécuter DLG.

Client 1 → grad_1 + mask_1  →┐
Client 2 → grad_2 + mask_2  →┼→ serveur reçoit Σ(grad + mask)
Client 3 → grad_3 + mask_3  →┘   où Σ(mask) = 0 par construction

Combinable avec DP sur les gradients individuels avant masking pour défense en profondeur.

Couche 3 — Gradient clipping + noise

Si secure aggregation n'est pas possible (centralized training, ou FL simple), au minimum :

• Per-example gradient clipping (norme bornée).
• Bruit gaussien sur les gradients agrégés.

Réduit la fidélité de l'inversion sans éliminer le risque.

Couche 4 — Output filtering

Pour les attaques de type verbatim extraction :

• Bloom filter sur n-grams du training set (cf. membership inference).
• Détection de mémorisation au runtime via perplexité comparative.
• Refus structurels sur les prompts ressemblant à du verbatim probing.

def detect_inversion_attempt(prompt: str, model) -> bool:
    """Heuristiques pour signaler un prompt d'inversion probable."""
    # 1. Prompt ressemblant à un préfixe mémorisable
    if matches_common_inversion_prefix(prompt):
        return True
    
    # 2. Très haute température demandée
    # 3. Volume de prompts similaires sur la session
    # 4. Pattern de génération suivi de filtrage perplexité côté client
    
    return False

Couche 5 — Embedding privacy (pour vector DB exposés)

Spécifique aux exposures Vec2Text :

• Chiffrement at-rest (mais inversion possible une fois déchiffrement disponible côté serveur).
• Limiter l'exposition des embeddings : ne pas les retourner aux clients qui n'en ont pas besoin.
• Adversarial embedding training : entraîner avec des perturbations pour rendre l'inversion plus difficile (recherche émergente).
• Privacy-preserving retrieval : Private Information Retrieval, recherche académique pas encore production-ready.

Couche 6 — Rate limiting et monitoring extraction

Les attaques d'inversion à grande échelle (verbatim, generative) demandent du volume. Le monitoring détecte les patterns :

• Volume anormal par compte.
• Distribution de prompts atypique.
• Demande de logits/embeddings avec haut volume.
• Patterns de génération + filtrage qui suggèrent extraction.

Cf. model extraction pour les détails monitoring.

Couche 7 — Documentation et conformité

• Registre des traitements RGPD (Article 30) : documenter le risque inversion sur données personnelles.
• DPIA : évaluation explicite du risque.
• EU AI Act : pour modèles à haut risque, traçabilité des données et défenses appliquées.
• Audits réguliers : produire et conserver les rapports d'audit inversion.

Tests d'audit model inversion

Méthodologie en 5 phases :

1. Class representative attack : appliquer Fredrikson-style sur le modèle, mesurer fidélité des reconstructions par rapport à des exemples training connus.
2. Verbatim extraction : 1000-10000 prompts à haute température + filtrage perplexité + vérification online.
3. Gradient inversion (si FL) : intercepter gradients dans une simulation et tenter reconstruction via Zhu et al. method.
4. Embedding inversion (si vector DB exposé) : Vec2Text sur sample de 100 embeddings, mesurer fidélité.
5. Documentation : AUC, exemples reconstruits, taux de succès par méthode, recommandations.

def audit_inversion(model, members_corpus: list, embeddings_sample: list = None):
    """Audit basique d'inversion."""
    results = {}
    
    # 1. Verbatim extraction
    extracted = []
    for _ in range(10000):
        completion = model.generate(prefix="", temperature=1.0, max_length=100)
        if low_perplexity(completion):
            if completion in members_corpus or any(c[:50] in completion for c in members_corpus):
                extracted.append(completion)
    results["verbatim_extracted_count"] = len(extracted)
    
    # 2. Embedding inversion si applicable
    if embeddings_sample:
        from vec2text import load_pretrained_corrector, invert_embeddings
        corrector = load_pretrained_corrector("text-embedding-3-large")
        reconstructions = invert_embeddings(embeddings_sample, corrector)
        fidelity = measure_fidelity(reconstructions, source_texts_for_embeddings)
        results["embedding_inversion_fidelity"] = fidelity
    
    return results

Mapping OWASP LLM Top 10 v2

LLM02 est la catégorie centrale. LLM08 est spécifique à l'embedding inversion (introduite v2 2025).

Mapping conformité

RGPD

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

EU AI Act

Pour modèles à haut risque (Annexe III) et GPAI (Article 53) :

• Documentation des défenses contre inversion.
• Évaluation du risque inversion sur données d'entraînement.
• Plan de mitigation et procédures d'incident.

Sectoriel

• Santé / HDS / HIPAA : DP souvent obligatoire si entraînement sur données patients.
• Finance : exigence d'auditabilité.
• Federated learning sectoriel : secure aggregation devient quasi-obligatoire (Apple, Google PATE-style).

Points clés à retenir

• Le model inversion répond à "que peut-on reconstruire du training set en n'ayant que le modèle ?". Plus puissant que MIA (qui demande un candidat a priori).
• 5 vecteurs : class representative (Fredrikson 2015), verbatim extraction (Carlini 2021), gradient leakage en FL (Zhu 2019, Geiping 2020), embedding inversion (Vec2Text Morris 2023), generative inversion.
• Cas de référence : Fredrikson 2015 (visages), Carlini 2021 (verbatim GPT-2), Zhu 2019 (DLG en FL), Morris 2023 (Vec2Text >90% fidélité), procès NYT vs OpenAI + GitHub Copilot.
• Défense en 7 couches : DP-SGD, secure aggregation (FL), gradient clipping + noise, output filtering (Bloom n-grams), embedding privacy, rate limiting + monitoring, documentation conformité.
• DP est nécessaire mais pas toujours suffisante sur LLM frontier — combiner avec autres couches.
• Vec2Text → équivalence dump vector DB ≈ dump corpus en clair. Non négociable sur déploiements RGPD-régis.
• OWASP : LLM02 Sensitive Information Disclosure + LLM08 Vector and Embedding Weaknesses.
• Conformité : RGPD (Art. 5/25/32/33/35), EU AI Act Article 53 (GPAI), HDS/HIPAA sectoriel.
• Audit minimum : verbatim extraction (10000 prompts) + embedding inversion test si applicable + class representative si modèle classification.

Le model inversion n'est pas une attaque exotique de papier académique — c'est un risque mesurable, documenté en jurisprudence en cours (NYT vs OpenAI, GitHub Copilot), et défendable techniquement (DP, secure aggregation, output filtering). Le travail défensif est de mesurer le risque, le documenter, le réduire — pas de prétendre l'éliminer.