Lost in The Latent Space: Understanding, Auditing, and Evaluating Machine Learning Models for Code

L’intégration croissante de modèles d’apprentissage automatique dans l’ingénierie logicielle transforme de façon significative les processus d’ingénierie logicielle. Alors que les premières applications de tels modèles se limitaient à des outils fondés sur des règles, ciblant des tâches spécifiques et interprétables, l’essor de l’apprentissage profond et des grands modèles de langage a conduit à des systèmes puissants mais opaques, désormais employés pour automatiser des étapes centrales du processus d’ingénierie logicielle. Ce passage d’un flux de travail compréhensible par l’humain et fondé sur des règles à des modèles de type boîte noire pilotés par les données a introduit des défis en matière de transparence, de fiabilité et d’auditabilité du processus d’ingénierie logicielle. Les pratiques traditionnelles telles que les tests unitaires, la relecture de code et l’analyse statique demeurent indispensables, mais elles ont été optimisées pour un développement déterministe, dirigé par des humains, avec des spécifications explicites et des justifications de conception traçables. À l’inverse, les modèles d’apprentissage automatique apprennent des représentations internes à partir des données et des objectifs, ce qui rend difficile l’interprétation, l’audit ou la garantie de leur comportement de la même manière. Il en résulte une lacune critique : à mesure que ces modèles sont de plus en plus déployés dans la chaîne d’ingénierie logicielle, l’absence de transparence et de garanties de confiance risque de miner la fiabilité, la sécurité et la confiance accordée au code généré. Cette thèse s’attaque à ces défis dans le contexte des modèles d’apprentissage automatique entraînés sur du code. Nous proposons trois cadres distincts, chacun conçu pour traiter un aspect précis de la fiabilité et de la confiance : l’apprentissage de représentations, l’audit des modèles et l’évaluation des modèles. Nous examinons d’abord ce que les modèles d’apprentissage automatique apprennent du code au cours de l’entraînement et la manière dont leurs représentations internes encodent des informations syntaxiques et sémantiques. Pour permettre une analyse systématique, nous introduisons DeepCodeProbe, un cadre d’inspection “probing” destiné à évaluer la structure et la qualité des représentations de code apprises. Ce travail apporte des éclairages sur la façon dont les représentations de code et la capacité des modèles influencent la rétention de caractéristiques de code essentielles, et il favorise une ingénierie des représentations et une conception de modèles plus interprétables et robustes. Nous abordons ensuite le besoin d’un audit transparent des grands modèles de langage (GML) entraînés sur du code, d’autant que les jeux de données d’entraînement croissent en taille et ne sont pas mis à disposition pour examen. Nous proposons TraWiC, un cadre permettant de détecter l’inclusion de jeux de données dans des GML entraînés sur du code, sans exiger l’accès ni aux jeux de données d’origine ni aux poids des modèles. Cette approche permet d’identifier d’éventuelles fuites de données, des violations de propriété intellectuelle et des phénomènes de mémorisation, contribuant ainsi à un développement et à un audit de modèles dignes de confiance. Enfin, nous répondons au besoin de cadres de référence pour l’étalonnage “benchmarking” fiables, extensibles et adaptatifs pour les GML de code. Les benchmarks statiques ne parviennent pas à saisir de façon précise les faiblesses ni l’évolution des capacités des GML, car ils se concentrent uniquement sur des signaux binaires de succès/échec sur des tâches sous-jacentes, et ils sont susceptibles d’être incorporés dans les jeux de données d’entraînement des GML, ce qui gonfle artificiellement les résultats. Les benchmarks dynamiques existants s’appuient souvent sur d’autres GML pour juger les performances du modèle évalué (“LLM-as-judge”), ce qui introduit des biais, ou manquent d’une structure fondée sur des principes pour l’évaluation des tâches, ce qui engendre une forte variance entre exécutions. En outre, ils cherchent à tester plusieurs capacités à la fois (par exemple, la résolution d’un ticket), ce qui masque comment le modèle tente de résoudre la tâche et dissimule ses faiblesses en regroupant plusieurs exigences de raisonnement. Nous proposons PrismBench, une méthodologie d’évaluation dynamique nouvelle pour un benchmarking complet et adaptatif des capacités de génération de code des GML, afin de pallier les limites des approches statiques et dynamiques actuelles. PrismBench permet des diagnostics plus fiables et plus fins et soutient le développement de modèles robustes et de haute assurance pour la génération de code en ingénierie logicielle. Ensemble, ces cadres constituent une chaîne permettant de sonder, auditer et soumettre à des tests de résistance systématiques les modèles d’apprentissage automatique destinés à l’ingénierie logicielle. Notre travail fournit à la fois des fondements théoriques et des outils pratiques pour comprendre ce que ces modèles apprennent, la manière dont leurs données d’entraînement peuvent être auditées, et comment leurs capacités et limites en conditions réelles peuvent être évaluées de façon rigoureuse. Ce faisant, il fait progresser l’état de l’art des modèles d’apprentissage automatique dignes de confiance pour l’ingénierie logicielle et propose des méthodes concrètes pour accroître la transparence et la fiabilité à mesure que ces systèmes deviennent partie intégrante du développement logiciel.

Abstract

The growing integration of Machine Learning models into Software Engineering is reshaping the development, testing, and maintenance of software systems. While early applications of such models were limited to rule-based tools targeting specific, interpretable tasks, the advent of Deep Learning and Large Language Models has led to powerful but black-box systems that are now being employed to automate core stages of the Software Engineering process. However, this shift from human-understandable, rule-driven workflows to black-box, datadriven models has introduced challenges regarding transparency, trustworthiness, and auditability of the Software Engineering workflow. In software development, code is expected to be explainable and accountable: the rationale and behavior of human-written code can be justified against explicit specifications, and quality-assurance practices such as unit testing, code review, and static analysis were developed to enable that accountability. Machine Learning models, by contrast, learn internal representations from data and objectives, making it difficult to interpret, audit, or guarantee their behavior in the same manner. This creates a critical gap: as these models are being increasingly deployed in the Software Engineering pipeline, a lack of transparency and trustworthiness risks undermining the reliability, security, and trust in the generated code. This thesis aims to address the challenges described above in the context of Machine Learning models trained on code. We provide three separate frameworks, each designed to address a specific aspect of reliability and trustworthiness: model representation learning, model auditing, and model evaluation. First, we investigate what Machine Learning models learn from code during training, and how their internal representations encode syntactic and semantic information. To enable systematic analysis, we introduce DeepCodeProbe, a probing framework for assessing the structure and quality of learned code representations. This work provides insights into how code representations and model capacity influence the retention of critical code features, supporting more interpretable and robust representation engineering and model design. Next, we address the need for transparent auditing of LLMs trained on code, especially as training datasets grow in size and are not made available for inspection. We propose TraWiC, a framework for detecting dataset inclusion in LLMs trained on code without requiring access to original datasets or model weights. This enables the detection of potential data leakage, intellectual property violations, and memorization, thereby supporting trustworthy model development and audit.

Finally, we address the need for reliable, scalable, and adaptive benchmarking frameworks for code LLMs. Static benchmarks fail to capture LLMs’ nuanced weaknesses or evolving capabilities by focusing only on binary success/failure signals on underlying tasks, and are prone to being incorporated in LLMs’ training datasets, resulting in inflated benchmarking results. Existing dynamic benchmarks often rely on other LLMs to judge the performance of the model-under-test (i.e., LLM-as-judge), which introduces bias, or lack a principled structure for task evaluation, which introduces high variance between benchmarking runs. Furthermore, they attempt to test for multiple capabilities at the same time (e.g., resolving an issue), which masks how the model attempts to solve the task and hides model weaknesses by bundling multiple reasoning requirements into one. We propose PrismBench, a novel dynamic evaluation methodology for comprehensive and adaptive benchmarking of LLMs’ code generation capabilities to address the shortcomings of current static and dynamic benchmarking approaches. This enables more reliable, fine-grained diagnostics and supports the development of robust, high-assurance models for code generation in Software Engineering. Together, these frameworks form a pipeline for probing, auditing, and systematically stresstesting Machine Learning models for Software Engineering. Our work provides both theoretical foundations and practical tools for understanding what these models learn, how their training data can be audited, and how their real-world capabilities and limitations can be rigorously evaluated. In doing so, it advances the state of the art in trustworthy Machine Learning models for Software Engineering and offers concrete methods for increasing transparency and reliability as these systems become integral to software development.