Les IA de codage souffrent souvent de l’effet Dunning-Kruger

De nouvelles recherches montrent que les IA de codage, telles que ChatGPT, souffrent de l’effet Dunning-Kruger, agissant souvent avec la plus grande confiance lorsqu’elles sont les moins compétentes. Lorsqu’elles abordent des langages de programmation inconnus ou obscurs, elles affirment une grande certitude, même si leurs réponses s’effondrent. L’étude relie la surconfiance du modèle à la fois à de mauvaises performances et à un manque de données de formation, soulevant de nouvelles inquiétudes sur ce que ces systèmes savent vraiment sur ce qu’ils ne savent pas.

Quiconque a passé même une quantité modérée de temps à interagir avec des modèles de langage à grande échelle sur des questions factuelles sait déjà que les LLM sont souvent enclins à donner une réponse confidently wrong à une requête utilisateur.

Avec des formes plus ouvertes d’hallucination, la raison de cette vantardise vide n’est pas 100 % claire. Des recherches publiées au cours de l’été suggèrent que les modèles donnent des réponses confiantes même lorsqu’ils savent qu’ils ont tort, par exemple; bien que d’autres théories attribuent la surconfiance à des choix architecturaux, entre autres possibilités.

Ce que l’utilisateur final peut être certain, c’est que l’expérience est incroyablement frustrante, puisque nous sommes programmés pour avoir confiance dans les estimations des capacités des personnes (ne serait-ce que parce que, dans de tels cas, il y a des conséquences, juridiques et autres, à surestimer et sous-estimer); et une sorte de transfert anthropomorphique signifie que nous tendons à reproduire ce comportement avec les systèmes de conversation IA.

Mais un LLM est une entité non responsable qui peut et va effectivement retourner un ‘Whoops! Butterfingers…’ après avoir aidé l’utilisateur à inadvertamment détruire quelque chose d’important, ou au moins gaspiller un après-midi de leur temps; en supposant qu’il admettra la responsabilité.

Pire, ce manque de prudence semble impossible à éloigner, au moins dans ChatGPT, qui abondera en assurances à l’utilisateur de la validité de ses conseils, et n’expliquera les défauts de sa pensée qu’après que le mal soit fait. Ni la mise à jour de la mémoire persistante du système, ni l’utilisation de prompts répétitifs ne semblent avoir beaucoup d’impact sur le problème.

Les personnes peuvent être également obstinées et auto-trompeuses – bien que quiconque a commis une erreur aussi profonde et fréquente serait probablement licencié tôt. De tels individus souffrent du contraire du « syndrome de l’imposteur » (où un employé craint d’avoir été promu au-delà de ses capacités) – l’effet Dunning Kruger, où une personne surestime considérablement sa capacité à effectuer une tâche.

Le coût de l’inflation

Une nouvelle étude de Microsoft examine la valeur de l’effet Dunning-Kruger en ce qui concerne la performance effective des architectures de codage aidées par l’IA (telles que le Copilot de Redmond), dans un effort de recherche qui est le premier à s’attaquer spécifiquement à ce sous-secteur des LLM.

L’étude analyse comment les IA de codage évaluent avec confiance leurs propres réponses en leur posant des milliers de questions de programmation à choix multiples, avec chaque question appartenant à un domaine de langage spécifique, allant de Python et Java à Perl et COBOL:

Domaines de langages de programmation utilisés dans l’étude, ainsi que le nombre de questions de codage à choix multiples échantillonnées pour chaque domaine.

Les modèles étaient chargés de choisir l’option correcte, puis d’estimer à quel point ils étaient confiants dans leur choix, avec leur performance réelle mesurée par la fréquence à laquelle ils obtenaient la bonne réponse – et leur confiance auto-évaluée indiquant à quel point ils croyaient être bons. La comparaison de ces deux métriques a permis aux chercheurs de voir où la confiance et la compétence divergeaient.

Pour mesurer à quel point les modèles semblaient confiants, l’étude a utilisé deux méthodes: confiance absolue et confiance relative. Dans la première, le modèle devait donner un score allant de zéro à un pour chaque réponse, avec sa confiance pour un langage donné définie par la moyenne de ces scores pour les questions dans ce langage.

La deuxième méthode a examiné à quel point le modèle était confiant lorsqu’il choisissait entre deux questions; pour chaque paire, le modèle devait dire laquelle il se sentait plus sûr. Ces choix ont été notés à l’aide de systèmes de classement initialement conçus pour les jeux compétitifs, en traitant chaque question comme si elle était un joueur dans un match. Les scores finals ont été normalisés et moyennés pour chaque langage pour donner un score de confiance relatif.

Deux formes établies de l’effet Dunning-Kruger sont examinées dans le document: l’une qui suit comment un seul modèle surestime sa performance dans différents domaines; et une autre qui compare les niveaux de confiance entre les modèles plus faibles et plus forts.

La première forme, appelée effet DKE intra-participant, examine si un seul modèle devient plus surconfiant dans les langages où il se performs mal. La deuxième, effet DKE inter-participant, demande si les modèles qui se performs moins bien dans l’ensemble tendent également à se surestimer.

Dans les deux cas, l’écart entre la confiance et la performance réelle est utilisé pour mesurer la surconfiance, avec des écarts plus importants dans les paramètres de faible performance indiquant un comportement similaire à l’effet DKE.

Méthode

L’étude a testé comment les IA de codage pouvaient évaluer avec précision leurs propres réponses en leur posant des milliers de questions de programmation à choix multiples, avec chaque question appartenant à un domaine de langage spécifique, allant de Python et Java à Perl et COBOL:

Domaines de langages de programmation utilisés dans l’étude, ainsi que le nombre de questions de codage à choix multiples échantillonnées pour chaque domaine.

Les modèles étaient chargés de choisir l’option correcte, puis d’estimer à quel point ils étaient confiants dans leur choix, avec leur performance réelle mesurée par la fréquence à laquelle ils obtenaient la bonne réponse – et leur confiance auto-évaluée indiquant à quel point ils croyaient être bons. La comparaison de ces deux métriques a permis aux chercheurs de voir où la confiance et la compétence divergeaient.

Pour mesurer à quel point les modèles semblaient confiants, l’étude a utilisé deux méthodes: confiance absolue et confiance relative. Dans la première, le modèle devait donner un score allant de zéro à un pour chaque réponse, avec sa confiance pour un langage donné définie par la moyenne de ces scores pour les questions dans ce langage.

La deuxième méthode a examiné à quel point le modèle était confiant lorsqu’il choisissait entre deux questions; pour chaque paire, le modèle devait dire laquelle il se sentait plus sûr. Ces choix ont été notés à l’aide de systèmes de classement initialement conçus pour les jeux compétitifs, en traitant chaque question comme si elle était un joueur dans un match. Les scores finals ont été normalisés et moyennés pour chaque langage pour donner un score de confiance relatif.

Deux formes établies de l’effet Dunning-Kruger sont examinées dans le document: l’une qui suit comment un seul modèle surestime sa performance dans différents domaines; et une autre qui compare les niveaux de confiance entre les modèles plus faibles et plus forts.

La première forme, appelée effet DKE intra-participant, examine si un seul modèle devient plus surconfiant dans les langages où il se performs mal. La deuxième, effet DKE inter-participant, demande si les modèles qui se performs moins bien dans l’ensemble tendent également à se surestimer.

Dans les deux cas, l’écart entre la confiance et la performance réelle est utilisé pour mesurer la surconfiance, avec des écarts plus importants dans les paramètres de faible performance indiquant un comportement similaire à l’effet DKE.

Résultats

L’étude teste l’effet Dunning-Kruger sur six grands modèles de langage: Mistral; Phi-3; DeepSeek-Distill; Phi-4; GPT-0.1, et GPT-4o.

Chaque modèle a été testé sur des questions de programmation à choix multiples du jeu de données public CodeNet, avec 37 langages représentés pour révéler comment la confiance et la précision variaient à travers les domaines de codage familiers et obscurs.

L’analyse inter-modèle montre un modèle Dunning-Kruger clair:

Performance réelle par rapport à la performance perçue sur six modèles de code, montrant comment les modèles à faible performance tels que Mistral et Phi-3 affichent une confiance élevée malgré une précision faible, tandis que les modèles plus forts tels que GPT-4o montrent un comportement plus calibré ou même sous-confiant.

Les modèles avec une précision plus faible, y compris Mistral et Phi-3, tendaient à surestimer leurs propres capacités, tandis que les systèmes à plus haute performance, tels que GPT-4o, affichaient des niveaux de confiance qui correspondaient plus étroitement à leur performance réelle, en particulier lorsqu’ils étaient jugés par confiance relative.

Les résultats indiquent également que les modèles les plus capables peuvent parfois sous-estimer leurs propres capacités (un modèle que les scores de confiance absolue ne capturent pas).

Les résultats indiquent également que l’analyse intra-modèle soutient également la présence de l’effet Dunning-Kruger. Dans le graphique de résultats montré au début de l’article, nous voyons comment chaque modèle s’est performé à travers différents langages de programmation, classés par performance réelle.

Dans les langages où les modèles ont obtenu de mauvais résultats, en particulier dans les langages rares ou à faible ressource tels que COBOL, Prolog et Ceylon, leur confiance était nettement plus élevée que ce que justifiaient leurs résultats. Dans les langages bien connus tels que Python et JavaScript, leur confiance correspondait plus étroitement à leur précision réelle, et parfois même était inférieure à celle-ci.

Ce modèle est apparu à la fois dans les mesures de confiance absolue et relative, suggérant que les modèles sont moins conscients de leurs propres limites lorsqu’ils opèrent dans des domaines de codage inconnus.

En traitant les modèles comme des participants, certaines limites ont été introduites, car le petit nombre de modèles en jeu affecte la diversité; les différences au sein des sorties d’un seul modèle sont ignorées; et la distribution des données peut ne pas refléter celle de participants humains réels.

Pour tenir compte de cela, l’étude a testé trois configurations alternatives: premièrement, chaque modèle a reçu une personnalité distincte; deuxièmement, les réponses ont été échantillonnées à une température plus élevée pour créer plus de variations; troisièmement, les invites ont été paraphrasées plusieurs fois, avec chaque version traitée comme un participant distinct:

Corrélation entre la surconfiance et la performance réelle à travers différentes configurations expérimentales, montrant que le modèle Dunning-Kruger reste cohérent dans toutes les conditions et est le plus fort lorsque plusieurs réponses diverses sont échantillonnées à partir du même modèle.

Le tableau de résultats ci-dessus indique à quel point l’effet Dunning-Kruger se manifeste dans ces conditions, restant présent dans chaque cas; et que l’effet DKE est le plus prononcé lorsque plusieurs réponses sont échantillonnées à partir du même modèle à température élevée.

Pour mieux comprendre comment la performance perçue diverge de la performance réelle, l’étude a comparé les estimations de confiance absolue et relative, en calculant à quel point chaque modèle surestimait sa propre capacité (spécifiquement, la différence entre son score de confiance et sa précision réelle), puis en mesurant comment cette surestimation se rapportait à la performance réelle du modèle:

Corrélation entre la surconfiance (mesurée comme la confiance absolue moins la confiance relative) et la précision réelle à travers les domaines de programmation et les types de modèles, montrant que la surestimation est systématiquement associée à une performance plus faible.

Les résultats du tableau ci-dessus illustrent comment la surestimation se rapporte à la performance réelle, à la fois à travers les domaines de programmation et à travers les modèles. Dans les deux cas, on peut voir que les modèles avec une précision plus faible tendent à montrer une plus grande surconfiance.

De plus, les modèles spécialisés formés sur des domaines plus étroits ont montré des effets DKE plus forts que les modèles généralistes:

Corrélation entre la surestimation et la performance réelle pour les modèles de base, les modèles spécialisés à domaine unique et les modèles spécialisés à plusieurs domaines, montrant des effets DKE plus forts à mesure que la spécialisation augmente.

En utilisant le jeu de données MultiPL-E à travers huit langages de programmation, les auteurs ont constaté que la formation à un seul domaine conduisait à une plus grande surconfiance que les configurations de base ou multi-domaines, suggérant que l’effet DKE empire avec une spécialisation accrue.

Les tests ont également montré que les modèles tendent à être plus surconfiants dans les langages de programmation rares. À travers les classements GitHub, IEEE et TIOBE, la rareté est fortement corrélée avec une confiance perçue plus élevée, culminant à 0,797:

Corrélation entre la surconfiance du modèle et la rareté du langage, en utilisant trois classements de popularité. Les langages moins courants sont associés à une performance perçue plus élevée.

Enfin, les auteurs ont testé si l’effet Dunning-Kruger apparaît dans la génération de code, en évaluant les modèles sur le jeu de données MultiPL-E à travers les langages Ada, Dart, Prolog, Swift, C++, Python, C# et Elixir.

Bien que l’effet soit toujours présent, il est nettement plus faible que dans le paramètre des questions à choix multiples, reflétant probablement la plus grande difficulté à évaluer la confiance et la correction dans les tâches ouvertes:

Corrélation entre la surestimation et la performance réelle dans la génération de code ouvert, basée sur les résultats de MultiPL-E à travers huit langages de programmation.

En considérant l’explication encore disputée de l’effet Dunning-Kruger, les auteurs concluent:

‘Une explication potentielle qui peut être commune aux humains et aux modèles d’IA est l’explication métacognitive, qui stipule que l’évaluation de la qualité d’une performance d’une compétence est une partie cruciale de l’acquisition d’une compétence.

‘Cette explication peut potentiellement être testée expérimentalement dans les modèles d’IA avec une étude contrôlée de différentes stratégies de formation et si elles conduisent toutes à des améliorations simultanées de la performance et de la capacité à évaluer la qualité de la performance. Cependant, cette étude est significativement au-delà de la portée de ce document, et nous la laissons pour un travail futur.’

Conclusion

Même dans son domaine natif, l’effet Dunning-Kruger (comme le note le document) peut être attribué soit à une cause statistique, soit à une cause cognitive. Si c’est à une cause statistique, l’application d’un syndrome jusqu’alors uniquement humain à un contexte d’apprentissage automatique est en fait tout à fait valable.

Bien que les auteurs spéculent que la cause pourrait être trouvée pour être ‘cognitive’ dans les deux cas, cela nécessiterait un point de vue légèrement plus métaphysique.

Peut-être la découverte la plus intéressante dans le document est l’étendue à laquelle plusieurs LLM de codage ont tendance à doubler dans leurs circonstances les moins favorables, c’est-à-dire en affichant une confiance maximale lorsqu’ils traitent des langages les plus rares ou les moins connus – ce qui serait une stratégie presque immédiatement autodestructrice dans un environnement de travail réel.

* Les langages de programmation utilisés étaient Ada, Bash, C, C#, C++, COBOL, Ceylon, Clojure, D, Dart, Dash, Elixir, Erland, F#, Fortran, Go, Haskell, Java, JavaScript, Julia, Lisp, Kotlin, Lua, OCaml, Objective-C, PHP, Pascal, Perl, Prolog, Python, Racket, Ruby, Rust, Scala, Swift, TypeScript et Visual Basic.

Publié pour la première fois le mercredi 8 octobre 2025