Expert Parallelism

Le parallélisme par experts (EP) est une stratégie d'entraînement distribué et d'inférence pour les modèles à mélange d'experts (MoE), qui place différents experts sur différents GPU et envoie chaque jeton aux appareils hébergeant les experts sélectionnés pour le traiter. Une couche MoE remplace un grand bloc à propagation avant d'un transformer par de nombreux petits réseaux experts et un routeur qui n'active que quelques experts par jeton ; le nombre total de paramètres peut ainsi augmenter bien plus vite que le calcul consacré à chaque jeton. Le parallélisme par experts permet de faire tenir ces paramètres en mémoire : au lieu de stocker tous les experts sur chaque GPU, chaque GPU n'en conserve qu'une partie. Dès 2017, Noam Shazeer et ses collègues de Google répartissaient déjà les experts entre les appareils, avec une copie partagée de chacun, dans leur couche MoE à activation parcimonieuse ; GShard a étendu cette approche en juin 2020, répartissant les experts d'un modèle de traduction de plus de 600 milliards de paramètres sur 2 048 accélérateurs TPU v3. Le parallélisme par experts est désormais courant pour entraîner et déployer à grande échelle les modèles de langage et les modèles vision-langage MoE.

Comment les jetons circulent entre les GPU#

Chaque couche MoE s'exécute en quatre étapes :

1. Routage : le routeur évalue chaque jeton par rapport à chaque expert et conserve les k meilleurs experts, généralement un, deux ou huit.
2. Distribution : Une opération collective tous-vers-tous envoie l'état caché de chaque jeton aux GPU qui hébergent les experts sélectionnés.
3. Calcul : chaque GPU exécute ses experts locaux sur les jetons qu'il a reçus.
4. Combinaison : une seconde opération all-to-all renvoie les résultats au GPU d'origine de chaque jeton, où ils sont pondérés par les scores du routeur puis additionnés.

L'extrait ci-dessous simule les étapes de routage et de distribution pour une couche comportant 8 experts répartis sur 4 GPU, soit deux experts par GPU :

import torch

torch.manual_seed(0)
num_experts, num_gpus, top_k = 8, 4, 2
tokens = torch.randn(4096, 512)  # états cachés de 4 096 jetons
router = torch.nn.Linear(512, num_experts)

# Routage : chaque jeton sélectionne ses 2 meilleurs experts selon le score du routeur
with torch.no_grad():
    _, experts = router(tokens).topk(top_k, dim=-1)

# Parallélisme par experts : les experts 0-1 se trouvent sur le GPU 0, les experts 2-3 sur le GPU 1, et ainsi de suite
gpu = experts // (num_experts // num_gpus)

# Distribution : compte les affectations jeton-expert reçues par chaque expert et chaque GPU
print(torch.bincount(experts.flatten(), minlength=num_experts).tolist())
print(torch.bincount(gpu.flatten(), minlength=num_gpus).tolist())

La première ligne de la sortie indique la charge de chaque expert, de 948 à 1 087 affectations, pour une part égale de 1 024. La seconde indique que les quatre GPU reçoivent entre 1 968 et 2 139 des 8 192 affectations. Même un routeur initialisé aléatoirement répartit le travail de manière inégale, et les routeurs entraînés développent des experts populaires qui déséquilibrent bien davantage la charge.

Équilibrage de charge et capacité#

Une couche ne se termine que lorsque le GPU le plus sollicité a fini. Un déséquilibre du routage entraîne donc directement une sous-utilisation du matériel. L'entraînement MoE y remédie de trois façons :

• Perte auxiliaire d'équilibrage : Un terme supplémentaire dans la fonction de perte encourage le routeur à répartir les jetons uniformément entre les experts.
• Facteur de capacité : Chaque expert accepte au plus un nombre fixe de jetons par lot, par exemple 1,25 fois la part équitable ; les jetons excédentaires ignorent cet expert.
• Équilibrage par biais : DeepSeek-V3 ajoute aux scores du routeur un biais par expert qui n'influe que sur le choix des experts : il diminue le biais des experts surchargés et augmente celui des experts inactifs après chaque étape. Cela équilibre la charge sans ajouter de perte auxiliaire susceptible d'entrer en concurrence avec l'objectif principal.

Avec une limite de capacité, le parcours de chaque jeton dépend de la charge de ses experts :

Un jeton ignoré traverse la couche sans modification grâce à la connexion résiduelle ; un rejet important nuit donc à la qualité. DeepSeek-V3 ne rejette aucun jeton pendant l'entraînement et s'appuie plutôt sur son équilibrage par biais.

La communication constitue l'autre coût. Les deux échanges tous-vers-tous ont lieu dans chaque couche MoE ; le parallélisme par experts fonctionne donc mieux au sein d'un même nœud, où les GPU partagent des connexions NVLink rapides, et devient coûteux sur les liaisons plus lentes entre les nœuds. DeepSeek-V3 répartit ses 256 experts routés par couche en parallélisme par experts à 64 voies sur 8 nœuds, envoie chaque jeton vers des experts situés sur 4 nœuds au maximum et superpose les échanges aux calculs.

Combiner les stratégies de parallélisme#

Le parallélisme par experts n'est qu'une des méthodes de répartition de l'entraînement entre les appareils :

• Parallélisme des données : Il réplique le modèle complet sur chaque GPU et répartit chaque lot, en synchronisant les gradients après chaque étape.
• Parallélisme tensoriel : Il répartit les matrices de poids individuelles entre les GPU, de sorte que chacun participe à chaque couche.
• Parallélisme des pipelines : Il attribue les couches consécutives à différents GPU et leur transmet les micro-lots en continu.
• Parallélisme du contexte : Il répartit une longue séquence d'entrée entre les GPU.

Les modèles denses qui tiennent sur un seul GPU n’ont besoin que du parallélisme des données. C’est ainsi que Ultralytics YOLO26 s’entraîne sur plusieurs GPU lorsqu’une liste d’appareils telle que device=[0, 1] est transmise en mode entraînement. Les grands modèles MoE combinent plusieurs approches : DeepSeek-V3 a entraîné ses 671 milliards de paramètres, dont 37 milliards actifs par jeton, avec un parallélisme de pipeline à 16 voies, un parallélisme d’experts à 64 voies et un parallélisme des données avec partitionnement, sans parallélisme tensoriel. Les moteurs d’inférence tels que vLLM appliquent la même répartition lors du déploiement d’un modèle : un modèle MoE dont les experts dépasseraient la mémoire d’un seul GPU s’exécute sur plusieurs GPU, chacun ne contenant que sa part des experts.