🤖 machine learning

Deep4ge: DNN Training Trajectories for Fault Detection and Diagnosis

Cet article présente Deep4ge, un ensemble de données de référence complet comprenant plus de 14 000 cycles d'entraînement par époque issus de 59 programmes de réseaux de neurones profonds avec des fautes injectées, conçu pour soutenir la recherche dans la détection et le diagnostic d'erreurs d'implémentation subtiles dans les systèmes d'apprentissage profond.

Auteurs originaux : Sigma Jahan

Publié 2026-07-15

📖 6 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Sigma Jahan

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

Imaginez que vous regardiez un étudiant essayer d'apprendre une nouvelle compétence, comme le jonglage. Parfois, il échoue non pas parce qu'il est paresseux, mais parce qu'il tient les balles de la mauvaise façon, ou que la pièce est trop sombre, ou qu'il essaie d'apprendre le mauvais tour entièrement. Dans le monde de l'intelligence artificielle, ces « étudiants » sont des réseaux de neurones profonds (DNN). Et lorsqu'ils échouent, ils ne s'effondrent pas toujours avec un message d'erreur bruyant ; au lieu de cela, ils deviennent simplement très mauvais en jonglage, ou commencent à tourner en rond, ou abandonnent à mi-chemin.

C'est le problème que l'article Deep4ge s'attaque. Les chercheurs ont réalisé que, bien que nous disposions de nombreux outils pour vérifier si la note finale d'un étudiant est bonne, nous n'avons pas de grande bibliothèque publique de « journaux de bord d'entraînement » montrant exactement comment ils ont échoué pendant le processus d'apprentissage. Pour y remédier, ils ont construit Deep4ge, une expérience massive et contrôlée qui agit comme un immense laboratoire de simulation pour les échecs d'entraînement de l'IA.

La grande simulation d'entraînement de l'IA

L'équipe a commencé par récupérer 59 extraits de code réels de Stack Overflow (un site web où les programmeurs posent et répondent à des questions). Ils les ont nettoyés pour s'assurer qu'ils s'exécutent parfaitement, comme on prépare une voiture de course avant un test de conduite. Ensuite, ils ont joué à un jeu de « Mad Libs » avec le code.

Ils ont utilisé 27 différents « opérateurs de mutation » — pensez à ces petits lutins malicieux qui se glissent dans le code et changent une infime chose. Peut-être remplacent-ils la vitesse d'apprentissage, changent le type de mathématiques utilisées, ou perturbent la façon dont l'IA commence son cerveau. Ils ont appliqué ces lutins pour créer 9 845 exécutions d'entraînement « défectueuses ». Pour s'assurer que la comparaison soit équitable, ils ont également lancé 4 382 versions « correctes » sans aucun lutin.

Au total, ils ont observé 14 227 sessions d'entraînement différentes. Pour chaque session, ils ne se sont pas contentés de regarder la note finale ; ils ont enregistré une entrée de journal pour chaque « époque » (un cycle d'apprentissage). Ils ont consigné 26 indices différents, comme la lourdeur des « pensées » (poids) de l'IA, la vitesse à laquelle les signaux se déplaçaient (gradients), et même la quantité de mémoire informatique utilisée par l'IA. Cela a produit 719 560 points de données individuels, créant une carte détaillée de ce qui va mal et de quand cela arrive.

La grande découverte : Ne regardez pas seulement la ligne d'arrivée

La partie la plus excitante de l'article est ce qu'ils ont découvert en essayant d'utiliser ces données pour prédire les échecs. Imaginez que vous êtes un entraîneur essayant de repérer un étudiant en difficulté.

Les chercheurs ont testé deux méthodes pour repérer le problème :

La méthode de l'« Examen Final » : Regarder uniquement le tout dernier jour de l'entraînement pour voir si l'étudiant a échoué.
La méthode du « Journal de Bord » : Regarder tout l'historique de la façon dont l'étudiant a appris, étape par étape.

Les résultats étaient clairs : la méthode de l'« Examen Final » n'était pas très bonne. Si l'on regardait seulement le dernier jour, un programme informatique pouvait à peine faire la différence entre un étudiant qui faisait de gros efforts mais échouait, et un étudiant qui était simplement confus. L'approche de l'« Examen Final » a donné un score (appelé MCC) d'environ 0,150 pour le meilleur modèle informatique.

Cependant, lorsqu'ils ont utilisé la méthode du « Journal de Bord » — en observant les tendances, les hauts et les bas, et tout le parcours — l'ordinateur est devenu bien meilleur pour repérer les problèmes. Le score a bondi à 0,227. C'est comme réaliser qu'un étudiant qui commence fort mais qui s'affaiblit progressivement est différent d'un étudiant qui commence lentement mais qui progresse. L'article suggère que pour vraiment comprendre pourquoi une IA échoue, il faut regarder tout le film, et pas seulement la fin.

Ce qu'ils peuvent (et ne peuvent pas) faire

L'équipe a également essayé de deviner quel type d'erreur l'IA a commise (comme : « Ont-ils raté la vitesse d'apprentissage ? » ou « Ont-ils choisi la mauvaise mathématique ? »). Ils ont constaté que certaines erreurs sont faciles à repérer, comme les erreurs de « Poids » (Weight), que l'ordinateur a identifiées correctement 70 % du temps. Mais d'autres erreurs, comme les erreurs d'« Activation » (où l'IA cesse totalement de réfléchir), étaient très difficiles à diagnostiquer, l'ordinateur obtenant 0 % de réussite dans certains tests.

Ils ont également testé si leurs conclusions fonctionneraient sur différents types d'étudiants d'IA (comme ceux qui traitent des images par rapport à ceux qui traitent du langage). Ils ont constaté que les compétences se transféraient assez bien, mais qu'il y avait une légère baisse de performance, notamment pour les modèles de traitement du langage, suggérant que différents types d'IA apprennent de manières légèrement différentes.

Les limites du laboratoire

Il est important de se rappeler qu'il s'agissait d'une simulation contrôlée. Les chercheurs ont créé les défauts eux-mêmes à l'aide de leurs outils de « lutins ». Ils suggèrent que cela aide à comprendre les problèmes du monde réel, mais ils admettent n'avoir pas prouvé que ces défauts de « lutins » exacts se produisent exactement de la même manière dans les logiciels industriels réels et désordonnés. De plus, ils n'ont examiné que trois types spécifiques d'architectures d'IA (FNN, CNN et RNN) et n'ont pas inclus les modèles « Transformer », plus récents et tendance.

La conclusion à retenir

Deep4ge est un cadeau fait à la communauté scientifique. C'est une bibliothèque publique de 14 227 histoires d'entraînement, complètes avec le « journal » de chaque étape. La leçon principale est que si vous voulez attraper une IA défaillante tôt, vous ne pouvez pas simplement attendre le rapport final. Vous devez observer le processus d'entraînement se dérouler, car les indices de l'échec sont cachés dans le voyage, et non dans la destination. Les auteurs ont publié toutes leurs données et outils afin que quiconque puisse construire de meilleurs détecteurs, prouvant que parfois, la meilleure façon de réparer un robot cassé est de le regarder trébucher encore et encore.

Résumé Technique : Deep4ge – Trajectoires d'entraînement de DNN pour la détection et le diagnostic de fautes

Énoncé du problème

Les systèmes d'apprentissage profond souffrent fréquemment de fautes d'implémentation subtiles qui altèrent le comportement de l'entraînement sans produire d'erreurs d'exécution explicites. Contrairement aux fautes logicielles traditionnelles, les défaillances des réseaux de neurones profonds (DNN) se manifestent souvent par des « symptômes silencieux » tels qu'une optimisation instable, des gradients évanescents ou explosifs, ou une faible généralisation. Le débogage de ces problèmes nécessite l'observation de l'évolution de l'entraînement au fil du temps plutôt que l'inspection du seul code source ou des sorties finales.

Malgré les propositions récentes d'outils de débogage pour les DNN (par exemple, AutoTrainer, DeepLocalize, DeepFD), la communauté du génie logiciel manque d'un ensemble de données public et réutilisable contenant des exécutions d'entraînement par époque avec des historiques de fautes documentés. Les cadres de mutation existants (par exemple, DeepCrime) se concentrent principalement sur l'évaluation des opérateurs plutôt que sur la fourniture de trajectoires d'entraînement complètes. De plus, de nombreuses études existantes reposent sur des fautes injectées limitées et spécifiques à l'étude, dont les données d'entraînement correspondantes ne sont pas publiées pour une réévaluation systématique.

Méthodologie

Les auteurs présentent Deep4ge, un benchmark contrôlé conçu pour combler cette lacune en générant un ensemble de données à grande échelle de trajectoires d'entraînement de DNN avec des catégories de fautes connues.

1. Construction de l'ensemble de données

Programmes sources : Les auteurs ont collecté 59 programmes DNN TensorFlow/Keras à partir de Stack Overflow. Ceux-ci ont été sélectionnés sur la base de leur complétude (contenant la définition du modèle, le chargage des données et l'entraînement), de leur réparabilité (pour garantir une exécution déterministe) et de leur portée architecturale (réseaux de neurones à propagation avant, convolutionnels et récurrents).
Déterminisme : Pour minimiser la variabilité non déterministe, les graines aléatoires ont été fixées au niveau du framework et des opérateurs, et les divisions de jeux de données ainsi que les paramètres d'initialisation ont été standardisés.
Injection de fautes : À partir de programmes de base corrigés, les auteurs ont appliqué 27 opérateurs de mutation au niveau de la source pour générer des variantes défectueuses. Ces opérateurs ont été regroupés en sept catégories de fautes :
1. Hyperparamètre
2. Perte (Loss)
3. Poids (initialisation/biais)
4. Couche (choix structurels)
5. Optimisation
6. Activation
7. Régularisation
  Note : L'ensemble des opérateurs combine un sous-ensemble des opérateurs de DeepCrime avec de nouveaux opérateurs de niveau couche introduits dans ce travail. Les opérateurs modifiant les données d'entraînement ou le contrôle du processus ont été exclus.
Validation de la mutation : Les auteurs ont employé le « critère d'élimination » de DeepCrime, qui repose sur la signification statistique (Cohen's $d \ge 0,5$ , $p < 0,05$ ) entre les distributions de précision des réseaux originaux et mutants sur 15 réentraînements. Les mutants statistiquement indiscernables de l'original ont été écartés. Les scores de mutation résultants étaient de 0,85 (FNN), 0,87 (CNN) et 0,83 (RNN).

2. Extraction de caractéristiques

Pour chaque exécution d'entraînement (correcte ou défectueuse), le système enregistre des données à chaque époque. Chaque exécution enregistre :

4 métriques d'évaluation : Perte et précision (training/validation).
26 caractéristiques dynamiques :
- Poids : Nombre de poids importants, drapeaux de moyenne/écart-type inchangés, nombre de NaN.
- Tendances : Écart, oscillation, diminution et augmentation de la précision/perte.
- Activations : ReLU mourante (Dying ReLU), saturation, moyenne et écart-type.
- Gradients : Drapeaux d'évanescence/explosion, nombre de NaN, moyenne, écart-type, min, max, médiane des normes de couche, et statistiques par poids.
- Matériel : Taux d'apprentissage, utilisation du CPU, pic de mémoire GPU et utilisation de la mémoire système.

3. Tâches de référence (Benchmarks)

L'ensemble de données prend en charge trois tâches principales :

Détection de fautes binaire : Classer une exécution comme défectueuse ou correcte.
Diagnostic de fautes multiclasse : Assigner l'une des sept catégories de fautes à une exécution défectueuse.
Prédiction précoce de fautes : Prédire les fautes à partir d'exécutions d'entraînement partielles (époque unique ou sous-ensembles de trajectoire).

Principales contributions

Ensemble de données Deep4ge : Un ensemble de données étiqueté comprenant 14 227 exécutions d'entraînement (9 845 défectueuses, 4 382 bases correctes) couvrant 719 560 enregistrements d'époques. Les données couvrent 59 programmes Stack Overflow uniques à travers trois familles d'architectures et sept catégories de fautes.
Cadre Open-Source : Un cadre d'injection de fautes qui applique des transformations basées sur l'AST, enregistre les caractéristiques par époque et inclut des scripts de validation. Le cadre permet aux praticiens de régénérer l'ensemble de données ou de l'étendre avec de nouvelles transformations.
Modèles de base de preuve de concept : Les auteurs fournissent des mesures de performance de base pour la détection et le diagnostic de fautes en utilisant des modèles de régression logistique et de forêt aléatoire (Random Forest), en comparant les caractéristiques de la « dernière époque » aux caractéristiques de la « trajectoire complète ».

Résultats et conclusions

Les auteurs ont évalué la performance de détection et de diagnostic en utilisant une validation croisée de type 5-fold group-aware (groupée par programme source pour éviter la fuite de données).

Trajectoire vs Dernière Époque : L'utilisation de trajectoires d'entraînement complètes surpasse de manière significative l'utilisation des seules caractéristiques de la dernière époque.
- Pour la Détection de fautes, la forêt aléatoire (RF) utilisant les caractéristiques de trajectoire a atteint un coefficient de corrélation de Matthews (MCC) de 0,227, contre 0,150 pour les caractéristiques de la dernière époque.
- Pour le Diagnostic de fautes, le F1 macro de la RF est passé de 0,355 (dernière époque) à 0,381 (trajectoire), le MCC passant de 0,346 à 0,401.
Performance par catégorie de faute : La performance de diagnostic varie selon la catégorie. Les fautes liées aux poids ont été les plus faciles à diagnostiquer (F1 = 0,700), suivies par les hyperparamètres et la perte. Les fautes d'optimisation et d'activation ont été les plus difficiles (F1 = 0,075 et 0,000, respectivement). Les matrices de confusion indiquent que les fautes d'activation sont souvent classées à tort comme des fautes d'optimisation, et les fautes d'optimisation comme des fautes de couche.
Transfert entre architectures : Les modèles entraînés sur deux familles d'architectures et testés sur la troisième ont montré une légère mais non nulle baisse de performance (le MCC est passé de 0,227 à ~0,20), suggérant que si certaines caractéristiques sont transférables, d'autres restent spécifiques à l'architecture.
Détection précoce : La détection à l'époque unique (utilisant les caractéristiques de l'époque $k$ ) a donné des performances moindres (MCC 0,14–0,19) par rapport aux modèles de trajectoire complète, indiquant qu'observer l'évolution de l'entraînement est nécessaire pour une détection robuste.

Signification et affirmations

L'article affirme que Deep4ge est le premier ensemble de données public qui lie des programmes DNN adaptés avec des catégories de fautes dérivées de mutations et des trajectoires d'entraînement par époque correspondantes. Sa signification réside dans :

Standardisation : Fournir un benchmark contrôlé qui permet une réévaluation et une comparaison systématiques des techniques de détection et de diagnostic de fautes.
Changement méthodologique : Permettre la recherche axée sur la dynamique d'entraînement (trajectoires) plutôt que sur l'analyse statique du code ou les sorties finales.
Reproductibilité : Offrir un artefact versionné et open-source (CC BY 4.0 pour les données, MIT pour le code) qui permet à la communauté de répliquer les résultats, d'étendre la taxonomie des fautes et de tester de nouvelles architectures.

Les auteurs maintiennent un champ d'application modeste, reconnaissant que l'ensemble de données est limité aux architectures TensorFlow/Keras FNN, CNN et RNN (excluant les Transformers) et que les programmes Stack Overflow peuvent ne pas refléter pleinement les pratiques industrielles. Ils ne prétendent pas que les fautes dérivées de la mutation représentent parfaitement les fautes survenant naturellement dans l'industrie, mais plutôt que l'ensemble de données sert de ressource fondamentale pour étudier les comportements de fautes lors de l'entraînement.