Inférence MoE : faire tourner 180 milliards de paramètres
Découvrez comment le streaming d’experts MoE fait tourner un modèle de 180 milliards de paramètres avec 32 Go de mémoire, et ce que les tests révèlent.

Faire tourner un modèle MoE de 180 milliards de paramètres avec 32 Go de mémoire
Exécuter un grand modèle de langage en local, ce n'est pas juste une question de calcul. La mémoire est souvent le premier mur : les poids finissent par dépasser ce que peut encaisser une carte graphique, ou même une machine portable. Les architectures à experts (MoE) changent la donne : pour chaque jeton, elles n'activent qu'une partie des paramètres. Sauf que, dans la vraie vie, il reste un autre problème : garder les experts disponibles sans saturer la mémoire.
Une expérimentation menée avec Transformers propose une réponse assez pragmatique : laisser en mémoire les poids denses et les experts récemment sollicités, puis charger à la demande les autres depuis le SSD. Sur un Mac avec 32 Go de mémoire unifiée, l'approche a permis de faire tourner un modèle de 180 milliards de paramètres, avec des performances proches d'un moteur spécialisé sur certaines tâches. Et surtout, ça ne prétend pas battre tout le monde en vitesse sur tous les scénarios. Le point central, c'est plutôt ce qui se passe concrètement à chaque jeton : combien de données transitent, comment le cache se comporte, et comment l'exécution coordonne processeur, mémoire et GPU.
Voici comment marche ce streaming, ce que les essais ont mesuré, et dans quels cas ça vaut la peine.
Pourquoi un modèle MoE peut-il dépasser la mémoire disponible ?
Un modèle MoE (Mixture of Experts) contient plusieurs réseaux spécialisés appelés experts. Un routeur choisit, pour chaque jeton, quels experts doivent intervenir. Résultat : on peut avoir énormément de paramètres au total, sans activer l'ensemble à chaque étape de génération.
Ça réduit le calcul. Mais ça ne supprime pas le stockage. Si les poids doivent tous être chargés en même temps dans la mémoire (souvent la VRAM), il faut quand même de la capacité pour les contenir. Dans un MoE massif, la majorité des poids correspond justement aux experts : on peut dépasser la VRAM d'un GPU grand public, et même la mémoire unifiée d'un ordinateur portable.
Paramètres totaux et paramètres actifs ne disent pas la même chose
Il faut garder en tête trois chiffres :
- le nombre total de paramètres ;
- la quantité activée pour un jeton ;
- la place à prévoir pour stocker les poids (en RAM/VRAM ou sur un périphérique).
Dans l'expérience dont il est question, Qwen3.8-Flash-Next compte 48 couches et 512 experts par couche, avec 10 experts activés par jeton. En FP8, les experts représentent environ 121 Go. C'est justement la faible proportion d'experts sollicités à chaque jeton qui rend le streaming pertinent : au lieu de maintenir 121 Go en mémoire, on charge uniquement les experts nécessaires et on conserve le reste via un cache de taille limitée.
Le SSD devient une partie du système d'inférence
Le modèle ne vit pas « entièrement » en RAM. Les poids sont répartis entre stockage (SSD), cache mémoire/GPU, et les composants denses du modèle. À chaque fois qu'un expert n'est pas dans le bon cache, il faut le relire depuis le SSD. Et là, la vitesse réelle dépend d'un paquet de facteurs : combien d'experts manquent, la taille des lectures, la capacité à anticiper ces accès, et le temps perdu à coordonner tout ça.
C'est un point important si on parle d'usages professionnels : une machine « moins chère » peut exécuter un modèle qu'elle ne pourrait pas charger entièrement, mais ça ne veut pas dire qu'elle aura un débit suffisant ni une expérience fluide. Le bon critère, ce n'est pas seulement « est-ce que ça démarre ? », mais « combien de temps faut-il pour obtenir une réponse dans le scénario réel ? ».
Comment les moteurs d'inférence gèrent-ils les experts hors mémoire ?
Quand un modèle ne tient pas sur le GPU, les moteurs d'inférence font des choix différents. Pour les MoE, on peut résumer la performance à trois questions : où résident les experts, où leur calcul se fait, et quelles données sont réellement transférées pour chaque jeton ?
Calculer sur le processeur ou transférer les poids
Avec llama.cpp, les experts peuvent être placés en mémoire système et exécutés sur le processeur. Dans ce cas, les activations passent par le bus PCIe, mais les poids ne sont pas renvoyés au GPU à chaque calcul. Ça marche plutôt bien tant que les experts tiennent en RAM. Si la mémoire est trop juste, le cache système se met à rater plus souvent et le débit finit par chuter.
vLLM peut aussi utiliser de la mémoire épinglée : le GPU lit les poids via PCIe. Sur une configuration adaptée, on peut déporter uniquement les experts. Mais un expert fréquemment utilisé peut quand même repasser par PCIe à chaque jeton, et le moteur ne propose pas ici un stockage SSD orienté « experts » qui resterait persistant pendant la génération.
Transformers, via Accelerate, déplace généralement des modules entiers sur le GPU avant exécution. Pour une couche MoE, ça peut revenir à charger tout le banc d'experts alors que le routeur n'en utilise que quelques-uns. Le mécanisme ne suit pas le routage fin. Sur un Mac, la situation est encore plus piégeuse : CPU et GPU partagent la même mémoire unifiée, donc « placer côté CPU » ne libère pas vraiment de la place.
Pourquoi la granularité du cache change tout
Le plus efficace, c'est de ne transférer que les experts choisis par le routeur, et de garder en cache (avec une taille limitée) ceux qui risquent de resservir. Ce cache doit être assez grand pour éviter des relectures trop fréquentes... sans voler trop d'espace au reste du modèle.
Mais un cache ne suffit pas. Il faut aussi éviter de dégrader la façon dont les experts sont calculés. Certaines implémentations optimisées regroupent plusieurs experts dans un noyau. À l'inverse, une boucle Python qui traite chaque expert séparément peut annuler le bénéfice du transfert sélectif, même si les données sont déjà là.
Ce que montrent les premiers benchmarks
Sur une carte A10G de 24 Go, les essais sur Qwen3.6-35B-A3B ont comparé plusieurs moteurs. Dans ce contexte précis, Strata en Q8_0 a atteint 82 à 88 jetons par seconde, contre 63 à 64 pour llama.cpp en Q8_0. vLLM avec FP8 et un déport limité aux experts a mesuré 20,1 jetons par seconde ; sans cette restriction, le débit a chuté à 9,7.
Avec Transformers et le chemin de déport standard d'Accelerate, le test donnait seulement 0,16 jeton par seconde. Ce n'est évidemment pas un classement universel : le matériel, la quantification, le modèle et les options changent la donne. Mais ces chiffres racontent une histoire assez claire : charger trop large coûte cher, et la mécanique mémoire doit coller à la structure MoE.
Comment le streaming d'experts a-t-il été adapté à Transformers ?
L'expérimentation a commencé avec un petit modèle OLMoE, capable de tenir en mémoire. L'idée était de comparer la sortie de chaque jeton avec Transformers, sans déport, avant d'introduire le streaming.
La première version plaçait les experts sur disque, utilisait un cache LRU sur l'appareil, et exécutait les experts un par un via une boucle Python. Le résultat (10,1 jetons par seconde quand les experts étaient dans le cache) était bien inférieur à la référence, autour de 32 jetons par seconde. Le problème ne venait pas surtout de la lecture disque : c'était la boucle, qui empêchait d'exploiter correctement le calcul groupé des experts.
Un pool de mémoire partagé entre les couches
Le changement principal a consisté à remplacer cette approche par un pool de créneaux préalloués. Les experts présents dans le cache occupent ces emplacements. Pour chaque couche, une table fait correspondre l'identifiant d'un expert et son emplacement dans le pool.
Ensuite, au moment du calcul, les identifiants fournis par le routeur sont remappés vers les créneaux correspondants. Le pool se comporte alors comme un banc d'experts « classique », et le calcul groupé existant peut être réutilisé. Sur le petit modèle, l'approche atteint 34,6 jetons par seconde, contre 38,1 pour Transformers sans déport. Le gain ne vient pas d'une nouvelle magie mathématique, mais d'une meilleure organisation des données.
Lire les bons experts sans bloquer chaque couche
Pour le modèle plus grand, les experts sont stockés sur disque et lus à la demande par plusieurs fils d'exécution. Les lectures sont faites de façon contiguë pour chaque expert. Le système tente aussi d'anticiper : les routeurs des couches suivantes sont exécutés en avance à partir des états cachés disponibles, ce qui permet de précharger certains experts avant qu'ils ne soient nécessaires.
Les experts sont quantifiés hors ligne pour réduire le volume de données lu. Dans l'essai, la répartition est la suivante : experts quantifiés sur disque, cache d'experts de 12 Gio, couches denses quantifiées sur l'appareil, et une table d'embeddings n-grammes gérée par un chemin de stockage distinct.
Cette table compte. Elle occupe environ 51 Go, donc on ne peut pas simplement « streamer les experts » et espérer que tout le reste suivra. Une solution de streaming limitée aux experts ne suffit pas à faire fonctionner ce modèle sur une machine de 32 Go.
Une intégration encore expérimentale
Le travail a été proposé dans une évolution de Transformers pour ajouter une option de déport des experts. Au moment des essais, l'API n'était pas figée, donc il faut distinguer une démonstration technique d'une fonctionnalité stabilisée.
La méthode vise les modèles MoE dont les experts suivent une disposition standard. Elle combine des outils Python, des noyaux Metal compilés à l'exécution, et des optimisations spécifiques à certains composants. L'intérêt, c'est de tester l'approche directement dans l'écosystème Transformers, sans devoir réécrire toute l'inférence dans une extension C++ dédiée.
Quels résultats obtient-on sur un ordinateur avec 32 Go de mémoire ?
Sur un Mac M5 avec 32 Go de mémoire unifiée, le modèle testé occupe environ 18 Gio après chargement. Avec un prompt de 6 000 jetons, le pic atteint 25,4 Gio. La marge est courte : l'auteur de l'expérimentation indique devoir fermer son navigateur pour éviter que macOS ne commence à utiliser le swap.
Côté experts : au départ, ils étaient estimés à 121 Go en FP8, puis quantifiés à 3 bits, ce qui les ramène à environ 49 Go sur disque. Le cache sur l'appareil fait 12 Gio. Les couches denses prennent environ 5,4 Go en 8 bits, avec une hausse mesurée de 0,2 % de la perplexité par rapport au BF16. La conversion des poids dure environ cinq heures : ce temps fait partie du coût opérationnel, même si ce n'est pas quelque chose qu'on répète à chaque génération.
Les résultats avant et après optimisation
La première version basée sur Transformers plafonnait vers 10 jetons par seconde en génération. Par rapport à Strata sur la même machine, elle était plus lente en décodage, et surtout en préremplissage du prompt.
Après plusieurs optimisations, les mesures rapportées étaient les suivantes :
| Scénario | Transformers optimisé | Strata | Écart observé |
|---|---|---|---|
| Décodage, 200 jetons | 13,9 jetons/s | 14,8 jetons/s | Environ 6 % |
| Préremplissage, prompt de 4 000 jetons | 228 jetons/s | 220 jetons/s | Transformers légèrement devant |
| Décodage après un document de 6 000 jetons | 12,4 jetons/s | 13,7 jetons/s | Environ 10 % |
À noter : les deux systèmes n'utilisaient pas les mêmes représentations de poids, et les résultats dépendent du protocole. L'important, c'est que l'approche intégrée à Transformers peut se rapprocher d'un moteur spécialisé dans cette configuration, pour ces prompts. Ça ne prouve pas que Transformers sera aussi rapide sur tous les modèles ou sur toutes les machines.
Les optimisations qui ont compté
Les améliorations ne se limitaient pas au streaming des experts. Parmi les points clés :
- Réduire l'attente du GPU. Sur MPS, de petits noyaux peuvent rester en file avant soumission. Dans les essais, forcer la validation après chaque bloc a apporté environ 10 %.
- Ajouter des noyaux Metal ciblés. Certaines opérations (comme Gated DeltaNet et les hyper-connexions) ne profitaient pas d'un chemin adapté sur macOS.
- Améliorer le préremplissage. Des blocs plus grands et la lecture anticipée des experts ont fait passer le débit d'environ 68 à 228 jetons par seconde.
- Éviter des copies inutiles. Sur les documents longs, l'attention a été limitée aux blocs sélectionnés, et le cache KV a été étendu « en place » plutôt que recopié à chaque jeton.
- Lire pendant que le SSD est disponible. Précharger un expert probable par couche a mieux masqué certains défauts de cache, sans aller jusqu'à des changements de politique plus lourds.
Au final, l'approche se rapproche de Strata sur le décodage court. Mais le coût en préparation logicielle et matérielle reste élevé : conversion, contrôle de la mémoire, et un débit qui peut rester limité pour certains usages interactifs.
Quelles limites faut-il prendre en compte avant de l'adopter ?
Un débit autour de 14 jetons par seconde peut suffire pour tester un modèle ou générer des réponses courtes. Pour un agent qui enchaîne de nombreux appels, utilise des outils, et lit fréquemment depuis des dépôts, ça risque d'être trop lent. Et la génération n'est pas tout : le préremplissage, la taille du contexte et les pauses entre couches pèsent aussi sur l'expérience.
Le goulot d'étranglement n'est pas toujours le SSD
Sur les derniers essais, les allers-retours entre le processeur hôte et le GPU représentaient environ 10 millisecondes par jeton. La reprise après synchronisation n'était qu'une petite partie du coût. Le reste venait notamment du fait que le GPU attendait que Python prépare le travail suivant.
Un moteur spécialisé peut soumettre les opérations d'un jeton à l'avance et synchroniser le GPU avec les lectures de poids. Dans l'environnement testé, PyTorch sur MPS ne donnait pas un contrôle aussi direct pour reproduire ce comportement. Pour réduire davantage l'écart, il faudrait donc aller plus loin dans la pile logicielle, avec un risque accru si les synchronisations sont mal gérées.
Une expérience de laboratoire n'est pas un déploiement
Le modèle testé était trop lent pour l'usage principal de l'auteur (programmation assistée), qui utilisait plutôt une machine avec deux RTX 4090. Ce détail compte : « faire tenir » un modèle ne veut pas dire « avoir le meilleur choix opérationnel ».
Avant d'adopter l'approche, il faut au minimum mesurer :
- le débit réel sur vos prompts et vos documents habituels ;
- le pic de mémoire, avec les applications ouvertes en parallèle ;
- la latence du premier jeton et le temps de préremplissage ;
- la fréquence des défauts de cache et la pression sur le SSD ;
- le coût de conversion, de stockage et de maintenance des poids ;
- la qualité après quantification sur vos tâches métier.
Sur une équipe qui traite des données sensibles, l'exécution locale peut limiter les transferts vers un service externe. Mais ça ne règle pas tout côté conformité : contrôle des accès, conservation des journaux, sécurité du poste et gouvernance des données restent à traiter. Le RGPD ne se résume pas au « où tourne le modèle ».
Quand cette approche est-elle pertinente ?
Le streaming d'experts devient intéressant quand le modèle ne tient pas en mémoire, que les experts sont effectivement peu sollicités par étape, et qu'un SSD assez rapide peut alimenter le cache. Ça peut servir à évaluer des modèles ouverts en local, prototyper un assistant interne, ou explorer des architectures sans investir tout de suite dans une infrastructure GPU plus lourde.
En revanche, si les experts tiennent déjà en RAM, si vous prévoyez beaucoup d'utilisateurs en parallèle, ou si vous devez garder une latence très basse et très prévisible, un moteur optimisé, plus de mémoire, ou un modèle plus petit ont souvent un meilleur coût total. La « bonne » décision se prend sur votre scénario réel, pas sur le nombre impressionnant de paramètres.
Conclusion
Le résultat le plus utile de cette expérimentation n'est pas « un modèle de 180 milliards de paramètres peut démarrer sur un ordinateur portable ». C'est plutôt la leçon : une gestion fine des experts peut rendre exploitable une architecture qui ne tient pas en mémoire, à condition de traiter le cache, les lectures disque et l'ordonnancement comme un seul système.
Sur le Mac testé, Transformers finit à environ 6 % de Strata sur le décodage court, avec un préremplissage légèrement plus rapide. Mais il faut quantifier les poids, développer des noyaux ciblés et optimiser les synchronisations. Si vous voulez choisir une solution, partez surtout de vos contraintes : qualité attendue, latence tolérable, mémoire disponible et nombre d'utilisateurs. Et gardez une idée simple en tête : un modèle plus gros n'est intéressant que si le reste du système peut réellement le servir efficacement.