💬 NLP

ZetaGPT: A Reference Implementation of Positional--Encoding--Free State--Space--Attention Language Models

Cet article présente ZetaGPT, un petit modèle de langage open-source qui élimine les encodages positionnels explicites en intégrant des équations d'espace d'états causales pour encoder implicitement l'information séquentielle avant l'auto-attention, tout en fournissant un pipeline d'entraînement complet de bout en bout à des fins de recherche et d'éducation.

Auteurs originaux : Róisín Luo

Publié 2026-08-11

📖 8 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Róisín Luo

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous essayez d'apprendre à un robot à lire une histoire. Pendant longtemps, la meilleure façon de faire cela était de donner au robot un « autocollant » spécial pour chaque mot qu'il lisait. Si le robot voyait le mot « chat », il saurait qu'il s'agissait du premier mot car il avait un autocollant « Premier Mot », et s'il voyait « chien » plus tard, il aurait un autocollant « Cinquième Mot ». Sans ces autocollants, le robot serait confus, pensant que « Le chat a poursuivi le chien » était la même chose que « Le chien a poursuivi le chat » parce que les mots n'étaient qu'un tas d'ingrédients mélangés. Cette méthode consistant à coller des étiquettes sur les mots est appelée « encodage positionnel », et elle a été la règle de base pour presque tous les modèles de langage intelligents que nous utilisons aujourd'hui.

Mais et si le robot n'avait pas besoin d'autocollants du tout ? Et si, au lieu de regarder une étiquette, le robot pouvait simplement ressentir l'ordre de l'histoire en la lisant ? C'est la grande question que pose cet article. Il explore une nouvelle façon de construire des modèles de langage qui ne dépend pas de ces autocollants externes. Au lieu de cela, il utilise une « boucle de mémoire » qui se met à jour d'elle-même pendant la lecture, se souvenant naturellement de ce qui a précédé. Cela importe car, si nous pouvons construire des modèles qui comprennent l'ordre sans avoir besoin qu'on leur dise explicitement où se trouve chaque mot, nous pourrions être capables de les rendre plus intelligents, plus efficaces et meilleurs pour gérer des histoires très longues sans qu'ils ne se perdent.

La grande idée de l'article : ZetaGPT

L'auteur de cet article présente ZetaGPT, un petit modèle de langage en open-source qui tente de faire exactement cela : lire sans autocollants. La conclusion principale est qu'en plaçant un module spécial de « l'état causal de l'espace d'états » juste avant le mécanisme d'attention du modèle, celui-ci peut apprendre implicitement l'ordre des mots grâce à sa propre dynamique interne.

Pensez à un modèle de langage standard comme un élève passant un examen qui a le droit de regarder une fiche de référence indiquant « Question 1 », « Question 2 », etc. ZetaGPT est comme un élève qui doit compter entièrement sur sa mémoire de l'histoire jusqu'ici. À mesure que l'élève lit chaque mot, son état interne change, créant une « empreinte digitale » unique pour ce moment précis de l'histoire. L'article suggère que cette empreinte digitale interne est suffisante pour dire au modèle : « Hé, ce mot vient après celui-là », sans avoir besoin d'aide externe.

Comment ça marche : La boucle de mémoire

Pour comprendre comment ZetaGPT réussit ce tour de force, imaginez une course de relais. Dans une course normale, le témoin est passé et tout le monde court simplement. Dans la version de ZetaGPT, le coureur (le modèle) porte un sac à dos spécial (le module d'espace d'états) qui change de forme et de poids selon ce qu'il vient de traverser.

Le Sac à Dos (Module d'Espace d'États) : Avant que le modèle ne regarde l'ensemble de la phrase pour comprendre les connexions (un processus appelé « auto-attention »), il fait d'abord passer les mots par ce sac à dos. Le sac à dos est un système « récurrent », ce qui signifie qu'il se souvient du passé. À mesure que chaque nouveau mot entre, le sac à dos met à jour son état interne en fonction des mots précédents.
L'Évolution : L'article montre qu'au fur et à mesure que le modèle s'entraîne, ce sac à dos apprend à développer différents « horizons de mémoire ». Certaines parties du sac à dos se souviennent des derniers mots (mémoire à court terme), tandis que d'autres se souviennent d'une longue partie de l'histoire (mémoire à long terme).
Le Résultat : Au moment où le mot sort du sac à dos et entre dans la couche d'attention principale, il n'est plus seulement un mot brut ; c'est un mot « conscient de sa position ». Il porte l'histoire de l'endroit où il se trouvait dans la phrase. L'article observe que, pendant l'entraînement, le modèle apprend naturellement à utiliser ces différentes échelles de temps de mémoire pour encoder la séquence, remplaçant ainsi efficacement le besoin des « autocollants » (encodages positionnels) utilisés par les autres modèles.

Ce que l'article écarte et ce qu'il trouve

L'article soutient explicitement l'idée que nous ne devons pas utiliser d'encodages positionnels explicites (comme les « autocollants » mentionnés plus haut) pour construire un modèle de langage fonctionnel. Il rejette la notion que l'information positionnelle doit être une « capacité acquise architecturalement » injectée de l'extérieur. Au lieu de cela, il propose que cette information peut être une « propriété inhérente » de la propre dynamique du modèle.

L'auteur a constaté que ZetaGPT fonctionne. Ils ont entraîné trois versions du modèle (Small, Medium et Large) avec respectivement 34,4 millions, 159,2 millions et 479,9 millions de paramètres. Ils ont montré que ces modèles pouvaient apprendre à prédire le mot suivant dans une phrase sans jamais recevoir d'encodage positionnel.

Cependant, l'article est prudent quant à sa confiance. Il ne prétend pas avoir « résolu » le problème de la modélisation du langage ou que ZetaGPT est meilleur que les modèles massifs utilisés par les géants de la technologie. En fait, l'auteur admet que leurs modèles sont petits et ont été entraînés sur un ensemble de données relativement modeste (le corpus WikiText-103). Il note que, comme les modèles sont petits, ils n'ont été entraînés que sur des contextes courts (256, 512 et 1024 tokens). L'article suggère que, bien que l'architecture fonctionne à ces petites échelles, nous ne savons pas encore si elle fonctionnera tout aussi bien pour les modèles géants qui lisent des millions de mots à la fois.

Le voyage complet : De zéro au raisonnement

L'un des aspects les plus ludiques et complets de cet article est qu'il ne se contente pas de présenter le modèle ; il présente toute la « recette » pour le construire. L'auteur fournit un pipeline complet en open-source qui vous mène du texte brut à un modèle capable de raisonner.

Le Tokenizer : D'abord, ils ont construit un « tokenizer » (un traducteur qui transforme le texte en nombres) à partir de zéro, en partant de bytes bruts et en les fusionnant en un vocabulaire de 50 259 symboles.
L'Entraînement : Ils ont pré-entraîné le modèle, puis l'ont affiné pour qu'il suive des instructions, et ont même entraîné un « modèle de récompense » pour aider l'IA à apprendre à partir des retours humains (RLHF).
Le Moment « Eurêka » : Enfin, ils ont utilisé une technique appelée Group Relative Policy Optimization (GRPO) pour enseigner au modèle le raisonnement de type « Chaîne de Pensée » (Chain-of-Thought). C'est la partie où le modèle apprend à réfléchir étape par étape, comme un humain résolvant un problème de mathématiques, sans qu'on lui montre explicitement les étapes au préalable. L'article suggère que cette capacité de raisonnement peut « émerger » directement par l'apprentissage par renforcement.

Les Limites

L'auteur est très honnête concernant les limites de son travail. Il déclare que les principales limitations sont dues aux ressources de calcul dont il disposait, et non à un défaut de l'idée elle-même. Comme ils n'avaient pas accès à des supercalculateurs dotés d'une puissance infinie, ils n'ont pas pu s'entraîner sur les ensembles de données massifs (des billions de tokens) utilisés par les géants modernes. Par conséquent, leurs modèles ne possèdent pas la vaste connaissance du monde de ces systèmes plus larges.

Ils soulignent également que, comme ils n'ont pas pu s'entraîner sur des textes extrêmement longs, ils n'ont pas pleinement testé si cette approche « sans autocollant » fonctionne pour des histoires très longues. L'article conclut que ZetaGPT est une « implémentation de référence compacte » : une preuve de concept et un terrain de jeu pour les chercheurs étudiant comment l'information positionnelle peut être apprise implicitement, plutôt qu'un produit fini prêt à remplacer les plus grands modèles de langage du monde.

En résumé, ZetaGPT est un petit robot sans autocollant qui prouve que l'on peut apprendre à une machine à comprendre l'ordre d'une histoire simplement en la laissant se souvenir du voyage, un mot à la fois. C'est un petit pas, mais cela ouvre une nouvelle porte sur la façon dont nous pourrions construire la prochaine génération de modèles de langage.

Résumé Technique : ZetaGPT

Problématique

Les modèles de langage de grande taille (LLM) basés sur les Transformers reposent sur des mécanismes d'auto-attention qui sont intrinsèquement équivariants par permutation, ce qui signifie qu'ils manquent d'une capacité intrinsèque à représenter l'ordre des jetons. Par conséquent, les architectures existantes doivent injecter explicitement des informations positionnelles via des plongements appris ou des encodages faits à la main (ex: sinusoïdal, RoPE). Bien qu'efficaces, ces méthodes traitent l'information positionnelle comme un composant architectural externe plutôt que comme une propriété inhérente au modèle. Cette dépendance crée des défis pour l'extension du contexte, nécessitant souvent des adaptations spécifiques du mécanisme d'encodage (ex: interpolation ou mise à l'échelle) plutôt que de surgir naturellement des dynamiques du modèle. Les philosophies de conception récentes se sont tournées vers des architectures sans encodage positionnel, où l'information séquentielle émerge implicitement à travers les dynamiques de calcul, pourtant les implémentations de référence compactes et open-source pour de tels modèles restent rares.

Méthodologie

ZetaGPT introduit une architecture hybride d'État–Espace–Attention (SSA) conçue pour encoder implicitement l'information positionnelle avant le calcul de l'auto-attention. La méthodologie centrale comprend les composants suivants :

1. Conception Architecturale

Chaque bloc Transformer dans ZetaGPT consiste en trois sous-couches résiduelles pré-normalisées disposées dans un ordre spécifique :

Module d'État-Espace Causal (SSM) : Placé avant l'auto-attention, ce module traite l'entrée à travers des dynamiques d'état récurrentes.
Auto-attention Multi-Têtes à Porte (Gated) : Opère sur les représentations sensibles à la position générées par le SSM.
Réseau de Propagation Avant (FFN) : Effectue une transformation de caractéristiques non linéaire.

2. Encodage Positionnel Implicite via les Dynamiques d'État-Espace

Le modèle utilise des équations d'état-espace sélectives pour transformer les représentations de jetons indépendantes de la position en représentations sensibles à la position. Étant donné une séquence d'entrée $\{x_t\}$ , l'état caché $h_t$ évolue de manière récursive :
$h_t = A(x_t)h_{t-1} + B(x_t)x_t$
$y_t = C(x_t)h_t + D(x_t)x_t$

Dans l'implémentation de ZetaGPT :

L'opérateur de transition d'état $A(x_t)$ est défini comme une matrice diagonale avec des coefficients de décroissance dépendants de l'entrée $a_t = \exp(-\text{softplus}(W_a x_t + b_a))$ .
Le chemin d'entrée implique une projection, une convolution causale de profondeur (depthwise) et une activation SiLU.
La sortie est modulée par une porte $g_t$ dépendante de l'entrée.

Parce que l'état caché $h_t$ résume de manière récursive le préfixe causal $\{x_1, \dots, x_t\}$ , les représentations résultantes contiennent intrinsèquement l'ordre séquentiel. Cela permet à la couche d'auto-attention suivante d'opérer sur des données sensibles à la position sans nécessiter d'encodages positionnels explicites.

3. Mécanisme d'Attention à Porte

Pour atténuer les "attention sinks" (puits d'attention) et l'effondrement des activations, ZetaGPT emploie un mécanisme d'auto-attention à porte qui module la sortie de l'attention avant la projection, améliorant la sélectivité et la stabilité dans les Transformers pré-normalisés par couche.

4. Pipeline d'Entraînement de Bout en Bout

ZetaGPT fournit un pipeline entièrement open-source couvrant :

Tokenizer : Byte-level Byte-Pair Encoding (BPE) entraîné sur le corpus de pré-entraînement, résultant en un vocabulaire de 50 259 jetons.
Pré-entraînement : Entraîné sur le corpus WikiText-103.
Ajustement Supervisé (SFT) : Aligné via le jeu de données d'instruction Alpaca-GPT4.
Apprentissage par Renforcement (RLHF) : Inclut l'entraînement du modèle de récompense et l'optimisation des préférences.
Chaîne de Pensée (CoT) : Développée via l'apprentissage par renforcement pur utilisant le Group Relative Policy Optimization (GRPO) sur le benchmark GSM8K, permettant des capacités de raisonnement sans démonstrations de CoT supervisées.

Contributions Clés

Modèle État-Espace–Attention sans Encodage Positionnel : ZetaGPT est un modèle de langage compact où des équations d'état-espace causales précèdent l'auto-attention dans chaque bloc. Cette conception permet à l'évolution de l'état récurrent de représenter implicitement l'information positionnelle, supprimant le besoin d'encodages positionnels explicites.
Implémentation de Référence : À la connaissance de l'auteur, ZetaGPT est le premier petit modèle de langage open-source sans encodage positionnel explicite. Il sert de référence compacte et reproductible pour l'étude empirique des architectures sans encodage positionnel.
Pipeline d'Entraînement Complet : Ce travail présente un pipeline complet, de la construction du jeu de données et de l'entraînement du tokenizer jusqu'au pré-entraînement, au SFT, au RLHF et au raisonnement CoT via l'apprentissage par renforcement, fournissant une recette unifiée pour construire des petits LLM modernes.

Résultats et Observations

L'article rend compte de la dynamique d'entraînement des modules d'état-espace pendant le pré-entraînement (sur plus de 12 800 étapes) :

Émergence d'une Mémoire Multi-Échelle : Le modèle apprend plusieurs échelles de temps de mémoire. Les couches peu profondes conservent des horizons de mémoire plus longs, tandis que les couches intermédiaires développent des horizons plus courts, créant une hiérarchie de représentations temporelles.
Sélectivité de l'Entrée : Les coefficients de décroissance deviennent de plus en plus dépendants de l'entrée, permettant à l'horizon de mémoire de s'adapter au contexte local.
Contribution Résiduelle : La contribution du module d'état-espace au flux résiduel croît tout au long de l'entraînement, indiquant que le réseau repose de plus en plus sur ces dynamiques apprises.
Canaux Hétérogènes : La distribution de la décroissance évolue pour inclure des canaux à mémoire longue ( $a > 0.99$ ) et à mémoire courte ( $a < 0.5$ ), démontrant une organisation automatique en plages temporelles distinctes.

Les configurations du modèle varient de ZetaGPT-S (34,4M de paramètres, 6 couches) à ZetaGPT-L (479,9M de paramètres, 24 couches). Les longueurs de contexte sont traitées comme des configurations d'entraînement (256, 512, 1024 jetons) plutôt que comme des contraintes architecturales.

Signification et Limites

Signification :
ZetaGPT établit une base compacte et reproductible pour le développement de modèles de langage sans encodage positionnel. En démontrant que l'information positionnelle peut être représentée implicitement par les dynamiques architecturales plutôt que par des a priori injectés, il offre une nouvelle voie pour la recherche sur la modélisation de contextes longs et l'extrapolation de contexte qui ne dépend pas de la modification des mécanismes d'encodage explicites.

Limites :
L'auteur note explicitement que les limites découlent des contraintes de calcul plutôt que de l'architecture elle-même :

Échelle des Données : Le corpus de pré-entraînement (WikiText-103) est modeste, manquant de la diversité et des connaissances du monde des modèles entraînés sur des trillions de jetons.
Échelle du Modèle : La configuration par défaut (34,4M de paramètres) est petite ; les dynamiques observées ici peuvent ne pas se transférer directement à des modèles beaucoup plus grands.
Longueur de Contexte : Le pré-entraînement est limité à des contextes courts (jusqu'à 1024 jetons), empêchant une évaluation complète de la modélisation ou de l'extrapolation de contextes longs.

Le travail positionne principalement ZetaGPT comme un outil de recherche, de prototypage rapide, de vérification d'algorithmes et d'éducation, plutôt que comme un modèle de langage à grande échelle prêt pour la production.