A comprehensive study on causal discovery between degradation paths

This paper proposes a causal discovery strategy using degradation increments combined with non-temporal techniques to uncover dependencies between system parameters, demonstrating through numerical and engineering case studies that this approach outperforms raw data methods, with stable Peter-Clark and greedy equivalence search identified as the most robust algorithms.

The Gist

Imagine you are a mechanic trying to figure out why a complex machine, like a car engine or a sophisticated radio, is slowly breaking down over time. You have a logbook full of data showing how different parts (like temperature, pressure, or speed) are changing day by day.

The big question is: Are these changes just happening at the same time by coincidence, or is one part actually causing the other to fail?

This paper is like a detective story about solving that mystery. Here is the breakdown in simple terms:

1. The Problem: The "Trend" Trap

Imagine you are watching two runners in a race.

• Runner A is getting tired and slowing down.
• Runner B is also getting tired and slowing down.

If you just look at their positions over time, they both look like they are moving in the same direction (downward). A simple computer program might look at this and say, "Aha! Runner A is causing Runner B to slow down!" or vice versa.

But in reality, they might just both be tired because it's a hot day (a third factor), or they are just both naturally slowing down as the race goes on. In engineering, this is called a "trend." Because everything degrades (wears out) over time, the data always goes up or down. This "trend" tricks standard computer algorithms into seeing fake connections. It's like thinking your hair turning gray causes your knees to ache, when really, both are just signs of getting older.

2. The Solution: The "Step-by-Step" Trick

The authors realized that looking at the total position of the runners (the raw data) is confusing. Instead, they proposed looking at how much they moved in the last step.

• Raw Data: "Runner A is at mile 10, Runner B is at mile 10." (Hard to tell who is leading).
• Degradation Increments: "Runner A took a tiny step forward, but Runner B stumbled and took a huge step backward."

By focusing on the small changes (the increments) between measurements rather than the total values, the "trend" disappears. It's like zooming in on the footprints rather than the whole path. This allows the computer to see the real cause-and-effect relationships without being fooled by the general "wearing out" of the system.

3. The Toolbox: Testing the Detectives

The researchers didn't just invent one new method; they tested six different "detective" algorithms (computer programs designed to find causes) to see which one was the best at solving this specific puzzle.

Think of these algorithms as different types of detectives:

• The Skeptics (Stable-PC & GES): They are very careful. They look for patterns where variables are independent. They are great at saying, "These two things are not connected," but they sometimes struggle to say exactly who is pushing whom.
• The Mathematicians (NOTEARS & LiNGAM): They use complex math to guess the direction of the push. They are very good at finding the direction, but they can get confused if the data is messy or if the "steps" are too small.
• The Newcomer (CaPS): A fresh approach that tries to order the variables, but it struggled to tell the difference between independent runners and connected ones.

4. The Experiments: From Simulations to Real Engines

The team tested these detectives in two ways:

• The Simulation (The Video Game): They created fake degradation data using a mathematical model (Wiener process). They tested scenarios where two parts were totally unrelated and scenarios where one part definitely broke the other.

  • Result: The "Step-by-Step" trick worked wonders. The best detectives for finding the direction of the break were NOTEARS-MLP (a smart math detective) and NOTEARS-Linear. However, the "Skeptics" (Stable-PC and GES) were the most reliable at simply saying "Yes, they are connected" or "No, they aren't."

• The Real World (The Filter and the Jet Engine):

  • Case 1: A Radio Filter. They simulated a radio circuit. They knew exactly which resistors and capacitors were supposed to affect the signal. The "Skeptics" (Stable-PC and GES) correctly identified the connections, even if they couldn't point a finger at the exact direction. The math-heavy detectives got confused by the real-world noise.
  • Case 2: A Jet Engine. They used real data from NASA's turbofan engines. Again, the "Skeptics" found the most accurate map of how the engine parts were linked. They correctly identified that fuel flow affects temperature, and temperature affects speed, matching what real engineers know.

5. The Big Takeaway

The paper concludes with two main pieces of advice for engineers and data scientists:

1. Don't look at the whole picture; look at the steps. If you want to find out what causes what in a breaking machine, don't feed the raw data into your computer. First, calculate the changes (increments) between measurements. This removes the "aging" noise.
2. Pick the right detective.
   • If you want to know if two things are connected, use Stable-PC or GES. They are the most reliable.
   • If you need to know which way the influence flows (A causes B, or B causes A), NOTEARS-MLP is powerful, but it needs a lot of clean data to work well.

In a nutshell: This study teaches us that to understand how complex machines break, we need to stop looking at the "big picture" of them getting old and start looking at the "small steps" they take. By doing this, we can finally see the true chain reaction of failure, helping us fix machines before they crash.

Technical Summary

1. Problem Statement

Reliability analysis and Remaining Useful Life (RUL) prediction for complex engineered systems rely heavily on understanding the dependencies between multiple degradation parameters. While existing methods effectively model correlations (e.g., via copulas or state-space matrices), correlation does not imply causation.

• The Core Challenge: Current causal discovery techniques face significant hurdles when applied to degradation data:
  1. Violation of Assumptions: Most non-temporal causal discovery methods assume data is Independent and Identically Distributed (IID). However, raw degradation data exhibits strong trends over time, violating the IID assumption.
  2. Inapplicability of Temporal Methods: Standard temporal causal methods (e.g., Granger Causality, Transfer Entropy) assume that a variable's current state is influenced by the historical states of other variables. In many physical degradation processes (steady-state dependencies), a variable's current degradation state is influenced by the current states of other variables, rendering temporal methods ineffective.
  3. Lack of Benchmarking: Existing studies often apply causal discovery algorithms without rigorously assessing their suitability or comparing their performance across different degradation characteristics.

2. Methodology

A. Proposed Strategy: Degradation Increments (S2)

To address the violation of the IID assumption caused by trends in raw data, the authors propose a Causal Discovery Strategy based on Degradation Increments (S2).

• Concept: Instead of using raw degradation values ($X_t$), the method utilizes the degradation increments ($\Delta X_t = X_t - X_{t-1}$).
• Rationale: Degradation increments largely mitigate the monotonic trend inherent in performance degradation while preserving the causal relationships between variables. This transforms the data into a form more compatible with non-temporal causal discovery assumptions.
• Comparison: This is contrasted with Strategy S1 (using raw data), which the study demonstrates leads to false causal inferences.

B. Benchmark Techniques

The study evaluates six non-temporal causal discovery techniques representing five different algorithmic families:

1. Constraint-based: Stable-PC (an improved, order-independent version of the PC algorithm using Conditional Independence tests).
2. Score-based: GES (Greedy Equivalence Search, optimizing a score function like BIC).
3. Functional Causal Model-based: Direct-LiNGAM (assumes linear non-Gaussian acyclic models).
4. Gradient-based: NOTEARS-Linear and NOTEARS-MLP (reformulates DAG learning as a continuous optimization problem; MLP handles non-linearity).
5. Ordering-based: CaPS (Causal Discovery with Parent Score, a newer method using topological ordering).

C. Experimental Design

• Numerical Study: Simulated degradation paths using Wiener processes to model both independent and causally dependent scenarios.
  • Sensitivity Analysis: Systematically varied factors including causality nonlinearity ($\beta$), degradation nonlinearity ($\gamma$), random effects ($v_a$), measurement error ($\sigma_\epsilon$), and diffusion coefficients ($\sigma$).
• Engineering Applications:
  1. Second-order Multiple-Feedback Band Pass Filter: A circuit where component degradation (resistors/capacitors) affects center frequency ($f_0$) and peak gain ($G$).
  2. Turbofan Engine (C-MAPSS dataset): Real-world sensor data from 100 engine units to identify causal links between 14 performance parameters.

3. Key Contributions

1. Novel Strategy: Introduction of the degradation increment strategy (S2), which effectively bridges the gap between non-temporal causal discovery assumptions and the reality of trending degradation data.
2. Comprehensive Benchmarking: The first study to systematically compare five distinct categories of causal discovery techniques specifically for degradation paths, identifying Stable-PC and GES as the most robust.
3. Sensitivity Guidelines: Detailed analysis of how specific degradation characteristics (e.g., nonlinearity, noise levels) impact discovery accuracy, providing feasibility criteria for practitioners.
4. Practical Validation: Demonstration of the approach's utility in two distinct engineering domains (electronics and aerospace), showing its ability to uncover physical dependencies that correlation-based methods miss.

4. Key Results

Numerical Study Findings

• Strategy Performance: Strategy S1 (raw data) failed across all methods, incorrectly identifying causal links due to trend-induced correlations. Strategy S2 (increments) significantly improved accuracy.
• Method Performance:
  • Independent Paths: NOTEARS-Linear and NOTEARS-MLP were best at identifying independence (avoiding false positives). Stable-PC and GES had a slight risk of misjudgment.
  • Causally Dependent Paths: NOTEARS-MLP was the only method to robustly identify both the existence and direction of causal links (requiring $n \ge 7$ samples).
  • Stable-PC & GES: While they often failed to determine the direction of the link (outputting Markov Equivalence Classes), they were highly reliable in identifying the existence of the causal skeleton.
• Sensitivity Insights:
  • Causality Nonlinearity ($\beta$): Weak causal relationships ($\beta \le 0.8$) are undetectable by current methods.
  • Measurement Error: High measurement error ($\sigma_\epsilon \ge 0.8$) destroys discovery accuracy for dependent paths.
  • Diffusion Coefficient: Interestingly, a larger diffusion coefficient (more noise in the process) actually improved discovery accuracy for dependent paths, likely by breaking spurious linear correlations.

Engineering Application Findings

• Band Pass Filter:
  • Stable-PC and GES correctly identified the causal skeleton (which components affect $f_0$ and $G$) but could not determine direction.
  • NOTEARS methods failed in this practical case, likely due to scale disparities between parameters, highlighting a gap between numerical simulations and real-world data.
  • Conclusion: Domain knowledge combined with Stable-PC/GES skeletons provided the most accurate physical interpretation.
• Turbofan Engine:
  • Stable-PC identified 18 causal links, and GES identified 12.
  • Most identified links (e.g., Fuel Flow $\to$ Core Speed, Pressure $\to$ Bleed) aligned with physical domain knowledge.
  • Other methods (LiNGAM, NOTEARS, CaPS) failed to produce effective results on the real dataset.

5. Significance and Recommendations

• Recommendation: For causal discovery between degradation paths, Stable-PC and GES are the recommended methods. They offer the best balance of robustness and accuracy in identifying the causal structure (skeleton). While they may not determine direction automatically, the resulting skeleton can be combined with domain knowledge to infer direction.
• Impact on Reliability Engineering:
  • Enhanced Modeling: Causal graphs allow for more precise multivariate degradation modeling by using causal ancestors as inputs, rather than just correlated variables.
  • Targeted Control: Identifying true causal drivers enables maintenance strategies to focus on components that actually drive system failure, rather than just monitoring correlated symptoms.
• Future Work: The authors suggest extending this to multi-variable (non-pairwise) causal networks and integrating these causal graphs directly into RUL prediction models.

Code Availability: The study provides open-source code on GitHub for reproducibility.