State Space Models et Mamba (au-delà des Transformers)

Les Transformers dominent l'IA depuis 2017, mais leur mécanisme d'attention paie un prix : son coût croît avec le carré de la longueur de la séquence. Doubler le contexte quadruple le calcul, et le cache mémoire enfle linéairement à chaque jeton généré. Les modèles d'espace d'états (State Space Models, SSM) — et leur incarnation la plus aboutie, Mamba — proposent une autre voie : un coût linéaire en longueur, une inférence à mémoire constante, et des performances qui, pour la première fois, rivalisent avec l'attention sur le langage. Cet article explique d'où viennent les SSM, comment S4 a débloqué la mémoire longue, pourquoi Mamba rend l'état sélectif, et où ces architectures gagnent — ou perdent — face aux Transformers.

Pourquoi chercher une alternative à l'attention

L'auto-attention compare chaque jeton à tous les autres. Pour une séquence de longueur n, cela construit une matrice de scores n × n : le temps et la mémoire d'entraînement croissent en O(n²). C'est précisément ce qui rend l'attention si expressive (chaque position « voit » directement toutes les autres), mais aussi ce qui la rend coûteuse sur les longues séquences : documents entiers, génomes, audio brut, longues sessions d'agents.

À l'inférence autoregressive, le problème prend une autre forme : pour ne pas recalculer le passé, on conserve un cache KV (clés et valeurs) qui grandit à chaque jeton. La mémoire occupée croît donc linéairement avec le contexte, et chaque nouveau jeton doit attendre la lecture de ce cache de plus en plus gros. C'est la rançon de l'expressivité.

Un ordre de grandeur concret : pour une fenêtre de 32 768 jetons, la seule matrice d'attention contient plus d'un milliard d'entrées par tête et par couche. Avec quelques dizaines de têtes et de couches, le pic mémoire d'entraînement explose, et c'est ce mur quadratique — pas la qualité — qui borne en pratique la longueur de contexte.

Figure : attention quadratique O(n²) contre récurrence SSM linéaire O(n).

De nombreuses alternatives sous-quadratiques ont été proposées — attention linéaire, convolutions à portes, RNN modernisés, SSM. Le verdict de Gu & Dao est net : jusqu'à Mamba, aucune n'égalait l'attention sur les modalités importantes comme le langage. Comprendre pourquoi exige de revenir à la racine : les modèles d'espace d'états classiques.

Ce qu'on attend d'un bloc de séquence

Avant de plonger, fixons le cahier des charges. Un bon bloc de mélange de séquence devrait : (1) s'entraîner en parallèle sur GPU pour absorber des téraoctets de texte ; (2) inférer vite, idéalement à coût mémoire borné ; (3) router l'information selon le contenu, pas seulement selon la position. L'attention coche (1) et (3) mais rate (2) ; les RNN classiques cochent (2) mais ratent (1). Les SSM visent les trois à la fois — c'est tout l'enjeu de l'histoire qui suit.

Les modèles d'espace d'états classiques

Le SSM est un objet vieux de plusieurs décennies, issu de l'automatique et du traitement du signal (filtres de Kalman, théorie du contrôle). Dans sa forme continue, il relie un signal d'entrée u(t) à une sortie y(t) via un état latent x(t) de dimension N :

x'(t) = A x(t) + B u(t)      (dynamique de l'état)
y(t)  = C x(t) + D u(t)      (équation de sortie)

Quatre matrices gouvernent le système : A décrit comment l'état évolue tout seul (la « mémoire »), B comment l'entrée y est injectée, C comment on lit la sortie depuis l'état, et D une connexion directe entrée→sortie (souvent vue comme un saut résiduel). L'intuition centrale : l'état x(t) est un résumé compressé de tout le passé du signal, de taille fixe N, quelle que soit la longueur de la séquence.

Pour ancrer l'idée, prenez A scalaire négatif, disons A = −1, sans entrée : l'état suit x'(t) = −x(t), donc x(t) = x(0)·e^{−t} — une décroissance exponentielle. C'est un filtre à fuite (leaky integrator) : l'état oublie son passé à un rythme dicté par A. Multipliez N de ces filtres avec des taux différents et vous obtenez une banque de mémoires à des échelles de temps variées — l'embryon de ce que HiPPO formalisera.

Discrétisation : du continu au discret

Le langage et la plupart des données arrivent en pas discrets, pas en temps continu. On discrétise donc le système avec un pas Δ (delta), typiquement via un zero-order hold. Cela transforme A et B continus en versions discrètes Ā et B̄ :

Ā = exp(Δ A)
B̄ = (Δ A)⁻¹ (exp(Δ A) − I) · Δ B   ≈   Δ B
hₜ = Ā hₜ₋₁ + B̄ xₜ
yₜ = C hₜ + D xₜ

Le pas Δ joue un rôle d'échelle de temps : un grand Δ fait « oublier » l'état (il privilégie l'entrée courante), un petit Δ le fait persister (mémoire longue). Retenez ce paramètre : c'est lui que Mamba rendra dépendant du contenu.

Intuition de la formule : Ā = exp(Δ A) est simplement la solution exacte de l'EDO linéaire sur un intervalle de durée Δ. Sur notre exemple A = −1, on a Ā = e^{−Δ} : avec Δ = 0,1, Ā ≈ 0,90 (l'état garde 90 % de sa valeur à chaque pas, mémoire longue) ; avec Δ = 3, Ā ≈ 0,05 (il oublie presque tout, mémoire courte). Ce seul nombre règle donc la portée temporelle du modèle.

Deux visages : récurrent et convolutif

La force des SSM linéaires invariants dans le temps (LTI, c'est-à-dire A, B, C, Δ fixes) est de posséder deux représentations mathématiquement équivalentes :

• Vue récurrente : on applique hₜ = Ā hₜ₋₁ + B̄ xₜ pas à pas. Coût O(n), mémoire constante (on ne garde que l'état courant). Idéale à l'inférence — c'est un RNN.
• Vue convolutive : comme les paramètres ne changent pas dans le temps, dérouler la récurrence donne une convolution par un noyau global K précalculé. Coût parallélisable sur GPU, idéal à l'entraînement — comme une CNN.

Déroulons explicitement pour voir d'où sort le noyau. En partant de h₋₁ = 0 :

h₀ = B̄ x₀
h₁ = Ā B̄ x₀ + B̄ x₁
h₂ = Ā² B̄ x₀ + Ā B̄ x₁ + B̄ x₂
yₜ = Σ_{k=0..t}  (C Āᵏ B̄) · xₜ₋ₖ        ← convolution par K
K  = (C B̄, C Ā B̄, C Ā² B̄, …, C Ā^{n−1} B̄)

Chaque sortie est donc une convolution de l'entrée par le noyau K, dont les coefficients sont les puissances C Āᵏ B̄. On entraîne en mode convolution (parallèle, rapide, souvent via FFT) et on infère en mode récurrent (linéaire, mémoire constante). Le meilleur des deux mondes — à condition que les paramètres restent fixes dans le temps. C'est exactement cette condition que Mamba va briser.

Comment lire l'état

Pour l'intuition, pensez à l'état hₜ comme à un registre compressé qui accumule l'histoire vue jusqu'ici.

À chaque pas, deux forces s'affrontent : Ā hₜ₋₁ fait survivre l'ancien contenu (la mémoire), et B̄ xₜ y injecte la nouvelle information.

La matrice A décide du taux d'oubli : ses valeurs propres, proches de 1, font durer la mémoire ; loin de 1, elles l'effacent vite.

C'est pourquoi l'initialisation de A n'est pas anodine — un mauvais A condamne l'état à oublier presque tout, quelle que soit la qualité du reste du réseau.

S4 : structurer l'état pour la mémoire longue

Naïvement, calculer le noyau de convolution d'un SSM est numériquement instable et coûteux, et un A aléatoire oublie le passé presque immédiatement. S4 (Structured State Space, Gu, Goel & Ré, 2021) a résolu les deux problèmes.

D'abord, l'initialisation HiPPO. HiPPO (High-order Polynomial Projection Operators) fournit une matrice A particulière qui fait mémoriser à l'état une approximation de tout l'historique du signal, en le projetant sur une base de polynômes orthogonaux (typiquement des polynômes de Legendre). Concrètement, l'état devient un jeu de coefficients qui reconstruit au mieux la fonction passée — une mémoire compressée mais structurée. Les ablations sont sans appel : remplacer la matrice HiPPO par une matrice aléatoire effondre les performances. La mémoire longue n'est pas un accident, elle est câblée dans A.

Ensuite, une paramétrisation structurée (diagonale plus rang faible, dite DPLR) rend le calcul du noyau stable et efficace. Plutôt que d'élever une matrice pleine N × N à des puissances successives (coûteux et instable), S4 exploite cette structure pour calculer le noyau via une fraction rationnelle et une FFT, ramenant l'entraînement à un coût quasi linéaire en longueur. C'est cette astuce algébrique qui a débloqué l'entraînement à grande échelle.

Le résultat a marqué les esprits sur le Long Range Arena (LRA), une suite de tâches conçue pour stresser la dépendance à long terme. S4 y a établi l'état de l'art sur toutes les tâches, et fut le premier modèle à résoudre Path-X — une tâche sur des séquences de 16 384 éléments où les Transformers échouaient purement et simplement. Des variantes comme S5 ont ensuite simplifié l'architecture (un seul SSM multi-entrées, balayage parallèle) tout en gardant la performance, et DSS / S4D ont montré qu'une paramétrisation purement diagonale suffit souvent, simplifiant encore l'implémentation.

Ce succès a aussi clarifié un point conceptuel : un SSM profond n'est ni vraiment un RNN, ni vraiment une CNN, mais un objet qui peut emprunter les deux algorithmes selon le besoin. C'est cette flexibilité — récurrence pour l'inférence, convolution pour l'entraînement — qui a fait des SSM une alternative crédible, là où les RNN classiques (LSTM, GRU) butaient sur l'entraînement séquentiel et les gradients qui s'évanouissent.

La limite cachée : l'invariance dans le temps

Tout l'édifice S4 repose sur la propriété LTI : A, B, C, Δ sont les mêmes pour chaque jeton. C'est ce qui autorise la vue convolutive et donc l'entraînement efficace. Mais c'est aussi son talon d'Achille.

Un système LTI traite chaque entrée de façon identique, indépendamment de son contenu. Il ne peut pas décider « ce jeton est important, je le mémorise » ni « celui-ci est du bruit, je l'ignore ». Or c'est précisément ce que l'attention fait naturellement : sélectionner. Gu & Dao l'illustrent avec deux tâches-jouets — Selective Copying (copier en ignorant des distracteurs) et Induction Heads (retrouver un motif vu plus tôt) — que les SSM LTI échouent à résoudre, faute de pouvoir filtrer selon le contenu. Le problème n'est pas la capacité de mémoire ; c'est l'absence de sélection.

Le diagnostic est subtil : un noyau de convolution fixe applique le même filtre où que se trouve l'information pertinente. Si le jeton à copier peut apparaître à n'importe quelle position, aucun filtre statique ne peut le cibler de façon fiable. Il faudrait que la dynamique réagisse au contenu — exactement ce que la convolution LTI interdit par construction.

Mamba : rendre l'état sélectif

L'idée de Mamba (Gu & Dao, 2023) tient en une phrase : laisser les paramètres du SSM dépendre de l'entrée. Concrètement, B, C et surtout le pas Δ deviennent des fonctions du jeton courant xₜ, calculées par des projections linéaires. Le système devient variant dans le temps : à chaque position, il peut moduler sa dynamique.

Cela donne le mécanisme de sélection qui manquait. Via Δ(xₜ), le modèle peut, selon le contenu : faire persister l'état (mémoriser un jeton clé) ou le réinitialiser (oublier un distracteur). C'est un raisonnement fondé sur le contenu, exactement ce que l'attention apporte — mais ici sans matrice n × n.

L'analogie est éclairante : un Δ grand pousse Ā = exp(Δ A) vers 0 et remet l'état à zéro sur ce jeton (« porte d'entrée » grande ouverte, on écrase le passé) ; un Δ petit garde Ā ≈ 1 et laisse passer l'état presque intact (on ignore l'entrée courante). En rendant Δ dépendant du jeton, Mamba retrouve les portes des LSTM (oubli/entrée), mais dans un cadre SSM qui reste linéaire en l'état et donc parallélisable.

Figure : bloc Mamba — SSM sélectif et balayage parallèle conscient du matériel.

Le prix de la sélectivité — et la parade matérielle

Rendre les paramètres dépendants du temps a un coût immédiat : on perd la vue convolutive. Le noyau global K n'existe plus, puisque la dynamique change à chaque pas. On retombe sur la récurrence — séquentielle par nature, donc a priori hostile aux GPU.

La contribution d'ingénierie de Mamba est un algorithme parallèle conscient du matériel (hardware-aware parallel scan). La récurrence linéaire est associative, ce qui autorise un scan parallèle (à la Blelloch) en O(log n) étapes au lieu d'une boucle séquentielle de n pas. Surtout, l'implémentation exploite la hiérarchie mémoire du GPU : les paramètres et l'état sont matérialisés dans la SRAM rapide (et non dans la HBM lente), et l'état intermédiaire n'est jamais écrit en entier en mémoire globale — il est recalculé lors de la rétropropagation (recomputation), comme une fusion de noyaux à la FlashAttention. Le bloc Mamba supprime aussi attention et MLP : c'est une architecture homogène, empilable.

Pourquoi la SRAM change tout : sur un GPU, lire/écrire en HBM coûte un ordre de grandeur de plus qu'en SRAM. Une récurrence naïve qui matérialiserait l'état (longueur × N) en HBM serait dominée par ce trafic mémoire (memory-bound). En gardant le travail en SRAM et en ne recalculant l'état qu'au besoin, Mamba transforme une opération mémoire-limitée en opération calcul-limitée — exactement la leçon de FlashAttention appliquée au scan.

# SSM sélectif (pseudo-code simplifié) : B, C, Δ dépendent de l'entrée.
def selective_ssm(x):            # x : (longueur, dim)
    delta = softplus(proj_delta(x))      # pas Δ dépendant du jeton
    B = proj_B(x)                        # entrée  -> état, dépend de x
    C = proj_C(x)                        # état    -> sortie, dépend de x
    A_bar = exp(delta[..., None] * A)    # discrétisation : A fixe, modulé par Δ
    B_bar = delta[..., None] * B

    h = zeros(state_dim)                 # état initial (taille fixe)
    ys = []
    for t in range(len(x)):              # en pratique : scan parallèle, pas une boucle
        h = A_bar[t] * h + B_bar[t] * x[t]   # hₜ = Ā·hₜ₋₁ + B̄·xₜ
        ys.append(C[t] @ h)                   # yₜ = C·hₜ
    return stack(ys) + D * x             # + saut résiduel

Notez que A reste un paramètre appris fixe ; c'est Δ (et donc Ā = exp(Δ A)), B et C qui varient avec le jeton. La sélectivité tient entièrement dans cette dépendance à l'entrée, calculée par de simples projections linéaires bon marché.

Les résultats de Mamba

Les chiffres rapportés sont marquants : un débit d'inférence 5× supérieur à celui des Transformers, un passage à l'échelle linéaire en longueur, et des gains qui se maintiennent jusqu'à des séquences d'un million d'éléments. En modélisation du langage, Mamba-3B égale ou dépasse des Transformers de deux fois sa taille, en pré-entraînement comme en aval. Et l'architecture est généraliste : elle excelle aussi en audio et en génomique. Sur les tâches-jouets qui mettaient S4 en échec — Selective Copying, Induction Heads — Mamba les résout, confirmant que la sélectivité, et non la simple capacité de mémoire, était la pièce manquante.

Le tableau des complexités

Pour fixer les idées, voici le cœur du compromis, résumé par grandeur dominante :

• Attention : entraînement O(n²·d), mémoire d'entraînement O(n²), inférence par jeton O(n·d) avec un cache KV en O(n).
• SSM LTI (S4) : entraînement O(n·d) (en mode convolution via FFT), inférence par jeton O(d) avec un état en O(N) constant.
• SSM sélectif (Mamba) : entraînement O(n·d) via balayage parallèle, inférence par jeton O(d), état constant O(N) — mais sans la vue convolution, d'où l'algorithme conscient du matériel.

La ligne qui change tout est la dernière colonne : avec un Transformer, le coût mémoire à l'inférence croît avec le contexte (le cache KV) ; avec un SSM, il reste plat. Sur une fenêtre de 100K jetons, cette différence se chiffre en gigaoctets de VRAM et en latence par jeton. Et comme la latence par jeton d'un SSM ne dépend pas de la longueur déjà générée, la génération longue garde un débit constant, là où un Transformer ralentit à mesure que son cache enfle.

Mamba-2 et la dualité SSM ↔ attention

En 2024, Dao & Gu ont noué un pont théorique inattendu avec Structured State Space Duality (SSD). L'idée : un SSM avec une matrice d'état « scalaire fois identité » est équivalent à une forme d'attention causale masquée (un masque dit 1-semiseparable). Autrement dit, la même transformation de séquence admet deux algorithmes : une récurrence en O(n) ou une attention en O(n²) — deux faces d'une même pièce.

Cette dualité n'est pas qu'élégante : elle est pratique. Elle permet de reformuler le calcul du SSM en multiplications de matrices structurées, donc d'exploiter les unités matricielles ultra-optimisées des GPU (les tensor cores) plutôt qu'un scan sur mesure. Le cœur de Mamba-2 est ainsi 2 à 8× plus rapide que celui de Mamba-1, tout en restant compétitif avec les Transformers. SSD réconcilie en partie les deux mondes : l'attention et les SSM ne sont pas des rivaux étrangers, mais des cas particuliers d'une même famille.

Concrètement, l'algorithme SSD découpe la séquence en blocs (chunks) de taille Q (typiquement 64 à 256 jetons). À l'intérieur d'un bloc, il calcule la transformation comme une attention quadratique sur Q × Q (rapide grâce aux tensor cores) ; entre les blocs, il propage l'état récurrent d'un bloc au suivant en O(1). On obtient ainsi le meilleur des deux formes : la parallélisation matricielle intra-bloc et la linéarité inter-blocs. Mamba-2 autorise aussi des dimensions d'état beaucoup plus grandes (de l'ordre de 8× celles de Mamba-1) à coût comparable, ce qui augmente la capacité de mémoire du modèle.

Les hybrides : le meilleur des deux mondes

Si l'attention excelle au rappel précis et les SSM à l'efficacité, pourquoi choisir ? Les architectures hybrides entrelacent les deux. Le plus marquant est Jamba (AI21 Labs, 2024), premier modèle Mamba de qualité production. Sa recette :

• des blocs alternés mêlant couches Mamba et couches d'attention, dans un ratio d'environ une couche d'attention pour huit couches au total (le fameux 1
  ) ;
• du Mixture-of-Experts (MoE) appliqué une couche sur deux, pour gonfler la capacité totale tout en gardant peu de paramètres actifs par jeton (donc un coût d'inférence maîtrisé) ;
• un contexte de 256K jetons, là où les MLP/attention seuls deviendraient prohibitifs.

Le Jamba original n'active que 12 Mds de paramètres sur 52 Mds au total grâce au MoE, et tient jusqu'à 140K jetons sur un seul GPU de 80 Go — un profil mémoire impensable pour un Transformer dense de taille comparable. Jamba 1.5 décline ensuite deux tailles : Mini (12 Mds de paramètres actifs) et Large (94 Mds actifs), toutes deux à 256K de contexte effectif. Les quelques couches d'attention restaurent le rappel précis que le Mamba pur peine à fournir, tandis que l'ossature SSM assure le débit et la mémoire constante sur les longs contextes. Le compromis est désormais un réglage de proportions, pas un choix binaire.

D'autres familles explorent la même piste avec des dosages différents. Certaines remplacent presque toutes les couches d'attention par des couches SSM en n'en gardant qu'une poignée bien placées ; d'autres distillent un Transformer pré-entraîné vers un backbone SSM pour récupérer le savoir quadratique à coût sous-quadratique. Le principe commun : utiliser l'attention avec parcimonie, là où le rappel exact compte, et confier le reste — l'essentiel du flux — à un mécanisme linéaire.

Où les SSM brillent en pratique

Au-delà du langage, la mémoire constante et le coût linéaire ouvrent des domaines mal servis par l'attention :

• Génomique : des séquences d'ADN de centaines de milliers de bases, où la fenêtre d'un Transformer serait prohibitive.
• Audio brut et formes d'onde : des signaux très longs et finement échantillonnés.
• Séries temporelles et capteurs : flux continus où l'état récurrent à taille fixe est naturel.
• Vision et modèles séquentiels d'images, où des variantes de Mamba balaient les patches.

Le fil rouge : dès que la longueur devient le facteur limitant et que le rappel verbatim n'est pas critique, le profil de coût des SSM devient décisif.

Forces et faiblesses face aux Transformers

Récapitulons le compromis, sans angélisme.

Forces des SSM / Mamba :

• Passage à l'échelle linéaire en longueur de séquence à l'entraînement (vs quadratique).
• Inférence rapide à mémoire constante : l'état a une taille fixe, il n'y a pas de cache KV qui enfle — d'où le débit ~5× supérieur.
• Contextes très longs abordables (documents, génomes, audio, séries temporelles).
• Architecture homogène et empilable (ni attention ni MLP requis dans le bloc de base).

Faiblesses face aux Transformers :

• Rappel et copie en contexte : un état comprimé de taille fixe est, par construction, un goulot d'étranglement pour la récupération exacte d'informations arbitraires vues plus tôt (copie verbatim, recherche d'un fait précis dans une longue fenêtre). L'attention, qui garde tout dans son cache KV, y reste supérieure — d'où l'intérêt des hybrides.
• Maturité de l'écosystème : l'outillage, le tuning, les recettes et le matériel sont massivement optimisés pour l'attention ; les SSM rattrapent, mais partent de loin.
• Interprétabilité : la dynamique d'un état récurrent est moins lisible que des cartes d'attention.

Une façon nette de résumer la faiblesse de rappel : l'attention dispose d'une mémoire en lecture aléatoire (tout le passé reste adressable via le cache KV), tandis qu'un SSM n'a qu'une mémoire compressée à écrasement de taille N. Au-delà de cette capacité, retrouver verbatim un jeton arbitraire devient un pari — d'où la persistance de quelques têtes d'attention dans les hybrides.

Pièges et conseils pratiques

Quelques garde-fous pour qui veut expérimenter avec ces architectures.

• Ne confondez pas taille d'état et fenêtre de contexte. Un SSM voit toute la séquence, mais ce qu'il retient est borné par la dimension N de l'état ; augmenter N augmente la capacité de mémoire, à un coût.
• Le rappel exact reste un point faible. Pour un cas d'usage de type « retrouve cette chaîne précise dans 50 pages », un Mamba pur déçoit souvent ; préférez un hybride ou conservez quelques têtes d'attention.
• Le pas Δ est sensible. Mal initialisé (via le softplus et son biais), il peut faire saturer ou s'évanouir l'état ; suivez les recettes d'initialisation publiées plutôt que d'improviser.
• Mesurez sur VOTRE longueur réelle. Les gains des SSM se révèlent surtout sur les longs contextes ; sur des séquences courtes, l'avantage face à un Transformer bien optimisé peut être marginal.
• L'écosystème évolue vite. Noyaux CUDA, variantes (Mamba-2, hybrides) et supports d'inférence changent au fil des mois ; vérifiez l'état du support avant de bâtir en production.
• Choisissez Mamba-2 plutôt que Mamba-1 par défaut. Pour un nouveau projet, la dualité SSD donne un noyau plus rapide et des états plus grands à coût comparable ; réservez Mamba-1 aux cas où une dépendance existante l'impose.

État actuel et perspectives

Les SSM sélectifs sont passés du laboratoire à la production en deux ans. Mamba et Mamba-2 sont des dorsales sérieuses ; Jamba et d'autres hybrides montrent qu'on peut combiner efficacité SSM et précision de l'attention dans un même modèle, jusqu'à des centaines de milliers de jetons de contexte. La dualité SSD a, au passage, brouillé la frontière théorique entre les deux familles.

La leçon n'est pas « les SSM remplacent les Transformers », mais « le bloc de séquence n'est plus un monopole ». Selon la tâche — débit et long contexte, ou rappel exact — on dosera attention et SSM. Pour un site qui sert le même contenu aux humains et aux agents, c'est une bonne nouvelle : les futurs lecteurs IA pourront avaler des contextes plus longs, plus vite, à coût plus prévisible. L'attention reste reine du rappel ; les SSM lui imposent désormais un partage du trône.

En résumé

Les modèles d'espace d'états reformulent la modélisation de séquences autour d'un état latent de taille fixe plutôt que d'une comparaison de tous les jetons entre eux.

S4 a montré qu'avec la bonne structure (HiPPO, paramétrisation diagonale plus rang faible) on pouvait capturer des dépendances sur des dizaines de milliers de pas.

Mamba a ajouté la sélectivité — des paramètres qui dépendent de l'entrée — et un balayage parallèle conscient du matériel qui rend la chose praticable sur GPU.

Mamba-2 a relié SSM et attention par la dualité SSD, et les hybrides comme Jamba ont prouvé qu'on peut combiner les deux à l'échelle de la production.

Le résultat net : un éventail d'architectures où l'on choisit son point sur l'axe efficacité ↔ rappel exact, au lieu d'un Transformer par défaut.