Passe à Flower 1.0

Note

This guide is for users who have already worked with Flower 0.x and want to upgrade to Flower 1.0. Newer versions of Flower (1.13 and later) are based on a new architecture and not covered in this guide. After upgrading Flower 0.x projects to Flower 1.0, please refer to Upgrade to Flower 1.13 to make your project compatible with the lastest version of Flower.

Flower 1.0 est arrivé. En plus de nouvelles fonctionnalités, Flower 1.0 fournit une base stable pour la croissance future. Par rapport à Flower 0.19 (et aux autres versions de la série 0.x), il y a quelques changements qui nécessitent de modifier le code des projets de la série 0.x existants.

Installer la mise à jour

Voici comment mettre à jour une installation existante vers Flower 1.0 en utilisant soit pip soit Poetry :

  • pip : ajoute -U lors de l’installation.

    • python -m pip install -U flwr (lors de l’utilisation de start_server et start_client)

    • python -m pip install -U 'flwr[simulation]' (lors de l’utilisation de start_simulation)

  • Poetry : mettez à jour la dépendance flwr dans pyproject.toml puis réinstallez (n’oubliez pas de supprimer poetry.lock via rm poetry.lock avant d’exécuter poetry install).

    • flwr = "^1.0.0" (lors de l’utilisation de start_server et start_client)

    • flwr = { version = "^1.0.0", extras = ["simulation"] } (lors de l’utilisation de start_simulation)

Changements nécessaires

Les changements de rupture suivants nécessitent des mises à jour manuelles.

Généralités

Passe tous les arguments comme des arguments de mots-clés (et non comme des arguments de position). Voici un exemple :

  • Flower 0.19 (arguments positionnels) : start_client("127.0.0.1:8080", FlowerClient())

  • Fleur 1.0 (arguments de mots-clés) : start_client(server_address="127.0.0.1:8080", client=FlowerClient())

Client

  • Sous-classes de NumPyClient : changez def get_parameters(self): en def get_parameters(self, config):

  • Sous-classes de Client : changez def get_parameters(self): en def get_parameters(self, ins : GetParametersIns):

Stratégies / démarrer_serveur / démarrer_simulation

  • Passez ServerConfig (au lieu d’un dictionnaire) à start_server et start_simulation. Voici un exemple :

    • Flower 0.19 : start_server(..., config={"num_rounds" : 3, "round_timeout" : 600.0}, ...)

    • Flower 1.0 : start_server(..., config=flwr.server.ServerConfig(num_rounds=3, round_timeout=600.0), ...)

  • Remplacer num_rounds=1 dans start_simulation par le nouveau config=ServerConfig(...) (voir point précédent)

  • Supprime le paramètre force_final_distributed_eval des appels à start_server. L’évaluation distribuée sur tous les clients peut être activée en configurant la stratégie pour échantillonner tous les clients pour l’évaluation après le dernier tour de formation.

  • Renomme les fonctions de conversion des paramètres et des tableaux :

    • parameters_to_weights –> parameters_to_ndarrays

    • Poids_à_paramètres –> Réseaux_à_paramètres

  • Initialisation de la stratégie : si la stratégie repose sur les valeurs par défaut de fraction_fit et fraction_evaluate, fixer manuellement fraction_fit et fraction_evaluate à 0.1`. Les projets qui ne créent pas manuellement une stratégie (en appelant start_server` ou ``start_simulation sans passer une instance de stratégie) doivent maintenant initialiser manuellement FedAvg avec fraction_fit et fraction_evaluate fixés à 0.1.

  • Renommer les paramètres de stratégie intégrés (par exemple, FedAvg) :

    • fraction_eval –> fraction_evaluate

    • min_eval_clients` --> ``min_evaluate_clients

    • eval_fn –> evaluate_fn

  • Renommez rnd en server_round. Cela a un impact sur plusieurs méthodes et fonctions, par exemple, configure_fit, aggregate_fit, configure_evaluate, aggregate_evaluate, et evaluate_fn.

  • Ajoute server_round et config à evaluate_fn` :

    • Flower 0.19 : def evaluate(parameters : NDArrays) -> Optional[Tuple[float, Dict[str, Scalar]]]]:

    • Flower 1.0 : def evaluate(server_round : int, parameters : NDArrays, config : Dict[str, Scalar]) -> Optional[Tuple[float, Dict[str, Scalar]]]:

Stratégies personnalisées

  • Le type du paramètre failures a changé de List[BaseException] à List[Union[Tuple[ClientProxy, FitRes], BaseException]] (dans aggregate_fit) et List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]] (dans aggregate_evaluate)

  • La méthode Stratégie évaluer` reçoit maintenant le cycle actuel d’apprentissage/évaluation fédéré comme premier paramètre :

    • Flower 0.19 : def evaluate(self, parameters : Parameters) -> Optional[Tuple[float, Dict[str, Scalar]]]]:

    • Flower 1.0 : def evaluate(self, server_round : int, parameters : Parameters) -> Optional[Tuple[float, Dict[str, Scalar]]]]:

Améliorations facultatives

En plus des changements nécessaires mentionnés ci-dessus, il existe un certain nombre d’améliorations potentielles qui viennent d’être rendues possibles :

  • Supprime les méthodes « placeholder » des sous-classes de Client ou de NumPyClient. Si tu utilises, par exemple, l’évaluation côté serveur, alors les implémentations « placeholder » de evaluate ne sont plus nécessaires.

  • Configurez le délai d’attente de la ronde via start_simulation : start_simulation(..., config=flwr.server.ServerConfig(num_rounds=3, round_timeout=600.0), ...)

Aide supplémentaire

La plupart des exemples de code Flower officiels sont déjà mis à jour vers Flower 1.0, ils peuvent servir de référence pour l’utilisation de l’API Flower 1.0. Si vous avez d’autres questions, joins le Slack Flower et utilise le canal #questions.