Examiner les LCGMs avec des tâches de programmation bilingues

Les grands modèles de génération de code (LCGMs) sont des outils puissants conçus pour aider avec les tâches de programmation. Ils ont montré un grand potentiel pour générer des extraits de code et assister les développeurs. Cependant, ces modèles apprennent principalement à partir d'exemples en anglais, ce qui soulève des inquiétudes sur leur performance avec des entrées non anglaises, surtout vu que de nombreux langages de programmation utilisent des termes anglais.

La plupart des tests disponibles pour ces modèles se concentrent sur des problèmes de programmation en anglais et utilisent un petit nombre de tests manuels pour vérifier la qualité du code. Cette pratique n'évalue pas correctement à quel point les LCGMs peuvent générer du code dans d'autres langues.

Cet article examine la performance des LCGMs lorsqu'on leur donne des tâches de programmation en anglais et en chinois. On se concentre sur les différences de qualité du code, surtout en termes d'Efficacité (si le code fonctionne correctement) et d'efficience (à quelle vitesse il s'exécute). On a choisi le chinois et l'anglais parce que ces deux langues contiennent beaucoup de contenu de programmation et des modèles existants qui les soutiennent.

Pour évaluer la performance des LCGMs avec des entrées Bilingues, on a rencontré plusieurs défis. Cela inclut un manque de jeux de données de programmation bilingues de haute qualité, pas assez de cas de test pour garantir que le code est correct, et des outils limités pour comparer comment bien le code généré s'exécute.

Pour résoudre ces problèmes, on a créé une suite de tests avec 52 questions de programmation bilingues et des outils automatisés pour générer des entrées pour les tests. On a aussi amélioré la façon de vérifier la correction en utilisant de plus grands cas de test et mesuré la rapidité d'exécution du code en fonction de différentes tailles d'entrée.

Avec ce cadre, on a étudié six LCGMs de premier plan. Nos résultats ont montré que le code généré par les LCGMs a une correction variable quand on utilise des entrées en anglais et en chinois. En moyenne, 10,5% des tâches ont montré ce problème, et 39,5% du code correct a affiché des différences de performance entre les deux langues. Nos résultats indiquent que ces modèles ne génèrent pas de manière cohérente du code de haute qualité pour différentes langues, pointant vers des domaines pour de futures recherches.

#Croissance des LCGMs

La croissance rapide des LCGMs a changé le paysage du développement logiciel, fournissant des solutions utiles pour de nombreux problèmes de programmation. Entraînés sur des ensembles de données massifs de code source, ces modèles peuvent créer des extraits de code fonctionnels, aider avec des tâches de programmation et automatiser des parties du développement logiciel.

Tout en soutenant plusieurs langues, une question essentielle se pose : à quel point les LCGMs performent-ils avec la génération de code dans des langues autres que l'anglais ? Cette préoccupation est cruciale car la plupart des modèles ont été formés sur du contenu en anglais, ce qui affecte leur performance lorsqu'on leur fournit des entrées dans d'autres langues.

De plus, de nombreux langages de programmation sont basés sur l'anglais. Par exemple, ils utilisent souvent des mots anglais comme mots-clés, ce qui rend encore plus difficile pour les LCGMs de comprendre les instructions dans d'autres langues. Les tests existants pour les LCGMs se concentrent principalement sur l'anglais et le nombre limité de cas de test n'évalue pas pleinement la qualité du code, notamment en termes d'efficacité et d'efficience.

Cet article vise à combler cette lacune en examinant la performance des LCGMs lorsqu'on leur donne des tâches de programmation dans plusieurs langues. Plus précisément, on va analyser leur efficacité et leur efficience en anglais et en chinois, qui sont tous deux largement utilisés en programmation.

#Questions de recherche

Pour étudier la performance des LCGMs dans la génération de code à partir de questions de programmation bilingues, on a voulu répondre aux questions suivantes :

1. Les codes générés par les LCGMs sont-ils également efficaces lorsqu'on utilise des questions de programmation bilingues ?
2. Les codes générés par les LCGMs sont-ils également efficients lorsqu'on utilise des questions de programmation bilingues ?
3. Quel est l'impact de la façon dont les invites sont données sur les différences de qualité entre les langues ?

#Cadre d'évaluation

Évaluer la qualité des LCGMs dans le traitement des entrées bilingues présente plusieurs défis. Tout d'abord, il y a un manque de bons ensembles de données de programmation bilingues. Les ensembles de données existants proposent généralement des tâches en anglais.

Ensuite, les quelques cas de test dans les benchmarks actuels peuvent ne pas garantir une vérification approfondie de la correction du code généré. Enfin, il existe des méthodes limitées disponibles pour mesurer et comparer l'efficacité du code généré, ce qui est vital pour déterminer leur qualité.

Pour surmonter ces défis, on a développé un nouveau cadre d'évaluation qui combine plusieurs étapes : sélection de questions de programmation appropriées, génération de code, vérification de la correction et estimation de la performance.

On a sélectionné un ensemble de problèmes de programmation à partir des ensembles de données existants, les traduisant en versions bilingues. On a aussi créé un outil pour générer automatiquement des échantillons d'entrées de différentes tailles pour chaque tâche. Ensuite, on a testé le code généré par les LCGMs pour voir à quel point ils étaient efficaces et efficients pour résoudre les problèmes.

En utilisant notre cadre d'évaluation, on a mené une étude détaillée sur six LCGMs différents.

#Collecte de données

Les benchmarks existants pour évaluer les LCGMs fournissent généralement un éventail de tâches de programmation pour vérifier la correction du code généré. Ces tâches consistent en des descriptions, des exemples d'entrée/sortie et des solutions correctes.

On a sélectionné des ensembles de données populaires comme HumanEval, MBPP et LeetCode comme notre liste initiale. On a filtré les tâches pour garantir qu'elles sont de difficulté modérée, qu'elles ont plusieurs solutions possibles et qu'elles fonctionnent avec des variables d'entrée qui peuvent changer de taille.

Après une sélection minutieuse, on a fini avec 52 questions de programmation couvrant divers types de problèmes, y compris la programmation dynamique et le traitement de chaînes. On a veillé à ce que les versions bilingues soient cohérentes dans leurs descriptions de tâches et leurs conventions linguistiques.

#Génération de code

Bien que les LCGMs puissent générer du code, extraire avec précision la sortie désirée de leurs réponses peut être délicat. Souvent, ces modèles peuvent continuer à générer du code non pertinent même après avoir terminé la fonction nécessaire. Cela pourrait entraîner des erreurs lorsque l'on essaie d'exécuter le code généré.

Pour résoudre ce problème, on a analysé le code en utilisant une méthode d'arbre de syntaxe abstraite (AST). Cela nous permet de nous concentrer uniquement sur les parties du code qui sont essentielles pour la fonction que l'on veut tester.

En gardant notre évaluation concentrée sur le code pertinent, on peut mieux évaluer sa correction et assurer des évaluations de haute qualité.

#Vérification de la correction

De nombreux benchmarks existants n'utilisent que quelques cas de test, ce qui peut être insuffisant pour valider correctement la fonctionnalité du code généré. Pour garantir que nous avons suffisamment de tests, on a généré automatiquement de plus grands cas de test basés sur notre ensemble de données.

On a utilisé les solutions canoniques pour créer des sorties de référence pour la vérification de la correction. En comparant les sorties du code généré à ces sorties de référence, on peut effectuer des tests plus approfondis.

Ce processus nous permet de voir à quel point les LCGMs performent dans différentes langues et nous aide à tirer des conclusions significatives sur leur efficacité.

#Estimation de la performance

Évaluer la performance d'exécution du code généré peut être un défi. Pour mesurer cela efficacement, on a collecté des données sur le temps d'exécution pour différentes tailles d'entrée.

Notre générateur d'entrées nous a permis de créer des entrées de test de différentes tailles pour le code que l'on évaluait. Au départ, on a fixé une taille d'entrée maximale basée sur la complexité de la tâche. Si le code généré prenait trop de temps à s'exécuter, on a ajusté la taille maximale et continué à tester.

En rassemblant un ensemble de "paires taille d'entrée-temps d'exécution", on a pu analyser et déterminer l'efficacité du code généré. Des temps d'exécution plus bas indiquent une meilleure performance.

#Métriques de mesure

Dans cette étude, on s'est concentré sur la mesure des différences de qualité du code des LCGMs lors de la génération de code pour des tâches bilingues. On a mesuré l'efficacité par la vérification de la correction et utilisé diverses métriques pour évaluer comment les modèles ont performé dans les deux langues.

On s'est concentré sur les métriques de correction, déterminant combien de tâches ont été résolues correctement dans chaque langue et si le code était correct dans les deux langues.

De plus, on a mesuré l'efficacité en fonction de la performance estimée du code généré dans les deux langues.

#LCGMs ciblés

On a sélectionné six LCGMs pour notre étude en fonction de leurs capacités avec l'anglais et le chinois, de leur performance dans les évaluations courantes, et de leur architecture variée. On a cherché à s'assurer que nos modèles choisis représentent l'état actuel de la technologie dans la génération de code.

Les LCGMs que l'on a choisis incluent CodeGen2.5, StarCoder, CodeGeeX, CodeLlama, DeepSeek-Coder et GPT-3.5-Turbo. Ces modèles varient en taille et en fonctionnalité, mais tous ont montré de bonnes performances dans des tâches de programmation.

#Résultats et analyse

Dans nos résultats, on a trouvé des différences significatives en termes d'efficacité et d'efficience au sein des LCGMs lors de la génération de code pour des questions de programmation bilingues.

#Efficacité

Pour analyser l'efficacité, on a regardé comment bien les modèles généraient du code correct en anglais et en chinois. Chaque LCGM a été exécuté plusieurs fois sur chaque question, et si une version produisait la sortie correcte, on la considérait comme réussie.

Nos résultats ont montré que la plupart des modèles performent mieux pour générer du code correct lorsque le réglage de température était augmenté, avec une tendance notable vers l'anglais. Cela indique que plus la température est élevée, plus les modèles sont susceptibles de générer du code correct en anglais plutôt qu'en chinois.

#Efficience

En termes d'efficience, on s'est concentré sur les questions de programmation que les LCGMs pouvaient résoudre correctement dans les deux langues. On a trouvé que pour de nombreuses questions, l'efficacité des codes générés variait largement entre les deux langues.

En moyenne, plus de 39% des questions correctement résolues ont montré des différences à cet égard. En modifiant la température, on a observé un changement d'avantages de performance des entrées chinoises vers les entrées anglaises.

#Impact du prompting

On a aussi examiné comment différentes méthodes de prompting influençaient l'efficacité et l'efficience du code généré. Par exemple, des invites basiques ont été testées contre des plus détaillées qui pouvaient améliorer la qualité de la sortie.

Nos résultats ont montré que des stratégies de prompting diverses pouvaient affecter les résultats de manière notable, notamment en ce qui concerne la manière dont les modèles généraient du code dans les deux langues.

#Discussions et suggestions

Les résultats de notre étude soulignent l'importance des méthodes d'évaluation approfondies pour les capacités multilingues des LCGMs. Étant donné les différences de performance observées, il y a clairement un besoin de recherches supplémentaires dans ce domaine.

De plus, nos résultats indiquent que l'efficacité et l'efficience ne sont pas les seuls facteurs à considérer. On suggère que de futures recherches se concentrent aussi sur des éléments importants comme la sécurité, la lisibilité et la maintenabilité du code généré.

En outre, développer de meilleures méthodes de prompting est crucial. Comme on l'a découvert, des invitations soigneusement construites impactent significativement la qualité du code généré. Examiner comment créer des invites efficaces pour différentes langues peut grandement améliorer la performance des LCGMs.

Enfin, identifier les réglages de température optimaux pour différentes langues pourrait encore améliorer les capacités des LCGMs à générer du code de haute qualité.

#Conclusion

En conclusion, notre enquête a montré que les LCGMs présentent des variations significatives en termes de qualité du code lors de la génération de réponses basées sur des questions de programmation bilingues. Les différences en termes d'efficacité et d'efficience suggèrent un besoin pressant d'études plus complètes et d'améliorations dans la génération de code multilingue.

En publiant notre ensemble de données et notre cadre d'évaluation, on espère encourager de futures recherches dans ce domaine essentiel. Le développement de benchmarks et de méthodes d'évaluation efficaces est vital pour comprendre et améliorer la performance des LCGMs dans des environnements multilingues.

Notre étude établit les bases pour une exploration future dans ce domaine, visant à améliorer les capacités des LCGMs et à fournir de meilleures ressources pour les développeurs travaillant avec des langues diverses.