💬 NLP

LLMSniffer: Detecting LLM-Generated Code via GraphCodeBERT and Supervised Contrastive Learning

Ce papier présente LLMSniffer, un cadre de détection qui combine le fine-tuning de GraphCodeBERT avec un apprentissage contrastif supervisé et un prétraitement de suppression de commentaires pour améliorer significativement la précision de la distinction entre le code généré par des LLMs et le code humain.

Auteurs originaux : Mahir Labib Dihan, Abir Muhtasim

Publié 2026-04-20

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Mahir Labib Dihan, Abir Muhtasim

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

🕵️‍♂️ LLMSniffer : Le Détective qui repère les codes écrits par des robots

Imaginez que vous êtes un professeur de programmation ou un chef d'équipe de développeurs. Soudain, vous vous demandez : "Est-ce que ce code a été écrit par un humain ou par une Intelligence Artificielle (IA) ?"

C'est un peu comme essayer de distinguer une peinture peinte à la main d'une image générée par un ordinateur. C'est de plus en plus difficile car les IA (comme ChatGPT ou GitHub Copilot) deviennent très douées pour imiter les humains.

C'est là qu'intervient LLMSniffer, un nouvel outil créé par des chercheurs de l'Université BUET au Bangladesh. Voici comment il fonctionne, expliqué avec des analogies simples.

1. Le Problème : Pourquoi est-ce difficile ?

Avant, on pouvait repérer un plagiat en cherchant des phrases copiées-collées. Mais aujourd'hui, les IA réécrivent tout. Elles ne copient pas, elles inventent. De plus, les IA ont tendance à écrire des commentaires (des notes dans le code) très verbeux et explicatifs, un peu comme un robot qui explique trop ce qu'il fait.

Les anciens détecteurs de texte (faits pour les articles de journaux) échouent souvent avec le code informatique, car le code a une structure très particulière, comme une partition de musique ou un plan d'architecture.

2. La Solution : Comment LLMSniffer fonctionne-t-il ?

L'équipe a construit un détective en trois étapes clés :

🗑️ Étape 1 : Enlever le "bruit" (Le nettoyage)

Imaginez que vous essayez de reconnaître la voix d'un chanteur, mais qu'il porte un masque et crie des phrases inutiles. C'est difficile.
Les IA ont souvent l'habitude d'ajouter beaucoup de commentaires explicatifs dans leur code.

L'astuce de LLMSniffer : Avant d'analyser le code, l'outil supprime tous les commentaires. Il ne regarde que la "musique" pure (le code lui-même), pas les notes du compositeur. Cela force le détective à se concentrer sur la structure logique du code, pas sur le style d'écriture.

🧠 Étape 2 : L'entraînement avec des "jumeaux" (L'apprentissage contrastif)

C'est la partie la plus intelligente. Imaginez un entraîneur de sport qui veut apprendre à un athlète à distinguer deux équipes.

Au lieu de simplement dire "C'est l'équipe A" ou "C'est l'équipe B", l'entraîneur montre des photos de joueurs de l'équipe A et dit : "Regardez, tous ces joueurs se ressemblent, ils doivent être très proches les uns des autres. Et ils doivent être très loin des joueurs de l'équipe B."
Techniquement, cela s'appelle l'apprentissage contrastif supervisé. LLMSniffer apprend à regrouper tous les codes humains ensemble et tous les codes IA ensemble, en créant un espace où les deux groupes sont bien séparés, comme deux îles distinctes dans l'océan.

🎯 Étape 3 : Le juge final (Le classifieur)

Une fois que le code est bien compris et trié, un petit "juge" (un classifieur) regarde la position du code dans cet espace et décide : "Humain" ou "IA".
Les chercheurs ont découvert que ce juge doit être un peu plus complexe qu'une simple ligne droite (un classifieur linéaire) pour bien comprendre les nuances. Ils ont utilisé un "réseau de neurones" un peu plus sophistiqué (un MLP) pour prendre la décision finale.

3. Les Résultats : Est-ce que ça marche ?

Les chercheurs ont testé leur détective sur deux grands examens (des bases de données de code) :

Sur le premier examen (GPTSniffer) : L'ancien meilleur détective avait un taux de réussite de 70%. LLMSniffer a grimpé à 78%. C'est une amélioration significative, un peu comme passer d'un élève moyen à un excellent élève.
Sur le deuxième examen (Whodunit) : Là, c'est encore plus impressionnant. L'ancien détective était bon à 91%. LLMSniffer atteint 94,65%.

La preuve visuelle :
Les chercheurs ont fait une carte (une visualisation) pour montrer comment le détective voit les choses.

Avec les anciens outils, les points "Humain" et "IA" étaient mélangés comme un plat de pâtes et de sauce : on ne voyait pas où s'arrêtaient les uns et où commençaient les autres.
Avec LLMSniffer, c'est comme si on avait séparé les pâtes et la sauce dans deux bols différents. C'est net, clair et facile à distinguer.

4. Pourquoi est-ce important ?

Pour les écoles : Les professeurs peuvent mieux savoir si un étudiant a triché en utilisant une IA pour faire ses devoirs.
Pour les entreprises : Si un bug apparaît dans le code, savoir s'il vient d'une IA ou d'un humain aide à comprendre la nature du problème.
Pour la sécurité : Parfois, les IA peuvent introduire des failles de sécurité sans le vouloir. Savoir qui (ou quoi) a écrit le code aide à auditer la sécurité.

⚠️ Une petite mise en garde (Éthique)

Les auteurs sont prudents. Ils disent que cet outil ne doit jamais être utilisé seul pour punir quelqu'un (comme un étudiant).

Pourquoi ? Parce que l'IA s'améliore tout le temps. Demain, elle pourrait écrire comme un humain, et l'outil pourrait se tromper.
Le conseil : LLMSniffer est un "détective" qui donne un indice, pas un juge final. Un humain doit toujours vérifier avant de prendre une décision importante.

En résumé

LLMSniffer est un détective de code qui :

Nettoie le code pour enlever les indices trompeurs (les commentaires).
Apprend à distinguer les humains des robots en les regroupant par "famille".
Décide avec une grande précision si le code est humain ou artificiel.

C'est un outil puissant, gratuit et accessible à tous, qui aide à naviguer dans le monde de plus en plus complexe de la programmation assistée par l'IA.

1. Problématique

L'émergence rapide des Modèles de Langage à Grande Échelle (LLM) capables de générer du code (comme GitHub Copilot, ChatGPT, Code Llama) pose un défi critique pour distinguer le code généré par l'IA du code écrit par des humains. Cette distinction est essentielle pour :

L'intégrité académique : Détecter la triche dans les évaluations de programmation.
La qualité du code : Assurer la traçabilité et la revue de code.
La sécurité : Identifier les patterns malveillants ou les vulnérabilités introduites par l'IA.

Les solutions existantes (comme GPTZero ou DetectGPT) sont souvent conçues pour le texte naturel et échouent face aux propriétés structurelles et syntaxiques uniques des langages de programmation. De plus, les méthodes précédentes de détection de code (comme GPTSniffer) utilisent des classificateurs binaires simples qui peinent à capturer les nuances structurelles profondes.

2. Méthodologie : LLMSniffer

L'approche proposée, LLMSniffer, est un cadre de détection qui combine un encodeur pré-entraîné avancé, une stratégie d'apprentissage contrastif supervisé et un prétraitement spécifique.

A. Prétraitement : Suppression des commentaires

Une décision de conception clé est la suppression des commentaires avant l'encodage. Les LLM ont tendance à produire des commentaires explicatifs verbeux qui reflètent leur "style d'écriture" plutôt que la structure algorithmique. En les retirant, le modèle est forcé d'apprendre à distinguer les sources basées sur les propriétés syntaxiques et structurelles du code, réduisant ainsi le risque de sur-apprentissage sur des indices stylistiques superficiels.

B. Architecture du Modèle

Le pipeline se compose de trois éléments principaux :

Encodeur GraphCodeBERT : Contrairement à CodeBERT standard, GraphCodeBERT intègre non seulement les tokens de code, mais aussi un graphe de flux de données (data-flow graph). Cela permet de capturer les dépendances sémantiques au niveau des variables (où une variable est calculée et où elle est utilisée).
Tête de projection (Projection Head) : Un MLP (Perceptron Multicouche) à deux couches qui projette la représentation du token [CLS] dans un espace de plus basse dimension pour l'apprentissage contrastif.
Tête de classification MLP : Un classificateur multicouche avec activation sigmoïde pour la prédiction binaire finale (Humain vs IA). Les auteurs montrent qu'un MLP performe mieux qu'un classificateur linéaire simple utilisé dans les travaux antérieurs.

C. Procédure d'Entraînement en Deux Étapes

L'entraînement suit une stratégie supervisée contrastive en deux phases :

Étape 1 : Pré-entraînement Contrastif Supervisé. Le modèle est affiné (fine-tuned) en utilisant la perte contrastive supervisée ( $L_{SupCon}$ ). Cette fonction de perte vise à rapprocher les représentations des échantillons de la même classe (compactage intra-classe) et à éloigner celles des classes différentes (séparation inter-classe) dans l'espace d'embedding.
Étape 2 : Affinage pour la Classification. La tête de projection est retirée et remplacée par la tête de classification MLP. Le modèle complet est ensuite affiné de bout en bout avec une perte d'entropie croisée binaire (Binary Cross-Entropy). Cette étape "réchauffe" l'encodeur pour produire des représentations discriminatives avant la classification finale.

3. Contributions Clés

Stratégie d'affinage contrastif : Introduction d'une approche à deux étapes combinant GraphCodeBERT et l'apprentissage contrastif supervisé pour la détection de code.
Prétraitement innovant : La suppression systématique des commentaires pour isoler les signatures structurelles du code.
Architecture améliorée : Démonstration qu'un classificateur MLP surpasse les classificateurs linéaires dans ce contexte spécifique.
Ressources ouvertes : Publication des checkpoints, des jeux de données, du code source et d'une démo interactive (Streamlit) pour assurer la reproductibilité.

4. Résultats Expérimentaux

Le modèle a été évalué sur deux jeux de données de référence : GPTSniffer (code ChatGPT multi-langages) et Whodunit (solutions Python GPT-4 pour CodeChef).

Sur GPTSniffer :
- L'exactitude (Accuracy) passe de 70 % (baseline) à 78 %.
- Le score F1 s'améliore de 68 % à 78 %.
- L'analyse d'ablation montre que l'ajout de la suppression des commentaires et du MLP est décisif ; l'apprentissage contrastif seul avec un classificateur linéaire n'apporte aucune amélioration.
Sur Whodunit :
- L'exactitude passe de 91 % à 94,65 %.
- Le score F1 atteint 94,64 %.
Visualisation (t-SNE) : Les visualisations des embeddings montrent que contrairement au modèle de base (où les clusters humain/IA sont fortement imbriqués), LLMSniffer produit des clusters compacts et bien séparés, expliquant géométriquement les gains de performance.

5. Signification et Impact

LLMSniffer établit un nouvel état de l'art (SOTA) pour la détection de code généré par LLM.

Preuve conceptuelle : Il démontre que l'intégration de la structure de flux de données (via GraphCodeBERT) et de l'apprentissage contrastif supervisé est supérieure aux approches basées uniquement sur la séquence de tokens.
Robustesse : La méthode est efficace même dans des évaluations inter-domaines (le jeu de test provient d'un domaine différent du jeu d'entraînement).
Limites et Avenir : Le modèle est limité à 512 tokens et pourrait nécessiter un réentraînement face à l'évolution rapide des LLM. Les auteurs prévoient d'explorer la détection multi-classe (identifier quel LLM spécifique a généré le code) et la robustesse aux attaques d'obfuscation.

En conclusion, LLMSniffer fournit un outil robuste et reproductible pour l'industrie et l'éducation, soulignant l'importance de se concentrer sur la structure du code plutôt que sur le style textuel pour détecter l'IA.