DifferentialPrivacyClientSideAdaptiveClipping

class DifferentialPrivacyClientSideAdaptiveClipping(strategy: Strategy, noise_multiplier: float, num_sampled_clients: int, initial_clipping_norm: float = 0.1, target_clipped_quantile: float = 0.5, clip_norm_lr: float = 0.2, clipped_count_stddev: float | None = None)

Bases : Strategy

Wrapper stratégique pour le DP centralisé avec une éclissure client adaptative.

Utiliser le modificateur adaptiveclipping_mod côté client.

En comparaison avec DifferentialPrivacyServerSideAdaptiveClipping, qui effectue la mise au carré sur le serveur, DifferentialPrivacyClientSideAdaptiveClipping attend que la mise au carré se produise côté client, généralement en utilisant le modificateur intégré adaptiveclipping_mod.

Paramètres:

• strategy (Strategy) – La stratégie à laquelle les fonctionnalités de DP seront ajoutées par ce wrapper.

• noise_multiplier (float) – Le multiplicateur de bruit pour la mécanique gaussienne pour les mises à jour du modèle.

• num_sampled_clients (int) – Le nombre de clients échantillonnés à chaque tour.

• initial_clipping_norm (float) – La valeur initiale de la norme de mise au carré. Par défaut à 0,1. Andrew et al. recommande d’y fixer 0,1.

• target_clipped_quantile (float) – Le quantile souhaité des mises à jour qui doivent être mis au carré. Par défaut à 0,5.

• clip_norm_lr (float) – La vitesse d’apprentissage pour l’adaptation de la norme de clipping. Par défaut, 0,2. Andrew et al. recommandent de fixer à 0,2.

• clipped_count_stddev (float) – L’écart-type du bruit ajouté au nombre d’actualisations actuellement inférieur à l’estimation. Andrew et al. recommandent de fixer à expected_num_records/20

Exemples

Créez une stratégie:

strategy = fl.server.strategy.FedAvg(...)

Enveloppez la stratégie avec le wrapper DifferentialPrivacyClientSideAdaptiveClipping:

dp_strategy = DifferentialPrivacyClientSideAdaptiveClipping(
    strategy, cfg.noise_multiplier, cfg.num_sampled_clients
)

Sur le client, ajoutez le adaptiveclipping_mod aux mods côté-client:

app = fl.client.ClientApp(
    client_fn=client_fn, mods=[adaptiveclipping_mod]
)

Methods

aggregate_evaluate(server_round, results, ...)	Aggregate evaluation losses using the given strategy.
aggregate_fit(server_round, results, failures)	Aggregate training results and update clip norms.
configure_evaluate(server_round, parameters, ...)	Configure the next round of evaluation.
configure_fit(server_round, parameters, ...)	Configure le prochain tour d'entraînement.
evaluate(server_round, parameters)	Evaluate model parameters using an evaluation function from the strategy.
initialize_parameters(client_manager)	Initialize global model parameters using given strategy.

aggregate_evaluate(server_round: int, results: list[tuple[ClientProxy, EvaluateRes]], failures: list[tuple[ClientProxy, EvaluateRes] | BaseException]) → tuple[float | None, dict[str, bool | bytes | float | int | str]]

Aggregate evaluation losses using the given strategy.

aggregate_fit(server_round: int, results: list[tuple[ClientProxy, FitRes]], failures: list[tuple[ClientProxy, FitRes] | BaseException]) → tuple[Parameters | None, dict[str, bool | bytes | float | int | str]]

Aggregate training results and update clip norms.

configure_evaluate(server_round: int, parameters: Parameters, client_manager: ClientManager) → list[tuple[ClientProxy, EvaluateIns]]

Configure the next round of evaluation.

configure_fit(server_round: int, parameters: Parameters, client_manager: ClientManager) → list[tuple[ClientProxy, FitIns]]

Configure le prochain tour d’entraînement.

evaluate(server_round: int, parameters: Parameters) → tuple[float, dict[str, bool | bytes | float | int | str]] | None

Evaluate model parameters using an evaluation function from the strategy.

initialize_parameters(client_manager: ClientManager) → Parameters | None

Initialize global model parameters using given strategy.