💻 computer science

BenchEvolver: Frontier Task Synthesis via Solution-Centric Evolution

BenchEvolver est un cadre évolutif centré sur les solutions qui transforme automatiquement des problèmes de codage existants en variantes plus difficiles et vérifiables en faisant évoluer les solutions de référence, créant ainsi des bancs d'essai de haute qualité comme LiveCodeBench-Plus qui restaurent la discrimination des modèles et fournissent des signaux d'entraînement efficaces pour l'auto-amélioration.

Auteurs originaux : Yangzhen Wu, Aaron J. Li, Wenjie Ma, Li Cao, Ziheng Zhou, Mert Cemri, Shu Liu, Yuran Xiu, Chenxiao Yan, Haikun Zhao, Bin Yu, Ion Stoica, Dawn Song

Publié 2026-06-02

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Yangzhen Wu, Aaron J. Li, Wenjie Ma, Li Cao, Ziheng Zhou, Mert Cemri, Shu Liu, Yuran Xiu, Chenxiao Yan, Haikun Zhao, Bin Yu, Ion Stoica, Dawn Song

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 un jeu vidéo où les joueurs (les modèles d'IA) sont devenus si performants qu'ils réussissent chaque niveau avec une précision de 100 %. Les concepteurs du jeu (les chercheurs humains) sont bloqués car ils ne parviennent pas à créer de nouveaux niveaux assez rapidement pour défier ces super-joueurs. Les anciens niveaux sont trop faciles, et le jeu a perdu tout son intérêt.

Ce document présente BenchEvolver, un nouvel outil qui agit comme un « moteur de montée en niveau » pour ces jeux d'IA. Au lieu que les humains tentent d'inventer de nouveaux problèmes complexes à partir de zéro, BenchEvolver prend un problème existant et facile et le transforme automatiquement en quelque chose de beaucoup plus difficile, tout en s'assurant que le nouveau niveau reste équitable et soluble.

Voici comment cela fonctionne, décomposé en concepts simples :

1. Le Problème : Le piège du « Mode Facile »

Actuellement, les modèles d'IA sont si avancés qu'ils peuvent résoudre presque tous les puzzles de programmation que nous avons. C'est comme un étudiant qui aurait mémorisé toutes les questions du manuel. Lorsqu'il passe un examen, il obtient 100 % partout. C'est une mauvaise chose pour deux raisons :

Nous ne pouvons pas dire quelle IA est réellement la plus intelligente, car elles obtiennent toutes des scores parfaits.
L'IA cesse d'apprendre parce qu'elle ne fait jamais face à un défi qu'elle ne peut pas résoudre.

2. La Solution : Faire évoler le « Corrigé » en premier

La plupart des tentatives précédentes pour créer de nouveaux problèmes fonctionnaient ainsi : « Écrivons une nouvelle histoire sur un problème mathématique, puis espérons qu'une IA puisse le résoudre. » Cela conduit souvent à des puzzles cassés ou à des problèmes trop vagues.

BenchEvolver inverse la tendance. Au lieu de commencer par l'histoire (le problème), il commence par le corrigé (le code de la solution).

La Métaphore : Imaginez un chef cuisinier expert (l'IA) qui sait préparer un gâteau au chocolat parfait (la solution).
La Mutation : BenchEverler dit au chef : « D'accord, maintenant prépare un gâteau, mais tu dois utiliser un ingrédient secret qui change la chimie, et tu ne peux pas utiliser les mêmes réglages de four. »
Le Résultat : Le chef écrit une nouvelle recette complexe (la solution évoluée).
L'Étape vers l'arrière : Une fois que le chef a la nouvelle recette complexe, BenchEvolver travaille à rebours pour écrire les instructions destinées au client (l'énoncé du problème) et crée un test de dégustation (les tests) pour voir si le gâteau est réussi.

Parce que le problème est construit autour d'une solution complexe et fonctionnelle, nous savons avec certitude que le puzzle est soluble et possède une réponse claire.

3. La Boucle d'« Auto-Défi »

La partie la plus intéressante est que BenchEvolver n'a pas besoin d'un « professeur super intelligent » pour rendre les niveaux difficiles. Il utilise l'IA elle-même pour tester les nouveaux niveaux.

L'IA essaie de résoudre le nouveau problème muté.
Si l'IA réussit, le niveau est trop facile. BenchEvolver dit : « Réessaie, rends-le plus difficile ! »
Si l'IA échoue, mais que le puzzle est toujours valide, succès ! Nous avons trouvé un niveau qui expose la faiblesse de l'IA.

Cela crée un cycle où l'IA génère un défi, tente de le résoudre, échoue, apprend de son échec, puis génère un défi encore plus difficile. C'est comme un partenaire d'entraînement qui devient plus fort à chaque combat.

4. Les Résultats : Une nouvelle « Ligue du Mode Difficile »

Les chercheurs ont testé cela sur deux grands ensembles de puzzles de programmation :

LiveCodeBench : Puzzles de programmation compétitive (comme Codeforces).
SciCode : Puzzles de programmation de recherche scientifique.

Que s'est-il passé ?

La difficulté a grimpé en flèche : Ils ont pris des problèmes où les modèles d'IA obtenaient auparavant 90 à 99 % de réussite. Après l'évolution, ces mêmes modèles sont tombés à 27–62 % de réussite. Le « Mode Facile » a été transformé avec succès en « Mode Difficile ».
Nouveau Benchmark : Ils ont créé LIVECODEBENCH-PLUS, une collection de 91 problèmes super difficiles. Cette nouvelle suite de tests peut enfin différencier à nouveau les meilleurs modèles d'IA.
Puissance d'entraînement : Lorsqu'ils ont utilisé ces nouveaux problèmes difficiles pour entraîner l'IA (en utilisant une méthode appelée Apprentissage par Renforcement), l'IA est devenue nettement meilleure pour résoudre d'autres problèmes difficiles qu'elle n'avait jamais vus auparavant.

Résumé

Voyez BenchEvolver comme une salle de sport pour l'IA. Au lieu d'attendre que les humains construisent de nouveaux poids lourds, l'IA soulève les poids existants, ajoute des disques de poids dessus, puis essaie de soulever la nouvelle version plus lourde. Si elle n'y arrive pas, elle apprend comment devenir plus forte.

L'article prouve qu'en faisant évoluer les solutions d'abord et en travaillant à rebours pour obtenir les problèmes, nous pouvons créer automatiquement un flux inépuisable de défis de haute qualité et difficiles qui maintiennent les modèles d'IA affûtés et permettent de mesurer leur véritable progression.

Résumé technique : BenchEvolver : Synthèse de tâches de pointe via l'évolution centrée sur la solution

Énoncé du problème

L'avancement rapide des modèles de langage de pointe (LLM) a conduit à la saturation des benchmarks de codage largement utilisés. Sur des jeux de données comme LiveCodeBench, les modèles de pointe atteignent des taux de réussite quasi parfaits (par exemple, >99 % sur les divisions faciles, >90 % en moyenne), rendant ces benchmarks inefficaces pour différencier les capacités des modèles ou fournir des gradients d'entraînement significatifs. Bien que la construction humaine de nouveaux jeux de données complexes soit possible, elle est coûteuse et difficile à mettre à l'échelle. Les méthodes existantes de génération de données synthétiques suivent souvent un paradigme asymétrique enseignant-élève (où un modèle plus fort génère des données pour des modèles plus faibles) ou opèrent au niveau de l'instruction sans garantir la validité de la tâche exécutable sous-jacente (énoncé, solution et tests). Par conséquent, il manque des mécanismes permettant aux modèles de pointe de générer des tâches valides, vérifiables et difficiles qui défient le générateur lui-même, une condition préalable à l'auto-amélioration en boucle fermée.

Méthodologie : BenchEvolver

Les auteurs présentent BenchEvolver, un cadre d'évolution centré sur la solution conçu pour transformer des tâches de codage saturées en variantes plus difficiles et vérifiables. Contrairement aux approches traditionnelles qui génèrent d'abord un énoncé de problème puis tentent de trouver une solution, BenchEvolver inverse ce pipeline :

Évolution centrée sur la solution : Le processus commence par la solution de référence ( $C$ ) d'une tâche initiale (seed). Un Proposeur (Proposer) mute cette solution en une nouvelle solution de référence ( $C'$ ) structurellement distincte. Cette mutation est guidée par l'objectif d'introduire un « levage algorithmique dominant » (dominant algorithmic lift) — un changement substantiel (par exemple, nécessiter une nouvelle structure de données, une classe de complexité différente ou une reformulation mathématique) qui rend la solution parente insuffisante.
Dérivation des composants de la tâche : Une fois $C'$ établie, le cadre dérive l'énoncé du problème en langage naturel ( $S'$ ), les exemples publics et les suites de tests cachés ( $T'$ ) directement à partir de la solution évoluée. Cela garantit que la tâche est ancrée dans une sémantique exécutable.
Vérification et sélection empirique : Un Évaluateur (Evaluator) valide la tâche candidate ( $I' = (S', C', T', E)$ ) via des contrôles de cohérence spécifiques au benchmark (par exemple, la triangulation entre la solution de référence, un solveur de force brute et un oracle de type « énoncé seul » pour la programmation compétitive ; l'utilisation de contrôles de fidélité de l'énoncé pour le codage scientifique). Crucialement, la difficulté n'est pas assignée de manière heuristique mais mesurée empiriquement : une candidate n'est acceptée que si elle entraîne un taux de réussite inférieur pour un panel cible de modèles par rapport à la tâche initiale.
Recherche guidée par la mémoire : Le cadre utilise des modules de mémoire locale et globale. La mémoire locale suit la lignée d'une graine spécifique (mutations acceptées, raisons d'échec), tandis que la mémoire globale enregistre les familles de mutations acceptées à travers toutes les graines pour encourager la diversité et éviter l'exploration redondante. Cela guide le Proposeur pour éviter les échecs répétés et explorer des directions algorithmiques distinctes.

Contributions clés

Cadre BenchEvolver : Un nouveau cadre en boucle fermée qui fait évoluer les tâches de codage saturées en mutant d'abord les solutions de référence, puis en dérivant les énoncés et les tests. Cette conception garantit que les tâches sont exécutables et vérifiables sans nécessiter de modèle « enseignant » strictement plus fort.
Validation trans-domaine : Le cadre est démontré comme fonctionnel à travers deux domaines de codage exécutables distincts : la programmation compétitive (LiveCodeBench) et le codage scientifique (SciCode), produisant des tâches valides, diverses et sensiblement plus difficiles dans les deux cas.
LIVECODEBENCH-PLUS : Les auteurs ont constitué un nouveau benchmark de 91 problèmes combinant des tâches évoluées avec des problèmes originaux difficiles de LiveCodeBench-v6. Ce benchmark restaure une discrimination claire entre les modèles de pointe, avec des scores Pass@1 allant de 27,5 % à 62,6 %.
Signal d'auto-amélioration : L'article fournit la preuve que les tâches évoluées servent de signaux d'entraînement efficaces pour le modèle qui les a générées. L'apprentissage par renforcement (RL) sur les tâches évoluées améliore les performances de codage sur des données non vues (held-out) au-delà du simple entraînement sur l'ensemble de graines initial.

Résultats

Difficulté et validité des tâches : Appliqué à LiveCodeBench et SciCode, BenchEvolver génère avec succès des tâches évoluées valides qui réduisent considérablement les taux de réussite des modèles cibles. Par exemple, sur les graines « Hard » de LiveCodeBench, le Pass@1 moyen des modèles est passé de 87,0 % à 45,7 % sur les tâches évoluées.
Diversité algorithmique : L'évaluation humaine par des experts en programmation compétitive a révélé que les tâches évoluées élargissent la surface algorithmique. Alors que les problèmes initiaux étaient dominés par la « Recherche/Simulation » (32,7 %), les tâches évoluées ont réparti la masse vers des catégories avancées comme HLD/LCT, les automates AC et les méthodes polynomiales. Le nombre de catégories algorithmiques distinctes est passé de 19 dans les graines à 30 dans l'ensemble évolué.
Gains de performance par RL : En utilisant gpt-oss-20b comme évolueur et modèle cible, l'entraînement sur un mélange de tâches initiales et évoluées a produit des gains significatifs sur les benchmarks de test :
- LCB v6 Hard : Gain de +8,7 en Pass@1 par rapport à la ligne de base (baseline) composée uniquement de graines (une amélioration relative de 70,7 % par rapport au gain de la graine seule).
- LCB-Pro Easy : Gain de +8,3 en Pass@1 par rapport à la ligne de base (une amélioration relative de 34,8 %).
- Transfert : L'entraînement sur des tâches évoluées auto-générées a également amélioré les performances sur un benchmark évolué indépendamment (généré par Gemini-3-Flash), suggérant que le signal se transfère au-delà de la distribution spécifique du générateur.

Signification et affirmations

L'article affirme que BenchEvolver résout le goulot d'étranglement de la saturation des benchmarks en convertissant des ensembles de données statiques et saturés en suites d'évaluation de niveau frontière et en signaux d'entraînement réutilisables. La signification centrale réside dans la conception centrée sur la solution, qui ancre la génération de tâches dans une sémantique exécutable, garantissant que la difficulté est une propriété du calcul plutôt que de la complexité de surface.

Les auteurs soutiennent que cette approche permet un mécanisme d'auto-amélioration en boucle fermée : les modèles peuvent utiliser le calcul au moment de l'inférence pour découvrir leurs propres faiblesses, convertir ces échecs en environnements d'entraînement vérifiés et s'améliorer via le RL. Cela dépasse la vision traditionnelle des benchmarks comme des artefacts statiques qui finissent inévitablement par saturer, proposant plutôt un paradigatisme de « benchmark vivant » où l'évaluation et les ensembles d'entraînement co-évoluent avec les capacités des modèles. Les résultats suggèrent que les tâches évoluées ne sont pas seulement des éléments d'évaluation plus difficiles, mais fournissent des signaux d'entraînement exploitables qui aident les modèles à s'améliorer sur des régimes de codage difficiles dépassant leur distribution d'entraînement originale.