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#

L’écriture d’une stratégie entièrement personnalisée est un peu plus complexe, mais c’est celle qui offre le plus de souplesse. Lis le guide Implémentation des stratégies pour en savoir plus.