Conventional Commit Classification using Large Language Models and Prompt Engineering

Cet article démontre que les grands modèles de langage sans entraînement, en particulier DeepSeek-R1-32B utilisant l'inférence few-shot, peuvent classer efficacement les commits conventionnels à partir de diff de code, offrant ainsi une alternative pratique aux approches traditionnelles d'apprentissage automatique supervisé.

L'essentiel

Imaginez que vous êtes le gestionnaire d'une immense bibliothèque chaotique où des milliers de livres sont ajoutés chaque jour. Pour maintenir l'ordre, la bibliothèque impose une règle stricte : chaque nouveau livre doit porter une étiquette spécifique sur sa tranche (comme « Nouvelle Fonctionnalité », « Correction de Bug » ou « Documentation ») afin que des robots puissent les trier automatiquement, mettre à jour le catalogue et informer les visiteurs des nouveautés.

Cependant, dans la réalité, les personnes qui ajoutent les livres ignorent souvent les règles. Elles griffonnent des notes désordonnées comme « corrigé le truc » ou « modifié du code », rendant impossible pour les robots de déterminer à quelle catégorie appartient le livre.

Ce document traite de l'apprentissage d'un robot ultra-intelligent (une IA) à lire ces notes désordonnées et à déterminer l'étiquette correcte, sans avoir à passer des années à étudier des milliers d'exemples au préalable.

Le Problème : Notes Désordonnées vs Règles Stricte

Dans le développement logiciel, les programmeurs écrivent des « messages de commit » (des notes) à chaque fois qu'ils enregistrent des modifications dans leur code. L'industrie dispose d'un format standard appelé Conventional Commits qui agit comme un système de classement strict. Il exige que les notes commencent par une balise spécifique (par exemple, feat:, fix:).

Mais les humains sont désordonnés. Ils oublient souvent les balises. Traditionnellement, pour résoudre ce problème, les chercheurs construisaient un robot personnalisé en lui fournissant des milliers d'exemples étiquetés (comme un étudiant mémorisant un manuel). Cela prend beaucoup de temps et de données.

La Nouvelle Approche : La Stratégie du « Prompt »

Au lieu d'entraîner un nouveau robot à partir de zéro, les auteurs se sont demandé : Pouvons-nous simplement donner à une IA préexistante très intelligente un ensemble d'instructions (un « prompt ») pour accomplir la tâche ?

Ils ont traité l'IA comme un stagiaire brillant qui connaît déjà beaucoup de choses sur le langage mais doit savoir exactement quelle tâche accomplir. Ils ont testé trois méthodes différentes pour donner des instructions :

1. Zero-Shot (L'Approche « Dis-le-moi simplement ») :

   • L'Analogie : Vous vous approchez du stagiaire et dites : « Voici une note désordonnée. Veuillez me dire à quelle catégorie elle appartient selon les règles. » Vous ne donnez aucun exemple.
   • Résultat : Le stagiaire devine, mais se trompe souvent car il ne sait pas exactement ce que vous voulez.

2. Few-Shot (L'Approche « Montrez-moi des exemples ») :

   • L'Analogie : Vous dites : « Voici une note désordonnée qui signifie « Nouvelle Fonctionnalité ». Voici une autre qui signifie « Correction de Bug ». Maintenant, regardez cette nouvelle note désordonnée et dites-moi ce qu'elle est. » Vous montrez d'abord quelques exemples clairs au stagiaire.
   • Résultat : Cela a fonctionné le mieux. Le stagiaire a compris le modèle rapidement et a trié les livres avec précision.

3. Chain-of-Thought (L'Approche « Pense à voix haute ») :

   • L'Analogie : Vous dites : « Avant de me donner la réponse, veuillez écrire votre raisonnement étape par étape : « Je vois le mot « fix », donc je pense que c'est un bug... » »
   • Résultat : Étonnamment, cela n'a pas aidé. Pour cette tâche spécifique de tri d'étiquettes, obliger le stagiaire à « penser à voix haute » n'a fait qu'ajouter des étapes supplémentaires sans améliorer la réponse finale. C'était comme demander à un bibliothécaire de rédiger un essai avant de ranger un livre ; cela le ralentissait sans améliorer le résultat.

Les Concurrents : Quelle Taille Doit Avoir le Cerveau ?

Les chercheurs ont testé trois « stagiaires » (modèles d'IA) de tailles différentes :

• Mistral-7B : Un cerveau de taille moyenne (7 milliards de paramètres).
• LLaMA-3-8B : Un cerveau légèrement plus grand (8 milliards de paramètres).
• DeepSeek-R1-32B : Un cerveau géant (32 milliards de paramètres).

La Découverte : Le plus grand cerveau a gagné. Le DeepSeek-R1-32B était le plus précis pour lire les notes désordonnées et trouver la bonne étiquette. Cela suggère que pour ce type de tâche, disposer d'un modèle d'IA plus grand et plus puissant fait une réelle différence.

La Conclusion

L'article conclut que vous n'avez pas besoin de construire un modèle d'apprentissage automatique personnalisé à partir de zéro pour organiser des notes logicielles désordonnées. À la place, vous pouvez utiliser une IA puissante et préexistante et lui donner simplement quelques bons exemples (prompting Few-Shot) pour accomplir la tâche.

• Meilleure Stratégie : Montrer d'abord quelques exemples à l'IA.
• Meilleure IA : Le modèle le plus grand et le plus puissant disponible.
• Perte de Temps : Faire écrire à l'IA un long processus de raisonnement avant de répondre.

Cette approche économise du temps et des efforts car elle évite la nécessité de collecter et d'étiqueter des milliers d'exemples d'entraînement, permettant aux développeurs d'automatiser immédiatement l'organisation de leurs fichiers.

Résumé technique

Résumé Technique : Classification des Conventional Commits à l'aide de Modèles de Langage de Grande Taille et d'Ingénierie des Prompts

Énoncé du Problème

Les Conventional Commits fournissent un format structuré pour les messages de commit (par exemple, type: description), permettant l'utilisation d'outils d'automatisation tels que les générateurs de journaux des modifications et les systèmes de versionnement sémantique. Cependant, les développeurs écrivent fréquemment des messages non structurés, ce qui rend nécessaire une classification automatique pour restaurer cette structure. Les approches traditionnelles reposent sur des modèles d'apprentissage automatique (ML) et d'apprentissage profond (DL) entraînés sur de grands ensembles de données étiquetés. Ces méthodes nécessitent un prétraitement important des données, une ingénierie des caractéristiques et un réentraînement fréquent lorsque la terminologie du projet ou les taxonomies de classification évoluent. Cet article examine une alternative sans entraînement : l'utilisation de Modèles de Langage de Grande Taille (LLM) via l'ingénierie des prompts pour classer les messages de commit sans la surcharge de la curation de données d'entraînement étiquetées ou du fine-tuning des modèles.

Méthodologie

L'étude emploie un cadre sans entraînement où les LLM classent directement les changements de code sur la base de prompts, sans fine-tuning du modèle.

• Jeu de données : Un jeu de données équilibré de 3 200 commits a été extrait du dépôt open-source InfluxDB. Le jeu de données comprend les messages de commit et leurs diffs de code correspondants (changements). Les données sont approximativement équilibrées entre les types de commits (par exemple, feat, fix, docs, refactor, test, chore).
• Modèles évalués : Trois LLM open-source de différentes échelles de paramètres ont été testés :
  • Mistral-7B-Instruct (7 milliards de paramètres)
  • LLaMA-3-8B (8 milliards de paramètres)
  • DeepSeek-R1-32B (32 milliards de paramètres)
• Stratégies de prompting : Trois approches de prompting distinctes ont été évaluées :
  1. Zero-Shot : Le modèle reçoit des définitions de classes et des instructions, mais aucun exemple.
  2. Few-Shot : Le modèle reçoit des exemples étiquetés représentatifs de messages de commit et de diffs de code, accompagnés d'instructions.
  3. Chaîne de Pensée (CoT) : Le modèle est instruit de générer des étapes de raisonnement intermédiaires (identification des indices et leur mise en correspondance avec les types) avant de produire la classification finale.
• Évaluation : Les modèles ont été évalués à l'aide de métriques de classification standard : Précision, Rappel, F1-score et Exactitude. La vérité terrain a été dérivée des étiquettes existantes dans le dépôt InfluxDB.

Résultats Clés

L'évaluation empirique a produit les résultats suivants :

1. Performance des stratégies de prompting :

   • Le prompting Few-shot a constamment atteint la plus haute exactitude pour tous les modèles. Par exemple, DeepSeek-R1-32B a atteint une exactitude de 0,5749 avec le prompting Few-shot, contre 0,5652 (Zero-shot) et 0,5497 (CoT).
   • La Chaîne de Pensée (CoT) n'a pas apporté de gains supplémentaires pour cette tâche de classification spécifique. Dans plusieurs cas, la performance de la CoT était intermédiaire ou inférieure à celle du Few-shot, suggérant que la classification structurée repose davantage sur la reconnaissance de motifs que sur le raisonnement multi-étapes.
   • Le Zero-shot a généralement donné les performances les plus faibles ou proches des plus faibles, en particulier pour les modèles plus petits comme Mistral-7B-Instruct (exactitude de 0,3356).

2. Impact de l'échelle du modèle :

   • DeepSeek-R1-32B (32 milliards de paramètres) a démontré les performances globales les plus fortes sur toutes les métriques et stratégies de prompting, atteignant une exactitude moyenne de 0,563.
   • LLaMA-3-8B a enregistré les performances les plus faibles (exactitude moyenne de 0,372).
   • Mistral-7B-Instruct a montré des performances intermédiaires.
   • Les résultats suggèrent que l'échelle du modèle joue un rôle significatif dans la capacité à comprendre le contexte et à classer les changements de code avec précision.

3. Métriques agrégées :

   • Pour tous les modèles confondus, le prompting Few-shot a atteint la plus haute exactitude moyenne (0,531) et le meilleur F1-score (0,468).
   • Le prompting Zero-shot a atteint la plus haute précision moyenne (0,508) mais un rappel plus faible.

Contributions Principales

L'article expose trois contributions principales :

1. Nouvelle Approche : Il propose une approche sans entraînement pour la classification des Conventional Commits utilisant les LLM et l'ingénierie des prompts, s'opposant aux pipelines ML/DL traditionnels qui nécessitent des jeux de données étiquetés.
2. Évaluation Empirique : Il fournit une évaluation empirique complète de cette approche utilisant un large jeu de données (3 200 commits) et plusieurs modèles open-source de pointe.
3. Conseils Pratiques : Il discute de l'efficacité de la classification basée sur les prompts, identifiant que le prompting Few-shot est supérieur au Zero-shot et à la CoT pour cette tâche, et mettant en lumière les compromis au sein du cadre de l'ingénierie logicielle.

Importance et Affirmations

Les auteurs positionnent ce travail comme un guide pratique pour les chercheurs et les praticiens visant à automatiser la classification des commits sans le processus intensif en ressources de la curation de données et de l'entraînement de modèles.

• La Conception du Prompt est Critique : L'étude souligne que la conception du prompt impacte significativement les performances, dépassant souvent l'influence de l'architecture du modèle elle-même. Plus précisément, l'inclusion d'exemples clairs et diversifiés (Few-shot) agit comme un signal d'entraînement implicite.
• Limites du Raisonnement : L'article affirme modestement que, bien que la CoT soit efficace pour le raisonnement complexe, elle n'améliore pas nécessairement les performances pour les tâches de classification structurée comme le typage des commits, où la reconnaissance de motifs est primordiale.
• Portée de la Comparaison : Les auteurs déclarent explicitement ne pas viser à surpasser directement les bases de référence ML/DL traditionnelles. Au lieu de cela, l'étude se concentre sur l'analyse de la manière dont différentes conceptions de prompts influencent la classification basée sur les LLM. L'affirmation selon laquelle « les modèles plus grands fonctionnent mieux » est strictement relative aux LLM évalués et ne constitue pas une comparaison par rapport à des bases de référence supervisées externes.
• Directions Futures : L'article suggère que des travaux futurs pourraient inclure le test de la généralisation sur des dépôts plus diversifiés, l'application d'une optimisation automatisée des prompts, et l'exploration d'approches hybrides combinant les LLM avec des techniques ML traditionnelles. Il note également le potentiel d'appliquer ces résultats à la génération automatisée de notes de version et à la prédiction de bogues.