🤖 AI

LSem2Vec: A Simple yet Effective Two-Stage Approach for Source Code Embedding

Cet article introduit LSem2Vec, un cadre à deux étapes simple mais efficace qui combine des modèles de langage de grande taille pour l'extraction sémantique avec des modèles d'encodage de phrases afin de générer des représentations de code source robustes sans nécessiter d'entraînement ou d'ajustement spécifique aux tâches coûteux, surpassant les méthodes non supervisées existantes sur plusieurs jeux de données.

Auteurs originaux : Zixiang Xian, Chenhui Cui, Rubing Huang, Chunrong Fang, Zhenyu Chen

Publié 2026-08-19

📖 6 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Zixiang Xian, Chenhui Cui, Rubing Huang, Chunrong Fang, Zhenyu Chen

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

Dans le vaste paysage du logiciel moderne, les lignes de code sont les briques et le mortier de notre monde numérique. Tout comme un urbaniste doit comprendre la disposition des rues et des bâtiments pour gérer une métropole, les ingénieurs logiciels doivent comprendre la structure et le sens du code pour maintenir, améliorer et sécuriser les systèmes qu'ils construisent. Un défi critique dans ce domaine est de reconnaître quand deux morceaux de code font essentiellement la même chose, même s'ils semblent différents en surface. C'est ce qu'on appelle la recherche de « clones », et cela aide les développeurs à éviter la redondance et à repérer les risques de sécurité. Pendant des années, les ordinateurs ont lutté contre cette tâche car ils se perdaient souvent dans le volume massif de texte ou ne parvenaient pas à saisir la logique sous-jacente lorsque la formulation changeait. Bien que des outils d'intelligence artificielle puissants aient récemment émergé, capables de lire et d'écrire du code, les utiliser pour comparer des milliers de fichiers s'est avéré difficile, coûteux et sujet aux erreurs, souvent parce que les outils sont submergés par la longueur du code ou donnent des réponses incorrectes lorsqu'on leur demande de porter des jugements complexes d'un seul coup.

Une équipe de chercheurs a maintenant introduit une nouvelle méthode appelée LSEM2VEC qui résout ces problèmes en changeant la façon dont l'ordinateur « lit » le code. Au lieu de demander à une intelligence artificielle massive de fixer deux longs fichiers et de décider s'ils sont similaires — une tâche qui mène souvent à la confusion ou aux erreurs — la nouvelle approche décompose le travail en deux étapes simples et gérables. Premièrement, le système utilise un grand modèle de langage pour agir comme un traducteur, lisant un fragment de code et écrivant une seule phrase claire qui résume ce que ce code fait. Cette étape élimine les détails déroutants et ne laisse que le sens profond. Ensuite, un second outil spécialisé prend cette phrase de résumé et la convertit en un point mathématique dans l'espace, appelé un « embedding ». En transformant le code en ces points, l'ordinateur peut facilement mesurer la distance entre eux pour voir à quel point ils sont similaires, sans jamais avoir besoin de relire les fichiers originaux et volumineux. Ce processus est comparable à un bibliothécaire qui écrirait d'abord une description d'une phrase pour chaque livre d'une immense bibliothèque, puis regrouperait les livres sur la base de ces descriptions, plutôt que d'essayer de lire chaque page de chaque livre pour trouver des correspondances.

Les chercheurs ont testé cette méthode sur trois ensembles différents de code écrit dans diverses langages de programmation, incluant le C et le Java, en utilisant plusieurs modèles d'intelligence artificielle différents pour s'assurer que les résultats étaient robustes. Ils ont comparé leur nouvelle approche à de nombreuses méthodes existantes, y compris celles qui nécessitent un entraînement intensif sur des données étiquetées ou celles qui tentent d'utiliser l'intelligence artificielle directement pour la comparaison. Les résultats ont été frappants : la nouvelle méthode a systématiquement surpassé les autres, trouvant des clones de code avec une précision bien plus élevée. Dans un test impliquant du code C, le système a atteint un score de précision de plus de 95 pour cent, battant nettement la deuxième meilleure méthode. Il s'est également avéré très efficace pour regrouper le code similaire, une tâche connue sous le nom de « clustering » (regroupement), où il a obtenu un score de 0,99 sur l'indice de Rand ajusté, dépassant même les méthodes qui avaient été entraînées avec une supervision humaine, lesquelles atteignaient un score de 0,90.

Un avantage clé de ce travail est qu'il ne nécessite pas le processus coûteux et chronophage d'entraînement de l'intelligence artificielle sur des jeux de données spécifiques. Les méthodes traditionnelles ont souvent besoin de milliers d'exemples de paires de code étiquetées par des humains pour apprendre à détecter les similitudes, ce qui est lent et coûteux. La nouvelle approche fonctionne immédiatement, utilisant les connaissances existantes des modèles d'intelligence artificielle sans entraînement supplémentaire. Elle résout également un obstacle technique majeur : la mémoire limitée de ces modèles. Les grands modèles de langage ne peuvent traiter qu'une certaine quantité de texte à la fois ; si le code est trop long, le modèle plante ou abandonne. En résumant d'abord le code, les chercheurs ont contourné cette limite, permettant au système de gérer des fichiers volumineux qui auraient été impossibles à analyser auparavant. De plus, la méthode est beaucoup plus efficace, nécessitant beaucoup moins d'appels aux modèles d'intelligence artificielle, ce qui permet d'économiser du temps et de l'argent.

L'étude a également exploré comment différents choix affectent le résultat, tels que l'utilisation de différents types de modèles d'intelligence artificielle ou la suppression des « mots vides » (stop words) des résumés. Ils ont découvert que, bien que les outils spécifiques importent, l'approche globale reste solide à travers différentes configurations. Par exemple, l'utilisation d'un modèle d'intelligence artificielle plus avancé pour rédiger les résumés a conduit à de meilleurs résultats, mais même les modèles standards ont performé exceptionnellement bien. Les chercheurs ont également visualisé les résultats, montrant que les points de code générés par leur méthode formaient des groupes serrés et clairs, alors que les autres méthodes produisaient des grappes désordonnées et chevauchantes. Cette clarté suggère que le système comprend réellement le sens du code plutôt que de simplement faire correspondre des motifs de surface.

En fin de compte, cette recherche offre une manière pratique et efficace de comprendre les vastes océans de code qui alimentent notre monde. En simplifiant la tâche complexe de la comparaison de code en un processus à deux étapes de résumé et de mesure, les chercheurs ont créé un outil qui est à la fois puissant et accessible. Cela démontre que nous n'avons pas toujours besoin de construire des modèles plus grands et plus complexes pour résoudre des problèmes difficiles ; parfois, une manière plus intelligente d'utiliser les outils que nous possédons déjà suffit pour voir la forêt derrière les arbres. Cette approche pourrait aider les ingénieurs logiciels à nettoyer leurs bases de code, à trouver des vulnérabilités de sécurité cachées et à organiser leurs projets plus efficacement, le tout sans le coût computationnel lourd qui a précédemment limité ces capacités.

Résumé technique de LSEM2VEC : Une approche d'embedding efficace pour la détection et le regroupement de clones de code

Énoncé du problème
L'intégration des grands modèles de langage (LLM) dans le génie logiciel (SE) a fait progresser des tâches telles que la détection et le regroupement de clones de code source. Cependant, les méthodes existantes pour générer des embeddings de code source font face à des limitations significatives. Les modèles pré-entraînés (PTM) traditionnels nécessitent souvent un entraînement supervisé intensif ou un ajustement fin (fine-tuning) sur des données spécifiques à la tâche, ce qui exige des ressources de calcul substantielles et des ensembles de données étiquetées. Bien que les LLM possèdent d'impressionnantes capacités d'apprentissage zero-shot, l'application directe des LLM aux tâches de SE présente deux défis critiques :

Réponses erronées : Les LLM produisent fréquemment des sorties incorrectes lorsqu'ils sont confrontés à un raisonnement complexe, comme déterminer si deux extraits de code sont des clones, en particulier lorsque le flux de travail implique de résumer une fonctionnalité puis de prendre une décision binaire.
Limitations de la longueur du contexte : Les LLM ont des fenêtres de contexte fixes. Le traitement de volumes importants de code source ou la comparaison de multiples paires de code simultanément dépasse souvent ces limites, entraînant des erreurs ou l'incapacité de traiter de longs fragments de code. De plus, la comparaison directe par paires utilisant les LLM entraîne une complexité temporelle quadratique ( $O(n^2)$ ) concernant les appels aux LLM, ce qui est inefficace et coûteux pour les grands ensembles de données.

Méthodologie : LSEM2VEC
Les auteurs proposent LSEM2VEC (LLM-extracted code Semantics to Vector embedding), une nouvelle approche sans entraînement qui génère des embeddings de code source en combinant les LLM avec des modèles d'embedding de phrases. Le cadre fonctionne via un pipeline en quatre étapes conçu pour atténuer les défis susmentionnés grâce à une stratégie de « interaction tardive » (late-interaction) :

Conception de prompts uniformes : Un modèle de prompt standardisé ordonne au LLM de lire un fragment de code source et de résumer succinctement sa fonction en une seule phrase, en interdisant explicitement tout texte explicatif. Cela garantit la compatibilité avec les modèles d'embedding de phrases, qui attendent des entrées de type phrase unique.
Résumés de code et stockage : Le LLM génère le résumé d'une phrase pour chaque fragment de code. Crucialement, le système n'extrait que la première phrase de la réponse pour assurer la cohérence et stocke ces résumés au format JSON. Cette étape découple l'extraction sémantique de la tâche en aval, permettant aux résumés d'être réutilisés sans interroger à nouveau le LLM.
Génération d'embeddings de code : Les résumés textuels stockés sont injectés dans un modèle d'embedding de phrase pré-entraîné (par exemple, MiniLM ou SBERT-CN) pour générer des représentations vectorielles de dimension fixe. Cette étape convertit les résumés en langage naturel en vecteurs sémantiques sans aucun entraînement ou ajustement fin supplémentaire.
Tâches en aval : Les embeddings résultants sont utilisés pour des tâches non supervisées. Pour la détection de clones de code, la similitude est calculée à l'aide de la similitude cosinus entre les paires de vecteurs. Pour le regroupement de code (clustering), la distance euclidienne est utilisée avec l'algorithme K-means.

Cette conception d'« interaction tardive » réduit la complexité computationnelle de la détection de clones de code de $O(n^2)$ (nécessitant un appel LLM pour chaque paire de code) à $O(n)$ (nécessitant un seul appel LLM par fragment de code), réduisant ainsi considérablement les coûts de jetons (tokens) et évitant le dépassement de la longueur du contexte.

Contributions clés
Le papier revendique les contributions suivantes :

Première intégration sans entraînement : Il s'agit du premier travail employant de grands modèles de langage et des modèles d'embedding de phrases pour générer des embeddings de code source sans nécessiter d'entraînement ou d'ajustement fin, en utilisant des ensembles de données non étiquetées.
Atténuation des limitations des LLM : Le pipeline proposé traite efficacement les réponses erronées des LLM et les contraintes de longueur de contexte en décomposant la tâche en étapes plus petites (résumé suivi de l'embedding) plutôt que de demander au LLM d'effectuer directement toute la tâche de raisonnement.
Flexibilité et scalabilité : L'approche est indépendante du LLM, permettant l'utilisation de n'importe quel LLM open-source ou propriétaire et de divers modèles d'embedding de phrases. Elle est adaptable à différents langages de programmation sans nécessiter de données d'entraînement spécifiques au langage.
Efficacité : En réduisant le nombre d'appels aux LLM et en exploitant des encodeurs de phrases pré-entraînés, la méthode offre une solution économiquement efficace par rapport aux modèles ajustés ou au prompting direct des LLM.

Résultats expérimentaux
Les auteurs ont évalué LSEM2VEC sur trois jeux de données (POJ-104, OJClone C, et BigCloneBench) couvrant les langages C et Java. L'évaluation s'est concentrée sur la détection de clones de code non supervisée et le regroupement de code en utilisant GPT-3.5, GLM3 et GLM4.

Détection de clones de code : LSEM2VEC a nettement surpassé les méthodes non supervisées de pointe, notamment SourcererCC, Code2vec, InferCode, TransformCode et LLM2Vec.
- Sur le jeu de données OJClone C, la meilleure configuration (GPT-3.5 + MiniLM-L12) a atteint un score F1 de 91,82 %, surpassant le modèle supervisé LLM2Vec (83,70 %) et les autres bases de référence non supervisées.
- Sur le jeu de données BigCloneBench, LSEM2VEC a atteint des scores F1 allant jusqu'à 85,83 % (en utilisant GPT-3.5 + MiniLM-L6), surpassant à nouveau le modèle supervisé LLM2Vec et les autres méthodes.
- L'étude a constaté que GPT-3.5 produisait généralement de meilleurs résultats que les modèles de la série GLM (GLM3 et GLM4), et que le choix du modèle d'embedding de phrase (par exemple, MiniLM-L12 vs L6) impactait la performance.
Regroupement de code (Clustering) : En utilisant l'indice de Rand ajusté (ARI) comme métrique, LSEM2VEC a démontré des capacités de regroupement supérieures.
- La configuration GPT-3.5 a obtenu un ARI de 0,97 (en utilisant MiniLM-L6) et de 0,91 (en utilisant MiniLM-L12), surpassant le modèle supervisé LLM2Vec (0,90) et toutes les autres bases de référence non supervisées.
- La visualisation via t-SNE a confirmé que les embeddings de LSEM2VEC produisaient des frontières de clusters bien définies et distinctes, particulièrement lors de l'utilisation de LLM plus avancés comme GPT-3.5 par rapport à GLM3.

Signification et revendications
Le papier positionne LSEM2VEC comme une alternative robuste et efficace aux stratégies d'embedding existantes. Sa principale importance réside dans la démonstration que des embeddings de code source de haute qualité peuvent être générés sans la surcharge computationnelle de l'ajustement fin ou la dépendance aux données étiquetées. En exploitant les capacités zero-shot des LLM pour l'extraction sémantique et les modèles de phrases pour la vectorisation, l'approche fournit une solution pratique pour les applications de génie logiciel réelles où les ressources sont limitées. Les auteurs concluent que cette méthode offre une nouvelle direction à la communauté pour explorer des représentations de code source avancées, pouvant potentiellement s'étendre à des tâches telles que la résumé de code, la détection de vulnérabilités et l'analyse de code binaire dans des travaux futurs.

Articles similaires