Error Understanding in Program Code With LLM-DL for Multi-label Classification

1. Problématique

L'apprentissage de la programmation et le génie logiciel (SE) font face à un défi majeur : l'identification et la résolution des erreurs de code, en particulier les erreurs logiques. Contrairement aux erreurs de syntaxe détectées par les compilateurs traditionnels, les erreurs logiques permettent au code de compiler et de s'exécuter, mais produisent des résultats incorrects.

Le problème central abordé par cette étude est la classification multi-étiquettes (Multi-Label Classification - MLC) des erreurs dans le code source. Un même extrait de code peut contenir plusieurs types d'erreurs simultanés et interdépendants (par exemple, une erreur dans une boucle, une mauvaise utilisation d'un opérateur de comparaison et une erreur d'importation). Les approches existantes, souvent basées sur des règles ou des modèles à étiquette unique, peinent à capturer ces complexités sémantiques et structurelles. Bien que les Grands Modèles de Langage (LLM) excellent dans la génération et la compréhension du code, leur intégration systématique avec des architectures d'apprentissage profond (Deep Learning - DL) pour la classification multi-étiquettes spécifique aux erreurs de programmation reste sous-exploitée.

2. Méthodologie

Les auteurs proposent un cadre hybride LLM-DL (Large Language Model - Deep Learning) conçu pour capturer à la fois les représentations sémantiques globales et les dépendances séquentielles locales du code.

Architecture Hybride

Le modèle fonctionne en trois étapes principales :

1. Encodage par LLM (Pré-entraînement) : Le code source est tokenisé et passé à travers un encodeur LLM pré-entraîné spécialisé dans le code. Les modèles évalués incluent :
   • CodeT5, CodeT5+, GraphCodeBERT, UniXcoder, RoBERTa, PLBART, CoTexT.
   • Ces encodeurs transforment le code en vecteurs d'embeddings contextuels riches.
2. Modélisation Séquentielle (Décodeur DL) : Les embeddings extraits sont ensuite traités par des couches de réseaux de neurones récurrents (RNN) pour capturer les dépendances temporelles et structurelles entre les tokens. Les architectures testées sont :
   • GRU (Gated Recurrent Unit)
   • LSTM (Long Short-Term Memory)
   • BiLSTM (Bidirectional LSTM)
   • BiLSTM avec mécanisme d'attention additive (BiLSTM-A)
3. Classification : Une couche entièrement connectée (Fully Connected) suivie d'une activation sigmoïde mappe les caractéristiques apprises vers un vecteur de probabilités pour chaque type d'erreur possible.

Données et Optimisation

• Dataset : Utilisation d'un ensemble de données réel provenant du système Aizu Online Judge (AOJ), comprenant 95 631 paires de code (solution erronée vs solution acceptée) issues de cours d'introduction à la programmation en Python. Les erreurs ont été regroupées en 11 catégories d'erreurs résumées (ex: boucle, condition, opérateur, import, etc.).
• Optimisation des Hyperparamètres : Une recherche systématique a été menée sur 32 variantes de modèles (8 LLM × 4 architectures DL) en utilisant le framework Optuna (algorithme TPE - Tree-structured Parzen Estimator). Les paramètres optimisés incluent le taux d'apprentissage, la taille de la couche cachée, le dropout, la taille du lot (batch size) et le poids de régularisation (weight decay).

3. Contributions Clés

1. Architecture Unifiée : Introduction de la première exploration systématique combinant des encodeurs LLM basés sur les Transformers avec des décodeurs RNN pour la compréhension des erreurs de code en contexte multi-étiquettes.
2. Cadre d'Évaluation Rigoureux : Évaluation exhaustive utilisant une suite complète de métriques multi-étiquettes, notamment :
   • Précision, Rappel et F1-score (Macro et Pondéré).
   • Exact Match Accuracy (EMAcc) et Average Accuracy (AvgAcc).
   • Hamming Loss, Jaccard Similarity, One-Error et ROC-AUC (Micro, Macro, Pondéré).
3. Analyse Comparative Approfondie : Comparaison de 32 configurations pour identifier les synergies optimales entre les encodeurs sémantiques et les décodeurs séquentiels, démontrant l'importance de l'ajustement fin des hyperparamètres.

4. Résultats Expérimentaux

Les résultats démontrent que l'intégration LLM-DL surpasse significativement les modèles utilisant uniquement l'un ou l'autre composant.

• Meilleur Modèle : La combinaison CodeT5+ avec GRU a obtenu les performances les plus élevées sur l'ensemble des métriques.
  • F1-score pondéré (F1ψ) : 0,8243 (le meilleur score).
  • Précision moyenne (AvgAcc) : 91,84 %.
  • Exact Match Accuracy (EMAcc) : 53,78 %.
  • Hamming Loss : 0,0816 (très faible, indiquant peu d'erreurs d'étiquetage).
  • One-Error : 0,0708.
• Comparaison des Architectures :
  • Les modèles basés sur GRU ont généralement surpassé les variantes LSTM et BiLSTM, probablement en raison d'une meilleure efficacité de convergence et d'une capacité à éviter le surapprentissage (overfitting) lorsqu'ils sont couplés à des embeddings LLM riches.
  • Les modèles RoBERTa standards ont montré des performances instables, mais une variante avec un ajustement spécifique du taux d'apprentissage (RoBERTa LR) a considérablement amélioré les résultats.
  • L'ajout de mécanismes d'attention (BiLSTM-A) n'a pas systématiquement amélioré les performances par rapport aux GRU simples dans ce contexte.
• Amélioration Globale : Par rapport au pire modèle (RoBERTa LSTM, F1ψ = 0,1503), le modèle optimal (CodeT5+ GRU) représente une amélioration absolue d'environ 67,40 %.

5. Signification et Implications

Cette étude valide l'hypothèse que la combinaison de la compréhension sémantique profonde des LLM pré-entraînés avec la modélisation séquentielle des RNN est cruciale pour la classification des erreurs de code.

• Éducation Informatique (PE) : Le cadre proposé peut alimenter des systèmes de tutorat intelligents (ITS) capables de fournir un retour d'information automatisé, précis et multi-dimensionnel aux étudiants, allant au-delà de la simple détection de syntaxe.
• Génie Logiciel (SE) : Les résultats ouvrent la voie à des outils de revue de code automatisée, de localisation de défauts et de refactorisation capables de gérer des scénarios complexes où plusieurs bugs coexistent.
• Scalabilité : L'utilisation de décodeurs légers (comme GRU) couplés à des encodeurs puissants offre un compromis efficace entre performance et coût de calcul, facilitant le déploiement dans des environnements éducatifs ou industriels.

En conclusion, ce travail établit une nouvelle référence pour la compréhension des erreurs de code, démontrant que l'hybridation des architectures Transformer et RNN, optimisée par des techniques de réglage automatique, est la clé pour résoudre les problèmes complexes de classification multi-étiquettes en programmation.