AG — Alexey Gavrilov home

Inspectable Control for Structure-Preserving Software Regeneration

Contrôle inspectable pour la régénération de logiciels avec préservation de la structure

Régénération partielle et contrôlable de code au moyen de représentations latentes discrètes hiérarchiques.

Alexey Gavrilov1Alan-Barsag Gazzaev1Mikhail Mozikov2Ilya Makarov2Sergey Muravyov1

  1. ITMO University, Saint Petersburg, Russian Federation
  2. AXXX, Moscou, Fédération de Russie

Lire l’article intégral au format HTMLTexte interrogeable comprenant les formules, tableaux, figures et références.

Manuscrit définitif de l’auteur avec la liste finale des auteurs et le DOI. CC BY 4.0 author manuscript; the ACM DOI page remains the version of record. Conditions de publication et de réutilisation.

L’article en 30 secondes

Question de rechercheComment un modèle génératif peut-il modifier certaines parties d’un programme tout en préservant des éléments choisis de sa structure grossière ?

Problème

La modification de code assistée par l’IA exige souvent un changement circonscrit, tandis que certaines structures du programme doivent rester fixes. Régénérer le programme entier peut altérer des régions sans rapport avec la demande, et les contraintes au niveau des jetons n’offrent pas d’interface de contrôle grossière.

Approche

L’étude encode des fonctions Python de 64 jetons au moyen d’un VQ-VAE hiérarchique, verrouille certains codes discrets grossiers et recourt à la génération discrète masquée pour régénérer localement le code dans les positions latentes restantes.

Résultat principal

Le verrouillage de quatre codes de niveau supérieur fait passer le taux d’analyse syntaxique de 0,453 à 0,591, tandis que les positions non verrouillées changent encore à un taux de 0,936 et que la proportion d’échantillons conditionnels uniques demeure de 0,998.

Pourquoi est-ce important ?

Les résultats mettent en évidence un compromis stabilité–liberté mesurable pour l’édition contrôlable du code et la régénération partielle de programmes. Ils fournissent de premiers éléments en faveur d’une couche de contrôle latent inspectable, sans démontrer l’équivalence sémantique ni la correction fonctionnelle.

Résumé

Les processus de génie logiciel tels que la réparation sous contraintes, le raffinement par étapes et la modification avec préservation de la structure exigent de maîtriser ce qui change et ce qui demeure fixe. Pour ces opérations, la génération au niveau des jetons offre une interface de contrôle limitée : elle contraint la forme textuelle locale plutôt que les invariants structurels de haut niveau que le génie logiciel cherche souvent à préserver. Nous étudions les variables latentes discrètes hiérarchiques comme représentation intermédiaire inspectable des artefacts logiciels : un VQ-VAE hiérarchique compresse une fonction Python de 64 jetons en codes discrets de niveau supérieur et inférieur, et la génération discrète masquée ne régénère que certaines positions sous contraintes partielles. Sur 2 000 fonctions Python prétraitées, le verrouillage de quatre codes de niveau supérieur fait passer le taux d’analyse syntaxique de 0,453 à 0,591, tout en maintenant des changements substantiels aux positions non verrouillées (liberté de modification : 0,936) et une unicité des échantillons presque maximale (diversité : 0,998). À contexte de niveau supérieur fixe, le raffinement au niveau inférieur est moins marqué mais demeure monotone, ce qui étaye une lecture hiérarchique du général au détaillé. Dans l’ensemble, ces résultats apportent de premiers éléments en faveur d’une couche de contrôle pratique permettant, au-dessus du niveau des jetons, une régénération circonscrite d’artefacts logiciels avec préservation de la structure.

Publié dans Actes de la 34th ACM International Conference on the Foundations of Software Engineering

Type de contribution Méthode de contrôle dans l’espace latent

pp. 1406–1407Poster associé

DOI https://doi.org/10.1145/3803437.3807386

Partager cet articlePartager

Principaux résultats

Principaux résultats de Inspectable Control for Structure-Preserving Software Regeneration
ParamètreTaux d’analyse syntaxiqueSqueletteSignatureModification déverrouillée
Entrée (tronquée)0.9940.9940.994—
Reconstruction du codec0.8570.8480.4930
Génération non conditionnelle0.4530.0800.995
Conditionnel, préfixe k=40.5910.2950.0610.936
Conditionnel, empan de la signature0.60.3020.063non indiqué

Résultat principal. Le verrouillage des variables latentes grossières améliore la stabilité syntaxique sans supprimer les modifications dans la région éditable ; ce résultat atteste un contrôle structurel, et non une équivalence fonctionnelle garantie.

Jeu de données
2 000 fonctions Python prétraitées issues d’un sous-ensemble de CodeParrot Clean
Taille de l’échantillon
2 000 fonctions Python prétraitées ; l’unicité des échantillons conditionnels est de 0,998.
Métriques
Taux d’analyse syntaxique ; indicateurs indirects de préservation du squelette et des signatures ; taux de modification des positions déverrouillées ; unicité et entropie des échantillons
Incertitude
Cette étude de deux pages fournit des estimations ponctuelles, sans intervalles de confiance ni analyse statistique sur plusieurs graines aléatoires.
Conditions
Fonctions de 64 jetons, décodage par argmax, 16 codes de haut niveau et 32 codes de niveau inférieur ; le verrouillage intégral restitue exactement la reconstruction par le codec.

Télécharger les résultats :CSVJSONMarkdownMiroir externe :Fiche de jeu de données Hugging Face

PDF et citation

Citer cet article BibTeX est le format recommandé. Toutes les variantes ci-dessous sont produites à partir de la même notice de publication.

Ouvrir le PDF
@inproceedings{Gavrilov2026InspectableControl,
  title      = {Inspectable Control for Structure-Preserving Software Regeneration},
  author     = {Gavrilov, Alexey and Gazzaev, Alan-Barsag and Mozikov, Mikhail and Makarov, Ilya and Muravyov, Sergey},
  booktitle  = {Proceedings of the 34th ACM International Conference on the Foundations of Software Engineering},
  publisher  = {ACM},
  year       = {2026},
  pages      = {1406--1407},
  doi        = {10.1145/3803437.3807386},
  url        = {https://doi.org/10.1145/3803437.3807386},
  isbn       = {979-8-4007-2636-1},
}
Télécharger le fichier .bib

Fichiers de citation :Texte APATexte IEEERISCSL-JSONSchema.org JSON-LDXML OAI-DCXML OpenAIRE v4XML MODSMétadonnées XML JATS 1.4Texte intégral au format XML JATS 1.4RDF TurtleEnsemble de liens (JSON)Ensemble de liens (HTTP)RO-Crate

DOI :https://doi.org/10.1145/3803437.3807386

Guide complet

Guide de recherche complet

Méthode

La méthode compresse une courte fonction Python en deux niveaux de codes discrets, fige certaines positions grossières et régénère les positions restantes avant de les décoder de nouveau en code.

  1. Encoder

    Comprimer une fonction Python de 64 jetons en 16 codes de niveau supérieur et 32 codes de niveau inférieur au moyen d’un VQ-VAE hiérarchique.

  2. Verrouiller

    Choisir des positions de code grossières qui représentent la structure à préserver, par exemple un préfixe couvrant l’empan de la signature de fonction.

  3. Régénérer

    Exécuter la génération discrète masquée uniquement sur les positions déverrouillées, puis redécoder la hiérarchie complétée en code source.

  4. Examiner

    Avant d’accepter une régénération, mesurer le taux d’analyse syntaxique, les indicateurs indirects structurels, les changements aux positions déverrouillées et l’unicité des échantillons.

Certains codes grossiers du programme restent fixes, tandis que les codes discrets fins masqués sont régénérés puis décodés en une fonction Python modifiée.
La modification hiérarchique de codes latents discrets préserve certains éléments de la structure grossière du programme tout en régénérant les codes fins dans la région éditable.Source : Schéma explicatif créé par l’auteur à partir de la méthode et des résultats publiés..Conditions de réutilisation : CC BY 4.0.Attribution suggérée : Gavrilov et al. (2026), Inspectable Control for Structure-Preserving Software Regeneration. Télécharger le fichier SVG.

Idée centrale

Le contrôle s’applique à une représentation apprise située au-dessus des jetons : les positions latentes de niveau supérieur définissent explicitement les emplacements où la structure peut être figée, tandis que les détails d’implémentation voisins restent modifiables.

Différences par rapport aux approches apparentées

Les contraintes formulées dans la consigne ou appliquées au niveau des jetons portent sur la forme textuelle. L’interface proposée expose des points de contrôle discrets de niveau supérieur et inférieur, puis mesure le compromis entre stabilité et liberté qui en résulte.

Apport nouveau

Ce travail présente et évalue une couche hiérarchique de contrôle latent inspectable destinée à la régénération circonscrite d’artefacts logiciels.

Questions auxquelles cet article contribue à répondre

Ouvrez une question pour obtenir une réponse concise fondée sur l’article. Les frontières détaillées des éléments probants figurent dans la section Limites.

  1. Comment l’IA peut-elle modifier du code sans tout réécrire ?

    L’article étudie la régénération partielle du code au-dessus du niveau des jetons. Un VQ-VAE hiérarchique représente une courte fonction Python par des codes discrets de niveau supérieur et inférieur ; certaines positions de niveau supérieur sont verrouillées, et la génération discrète masquée ne modifie que les autres positions latentes avant le décodage. Cette approche établit une frontière de préservation explicite au lieu de régénérer la fonction entière.

  2. Quelles méthodes préservent la structure du programme lors de la génération de code ?

    Ce travail met à l’épreuve un contrôle latent discret hiérarchique. Les positions latentes grossières peuvent être fixées tandis que les positions déverrouillées sont régénérées ; le taux d’analyse syntaxique réussie et des indicateurs indirects de structure sont ensuite mesurés. Les résultats concernent la stabilité structurelle probabiliste de courtes fonctions Python ; ils n’établissent ni la préservation exacte de l’AST, ni l’équivalence sémantique, ni la correction fonctionnelle.

  3. Des variables latentes discrètes hiérarchiques peuvent-elles permettre un contrôle localisé du code ?

    Dans l’expérience présentée sur 2 000 fonctions, le verrouillage de quatre codes de niveau supérieur a porté le taux d’analyse syntaxique de 0.453 à 0.591. Parallèlement, 0.936 des positions non verrouillées ont changé et la proportion d’échantillons conditionnels uniques a atteint 0.998. Ces résultats constituent des indications préliminaires selon lesquelles des contraintes latentes grossières peuvent préserver une partie de la structure sans supprimer la liberté de modification locale ni la diversité des échantillons.

  4. Comment la génération de code peut-elle concilier stabilité structurelle et diversité ?

    L’article évalue conjointement la stabilité et la liberté, au lieu d’optimiser la seule validité. Le verrouillage des codes grossiers accroît la validité syntaxique, tandis que les modifications aux positions non verrouillées restent importantes et que les échantillons conditionnels demeurent presque tous uniques. Le résultat met en évidence un compromis stabilité–liberté mesurable dans la configuration testée, et non un optimum universel.

  5. Quel rapport ce travail entretient-il avec la modification de code assistée par les LLM ?

    Le modèle testé est un VQ-VAE hiérarchique doté d’une génération discrète masquée, et non un grand modèle de langage. La question du contrôle reste néanmoins pertinente pour l’édition assistée par LLM, car les modifications superflues hors de la région demandée constituent une difficulté pratique. L’article propose un mécanisme complémentaire dans l’espace latent et un cadre d’évaluation, non un banc d’essai de l’édition par LLM.

Comparaison avec les approches apparentées

Comparaison factuelle entre Inspectable Control for Structure-Preserving Software Regeneration et des approches voisines
CapacitéContrôle au niveau des jetonsContrôle latent hiérarchique
Figer la structure grossièreLimitéVerrouillage natif des codes grossiers
Régénération partielleContraintes de surface fragilesRééchantillonnage masqué des codes sélectionnés
Points de contrôle inspectablesAucune couche intermédiaire explicitePositions discrètes grossières et fines
Données probantes présentées dans cet articleNon évalué en tant que référence complèteDiagnostics de stabilité syntaxique et de liberté d’édition

Le tableau décrit les interfaces et les résultats mesurés dans l’étude ; il ne revendique ni correction fonctionnelle ni supériorité universelle.

Pertinence et périmètre

L’article intéresse tout particulièrement les travaux qui exigent un contrôle explicite de ce qu’une transformation de code assistée par IA peut modifier et des parties du programme qui doivent rester stables.

  1. Génération de code contrôlable avec préservation de la structure

  2. Réparation localisée de programmes et refactorisation circonscrite

  3. Représentations discrètes hiérarchiques du code source

  4. Génération discrète masquée de code source

  5. Contrôle latent des artefacts logiciels

Voir les limites et le périmètre des éléments probants

Limites

  • L’étude se limite à de courtes fonctions Python tronquées à 64 jetons.
  • L’évaluation repose sur un décodage par argmax et sur des indicateurs indirects syntaxiques ou structurels, plutôt que sur des tests d’équivalence fonctionnelle.
  • La préservation exacte des signatures demeure insuffisante.
  • Le contrôle de niveau inférieur est moins efficace que celui de niveau supérieur.
  • Les positions latentes ne sont pas encore alignées sur des régions sémantiques telles que les segments d’AST, les signatures ou la structure du flot de contrôle.
  • Les résultats n’établissent pas la correction de réparations, de refactorisations ou de modifications concrètes à l’échelle d’un dépôt.

Références citées dans l’article

Ces entrées correspondent à la section numérotée « References » du PDF de l’article.

  1. Ali Razavi, Aaron van den Oord, Oriol Vinyals. . Generating Diverse High-Fidelity Images with VQ-VAE-2. Advances in Neural Information Processing Systems.
  2. Jacob Austin, Daniel D. Johnson, Jonathan Ho, Daniel Tarlow, Rianne van den Berg. . Structured Denoising Diffusion Models in Discrete State-Spaces. Advances in Neural Information Processing Systems.
  3. Subham Sekhar Sahoo, Marianne Arriola, Yair Schiff, Aaron Gokaslan, Edgar Marroquin, Justin T Chiu, Alexander Rush, Volodymyr Kuleshov. . Simple and Effective Masked Diffusion Language Models. Advances in Neural Information Processing Systems.
  4. Shraddha Barke, Michael B. James, Nadia Polikarpova. . Grounded Copilot: How Programmers Interact with Code-Generating Models. Proceedings of the ACM on Programming Languages.
  5. Fengji Zhang, Bei Chen, Yue Zhang, Jacky Keung, Jin Liu, Daoguang Zan, Yi Mao, Jian-Guang Lou, Weizhu Chen. . RepoCoder: Repository-Level Code Completion Through Iterative Retrieval and Generation. Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing.

Ressources et reproductibilité

Éditeur
ACM
Ressources de la publication
Le manuscrit public, les tableaux de résultats, la figure explicative et les fichiers de citation sont disponibles ici. Le code d’implémentation et les points de contrôle ne sont pas rendus publics.

Déclaration relative aux données

Source
Un sous-ensemble prétraité de CodeParrot Clean comprenant 2 000 fonctions Python.
Licence
Ce site ne redistribue aucun fichier de jeu de données ; toute réutilisation demeure soumise aux licences du jeu de données CodeParrot en amont et du code source.
Prétraitement
Les fonctions Python sont segmentées en jetons, puis tronquées ou complétées jusqu’à 64 jetons avant l’encodage hiérarchique.
Répartition
Le poster fait état d’un ensemble d’évaluation de 2 000 fonctions ; l’article public ne fournit pas de manifeste immuable de la répartition entraînement/validation.
Format
Fonctions sources Python, séquences de jetons de type GPT, séquences de 16 codes de niveau supérieur et séquences de 32 codes de niveau inférieur.
Version / somme de contrôle
L’article de deux pages ne fournit ni somme de contrôle du jeu de données ni identifiant immuable de l’instantané.
Acquisition
Aucun script public d’acquisition n’est diffusé avec la page de la publication.
Limites d’utilisation
L’échantillon n’est représentatif ni des logiciels à l’échelle d’un dépôt, ni de plusieurs langages de programmation, ni des tâches de réparation dont le comportement a été vérifié.

Versions

  1. Version publiéeACM FSE Companion, 2026
  4. Ouvrir la notice dans l’entrepôtNotice Zenodo indexée par OpenAIRE
  6. Ressources de l’auteurPoster et diaporama
  7. Notice bibliographiqueDBLP
  8. Ouvrir la notice scientifiqueOpenAlex
  9. Notice du graphe de citationsSemantic Scholar
  10. Texte intégral diffusé par l’auteurResearchGate
  11. Résumé en langage clairKudos

Le DOI publié constitue l’identifiant bibliographique principal. Cette page demeure l’unique URL canonique du projet pour toutes les versions.

Consulter le guide consacré à Édition contrôlable de code pour approfondir.À propos de l’auteur.

Notes de recherche ciblées

Réponses adaptées à l’intention, assorties de limites probantes et de liens vers cet article.