OpenAI vient de surprendre une IA en train de réfléchir.

Quelqu'un chez OpenAI vient de réaliser l'équivalent en IA de sortir un CPU d'époxy et de trouver un Schaltplan lisible à l'intérieur. Leur nouvelle recherche sur la « sparsité des circuits » prend un Transformeur de style GPT-2, l'entraîne sur du code Python et supprime brutalement plus de 99,9 % de ses connexions internes pendant l'entraînement. Ce qui survit n'est pas un flou de probabilités, mais de minuscules circuits traçables que vous pouvez réellement suivre.

Le design moderne des modèles linguistiques traite le raisonnement comme une boîte noire : des millions ou des milliards de poids s'activent simultanément, et vous ne voyez jamais que le dernier token. Même lorsque la réponse semble correcte, personne ne peut dire quel tête d'attention, quel neurone ou quel espace mémoire a vraiment compté. Les travaux sur l'interprétabilité explorent généralement cette brume ; ils ne la condensent presque jamais en quelque chose qui ressemble à un schéma de câblage dessiné à la main.

La parcimonie des circuits inverse l'objectif. OpenAI ne revendique pas de saut de performance par rapport au dense GPT‑2 ; ils échangent explicitement l'efficacité contre la lisibilité et la confiance. L’équipe impose la parcimonie des poids lors de l'optimisation elle-même, en annulant toutes les connexions sauf les plus fortes après chaque étape d'AdamW, et ajoute une légère parcimonie d'activation afin que seulement environ 1 signal interne sur 4 s'active à la fois.

Dans les modèles les plus agressifs, environ 1 poids sur 1000 demeure non nul, tandis que la perte de référence reste comparable aux bases denses. Comme la taille des paramètres est réduite progressivement pendant l'entraînement, le modèle compresse son comportement appris dans un budget de nœuds et d'arêtes en diminution. Ce qui reste forme des "circuits dispersés" compacts qui continuent à fermer les guillemets, compter les parenthèses ou suivre les types de variables.

Les Transformers denses diffusent chaque comportement à travers des sous-réseaux tentaculaires et chevauchants qui résistent à une explication claire. Une seule caractéristique peut exister à travers des dizaines de têtes et de couches, entremêlée avec des motifs sans rapport. Lorsque les chercheurs retirent des parties de ces modèles, ils apprennent principalement que « beaucoup de choses ont compté », et non comment l'algorithme fonctionne.

Les homologues rares semblent presque démodés. Pour une tâche de clôture de citation, OpenAI rapporte un circuit final avec seulement 12 unités internes et 9 connexions survivantes, y compris une unité qui s'active sur n'importe quelle citation et une autre qui suit les guillemets simples par rapport aux guillemets doubles. La même précision qui nécessitait autrefois un brouillard d'activations tient désormais dans quelque chose qui ressemble davantage à un diagramme logique que vous pourriez imprimer, annoter et discuter.

La sparsité des circuits commence par une règle simple mais brutale : presque chaque connexion doit disparaître pendant que le Sprachmodell est encore en apprentissage. OpenAI entraîne un transformateur de style GPT-2 sur du code Python et, après chaque mise à jour AdamW, annule toutes les poids de plus grande amplitude. Pas de régularisation douce, pas de pénalités légères : les connexions comptent suffisamment pour survivre ou elles tombent exactement à zéro.

Dans la configuration la plus agressive, seulement environ 1 poids sur 1 000 reste non nul. Cela signifie que plus de 99,9 % du câblage interne disparaît et ne contribue jamais discrètement en arrière-plan. De plus, le système impose une sparsité d'activation : à tout moment, seule environ 1 signal interne sur 4 est autorisé à s'activer.

Ces signaux couvrent toute la pile de transformateurs. Le budget de sparsité englobe : - Les neurones individuels dans les blocs MLP - Les têtes d'attention et les canaux - Les emplacements de lecture/écriture dans le flux résiduel et la mémoire

La taille traditionnelle fonctionne généralement à l'opposé. Vous formez d'abord un grand modèle dense jusqu'à convergence, puis vous coupez les poids « non importants » par la suite, espérant que le réseau ne s'en aperçoive à peine. La parcimonie des circuits renverse ce scénario et intègre la contrainte dans l'optimisation elle-même, de sorte que le modèle n'apprenne jamais à s'appuyer sur un énorme réseau enchevêtré dès le départ.

L'entraînement commence de manière relativement normale et dense, puis se resserre. Au fil du temps, le nombre autorisé de poids non nuls diminue selon un calendrier, obligeant le réseau à compresser ce qu'il sait en un nombre de connexions de plus en plus réduit. Il en va de même pour les activations : seule une petite fraction des unités peut s'activer à chaque passage en avant, rendant la redondance coûteuse.

La plupart des gens s'attendraient à ce que cela nuise aux performances. Au lieu de cela, le modèle se stabilise en quelque chose de plus froid et plus précis : un ensemble de circuits hyper-efficaces. Pour des tâches algorithmiques simples comme la clôture de devis ou le comptage de parenthèses, OpenAI rapporte que les circuits minimaux épars sont environ 16 fois plus petits (en nombre de bords) que la machinerie interne des références denses au même taux de perte.

Fonctionnellement, le comportement reste presque identique ; en interne, le chaos se transforme en une logique compacte. Ce qui reste n'est pas un réseau endommagé, mais un Schaltplan épuré qui montre réellement son fonctionnement.

La survie ici dépend de la capacité d'un modèle à condenser ses compétences dans de moins en moins de voies sans perdre en précision. OpenAI emprunte un procédé à la physique et à l'optimisation : le recuit. L'entraînement commence avec un transformateur dense normal, puis le nombre de poids non nuls autorisés diminue au fil du temps, étape par étape, tandis qu'AdamW continue de mettre à jour ce qui reste.

Au lieu de réduire le modèle après l'entraînement, le système annule toutes les connexions sauf les poids de la plus grande amplitude après chaque mise à jour. Au début, des milliers de connexions peuvent transmettre un signal ; plus tard, seul un petit budget survit. À la fin, environ 1 poids sur 1 000 reste non nul, et seulement environ 1 activation interne sur 4 peut s'activer à tout moment.

Imaginez forcer un essai décousu à devenir un poème percutant et précis. Toutes les clauses réservées et les pensées secondaires disparaissent ; seules restent les lignes qui font vraiment avancer l'idée. La rareté des circuits applique cette même pression aux calculs internes d'un modèle linguistique.

Sous ce régime, tout schéma paresseux ou redondant disparaît. Si deux neurones font presque la même chose, le recuit pousse le modèle à en conserver un et à rejeter l'autre. Le résultat est un réseau où les voies survivantes représentent de véritables morceaux de logique distincts plutôt qu'un mélange indistinct.

OpenAI compare ensuite ces survivants rares à des bases de référence denses standard à perte de tâche identique. Pour des tâches simples de code Python—fermeture de guillemets, comptage de parenthèses, détection d'ensembles par rapport à des chaînes—les modèles rares atteignent la même précision tout en fonctionnant sur une infrastructure interne environ 16 fois plus petite en moyenne. Même comportement, un seizième du câblage.

Cette compression est importante car elle révèle ce que le modèle fait réellement. Dans la tâche de clôture des citations, le circuit final utilise seulement 12 unités internes et 9 connexions : une unité s'active pour chaque citation, une autre suit les guillemets simples versus doubles, et d'autres propagent et inversent cet état. Vous pouvez littéralement retracer chaque décision pas à pas.

OpenAI définit ces circuits rares comme des sous-graphes minimaux qui résolvent encore une tâche lorsque tout le reste est figé à une valeur moyenne. Les chercheurs ablative les nœuds jusqu'à ce que la performance s'effondre, éliminant le poids mort jusqu'à ce que seul l'algorithme indispensable demeure. La présentation de l'entreprise, Comprendre les réseaux neuronaux à travers des circuits rares, explique comment ces petits mécanismes implémentent le comptage, la mémoire et le flux de contrôle, token par token.

Oubliez les « fonctionnalités » floues ou les discours poétiques sur le comportement émergeant. OpenAI vise tout directement sur les circuits : de minuscules sous-graphes à l'intérieur du modèle linguistique composés de neurones spécifiques, de têtes d'attention et de slots de lecture/écriture mémoire, ainsi que des poids individuels qui les relient. Chaque arête survivante est un seul paramètre non nul dans une mer où plus de 99,9 % des poids sont maintenus exactement à zéro.

Pour comprendre ce que font réellement ces circuits, l'équipe réduit l'espace de problème à son essence. Ils s'entraînent sur 20 petits casse-têtes de programmation déterministes où le modèle doit choisir entre exactement deux jetons suivants. Pas de créativité, pas de génération ouverte, juste "A ou B" sous des règles strictes.

De nombreuses tâches semblent presque ennuyeuses jusqu'à ce que l'on se rende compte qu'elles révèlent une véritable structure algorithmiquement. Un circuit décide s'il faut fermer une chaîne Python avec une apostrophe ou des guillemets en fonction de ce qui l'a ouverte. Un autre compte les listes imbriquées et choisit entre “]” et “]]” selon la profondeur actuelle des crochets, tandis qu'un troisième suit si une variable a commencé sa vie en tant que ensemble ou chaîne pour pouvoir choisir plus tard entre `add` et `+=`.

Pour isoler la machinerie derrière chaque comportement, OpenAI effectue une ablation brutale. Ils suppriment progressivement des unités internes et des connexions, les bloquant à une valeur moyenne afin qu'elles ne puissent pas aider secrètement, et observent quand la précision de la tâche s'effondre. Une boucle d'optimisation distincte recherche le plus petit sous-graphe qui maintient encore la performance au-dessus d'un seuil strict.

Ce qui survit à ce processus est le "circuit minimal" pour la tâche : un ensemble de nœuds et d'arêtes à la fois suffisants et nécessaires au comportement. Pas de tableaux de bord d'interprétabilité, pas de cartes de chaleur post-hoc—juste un masque sur les véritables poids et activations que le Sprachmodell utilise au moment de l'inférence.

Pour la tâche de clôture de citation, ce circuit minimal ne contient que 12 unités et 9 connections. Deux unités ressortent immédiatement : l'une se déclenche chaque fois que le modèle rencontre un caractère de citation, l'autre transporte un simple signal binaire distinguant les guillemets simples des guillemets doubles au fil du temps. Ce signal circule à travers quelques connexions restantes pour déterminer le choix final du jeton, une machine littérale et inspectable pour une seule pensée.

Imaginez une petite sous-routine vivant à l'intérieur d'un réseau de neurones : 12 unités, 9 connexions, un seul objectif. Nourrissez ce modèle de langue Sprachmodell de style GPT‑2 avec une chaîne Python à moitié terminée, et vous pouvez littéralement observer un circuit dédié à "fermer les guillemets" s'activer, exécuter son algorithme, puis se désactiver.

Le processus commence avec une seule unité de détection. Ce neurone s'active chaque fois que le modèle voit un caractère de citation, que ce soit une simple ou une double, ouvrante ou fermante. Son activation devient un drapeau clair "il y a une citation ici", et non une nuage de probabilité flou.

Juste à côté, une deuxième unité se spécialise davantage. Celle-ci ne se soucie pas de la position ; elle se préoccupe du type. Son état interne sépare clairement les guillemets simples (') des guillemets doubles ("). Il s'agit d'une distinction d'un bit encodée dans une activation continue mais utilisée comme un booléen.

Ces deux signaux sont ensuite dirigés vers un petit relais : une troisième unité qui agit comme une cellule de mémoire. Elle lit « une citation vient d'apparaître » ainsi que « c'était simple ou double » et inscrit cette information dans le flux résiduel du modèle, où les couches suivantes peuvent la récupérer. Cette inscription est littéralement une poignée de poids restants, pas des milliers.

À partir de là, le circuit se comporte comme un petit algorithme écrit à la main : Détecter → Classifier → Copier → Sortir. Les unités en aval lisent le signal de type citation stocké alors que le modèle progresse dans le reste de la ligne de code. Lorsqu'il atteint le point où la chaîne doit se terminer, une autre unité utilise ce bit mémorisé pour choisir le bon token de fermeture.

De manière cruciale, OpenAI peut ablater ce circuit nœud par nœud. Désactivez le détecteur de citations, et le modèle cesse de réagir aux citations. Figez l'unité de suivi des types à une valeur constante, et il se ferme toujours avec la même citation, peu importe ce qui a ouvert la chaîne.

Les chercheurs ne déduisent pas cela à partir de cartes thermiques ou d'attributions de caractéristiques vagues. Ils définissent un circuit parcimonieux minimal, optimisent les masques jusqu'à ce qu'il ne reste que 12 unités et 9 arêtes, et vérifient que ce sous-graphe à lui seul résout toujours la tâche `single_double_quote`. Tout le reste peut rester à sa valeur moyenne et le comportement change à peine.

Pour un domaine où des comportements "émergents" se diluent à travers des millions de paramètres, pouvoir pointer du doigt une dizaines d'unités et dire "voilà le clos d'affaires" semble presque mécanique. Cela ressemble moins à des statistiques et plus à du code.

La mémoire se manifeste le plus clairement dans une tâche apparemment simple : set_or_string. Le modèle lit du code Python où une variable peut être créée en tant que `set()` ou en tant que chaîne, puis doit plus tard choisir entre `x.add(...)` ou `x += ...`. Ce choix n'a de sens que si le modèle se souvient comment `x` a débuté sa vie plusieurs tokens auparavant.

Le transformateur éparse d'OpenAI ne se contente pas de « ressentir » les patterns ici. Lorsque le code définit `x = set()`, un petit sous-circuit dédié écrit un marqueur interne dans le flux résiduel : une caractéristique compacte qui encode « x est un ensemble, pas une chaîne de caractères ». Un chemin parallèle déclenche un marqueur différent lorsque le modèle voit `x = "hello"` ou des initialisations de chaînes similaires.

Ce marqueur ne reste pas partout à la fois. Parce que le modèle fonctionne sous une brutalité de parcimonie — environ 1 poids sur 1000 non nul et seulement environ 1 activation sur 4 autorisée à se déclencher — seules quelques rares unités peuvent faire avancer le type de signal. Des têtes d'attention spécifiques apprennent à suivre la position de la variable et à copier son marqueur de type au fil du temps, étape par étape, à mesure que de nouveaux jetons affluent à travers le Sprachmodell.

Plus tard, lorsque le code atteint `x ??? quelque chose`, une autre partie du circuit s'active. Un petit groupe de lecture interroge le flux résiduel à ce moment-là, demandant en effet : « Quel marqueur a survécu pendant x ? » Si le marqueur défini domine, le circuit dirige la masse de probabilité vers `.add(` ; si le marqueur de chaîne l'emporte, il privilégie `+=` à la place. La décision dépend d'un état interne stocké, puis récupéré.

Les chercheurs ont validé cela en supprimant les nœuds et les arêtes individuels à l'intérieur du circuit set_or_string. En supprimant les unités d'écriture qui créent le marqueur, le modèle oublie le type de variable ; en tuant les unités de lecture, il ne peut plus utiliser les informations stockées, même si les jetons précédents semblaient corrects. Le comportement s'effondre exactement de la manière qu'un registre mémoire défaillant le ferait.

C'est pourquoi OpenAI le présente comme une mémoire délibérée véritable, et non comme un simple appariement de modèles. Le document sur les transformateurs à poids épars (article d'OpenAI) le décrit comme un mécanisme concret de stockage et de récupération : un circuit minimal et inspectable qui se souvient d'un fait et le consulte ensuite pour choisir la bonne ligne de code.

Les ponts sont l'endroit où cela cesse d'être une démonstration de laboratoire mignonne et commence à toucher de véritables modèles linguistiques. OpenAI entraîne de petits transformateurs, brutalement peu fournis, où ils peuvent voir des circuits individuels, puis ajoute des réseaux de "pont" appris qui traduisent entre ces activations rares et un modèle dense normal de la taille que vous déploieriez réellement.

Un pont fonctionne comme une paire d'adaptateurs. Un encodeur traduit l'état caché brouillon du modèle dense dans l'espace propre et de faible dimension d'un circuit sparse ; un décodeur traduit tout changement dans cet espace sparse de nouveau dans le langage natif du modèle dense, composé de millions d'activations.

Cette couche de traduction est importante car elle transforme l'interprétabilité en une rue à double sens. Les chercheurs peuvent trouver une caractéristique dans le modèle sparse—par exemple, le circuit set_or_string qui suit si une variable est un ensemble ou une chaîne—et ensuite utiliser le pont pour traquer son homologue dans un modèle de style GPT-2 à échelle de production, entraîné sur les mêmes données Python.

Une fois qu'ils se verrouillent sur la fonctionnalité correspondante, ils peuvent l'explorer. Faites pivoter l'unité sparse « ceci est un ensemble » via le pont et observez si le modèle dense commence à préférer `.add(` plutôt que `+=`. Poussez le circuit de fermeture de citation et voyez si le grand modèle commence soudainement à mal fermer les chaînes, même si aucun poids dans le réseau dense n'a changé directement.

Cela offre un flux de travail concret pour le débogage de systèmes réels, et pas seulement de configurations expérimentales. Lorsque un modèle déployé hallucine une API ou classifie mal du contenu, les ingénieurs pourraient : - Utiliser un proxy sparse pour identifier un circuit responsable - Cartographier ce circuit à travers un pont vers le modèle dense - Intervenir systématiquement pour confirmer la causalité et tester les correctifs

Le hic pratique : les ponts ne rendent pas magiquement les réseaux denses transparents ; ils s’appuient sur un modèle clairsemé qui expose déjà sa logique interne. Mais une fois que vous avez cette structure, vous pouvez commencer à imaginer des hybrides où des parties clairsemées et denses coexistent.

Les futures architectures de modèles linguistiques pourraient acheminer des comportements critiques en matière de sécurité ou sensibles à la réglementation via des circuits rares et audibles, tout en réservant la génération ouverte à des blocs denses. Les ponts deviennent alors non seulement des outils de recherche, mais le liant qui permet à ces deux régimes de communiquer au sein d'un système cohérent.

OpenAI n'a pas seulement publié un article ; ils ont lâché un kit de laboratoire fonctionnel. Sur Hugging Face se trouve openai/circuit-sparsity, un modèle de langage de style GPT-2 de 0,4 milliard de paramètres, entraîné sur du code Python avec plus de 99,9 % de ses poids fixés à zéro. À côté, un kit complet circuit_sparsity réside sur GitHub, transformant un résultat d'interprétabilité abstrait en quelque chose que vous pouvez explorer, tester et casser.

Le modèle est minuscule selon les normes de 2025, mais exceptionnellement transparent. Environ 1 poids sur 1 000 survit à l'entraînement, et seulement ~1 activation interne sur 4 peut s'activer simultanément entre les neurones, les canaux d'attention et les emplacements de lecture/écriture résiduels. Ce minimalisme imposé crée des circuits dispersés qui, pour une perte de préentraînement équivalente, fonctionnent à environ 16 fois plus petit que la logique équivalente dans un modèle dense.

Le dépôt GitHub ne se contente pas d'expédier des points de contrôle de modèle et un fichier readme. Il regroupe une batterie soigneusement sélectionnée d'environ 20 tâches mécaniques qui mettent à l'épreuve les algorithmes internes du modèle, allant de `single_double_quote` et `bracket_counting` à la tâche gourmande en mémoire `set_or_string`. Chaque tâche contraint le modèle à un choix binaire de prochain jeton A/B, rendant brutalement évident lorsqu'un circuit échoue.

Les chercheurs bénéficient également d'outils intégrés de taille et de recherche de circuit. La boîte à outils peut : - Figé les nœuds non pertinents à leur activation moyenne - Masquer les arêtes jusqu'à ce que la performance baisse - Optimiser pour le plus petit sous-graphe qui atteint toujours une précision cible

Ce qui émerge n'est pas un joli diagramme collé sur une boîte noire, mais un sous-réseau minimal qui exécute réellement le comportement.

Une interface de visualisation légère complète le package. OpenAI propose une interface basée sur Streamlit qui vous permet d'observer les nœuds et les arêtes individuels s'activer sur des invites spécifiques, de parcourir les positions des tokens et de comparer des circuits dispersés à leurs homologues denses. Vous pouvez littéralement voir quel neurone s'active lorsque le modèle décide qu'une variable est un ensemble au lieu d'une chaîne.

De manière cruciale, tout ceci est proposé sous une licence Apache 2.0. Cela signifie que des laboratoires commerciaux, des groupes académiques et des hackers isolés peuvent forker, modifier et intégrer ces circuits et ponts rares dans leurs propres systèmes sans gymnastique juridique. OpenAI invite en effet le reste du secteur à tester, étendre ou contredire outright sa revendication : que l'on peut ouvrir un modèle de langage moderne et retracer une logique réelle et fonctionnelle à l'intérieur.

OpenAI se trouve désormais au cœur de ce que Axios a récemment qualifié d’« économie de l'IA », une position qui semble dangereusement proche du concept de trop grand pour échouer. Ses modèles orientent le code, modèrent le contenu, supervisent les classifications d'âge et arbitrent de plus en plus ce que des milliards de personnes voient. Lorsque le modèle linguistique d'une entreprise devient une infrastructure critique, sa manière de penser est tout aussi importante que la réponse qu'il délivre.

Les scores bruts de référence ne résolvent plus le véritable problème. Si un système d'IA classifie silencieusement mal un code médical, ne renforce pas suffisamment les filtres de sécurité ou hallucine un raisonnement juridique, quelqu'un exigera de savoir pourquoi. La parcimonie des circuits offre une chose rare dans ce paysage : un moyen de pointer quelques neurones et liens et de dire : « ces composants spécifiques ont produit cette décision. »

La pression sur OpenAI ne cesse de croître de toutes parts. Les startups et les entreprises établies rivalisent pour proposer des API de type GPT à des prix inférieurs, les régulateurs antitrust enquêtent sur sa domination, et les poursuites pour violation du droit d'auteur et diffamation s'accumulent concernant la manière dont les modèles sont entraînés et réagissent. Pendant ce temps, OpenAI dépense des sommes astronomiques en GPU, centres de données et réseaux personnalisés juste pour maintenir ses API de Sprachmodell en ligne.

Cette accumulation de risques modifie ce que signifie "à la pointe de la technologie". Une augmentation de 0,2 % de la précision sur un indicateur de codage n’est d’aucune aide lorsque les régulateurs demandent pourquoi une décision de modération a échoué ou pourquoi un modèle financier a mal évalué le risque. Ce dont OpenAI a besoin — et ce que la parcimonie des circuits suggère — c’est d’une intelligence contrôlable, pas simplement d’une intelligence accrue.

Readable AI se retrouve directement dans le viseur d'une réglementation imminente. Les législateurs de l'UE, des États-Unis et du Royaume-Uni envisagent des exigences pour l'« explication », les pistes d'audit et les évaluations des risques au niveau des systèmes pour les modèles à fort impact. Des circuits clairsemés offrent aux auditeurs et aux équipes internes un objet à inspecter : un sous-graphe concret qui implémente « fermer la citation » ou « suivre si cette variable est un ensemble ou une chaîne ».

C'est pourquoi la publication en open-source est importante. Le modèle Hugging Face et le dépôt openai/circuit_sparsity – Publication open-source d'outils de circuits rares transforment l'interprétabilité d'une promesse théorique en quelque chose que les régulateurs, les universitaires et les concurrents peuvent réellement examiner. Si OpenAI souhaite continuer à fonctionner en tant qu'infrastructure critique, ce type de technologie en boîte de verre pourrait être plus significatif que le prochain trillion de paramètres.

L'IA lisible cesse d'être une métaphore dès que l'on peut pointer vers un circuit de 12 nœuds et 9 arêtes et dire : c'est là que se prend la décision de clôture de citation. La parcimonie du circuit prend cette idée et la transforme en un objectif d'ingénierie : les futurs modèles ne devraient pas seulement fonctionner, ils devraient également exposer leur logique interne comme des composants inspectables. Cela déplace l'interprétabilité d'une autopsie a posteriori à une contrainte de conception.

Les fonctionnalités à venir comme le « mode adulte » prévu de ChatGPT rendent ce changement inévitable. Un système qui déduit discrètement si vous êtes un enfant, un adolescent ou un adulte ne peut pas camoufler ce jugement dans une activation intractable. Les régulateurs, les auditeurs et probablement les tribunaux voudront savoir quels signaux — historique de navigation, formulation, heure de la journée, région — ont alimenté quels circuits avant qu'un modèle approuve le contenu explicite.

Les circuits clairsemés offrent un modèle pour ce type de responsabilité. Si un modèle de sécurité décide que "l'utilisateur est probablement âgé de moins de 16 ans", vous souhaitez un sous-graphe nommé et limité qui porte cette croyance, et non pas mille caractéristiques partiellement redondantes étalées sur le flux résiduel. Avec la rareté des circuits, OpenAI montre que pour des tâches de code Python, des circuits équivalents en comportement peuvent fonctionner ~16x plus petits que leurs homologues denses tout en maintenant la perte constante.

La recherche sur l'alignement repose sur ce type de localisation. Les méta-optimiseurs cachés et les objectifs émergents deviennent plus difficiles à nier si vous pouvez scanner de manière systématique les circuits qui suivent le pouvoir, la tromperie ou la préservation de soi. Les ponts entre les modèles rares et denses laissent entrevoir un avenir où vous pouvez :

• 1Explorer un circuit de "honnêteté" sparse
• 2Mettez-le dans un modèle de langue de production.
• 3Contrôler strictement ou amplifier son influence sur les résultats.

L'augmentation seule ne peut résoudre ces problèmes. Un modèle 10 fois plus grand avec 10 fois plus de caractéristiques imbriquées ne fait qu'approfondir la boîte noire. La parcimonie des circuits pointe vers une autre frontière : une IAG dont la structure interne est suffisamment lisible pour être déboguée, régulée et, si nécessaire, arrêtée.

Si cette vision se réalise, certains des travaux les plus importants en IA de cette décennie ne viseront pas à atteindre un autre point décimal d'exactitude de référence. Ils poursuivront quelque chose de plus étrange et d'ambitieux : des modèles dont les pensées sont accompagnées d'un schéma de circuit.

Quelle est la recherche sur la parcimonie des circuits d'OpenAI ?

C'est une méthode où un modèle d'IA est entraîné avec plus de 99,9 % de ses connexions internes supprimées. Cela pousse le modèle à développer de petits "circuits" compréhensibles pour sa logique, rendant son processus de prise de décision transparent.

Comment cela diffère-t-il d'un modèle d'IA normal ?

Les modèles d'IA normaux sont 'denses', avec des milliards de voies interconnectées, ce qui en fait une 'boîte noire'. Les modèles clairsemés ont des voies minimales et épurées, permettant aux chercheurs de retracer une décision spécifique du début à la fin, comme en lisant un schéma de circuit.

Pourquoi est-il si important de rendre l'IA compréhensible ?

À mesure que les systèmes d'IA contrôlent des fonctions de plus en plus critiques dans la société, allant de la modération de contenu aux systèmes économiques, comprendre *comment* ils prennent des décisions est crucial pour la confiance, la sécurité et la régulation. Cela nous permet de vérifier leur logique et d'éviter des échecs cachés.

Puis-je essayer cela moi-même ?

Oui. OpenAI a publié un modèle épars de 0,4 milliard de paramètres sur Hugging Face ainsi qu'un ensemble complet d'outils avec des outils de visualisation sur GitHub, permettant aux chercheurs et aux développeurs d'explorer ces circuits de première main.