🤖 AI

CauSim: Scaling Causal Reasoning with Increasingly Complex Causal Simulators

CauSim est un cadre qui répond à la pénurie de données de raisonnement causal en permettant aux LLM de construire des modèles causaux structurels (SCM) exécutables de plus en plus complexes, qui servent de simulateurs évolutifs pour générer des données d'entraînement vérifiables et améliorer les performances des modèles à travers des représentations diverses.

Auteurs originaux : Nicolás Astorga, Anita Kriz, Mihaela van der Schaar

Publié 2026-05-12

📖 7 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Nicolás Astorga, Anita Kriz, Mihaela van der Schaar

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

Le Grand Problème : Les LLM sont excellents pour les faits, mauvais pour les « Et si... »

Imaginez les grands modèles de langage (LLM) comme des bibliothécaires incroyablement bien informés. Ils ont lu presque tous les livres jamais écrits. Si vous leur demandez : « Qui a écrit Orgueil et Préjugés ? » ou « Comment écrire une boucle en Python ? », ils peuvent répondre instantanément et parfaitement.

Mais si vous leur posez une question « Et si... », ils trébuchent souvent.

Exemple : « Si j'avais pris ce médicament spécifique hier, ma tumeur serait-elle plus petite aujourd'hui ? »

Pour répondre à cela, le modèle doit effectuer un raisonnement causal. Il ne peut pas simplement deviner en se basant sur des motifs ; il doit simuler une réaction en chaîne : Le médicament A modifie la cellule B, ce qui modifie la protéine C, ce qui rétrécit la tumeur D.

Le papier soutient que les LLM éprouvent des difficultés ici pour trois raisons principales :

Échelle : Les systèmes du monde réel sont immenses. Suivre une chaîne de 50 variables interactives, c'est comme essayer de suivre un jeu de « téléphone arabe » joué par 50 personnes simultanément.
Langage vs Code : Les connaissances causales sont généralement écrites dans un langage naturel désordonné (comme les notes d'un médecin). Les ordinateurs ont besoin d'un code précis pour exécuter des simulations, mais traduire des notes désordonnées en code parfait est difficile.
Pas de corrigé : Dans le monde réel, nous ne pouvons pas remonter le temps pour voir ce qui aurait pu se produire si nous avions donné un médicament différent à un patient. Nous n'avons pas la « vérité terrain » (la bonne réponse) pour enseigner à l'IA. Sans corrigé, l'IA ne peut pas apprendre.

La Solution : CauSim (L'Usine de « Simulateur Causal »)

Les auteurs présentent CauSim, un cadre qui transforme la tâche impossible d'apprendre à partir de données réelles rares en un jeu supervisé évolutif.

Pensez à CauSim comme un moteur de jeu vidéo que l'IA construit elle-même. Au lieu d'essayer d'apprendre à partir d'une histoire réelle et désordonnée, l'IA construit un monde virtuel où elle connaît les règles, exécute la simulation et obtient un score parfait.

Voici comment cela fonctionne, étape par étape :

1. Construire le monde brique par brique (Construction incrémentale)

Si vous demandez à une IA de construire une ville 3D complexe d'un seul coup, elle risque de planter ou de faire un désastre.

L'astuce du papier : CauSim demande à l'IA de construire le monde une pièce à la fois.
L'analogie : Imaginez construire un immense château en LEGO. Au lieu de verser 10 000 briques et d'espérer qu'elles tiennent, vous construisez une petite tour, vérifiez si elle tient debout, ajoutez la tour suivante, re-vérifiez, et ainsi de suite.
Pourquoi cela fonctionne : En construisant le « Simulateur Causal » (un programme informatique qui simule la cause et l'effet) de manière incrémentale, l'IA s'assure que chaque nouvelle pièce s'adapte parfaitement aux anciennes. Cela leur permet de créer des systèmes incroyablement complexes (avec de nombreuses variables) qui seraient impossibles à générer en une seule étape.

2. Traduire entre « Parole humaine » et « Code informatique »

Le papier résout le problème « Langage vs Code » en agissant comme un traducteur universel.

Formalisation (Humain $\to$ Code) : L'IA prend une description désordonnée et non exécutable (comme une directive médicale) et la traduit en un programme Python strict. Maintenant, l'ordinateur peut l'exécuter et obtenir une réponse définitive.
Informalisation (Code $\to$ Humain) : L'IA prend un programme Python strict et le transforme à nouveau en une histoire en langage naturel.
L'avantage : Cela crée une boucle. L'IA peut générer des scénarios « Et si... » infinis en code, les exécuter pour obtenir les bonnes réponses, puis transformer ces scénarios en texte pour s'enseigner elle-même comment raisonner en langage humain.

3. Le corrigé infini

Parce que l'IA a construit le simulateur elle-même, elle connaît le corrigé.

Dans le monde réel, nous ne savons pas si le médicament X guérit la maladie Y.
Dans le monde CauSim, l'IA définit les règles. Elle dit : « Dans cette simulation, le médicament X réduit toujours la tumeur Y. »
Elle génère ensuite des millions de questions « Et si... » basées sur ces règles, exécute le code pour obtenir la réponse, et utilise ces données pour entraîner le modèle. Elle transforme un « problème de labels rares » (pas assez de données) en un problème « supervisé et évolutif » (données infinies avec des réponses parfaites).

Qu'ont-ils découvert ? (Les Résultats)

Le papier a mené quatre expériences principales pour voir si ce « simulateur auto-construit » aide réellement l'IA à mieux penser.

1. Généralisation (Le test de « Transfert »)

Le dispositif : Ils ont entraîné l'IA sur un simulateur utilisant des mots sans sens (par exemple : « Si la variable A augmente, la variable B diminue »). L'IA ne savait pas ce que A ou B signifiaient.
Le résultat : Lorsqu'ils ont testé l'IA sur des termes médicaux réels (par exemple : « Si le médicament A augmente, la tumeur B diminue »), l'IA a beaucoup mieux performé.
La conclusion : L'IA n'a pas seulement mémorisé des faits médicaux ; elle a appris la logique de la cause et de l'effet. Elle a appris la « grammaire » de la causalité, qu'elle a ensuite pu appliquer à de nouveaux sujets du monde réel.

2. L'effet de curriculum (Apprendre par la difficulté)

Le dispositif : Ils ont testé si l'IA apprenait mieux si elle commençait par des simulateurs simples (peu de variables) et passait à des complexes (beaucoup de variables), ou si on la plongeait directement dans le grand bain.
Le résultat : L'IA a appris le mieux lorsqu'elle suivait un curriculum — commençant petit et devenant plus difficile.
La conclusion : Tout comme un élève humain, l'IA doit apprendre à marcher avant de pouvoir courir. Construire un raisonnement causal complexe nécessite une approche étape par étape.

3. Auto-amélioration (Le test de « Bootstrapping »)

Le dispositif : Une IA peut-elle s'améliorer elle-même en générant ses propres données d'entraînement ?
Le résultat : Oui. Un modèle d'IA a généré ses propres simulateurs, s'est entraîné dessus et est devenu meilleur pour répondre à des questions causales.
La conclusion : L'IA peut agir comme son propre professeur. Elle n'a pas besoin qu'un humain écrive les questions « Et si... » ; elle peut les inventer, les résoudre et apprendre des solutions.

4. Augmentation des données (Surcharger les connaissances existantes)

Le dispositif : Ils ont pris un jeu de données réel (l'échelle de stroke NIH) qui comportait très peu d'exemples de scénarios « Et si... ». Ils ont converti les règles de ce jeu de données en un simulateur et généré 1 000 nouveaux exemples.
Le résultat : L'IA entraînée sur ces données « augmentées » a nettement mieux performé sur les questions réelles originales que l'IA entraînée uniquement sur le petit jeu de données initial.
La conclusion : Vous pouvez prendre un petit jeu de données réel et utiliser un simulateur pour « combler les lacunes », créant ainsi un ensemble d'entraînement massif qui aide l'IA à mieux comprendre le monde réel.

Résumé

CauSim est un cadre qui aide l'IA à apprendre à penser comme un scientifique. Au lieu d'attendre que les humains fournissent des réponses parfaites aux questions « Et si... » (qui sont rares et coûteuses), l'IA construit ses propres laboratoires virtuels. Elle construit ces laboratoires brique par brique pour assurer leur stabilité, les traduit entre le langage humain et le code informatique, et exécute des millions d'expériences pour générer son propre « Corrigé ».

Le résultat est une IA qui ne se contente pas de mémoriser des faits, mais qui apprend réellement la logique sous-jacente de la cause et de l'effet, lui permettant de répondre à des questions complexes « Et si... » avec une bien plus grande précision.

Résumé technique : CauSim : Mise à l'échelle du raisonnement causal avec des simulateurs causaux de complexité croissante

1. Énoncé du problème

Malgré des performances surhumaines en mathématiques, en programmation et dans des tâches à forte densité de connaissances, les grands modèles de langage (LLM) continuent de peiner avec le raisonnement causal. L'article identifie trois obstacles majeurs empêchant les LLM de maîtriser cette capacité :

Échelle (C1) : À mesure que le nombre de variables dans un système causal augmente (par exemple, effets secondaires, caractéristiques des patients), le suivi de toutes les interactions et dépendances devient un défi tant computationnel que cognitif.
Représentation (C2) : Les connaissances causales sont fréquemment exprimées sous des formes non exécutables, telles que le langage naturel ou des diagrammes. Pour répondre aux requêtes, les modèles doivent extraire et composer correctement les relations causales sous-jacentes, un processus sujet à erreurs lorsque la représentation est non structurée.
Absence de supervision par vérité terrain (C3) : Le raisonnement causal nécessite des réponses à des requêtes interventionnelles et contrefactuelles. Cependant, les réponses de vérité terrain pour ces requêtes sont intrinsèquement rares dans les données réelles ; les données interventionnelles sont coûteuses à obtenir et les résultats contrefactuels sont inobservables. Cette rareté rend l'entraînement supervisé direct pour l'inférence causale impossible.

La question de recherche centrale est : Comment pouvons-nous obtenir une supervision vérifiable pour le raisonnement causal à travers des échelles et des représentations variées ?

2. Méthodologie : Le cadre CauSim

Les auteurs introduisent CauSim, un cadre conçu pour transformer le raisonnement causal d'un problème à étiquettes rares en un problème supervisé et évolutif. L'innovation centrale réside dans la construction de simulateurs causaux de complexité croissante — des Modèles Causaux Structurels (SCM) exécutables construits de manière incrémentale par des LLM.

2.1 Construction incrémentale des SCM

Pour relever le défi de l'Échelle (C1), CauSim évite la génération en une seule étape de modèles complexes, qui conduit souvent à des erreurs structurelles. À la place, il emploie une procédure itérative en quatre étapes :

Spécification : Un LLM spécifie un SCM exécutable initial (code Python).
Planification : Le LLM reçoit une vue sémantique (résumés fonctionnels et structure de graphe) du SCM actuel et planifie une modification en proposant un nouveau mécanisme structurel ( $f_i$ ) et un échantillonneur exogène ( $U_i$ ), en définissant leurs parents et leurs enfants.
Exécution : Le LLM implémente la mise à jour en utilisant uniquement un contexte localisé (code complet pour les enfants, docstrings pour les parents) pour garantir que le nouveau nœud s'intègre correctement sans briser la logique existante.
Vérification : Des vérifications déterministes imposent l'acyclicité, la connectivité et l'exécutabilité à l'exécution. Si les vérifications échouent, la modification est rejetée et réessayée.

Cette approche incrémentale permet la génération de systèmes globalement complexes (jusqu'à plus de 10 nœuds dans les expériences) tout en maintenant une validité structurelle.

2.2 Traduction inter-représentationnelle

Pour relever le défi de la Représentation (C2), CauSim opère de manière bidirectionnelle entre des formes exécutables et non exécutables :

Formalisation (Informel $\to$ Exécutable) : Le cadre traduit des descriptions causales non structurées (par exemple, des notes cliniques) en SCM Python exécutables. Cela permet la génération de réponses de vérité terrain pour des requêtes qui seraient autrement non supervisables.
Informalisation (Exécutable $\to$ Informel) : Inversement, les SCM exécutables sont traduits en langage naturel. Cela permet un entraînement supervisé sur des représentations non exécutables, en exploitant la vérité terrain générée par la version exécutable.

2.3 Génération de requêtes et entraînement

Une fois un SCM vérifié construit, le cadre échantillonne des requêtes causales couvrant quatre types : Déduction, Intervention, Abduction et Contrefactuels.

Génération de données : Le cadre génère une quantité pratiquement illimitée de données supervisées en exécutant le SCM pour obtenir des réponses de vérité terrain.
Pipeline d'entraînement : Les auteurs emploient un pipeline d'affinement par échantillonnage de rejet (similaire à STaR/RAFT). Le modèle de base génère des réponses ; seules celles correspondant à la vérité terrain vérifiable sont conservées pour l'Affinement Supervisé (SFT).
Mise à l'échelle du curriculum : L'entraînement est réalisé à travers des niveaux croissants de complexité des SCM (nombre de nœuds) pour étudier les effets de la conception du curriculum.

3. Contributions clés

Cadre CauSim : Une méthode novatrice pour construire des simulateurs causaux exécutables de complexité croissante, évolutifs tant en complexité du système qu'en types de représentation.
Étude empirique systématique : Une évaluation complète démontrant que :
- L'entraînement sur des SCM exécutables généralise aux représentations non exécutables et au contenu sémantique hors distribution.
- Les gains de performance sont cohérents avec la mise à l'échelle du curriculum (difficulté progressive) et l'augmentation du volume de données.
- Les LLM peuvent s'améliorer eux-mêmes en générant et en raisonnant sur leurs propres simulateurs causaux.
- Les connaissances de domaine existantes peuvent être formalisées en SCM exécutables pour augmenter les jeux de données et améliorer les performances sur les distributions originales.

4. Résultats expérimentaux

Les auteurs ont évalué CauSim en utilisant les modèles Qwen2.5 et GPT-5 pour la génération, en se concentrant sur des variables « Nonsense » (chaînes de 4 lettres) pour dissocier le raisonnement causal des connaissances préalables, ainsi que sur des domaines médicaux (Échelle de AVC NIH) et des benchmarks externes (bnlearn, GSM8K).

Généralisation (Q1) : Les modèles entraînés sur des SCM exécutables avec des variables sans signification ont nettement surpassé les modèles de base sur des termes médicaux invisibles et des représentations non exécutables (langage naturel). Cela suggère que l'entraînement enseigne la logique causale plutôt que la mémorisation de faits de domaine.
Effets de mise à l'échelle (Q2) :
- Curriculum : Un curriculum progressif (entraînement sur de petits SCM avant les grands) a constamment surpassé l'entraînement sur toutes les complexités à la fois ou l'entraînement uniquement sur des sous-ensembles faciles/difficiles.
- Volume de données : L'augmentation du nombre de requêtes causales par SCM (de 5 à 135) a conduit à des améliorations constantes de la précision, en particulier pour les SCM complexes.
Auto-amélioration (Q3) : Un LLM affiné sur des SCM générés par lui-même (Qwen2.5-7B) a atteint des performances comparables à celles de modèles entraînés sur des SCM générés par des modèles plus puissants (GPT-5), démontrant la viabilité de l'amorçage des capacités de raisonnement causal.
Augmentation de données (Q4) : La formalisation de l'Échelle de AVC NIH (NIHSS) en un SCM exécutable a permis la génération de 1 000 échantillons interventionnels et contrefactuels supplémentaires. Les modèles entraînés sur ces données augmentées ont nettement surpassé ceux entraînés uniquement sur les 100 échantillons originaux, les gains augmentant avec la complexité du SCM.

5. Signification et affirmations

L'article affirme que CauSim fournit une solution évolutive au problème de rareté des données dans le raisonnement causal. En exploitant l'exécutabilité du code, le cadre crée un « environnement d'entraînement vérifiable » où les réponses de vérité terrain sont dérivées mécaniquement plutôt que curées par l'humain.

Les auteurs soulignent que leur travail se concentre sur l'amélioration des capacités de raisonnement causal plutôt que sur leur simple évaluation. Ils soutiennent que la construction incrémentale de simulateurs est essentielle pour maintenir la fidélité dans des systèmes complexes, une prouesse difficile à réaliser avec une génération en une seule étape.

Limites et modestie :
Les auteurs sont modestes quant aux implications de leurs résultats. Ils déclarent explicitement que :

Une haute précision sur les requêtes causales ne garantit pas que le modèle a appris des mécanismes causaux invariants ou récupéré le graphe sous-jacent réel ; le modèle peut toujours compter sur des raccourcis prédictifs.
L'auto-amélioration est limitée par la diversité et la qualité de la sortie du générateur ; l'auto-amélioration récursive sans ancrage externe risque l'effondrement du modèle ou le renforcement des biais.
Les expériences actuelles sont principalement déterministes ; l'extension au raisonnement stochastique où les contrefactuels sont ambigus reste un travail futur.

En conclusion, CauSim démontre que transformer le raisonnement causal en un problème supervisé et évolutif via des simulateurs exécutables est une voie viable pour améliorer la capacité des LLM à gérer des scénarios complexes de type « et si » à travers des représentations diverses.