Écrivez votre première application Flower

Bienvenue dans la deuxième partie de la tutorial d’intelligence artificielle collaborative de Flower !

Dans le tutoriel précédent, vous avez créé votre première fédération sur SuperGrid à l’aide du Simulation Runtime. Cela vous a permis d’expérimenter avec des nœuds Super simulés, d’exécuter une application Flower existante sur SuperGrid et d’explorer l’interface de dashboard pour suivre son progression et visualiser ses journaux.

Dans ce tutoriel, vous allez récupérer l’application @flwrlabs/demo depuis Flower Hub et l’exécuter sur SuperGrid à partir de votre machine locale. Vous allez ensuite faire une petite modification au ServerApp, exécuter l’application à nouveau, et confirmer dans les journaux de SuperGrid que vos messages personnalisés sont maintenant partie intégrante du comportement de l’application. Dans la deuxième moitié du tutoriel, vous allez revenir sur le flux de travail pratique pour obtenir une introduction de haut niveau aux principaux composants d’une application Flower et voir, dans des termes concrets, comment l’exemple d’application utilise ces composants ensemble.

Astuce

Star Flower on GitHub ⭐️ et rejoignez la communauté Flower sur Flower Discuss ou Flower Slack pour vous présenter, poser des questions et obtenir de l’aide.

Allons-y ! 🌼

Préparation

Dans ce tutoriel, vous allez modifier le code d’une application Flower existante que vous allez récupérer depuis la plateforme Flower Hub. Pour cela, vous devez installer flwr, le package Python de Flower. Voici une brève guide sur la façon dont il faut procéder :

Installation des dépendances

Tout d’abord, nous installons le paquet Flower flwr dans un nouvel environnement Python.

$ pip install -U "flwr[simulation]"

Ensuite, utilisez flwr new pour récupérer une application Flower existante depuis la plateforme Flower Hub. Dans ce cas, vous allez récupérer l’application @flwrlabs/demo.

$ flwr new @flwrlabs/demo

Après avoir exécuté le code, vous remarquerez qu’un nouveau répertoire nommé demo a été créé dans le répertoire où vous avez exécuté la commande précédente. Il devrait avoir la structure suivante :

demo
├── quickstart_numpy
│   ├── __init__.py
│   ├── client_app.py   # Defines your ClientApp
│   ├── server_app.py   # Defines your ServerApp
│   └── task.py         # Defines your model, training and data loading
├── pyproject.toml      # Project metadata like dependencies and configs
└── README.md

Vous y êtes arrivé ! Vous avez récupéré une application Flower existante depuis la plateforme Flower Hub. Ouvrez le répertoire demo dans votre éditeur de code préféré, puis passez à la section suivante pour apprendre comment exécuter cette application sur SuperGrid. Plus tard, vous allez apprendre les composants clés d’une application Flower.

Exécutez l’application sur SuperGrid

Note

Si vous n’avez pas déjà fait cela, assurez-vous de compléter le first tutorial in this series pour configurer votre compte SuperGrid et exécuter une démo directement depuis la plateforme Flower Hub.

Dans le tutoriel précédent, vous avez exécuté la démo directement depuis la plateforme Flower Hub. Maintenant que vous avez le code de l’application sur votre machine, vous pouvez l’exécuter à partir-là plutôt qu’à partir de la plateforme. C’est un pas crucial pour personnaliser l’application et la rendre vôtre.

Ouvrez une fenêtre de terminal, activez votre environnement Python et exécutez la commande suivante pour vous connecter à SuperGrid :

# This will open a browser window where you can enter your SuperGrid credentials.
$ flwr login supergrid

Une fois que vous êtes connecté, exécutez la commande suivante pour exécuter l’application sur SuperGrid et dans la fédération que vous avez créée dans le tutoriel précédent :

# Navigate to the directory of the app you want to run
$ cd /path/to/demo
# Run the app across the federation you created in the previous tutorial
$ flwr run . supergrid --federation @<username>/<federation-name>
# for example
# flwr run . supergrid --federation @peter123/my-first-federation

Ensuite, si vous naviguez vers le répertoire SuperGrid dashboard, vous devriez voir une nouvelle exécution dans la liste des exécutions de votre fédération. Cliquez dessus pour voir les détails et les journaux.

Si vous inspectez les journaux, vous devriez voir le même résultat que lorsque vous avez exécuté l’application directement depuis la plateforme Flower Hub dans le tutoriel précédent. C’est parce que vous exécutez exactement la même application. Dans la section suivante, nous allons faire une petite modification à l’application qui se reflétera dans les journaux et la rendra vôtre !

Personnalisez votre Application

Maintenant que vous avez l’application en cours d’exécution sur SuperGrid, vous pouvez commencer à la personnaliser. Dans ce tutoriel, vous allez faire une petite modification au ServerApp pour imprimer un message avant le début de l’apprentissage fédéré et juste avant que l’application se ferme. Ouvrez le répertoire demo dans votre éditeur de code préféré et ouvrez le fichier quickstart_numpy/server_app.py. Ensuite, ajoutez les deux lignes suivantes à la fonction main():

@app.main()
def main(grid: Grid, context: Context) -> None:
    """Main entry point for the ServerApp."""

    print("👋 Hello from the ServerApp! This is a custom message that I added.")
    # Read run config
    num_rounds: int = context.run_config["num-server-rounds"]

    # Load global model
    model = get_dummy_model()
    arrays = ArrayRecord(model)

    # Initialize FedAvg strategy
    strategy = FedAvg()

    # Start strategy, run FedAvg for `num_rounds`
    result = strategy.start(
        grid=grid,
        initial_arrays=arrays,
        num_rounds=num_rounds,
    )
    print("Goodbye from the ServerApp! This is my first custom Flower App 🚀!")

Si vous exécutez à nouveau l’application, vous devriez voir les nouveaux messages dans les journaux de votre exécution sur SuperGrid :

# Run your app
$ flwr run . supergrid --federation @<username>/<federation-name>

Ensuite, si vous naviguez vers le SuperGrid dashboard, et ouvrez les journaux de la nouvelle exécution, vous devriez voir les nouveaux messages imprimés du ServerApp au début et à la fin des journaux.

Vous y êtes arrivé ! Vous avez réussi à personnaliser une application Flower existante et l’avez exécutée sur SuperGrid. Jusqu’à présent, vous avez appris deux commandes puissantes de Flower (flwr new et flwr run) qui vous permettent de récupérer des applications existantes depuis la plateforme Flower Hub et les exécuter sur SuperGrid. flwr new est une excellente façon de commencer avec une nouvelle application que vous pouvez personnaliser pour vos besoins.

Dans la section suivante, vous allez apprendre les composants principaux d’une application Flower et comment ils fonctionnent ensemble, en utilisant l’application démo comme exemple concret.

Composants d’une Application Flower

Toutes les applications Flower suivent la même structure de base, conçue pour être flexible et suffisamment puissante pour supporter une large gamme de charges de travail collaborative AI, y compris l’apprentissage fédéré, l’analyse fédérée, le formation distribuée et plus encore. Les composants principaux d’une application Flower sont :

• ServerApp: l’entrée serveur pour une exécution. Dans un cadre d’apprentissage fédéré typique, il définit comment l’exécution commence, quel modèle initial est utilisé, quelle stratégie contrôle le processus d’apprentissage fédéré et combien de tours à exécuter. Une application Flower peut également être construite avec une stratégie personnalisée ou sans stratégie du tout.

• ClientApp: le code qui s’exécute sur chaque client (SuperNode). Il définit ce qui doit se passer lorsque un SuperNode reçoit des instructions du côté serveur, par exemple « entraînez ce modèle sur vos données locales » ou « évaluez ce modèle sur vos données locales » ou, en général, « faites x avec vos données locales ».

• pyproject.toml: le fichier de configuration de l’application. Il déclare les métadonnées du projet et les dépendances, indique au Flower où importer les ServerApp et les ClientApp, et stocke la configuration d’exécution (par exemple, les hyperparamètres) que l’application peut lire en temps réel.

En résumé, vous pouvez penser du ServerApp comme le lieu où l’exécution fédérée est lancée, du Strategy comme l’algorithme qui coordonne chaque tour, et du ClientApp comme le code que chaque participant SuperNode exécute. Le ServerApp et le ClientApp échangent des objets Message à travers le SuperGrid. En fonction de la logique de l’application, ces messages peuvent contenir des instructions ou des questions, des paramètres du modèle, des métriques d’entraînement, ou toute autre information qui doit être communiquée entre le serveur et les SuperNodes pendant l’exécution.

Comment l’application de démonstration utilise ces composants

L’application @flwrlabs/demo est construite comme exemple NumPy délibérément petit afin que la structure Flower soit facile à voir.

Dans quickstart_numpy/server_app.py, le ServerApp est créé et définit son point d’entrée principal avec @app.main(). Lorsqu’une exécution commence, cette fonction :

1. lit num-server-rounds à partir de context.run_config;

2. crée le modèle global initial en appelant get_dummy_model() depuis quickstart_numpy/task.py; Pour simplifier, le modèle est simplement une liste d’un tableau NumPy unique, mais dans une application réelle, il pourrait s’agir d’un objet plus complexe comme un modèle PyTorch.

3. enveloppe les tableaux de modèles dans un ArrayRecord afin que Flower puisse les envoyer aux SuperNodes;

4. crée une stratégie de FedAvg;

5. Lance la stratégie en appelant strategy.start().

Dans quickstart_numpy/client_app.py, un ClientApp est créé et définit deux gestionnaires:

• @app.train() reçoit l’array de modèle global actuel, simule un entraînement local en ajoutant du bruit aléatoire à celui-ci, puis répond avec l’array mis à jour et quelques métriques.

• @app.evaluate() reçoit l’array de modèle global actuel et répond avec des métriques d’évaluation. Il ne retourne pas un array mis à jour car l’évaluation ne modifie pas le modèle.

La stratégie relie ces deux côtés. Dans ce démo, FedAvg envoie le tableau global actuel aux instances ClientApp sélectionnées pour l’entraînement, attend leurs réponses, et agrège les tableaux retournés dans le modèle global suivant.

Note

Dans une application réelle, le ClientApp aurait probablement une logique plus complexe, par exemple il pourrait charger un modèle et des données, effectuer un entraînement et une évaluation réels, et retourner les paramètres de modèle mis à jour et les métriques d’entraînement au serveur. Dans le prochain tutoriel, vous verrez un exemple plus complexe d’une application Flower qui utilise PyTorch et une logique d’entraînement et d’évaluation réelles.

Finalement, pyproject.toml rend les composants de l’application découvrables et configurables. La section [tool.flwr.app.components] pointe vers les objets que Flower doit importer:

serverapp = "quickstart_numpy.server_app:app"
clientapp = "quickstart_numpy.client_app:app"

La section [tool.flwr.app.config] définit des valeurs disponibles en temps réel à travers context.run_config. Dans ce démo, il définit :

num-server-rounds = 3

C’est la valeur que le ServerApp lit pour décider combien de tours d’apprentissage fédéré la stratégie FedAvg devrait exécuter. Dans une application réelle, vous pourriez avoir beaucoup plus de valeurs de configuration telles que le taux d’apprentissage, la taille du lot et ainsi de suite.

Remarques Finales

Félicitations, vous avez réussi à exécuter votre première application Flower personnalisée sur SuperGrid ! Vous avez également appris les composants principaux d’une application Flower et comment ils fonctionnent ensemble pour permettre des charges de travail d’IA collaborative au sein d’une fédération de SuperNodes.

Astuce

Ce tutoriel exécute l’application sur SuperGrid avec des SuperNodes simulés. Pour exécuter plutôt des applications Flower sur SuperGrid avec le Deployment Runtime, créez une fédération de déploiement dans le tableau de bord SuperGrid et connectez-y de vrais SuperNodes. Consultez Créez et Gérez les Fédérations sur SuperGrid et Connecter des SuperNodes à la grille SuperGrid.

Dans l’étape suivante, vous allez prendre un regard plus approfondi sur une application Flower plus complexe qui utilise PyTorch et une logique d’entraînement et d’évaluation réelles. Vous allez également apprendre à exécuter une application Flower localement sur votre machine, ce qui est idéal pour le développement et la déboguage avant l’exécution sur SuperGrid.

Prochaines étapes

Avant de continuer, assurez-vous d’adhérer à la communauté Flower sur Flower Discuss (Join Flower Discuss) et Slack (Join Slack).

Il existe un canal Slack dédié si vous avez besoin d’aide, mais nous aimerions également entendre qui vous êtes dans #introductions !

Le Flower Collaborative AI Tutorial - Part 3: Write a Flower App for a PyTorch model présente une application Flower plus avancée qui utilise PyTorch et une logique d’entraînement et d’évaluation réelles.