Federated Learning : Guide Complet

Résumé

Le Federated Learning (apprentissage fédéré) est un paradigme d’apprentissage automatique distribué qui permet d’entraîner des modèles de machine learning sur des données réparties à travers de nombreux appareils ou serveurs, sans jamais centraliser les données brutes. Proposé initialement par Google en 2017, le Federated Learning repose sur un principe élégant : au lieu de déplacer les données vers le modèle, on déplace le modèle vers les données. Cette approche révolutionnaire résout les problèmes fondamentaux de confidentialité et de conformité réglementaire (RGPD, HIPAA) tout en exploitant la richesse des données distribuées. Dans ce guide complet, nous explorerons le principe mathématique du Federated Learning via l’algorithme FedAvg, son intuition profonde, une implémentation Python complète, ses hyperparamètres critiques, ainsi que ses cas d’usage concrets dans l’industrie.

Principe Mathématique du Federated Learning

L’algorithme FedAvg (Federated Averaging)

Le cœur du Federated Learning est l’algorithme FedAvg (Federated Averaging), introduit par McMahan et al. en 2017. Cet algorithme orchestre la collaboration entre un serveur central et plusieurs clients sans exposer les données locales de chaque client.

Fonctionnement de base :

Soit un ensemble de $K$ clients, où chaque client $k$ possède un jeu de données local $D_k$ contenant $n_k$ échantillons. L’objectif global est de minimiser la fonction de coût :

$$F(w) = \sum_{k=1}^{K} \frac{n_k}{n} F_k(w)$$

où $n = \sum_{k=1}^{K} n_k$ est le nombre total d’échantillons et $F_k(w)$ est la fonction de coût locale du client $k$.

À chaque round de communication $t$ :

1. Sélection des clients : Le serveur sélectionne une fraction $C$ des clients disponibles (typiquement 10 %).
2. Entraînement local : Chaque client sélectionné $k$ entraîne le modèle localement pendant un nombre fixé d’époques, en démarrant des poids globaux $w_t$ reçus du serveur. Après entraînement local, le client obtient des poids mis à jour $w_k^{t+1}$ :

$$w_k^{t+1} = w_t – \eta \nabla F_k(w_t)$$

où $\eta$ est le taux d’apprentissage local.

3. Agrégation FedAvg : Le serveur agrège les mises à jour reçues de manière pondérée selon le nombre d’échantillons de chaque client :

$$w_{t+1} = \sum_{k=1}^{K} \frac{n_k}{n} \cdot w_k^{t+1}$$

C’est la formule fondamentale du Federated Learning : le nouveau modèle global est une moyenne pondérée des modèles locaux, où le poids de chaque client est proportionnel à sa quantité de données.

4. Répétition : Le processus se répète sur plusieurs rounds de communication jusqu’à convergence du modèle global.

Le défi des données non-IID

Un problème majeur du Federated Learning est que les données de chaque client ne suivent généralement pas la même distribution (non-IID : non-Independent and Identically Distributed). Par exemple, un utilisateur parisien prendra des photos de monuments français, tandis qu’un utilisateur tokyoïte photographiera des temples japonais. Cette hétérogénéité complique considérablement l’agrégation, car les gradients locaux convergent vers des minima locaux différents.

Plusieurs techniques ont été proposées pour atténuer ce problème :

• FedProx : Ajoute un terme de régularisation proximal pour limiter la dérive des poids locaux par rapport au modèle global.
• SCAFFOLD : Utilise des variables de contrôle pour corriger le biais causé par l’hétérogénéité des données.
• Momentum FedAvg : Intègre l’élan (momentum) dans l’agrégation serveur pour stabiliser la convergence.

Confidentialité différentielle (Differential Privacy)

Même si les données brutes ne quittent jamais les appareils, les mises à jour de modèle $w_k$ peuvent potentiellement fuiter des informations sensibles par des attaques par inférence. Pour renforcer la protection, on applique la confidentialité différentielle au Federated Learning en ajoutant du bruit gaussien aux gradients avant leur envoi au serveur :

$$w_k’ = w_k + \mathcal{N}(0, \sigma^2)$$

où $\mathcal{N}(0, \sigma^2)$ est une distribution normale de moyenne nulle et de variance $\sigma^2$. Le paramètre $\sigma$ contrôle le compromis fondamental entre confidentialité et performance du modèle : un bruit trop élevé dégrade la qualité d’apprentissage, tandis qu’un bruit insuffisant offre une protection inadéquate.

Communication efficace

Dans un système de Federated Learning réel, la bande passante disponible est souvent limitée, particulièrement lorsque les clients sont des appareils mobiles. Plusieurs techniques de compression sont employées :

• Quantification : Réduction de la précision des poids (par exemple, de float32 à float16 ou int8).
• Élagage (Sparsification) : Envoi uniquement des gradients les plus significatifs.
• Codage : Utilisation de techniques de codage pour représenter les mises à jour de manière compacte.

Intuition : Comprendre le Federated Learning simplement

Imaginez la situation suivante : dix hôpitaux possèdent chacun des dossiers médicaux de patients, mais pour des raisons légales et éthiques, ils ne peuvent pas partager ces données entre eux. Si l’on voulait entraîner un modèle d’intelligence artificielle capable de détecter des maladies rares, l’approche classique consisterait à rassembler toutes les données dans un entrepôt central. Mais cette centralisation crée un risque immense pour la vie privée : une fuite de données, une cyberattaque, ou même une utilisation abusive auraient des conséquences catastrophiques.

Le Federated Learning propose une approche radicalement différente et bien plus élégante. Au lieu de rassembler les données, on envoie le modèle dans chaque hôpital. Concrètement :

1. Un modèle initial est créé sur un serveur central.
2. Ce modèle est envoyé à chaque hôpital participant.
3. Chaque hôpital entraîne le modèle sur ses propres données, localement, sans jamais les exporter.
4. Chaque hôpital ne renvoie que les mises à jour du modèle (les poids ajustés), pas les données elles-mêmes.
5. Le serveur central agrège toutes ces mises à jour pour créer un modèle global amélioré.
6. Le cycle recommence avec le nouveau modèle global.

L’analogie des étudiants : Imaginez un groupe de dix étudiants qui préparent ensemble un examen difficile. Au lieu de se réunir dans une bibliothèque commune (ce qui serait l’équivalent de centraliser les données), chaque étudiant révise chez soi avec ses propres notes. Ensuite, au lieu de partager leurs notes brutes (leurs données), ils partagent uniquement ce qu’ils ont appris : leurs résumés, leurs formules clés, leurs astuces. Le professeur (le serveur) compile tous ces résumés pour créer un guide de révision global, qu’il redistribue ensuite à chaque étudiant. Chaque étudiant enrichit alors sa révision personnelle avec les connaissances du groupe. C’est exactement le principe du Federated Learning : un apprentissage collaboratif sans partage des données sources.

Cette métaphore illustre parfaitement l’élégance du Federated Learning : l’intelligence émerge de la collaboration, mais l’intimité des données reste préservée. C’est une avancée majeure qui rend possible l’entraînement de modèles puissants sur des données sensibles — médicales, financières, personnelles — tout en respectant la vie privée de chaque individu.

Implémentation Python Complète

Voici une simulation complète du Federated Learning avec l’algorithme FedAvg, utilisant 10 clients, une boucle d’entraînement locale, l’agrégation FedAvg et une évaluation globale. Cette implémentation repose sur PyTorch et simule un scénario de classification sur des données synthétiques.

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import copy

# ============================================================
# Configuration du Federated Learning
# ============================================================
N_CLIENTS = 10
N_ROUNDS = 20
LOCAL_EPOCHS = 5
CLIENT_FRACTION = 0.5  # 50 % des clients sélectionnés par round
LEARNING_RATE = 0.01
BATCH_SIZE = 32
SEED = 42

torch.manual_seed(SEED)
np.random.seed(SEED)

# ============================================================
# Modèle : Réseau de neurones simple pour la classification
# ============================================================
class ClientModel(nn.Module):
    """Modèle de type MLP utilisé par chaque client."""

    def __init__(self, input_dim=20, hidden_dim=64, output_dim=4):
        super(ClientModel, self).__init__()
        self.network = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, output_dim),
        )

    def forward(self, x):
        return self.network(x)

# ============================================================
# Génération de données synthétiques non-IID
# ============================================================
def generate_non_iid_data(n_clients, samples_per_client, input_dim, output_dim):
    """
    Génère des données non-IID : chaque client possède une distribution
    légèrement différente pour simuler l'hétérogénéité réelle des données.
    """
    client_datasets = []
    for k in range(n_clients):
        # Chaque client a un biais différent dans ses données
        bias = np.random.randn(input_dim) * 0.5 * (k / n_clients)
        X = np.random.randn(samples_per_client, input_dim).astype(np.float32) + bias
        y = np.random.randint(0, output_dim, size=samples_per_client)
        dataset = TensorDataset(
            torch.from_numpy(X), torch.from_numpy(y).long()
        )
        client_datasets.append(dataset)
    return client_datasets

# ============================================================
# Entraînement local sur un client
# ============================================================
def train_client(model, dataset, epochs, lr, batch_size):
    """
    Entraîne le modèle localement sur les données d'un client.
    Retourne les poids mis à jour après l'entraînement local.
    """
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9)

    model.train()
    for epoch in range(epochs):
        epoch_loss = 0.0
        for batch_X, batch_y in dataloader:
            optimizer.zero_grad()
            outputs = model(batch_X)
            loss = criterion(outputs, batch_y)
            loss.backward()
            optimizer.step()
            epoch_loss += loss.item()
    return model.state_dict()

# ============================================================
# Agrégation FedAvg
# ============================================================
def fedavg_aggregate(weighted_updates):
    """
    Agrégation FedAvg : moyenne pondérée des poids locaux.
    w_global = somme (n_k / n) * w_k
    """
    global_state = copy.deepcopy(weighted_updates[0][0])
    total_samples = sum(n_k for _, n_k in weighted_updates)

    for key in global_state.keys():
        global_state[key] = torch.zeros_like(global_state[key])
        for client_state, n_k in weighted_updates:
            global_state[key] += (n_k / total_samples) * client_state[key]

    return global_state

# ============================================================
# Évaluation globale
# ============================================================
def evaluate_global(model, test_dataset):
    """Évalue le modèle global sur un jeu de test centralisé."""
    dataloader = DataLoader(test_dataset, batch_size=256, shuffle=False)
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for batch_X, batch_y in dataloader:
            outputs = model(batch_X)
            _, predicted = torch.max(outputs, 1)
            total += batch_y.size(0)
            correct += (predicted == batch_y).sum().item()
    accuracy = correct / total
    return accuracy

# ============================================================
# Boucle principale du Federated Learning
# ============================================================
def federated_learning():
    """
    Boucle principale du Federated Learning avec FedAvg.
    """
    # Génération des données
    client_datasets = generate_non_iid_data(
        n_clients=N_CLIENTS,
        samples_per_client=500,
        input_dim=20,
        output_dim=4,
    )

    # Jeu de test global
    X_test = np.random.randn(2000, 20).astype(np.float32)
    y_test = np.random.randint(0, 4, size=2000)
    test_dataset = TensorDataset(
        torch.from_numpy(X_test), torch.from_numpy(y_test).long()
    )

    # Modèle global initial
    global_model = ClientModel(input_dim=20, hidden_dim=64, output_dim=4)

    print("=" * 60)
    print("Federated Learning — Simulation avec FedAvg")
    print(f"Clients : {N_CLIENTS} | Rounds : {N_ROUNDS}")
    print(f"Époques locales : {LOCAL_EPOCHS} | Fraction clients : {CLIENT_FRACTION}")
    print(f"Taux d'apprentissage : {LEARNING_RATE}")
    print("=" * 60)

    n_clients_per_round = max(1, int(N_CLIENTS * CLIENT_FRACTION))

    for round_num in range(N_ROUNDS):
        # Sélection aléatoire des clients pour ce round
        selected_clients = np.random.choice(
            N_CLIENTS, size=n_clients_per_round, replace=False
        )

        weighted_updates = []
        for client_id in selected_clients:
            # Copie du modèle global pour le client
            client_model = ClientModel(input_dim=20, hidden_dim=64, output_dim=4)
            client_model.load_state_dict(copy.deepcopy(global_model.state_dict()))

            # Entraînement local
            local_weights = train_client(
                model=client_model,
                dataset=client_datasets[client_id],
                epochs=LOCAL_EPOCHS,
                lr=LEARNING_RATE,
                batch_size=BATCH_SIZE,
            )

            n_k = len(client_datasets[client_id])
            weighted_updates.append((local_weights, n_k))

        # Agrégation FedAvg
        global_weights = fedavg_aggregate(weighted_updates)
        global_model.load_state_dict(global_weights)

        # Évaluation globale
        accuracy = evaluate_global(global_model, test_dataset)
        print(f"Round {round_num + 1:3d} | Accur. globale : {accuracy:.4f} | "
              f"Clients sélectionnés : {n_clients_per_round}")

    print("=" * 60)
    final_accuracy = evaluate_global(global_model, test_dataset)
    print(f"Précision finale après {N_ROUNDS} rounds : {final_accuracy:.4f}")
    return global_model, final_accuracy

# ============================================================
# Exécution
# ============================================================
if __name__ == "__main__":
    model, acc = federated_learning()
    print(f"\nFederated Learning terminé avec une précision de {acc:.2%}")

Cette implémentation couvre l’ensemble du pipeline du Federated Learning : génération de données non-IID simulées, entraînement local indépendant sur chaque client, agrégation FedAvg pondérée par le nombre d’échantillons, et évaluation globale itérative. Elle constitue une base solide que l’on peut étendre avec de la confidentialité différentielle, de la compression des communications, ou des algorithmes d’agrégation avancés comme FedProx ou SCAFFOLD.

Hyperparamètres Clés du Federated Learning

Le Federated Learning introduit des hyperparamètres spécifiques qui n’existent pas dans l’apprentissage centralisé classique. Chacun influence profondément la convergence, la confidentialité et l’efficacité du système.

Recommandations pratiques

• Commencez avec : local_epochs=5, client_fraction=0.2, learning_rate=0.01
• Si convergence lente : Augmentez client_fraction ou local_epochs
• Si dérive des poids (modèle qui diverge) : Réduisez local_epochs ou ajoutez de la régularisation (FedProx)
• Pour les données très non-IID : Réduisez le taux d’apprentissage et augmentez le nombre de rounds

Avantages du Federated Learning

Le Federated Learning présente des avantages considérables par rapport aux approches centralisées traditionnelles :

1. Confidentialité renforcée : Les données sensibles ne quittent jamais l’appareil ou le serveur local du client. Seules les mises à jour du modèle (les poids) sont transmises, ce qui réduit considérablement le risque de fuite de données.
2. Conformité réglementaire : Le Federated Learning facilite naturellement le respect du RGPD, de l’HIPAA, et d’autres réglementations sur la protection des données, puisque les données personnelles ne sont ni collectées ni transférées.
3. Réduction de la bande passante : Transmettre des poids de modèle (quelques mégaoctets) est bien moins coûteux que de transférer des gigaoctets de données brutes vers un serveur central, surtout lorsque les clients sont des appareils mobiles.
4. Scalabilité massive : Le Federated Learning peut fonctionner avec des millions de clients simultanément, comme le démontre Google avec son clavier Gboard qui s’améliore continuellement grâce aux frappes de ses utilisateurs.
5. Robustesse et résilience : Le système est distribué par nature. La défaillance de plusieurs clients n’empêche pas le bon fonctionnement du Federated Learning global.

Limites et Défis

Malgré ses avantages, le Federated Learning fait face à plusieurs défis importants :

1. Hétérogénéité des données (non-IID) : C’est le défi le plus fondamental. Lorsque les distributions de données varient fortement entre clients, la convergence du modèle global peut être lente, instable, voire impossible sans techniques spécialisées comme FedProx ou SCAFFOLD.
2. Communication coûteuse : Chaque round nécessite un échange bidirectionnel entre le serveur et les clients sélectionnés. Sur des réseaux instables ou à faible bande passante, cela peut devenir un goulot d’étranglement majeur.
3. Hétérogénéité des appareils : Les clients peuvent avoir des capacités de calcul et de stockage très différentes. Un smartphone d’entrée de gamme ne peut pas entraîner un modèle aussi rapidement qu’un serveur puissant, ce qui crée des problèmes de synchronisation.
4. Attaques potentielles : Bien que les données ne soient pas partagées, des clients malveillants peuvent envoyer des mises à jour empoisonnées pour corrompre le modèle global (attaques par empoisonnement Byzantin). Des mécanismes de détection et de robustesse sont nécessaires.
5. Débogage complexe : Identifier pourquoi un modèle Federated Learning ne converge pas est particulièrement difficile, car on ne peut pas inspecter directement les données locales ni les gradients intermédiaires de chaque client.

4 Cas d’Usage Concrets du Federated Learning

1. Santé et Médecine Collaborative

Plusieurs hôpitaux peuvent collaborer pour entraîner un modèle de diagnostic médical (par exemple, détection de cancer sur des images radiologiques) sans jamais partager les dossiers patients. Chaque hôpital entraîne localement sur ses propres images et le serveur agrège les résultats. Des projets comme NVIDIA Clara et OpenMined ont déjà démontré la viabilité de cette approche. L’impact est considérable : des hôpitaux de petite taille peuvent bénéficier de modèles entraînés sur des millions d’images, tout en protégeant la vie privée de leurs patients.

2. Claviers Intelligents et Prédiction de Texte

Google Gboard utilise le Federated Learning depuis 2017 pour améliorer ses suggestions de saisie. Chaque entraînement local sur votre smartphone se base sur vos propres habitudes de frappe. Seules les mises à jour du modèle sont envoyées à Google, pas vos messages. Cela signifie que le clavier apprend de votre vocabulaire personnel — noms propres, expressions familières, jargon professionnel — sans jamais lire vos conversations. Des milliards d’appareils participent à ce Federated Learning à grande échelle.

3. Finance et Détection de Fraude

Les banques peuvent collaborer pour détecter des schémas de fraude sans partager leurs données clients sensibles. Chaque banque entraîne un modèle sur ses propres transactions suspectes, et le modèle global bénéficie de l’expérience collective de toutes les banques participantes. Cette approche est particulièrement pertinente dans le contexte européen, où les réglementations bancaires interdisent le partage direct de données clients entre établissements concurrents. Le Federated Learning permet donc une intelligence collective sans compromettre la conformité réglementaire.

4. Véhicules Autonomes et Conduite Intelligente

Les véhicules connectés d’une flotte peuvent apprendre collectivement des conditions de route, des situations dangereuses et des comportements de conduite optimaux. Chaque véhicule entraîne un modèle de perception localement à partir de ses capteurs (caméras, lidars), et les mises à jour sont agrégées pour améliorer la perception de toute la flotte. Tesla a exploré cette approche avec son réseau de véhicules pour améliorer ses systèmes de conduite autonome. Les avantages sont doubles : amélioration continue des capacités de perception et respect de la vie privée des conducteurs, dont les trajets personnels ne sont jamais centralisés.

Voir Aussi

• Deux modules pour bien sécuriser votre navigateur web
• Tester la Primalité de $2n^2 – 1$ en Python : Guide Complet et Optimisé