Utilisez la confidentialité différentielle¶
Ce guide explique comment vous pouvez utiliser la confidentialité différentielle dans le cadre de Flower. Si vous n’êtes pas encore familiarisé avec la confidentialité différentielle, vous pouvez consulter Differential Privacy (confidentialité différentielle).
Avertissement
La confidentialité différentielle dans Flower est en phase de prévisualisation. Si vous prévoyez d’utiliser ces fonctionnalités dans un environnement de production avec des données sensibles, n’hésitez pas à nous contacter pour discuter de vos besoins et recevoir des conseils sur la manière de les utiliser de manière optimale.
Confidentialité différentielle centrale¶
Cette approche consiste en deux phases séparées : le recoupage des mises à jour et l’ajout d’un bruit au modèle agrégé. Pour la phase de recoupage, le cadre Flower a rendu possible de décider si effectuer le recoupage côté serveur ou côté client.
Recoupage côté serveur : Cette approche présente l’avantage du serveur imposant un recoupage uniforme sur toutes les mises à jour des clients et réduisant la charge de communication pour les valeurs de recoupage. Cependant, elle présente également l’inconvénient d’augmenter la charge de calcul côté serveur en raison du besoin de réaliser l’opération de recoupage pour tous les clients.
Recoupage côté client : Cette approche présente l’avantage de réduire la charge de calcul côté serveur. Cependant, elle présente également l’inconvénient de manquer de contrôle centralisé, car le serveur a moins de contrôle sur le processus de recoupage.
Recoupage côté serveur¶
Pour le DP central avec éclissage côté serveur, il existe deux classes Strategy qui agissent comme des enveloppes autour de l’instance réelle Strategy (par exemple, FedAvg). Les deux classes d’enveloppe sont DifferentialPrivacyServerSideFixedClipping et DifferentialPrivacyServerSideAdaptiveClipping pour l’éclissage fixe et adaptatif.
L’exemple de code ci-dessous permet la stratégie FedAvg d’utiliser l’éclissage côté serveur avec éclissage fixe en utilisant la classe d’enveloppe DifferentialPrivacyServerSideFixedClipping. La même approche peut être utilisée avec DifferentialPrivacyServerSideAdaptiveClipping en ajustant les paramètres d’entrée correspondants.
from flwr.serverapp.strategy import DifferentialPrivacyClientSideFixedClipping, FedAvg
# Create the strategy
strategy = FedAvg(...)
# Wrap the strategy with the DifferentialPrivacyServerSideFixedClipping wrapper
dp_strategy = DifferentialPrivacyServerSideFixedClipping(
strategy,
cfg.noise_multiplier,
cfg.clipping_norm,
cfg.num_sampled_clients,
)
Recoupage côté client¶
Pour le DP central avec éclissage côté client, le serveur envoie la valeur d’éclissage aux clients sélectionnés à chaque tour. Les clients peuvent utiliser l’existant Flower Mods pour effectuer l’éclissage. Deux mods sont disponibles pour l’éclissage fixe et adaptatif côté client : fixedclipping_mod et adaptiveclipping_mod avec les enveloppes correspondantes côté serveur DifferentialPrivacyClientSideFixedClipping et DifferentialPrivacyClientSideAdaptiveClipping.
L’exemple de code ci-dessous permet la stratégie FedAvg d’utiliser la vie privée différentielle avec l’éclissage fixe côté client en utilisant à la fois la classe d’enveloppe DifferentialPrivacyClientSideFixedClipping et, sur le client, fixedclipping_mod:
from flwr.serverapp.strategy import DifferentialPrivacyClientSideFixedClipping, FedAvg
# Create the strategy
strategy = FedAvg(...)
# Wrap the strategy with the DifferentialPrivacyClientSideFixedClipping wrapper
dp_strategy = DifferentialPrivacyClientSideFixedClipping(
strategy,
cfg.noise_multiplier,
cfg.clipping_norm,
cfg.num_sampled_clients,
)
En plus du wrapper de stratégie côté serveur, il faut configurer le ClientApp pour configurer le fixedclipping_mod correspondant pour effectuer l’éclissage côté client :
from flwr.clientapp import ClientApp
from flwr.clientapp.mod import fixedclipping_mod
# Add fixedclipping_mod to the client-side mods
app = ClientApp(mods=[fixedclipping_mod])
Confidentialité locale¶
Pour utiliser la confidentialité différentielle locale (DP) et ajouter du bruit aux paramètres du modèle client avant de les transmettre au serveur dans Flower, vous pouvez utiliser le LocalDpMod. Les hyperparamètres suivants doivent être définis : valeur de norme de recoupage, sensibilité, epsilon et delta.
Voici un exemple de code qui montre comment utiliser LocalDpMod:
Note
Appliquez le mod uniquement aux fonctions qui en ont besoin. Par exemple, pour utiliser la confidentialité différentielle locale lors de l’entraînement, ajoutez le mod à la fonction d’entraînement avec @app.train(mods=[your_mod]). Évitez d’y ajouter directement avec ClientApp et ClientApp(mods=[your_mod]), car cela applique le mod à toutes les fonctions (y compris l’évaluation), ce qui est généralement inutile et source d’erreurs.
from flwr.clientapp import ClientApp
from flwr.clientapp.mod import LocalDpMod
# Initialize the client app
app = ClientApp()
# Create an instance of the mod with the required params
local_dp_obj = LocalDpMod(cfg.clipping_norm, cfg.sensitivity, cfg.epsilon, cfg.delta)
# Add the mod to your training function
@app.train(mods=[local_dp_obj])
def train(message, context):
# Client-side training logic
...
Notez que l’ordre des mods, en particulier ceux qui modifient les paramètres, est important lorsqu’on utilise plusieurs mods. En général, les mods de confidentialité différentielle (DP) devraient être les derniers à opérer sur les paramètres.
Formation locale utilisant les moteurs de confidentialité¶
Pour garantir la confidentialité des instances de données pendant l’entraînement local du modèle côté client, envisagez d’utiliser des moteurs de confidentialité tels que Opacus. Pour des exemples d’utilisation de Flower avec ces moteurs, veuillez vous référer au répertoire d’exemples de Flower (Opacus).