R1-Code-Interpreter: LLMs Reason with Code via Supervised and Multi-stage Reinforcement Learning

Le papier présente R1-Code-Interpreter, un modèle de langage entraîné via un apprentissage par renforcement multi-étapes et un curriculum adaptatif pour maîtriser l'utilisation autonome d'interpréteurs de code sur des tâches variées, surpassant ainsi les performances de GPT-4o avec une précision accrue et des capacités d'auto-vérification émergentes.

L'essentiel

🧠 Le Grand Défi : Faire parler les IA avec des outils

Imaginez que vous avez un génie très intelligent (une Intelligence Artificielle) qui adore lire des livres et réfléchir. Il est excellent pour comprendre les blagues, écrire des poèmes ou expliquer la philosophie. Mais si vous lui demandez de faire un calcul mathématique complexe ou de trier une liste de 1000 noms, il commence à bégayer, à faire des erreurs de calcul ou à inventer des faits. C'est comme demander à un chef cuisinier de faire des maths : il a le cerveau, mais pas les outils adaptés.

Pour l'aider, on lui a donné un couteau suisse numérique : le "Code Interpreter" (un outil qui lui permet d'écrire et d'exécuter du code informatique pour faire les calculs à sa place).

Le problème ? Ce génie est un peu têtu. Parfois, il essaie de résoudre un problème de maths avec des mots (ce qui est lent et imprécis), et parfois il écrit du code pour une tâche simple (ce qui est inutilement compliqué). Il ne sait pas toujours quand utiliser son cerveau et quand utiliser son couteau suisse.

🚀 La Solution : R1-Code-Interpreter

Les chercheurs de ce papier ont créé une méthode pour apprendre à ce génie à devenir un maître stratège. Ils ne veulent plus qu'il devine, ils veulent qu'il apprenne par l'expérience, un peu comme un enfant qui apprend à faire du vélo.

Voici comment ils ont fait, en trois étapes simples :

1. La Phase d'Entraînement (Le "SFT")

Imaginez que vous donnez au génie un manuel d'instructions écrit par un expert (GPT-4o). Ce manuel contient des milliers d'exemples de problèmes résolus :

• Exemple 1 : "Pour compter les pommes, écris un petit programme."
• Exemple 2 : "Pour écrire une histoire, utilise juste tes mots."
  Le génie lit tout cela pour comprendre les bases. C'est comme apprendre la théorie avant de conduire.

2. Le Problème : Trop de problèmes, trop de confusion

Ensuite, les chercheurs ont voulu le faire pratiquer sur 144 types de problèmes différents (des énigmes logiques, des maths, de la géométrie, etc.).
Mais là, ça a failli échouer ! C'est comme si on mettait un élève devant 144 matières différentes en même temps sans programme.

• S'il essaie de résoudre un problème trop facile, il s'ennuie et n'apprend rien.
• S'il essaie un problème trop dur, il est frustré et ne progresse pas.
• Le mélange de tout ça a rendu l'apprentissage très lent et inefficace.

3. La Révolution : L'École par "Niveaux de Potentiel" (Curriculum Learning)

C'est ici que la magie opère. Au lieu de donner les problèmes dans le désordre, les chercheurs ont inventé un système de classement intelligent.

Imaginez un professeur très astucieux qui observe l'élève. Il ne donne pas les exercices les plus durs tout de suite, ni les plus faciles. Il cherche les exercices "juste à la limite" de la capacité de l'élève.

• Le concept de "Potentiel d'amélioration" : Le professeur regarde : "Est-ce que cet élève a 50% de chances de réussir cet exercice ?"
  • Si c'est 100% (trop facile) : Pas de gain, on ne perd pas de temps.
  • Si c'est 0% (trop dur) : Pas de gain, l'élève est bloqué.
  • Si c'est 50% (le juste milieu) : C'est là que l'apprentissage explose ! C'est le moment où l'élève peut vraiment progresser.

Les chercheurs ont donc organisé l'entraînement en 4 étapes :

1. Niveau 1 : On donne uniquement les exercices où le génie a un "potentiel d'amélioration" très élevé (ceux où il est à mi-chemin entre échec et réussite).
2. Niveau 2 : Une fois qu'il a maîtrisé ceux-là, on ajoute des exercices un peu plus difficiles.
3. Niveau 3 & 4 : On continue d'élargir le champ jusqu'à inclure tout, même les exercices très durs.

C'est comme monter une échelle : on ne saute pas les barreaux, on monte un par un, en commençant par ceux qui sont les plus accessibles pour faire progresser l'élève le plus vite possible.

🌟 Les Résultats Surprenants

Grâce à cette méthode, le modèle final (appelé R1-CI-14B) est devenu un champion :

• Il bat les géants : Il est plus performant que GPT-4o (le modèle le plus célèbre d'OpenAI), même quand GPT-4o utilise son propre outil de code.
• Il s'auto-vérifie (Le super-pouvoir) : Le plus fascinant, c'est que le modèle a développé un comportement qu'on n'avait pas programmé explicitement : l'auto-vérification.
  • Analogie : Imaginez un détective qui résout un crime. Avant de conclure, il écrit un petit script pour vérifier ses preuves. Si le script dit "Erreur", il ne se contente pas de dire "J'ai raté", il réécrit son code pour trouver la bonne réponse. Le modèle a appris à douter de lui-même et à se corriger en utilisant le code.

💡 En Résumé

Ce papier nous dit que pour faire apprendre une IA à utiliser des outils (comme le code) sur plein de tâches différentes, il ne suffit pas de lui donner des milliers d'exemples en vrac. Il faut être stratège :

1. Identifier les tâches où l'IA est "à mi-chemin" de la réussite.
2. L'entraîner d'abord sur ces tâches précises.
3. Progressivement lui donner des défis plus grands.

C'est comme apprendre à nager : on ne jette pas l'enfant dans l'océan (trop dur), ni on ne le laisse marcher sur la plage (trop facile). On le met dans la piscine, là où il peut apprendre à respirer et à bouger, pour qu'un jour, il puisse traverser l'océan.

Résultat : Une IA qui raisonne mieux, utilise mieux ses outils, et qui, surtout, apprend à se faire confiance... et à se corriger elle-même ! 🎓🤖✨

Résumé technique

Voici un résumé technique détaillé du papier de recherche R1-Code-Interpreter, publié à la conférence ICLR 2026.

1. Problématique

Bien que l'apprentissage par renforcement (RL) ait considérablement amélioré les capacités de raisonnement des grands modèles de langage (LLM), ces derniers peinent toujours sur des tâches apparemment simples et souffrent de coûts élevés en tokens lors de la recherche en temps d'inférence. Le raisonnement purement textuel excelle dans la sémantique et le bon sens, mais échoue souvent dans les calculs précis, la manipulation symbolique et l'optimisation algorithmique.

L'utilisation d'interpréteurs de code (Code Interpreter) par des modèles comme GPT-4o offre une solution potentielle, mais les implémentations actuelles ont du mal à décider efficacement quand basculer entre le raisonnement textuel et l'exécution de code. De plus, les travaux antérieurs sur l'intégration d'outils via RL se sont concentrés sur des domaines étroits (comme les mathématiques pures), laissant un vide concernant l'entraînement de codeurs généraux capables de gérer une grande diversité de tâches complexes. Le défi majeur réside dans l'hétérogénéité des tâches et la rareté des échantillons "efficaces" (ceux où le modèle peut apprendre) lors de l'entraînement RL sur un large éventail de problèmes.

2. Méthodologie

Les auteurs proposent R1-Code-Interpreter, un cadre d'entraînement combinant le Supervised Fine-Tuning (SFT) et un apprentissage par renforcement multi-étapes pour entraîner des LLMs à générer et exécuter du code de manière autonome.

A. Collecte de Données et SFT

• Jeu de données : 144 tâches de raisonnement et de planification diversifiées (issues de SymBench, Big-Bench-Hard et Reasoning-Gym), couvrant des compétences mathématiques, spatiales, logiques, d'optimisation et de recherche.
• Synthèse : Génération de 6 500 trajectoires multi-tours (texte/code) pour le SFT, en utilisant GPT-4o pour créer des exemples corrects.
• Format : Le modèle apprend à alterner entre le raisonnement textuel et la génération de blocs de code Python (encadrés par ```python), exécutés par un interpréteur externe, jusqu'à ce qu'une réponse finale soit produite (encadrée par <<< >>>).

B. Apprentissage par Renforcement (RL) et Courbe d'Apprentissage Multi-Étapes

L'approche standard de type DeepSeek (GRPO - Group Relative Policy Optimization) échoue sur des ensembles de données hétérogènes car le signal de récompense devient trop dilué ou trop rare (trop de tâches trop faciles ou trop difficiles).

Pour résoudre cela, les auteurs introduisent une méthode d'apprentissage par curriculum multi-étapes guidée par le "potentiel d'amélioration" :

1. Estimation du Potentiel : Avant le RL, le modèle est interrogé avec différentes stratégies d'agents (texte seul, code seul, hybride) sur chaque échantillon. Le "potentiel d'amélioration" ($\Pi_i$) est calculé comme $4 \times p_i(1-p_i)$, où$p_i$ est le taux de réussite empirique. Ce score est maximal lorsque le modèle réussit environ 50 % du temps (zone d'apprentissage optimale) et minimal pour les tâches triviales ou impossibles.
2. Curriculum en 4 Étapes : Les échantillons sont triés par potentiel décroissant et divisés en quatre groupes. L'entraînement GRPO commence par le groupe à fort potentiel, puis intègre progressivement les groupes à potentiel plus faible. Cela permet de maximiser le gradient de politique au début de l'entraînement.

C. Optimisation de l'Infrastructure (Code Execution Sandbox)

L'exécution de code est coûteuse en temps et réduit l'utilisation du GPU, limitant la taille des lots (batch size).

• Solution : Découplage du calcul des gradients (sur GPU) et de l'exécution du code (sur un sandbox CPU dédié avec 5 nœuds de 64 cœurs).
• Gain : Réduction du temps d'entraînement total de 39 % (passant de ~4500 à ~1845 heures GPU).

3. Contributions Clés

1. Premier Code Interpreter Généraliste : C'est le premier travail publié à entraîner un interpréteur de code généraliste sur une large gamme de tâches (144) et de domaines, au-delà des simples problèmes mathématiques.
2. Cadre d'Apprentissage par Curriculum Innovant : Identification des limites du RL standard sur des données hétérogènes et proposition d'une méthode guidée par le potentiel d'amélioration, augmentant les gains RL de +3,4 % à +9,3 %.
3. Efficacité de l'Entraînement : Découplage de l'exécution de code et du calcul des gradients pour réduire les coûts et le temps d'entraînement.
4. Analyse des Stratégies : Démonstration que l'initialisation par SFT est cruciale, que les modèles Qwen-2.5 surpassent les modèles distillés de DeepSeek pour cette tâche, et que le cadre multi-tours est supérieur aux approches mono-tour.

4. Résultats

Le modèle final, R1-CI-14B, a été évalué sur 37 tâches de test (non vues lors de l'entraînement) :

• Performance : Il atteint une précision moyenne de 72,4 %.
• Comparaison : Il surpasse :
  • GPT-4o (texte seul) : 58,6 %
  • GPT-4o avec Code Interpreter natif : 70,9 %
  • Les versions non entraînées (SFT seul ou GRPO sans curriculum) montrent des gains significatifs grâce à la méthode proposée.
• Généralisation : Le modèle montre une bonne capacité de généralisation sur des tâches hors distribution (OOD) comme GPQA et AIME.
• Comportement Émergent : Le modèle développe spontanément un comportement d'auto-vérification (self-checking), générant du code pour valider ses propres réponses avant de les soumettre, une capacité rarement observée avant l'entraînement.

5. Signification

Ce travail démontre que l'entraînement de modèles de langage à utiliser des outils de programmation de manière autonome et généraliste est possible, mais nécessite des stratégies d'entraînement sophistiquées pour surmonter l'hétérogénéité des tâches. La méthode de curriculum basée sur le potentiel d'amélioration offre une nouvelle voie pour optimiser l'apprentissage par renforcement dans des environnements complexes et multi-tâches. De plus, la réduction des coûts d'entraînement via le sandbox CPU rend cette approche plus accessible. R1-Code-Interpreter établit un nouvel état de l'art pour les agents LLM capables de raisonner et d'agir via le code, surpassant même les modèles propriétaires les plus avancés sur des benchmarks de raisonnement et de planification.