Leveraging LLM-Based Agentic Systems to Generate Quantum Applications for Test Optimization

Résumé Technique : Exploiter les systèmes d'agents basés sur les LLM pour générer des applications quantiques destinées à l'optimisation de tests

Énoncé du problème
Bien que l'informatique quantique (QC) soit prometteuse pour optimiser les tâches de génie logiciel (SE) — spécifiquement les problèmes de génie logiciel basés sur la recherche (SBSE) comme l'optimisation de cas de test (TCO) — un obstacle important subsiste : traduire les exigences de niveau tâche en langage naturel (NL) en applications quantiques exécutables. Les approches actuelles nécessitent une expertise substantielle tant en mécanique quantique qu'en programmation pour gérer la formulation du problème, l'encodage, la sélection du solveur et l'orchestration. Les outils d'ingénierie de flux de travail quantiques existants (par exemple, QuantME, Q-READY) offrent des abstractions mais n'automatisent pas la génération de bout en bout d'applications quantiques exécutables à partir d'exigences en NL. De plus, bien que les grands modèles de langage (LLM) aient démontré un succès dans la génération isolée de code quantique ou la transformation QUBO, ils n'ont pas encore été appliqués efficacement à la génération de flux de travail d'applications quantiques complets et traçables pour les tâches d'optimisation de la SE.

Méthodologie : Architecture QPipe
Les auteurs proposent QPipe, une architecture multi-agents basée sur les LLM conçue pour convertir de manière autonome des exigences en NL en applications quantiques exécutables. Le système fonctionne via un pipeline structuré impliquant huit agents spécialisés, soutenus par une connaissance des tâches et des compétences de codage organisées, et interagissant avec un environnement d'outils locaux.

1. Agents de flux de travail :

   • Agent de parsing (Analyse syntaxique) : Extrait la tâche de SE, les objectifs, les contraintes et les données du projet à partir de l'exigence en NL.
   • Agent d'analyse : Détermine la pertinence quantique, identifie le noyau d'optimisation (par exemple, QUBO ou modèle d'Ising) et définit la répartition classique/quantique.
   • Agent de blueprint (Planification) : Crée un plan de flux de travail hybride, spécifiant la structure, le choix du solveur et les artefacts attendus.
   • Agent d'encodage : Cartographie l'instance complète du problème en sous-problèmes exécutables, gérant les contraintes de budget de qubits en décomposant les variables ou les instances si nécessaire.
   • Agent de génération de code (Codegen) : Génère des programmes Python candidats (utilisant Qiskit/Qiskit-Aer) basés sur le blueprint et l'encodage. Il opère dans une boucle, utilisant des outils pour les vérifications statiques, la compilation et l'exécution en bac à sable (sandbox) afin de réparer le code de manière itérative.
   • Agent de revue : Effectue une revue sémantique du code généré par rapport à l'exigence originale et aux artefacts intermédiaires avant l'exécution, demandant des réparations en cas d'incohérences ou de décalages d'objectifs.
   • Agent/Script de combinaison : Agrège les résultats des sous-problèmes décomposés. Il utilise des scripts déterministes pour les agrégations simples (par exemple, la somme) et un agent LLM pour les interprétations sémantiques complexes.
   • Agent de vérification : Valide l'application exécutée finale et les résultats par rapport au registre de génération et, lorsque cela est possible, par rapport à un solveur de référence classique.

2. Capacités de support :

   • Connaissance des tâches : Fournit des conseils sur la formulation (QUBO/Ising) et ancre le problème dans des entités de SE spécifiques (par exemple, les attributs des cas de test).
   • Compétence en codage : Impose des conventions d'implémentation, telles que l'utilisation d'API Qiskit spécifiques et l'évitement des fonctions vides (stubs) ou obsolètes.
   • Outillage : Les agents accèdent à des outils locaux pour l'inspection de l'environnement, le stockage du code, la vérification statique/compilation, l'exécution en bac à sable et la résolution de référence classique (par exemple, décomposition propre exacte ou énumération par force brute pour les petites instances).

Contributions clés

• Automatisation de bout en bout : QPipe est le premier système capable de générer de manière autonome des applications quantiques traçables et exécutables à partir d'exigences d'optimisation de SE en NL, couvrant l'intégralité du cycle de vie, de l'analyse syntaxique à la vérification.
• Décomposition multi-agents : L'architecture sépare les préoccupations en rôles spécialisés (analyse, planification, codage, revue), permettant des boucles de rétroaction ciblées et préservant la traçabilité à travers les artefacts intermédiaires.
• Stratégie d'exécution hybride : Le système gère dynamiquement les contraintes de ressources (par exemple, les limites de qubits) en décomposant les problèmes volumineux en sous-problèmes et en orchestrant leur exécution et leur agrégation.
• Cadre d'évaluation empirique : Les auteurs établissent un protocole d'évaluation rigoureux utilisant 20 exigences en NL à travers 10 benchmarks réels de TCO (Sélection et Minimisation de Cas de Test), mesurant le coût de génération, l'efficacité (pass@k) et la qualité de la solution par rapport à une base de référence d'Algorithme Génétique (GA).

Résultats expérimentaux
L'étude a évalué QPipe sur 20 exigences en NL associées à 10 benchmarks (incluant elevator_o2, gsdtsr et des programmes sujets GNU).

• Efficacité de la génération : QPipe a atteint un taux de réussite de compilation de 100 % et un taux de succès de 96,7 % pour l'exécution de l'application et la combinaison finale des résultats sur l'ensemble des exigences. Le coût moyen de génération était de 260,1 secondes et 1,89 million de tokens par exigence.
• Qualité de la solution : Parmi les applications générées avec succès, les solutions ont surpassé la base de référence de l'Algorithme Génétique (GA) dans la plupart des cas. Le ratio de réduction quantique (QRR) a montré des améliorations positives, avec des médianes de QRR de 57,6 pour la Sélection de Cas de Test (TCS) et de 89,1 pour la Minimisation de Cas de Test (TCM). Les scénarios les plus défavorables égalisaient ou dépassaient légèrement la base de référence GA.
• Modèles de flux de travail : L'analyse des exécutions réussies a révélé que les agents convergeaient de manière autonome vers des formulations QUBO et des algorithmes QAOA, malgré l'existence d'autres options algorithmiques proposées. Le système a systématiquement décomposé les tâches en 4 à 6 sous-problèmes et a maintenu la taille des circuits autour de 12 qubits pour équilibrer faisabilité et surcharge.
• Études d'ablation : La suppression de certains composants a considérablement dégradé les performances. La suppression des compétences de génération de code a provoqué l'échec le plus drastique (succès de compilation quasi nul). La suppression de la connaissance des tâches, du feedback de revue ou de la décomposition multi-agents a également réduit l'efficacité et la qualité des solutions, confirmant la nécessité de l'architecture complète.
• Comparaison des modèles de base (Backbone LLM) : L'utilisation de Claude comme modèle de base a produit les meilleures performances (100 % de compilation, 93,3 % d'exécution). DeepSeek a bien performé lors des premières étapes et de la compilation, mais a peiné lors des étapes ultérieures de revue et de vérification. Llama a totalement échoué à l'étape de génération de code, soulignant la sensibilité du flux de travail aux capacités de codage du modèle de base.

Signification et revendications
L'article affirme que la coordination agentique est une approche viable pour générer des applications quantiques exécutables pour des problèmes réels d'optimisation de tests. Les auteurs soutiennent que QPipe démontre que les systèmes multi-agents basés sur les LLM peuvent naviguer de manière autonome dans les complexités de l'ingénierie de flux de travail quantiques — gérant la formulation du problème, l'encodage et l'orchestration — sans nécessiter d'intervention manuelle à chaque étape.

La portée de ce travail réside dans la réduction de la barrière à l'entrée pour l'application de l'optimisation quantique aux tâches de SE. En automatisant la traduction des exigences en NL vers le code exécutable, QPipe permet potentiellement d'abaisser le seuil d'expertise requis pour que les praticiens de la SE puissent exploiter l'informatique quantique. Les auteurs concluent modestement que, bien que le flux de travail actuel soit coûteux en termes de tokens et de temps, il produit avec succès des solutions de haute qualité qui surpassent souvent les bases de référence classiques, suggérant une voie vers un génie logiciel assisté par le quantique plus accessible. Ils notent que des études empiriques plus larges sont nécessaires pour généraliser ces résultats à d'autres tâches de SE et autres backends quantiques.