🤖 machine learning

CLEANER: Self-Purified Trajectories Boost Agentic Reinforcement Learning

Le papier propose CLEANER, une méthode qui exploite les capacités intrinsèques d'autocorrection d'un modèle à travers un mécanisme de retour en arrière adaptatif sensible à la similitude (Similarity-Aware Adaptive Rollback) pour générer des trajectoires d'entraînement sans erreur, résolvant ainsi les problèmes d'attribution de crédit et augmentant considérablement la performance et l'efficacité de l'apprentissage par renforcement agentique à paramètres contraints.

Auteurs originaux : Tianshi Xu, Yuteng Chen, Meng Li

Publié 2026-07-07

📖 4 min de lecture☕ Lecture pause café

CC BY 4.0

Auteurs originaux : Tianshi Xu, Yuteng Chen, Meng Li

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

Imaginez que vous enseignez à un jeune apprenti (un petit modèle d'IA) comment résoudre des énigmes complexes en utilisant un outil puissant mais capricieux : un interprète de code informatique. Le but est que l'apprenti écrive du code, l'exécute et obtienne la bonne réponse.

Cependant, il y a un problème. Comme l'apprenti est encore en plein apprentissage, il fait beaucoup d'erreurs. Il écrit du code qui plante, provoquant l'affichage de longs messages d'erreur confus par l'ordinateur. Dans une configuration d'entraînement standard, l'apprenti garde ces messages d'erreur désordonnés dans sa mémoire, essayant de les corriger étape par étape. Finalement, il peut trouver la bonne réponse, mais le chemin emprunté est rempli de bruit, de confusion et d'impasses.

Le papier soutient que ce « chemin désordonné » nuit en réalité au processus d'apprentissage. Lorsque l'apprenti réussit enfin, l'enseignant (l'algorithme d'entraînement) lui donne une récompense de type « bon travail » pour l'ensemble du voyage. C'est injuste car cela récompense les erreurs autant que la réflexion correcte. C'est comme féliciter un chef pour avoir brûlé la soupe mais l'avoir finalement réparée avec une cuillère ; le chef apprend alors que brûler les choses n'est pas grave tant qu'il les répare plus tard.

La Solution : CLEANER (Le Chef « Auto-Purificateur »)

Les auteurs proposent une nouvelle méthode appelée CLEANER. Au lieu de laisser l'apprenti conserver l'historique désordonné de ses erreurs, CLEANER agit comme un éditeur intelligent qui nettoie l'histoire pendant que l'apprenti apprend.

Voici comment cela fonctionne, en utilisant une analogie créative :

1. Le moment de l'« Oups » (Le Déclencheur)
L'apprenti écrit une ligne de code, l'exécute, et l'ordinateur hurle « ERREUR ! ». Dans un cours normal, l'apprenti ajouterait simplement cette erreur à son cahier et essaierait à nouveau.

2. Le bouton « Retour en arrière » (Le mécanisme SAAR)
CLEANER intervient immédiatement. Il met le processus en pause et demande à l'apprenti : « D'accord, tu as fait une erreur. Peux-tu la corriger dès maintenant ? » L'apprenti essaie à nouveau et réussit.

3. L'« Édition » (Rollback Adaptatif Sensible à la Similitude)
C'est la partie magique. CLEANER examine l'erreur et la correction pour décider comment nettoyer le cahier :

Scénario A (Les fautes de frappe) : Si la correction est un changement mineur (comme corriger une virgule manquante), CLEANER suppose que la réflexion de l'apprenti était en fait bonne, il s'agissait juste d'une faute de frappe. Il efface discrètement l'erreur et la correction, remplaçant la ligne désordonnée par le code correct et propre. Le cahier affiche désormais un processus de pensée fluide et réussi.
Scénario B (Le défaut de logique) : Si la correction est complètement différente de la tentative originale (comme réaliser que toute l'approche était mauvaise), CLEANER sait que la réflexion originale était erronée. Il efface l'intégralité de la tentative erronée et le message d'erreur, le remplaçant par la nouvelle ligne de raisonnement correcte.

4. Le Résultat : Une Trajectoire « Purifiée »
D'ici la fin de l'entraînement, l'apprenti n'a jamais « vu » les versions désordonnées et truffées d'erreurs de son travail. Il a seulement appris à partir d'histoires « auto-purifiées » où il a résolu le problème correctement dès la première tentative (ou l'a corrigé instantanément sans laisser de trace de la difficulté).

Pourquoi cela importe

Moins de bruit, plus d'apprentissage : Parce que l'apprenti n'est pas distrait par un historique d'erreurs, il apprend la logique correcte beaucoup plus rapidement.
Efficacité : Le papier affirme que cette méthode est incroyablement efficace. Ils ont réussi à entraîner un petit modèle d'IA pour qu'il soit aussi performant que des modèles beaucoup plus grands et coûteux, mais ils l'ont fait en utilisant seulement un tiers des étapes d'entraînement. C'est comme acquérir les compétences d'un maître chef en trois mois au lieu d'un an.
Meilleurs résultats : Sur des tests difficiles de mathématiques et de codage (comme AIME et LiveCodeBench), cette méthode a amélioré la précision d'environ 3 % à 6 % par rapport aux méthodes standards.

En résumé

Considérez l'entraînement standard comme le fait de laisser un étudiant s'exercer sur un tableau blanc couvert de gribouillis effacés, tachés et confus. CLEANER est comme une gomme magique qui nettoie instantanément les taches, ne laissant que les étapes parfaites et claires de la solution. Cela permet à l'étudiant d'internaliser la bonne façon de penser, plutôt que de se laisser confondre par la mauvaise façon qu'il a essayée au départ.

Résumé Technique : CLEANER – Des trajectoires auto-purifiées pour booster l'apprentissage par renforcement agentique

1. Énoncé du Problème

Le document traite d'un goulot d'étranglement critique dans l'Apprentissage par Renforcement (RL) Agentique pour les Grands Modèles de Langage (LLM), particulièrement pour les modèles à contraintes de paramètres (ex: 4B–7B paramètres) qui utilisent des outils comme les interpréteurs Python. Bien que l'utilisation d'outils permette une résolution de problèmes complexes, la phase d'exploration est entravée par des échecs d'exécution fréquents. Ces échecs génèrent des « trajectoires bruitées » contenant du code invalide et des traces d'erreurs verbeuses qui contaminent la fenêtre de contexte.

Sous les configurations de récompense basées sur le résultat standard (ex: Group Relative Policy Optimization ou GRPO), l'intégralité de la trajectoire reçoit une récompense positive uniforme lors du succès final, indépendamment des erreurs intermédiaires. Cela crée un dilemme d'attribution de crédit :

Pollution par le bruit : Les actions erronées et les boucles consécutives « Erreur → Feedback → Tentative » sont involontairement renforcées parallèlement au raisonnement réussi.
Interférence sémantique : Le modèle apprend à rationaliser des chemins d'exécution incorrects plutôt qu'à ancrer à nouveau ses décisions, ce qui conduit à une instabilité de la politique et une dégradation des performances.
Limitations existantes : Les stratégies d'atténuation actuelles font face à un compromis. L'attribution de récompenses denses peut déclencher le « détournement de récompense » (optimisation des métriques intermédiaires au détriment des résultats finaux), tandis que le suréchantillonnage (génération de multiples candidats pour filtrer la qualité) impose des coûts de calcul prohibitifs, car la phase de déploiement (rollout) domine le temps d'entraînement du RL.

2. Méthodologie : CLEANER et SAAR

Les auteurs proposent CLEANER, un cadre qui booste le RL agentique en éliminant le contexte contaminé par les erreurs directement lors de la collecte de données, plutôt que de compter sur un filtrage externe ou un échantillonnage accru. Le mécanisme central est le SAAR (Similarity-Aware Adaptive Rollback).

Le Mécanisme SAAR

SAAR opère durant la phase de déploiement lorsqu'une erreur d'exécution ( $o^-$ ) survient. Au lieu d'enregistrer de façon permanente l'échec dans l'historique, le système initie un processus en deux phases pour construire une trajectoire « auto-purifiée » :

Phase I : Déclenchement de l'erreur et correction par anticipation (Lookahead)
- Lors d'une erreur, l'état actuel est gelé.
- Le modèle est sollicité avec le contexte augmenté (incluant la trace d'erreur) pour générer une correction ( $c'_t$ ) et une trace de raisonnement auxiliaire ( $r'_{aux}$ ).
- Si la correction réussit, le processus passe à la Phase II.
Phase II : Remplacement adaptatif sensible à la similarité
- SAAR calcule la similarité sémantique entre le code erroné ( $c_t$ ) et le code corrigé ( $c'_t$ ) via une fonction de similarité (ex: difflib.SequenceMatcher).
- Cas A : Réparation au niveau de l'implémentation (Similarité élevée) : Si la similarité est supérieure à un seuil $\gamma$ , l'erreur est jugée superficielle (ex: fautes de frappe de syntaxe). Le système effectue un remplacement superficiel, écartant le tuple d'erreur et greffant directement le code corrigé sur le raisonnement original.
- Cas B : Réparation au niveau du raisonnement (Similarité faible) : Si la similarité est faible, l'erreur indique une faille logique profonde. Le système effectue un remplacement profond, supprimant l'intégralité du tour échoué (raisonnement + code + erreur) et le substituant par le raisonnement auxiliaire et le code corrigé pour maintenir la cohérence sémantique.

Détails d'Implémentation

Recalcul des Logits : Pour garantir que la mise à jour de la politique est ancrée dans le chemin causal correct, le système recalcule les log-probabilités des actions corrigées sous le contexte purifié (et non le contexte augmenté par l'erreur). Ceci est réalisé efficacement grâce à RadixAttention (via SGLang) pour réutiliser les caches KV des préfixes d'historique invariants.
Mélange de Curriculum : Pour équilibrer l'évitement des erreurs et la capacité intrinsèque du modèle à s'auto-corriger, le pipeline d'entraînement applique stochastiquement SAAR à 70 % des trajectoires tout en conservant 30 % dans leur état d'origine.

3. Principales Contributions

Le document expose quatre contributions majeures :

Cadre CLEANER : Une approche novatrice pour résoudre le dilemme de l'attribution de crédit dans le RL agentique en s'entraînant sur des trajectoires auto-purifiées, permettant aux modèles d'internaliser les schémas de raisonnement corrects tout en filtrant le bruit d'exécution.
Mécanisme SAAR : Une méthode autonome pour construire des signaux propres en réparant de manière adaptative les échecs (des fautes de syntaxe aux failles logiques) sans la surcharge de calcul du suréchantillonnage.
Efficacité et Performance : Démontrer que CLEANER atteint des performances de pointe (SOTA) avec une efficacité nettement supérieure, égalant les modèles SOTA tout en nécessitant seulement un tiers des étapes d'entraînement.
Reproductibilité : Fourniture d'un pipeline d'entraînement entièrement reproductible, incluant le code, les configurations d'environnement et les jeux de données traités.

4. Résultats Expérimentaux

Les auteurs ont évalué CLEANER sur AIME24/25, GPQA, et LiveCodeBench en utilisant Qwen3-4B-Instruct et Qwen2.5-7B-Instruct comme modèles de base.

Gains de Performance : Comparé aux bases de référence, CLEANER a obtenu des gains de précision moyens de :
- 6 % sur AIME (Pass@1).
- 3 % sur GPQA.
- 5 % sur LiveCodeBench.
Efficacité : CLEANER a égalé la performance de la base de référence SOTA DemyAgent-4B tout en utilisant seulement un tiers des étapes d'entraînement (250 étapes contre 750).
Suppression des Erreurs : Les métriques d'entraînement montrent une suppression constante des appels d'outils erronés, avec une corrélation claire entre la réduction des taux d'échec des outils et l'amélioration des taux de réussite.
Études d'Ablation :
- Nécessité des Outils : L'intégration d'un interprète de code a considérablement boosté les performances (ex: +20 % sur Qwen2.5-7B pour les tâches de maths/code).
- Purification de la Trajectoire : Le mécanisme SAAR a fourni des gains constants à travers tous les benchmarks et échelles de modèles.
- Internalisation : Lorsque SAAR était désactivé lors de l'inférence, la dégradation des performances était négligeable (ex: <1 % de baisse sur AIME24 Pass@1), confirmant que le modèle avait internalisé la logique d'évitement d'erreur plutôt que de s'appuyer sur le mécanisme comme d'un échafaudage.
- Récupération : L'introduction de CLEANER sur une base de référence sous-optimale et instable (à l'étape 200) a stabilisé l'entraînement et amélioré la précision, bien qu'il n'ait pas totalement atteint la performance des modèles entraînés avec SAAR dès le départ.

5. Signification et Revendications

Le papier affirme que CLEANER offre une solution scalable pour un RL agentique efficace en déplaçant l'accent de "plus de données" (suréchantillonnage) vers des "données plus propres" (purification de trajectoire).

Scalabilité : En éliminant le besoin de suréchantillonnage coûteux, la méthode rend le RL agentique de haute qualité réalisable dans des contextes à ressources limitées.
Alignement du Signal d'Apprentissage : La méthode aligne les signaux d'entraînement avec les comportements corrects, empêant le renforcement des boucles erreur-récupération et permettant aux modèles d'internaliser des schémas robustes d'utilisation d'outils.
Généralisabilité : Les résultats suggèrent que de petits modèles (4B), lorsqu'ils sont soumis à un post-entraînement sur mesure avec purification de trajectoire, peuvent atteindre des capacités comparables à des modèles nettement plus grands (ex: 72B ou 671B) dans des tâches de raisonnement agentique.

Les auteurs concluent que la purification de trajectoire est une alternative critique et scalable pour faire progresser l'efficacité et la performance des agents LLM augmentés par des outils.