Split Learning

L'apprentissage divisé est une approche d'apprentissage automatique distribué qui divise un réseau de neurones entre deux ou plusieurs emplacements informatiques. Un client traite des données d'entrée privées à travers les premières couches du modèle, n'envoie que des activations intermédiaires à un serveur et reçoit les gradients nécessaires pour continuer à entraîner ses couches locales. Cela permet à des organisations ou à des appareils de collaborer sans transférer directement des données d'entraînement brutes.

L'approche est particulièrement pertinente lorsque l'apprentissage automatique doit fonctionner au-delà de frontières de confidentialité, de propriété, de bande passante ou de matériel. Par exemple, un hôpital peut conserver des images médicales localement tandis qu'un serveur plus puissant exécute la partie d'un modèle gourmande en calculs. Cependant, conserver des données brutes en local ne garantit pas automatiquement la confidentialité des données, car les représentations intermédiaires peuvent encore révéler des informations sensibles.

Comment fonctionne l'apprentissage divisé#

Un réseau de neurones est divisé au niveau d'une couche de coupure choisie. Les couches situées avant la coupure s'exécutent sur le client, tandis que celles situées après s'exécutent sur le serveur. La sortie du réseau côté client est souvent appelée activation, représentation intermédiaire ou données écrasées.

Une étape d'entraînement suit cette séquence :

1. Le client exécute une passe avant depuis l'entrée brute jusqu'à la couche de coupure.
2. Il envoie l'activation résultante au serveur.
3. Le serveur termine la passe avant et calcule la perte.
4. Pendant la rétropropagation, le serveur calcule un gradient pour l'activation de la couche de coupure et le renvoie.
5. Le client utilise ce gradient pour mettre à jour ses couches locales.

Ce processus s'appuie sur la même règle de dérivation en chaîne mise en œuvre par des systèmes tels que la différenciation automatique PyTorch. La différence est que les activations et les gradients traversent une frontière réseau pendant l'entraînement.

L'exemple à processus unique suivant simule cette frontière :

import torch
from torch import nn

client_model = nn.Sequential(nn.Linear(8, 16), nn.ReLU())
server_model = nn.Sequential(nn.Linear(16, 2))
client_optimizer = torch.optim.SGD(client_model.parameters(), lr=0.01)
server_optimizer = torch.optim.SGD(server_model.parameters(), lr=0.01)

inputs = torch.randn(4, 8)
targets = torch.tensor([0, 1, 0, 1])

client_optimizer.zero_grad()
server_optimizer.zero_grad()

client_activations = client_model(inputs)
sent_activations = client_activations.detach().requires_grad_()

predictions = server_model(sent_activations)
loss = nn.CrossEntropyLoss()(predictions, targets)
loss.backward()

client_activations.backward(sent_activations.grad)
server_optimizer.step()
client_optimizer.step()

print(loss.item())

Détacher client_activations représente leur envoi vers un autre système. Le gradient d'activation renvoyé reconnecte les deux moitiés pour l'optimisation. Une mise en œuvre en production doit ajouter la mise en réseau, l'authentification, le chiffrement, la gestion des pannes et les contrôles de confidentialité.

Apprentissage divisé vs approches apparentées#

L'apprentissage divisé appartient au domaine plus large de l'entraînement distribué, mais il partitionne le calcul différemment.

• Apprentissage fédéré : Chaque participant entraîne normalement un modèle local complet et envoie des mises à jour de modèle pour agrégation. L'apprentissage divisé donne à chaque participant seulement une partie du modèle et échange des activations intermédiaires et des gradients.
• Parallélisme de pipeline : Les deux approches placent différentes couches sur différents appareils. Le parallélisme de pipeline améliore principalement l'échelle ou l'utilisation du matériel dans un environnement de confiance, tandis que l'apprentissage divisé sépare généralement les propriétaires de données des fournisseurs de calcul.
• Entraînement parallèle aux données : Des frameworks tels que PyTorch DistributedDataParallel et l'entraînement distribué TensorFlow répliquent un modèle et synchronisent les mises à jour. Ils ne conservent généralement pas les couches initiales exclusivement à côté des données d'origine.

L'apprentissage divisé peut également prendre en charge des données partitionnées verticalement, où des organisations détiennent différentes caractéristiques pour des enregistrements correspondants. Le flux de travail d'apprentissage divisé SecretFlow illustre cet arrangement.

Applications concrètes#

• Imagerie médicale collaborative : Les hôpitaux peuvent entraîner un système de vision par ordinateur partagé tout en conservant les radiographies ou les examens dans leur propre infrastructure. Chaque hôpital exécute les premières couches localement, et un serveur central termine l'entraînement à partir de caractéristiques intermédiaires. L'aperçu de l'apprentissage divisé du MIT utilise des centres de radiologie pour expliquer cette architecture.

• Caméras industrielles aux ressources limitées : Les caméras ou passerelles d'usine peuvent exécuter un extracteur de caractéristiques compact localement tandis qu'un serveur entraîne les couches restantes pour la détection d'objets. Cela peut réduire le transfert de vidéos brutes et le calcul côté client, rendant l'approche pertinente pour les systèmes d'edge AI fonctionnant sur plusieurs installations.

Avantages, risques et choix de conception#

La couche de coupure détermine l'équilibre entre la charge de travail du client, la charge de travail du serveur, le volume de communication et l'exposition des informations. Une coupure précoce réduit le calcul du client mais peut produire de grandes activations semblables à des entrées. Une coupure ultérieure peut créer des caractéristiques plus abstraites mais nécessite un matériel client plus puissant.

Les activations intermédiaires et les gradients peuvent rester vulnérables à la reconstruction, à l'inférence ou à la manipulation. Les équipes doivent donc évaluer les contrôles d'accès, le transport chiffré, la protection des activations, la journalisation d'audit et la confiance des participants plutôt que de traiter l'apprentissage divisé comme une solution complète de confidentialité. Le NIST Privacy Framework et le NIST AI Risk Management Framework fournissent des processus plus larges pour évaluer ces risques.

La bande passante et la latence comptent également car chaque étape d'entraînement peut nécessiter une communication bidirectionnelle. Des clients lents ou peu fiables peuvent retarder l'ensemble du système, tandis que des distributions de données incohérentes peuvent affecter la convergence.

Ultralytics YOLO ne fournit pas d'orchestration d'apprentissage divisé prête à l'emploi. Sa mise en œuvre nécessiterait de partitionner soigneusement l'architecture YOLO, de coordonner les passes avant et arrière distantes et potentiellement d'étendre le flux de travail de l'entraîneur personnalisé documenté. Pour les projets qui ont seulement besoin que les données restent sur le matériel possédé, l'entraînement de modèle de la plateforme Ultralytics prend en charge l'entraînement local avec des métriques diffusées en continu, mais l'entraînement local n'est pas un apprentissage divisé car le modèle lui-même n'est pas divisé entre les participants.