Comment exécuter un réseau de neurones de 744 milliards de paramètres sur un ordinateur ordinaire

Lorsque vous ouvrez la page d'un modèle comme GLM-5.2 avec 744 milliards de paramètres ou Kimi K3 avec 2,8 billions, la première pensée est assez simple : vous avez besoin d'une baie de serveurs avec une douzaine de GPU H100. Si vous n'avez pas ces ressources sous la main, la seule option qui reste est de payer pour des appels API.

Récemment, je suis tombé sur le projet JustVugg/colibri. L'auteur a écrit un moteur d'inférence léger en C pur sans dépendances tierces. Le moteur parvient à exécuter des modèles MoE massifs sur un ordinateur de bureau ou un ordinateur portable ordinaire avec 24 Go de RAM, en extrayant les poids directement depuis un SSD rapide.

Quel est le secret

L'architecture Mixture-of-Experts (MoE) est conçue de telle sorte que le modèle entier n'est pas nécessaire pour générer un seul token. Par exemple, dans GLM-5.2 sur 744 milliards de paramètres, seulement environ 40 milliards sont actifs. De plus, de token en token, seulement environ 11 Go de poids changent, correspondant aux experts sélectionnés par le routeur.

Au lieu d'essayer de comprimer 370 Go de modèle dans la mémoire vidéo, le moteur distribue les données sur une hiérarchie de stockage :

• La partie dense du modèle (embeddings, attention, couches partagées) pèse environ 9,9 Go en quantification int4 et reste définitivement dans la RAM.
• Près de 20 000 experts résident sur un SSD NVMe rapide et sont chargés à la demande via des E/S asynchrones.
• Les experts fréquemment utilisés se déposent dans le cache LRU de la RAM ou de la VRAM.

Fondamentalement, cela fonctionne comme un compilateur JIT, mais pour les poids des réseaux de neurones. Le moteur suit les statistiques d'accès, se souvient des branches chaudes et met en cache exactement les experts nécessaires pour le contexte actuel.

Comment fonctionne le moteur

La base de code est concise. Le cœur est écrit en C (chaque famille de modèles est séparée dans son propre fichier, par exemple c/colibri.c pour GLM) et se compile avec gcc ou clang avec le support OpenMP. Pas de frameworks massifs ni de runtimes monstrueux. Python n'est utilisé que pour la conversion unique des poids et le wrapper de l'interface web.

Lors de la génération de chaque token, le moteur effectue plusieurs étapes :

1. Calcule le routage une couche à l'avance via un thread de prélecture séparé. Le routeur prédit l'expert nécessaire avec environ 71% de précision, donc les lectures disque se produisent en parallèle avec les calculs.
2. Fusionne les requêtes vers des experts identiques en un lot pour éliminer les lectures en double.
3. Lit les trois matrices de chaque expert dans un seul appel système pread.
4. Sauvegarde les statistiques de hits dans un fichier d'historique afin que lors des exécutions suivantes, les couches chaudes soient pré-épinglées en mémoire.

Le support de deux périphériques de stockage est implémenté de manière intéressante. Si vous distribuez des copies de poids sur deux SSD différents, le moteur distribue les requêtes d'experts proportionnellement à la vitesse de lecture de chaque disque. Une paire de disques à 9 Go/s et 3 Go/s accélère la lecture d'environ un tiers.

Pour l'accélération du calcul, CUDA, Metal sur les puces Apple Silicon et Vulkan sont supportés. La variante Vulkan fonctionne même avec des GPU plus anciens comme l'AMD RX 580 via le pilote RADV, pour lequel le fournisseur a fermé le support de la dernière version de ROCm.

Le package inclut un tableau de bord web avec visualisation de l'activité des experts. Sur la page Atlas, vous pouvez faire pivoter une carte 3D de milliers d'experts et observer comment différents groupes gèrent le code, les sujets juridiques ou les langues étrangères.

Les chiffres réels de vitesse

Il n'y a pas de miracles, donc la vitesse est limitée par le débit du disque et la mémoire disponible.

Les benchmarks du projet ont enregistré les résultats suivants sur le modèle GLM-5.2 :

• Un ordinateur portable avec 25 Go de RAM et un cache froid produit un modeste 0,05-0,1 token par seconde. C'est lent, mais le modèle répond sans distorsion logique.
• Une station de travail avec 128 Go de RAM sans GPU dédié délivre environ 1,8 token par seconde sur un cache chaud.
• Un ordinateur portable avec une RTX 5070 Ti mobile accélère jusqu'à 1,07 token par seconde grâce au pipeline GPU.
• Un serveur avec six cartes RTX 5090 garde les experts entièrement en mémoire vidéo et affiche 5,8-6,8 tokens par seconde.

Modèles supportés

En plus du GLM-5.2 de base, l'auteur a ajouté le support de quatre architectures supplémentaires :

• Inkling (975B) — exécuter la partie dense en int4 nécessite environ 25 Go de RAM et 469 Go d'espace disque.
• Kimi K3 (2,8T) — un géant pesant 1,6 To, lit les poids natifs MXFP4 directement depuis les shards originaux sans pré-conversion.
• DeepSeek V4 Flash (284B) — fonctionne avec 167 Go de poids au format fp4/fp8 et nécessite 16 à 22 Go de RAM.
• OLMoE (7B) — une variante compacte avec 4 Go de poids pour des expériences rapides sur 8 Go de RAM.

Comment exécuter

Le moteur est distribué sous forme de binaires pré-construits pour Linux, macOS et Windows, ou peut être compilé à partir des sources en une minute :

git clone https://github.com/JustVugg/colibri && cd colibri/c
./setup.sh

Après la compilation, téléchargez les poids quantifiés pour le modèle souhaité depuis Hugging Face (par exemple, GLM-5.2 int4 prend environ 372 Go) et lancez le chat via le terminal :

COLI_MODEL=/path/to/glm52_i4 ./coli chat

Si vous voulez un serveur local compatible avec l'API OpenAI ainsi que le panneau web, exécutez :

./coli web --model /path/to/glm52_i4

Avant de lancer, il vaut la peine de vérifier la distribution de la mémoire avec ./coli plan et d'effectuer un test matériel rapide avec ./coli tune.

À qui ce projet sera utile

Colibrì ne conviendra probablement pas à la production à haute charge en raison de la latence de lecture du disque sur le matériel grand public. Cependant, c'est une trouvaille formidable pour les chercheurs, les passionnés et les développeurs qui ont besoin de tester le raisonnement des meilleurs modèles open-source localement sans acheter des GPU serveur pour des millions de roubles. Le code cœur est compact et transparent, ce qui rend le moteur pratique à utiliser comme terrain de jeu pour vos propres expériences avec les E/S et la quantification.