Split Learning

L’apprentissage fédéré par découpage est une méthode d’entraînement distribué collaboratif qui divise un réseau neuronal au niveau d’une couche de coupure choisie, entre un propriétaire des données (le client) et un serveur. Le client exécute les couches précédant la coupure sur ses données privées et n’envoie que les activations obtenues, parfois appelées données fragmentées ; le serveur exécute les couches restantes, calcule la perte et renvoie le gradient au niveau de la coupure afin que le client puisse mettre à jour ses couches. Les données d’entraînement brutes ne quittent jamais le client et aucune des deux parties ne détient le modèle complet. Otkrist Gupta et Ramesh Raskar, du MIT Media Lab, ont présenté cette méthode en octobre 2018 dans Distributed Learning of Deep Neural Network over Multiple Agents. Dans leur article de suivi de décembre 2018, Split Learning for Health, ils ont proposé des configurations permettant à des hôpitaux détenant différents types de données sur les patients, comme des clichés pour l’analyse d’images médicales, d’entraîner des modèles ensemble sans partager les dossiers bruts.

Fonctionnement de l’apprentissage scindé#

Chaque étape d’entraînement franchit deux fois la coupure : les activations vont du client au serveur pendant la passe avant, puis le gradient de la perte par rapport à ces activations revient pendant la rétropropagation. Comme la règle de la chaîne n’a besoin que de ce gradient pour poursuivre, les mises à jour du client sont identiques à celles obtenues en entraînant le modèle non découpé. Une simulation à processus unique dans PyTorch illustre cet échange :

import torch
from torch import nn

torch.manual_seed(0)
client = nn.Sequential(nn.Linear(784, 256), nn.ReLU())  # couches avant la coupure, à côté des données privées
server = nn.Sequential(nn.Linear(256, 10))  # couches après la coupure
images, labels = torch.randn(32, 784), torch.randint(0, 10, (32,))

# Client : passe avant jusqu’à la couche de coupure, puis envoi des seules activations
activations = client(images)
received = activations.detach().requires_grad_()

# Serveur : terminer la passe avant et effectuer la rétropropagation jusqu’à la coupure, puis renvoyer ce gradient
nn.functional.cross_entropy(server(received), labels).backward()

# Client : poursuivre la rétropropagation à partir du gradient renvoyé
activations.backward(received.grad)
split_grad = client[0].weight.grad.clone()

# La même étape sur le modèle non découpé donne au client des gradients identiques
client.zero_grad()
nn.functional.cross_entropy(server(client(images)), labels).backward()
print("Same client gradients as unsplit training:", torch.equal(split_grad, client[0].weight.grad))

Le programme affiche Same client gradients as unsplit training: True. Chaque partie exécute ensuite une étape avec son propre optimiseur. Avec plusieurs clients, le protocole d’origine les entraîne à tour de rôle ; chacun récupère les derniers poids côté client du participant précédent.

La configuration varie selon les éléments qui doivent rester privés. La configuration classique ci-dessus envoie les étiquettes au serveur ; une configuration en U conserve également les dernières couches et les étiquettes sur le client ; une configuration verticale s’adresse aux organisations qui détiennent différentes caractéristiques concernant les mêmes dossiers :

Apprentissage fédéré par découpage ou apprentissage fédéré#

L’apprentissage fédéré garde lui aussi les données sur les machines de leurs propriétaires, mais chaque client entraîne une copie complète du modèle et envoie les mises à jour des poids pour les moyenner. L’apprentissage fédéré par découpage transmet plutôt les activations et les gradients : les clients ont donc besoin de beaucoup moins de calcul et ne détiennent jamais le modèle complet. Les communications augmentent en fonction du volume de données plutôt que de la taille du modèle, et les clients s’entraînent à tour de rôle plutôt qu’en parallèle. L’apprentissage SplitFed, proposé par Chandra Thapa et ses collègues en 2020, combine les deux approches en exécutant les couches côté client en parallèle et en les moyennant selon le principe de l’apprentissage fédéré.

L’apprentissage fédéré par découpage vertical s’applique aussi à la finance : une banque et un partenaire détenant différentes caractéristiques sur les mêmes clients entraînent un modèle ensemble, comme dans le tutoriel de marketing bancaire de SecretFlow, sans échanger de données privées. Le parallélisme par pipeline découpe un réseau en profondeur de la même manière, mais entre les GPU d’un même cluster de confiance, afin de faire tenir un grand modèle en mémoire.

Risques pour la confidentialité#

Les activations et les gradients contiennent toujours des informations sur les données. Les activations des premières couches peuvent être inversées pour reconstituer des images reconnaissables ; lorsque le serveur détient les étiquettes, les gradients qu’il renvoie peuvent les révéler au client. Lors de la conférence ACM CCS 2021, Dario Pasquini, Giuseppe Ateniese et Massimo Bernaschi ont montré qu’un serveur malveillant pouvait détourner l’entraînement au moyen des gradients qu’il renvoie et orienter les couches du client de sorte que le serveur puisse reconstruire les entrées privées. Les défenses ajoutent du bruit grâce à la confidentialité différentielle, pénalisent la quantité d’informations sur l’entrée révélées par les activations ou détectent les gradients inhabituels, au prix d’une certaine précision. Les déploiements associent l’apprentissage fédéré par découpage à des mesures de sécurité des données, comme l’authentification et le chiffrement des communications, car le protocole lui-même ne régit que ce qui franchit la coupure.

Choisir la couche de coupure#

La coupure détermine le compromis entre calcul côté client, trafic et exposition : une coupure précoce nécessite peu de calcul côté client, mais transmet de grandes activations qui ressemblent encore à l’entrée ; une coupure plus tardive transmet des cartes de caractéristiques plus abstraites, mais sollicite davantage le matériel client, ce qui compte pour les appareils d’IA en périphérie. Les connexions de saut compliquent le choix, car chaque tenseur qui franchit la coupure doit être transmis. Découper Ultralytics YOLO26 après son backbone implique d’envoyer trois cartes de caractéristiques, car la configuration du modèle transmet les sorties des couches 4, 6 et 10 au neck : pour YOLO26n, à imgsz=640, elles contiennent 1 126 400 valeurs, presque autant que les 1 228 800 valeurs de l’image d’entrée.