Les IA de codage ont tendance à souffrir de l'effet Dunning-Kruger

De nouvelles recherches montrent que les IA de programmation comme ChatGPT souffrent de l'effet Dunning-Kruger, se montrant souvent plus confiantes alors qu'elles sont moins compétentes. Lorsqu'elles abordent des langages de programmation inconnus ou obscurs, elles affirment une grande certitude même si leurs réponses sont incomplètes. L'étude établit un lien entre l'excès de confiance des modèles et les faibles performances et le manque de données d'entraînement, ce qui soulève de nouvelles questions quant à la connaissance réelle de ces systèmes. ne voulez pas Savoir.

Quiconque a passé même un temps modéré à interagir avec de grands modèles de langage sur des questions factuelles saura déjà que les LLM sont souvent disposés à donner une assurément dans l'erreur réponse à une requête d'un utilisateur.

Parallèlement à des formes plus manifestes de hallucinationLa raison de cette vantardise creuse n'est pas totalement claire. Des recherches publiées cet été suggèrent que les modèles donnent des réponses confiantes. même quand ils savent qu'ils ont tort, par exemple ; bien que d’autres théories attribuent un excès de confiance à choix architecturaux, entre autres possibilités.

Ce dont l'utilisateur final peut être certain, c'est que l'expérience est incroyablement frustrante, car nous sommes programmés pour avoir confiance en peopleâ € ™ s estimations de leurs propres capacités (notamment parce que dans de tels cas, il y a des conséquences, juridiques et autres, pour une personne qui promet trop et ne tient pas ses promesses) ; et une sorte de transfert anthropomorphique signifie que nous avons tendance à reproduire ce comportement avec des systèmes d'IA conversationnels.

Mais un LLM est une entité irresponsable qui peut et va effectivement renvoyer un « Oups ! Des doigts de beurre… » après avoir aidé l'utilisateur à détruire par inadvertance quelque chose d'important, ou au moins perdre un après-midi de leur temps ; en supposant que cela se produira admettre sa responsabilité.

Pire encore, ce manque de circonspection prudente semble impossible à dissiper, du moins dans ChatGPT, qui rassurera largement l'utilisateur sur la validité de ses conseils et n'expliquera les failles de sa réflexion qu'une fois le mal fait. Ni la mise à jour du système mémoire persistante, ni l’utilisation d’invites répétitives ne semblent avoir beaucoup d’impact sur le problème.

On peut aussi être obstiné et se leurrer – même si quiconque commettant des erreurs aussi graves et fréquentes serait probablement licencié prématurément. Ces personnes souffrent du contraire du « syndrome de l'imposteur » (où un employé craint d'avoir été promu au-dessus de ses capacités) : L'effet Dunning Kruger, où une personne est significativement surestime leur 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 les performances efficaces des architectures de codage assistées par l'IA (telles que celle de Redmond) Copilote), dans un effort de recherche qui est le premier à aborder spécifiquement ce sous-secteur des LLM.

L'étude analyse la confiance que ces IA, qui codent, accordent à leurs propres réponses par rapport à leurs performances réelles, dans des dizaines de langages de programmation. Les résultats révèlent une tendance claire, similaire à celle observée chez les humains : lorsque les modèles étaient les moins performants, ils étaient les plus sûrs d'eux.

L'effet était le plus fort dans les langues obscures ou à faibles ressources, où les données d'apprentissage étaient minces : plus le modèle était faible ou plus la langue était rare, plus l' illusion de compétence :

Performances réelles et perçues de GPT-4o dans tous les langages de programmation, classées par performances réelles. Source : https://arxiv.org/pdf/2510.05457

Les quatre auteurs, tous contributeurs égaux travaillant pour Microsoft, soutiennent que le travail soulève de nouvelles questions sur la mesure dans laquelle ces outils peuvent être fiables pour juger de leur propre production, et ils déclarent :

« En analysant la confiance et les performances des modèles dans un ensemble diversifié de langages de programmation, nous révélons que les modèles d'IA reflètent les modèles humains de surconfiance, en particulier dans des domaines inconnus ou à faibles ressources.

Nos expériences démontrent que les modèles les moins performants et ceux fonctionnant dans des langages de programmation rares présentent un biais de type DKE plus prononcé, ce qui suggère que l'intensité du biais est proportionnelle à la compétence des modèles. Cela concorde avec les résultats des expériences humaines concernant ce biais.

Les chercheurs contextualisent cette ligne d’étude comme un moyen de comprendre comment la confiance du modèle devient peu fiable lorsque les performances sont faibles, et de tester si les systèmes d’IA affichent le même type de confiance excessive que celle observée chez les humains – avec des implications en aval pour la confiance et le déploiement pratique.

Bien que le nouveau papier défie La loi des gros titres de Betteridge, il est néanmoins intitulé Les modèles de code souffrent-ils de l’effet Dunning-Kruger ?. Bien que les auteurs déclarent que le code a été publié pour le travail, la préimpression actuelle ne contient aucun détail à ce sujet.

Méthode

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

Domaines de langage 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 ont été chargés de choisir la bonne option, puis d'estimer leur niveau de confiance dans leur choix, leur performance réelle étant mesurée par la fréquence à laquelle ils obtenaient la bonne réponse - et leur confiance auto-évaluée indiquant leur niveau de confiance. cru La comparaison de ces deux indicateurs a permis aux chercheurs de voir où la confiance et la compétence divergeaient.

Pour mesurer le degré de confiance des modèles, l’étude a utilisé deux méthodes : confiance absolue et confiance relativeDans le premier cas, le modèle devait attribuer un score de zéro à un à côté de chaque réponse, sa confiance pour une langue donnée étant définie par la moyenne de ces scores sur les questions dans cette langue.

La deuxième méthode a examiné le degré de confiance du modèle lorsque choisir entre deux questionsPour chaque paire, le modèle devait indiquer celle dont il était le plus sûr. Ces choix ont ensuite été notés à l'aide de systèmes de classement initialement conçus. pour les jeux de compétition, en traitant chaque question comme s'il s'agissait d'un joueur participant à un match. Les scores finaux ont été normalisés et moyennés pour chaque langue afin d'obtenir un score de confiance relatif.

Deux formes établies de l’effet Dunning-Kruger sont examinées dans l’article : l’une qui suit la façon dont un modèle unique évalue mal ses performances dans différents domaines ; et une autre qui compare les niveaux de confiance entre les modèles les plus faibles et les plus forts.

La première forme, appelée DKE intra-participant, examine si un modèle unique devient plus confiant dans les langues où ses performances sont faibles. Le deuxième, DKE inter-participants, demande si les modèles qui obtiennent des résultats globalement moins bons ont également tendance à s’évaluer eux-mêmes plus haut.

Dans les deux cas, l’écart entre la confiance et la performance réelle est utilisé pour mesurer l’excès de confiance, les écarts plus importants dans les environnements à faible performance indiquant un comportement de type DKE.

Résultats

L'étude teste l'effet Dunning-Kruger sur six grands modèles linguistiques : 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 disponibles au public. Ensemble de données CodeNet, avec 37 langues* représentées pour révéler comment la confiance et la précision varient selon les domaines de codage familiers et obscurs.

L'analyse inter-modèles montre un modèle clair de Dunning-Kruger :

Comparaison des performances réelles et perçues sur six modèles de code, montrant comment les modèles moins performants tels que Mistral et Phi-3 affichent une grande confiance malgré une faible précision, tandis que les modèles plus puissants tels que GPT-4o affichent un comportement plus calibré, voire peu confiant.

Les modèles présentant une précision moindre, notamment Mistral et Phi-3, avaient tendance à surestimer leurs propres capacités, tandis que les systèmes plus performants, comme GPT-4o, présentaient des niveaux de confiance qui correspondaient plus étroitement à leurs performances réelles, en particulier lorsqu’ils étaient jugés par une confiance relative.

Les résultats indiquent également que les modèles les plus performants peuvent parfois se sous-estimer (un modèle que les scores de confiance absolue ne parviennent pas à capturer).

Les résultats indiquent également que l'analyse intra-modèle confirme la présence de l'effet Dunning-Kruger. Le graphique des résultats présenté au début de l'article présente les performances de chaque modèle dans différents langages de programmation, classés par performance réelle.

Dans les langages où les modèles obtenaient de mauvais résultats, notamment les langages rares ou peu gourmands en ressources comme COBOL, Prolog et Ceylon, leur confiance était nettement supérieure à ce que leurs résultats justifiaient. Dans des langages connus comme Python et JavaScript, leur confiance correspondait davantage à leur précision réelle, et était même parfois inférieure.

Ce modèle est apparu 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.

Traiter les modèles comme des participants introduit certaines limites, car le petit nombre de modèles en jeu affecte la diversité ; les différences au sein des résultats d’un même modèle sont ignorées ; et la distribution des données peut ne pas refléter celle des participants humains réels.

Pour tenir compte de cela, l'étude a testé trois configurations alternatives : premièrement, chaque modèle s'est vu attribuer une personnalité distincte ; deuxièmement, les réponses ont été échantillonnées à un niveau plus élevé. la réactivité pour créer plus de variation ; troisièmement, les invites ont été paraphrasées plusieurs fois, chaque version étant traitée comme un participant distinct :

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

Le tableau des résultats ci-dessus indique à quel point l'effet Dunning-Kruger se manifeste dans ces conditions, restant présent dans tous les cas ; et que le DKE était plus prononcé lorsque plusieurs réponses étaient échantillonnées à partir du même modèle à haute température.

Pour mieux comprendre comment les performances perçues divergent des performances réelles, l'étude a comparé les estimations de confiance absolue et relative, en calculant dans quelle mesure chaque modèle surestimait sa propre capacité (plus précisément, la différence entre son score de confiance et sa précision réelle), puis en mesurant comment cette surestimation était liée aux performances réelles du modèle :

Corrélation entre l'excès de confiance (mesuré comme la confiance absolue moins la confiance relative) et la précision réelle dans les domaines de programmation et les types de modèles, montrant qu'une plus grande surestimation est systématiquement associée à des performances inférieures.

Le tableau des résultats ci-dessus illustre le lien entre la surestimation et les performances réelles, tant dans les domaines de programmation que dans les modèles. Dans les deux cas, on constate que les modèles moins précis tendent à afficher un excès de confiance plus important.

De plus, les modèles spécialisés entraîné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 les performances réelles pour les modèles spécialisés de base, à domaine unique et à domaines multiples, montrant des effets DKE plus forts à mesure que la spécialisation augmente.

Le Ensemble de données MultiPL-E dans huit langages de programmation, les auteurs ont constaté que la formation à domaine unique conduisait à une plus grande confiance excessive que les configurations multi-domaines ou de base, suggérant que Le DKE s'aggrave avec la spécialisation accrue.

Les tests ont également révélé que les modèles ont tendance à être plus confiants dans les langages de programmation rares. GitHub, IEEE et TIOBÉ classements, la rareté est fortement corrélée à une confiance perçue plus élevée, culminant à 0.797 :

Corrélation entre l'excès de confiance dans le modèle et la rareté d'une langue, à l'aide de trois classements de popularité. Les langues moins courantes sont associées à une meilleure performance perçue.

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 l'ensemble de données MultiPL-E dans les langages Ada, Dart, Prolog, Swift, C++, Python, C# et Elixir.

Bien que l’effet soit toujours présent, il était nettement plus faible que dans le cadre des questions à choix multiples, ce qui reflète probablement la plus grande difficulté à évaluer la confiance et l’exactitude dans les tâches ouvertes :

Corrélation entre la surestimation et les performances réelles dans la génération de code ouvert, basée sur les résultats MultiPL‑E dans huit langages de programmation.

En examinant l’explication encore controversé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 un élément crucial de l’acquisition d’une compétence.

Cette explication pourrait être testée expérimentalement dans des modèles d'IA, grâce à une étude contrôlée de différentes stratégies d'entraînement, afin de déterminer si elles conduisent toutes à des améliorations simultanées des performances et de la capacité à évaluer la qualité de ces dernières. Cependant, cette étude dépasse largement le cadre de cet article, et nous la réservons pour des travaux ultérieurs.

Conclusion

Même dans son domaine d'origine, l'effet Dunning-Kruger (comme le souligne l'article) peut être imputable à une cause statistique ou cognitive. S'il s'agit d'une cause statistique, l'application d'un syndrome jusqu'ici exclusivement humain au contexte de l'apprentissage automatique est tout à fait valable.

Bien que les auteurs émettent l’hypothèse que la cause pourrait être « cognitive » dans les deux cas, cela nécessiterait un point de vue légèrement plus métaphysique.

La découverte la plus intéressante de l’article est peut-être la mesure dans laquelle plusieurs LLM en codage ont tendance à redoubler d’efforts dans les circonstances les moins favorables, c’est-à-dire en faisant preuve d’une confiance maximale lorsqu’ils traitent des langues les plus rares ou les moins connues – ce qui serait une stratégie presque immédiatement contre-productive 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.

Première publication le mercredi 8 octobre 2025