DEFault++: Automated Fault Detection, Categorization, and Diagnosis for Transformer Architectures
| Authors | Sigma Jahan et al. |
| Year | 2026 |
| Field | AI / ML |
| arXiv | 2604.28118 |
| Download | |
| Categories | cs.SE, cs.AI, cs.LG |
Abstract
Transformer models are widely deployed in critical AI applications, yet faults in their attention mechanisms, projections, and other internal components often degrade behavior silently without raising runtime errors. Existing fault diagnosis techniques often target generic deep neural networks and cannot identify which transformer component is responsible for an observed symptom. In this article, we present DEFault++, a hierarchical learning-based diagnostic technique that operates at three level of abstraction: it detects whether a fault is present, classifies it into one of 12 transformer-specific fault categories (covering both attention-internal mechanisms and surrounding architectural components), and identifies the underlying root cause from up to 45 mechanisms. To facilitate both training and evaluation, we construct DEFault-bench, a benchmark of 3,739 labeled instances obtained through systematic mutation testing. These instances are created across seven transformer models and nine downstream tasks using DEForm, a transformer-specific mutation technique we developed for this purpose. DEFault++ measures runtime behavior at the level of individual transformer components. It organizes these measurements through a Fault Propagation Graph (FPG) derived from the transformer architecture. It then produces an interpretable diagnosis using prototype matching combined with supervised contrastive learning. On DEFault-bench, DEFault++ exceeds an AUROC of 0.96 for detection and a Macro-F1 of 0.85 for both categorization and root-cause diagnosis on encoder and decoder architectures. In a developer study with 21 practitioners, the accuracy of choosing correct repair actions increased from 57.1% without support to 83.3% when using DEFault++.
Engineering Breakdown
Plain English
DEFault++ is a hierarchical diagnostic system designed to detect, classify, and pinpoint faults in transformer models deployed in production. The system operates at three levels of abstraction: first detecting if a fault exists, then classifying it into one of 12 transformer-specific fault categories (covering attention mechanisms, projections, and architectural components), and finally identifying the root cause from up to 45 different internal mechanisms. This addresses a critical gap where existing fault diagnosis techniques target generic neural networks and cannot pinpoint which transformer component is responsible for observed failures. The approach is learning-based and hierarchical, enabling developers to move beyond generic debugging toward component-level fault identification.
Core Technical Contribution
The core novelty is a hierarchical, learning-based diagnostic framework specifically engineered for transformer internals rather than generic deep networks. Previous fault diagnosis work treated neural networks as black boxes or applied heuristics that don't account for transformer-specific architecture (multi-head attention, feed-forward projections, normalization layers). DEFault++ introduces a three-tier abstraction that progressively narrows fault attribution: presence detection → category classification (12 transformer-specific types) → root cause identification (45 mechanisms). This hierarchical decomposition is novel because it acknowledges that transformers have distinct internal components with different failure modes, and diagnosis must operate at the appropriate abstraction level for each.
How It Works
The system takes as input transformer model outputs and internal activation patterns when errors occur or performance degrades. The first stage uses a binary classifier to detect whether a fault is present versus normal operation. Once a fault is detected, the second stage routes the data to a 12-way classifier that categorizes the fault type—examples might include attention head collapse, gradient flow problems in projections, or normalization layer failures. The third stage then applies component-specific root cause analysis, examining up to 45 different internal mechanisms (e.g., specific weight matrices, bias terms, activation ranges) to isolate which mechanism is actually faulty. The hierarchical design means that earlier stages filter the decision space, reducing false positives and allowing later stages to focus on relevant mechanisms rather than searching all 45 independently.
Production Impact
In production, DEFault++ enables engineers to move from "the model outputs are wrong" to "head 3 of attention layer 8 has collapsed attention weights" within minutes. This dramatically reduces debugging time for silent failures—where the model runs without errors but degrades output quality. Adoption would require integrating activation monitoring hooks into your inference pipeline to collect internal states during inference, adding ~5-15% computational overhead during diagnosis runs (not during normal serving). The biggest win is reducing MTTR (mean time to repair) for subtle failures that don't trigger traditional error handling, and enabling targeted fixes (retraining specific components, applying layer-wise masks) rather than full model retraining. However, this requires maintaining diagnostic infrastructure, labeling training data with ground-truth fault annotations, and potentially storing diagnostic snapshots for failed inferences.
Limitations and When Not to Use This
The approach is limited to faults that manifest in observable ways—if a fault produces no measurable change in activations, it cannot be diagnosed by this system. The method requires labeled training data with 12 known fault categories and 45 mechanism-level ground truths, which may not exist for novel failure modes in your specific domain or model architecture. Scalability to extremely large models (>1T parameters) is unclear from the abstract, as monitoring all 45 mechanisms may become prohibitive. The 12 fault categories are transformer-specific, so the approach does not generalize to other architectures (CNNs, RNNs, Vision Transformers may require retraining or redesign), and the 45 mechanisms may need adjustment for different transformer variants (sparse attention, mixture-of-experts, etc.).
Research Context
This work builds on prior fault diagnosis literature in neural networks and addresses a gap in transformer-specific debugging. Existing techniques (e.g., neuron activation analysis, gradient-based attribution) treat transformers generically, missing component-specific failure modes. The paper likely evaluates against benchmarks like synthetic fault injection into transformer checkpoints or real failures from model monitoring data. It opens research directions in automated root cause analysis for deployed models, online diagnosis during inference, and extending the framework to other architectures and domains. The hierarchical classification approach is similar to medical diagnosis systems and represents a maturation of fault localization for deep learning toward production-grade debugging tools.
:::tip Subscribe Get weekly breakdowns of papers like this in AI Letters - the newsletter for engineers building production AI systems. :::