Des modèles opaques pour l’humain
Les grands modèles de langage (LLM) comme Claude 3.5 Haiku produisent aujourd’hui des textes cohérents, argumentés. Ils peuvent aussi générer du code, produire des images, ou répondre à des requêtes complexes — bien au-delà de la simple rédaction de texte. Ils sont désormais intégrés à des interfaces grand public, à des assistants professionnels, et à des outils d’aide à la décision — y compris dans le domaine médical.
Pourtant, leurs concepteurs eux-mêmes ne savent pas exactement comment ils fonctionnent en pratique. Des équipes entières sont dédiées à l’interprétation de modèles qu’ils ont pourtant entraînés — sans en maîtriser concrètement les mécanismes internes.
Cette opacité cognitive soulève une question majeure : comment réguler une technologie dont les rouages restent partiellement inaccessibles, y compris à ceux qui l’ont conçue ? Alors même que l’intelligence artificielle dite ‘générale’ — théoriquement plus puissante et plus autonome — n’existe pas, les LLM, formes d’IA dites “étroites”, produisent déjà des comportements que nous ne savons pas entièrement expliquer, ni anticiper.
Alors, pour commencer à percer cette boîte noire, il faut comprendre les principes selon lesquels les LLM sont construits. Que se passe-t-il réellement dans leurs « couches internes » ? Que signifie « comprendre » un mot pour un modèle ?
Les LLM sont constitués de dizaines de couches, empilant chacune des milliers de “neurones” artificiels. Mais ce terme, hérité d’une métaphore biologique, est trompeur. Un neurone artificiel ne fonctionne en réalité pas sur le principe d’un neurone humain.
Il s’agit plutôt d’une fonction mathématique : il prend plusieurs valeurs en entrée, les pondère (c’est-à-dire qu’il attribue à chacune un certain poids) puis applique une règle pour produire une valeur de sortie. Cette règle, appelée fonction d’activation, détermine à quel point le neurone “s’active” — c’est-à-dire si sa sortie est proche de zéro (rien d’intéressant détecté), ou plus élevée (le neurone reconnaît un motif qu’il a appris à détecter).
Au fil de l’entraînement, chaque neurone se spécialise dans la détection de certains motifs linguistiques — une construction syntaxique (comme une subordonnée concessive), un ton implicite (comme l’ironie ou l’attente déçue), ou une association récurrente entre mots (comme “cause” suivi de “conséquence”).
Chaque neurone correspond donc à un ensemble de poids — autrement dit, à une certaine “direction” dans l’espace des données. Il est sensible à certains motifs : quand les données vont dans cette direction, il s’active ; sinon, il reste silencieux. On peut imaginer chaque neurone comme une antenne orientée dans une direction précise : il ‘capte’ un motif quand les données pointent dans sa direction, et reste muet sinon.
📌 Par exemple, un neurone pourrait apprendre à s’activer lorsqu’il rencontre une formulation ironique, comme : « Quelle brillante idée, vraiment. » ou « C’est sûr que tout va parfaitement bien. »
Il ne réagit pas à un mot isolé, mais à un motif latent dans la phrase — un décalage entre la formulation littérale et le sens implicite. Ce motif, le neurone l’a appris à repérer à force d’en voir des milliers de variantes durant l’entraînement.
Mais ces “valeurs en entrée”, que sont-elles dans un modèle de langage ?
À chaque étape du traitement, chaque mot (ou token) est représenté par un vecteur de centaines ou de milliers de nombres. Chaque dimension de ce vecteur capture un aspect particulier du sens ou de l’usage du mot dans son contexte : certaines dimensions peuvent refléter des catégories grammaticales, d’autres des proximités sémantiques, des connotations, ou des relations conceptuelles implicites.
Ce vecteur ne se lit pas coordonnée par coordonnée, mais fonctionne comme une empreinte contextuelle compacte : une synthèse chiffrée de tout ce que le modèle « comprend » du mot à cet instant, en tenant compte de son sens, de sa fonction, et de son environnement linguistique.
Ce vecteur encode non seulement le mot lui-même, mais aussi le contexte dans lequel il apparaît — grâce aux couches précédentes du modèle, et notamment aux mécanismes d’attention.
Le mécanisme d’attention permet au modèle de pondérer l’influence de chaque mot de la séquence sur chaque autre. Lorsqu’un token est traité, le modèle regarde en parallèle tous les autres tokens précédents, et décide à qui il doit “prêter attention” — c’est-à-dire quelle information contextuelle réutiliser pour construire sa propre représentation vectorielle.
Par exemple, dans la phrase « Elle prit le livre et le posa sur la table », le mot “le” est ambigu. L’attention permet au modèle de retrouver que “le” renvoie à “livre”, car c’est le mot qui a reçu le plus de poids contextuel au bon moment. Chaque neurone ne voit donc pas directement les mots, ni même leur ordre exact, mais des vecteurs déjà enrichis par l’attention, qui résument ce qu’il y a à savoir sur un mot dans son contexte. Ce sont ces vecteurs — produits et raffinés couche après couche — que les neurones reçoivent en entrée.
Mais pris isolément, un neurone ne comprend rien. Il n’est qu’un filtre statistique. Ce qui rend les modèles puissants, c’est l’effet combiné de millions de ces filtres, empilés et interconnectés dans l’ensemble du réseau.
Le problème, c’est que ces neurones sont souvent polyvalents, et donc ambigus : un même neurone peut participer à des fonctions très différentes selon le contexte. Et les comportements du modèle — écrire un poème, résoudre une analogie, planifier une rime — n’émergent pas d’un neurone, ni même d’un groupe fixe, mais de l’interaction de milliers d’unités distribuées à travers le réseau.
Comprendre ce que perçoit un neurone, ce qu’il déclenche, et comment il interagit avec les autres, n’est pas un exercice de style : c’est une étape indispensable pour espérer un jour superviser — ou encadrer — les décisions prises par ces modèles à grande échelle.
Pour comprendre ce qu’il se passe à l’intérieur, les chercheurs d’Anthropic ont adopté une approche inspirée de la biologie. Présentée dans leur article Circuit Tracing: Revealing Computational Graphs in Language Models et appliquée à Claude dans On the Biology of a Large Language Model, , cette méthode vise à cartographier les circuits internes activés par une tâche donnée.
Comme on utilise un microscope pour observer les cellules, ils développent des outils pour révéler des “features” — des motifs internes récurrents, portés par l’activité du modèle, et partiellement interprétables. À l’aide de ce qu’ils appellent des attribution graphs, ils tracent des circuits internes activés par certaines tâches, comme écrire un couplet rimé.
Une manière de passer du comportement observable à la structure sous-jacente. Et peut-être, un jour, de transformer ces intelligences opaques en systèmes réellement interprétables — et donc contrôlables.
Un nouveau type de microscope : les features
Comprendre un grand modèle de langage comme Claude 3.5, ce n’est pas comme lire du code. Ce modèle ne contient aucune règle explicite, aucun module dédié à l’ironie, à la grammaire ou au raisonnement.
Il fonctionne en appliquant, à chaque étape, des opérations matricielles massives sur des vecteurs de grande dimension — des milliers de multiplications et de combinaisons linéaires. Ces calculs sont difficilement interprétables car ils reposent sur des vecteurs de milliers de dimensions, traités à travers des multiplications de matrices empilées sur des dizaines de couches de neurones artificiels.
À chaque étape, le modèle combine l’information de manière complexe : il réinjecte des fragments de contexte, transforme les représentations internes, et redistribue l’attention sur différents tokens. Le résultat est une dynamique computationnelle très efficace, mais impossible à lire directement : il n’existe aucune variable nommée “idée principale” ou “rime attendue” dans les poids du modèle.
Résultat : ces opérations sont trop dispersées, trop opaques pour être interprétées directement par un humain.
Sparse coding : rendre visible ce qui est épars
Pour percer cette opacité, les chercheurs utilisent une technique appelée sparse coding : elle consiste à approximer les représentations internes du modèle par des combinaisons plus simples et plus parcimonieuses, où seules quelques unités s’activent à la fois.
Techniquement, cela revient à projeter les activations originales dans un espace de dimension plus grande, via une multiplication matricielle, tout en pénalisant les composantes non nulles — afin de forcer des représentations clairsemées (d’où l’appellation de « sparse coding« ).
On parle d’espace plus grand, car le nombre de features disponibles est bien supérieur à celui des neurones initiaux (par exemple 30 millions au lieu de 4 096). Mais cet espace est plus parcimonieux, car à chaque instant, seules quelques features sont actives — la grande majorité restent nulles.
L’idée est donc de dilater l’espace des possibilités, tout en concentrant l’activation sur un petit nombre d’unités significatives. Cela permet de rendre l’information plus lisible : chaque feature devient plus expressive, plus spécifique, donc plus facile à interpréter – pour un humain.
Features
C’est grâce à cette simplification qu’on peut faire émerger des unités interprétables : les features.
Une feature est une brique de sens implicite qui apparaît dans l’activité du modèle. Elle ne fait pas partie de l’architecture d’origine, mais peut être identifiée a posteriori comme une activation récurrente et significative, associée à une idée, un motif, une structure intelligible pour nous.
📌 Par exemple, une feature pourrait s’activer chaque fois que le modèle rencontre une formulation exprimant une attente déçue, comme dans :
« Il avait tout prévu. Rien ne se passa comme prévu. »
ou
« Elle croyait à un miracle. Il n’est jamais venu. »
La feature ne réagit pas à un mot en particulier, mais à une configuration discursive dans laquelle une attente posée est contredite par la suite. Ce motif subtil, fréquent dans les récits, est statistiquement régulier dans les données d’entraînement : le modèle apprend à y répondre, sans jamais l’avoir formellement défini.
Il faut cependant préciser que ces features ne sont pas des entités “naturelles” dans le modèle. Ce ne sont pas des objets que le modèle manipule consciemment, ni des composants architecturaux identifiables dans les poids. Ce sont des outils d’interprétation construits par les chercheurs — une façon de projeter du sens sur l’activité interne du modèle, pour en extraire des motifs lisibles. Elles constituent seulement un modèle de lecture du modèle. Une feature n’est donc pas ce que “pense” le modèle, mais ce que nous repérons comme structure récurrente utile pour le comprendre.
D’un point de vue technique, chaque feature est une combinaison pondérée de plusieurs neurones, souvent répartis sur différentes couches. Elle s’active lorsqu’une certaine configuration du vecteur d’entrée est rencontrée — typiquement, un vecteur associé à un token dans son contexte. Contrairement aux neurones bruts, qui sont nombreux et faiblement actifs, les features extraites par sparse coding sont plus rares, mais plus ciblées. Elles agissent comme des capteurs spécialisés — des unités que l’on peut isoler, suivre, manipuler tout en comprenant leur signification.
Identifier les features, c’est dresser une cartographie partielle de l’activité interne du modèle. Chaque feature devient un point d’entrée vers une hypothèse sur le fonctionnement du réseau :
“Cette unité s’active lors d’une expression de doute”,
“celle-ci réagit aux constructions concessives, comme ‘même si’ ou ‘bien que’”,
“celle-là semble se déclencher face à une émotion implicite, comme la résignation”,
“une autre accompagne souvent des transitions narratives au passé”,
“celle-ci intervient dans la gestion de la rime dans un poème”,
ou encore :
“celle-là amplifie les contrastes logiques introduits par ‘mais’ ou ‘cependant’.”
Ces features ne sont pas isolées : elles s’organisent en réseaux. Certaines s’activent en chaîne, d’autres s’inhibent entre elles, et d’autres encore convergent pour renforcer une même sortie. On ne se contente plus de lire la réponse du modèle : on analyse les dynamiques internes — les influences distribuées — qui ont conduit à cette réponse.
C’est ce réseau d’interactions que les chercheurs cherchent à représenter — via un outil central : le graphe d’attribution.
Cartographier les circuits internes du modèle
Identifier des features permet de rendre visibles certaines unités internes du modèle, mais cela ne suffit pas à comprendre comment le LLM produit une sortie. Il faut aussi relier ces unités entre elles — comprendre comment elles interagissent, s’influencent, s’activent mutuellement pour produire une réponse.
C’est précisément le rôle des graphiques d’attribution (attribution graphs). Ces graphes représentent une hypothèse sur le cheminement computationnel qu’un modèle suit pour générer une sortie donnée. Ils ne décrivent pas l’intégralité du modèle, mais une trace locale, spécifique à un prompt donné, reconstruite a posteriori en suivant les activations et les interactions entre features.
🧩 De quoi s’agit-il concrètement ?
Un graphe d’attribution est un graphe orienté dans lequel les nœuds représentent des features (interprétables ou non), et les arêtes indiquent une influence causale estimée d’une feature sur une autre, ou sur la sortie finale.
La construction de ces graphes repose sur deux grandes étapes :
1. Attribution rétrospective (back attribution) : on part de la sortie (par exemple, le dernier token généré) et on remonte les activations internes qui y ont le plus contribué.
2. Quantification des liens : on estime quelles features intermédiaires ont activé (ou inhibé) d’autres features en amont, en analysant les poids du modèle et les dépendances locales.
Le résultat est une reconstruction partielle du “circuit” – du raisonnement – utilisé par le modèle pour transformer un contexte en prédiction. De la même façon que l’imagerie cérébrale montre quelles zones du cerveau s’activent pendant une tâche, le graphe d’attribution montre quelles features ont été impliquées dans un raisonnement précis, et comment elles se sont articulées entre elles.
Les attribution graphs permettent de :
– Suivre une prédiction jusque dans ses causes internes,
– Identifier les features qui portent les contraintes ou les choix clés,
– Formuler des hypothèses mécanistes sur ce que fait le modèle (“ici il planifie une rime”, “là il suit un raisonnement causal”),
– Et surtout : tester si ces hypothèses sont correctes grâce à des expériences de perturbation.
L’attribution graph nous donne en effet une hypothèse : telles features ont contribué à telle décision du modèle (par exemple, choisir “rabbit” comme rime). Mais il faut tester sa robustesse : est-ce que ces features sont vraiment causales, ou simplement corrélées à la sortie observée ? C’est ici qu’interviennent les expériences de perturbation, inspirées des sciences naturelles (biologie, neurosciences) : on modifie volontairement le comportement du modèle sur un point précis, et on observe l’impact sur la sortie.
🧩 Trois types d’interventions principales pour tester les hypothèses :
1. Suppression d’une feature
On force l’activation d’une feature donnée à zéro — comme si elle n’existait pas. C’est un peu comme couper une synapse.
→ Si la prédiction change (par exemple la rime finale), cela suggère que cette feature avait un rôle causal dans la production de la sortie.
2. Injection d’une feature étrangère
On active artificiellement une feature qui n’aurait normalement pas été déclenchée.
→ Si le modèle modifie sa génération pour intégrer cette “suggestion”, c’est qu’il utilise en réalité cette feature pour orienter sa réponse.
3. Substitution contextuelle
On modifie un mot en amont ou une structure, pour voir si les activations observées dans le graphe se maintiennent. → Cela permet de tester la spécificité du circuit observé : est-il stable ou contextuel ?
Ces techniques permettent de tester le rôle causal non seulement d’une feature prise isolément, mais aussi des interactions entre plusieurs features dans les circuits internes du modèle.
Planifier une rime : anatomie d’un poème
Ce qu’un LLM est censé faire
Claude 3.5 Haiku, comme tous les grands modèles de langage actuels, est un modèle auto-régressif de type Transformer. Son objectif est simple : prédire le prochain token (mot, sous-mot, ou caractère) en fonction de tous les tokens précédents. Plus précisément, à chaque étape, le modèle reçoit une séquence d’entrée et produit une distribution de probabilité sur le prochain token. Il ne regarde que le passé — il ne connaît pas la suite, ne planifie rien de manière explicite. Il procède ainsi, token par token, en alimentant lui-même la suite de la séquence.
En théorie, donc, le modèle n’a pas de mémoire externe, pas d’objectif global, pas de vision d’ensemble. Il se contente d’émettre le token suivant qui maximise la vraisemblance, à chaque instant. Rien dans son architecture ne l’oblige à penser à l’avance.
Ce qu’on observe pourtant : une forme de planification ?
Pour tester si ce fonctionnement local donne malgré tout naissance à des structures globales, les chercheurs d’Anthropic soumettent au modèle une tâche simple : compléter un couplet en rimes.
A rhyming couplet:
He saw a carrot and had to grab it,
Claude complète :
His hunger was like a starving rabbit.
La réponse est syntaxiquement correcte, sémantiquement cohérente, et elle rime parfaitement (grab it / rabbit). Mais comment ce choix s’est-il formé dans le réseau ? Est-il apparu à la dernière minute, ou bien était-il anticipé dès le début de la ligne ?
Les chercheurs construisent un graphe d’attribution : ils retracent les activations internes en remontant depuis le mot “rabbit”. Ils y découvrent un phénomène inattendu : plusieurs features associées à des candidats de rime (“rabbit”, “habit”, “cabinet”) s’activent dès le saut de ligne \n — soit avant même que la seconde ligne commence.
Ces activations influencent ensuite le choix des mots intermédiaires, orientant progressivement la phrase vers la rime finale retenue. Enfin, à la position finale, la feature “rabbit” est consolidée, et le mot est généré.
Ce comportement est surprenant parce qu’il va à l’encontre du cadre de fonctionnement prévu d’un modèle auto-régressif. Un LLM n’a, par construction, aucun mécanisme explicite de planification. Il ne peut pas “se fixer une cible” et “travailler en amont pour l’atteindre”. Et pourtant, le modèle envisage plusieurs cibles possibles avant même d’avoir commencé la ligne ; il les maintient actives pendant plusieurs étapes ; et il structure le contenu intermédiaire pour converger vers la fin la plus cohérente avec ce plan implicite.
Ce n’est pas de la génération mot à mot. Cela ressemble à une forme d’anticipation interne — une organisation computationnelle qui ressemble à une planification rudimentaire, bien qu’elle n’ait jamais été explicitement programmée.
Tester la causalité : interventions expérimentales
Mais comment être sûr que ces features anticipées ne sont pas de simples coïncidences ? Pour répondre, les chercheurs réalisent des expériences de perturbation — en modifiant le circuit interne du modèle sans changer le prompt.
Voici ce qu’ils font, étape par étape :
– Suppression de la feature “rabbit”
Ils désactivent manuellement la feature correspondant à “rabbit” (une activation identifiée dans le graphe). Résultat : le modèle choisit une autre rime, comme “habit” ou “cabinet”.
– Injection de la feature “habit”
Ils activent artificiellement la feature correspondant à “habit”, dès le saut de ligne. Résultat : la ligne générée devient par exemple : His craving grew into a strange new habit.
– Modification du contexte initial
Ils changent la première ligne en : He dropped the ball and tried to pick it,
Résultat : les features de rime changent — “ticket”, “cricket”, etc. — et le modèle oriente ses choix en conséquence.
Ces interventions montrent que le modèle ne suit pas une simple chaîne de prédictions locales, token après token : il génère certains mots en fonction d’une cible implicite maintenue plusieurs tokens en amont. Cela suggère une dynamique computationnelle structurée, modulable, et causalement traçable.
Une planification émergente ?
Ce comportement n’est pas programmé. Il émerge uniquement de l’entraînement du modèle à prédire un token à la fois, sur des milliards de séquences. Mais ce simple objectif, répété à grande échelle, produit des dynamiques internes qui se rapprochent d’un comportement structuré globalement. Et c’est grâce aux attribution graphs que ces structures invisibles deviennent lisibles : en retraçant les flux d’activation entre features, on peut reconstruire des hypothèses sur le circuit de « raisonnement » local du modèle, intelligibles et testables.
Ce phénomène relève-t-il d’une véritable planification, ou s’agit-il d’une simple convergence probabiliste vers une structure apprise ? La question reste ouverte. Le fait que l’on puisse induire ou bloquer certains comportements en intervenant sur les features suggère néanmoins une forme de cohérence computationnelle — un embryon d’intention, sans intentionnalité.
Que certaines activations puissent orienter la génération de texte ne signifie pas nécessairement qu’elles participent à une stratégie de planification au sens fort. Il s’agit peut-être simplement de l’expression, au sein d’un réseau auto-régressif bien entraîné, de régularités statistiques suffisamment structurées pour simuler un comportement organisé. Des effets causaux locaux ont bien été identifiés et mesurés. Mais le sens global de cette dynamique — entre structure, anticipation et illusion de plan — reste ouverte à interprétation. En effet, une véritable planification implique un objectif global explicite ou implicite, une organisation de l’action en vue d’une fin, et non juste une cascade de dépendances locales. Cette ambiguïté, loin d’invalider les travaux des chercheurs d’Anthropic, souligne au contraire leur importance.
Car comprendre ces mécanismes émergents est une condition nécessaire pour espérer un jour maîtriser — et réguler — ce que l’on appelle encore l’IA « étroite ».
Références
– Lindsey, J., Gurnee, W., Ameisen, E., Chen, B., Pearce, A., Turner, N. L., Citro, C., Abrahams, D., Carter, S., Hosmer, B., Marcus, J., Sklar, M., Templeton, A., Bricken, T., McDougall, C., Cunningham, H., Henighan, T., Jermyn, A., Jones, A., Persic, A., Qi, Z., Thompson, T. B., Zimmerman, S., Rivoire, K., Conerly, T., Olah, C., & Batson, J. (2025, March 27). On the biology of a large language model. https://transformer-circuits.pub/2025/attribution-graphs/biology.html
– Ameisen, E., Lindsey, J., Pearce, A., Gurnee, W., Turner, N. L., Chen, B., Citro, C., Abrahams, D., Carter, S., Hosmer, B., Marcus, J., Sklar, M., Templeton, A., Bricken, T., McDougall, C., Cunningham, H., Henighan, T., Jermyn, A., Jones, A., Persic, A., Qi, Z., Thompson, T. B., Zimmerman, S., Rivoire, K., Conerly, T., Olah, C., & Batson, J. (2025, March 27). Circuit tracing: Revealing computational graphs in language models. https://transformer-circuits.pub/2025/attribution-graphs/methods.html