When several parts of a sensor-rich system fail at once, most automated diagnosis breaks. Standard tools assume a single fault and return the one component that best explains the alarm. A severe fault then hides a milder one elsewhere, and two overlapping fault signatures get read as a third, unrelated state. This proposal starts from a cheap observation. Many common faults (a sensor that freezes, a coupling between two process units that breaks, a channel that drifts away from its peers) remove or rewire the correlations among sensors. They therefore show up as new extreme eigenvalues, each concentrated on a few sensors, in a recent-data covariance matrix. These are the same directions in which an iterative linear solver such as Conjugate Gradient converges slowly. We propose to run a warm-started Krylov solver on a short-memory covariance that tracks recent data, and to read off the slow-converging directions as fault components. Every localized component that clears a noise threshold counts as a separate fault, so the number of faults is estimated from the data instead of fixed at one.
The argument has two parts. Temporal data weighting, meaning exponential forgetting that down-weights old samples, builds the operator and sets its noise level. Adaptive graph learning, meaning a sensor dependency graph estimated from data rather than taken from a schematic, is the object whose changes we diagnose. Iterative-solver convergence theory supplies both the cheap tracking at scale and a principled detection threshold. The single-fault assumption is what the method removes.
Core Claim
Take a sensor stream $x_s \in \mathbb{R}^N$ and two forgetting factors $\gamma_L$ close to 1 (long memory) and $\gamma_S < \gamma_L$ (short memory). Define the forgetting-weighted covariances
$$\Sigma_t^{\gamma} = (1-\gamma)\sum_{s \le t} \gamma^{t-s} (x_s - \mu_t^\gamma)(x_s - \mu_t^\gamma)^T + \lambda I,$$
where $\mu_t^\gamma$ is the matching forgetting-weighted mean and $\lambda$ is a small ridge term. The inverse of $\Sigma$, the precision matrix, is a learned sensor graph. Its off-diagonal entries measure how strongly two sensors depend on each other once the rest are accounted for. We use the long-memory estimate as the healthy reference and the short-memory estimate as the current state, and we model their difference as a sum of localized low-rank pieces:
$$\Theta_t^{S} - \Theta^{L} \approx \sum_{k=1}^{K_t} s_k\, u_k u_k^T + E_t .$$
Here $\Theta = \Sigma^{-1}$, each $u_k$ is a unit vector supported on a few sensors, $s_k$ is a signed magnitude, and $E_t$ is estimation noise. The noise scales with the effective sample size of the short window, roughly $1/(1-\gamma_S)$, because exponential weights sum to that many equivalent samples. The claims are the following. The number of faults $K_t$ can be estimated online as the count of localized components that exceed a perturbation bound on $E_t$. The supports of the $u_k$ locate the faults, and $|s_k|$ tracks their severity. All of this can be recovered from Ritz vectors, the eigenvector estimates that Lanczos iteration produces, recycled across time steps, with no dense eigendecomposition. Masking is handled structurally. A severe fault claims its own component and does not suppress a second component supported elsewhere in the graph, whereas a single-argmax classifier or a single residual threshold lets the severe fault dominate.
Pure mean shifts, such as a constant sensor bias, do not change the covariance. We will not pretend they do. They are handled by a parallel forgetting-weighted first-moment test on $\mu_t^{\gamma_S} - \mu^{\gamma_L}$, and results are reported separately by fault type.
Relation to Prior Work
Four lines of work bear on this, and each plays a different role.
Two papers show the gap. Deep Variational Graph Convolutional Recurrent Network for Multivariate Time Series Anomaly Detection learns a sensor graph from inner products of node embeddings and detects anomalies well (F1 0.849 on the DND dataset). It explicitly leaves open the question of which sensors failed when anomalies overlap. Connecting the Dots: Multivariate Time Series Forecasting with Graph Neural Networks (MTGNN) learns a sparse directed graph that matches physically given road graphs. That graph is static over the dataset, and MTGNN names real-time topology adaptation as unresolved. We keep the idea of a data-learned graph but make it doubly time-weighted. We then diagnose from the change in the graph rather than from forecast residuals.
Two papers constrain the design. Gated KalmaNet: A Fading Memory Layer Through Test-Time Ridge Regression casts exponential forgetting as online ridge regression solved with Chebyshev iteration. It reports that aggressive forgetting ill-conditions the normal equations, and it counters this with adaptive regularization. We accept that tension and turn it around. A fault that kills a sensor's excitation is exactly what drives the smallest covariance eigenvalue down, so the ill-conditioning is the signal, and $\lambda$ has to stay small enough not to erase it. Adversarial Attacks and Defenses in Fault Detection and Diagnosis: A Comprehensive Benchmark on the Tennessee Eastman Process shows that supervised diagnosis models on the Tennessee Eastman Process (TEP) collapse below 0.2 accuracy under small perturbations, and that defenses cost clean accuracy. This warns us that any learned classifier baseline needs robustness checks, and so does our method.
Three papers supply the numerical method. Perturbation Bounds for Low-Rank Inverse Approximations under Noise bounds errors in the part of a low-rank inverse that corresponds to the $p$ smallest eigenvalues under noise, using contour integrals. Their bounds come within a factor of about 10 of empirical error, where classical bounds are one to two orders of magnitude too loose. The authors note that the spectral-gap inputs are expensive to re-estimate for matrices that change over time. We use their bound as the detection threshold for $E_t$, and our recycled Lanczos iterates provide the gap estimates cheaply at each step. Learning from Linear Algebra: A Graph Neural Network Approach to Preconditioner Design for Conjugate Gradient Solvers (PreCorrector) trains a graph neural network correction to incomplete Cholesky with a loss weighted toward the smallest eigenvalues, because that is where Conjugate Gradient stalls. We share its focus on the small end of the spectrum but use it for diagnosis, not speed. NysADMM: faster composite convex optimization via low-rank approximation uses Nyström sketches, which capture the large eigenvalues, to remove the dependence on condition number. That makes clear why a Nyström-style sketch is the wrong tool here: it throws away the eigen-directions that carry the fault information.
On multi-fault diagnosis itself, Battery Fault: A Comprehensive Dataset and Benchmark for Battery Fault Diagnosis is the strongest supervised multi-label and multi-severity result in the file, and it needs labeled examples of fault combinations. The consistency-based reasoning of de Kleer and Williams (conflict sets) avoids enumerating all combinations but requires a predictive model of the system. Our method requires neither labels of combinations nor a physics model, only a healthy reference period.
Research Program
The first component is the tracker. We maintain $\Sigma_t^{\gamma_S}$ and $\Sigma^{\gamma_L}$ implicitly, as rank-one updates applied to vectors. For small $N$ this means dense updates; for large $N$ it means a sparse graph-structured approximation. At each step, a block Lanczos run of a few iterations on $\Sigma_t^{\gamma_S}$ is warm-started from the previous step's Ritz vectors for the $p$ smallest and $p$ largest eigenvalues. These vectors also serve as a deflation preconditioner for the ridge solves that update the graph, so diagnosis is a byproduct of work the graph learner already does. The analysis question is how many iterations per step are needed to hold a Ritz vector within a given angle of the true eigenvector. We expect this to depend on the spectral gap and on $1-\gamma_S$, since the operator changes by an amount of order $1-\gamma_S$ per step.
The second component is decomposition and counting. We compute the change of the reference-relative operator on the tracked subspace and split it into localized components with a group-sparse rotation, meaning a rotation of the subspace basis that pushes each vector's weight onto as few sensors as possible. We count components whose magnitude exceeds the Tran–Vishnoi bound. That bound is evaluated with a noise level implied by the effective sample size $1/(1-\gamma_S)$ and with gap estimates from the Ritz values.
The third component is the forgetting trade-off. A smaller $\gamma_S$ reacts faster but is noisier and worse conditioned. We will derive and measure the detection-delay versus false-alarm frontier as a function of $\gamma_S$. We will also test a rule that freezes $\Sigma^{\gamma_L}$ once a component is detected, so that the healthy reference is not slowly overwritten by the faulty regime. This "forgetting the baseline" failure mode is inherent to single-timescale forgetting.
Baselines
The naive reference point is per-sensor thresholding. We compute a forgetting-weighted z-score on each channel's mean and variance and flag every channel that exceeds a tuned quantile. This is multi-fault by construction but ignores the graph. It shows how much the relational structure matters, especially for decoupling faults, where each sensor looks normal on its own.
The strongest learned competitor is a supervised multi-label classifier: a Temporal Convolutional Network (TCN) with independent sigmoid outputs, trained on TEP single faults plus whatever fault combinations are allowed in the training split. The closest reported number is in Adversarial Attacks and Defenses in Fault Detection and Diagnosis: A Comprehensive Benchmark on the Tennessee Eastman Process: TCN accuracy of 0.90 on clean normal data under standard training, falling to 0.77 under PGD adversarial training. That figure is single-fault classification accuracy, so it anchors the single-fault regime, not the multi-fault one. For multi-label severity on batteries, the reference is BatteryMultiModalCNN from Battery Fault: A Comprehensive Dataset and Benchmark for Battery Fault Diagnosis, with F1 0.9280 for LFP discharging classification and 0.8813 for LFP severity grading. It will be run on its own benchmark if the segments expose the multiple channels our method needs. We give the classifier the same training streams, a hyperparameter search budget matched in GPU-hours to our tuning of $\gamma_S$, $\gamma_L$, $\lambda$ and $p$, and the same held-out combinations.
Beating it means two things. On fault combinations never seen in training, we must achieve higher per-fault F1. On single faults, where the classifier is expected to win, clean accuracy must stay within a few points of 0.90.
The strongest unsupervised graph competitor is residual attribution from a learned-graph model. We train DVGCRN and MTGNN on healthy data and flag the sensors whose reconstruction or forecast residual exceeds a threshold. Hyperparameters follow the original papers, and thresholds are tuned on the same validation stream we use. Beating these models means better localization when two faults are within one or two hops of each other on the learned graph. That is where we expect residuals to smear across neighbors.
For model-based conflict-set diagnosis in the style of de Kleer and Williams, no reported result found on Lacuna on these benchmarks. We include it only on TEP, where a linearized process model can be built.
Four ablations isolate the key ingredients. The first replaces the two-timescale difference with a single short-memory operator compared against a fixed pre-computed reference, to test whether the frozen-reference rule matters. The second replaces warm-started Lanczos with an exact dense eigendecomposition per window. This is the accuracy ceiling and the compute reference, and the iterative version must match it. The third replaces the perturbation-bound threshold with a tuned fixed quantile, to test whether the theory buys calibration across $\gamma_S$. The fourth forces $K_t \le 1$ (keep only the top component), which reinstates the single-fault assumption inside our own pipeline and directly measures what dropping it is worth.
Why not just…?
Why not just train a multi-label classifier with sigmoid outputs? This drops the single-fault assumption trivially, and when labeled combinations are plentiful it is a real threat that may win. The problem is that combinations grow as $2^N$ and are rarely observed. The Battery Fault benchmark reaches high multi-label F1 only because it can simulate combinations from electrochemical models. Our experiments settle the question with a held-out-combination split: train on all single faults and some pairs, test on unseen pairs and triples. If the classifier matches us there, the spectral method's case reduces to "no labels needed," and we will say so.
Why not just threshold per-sensor residuals from MTGNN or DVGCRN? Residual attribution is the natural unsupervised answer. Residuals propagate along learned edges, however, so a severe fault inflates its neighbors' residuals, and a mild concurrent fault on one of those neighbors is either absorbed or misattributed. That is masking in its graph form, and DVGCRN's authors list root-cause localization under overlapping anomalies as open. The graph-distance sweep described below is designed to show whether residuals fail exactly where localized spectral components do not.
Why not just recompute a dense eigendecomposition every window and skip the solver machinery? For TEP's 52 sensors this is correct and cheap, and we will use it there without apology. The iterative tracker only earns its place at hundreds to thousands of channels and high sampling rates. That is why the scale experiments use PEMS-BAY, METR-LA and the 862-sensor Traffic set. If warm-started Lanczos does not beat dense recomputation in wall-clock time at matched localization accuracy on those sets, the solver component is dropped and the contribution narrows to the two-timescale spectral diagnosis plus its threshold.
Why not just use a sliding window instead of exponential forgetting? A window is a legitimate alternative, and the effective-sample-size noise analysis applies to it as well. We include a matched-length sliding-window variant. We expect it to have similar noise but worse behavior at the edges of the window: jumps in the operator when old samples drop out, which the tracker then has to absorb, and a spurious component whenever a fault onset leaves the window.
Proposed Experiments
The main testbed is TEP. The standard benchmark (52 sensors, 28 fault modes, 100 runs each) provides single-fault streams. We will generate multi-fault streams by enabling pairs and triples of disturbance flags in the simulator, with staggered onsets and varying magnitudes. The metrics are per-fault F1 on onset and identity, detection delay, error in the estimated fault count $K_t$, and rank correlation between $|s_k|$ and injected magnitude as a severity proxy.
The decisive masking check sweeps the magnitude ratio between a severe and a mild concurrent fault, together with the graph distance between the two. Per-fault recall for the mild fault is plotted against the severe fault's magnitude for our method, the $K_t \le 1$ ablation, residual attribution, and the multi-label TCN. The prediction is that our recall for the mild fault stays flat until the two supports overlap, while the alternatives decline once the severe fault becomes large.
For scale, we inject stuck, drift and decoupling faults into random subsets of 1 to 5 sensors in PEMS-BAY, METR-LA and Traffic, which gives exact ground truth. We report localization F1 and wall-clock time per step for dense versus warm-started Lanczos, together with iterations per step as a function of $1-\gamma_S$.
The calibration check fixes the false-alarm rate on healthy data across $\gamma_S$. It asks whether the perturbation-bound threshold holds the rate near nominal without retuning, while the fixed-quantile ablation drifts.
Robustness follows the TEP adversarial protocol, with small FGSM perturbations applied to inputs, to see whether a second-moment method degrades more gracefully than the classifiers that collapsed below 0.2.
The method fails in a clean way if localized components do not separate at realistic effective sample sizes. That would appear as $K_t$ errors dominated by noise components even with the bound-based threshold, and it would be reported as a negative result about the identifiability of the change in the forgetting-weighted operator.
References
- Deep Variational Graph Convolutional Recurrent Network for Multivariate Time Series Anomaly Detection
- Connecting the Dots: Multivariate Time Series Forecasting with Graph Neural Networks
- Gated KalmaNet: A Fading Memory Layer Through Test-Time Ridge Regression
- Adversarial Attacks and Defenses in Fault Detection and Diagnosis: A Comprehensive Benchmark on the Tennessee Eastman Process
- Perturbation Bounds for Low-Rank Inverse Approximations under Noise
- Learning from Linear Algebra: A Graph Neural Network Approach to Preconditioner Design for Conjugate Gradient Solvers
- NysADMM: faster composite convex optimization via low-rank approximation
- Battery Fault: A Comprehensive Dataset and Benchmark for Battery Fault Diagnosis