Use strategies#
Flower permet une personnalisation complète du processus d’apprentissage grâce à l’abstraction Stratégie
. Un certain nombre de stratégies intégrées sont fournies dans le cadre principal.
Il y a trois façons de personnaliser la manière dont Flower orchestre le processus d’apprentissage du côté du serveur :
Utilise une stratégie existante, par exemple
FedAvg
Personnalise une stratégie existante avec des fonctions de rappel
Mets en place une nouvelle stratégie
Utilise une stratégie existante#
Flower intègre un certain nombre de stratégies d’apprentissage fédéré populaires. Une stratégie intégrée peut être instanciée comme suit :
import flwr as fl
strategy = fl.server.strategy.FedAvg()
fl.server.start_server(config=fl.server.ServerConfig(num_rounds=3), strategy=strategy)
Cela crée une stratégie dont tous les paramètres sont laissés à leur valeur par défaut et la transmet à la fonction start_server
. Il est généralement recommandé d’ajuster quelques paramètres lors de l’instanciation :
import flwr as fl
strategy = fl.server.strategy.FedAvg(
fraction_fit=0.1, # Sample 10% of available clients for the next round
min_fit_clients=10, # Minimum number of clients to be sampled for the next round
min_available_clients=80, # Minimum number of clients that need to be connected to the server before a training round can start
)
fl.server.start_server(config=fl.server.ServerConfig(num_rounds=3), strategy=strategy)
Personnalise une stratégie existante avec des fonctions de rappel#
Les stratégies existantes offrent plusieurs façons de personnaliser leur comportement. Les fonctions de rappel permettent aux stratégies d’appeler le code fourni par l’utilisateur pendant l’exécution.
Configurer l’adaptation et l’évaluation du client#
Le serveur peut transmettre de nouvelles valeurs de configuration au client à chaque tour en fournissant une fonction à on_fit_config_fn
. La fonction fournie sera appelée par la stratégie et doit renvoyer un dictionnaire de paires de valeurs de clés de configuration qui seront envoyées au client. Elle doit renvoyer un dictionnaire de valeurs de configuration arbitraires client.fit
et client.evaluate
au cours de chaque tour d’apprentissage fédéré.
import flwr as fl
def get_on_fit_config_fn() -> Callable[[int], Dict[str, str]]:
"""Return a function which returns training configurations."""
def fit_config(server_round: int) -> Dict[str, str]:
"""Return a configuration with static batch size and (local) epochs."""
config = {
"learning_rate": str(0.001),
"batch_size": str(32),
}
return config
return fit_config
strategy = fl.server.strategy.FedAvg(
fraction_fit=0.1,
min_fit_clients=10,
min_available_clients=80,
on_fit_config_fn=get_on_fit_config_fn(),
)
fl.server.start_server(config=fl.server.ServerConfig(num_rounds=3), strategy=strategy)
Le on_fit_config_fn
peut être utilisé pour passer des valeurs de configuration arbitraires du serveur au client, et changer poétiquement ces valeurs à chaque tour, par exemple pour ajuster le taux d’apprentissage. Le client recevra le dictionnaire renvoyé par le on_fit_config_fn
dans sa propre fonction client.fit()
.
Comme pour on_fit_config_fn
, il existe aussi on_evaluate_config_fn
pour personnaliser la configuration envoyée à client.evaluate()
Configuration de l’évaluation côté serveur#
L’évaluation côté serveur peut être activée en passant une fonction d’évaluation à evaluate_fn
.
Mets en place une nouvelle stratégie#
Writing a fully custom strategy is a bit more involved, but it provides the most flexibility. Read the Implementing Strategies guide to learn more.