Résumé technique : ProxyWar : Évaluation dynamique de la génération de code par les LLM dans des arènes de jeux

1. Énoncé du problème

L'évaluation de la génération de code par les grands modèles de langage (LLM) a largement stagné derrière des benchmarks statiques et des métriques simplistes. Les approches actuelles, telles que HumanEval et MBPP, reposent fortement sur des métriques basées sur l'exécution comme le « pass@k » ou des scores de similarité textuelle (ex. : BLEU, CodeBLEU). Ces méthodes souffrent de plusieurs limitations critiques :

• Nature statique : Elles évaluent le code de manière isolée, échouant à capturer les contraintes d'exécution dynamiques, la stabilité au runtime et la robustesse sous des budgets de ressources partagés.
• Biais de simplicité : Les benchmarks consistent souvent en des fonctions autonomes avec un nombre limité de cas de test, ignorant la complexité du génie logiciel réel (ex. : dépendances, coordination multi-fichiers).
• Manque de contexte comparatif : Ils ne mesurent pas la manière dont le code se comporte face à des solutions alternatives dans des contextes compétitifs ou adverses, manquant ainsi les nuances de l'efficacité algorithmique et de la prise de décision stratégique.
• Dimensions négligées : Les métriques se concentrent presque exclusivement sur la justesse fonctionnelle, négligeant les caractéristiques opérationnelles telles que l'efficacité, la maintenabilité et l'adaptabilité aux cas limites.

Par conséquent, il existe un écart significatif entre les scores des benchmarks et la viabilité réelle du code généré par les LLM dans des scénarios dynamiques et réels.

2. Méthodologie : Le cadre ProxyWar

ProxyWar est un nouveau cadre conçu pour évaluer la génération de code par les LLM via une exécution compétitive et contrôlée au sein de divers environnements de jeu. Il orchestre un pipeline allant de la génération de code à l'évaluation compétitive, dépassant les tests binaires de type succès/échec pour une évaluation de performance holistique.

2.1 Architecture du système

Le cadre opère à travers cinq couches distinctes :

1. Couche d'environnement de jeu : Définit le jeu comme un tuple $G = \langle S, A, T, R, O, s_0 \rangle$, gérant les transitions d'état, les règles et les observations. Il supporte des scénarios à information parfaite et imparfaite.
2. Couche d'agent : Impose un contrat d'interface minimal ($\pi: O_{space} \times \{0, 1\}^{|A|} \to A$) que tous les agents générés doivent implémenter, garantissant une comparaison équitable sous des contraintes identiques.
3. Couche de génération de code : Transforme les spécifications en langage naturel en code d'agent exécutable. Elle inclut une Fonction de Réparation qui affine itérativement le code basé sur le feedback d'erreur, simulant les flux de travail de débogage du monde réel.
4. Couche de test : Valide les agents via une suite hiérarchique de tests couvrant la syntaxe, la conformité de l'interface, la fonctionnalité de base, la logique de jeu et la robustesse (cas limites). Les tests échoués déclenchent la boucle de réparation.
5. Couche de gestion de tournoi : Orchestre des tournois automatisés où les agents s'affrontent en tête-à-tête. Elle utilise des systèmes de classement TrueSkill pour calculer les rangs de compétence basés sur les résultats des matchs, fournissant une métrique de performance continue plutôt qu'un score binaire.

2.2 Méthodologie d'évaluation

ProxyWar emploie une stratégie d'évaluation multidimensionnelle :

• Performance compétitive : Utilise les classements TrueSkill pour classer les agents selon les résultats de victoires/défaites/nuls dans les tournois. Il rapporte des estimations de compétence conservatrices ($\mu - 3\sigma$) pour garantir la robustesse.
• Qualité statique du code : Mesure le Pass@1 (justesse initiale), le Taux de Réparation (capacité d'auto-correction) et la performance à travers les couches de tests hiérarchiques (Structure, Fonction, Logique, Robustesse).
• Caractéristiques opérationnelles : Suit les métriques d'exécution incluant la vitesse de décision (latence), les taux d'erreur (délais d'attente, exceptions) et les taux de participation.

2.3 Configuration expérimentale

Le cadre a été implémenté en Python et évalué sur 18 LLM de pointe (incluant des modèles à usage général, à raisonnement amélioré et spécialisés en code) et 10 environnements de jeu diversifiés. Ces environnements vont de puzzles solo (Sudoku, 2048) à des jeux de plateau pour deux joueurs (Tic-Tac-Toe, Reversi) et des jeux de cartes multijoueurs (Texas Hold'em). Chaque modèle a participé à plus de 10 000 matchs pour assurer la signification statistique.

3. Contributions clés

Le document présente quatre contributions principales :

1. Cadre ProxyWar : Le premier cadre d'évaluation compétitif basé sur l'exécution pour la génération de code par LLM qui intègre la génération automatisée, la réparation itérative et le classement par tournoi.
2. Évaluation multidimensionnelle : Une méthodologie qui capture les caractéristiques opérationnelles (efficacité, robustesse, adaptabilité) au-delà des métriques traditionnelles de succès/échec.
3. Plateforme évolutive : Une implémentation supportant divers environnements de jeu avec des niveaux de complexité et des structures d'information variés, permettant une évaluation systématique à travers différents paradigmes de programmation.
4. Évaluation empirique : Une étude exhaustive révélant des limitations auparavant cachées dans la génération de code par LLM, particulièrement concernant la créativité algorithmique, les stratégies d'optimisation et l'écart entre la justesse fonctionnelle et la déployabilité pratique.

4. Résultats clés et conclusions

L'évaluation empirique a produit plusieurs enseignements critiques :

• Pouvoir discriminatoire (RQ1) : ProxyWar révèle des écarts de performance substantiels invisibles pour les métriques statiques. Par exemple, bien que DeepSeek-R1 et Qwen2.5-Coder puissent avoir des scores Pass@k comparables, ProxyWar a montré une différence de taux de victoire en tournoi de près de trois fois (39,6 % contre 13,4 %). Des modèles avec des taux de participation de 100 % (passage parfait des tests) présentaient tout de même de larges variations de performance compétitive.
• Performance statique vs dynamique (RQ2) : Il existe une faible corrélation (Spearman $\rho = 0,23$) entre le Pass@1 et le classement compétitif.
  • Efficacité vs Sophistication : Dans le Sudoku, DeepSeek-R1 a généré un agent de backtracking minimaliste qui a surpassé l'approche heuristique plus complexe (MRV/LCV) de GPT-4.1. Le code de GPT-4.1 était théoriquement supérieur mais près de 28 fois plus lent en pratique à cause de l'overhead d'interprétation Python, menant à de moins bons résultats en tournoi.
  • Limites du débogage : Bien que certains modèles (ex. : Claude3.5-Sonnet) aient atteint un taux de réparation parfait, cela ne garantissait pas une forte performance en tournoi, indiquant les limites des capacités actuelles d'auto-correction.
• Sensibilité environnementale (RQ3) : La performance des modèles est hautement dépendante du contexte.
  • Complexité : Les écarts de performance s'élargissent considérablement à mesure que la complexité du jeu augmente (ex. : Reversi vs Tic-Tac-Toe).
  • Structure de l'information : Les jeux à information parfaite favorisent les capacités de recherche/planification, tandis que les jeux à information imparfaite (ex. : Poker) favorisent le raisonnement probabiliste. Aucun modèle unique n'excelle universellement à travers tous les types de jeux.
  • Spécialisation : Les modèles spécialisés en code sous-performent souvent dans des scénarios compétitifs riches en contexte par rapport aux modèles à usage général ou à raisonnement amélioré.

5. Signification et affirmations

Les auteurs positionnent ProxyWar comme une étape fondamentale vers une évaluation plus rigoureuse, reproductible et réaliste des systèmes de synthèse de programmes.

• Combler l'écart : Le cadre traite le décalage entre la performance des benchmarks et l'utilité pratique en évaluant le code sous des contraintes de ressources partagées et des conditions adverses.
• Au-delà de la justesse : Il souligne que le code « correct » est insuffisant ; les caractéristiques opérationnelles comme la latence, la stabilité et l'adaptabilité stratégique sont cruciales pour le déploiement réel.
• Recherche future : ProxyWar pose les bases de la recherche sur la découverte d'algorithmes pilotée par les LLM et la résolution de problèmes adaptative. Les auteurs suggèrent que les travaux futurs pourraient explorer si les codeurs LLM peuvent découvrir de nouvelles stratégies ou surpasser des agents conçus à la main dans des jeux complexes.
• Portée modeste : Le document reconnaît que les environnements de jeu, bien que diversifiés, peuvent ne pas capturer pleinement la complexité de toutes les tâches de génie logiciel du monde réel (ex. : développement collaboratif à grande échelle). Il considère la suite d'environnements actuelle comme un point de départ pour des benchmarks non-jeu plus larges.

En conclusion, ProxyWar démontre que l'évaluation compétitive basée sur le jeu fournit une différenciation fine des capacités des LLM, exposant les limitations opérationnelles que les benchmarks statiques ne parviennent pas à détecter.