LEA: Label Enumeration Attack in Vertical Federated Learning

Cet article présente LEA, une nouvelle attaque par énumération d'étiquettes dans l'apprentissage fédéré vertical qui, contrairement aux méthodes existantes, fonctionne dans divers scénarios sans données auxiliaires en utilisant la similarité des gradients de perte pour identifier les étiquettes, tout en surmontant les défis de calcul grâce à une version optimisée (Binary-LEA) et en résistant aux mécanismes de défense courants.

L'essentiel

🕵️‍♂️ Le Scénario : Une Cuisine Collaborative

Imaginez que vous êtes dans une cuisine géante où plusieurs chefs (les participants) travaillent ensemble pour créer un plat délicieux (un modèle d'intelligence artificielle).

• Le Chef A (la partie "Active") possède la recette secrète et, surtout, il sait à quoi le plat doit ressembler une fois fini (les étiquettes ou labels). C'est lui qui détient l'information sensible.
• Les Chefs B, C, D... (les parties "Passives") apportent chacun des ingrédients différents (des données ou features). Le Chef B apporte des légumes, le Chef C des épices, etc.

L'objectif est de cuisiner ensemble sans que le Chef A ait besoin de voir les ingrédients des autres, et sans que les autres chefs ne voient la recette finale ou le goût exact du plat. C'est ce qu'on appelle l'Apprentissage Fédéré Vertical (VFL).

🚨 Le Problème : Le Voleur dans la Cuisine

Le papier de recherche décrit une nouvelle façon pour un chef passif (disons le Chef B) de voler la recette secrète du Chef A, sans avoir besoin d'aucune aide extérieure.

Jusqu'à présent, les voleurs devaient avoir un "échantillon de cuisine" (des données étiquetées) pour comparer et deviner. Mais cette nouvelle attaque, appelée LEA (Attaque par Énumération d'Étiquettes), fonctionne même si le voleur n'a rien d'autre que ses propres ingrédients.

🧠 L'Idée Géniale : Le Jeu des Clusters

Voici comment l'attaque fonctionne, étape par étape, avec une analogie simple :

1. Le Tri des Ingrédients (Le Clustering) :
   Le Chef B (le voleur) regarde ses propres légumes. Même sans savoir ce qu'ils vont devenir, il remarque qu'ils se ressemblent par groupes. Il les trie en plusieurs tas : "Tas de légumes verts", "Tas de légumes rouges", "Tas de légumes racines".
   En langage technique : Il regroupe ses données en "clusters" basés sur leurs similitudes.

2. La Devinette des Permutations (L'Énumération) :
   Le Chef B sait qu'il y a, disons, 3 types de plats possibles (Pizza, Burger, Salade). Il ne sait pas quel tas de légumes correspond à quel plat.
   Alors, il fait une hypothèse folle : il imagine toutes les combinaisons possibles.

   • Hypothèse 1 : Les verts = Pizza, Les rouges = Burger, Les racines = Salade.
   • Hypothèse 2 : Les verts = Burger, Les rouges = Pizza, Les racines = Salade.
   • ...et ainsi de suite pour toutes les combinaisons.

3. La Simulation (L'Entraînement) :
   Pour chaque hypothèse, le Chef B construit un petit "faux chef" (un modèle simulé) et lui fait cuisiner avec ses hypothèses. Il regarde comment ce faux chef réagit quand il envoie le résultat au Chef A.

4. Le Test de Ressemblance (La Similarité) :
   C'est ici que la magie opère. Le Chef B compare la réaction de ses "faux chefs" avec la réaction du vrai chef qui travaille réellement avec le Chef A.

   • Si le "faux chef" qui a deviné la bonne combinaison (Hypothèse 1) réagit exactement comme le vrai chef, alors c'est gagné ! Le voleur a trouvé la correspondance.
   • L'astuce technique : Au lieu de comparer les ingrédients finaux (qui peuvent être différents), ils comparent la première réaction (le gradient de perte) dès le début de la cuisson. C'est comme comparer le premier mouvement de main : si le mouvement est identique, c'est la même personne.

⚡ Le Problème de la Vitesse : Le Facteur "Ouf !"

Il y a un gros problème : si vous avez 10 types de plats, le nombre de combinaisons possibles est énorme (3 628 800 !). Tester toutes ces combinaisons prendrait des années. C'est comme essayer de trouver la bonne combinaison d'un cadenas à 10 chiffres en essayant chaque chiffre un par un.

La Solution : L'Attaque Binaire (Binary-LEA)
Les auteurs ont trouvé un moyen de tricher intelligemment. Au lieu de deviner les 10 plats d'un coup, ils les divisent en petits duos.

• Ils comparent d'abord "Pizza vs Burger".
• Ensuite "Salade vs Soupe".
• En combinant ces petits duos, ils réduisent le travail colossal à quelque chose de gérable.
• Résultat : Au lieu de devoir faire des milliards d'essais, ils n'en font que quelques milliers. C'est passer de "toute une vie" à "quelques heures".

🛡️ Peut-on se défendre ?

Les chercheurs ont testé les boucliers habituels :

1. Le Bruit (Gradient Noise) : Ajouter du "grésillement" aux messages envoyés. Résultat : Le voleur arrive toujours à entendre la bonne mélodie, même avec un peu de bruit.
2. La Compression : Envoyer moins d'informations. Résultat : Le voleur arrive toujours à reconstituer le message.
3. Le Nouveau Bouclier (Table de Correspondance) : Le Chef A change les noms des plats (au lieu de dire "Pizza", il dit "X").
   • Efficacité : Ça marche bien si le voleur n'a aucune information.
   • Faiblesse : Si le voleur a un tout petit peu d'aide (quelques étiquettes volées) ou si certains plats sont beaucoup plus rares que d'autres, il peut deviner le code.

🎯 En Résumé

Ce papier nous dit que dans l'apprentissage collaboratif, le simple fait de trier ses propres données suffit souvent à deviner les secrets des autres, même sans avoir d'exemples préalables.

C'est comme si, en regardant simplement la façon dont vous triez vos chaussettes (paires blanches, paires noires), un voleur pouvait deviner votre emploi du temps secret, simplement en observant comment vous réagissez quand on vous demande de faire un choix.

La leçon : La vie privée dans ces systèmes collaboratifs est plus fragile qu'on ne le pensait, et il faut inventer de nouvelles façons de protéger les étiquettes (les secrets) bien plus robustes que les méthodes actuelles.

Résumé technique

1. Problématique

L'Apprentissage Fédéré Vertical (VFL) est un paradigme où plusieurs participants collaborent pour entraîner un modèle, chaque partie possédant des caractéristiques (features) différentes pour les mêmes échantillons, tandis qu'une seule partie (la partie active) détient les étiquettes (labels). Bien que le VFL soit conçu pour protéger la confidentialité des données brutes et des étiquettes, il reste vulnérable aux attaques d'inférence.

Les travaux antérieurs sur les attaques d'inférence d'étiquettes dans le VFL souffrent de limitations majeures :

• Ils sont souvent restreints à des scénarios spécifiques (par exemple, uniquement AggVFL ou SplitVFL).
• Ils nécessitent fréquemment des données auxiliaires (un petit ensemble de données étiquetées) pour fonctionner efficacement.
• Ils peinent à s'adapter aux applications réelles où l'adversaire (partie passive) n'a accès à aucune donnée étiquetée.

L'objectif de cet article est de combler ces lacunes en proposant une attaque capable de révéler les étiquettes sensibles de la partie active sans aucune donnée auxiliaire, et ce, dans divers scénarios VFL.

2. Méthodologie : L'Attaque par Énumération d'Étiquettes (LEA)

L'attaque proposée, nommée LEA (Label Enumeration Attack), repose sur l'hypothèse que les données locales d'une partie passive sont intrinsèquement classifiables (c'est-à-dire qu'elles contiennent une structure sous-jacente permettant de regrouper les échantillons).

Le processus d'attaque se déroule en plusieurs étapes clés :

A. Prémisse et Clustering

L'adversaire (partie passive) effectue un clustering non supervisé sur ses propres données locales pour regrouper les échantillons en $n$ clusters (où $n$ est le nombre de classes d'étiquettes). L'idée est que chaque cluster correspondra à une classe d'étiquettes spécifique.

B. Énumération et Simulation

Puisque l'adversaire ne connaît pas la correspondance réelle entre les clusters et les étiquettes, il procède par énumération :

1. Il génère toutes les permutations possibles des $n$ étiquettes ($n!$ permutations).
2. Pour chaque permutation, il attribue les étiquettes aux clusters correspondants, créant ainsi $n!$ jeux de données simulés étiquetés.
3. Il copie son modèle local $n!$ fois pour créer des modèles simulés, chacun étant entraîné sur une permutation d'étiquettes différente.

C. Évaluation de la Similarité (Le Cœur de l'Attaque)

Pour identifier quelle permutation correspond à la vérité terrain, l'adversaire compare les modèles simulés au modèle entraîné lors de la formation fédérale réelle (le modèle "benin").

• Défi : Comparer les poids finaux des modèles est inefficace car des modèles entraînés sur les mêmes données peuvent converger vers des minima locaux différents avec des poids très dissemblables.
• Solution proposée : L'attaque se base sur la similarité des gradients de perte de la première round (première itération).
  • L'adversaire calcule le gradient de perte de son modèle lors de la formation réelle.
  • Il compare ce gradient avec ceux générés par chaque modèle simulé (après une seule itération d'entraînement sur les données simulées).
  • La métrique utilisée est la similarité cosinus. Le modèle simulé dont le gradient de la première round présente la plus forte similarité cosinus avec le gradient réel est identifié comme le modèle d'attaque correct.

D. Optimisation : Binary-LEA

L'énumération de $n!$ permutations devient rapidement ingérable (complexité factorielle $O(n!)$). Pour résoudre ce problème, les auteurs proposent Binary-LEA :

• L'attaque transforme le problème de classification multiclasse en une série de tâches de classification binaire.
• Au lieu d'énumérer toutes les permutations, l'adversaire sélectionne deux clusters à la fois et énumère les permutations pour ces deux classes uniquement.
• Cela réduit la complexité computationnelle de $O(n!)$ à $O(n^3)$, rendant l'attaque réalisable même pour un grand nombre de classes (ex: MNIST avec 10 classes).

3. Contributions Clés

1. Nouvelle Attaque Sans Données Auxiliaires : LEA est la première attaque d'inférence d'étiquettes dans le VFL qui ne nécessite aucun jeu de données étiqueté auxiliaire. Elle repose uniquement sur le clustering des données locales de l'adversaire.
2. Applicabilité Universelle : L'attaque fonctionne aussi bien dans les scénarios AggVFL (modèle global non entraînable, fonction d'agrégation) que SplitVFL (modèle global entraînable, parties du modèle réparties). Elle est efficace sur des modèles de régression logistique et des réseaux de neurones.
3. Méthode de Similarité Innovante : Introduction d'une mesure de similarité basée sur les gradients de la première round plutôt que sur les paramètres finaux, offrant une meilleure précision et une détection plus rapide du modèle correct.
4. Optimisation Algorithmique (Binary-LEA) : Réduction drastique de la complexité computationnelle de $O(n!)$ à $O(n^3)$, permettant l'application de l'attaque sur des tâches multiclasse complexes.
5. Évaluation des Défenses : Analyse rigoureuse de l'efficacité des mécanismes de défense existants (bruit de gradient, compression) et proposition d'une nouvelle stratégie de défense basée sur une table de correspondance d'étiquettes.

4. Résultats Expérimentaux

Les expériences ont été menées sur des jeux de données réels (Breast Cancer, Give-me-some-credit, MNIST) dans des configurations à deux et plusieurs parties.

• Précision de l'Attaque :
  • Sans données auxiliaires, LEA améliore la précision d'attaque de 50 % à 90 % par rapport aux méthodes de l'état de l'art (comme l'achèvement de modèle passif - PMC).
  • Sur les tâches binaires, la précision d'attaque (ASR) dépasse souvent 0,90 (90 %).
  • Sur les tâches multiclasse (MNIST-10), la précision reste supérieure à 0,80 même avec Binary-LEA.
• Impact du Clustering : La réussite de l'attaque est directement corrélée à la précision du clustering. Si les données locales permettent un bon regroupement, l'attaque réussit même avec un faible pourcentage de caractéristiques locales.
• Coût Computationnel :
  • Pour MNIST-10, l'approche brute-force (LEA standard) nécessiterait environ 3 ans de temps de calcul.
  • L'approche Binary-LEA réduit ce temps à environ 4924 secondes (moins de 1h20), démontrant la viabilité pratique de l'optimisation.
• Résistance aux Défenses :
  • Bruit de Gradient (Laplace) : L'ajout de bruit n'empêche pas l'attaque tant que le bruit ne modifie pas l'ordre de grandeur de la similarité des gradients.
  • Compression de Gradient : L'attaque reste efficace même avec une compression partielle, car l'information de la première round conserve la structure nécessaire.
  • Table de Correspondance : Une défense basée sur une permutation aléatoire des étiquettes (mapping table) est efficace uniquement si l'adversaire n'a aucune donnée auxiliaire et si la distribution des étiquettes est équilibrée. Si l'adversaire possède un petit ensemble de données étiquetées ou si les classes sont déséquilibrées, cette défense échoue.

5. Signification et Conclusion

Cet article met en lumière une vulnérabilité critique dans les systèmes VFL : la confidentialité des étiquettes n'est pas garantie par le simple fait de ne pas partager les données brutes. L'attaque LEA démontre qu'un adversaire passif, disposant de données structurées mais non étiquetées, peut reconstruire les étiquettes sensibles de la partie active en exploitant la structure intrinsèque de ses propres données.

Implications :

• Les mécanismes de défense actuels (bruit, compression) sont insuffisants contre ce type d'attaque.
• La sécurité du VFL nécessite de nouvelles approches, car l'hypothèse de sécurité "honnête mais curieux" est compromise par des méthodes d'inférence basées sur le clustering et l'énumération.
• Les auteurs appellent à une recherche plus approfondie sur les contre-mesures robustes, soulignant l'urgence de protéger la vie privée des étiquettes dans les applications industrielles de l'IA collaborative.