xaynet

xaynet

Xaynet : Formez-vous à la périphérie avec l'apprentissage fédéré

Vous voulez un framework qui prend en charge l’apprentissage fédéré en périphérie, dans les navigateurs de bureau, qui s’intègre bien aux applications mobiles, qui soit performant et préserve la confidentialité ? Bienvenue sur XayNet, entièrement écrit en Rust !

Faciliter l'apprentissage fédéré pour les développeurs

Des cadres pour l’apprentissage automatique – y compris ceux expressément destinés à l’apprentissage fédéré – existent déjà. Ces cadres facilitent généralement l'apprentissage fédéré de cas d'utilisation inter-silos - par exemple dans le cadre d'un apprentissage collaboratif dans un nombre limité d'hôpitaux ou par exemple entre plusieurs banques travaillant sur un cas d'utilisation commun sans avoir besoin de partager des données précieuses et sensibles.

Ce référentiel se concentre sur l'apprentissage fédéré multi-appareils masqué pour permettre l'orchestration de l'apprentissage automatique dans des millions d'appareils Edge à faible consommation, tels que les smartphones ou même les voitures. Ce faisant, nous espérons également augmenter le rythme et la portée de l’adoption de l’apprentissage fédéré dans la pratique et notamment permettre la protection des données des utilisateurs finaux. Toutes les données restent dans des locaux locaux privés, où seuls les modèles d'IA cryptés sont agrégés automatiquement et de manière asynchrone. Ainsi, nous proposons une solution au dilemme de la confidentialité de l’IA et comblons le fossé souvent existant entre confidentialité et commodité. Imaginez, par exemple, un assistant vocal pour apprendre de nouveaux mots directement au niveau de l'appareil et partager ces connaissances avec toutes les autres instances, sans enregistrer ni collecter votre voix de manière centralisée. Ou pensez à un moteur de recherche qui apprend à personnaliser les résultats de recherche sans collecter de manière centralisée vos requêtes de recherche souvent sensibles… Il existe des milliers de cas d’utilisation de ce type qui, aujourd’hui encore, échangent la confidentialité contre la commodité. Nous pensons que cela ne devrait pas être le cas et nous souhaitons proposer une alternative pour surmonter ce dilemme.

Concrètement, nous mettons à disposition des développeurs :

• Outils de développement d'applications : un SDK pour intégrer l'apprentissage fédéré dans des applications écrites en Dart ou dans d'autres langages de choix pour le développement mobile, ainsi que dans des frameworks comme Flutter.
• Confidentialité via l'apprentissage fédéré multi-appareils : entraînez vos modèles d'IA localement sur des appareils de pointe tels que les téléphones mobiles, les navigateurs ou même dans les voitures. L'apprentissage fédéré regroupe automatiquement les modèles locaux dans un modèle global. Ainsi, toutes les informations inhérentes aux modèles locaux sont capturées, tandis que les données des utilisateurs restent privées sur les appareils finaux.
• Sécurité Confidentialité via le cryptage homomorphique : modèles agrégés avec la plus haute sécurité et confiance. Le protocole de masquage de Xayn crypte tous les modèles de manière homomorphe. Cela vous permet de regrouper des modèles locaux chiffrés en un modèle global, sans avoir à déchiffrer les modèles locaux. Cela protège les données privées et même les plus sensibles.

Les arguments en faveur de l'écriture de ce framework dans Rust

Notre cadre d’apprentissage fédéré n’est pas seulement un cadre d’apprentissage automatique en tant que tel. Au lieu de cela, il prend en charge la fédération de l'apprentissage automatique qui se déroule sur des appareils éventuellement hétérogènes et où les cas d'utilisation impliquent de nombreux appareils de ce type.

Le langage de programmation dans lequel ce framework est écrit devrait donc nous apporter un solide support pour les éléments suivants :

• Fonctionne "partout" : le langage ne doit pas nécessiter son propre runtime et le code doit être compilé sur un large éventail d'appareils.
• Sécurité de la mémoire et de la concurrence : le code qui compile doit être à la fois sécurisé en mémoire et exempt de courses de données.
• Communication sécurisée : une cryptographie de pointe doit être disponible dans des implémentations approuvées.
• Communication asynchrone : des abstractions pour la communication asynchrone devraient exister pour permettre à l'apprentissage fédéré d'évoluer.
• Rapide et fonctionnel : le langage doit proposer des abstractions fonctionnelles mais aussi compiler le code en exécutables rapides.

Rust est l'un des très rares choix de langages de programmation modernes qui répond à ces exigences :

• ses concepts de propriété et d'emprunt le rendent à la fois sécurisé pour la mémoire et les threads (évitant ainsi de nombreux problèmes de concurrence courants).
• il a une discipline et des traits de type forts et statiques, qui décrivent les fonctionnalités partageables d'un type.
• il s'agit d'un langage de programmation système moderne, avec quelques fonctionnalités de style fonctionnel telles que la correspondance de modèles, les fermetures et les itérateurs.
• son code idiomatique se compare favorablement au C idiomatique en termes de performances.
• il se compile en WASM et peut donc être appliqué nativement dans les paramètres du navigateur.
• il est largement déployable et ne dépend pas nécessairement d'un moteur d'exécution, contrairement à des langages tels que Java et leur besoin d'une machine virtuelle pour exécuter son code. Les interfaces de fonctions étrangères prennent en charge les appels à partir d'autres langages/frameworks, notamment Dart, Python et Flutter.
• il se compile en LLVM et peut donc s'appuyer sur les nombreuses suites d'outils pour LLVM.

---

Commencer

Version Rust minimale prise en charge

rustique 1.51.0

Faire fonctionner la plateforme

Il existe différentes manières d'exécuter le backend : via Docker, ou en le déployant sur un cluster Kubernetes ou en compilant le code et en exécutant le binaire manuellement.

1. Tout ce qui est décrit ci-dessous suppose que le répertoire de travail de votre shell est la racine du référentiel.
2. Les instructions suivantes supposent que vous avez des connaissances préexistantes sur certains des logiciels référencés (comme docker et docker-compose ) et/ou une configuration fonctionnelle (si vous décidez de compiler le code Rust et d'exécuter le binaire manuellement).
3. Si vous avez besoin d'aide pour configurer votre système en conséquence, nous vous recommandons de vous référer à la documentation officielle de chaque outil, car les prendre en charge ici dépasserait la portée de ce projet :
   • Rouiller
   • Docker et Docker Composer
   • Kubernetes

Note:

Avec Xaynet v0.11 le coordinateur a besoin d'une connexion à une instance Redis afin de sauvegarder son état.

Ne connectez pas le coordinateur à une instance Redis utilisée en production !

Nous vous recommandons de connecter le coordinateur à sa propre instance Redis. Nous avons investi beaucoup de temps pour nous assurer que le coordinateur supprime uniquement ses propres données mais dans l'état actuel du développement, nous ne pouvons pas garantir que ce sera toujours le cas.

Utiliser Docker

L'avantage d'utiliser la configuration Docker est qu'il n'est pas nécessaire de configurer un environnement Rust fonctionnel sur votre système, car tout se fait à l'intérieur du conteneur.

Exécuter une image depuis Docker Hub

Les images Docker des dernières versions sont fournies sur Docker Hub.

Vous pouvez les essayer avec le configs/docker-dev.toml par défaut en exécutant :

Xaynet ci-dessous v0.11

docker run -v ${PWD} /configs/docker-dev.toml:/app/config.toml -p 8081:8081 xaynetwork/xaynet:v0.10.0 /app/coordinator -c /app/config.toml

Xaynet v0.11+

 # don't forget to adjust the Redis url in configs/docker-dev.toml
docker run -v ${PWD} /configs/docker-dev.toml:/app/config.toml -p 8081:8081 xaynetwork/xaynet:v0.11.0

L'image Docker contient une version du coordinateur sans fonctionnalités facultatives.

Exécutez un coordinateur avec une infrastructure supplémentaire

Démarrez le coordinateur en pointant sur le fichier docker/docker-compose.yml . Il fait tourner toute l'infrastructure essentielle au fonctionnement du coordinateur avec des fonctionnalités par défaut ou facultatives. Gardez à l'esprit que ce fichier est utilisé uniquement à des fins de développement.

docker-compose -f docker/docker-compose.yml up --build

Créer une version de version

Si vous le souhaitez, vous pouvez créer une version optimisée du coordinateur, mais gardez à l'esprit que la compilation sera plus lente.

docker build --build-arg RELEASE_BUILD=1 -f ./docker/Dockerfile . 

Créer un coordinateur avec des fonctionnalités facultatives

Les fonctionnalités facultatives peuvent être spécifiées via l'argument de construction COORDINATOR_FEATURES .

docker build --build-arg COORDINATOR_FEATURES=tls,metrics -f ./docker/Dockerfile .

Utiliser Kubernetes

Pour déployer une instance du coordinateur sur votre cluster Kubernetes, utilisez les manifestes situés dans le dossier k8s/coordinator . Les manifestes dépendent de kustomize pour être générés ( kustomize est officiellement pris en charge par kubectl depuis la v1.14). Nous vous recommandons de parcourir attentivement les manifestes et de les ajuster en fonction de votre propre configuration (espace de noms, entrée, etc.).

N'oubliez pas de vérifier également (et d'ajuster si nécessaire) la configuration par défaut du coordinateur, disponible sur k8s/coordinator/development/config.toml .

Veuillez ajuster le domaine utilisé dans le fichier k8s/coordinator/development/ingress.yaml afin qu'il corresponde à vos besoins (vous pouvez également ignorer complètement ingress , assurez-vous simplement de supprimer sa référence de k8s/coordinator/development/kustomization.yaml ).

Gardez à l'esprit que la configuration ingress affichée sur k8s/coordinator/development/ingress.yaml repose sur des ressources qui ne sont pas disponibles dans ce référentiel, en raison de leur nature sensible (clé et certificat TLS, par exemple).

Pour vérifier les manifestes générés, exécutez :

kubectl kustomize k8s/coordinator/development

Pour les appliquer :

kubectl apply -k k8s/coordinator/development

Si vous n'exposez pas votre coordinateur via ingress , vous pouvez toujours l'atteindre en utilisant une redirection de port. L'exemple ci-dessous crée une redirection de port sur le port 8081 en supposant que le pod coordinateur utilise toujours l'étiquette app=coordinator :

kubectl port-forward $( kubectl get pods -l " app=coordinator " -o jsonpath= " {.items[0].metadata.name} " ) 8081

Construire le projet manuellement

Le coordinateur sans fonctionnalités optionnelles peut être construit et démarré avec :

 cd rust
cargo run --bin coordinator -- -c ../configs/config.toml

Exécuter l'exemple

L'exemple peut être trouvé sous rust/examples/. Il utilise un modèle factice mais est compatible réseau, c'est donc un bon point de départ pour vérifier la connectivité avec le coordinateur.

test-drive

Assurez-vous que vous disposez d'une instance en cours d'exécution du coordinateur et que les clients que vous générerez avec la commande ci-dessous peuvent l'atteindre via le réseau.

Voici un exemple sur la façon de démarrer 20 participants qui se connecteront à un coordinateur fonctionnant sur 127.0.0.1:8081 :

 cd rust
RUST_LOG=info cargo run --example test-drive -- -n 20 -u http://127.0.0.1:8081

Pour plus de détails sur la façon d'exécuter des exemples, consultez le guide de démarrage sous rust/xaynet-server/src/examples.rs.

Dépannage

Si vous rencontrez des difficultés pour exécuter le projet, veuillez nous contacter en ouvrant un problème et en décrivant votre configuration et les problèmes auxquels vous êtes confronté.