QwenPU exécute un réseau de neurones dans les poids de Qwen 3.5
Divyansh Agrawal met en ligne le 31 octobre 2026 QwenPU, un dépôt qui loge un processeur RISC-V 32 bits et son unité vectorielle dans treize couches compilées d'un Qwen3.5-4B. La machine simulée fait tourner stories260K, le petit modèle de 260 000 paramètrespoids du modèleNombre de valeurs apprises par un modèle. À quantification égale, plus de paramètres veut dire plus de mémoire occupée, et en général de meilleures réponses.Fiche du lexique de Karpathy, et écrit son histoire tokenPlus petite unité de texte qu'un modèle manipule. Un mot courant tient souvent en un seul, un mot rare se découpe en plusieurs morceaux. Les prix, les limites et les débits s'expriment en tokens, pas en mots.Fiche du lexique à token. Aucun poids nouveau n'est appris : un compilateur les calcule, et la même histoire sort à l'identique sur les trois exécutions.
par Gyom 1 novembre 2026 à 13:02 4 min de lecture rubrique : Code
etiquettes : Local · GPU
QwenPU prolonge un travail commencé par le même auteur : Qwenputer avait déjà compilé un processeur CHIP-8, puis un cœur RISC-V, dans les poids d'un Qwen3.5-4B. La nouveauté tient en un mot, unité vectorielle. Le processeur de Qwenputer ne savait multiplier que par des instructions de produit scalaire, une par token de trace, ce qui rendait chaque couche d'un réseau de neurones interminable. QwenPU ajoute à côté du processeur une unité qui avale une ligne de matrice entière en quelques tokens, et le réseau peut enfin tourner à une vitesse qui se regarde.
13 couches compilées avant les 32 de Qwen
Le modèle de base est Qwen3.5-4B, ses propres poids inchangés. Treize couches compilées sont insérées avant ses 32 : un processeur RV32IM avec l'extension Zba et une unité de grands nombres, plus l'unité vectorielle. La taille cachée du point de contrôle passe de 2 560 à 5 120 pour loger les dimensions de la machine, qui ne servent que sur les couches ajoutées. Le fichier complet pèse 26,7 Go en bf16, et l'essentiel de ce volume est du remplissage à zéro.
Le programme exécuté est stories260K, le modèle de 260 000 paramètres que Karpathy a publié avec llama2.c. Il ne s'agit pas de le simuler approximativement : le binaire C de l'histoire est chargé dans l'état de la machine, et le modèle hôte prédit chaque pas de son exécution. Ses poids int4 ne sont pas compilés dans le point de contrôle, ils restent des données dans la mémoire de l'unité, chargées par le programme. N'importe quel modèle qui tient dans cette mémoire tourne donc de la même façon.
53 000 tokens de trace par token d'histoire
Le chiffre qui mesure le progrès est le nombre de tokens de trace nécessaires pour produire un token d'histoire. Le même programme en C, avec des poids int8, en demande 2 430 000. L'unité de calcul de Qwenputer, avec ses instructions VDOT et SMAQA, descend à 225 000. L'unité vectorielle de QwenPU descend à 53 000, soit environ 46 fois moins que le programme C d'origine.
Le débittokens par secondeNombre de tokens produits par seconde en génération. Avec le temps d'attente du premier token, c'est le chiffre qui dit si un modèle est utilisable au quotidien sur une machine donnée.Fiche du lexique suit. L'exécuteur GPU tient environ 3 300 tokens de trace par seconde sur une L4, ce qui donne seize secondes par token d'histoire, contre 41 avec l'unité de Qwenputer. Le texte produit est le même dans les trois cas, mot pour mot, et le dépôt le cite en entier : l'histoire d'une petite fille nommée Lily et d'un ballon rouge.
Seize registres de 64 mots dans l'état DeltaNet
L'unité garde ses données dans les têtes DeltaNet des couches compilées, comme le faisait le processeur de Qwenputer. Elle dispose de seize registres de 64 mots, de 384 voies d'activations int8 lues par blocs de 64, d'une mémoire de poids de 4 152 morceaux de 64 poids int4 accompagnés de leur échelle, et de caches K et V de 32 positions. Le cache V garde une tête de valeur par position, si bien qu'une seule lecture rend une dimension de valeur sur toutes les positions à la fois.
Huit opérations suffisent : VMAT pour un produit matrice-vecteur ou un argmax, VQ pour quantifier un registre, VEW pour l'addition résiduelle, le produit filtré par SiLU et la rotation positionnelle, VMATR pour les scores d'attention puis les probabilités appliquées au cache V, VEXP pour les numérateurs de softmax par table, VRED pour les sommes et sommes de carrés, et VGET comme VPUT pour faire passer les valeurs entre le processeur et l'unité. Chaque opération commence par quelques tokens de configuration qui portent ses opérandes, puis diffuse ses résultats, et chaque token est un pas exact des couches compilées. SiLU et l'exponentielle sont des unités en virgule fixe, génériques comme les additionneurs du processeur.
3,18 millions de pas comparés à la référence
La vérification est mécanique, pas une impression. Chaque opération passe des programmes de test aléatoires dans le circuit, en mode imposé, et se compare à l'implémentation de référence, à l'identique. Le programme d'histoire traverse ensuite la représentation intermédiaire du circuit sur processeur pour ses 110 000 premiers pas, puis tourne librement sur l'exécuteur GPU pour les 3 184 920 pas, comparé à la référence à chaque pas. Le même jeu de tests et les 30 000 premiers pas du programme tournent enfin sur les couches du point de contrôle lui-même, par la commande vxcheck, avec le même résultat.
26,7 Go, exact mais pas encore petit
Le dépôt annonce lui-même la limite : QwenPU est exact, mais il n'est pas encore compact. Charger le point de contrôle entier demande un GPU de 40 Go ou plus. La démonstration et les vérifications font tourner les couches de la machine séparément, et tiennent alors sur 24 Go. Réduire la taille cachée, et avec elle le point de contrôle, est la prochaine étape annoncée.
Le code est sous licence MIT, les poids sous Apache-2.0 en tant que version modifiée de Qwen3.5-4B, dont les poids d'origine ne bougent pas. Ce dépôt ne rend pas les modèles plus rapides ni plus petits. Il montre jusqu'où va la compilation dans des poids : un processeur, son unité vectorielle et un autre réseau de neurones peuvent tenir dans les couches d'un modèle de langage, et produire un résultat vérifiable au token près.
Source primaire divagr18/QwenPU, « QwenPU: a vector unit, compiled into the weights of a language model », dépôt GitHub, 31 octobre 2026