Federated Learning : Entraîner l'IA sans partager vos données

Dans le pipeline traditionnel du machine learning, la collecte des données est la première étape et souvent la plus coûteuse. Pour entraîner un modèle, vous devez rassembler les données brutes des utilisateurs (photos, SMS, dossiers médicaux ou transactions financières) et les charger sur un serveur cloud centralisé.

Bien que cette approche centralisée ait propulsé la révolution de l’IA, elle est confrontée à des défis majeurs :

1. Préoccupations de confidentialité : Les utilisateurs hésitent de plus en plus à téléverser leurs données privées sur des serveurs tiers.
2. Réglementation des données : Les réglementations telles que le RGPD et l’HIPAA limitent strictement le transfert et le stockage des données personnelles.
3. Coûts de bande passante : Téléverser des gigaoctets de données brutes depuis des millions d’appareils périphériques (comme les smartphones) est extrêmement inefficace.

L’apprentissage fédéré (Federated Learning - FL) résout ces problèmes en inversant le paradigme traditionnel. Au lieu d’apporter les données au modèle, il apporte le modèle aux données.

Le concept clé : Entraînement décentralisé

Dans l’apprentissage fédéré, le serveur central maintient un modèle global. Au lieu de collecter des données brutes pour entraîner ce modèle, le serveur coordonne un processus d’entraînement collaboratif à travers un réseau d’appareils périphériques (clients), tels que des smartphones, des appareils domestiques intelligents ou des bases de données hospitalières régionales.

Voici la règle fondamentale de l’apprentissage fédéré :

Les données brutes ne quittent jamais l’appareil local. Seules les mises à jour mathématiques du modèle sont partagées.

Guide étape par étape : Comment ça marche

Un cycle d’entraînement typique en apprentissage fédéré (appelé round de communication) se compose de cinq étapes principales :

sequenceDiagram
    participant Server as Serveur Central (Modèle Global)
    participant ClientA as Client A (Données Privées A)
    participant ClientB as Client B (Données Privées B)
    
    rect rgb(240, 248, 255)
        Note over Server: Étape 1 : Initialiser le modèle global
    end
    Server->>ClientA: Étape 2 : Envoyer les poids globaux (W_t)
    Server->>ClientB: Étape 2 : Envoyer les poids globaux (W_t)
    rect rgb(245, 245, 245)
        Note over ClientA: Étape 3 : Entraîner localement sur données privées
        Note over ClientB: Étape 3 : Entraîner localement sur données privées
    end
    ClientA->>Server: Étape 4 : Envoyer les mises à jour locales (W_t^A)
    ClientB->>Server: Étape 4 : Envoyer les mises à jour locales (W_t^B)
    rect rgb(240, 255, 240)
        Note over Server: Étape 5 : Faire la moyenne des mises à jour (FedAvg)<br/>Mettre à jour le modèle global (W_t+1)
    end

1. Initialisation

Le serveur central initialise le modèle global avec des poids de départ ($W_0$). Ces poids peuvent être aléatoires ou pré-entraînés sur un ensemble de données public.

2. Distribution (Diffusion du modèle)

Le serveur sélectionne un sous-ensemble d’appareils clients disponibles (par exemple, des téléphones en cours de charge, connectés en Wi-Fi et inactifs) et leur diffuse les poids actuels du modèle global ($W_t$).

3. Entraînement local

Chaque client sélectionné entraîne le modèle global reçu sur son propre ensemble de données privé et local. Cela se fait à l’aide d’algorithmes d’optimisation standard comme la descente de gradient stochastique (SGD). Après quelques époques, chaque client $i$ produit un nouvel ensemble de poids de modèle local ($W_t^i$).

4. Téléversement des mises à jour locales

Plutôt que d’envoyer les données d’entraînement privées, les clients envoient uniquement leurs nouveaux poids de modèle locaux (ou la différence $\Delta W_t^i = W_t^i - W_t$) au serveur central. Ces mises à jour sont généralement chiffrées à l’aide de protocoles cryptographiques.

5. Agrégation globale

Le serveur central collecte les mises à jour de tous les clients participants. Il en fait la moyenne (généralement pondérée par la quantité de données locales de chaque client) pour produire un nouveau modèle global ($W_{t+1}$). L’algorithme le plus courant pour cela est le Federated Averaging (FedAvg) :

$$W_{t+1} = \sum_{i=1}^{K} \frac{n_i}{N} W_t^i$$

Où :

• $K$ est le nombre de clients participants.
• $n_i$ est le nombre d’échantillons de données sur le client $i$.
• $N$ est le nombre total d’échantillons de données sur l’ensemble des clients participants ($N = \sum n_i$).

Ce cycle se répète pendant plusieurs rounds jusqu’à ce que le modèle global atteigne la précision souhaitée.

Exemple de code : Une simulation simple en Python

Pour voir l’apprentissage fédéré en action, écrivons une simulation simple en Python avec NumPy.

Dans ce scénario, nous voulons entraîner un modèle pour prédire les prix de l’immobilier ($y = w \cdot x$) à l’aide d’une régression linéaire. Nous avons un serveur central et 3 clients, chacun ayant ses propres dimensions de maison ($x$) et ses prix ($y$) privés.

import numpy as np

# 1. Configuration des données privées des clients (ne peuvent pas être partagées avec le serveur)
# Chaque client a un nombre différent d'échantillons locaux (n_i)
clients_data = {
    "Client_1": {"x": np.array([1.0, 1.5, 2.0]), "y": np.array([110.0, 160.0, 210.0])}, # Relation réelle: y = 100x + 10
    "Client_2": {"x": np.array([0.8, 1.2]),       "y": np.array([90.0, 130.0])},       # Relation réelle: y = 100x + 10
    "Client_3": {"x": np.array([2.5, 3.0, 3.5]), "y": np.array([260.0, 310.0, 360.0])}  # Relation réelle: y = 100x + 10
}

# Nombre total de points de données (N) sur tous les clients
total_samples = sum(len(data["x"]) for data in clients_data.values())

# 2. Poids initial du serveur (Modèle global: W_t)
global_weight = 10.0  # Estimation initiale (très éloignée de la vraie valeur 100.0)
learning_rate = 0.05
epochs = 5  # Époques d'entraînement local par round
communication_rounds = 3

print(f"Poids global initial : {global_weight:.2f}\n")

# Boucle d'apprentissage fédéré
for round_idx in range(communication_rounds):
    print(f"--- Round de communication {round_idx + 1} ---")
    local_weights = []
    client_sample_sizes = []
    
    # Étapes 2 & 3 : Distribution du modèle et entraînement local sur les appareils clients
    for client_name, data in clients_data.items():
        x = data["x"]
        y = data["y"]
        n_i = len(x)
        
        # Le client reçoit le poids global
        w_local = global_weight
        
        # Le client s'entraîne localement pendant quelques époques
        for epoch in range(epochs):
            # Calculer la prédiction: y_pred = w * x
            y_pred = w_local * x
            # Calculer le gradient pour la régression linéaire simple
            gradient = -2 * np.mean(x * (y - y_pred))
            # Mettre à jour le poids local
            w_local -= learning_rate * gradient
            
        print(f"  {client_name} a entraîné son poids local à : {w_local:.2f} (échantillons : {n_i})")
        
        # Sauvegarder les poids locaux et les tailles d'échantillon pour l'agrégation
        local_weights.append(w_local)
        client_sample_sizes.append(n_i)
        
    # Étapes 4 & 5 : Agrégation côté serveur à l'aide de Federated Averaging (FedAvg)
    weighted_sum = 0.0
    for w, n in zip(local_weights, client_sample_sizes):
        weighted_sum += w * n
        
    global_weight = weighted_sum / total_samples
    print(f"=> Poids global agrégé par le serveur : {global_weight:.2f}\n")

print(f"Poids final du modèle global après FL : {global_weight:.2f}")

Pourquoi ce code représente l’apprentissage fédéré :

• Le dictionnaire clients_data représente des bases de données isolées. Le serveur n’y accède jamais.
• Dans la boucle d’entraînement, la seule variable transmise du client au serveur est w_local.
• Le serveur effectue une moyenne pondérée basée sur la taille des échantillons (client_sample_sizes), ce qui implémente la formule mathématique de FedAvg.

Apprentissage Centralisé vs. Apprentissage Fédéré

Options de sécurité : Confidentialité et Chiffrement

Bien que l’apprentissage fédéré soit intrinsèquement plus sûr que l’apprentissage centralisé, l’envoi de poids bruts à un serveur comporte toujours de légers risques pour la confidentialité (car les poids peuvent parfois être analysés pour reconstruire les données d’entraînement). Pour contrer cela, l’apprentissage fédéré est combiné avec deux techniques de sécurité majeures :

1. Agrégation sécurisée (Secure Aggregation - SecAgg) : Un protocole cryptographique qui permet au serveur de calculer la somme de toutes les mises à jour locales de modèles sans jamais voir la mise à jour d’un client individuel. Le serveur ne voit que le résultat agrégé.
2. Confidentialité différentielle (Differential Privacy - DP) : Ajout de “bruit” mathématique aux poids locaux avant le téléversement. Cela garantit que les données d’aucun utilisateur individuel ne peuvent être isolées ou mémorisées par le modèle global.

Exemples concrets

L’apprentissage fédéré fonctionne déjà en toute discrétion sur vos appareils aujourd’hui :

• Google Gboard : Google utilise l’apprentissage fédéré pour entraîner la prédiction du mot suivant et les suggestions de recherche. Votre clavier apprend vos habitudes de frappe sans envoyer vos frappes de touches aux serveurs de Google.
• Apple QuickType : Apple utilise l’entraînement décentralisé pour améliorer la correction automatique et les suggestions Siri directement sur les iPhones.
• Santé (Projet MELLODDY) : Les plus grandes entreprises pharmaceutiques utilisent l’apprentissage fédéré pour entraîner en collaboration des modèles de découverte de médicaments sur des bases de données chimiques privées sans exposer leurs recherches exclusives à la concurrence.

Résumé

L’apprentissage fédéré marque un changement de paradigme dans la façon dont nous construisons des systèmes d’IA. Il respecte la propriété des données, réduit les coûts de communication et permet l’entraînement de l’IA dans des secteurs hautement réglementés. En déplaçant le processus d’entraînement vers la périphérie (edge), nous pouvons créer des modèles plus intelligents et plus personnalisés tout en gardant nos données personnelles là où elles doivent rester : entre nos propres mains.

Explorez plus d’analyses sur les technologies décentralisées sur le blog Ghaznix →