wikillm

Paper · 2026-02-03 · cs.LG, cs.AI

Graph Autoencoder for Process Monitoring

CGSTAE learns time-varying correlation graphs with self-attention, then turns them into a causal graph by keeping the links that stay stable across windows. A GCLSTM sequence-to-sequence autoencoder on that graph flags faults with T2 and SPE statistics. On the Tennessee Eastman process it reports F1-score 0.896 against 0.822 for the best baseline. Author-reported.

Graph structure learningCausal discoveryGraph neural networkAnomaly detectionprocess-monitoringfault-detectioncausal-discoverygraph-autoencoder

arXivPDFMarkdown16 min read

AI-compiled by claude-haiku-5-5 on 2026-11-12, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.

In plain words

Factories and chemical plants are watched by software that learns what normal operation looks like and raises an alarm when the measurements drift away from it. Many such monitors look at which measurements tend to move together. That can mislead them: two readings may move together only because of a hidden common cause or a temporary operating condition, and the link can vanish when conditions change.

The idea here is to keep only the links that hold up across many different conditions, much like trusting a habit that shows up in every season rather than one that appears only in summer. The system first learns a graph of which process variables seem related in each short stretch of time. It then keeps the parts of that graph that stay stable across these stretches and treats them as candidate cause-and-effect links. Known facts about the plant can steer the result, and the graph is pushed towards clear yes-or-no links so that an operator can read it.

A second model rebuilds short stretches of the measurements using that graph. Readings that the model cannot rebuild well, or a hidden state that looks unusual, signal a fault. The goal is a monitor that stays reliable when conditions shift and whose graph can be inspected.

TL;DR

CGSTAE is a monitoring model for multivariate industrial processes. It learns a correlation graph per time window with self-attention, then derives a causal graph from the parts that stay stable, using a prior graph, sparsity and discreteness penalties §III-C. A GCLSTM sequence-to-sequence autoencoder built on that graph detects faults with a T² statistic in feature space and an SPE statistic in residual space §III-D1. On the Tennessee Eastman process the paper reports an F1-score of 0.896, the highest of the eight methods compared, while its average false alarm rate is the highest of those eight tab. I. The air separation process named in the abstract has no results in the paper body.

Problem

Correlation-based graph models for process monitoring can latch onto spurious correlations from confounders and sample selection bias, which may not hold under other operating conditions. They also fit process mechanisms poorly, which limits interpretability §I. The paper reviews classical causal discovery and finds each family limited: constraint-based methods cannot separate members of a Markov equivalence class, score-based methods can overlook unobserved confounders, functional methods rely on assumptions about the data-generating mechanism, and Granger causality and transfer entropy mainly measure predictability or information transfer rather than causal mechanism §I. Process-knowledge graphs are cited as an alternative, but their completeness and accuracy cannot be guaranteed §II-B.

The method rests on two causal identifiability conditions the paper states: invariant effect (a causal effect stays stable across conditions) and sufficient intervention (the data contains enough variation). Without enough fluctuation in the data, the authors add prior knowledge as a constraint §III-A §III-C2.

Method

The model has two parts: a self-attention module that learns a correlation graph for each window §III-B1, and a spatial-temporal encoder-decoder built from GCLSTM units §III-B2. Training has three steps, given as Algorithm 1 alg. 1: pre-training (step 1), causal graph learning with frozen parameters (step 2), and fine-tuning on the causal graph (step 3) §III-C. Monitoring then uses two statistics with control limits from kernel density estimation §III-D.

Notation: n variables, window length w, and a window X^(t) whose rows are the time steps t-w+1 to t. The shape (w, n) is inferred from the text, not stated.

1. Correlation graph (SSAM) §III-B1. Queries and keys are linear maps of the window, and the adjacency is a scaled inner product passed through a sigmoid. The paper calls this matrix the correlation graph at time t.

\mathbf{A}^{(t)}=\sigma \left( \frac{{(\mathbf{Q}^{(t)})}^{T}\mathbf{K}^{(t)}}{\sqrt{w}} \right) eq. 1

\mathbf{Q}^{(t)}=\mathbf{X}^{(t)}\mathbf{W}_{\mathbf{Q}}, \qquad \mathbf{K}^{(t)}=\mathbf{X}^{(t)}\mathbf{W}_{\mathbf{K}} eq. 2

2. Encoder §III-B2. The encoder GCLSTM steps forward through the window. Each gate applies a graph convolution over the adjacency to the current values stacked with the previous hidden state. The final cell and hidden states go to the decoder.

\begin{aligned} \mathbf{f}^{(k)} &= \sigma\big(GC_f([\mathbf{x}^{(k)};\mathbf{h}^{(k-1)}],\mathbf{A}^{(k)})+\mathbf{b}_f\big) \\ \mathbf{i}^{(k)} &= \sigma\big(GC_i([\mathbf{x}^{(k)};\mathbf{h}^{(k-1)}],\mathbf{A}^{(k)})+\mathbf{b}_i\big) \\ \mathbf{o}^{(k)} &= \sigma\big(GC_o([\mathbf{x}^{(k)};\mathbf{h}^{(k-1)}],\mathbf{A}^{(k)})+\mathbf{b}_o\big) \\ \tilde{\mathbf{c}}^{(k)} &= \tanh\big(GC_c([\mathbf{x}^{(k)};\mathbf{h}^{(k-1)}],\mathbf{A}^{(k)})+\mathbf{b}_c\big) \\ \mathbf{c}^{(k)} &= \mathbf{f}^{(k)}\odot\mathbf{c}^{(k-1)}+\mathbf{i}^{(k)}\odot\tilde{\mathbf{c}}^{(k)} \\ \mathbf{h}^{(k)} &= \mathbf{o}^{(k)}\odot\tanh\big(\mathbf{c}^{(k)}\big) \end{aligned} eq. 3

GC(\mathbf{Z},\mathbf{A}^{(k)})=\mathbf{D}^{-\frac{1}{2}}\big(\mathbf{A}^{(k)}+\mathbf{I}\big)\mathbf{D}^{-\frac{1}{2}}\mathbf{Z}\,\mathbf{W}_{GC} eq. 4

Here I is the identity and D the degree matrix of (A + I). W_GC is one trainable matrix in the text; the four gates are described as four GC layers §III-B2.

3. Decoder §III-B2. A second, separate GCLSTM unit runs the window in reverse order, starting from the encoder state. Each step reads the reconstruction and the hidden state, and a fully connected layer maps the hidden state to the reconstructed values.

\begin{aligned} \mathbf{f}^{(k-1)} &= \sigma\big(GC_f([\hat{\mathbf{x}}^{(k)};\mathbf{h}^{(k)}],\mathbf{A}^{(k)})+\mathbf{b}_f\big) \\ \mathbf{i}^{(k-1)} &= \sigma\big(GC_i([\hat{\mathbf{x}}^{(k)};\mathbf{h}^{(k)}],\mathbf{A}^{(k)})+\mathbf{b}_i\big) \\ \mathbf{o}^{(k-1)} &= \sigma\big(GC_o([\hat{\mathbf{x}}^{(k)};\mathbf{h}^{(k)}],\mathbf{A}^{(k)})+\mathbf{b}_o\big) \\ \tilde{\mathbf{c}}^{(k-1)} &= \tanh\big(GC_c([\hat{\mathbf{x}}^{(k)};\mathbf{h}^{(k)}],\mathbf{A}^{(k)})+\mathbf{b}_c\big) \\ \mathbf{c}^{(k-1)} &= \mathbf{f}^{(k-1)}\odot\mathbf{c}^{(k)}+\mathbf{i}^{(k-1)}\odot\tilde{\mathbf{c}}^{(k-1)} \\ \mathbf{h}^{(k-1)} &= \mathbf{o}^{(k-1)}\odot\tanh\big(\mathbf{c}^{(k-1)}\big) \end{aligned} eq. 5

\hat{\mathbf{x}}^{(k)}=\mathbf{W}_{FC}\,\mathbf{h}^{(k)}+\mathbf{b}_{FC} eq. 6

Forward pass for one window (pseudocode). This follows eq. 1 to eq. 6; the attention graph is replaced by the fixed causal graph after step 2 §III-C3.

Pseudocode
# One window through the model  [§III-B1] [§III-B2]
# Input:  window (w, n), rows = time steps; causal_adj or None
# Output: reconstruction (w, n) in time order; latent state; adjacency

# Graph convolution with symmetric normalisation of adj + I  [eq. 4]
def graph_conv(inputs, adj, weight):
    # Add self-loops, then normalise by node degrees  [eq. 4]
    looped = adj + identity                   # (n, n)
    scale = diag(row_sums(looped) ** -0.5)    # D^(-1/2)
    normed = scale @ looped @ scale
    return normed @ inputs @ weight           # weight shape not stated

# One GCLSTM step  [eq. 3]
def gclstm_step(x, h_prev, c_prev, adj, p):
    # Gate input: current values stacked with previous hidden state  [eq. 3]
    stacked = concat(x, h_prev)               # (n, 1 + d_h), inferred shape
    # Forget, input and output gates use a sigmoid  [eq. 3]
    forget = sigmoid(graph_conv(stacked, adj, p.W_f) + p.b_f)
    input_gate = sigmoid(graph_conv(stacked, adj, p.W_i) + p.b_i)
    output_gate = sigmoid(graph_conv(stacked, adj, p.W_o) + p.b_o)
    # Candidate cell state uses tanh  [eq. 3]
    candidate = tanh(graph_conv(stacked, adj, p.W_c) + p.b_c)
    # Update the cell state, then the hidden state  [eq. 3]
    c = forget * c_prev + input_gate * candidate
    h = output_gate * tanh(c)
    return h, c

def forward_window(window, causal_adj, p):
    # Self-attention adjacency for this window  [§III-B1] [eq. 1] [eq. 2]
    queries = window @ p.W_Q                  # (w, n); W_Q shape not stated
    keys = window @ p.W_K                     # (w, n); W_K shape not stated
    attention = sigmoid(queries.T @ keys / sqrt(w))   # (n, n) if shapes fit
    # After step 2 a fixed causal graph replaces the attention  [§III-C3]
    adj = attention if causal_adj is None else causal_adj
    # Encoder: run the window forward from an initial state  [§III-B2] [eq. 3]
    h, c = initial_state                      # initial values not stated
    for x in window:
        h, c = gclstm_step(x, h, c, adj, p.enc)
    # The final encoder state is the latent used for T2  [§III-D1]
    latent = h
    # Decoder: second unit runs the window in reverse  [§III-B2] [eq. 5]
    h_dec, c_dec = latent, c
    x_hat = initial_input                     # first decoder input not stated
    outputs = []
    for step in range(w):
        h_dec, c_dec = gclstm_step(x_hat, h_dec, c_dec, adj, p.dec)
        # Linear read-out of the hidden state  [eq. 6]
        x_hat = p.W_fc @ h_dec + p.b_fc
        outputs.append(x_hat)
    return outputs[::-1], latent, adj

4. Three-step causal graph learning §III-C alg. 1. Parameters are θ = [θ_SSAM, θ_STAE]. Step 1 pre-trains both parts on the MSE of the window reconstruction, summed over every window and every step inside it.

\bm{\theta}=\arg\min_{\bm{\theta}}\ \mathcal{L}_{\text{MSE}}(\bm{\theta}_{\text{SSAM}},\bm{\theta}_{\text{STAE}}) =\arg\min_{\bm{\theta}}\sum_{t=w}^{N}\sum_{k=t-w+1}^{t}\big\|\hat{\mathbf{x}}^{(k)}-\mathbf{x}^{(k)}\big\|^{2} eq. 7

\hat{\mathbf{X}}^{(t)}=f_{\text{STAE}}\big(\mathbf{X}^{(t)},\ \mathbf{A}^{(t)}=f_{\text{SSAM}}(\mathbf{X}^{(t)})\big), \qquad \hat{\mathbf{X}}^{(t)}=[\hat{\mathbf{x}}^{(t-w+1)},\dots,\hat{\mathbf{x}}^{(t)}]^{T} eq. 8

Step 2 freezes all of θ and learns a trainable n × n matrix A, the causal graph. Its objective is a weighted sum of five terms, with four balancing hyperparameters λ1 to λ4.

\mathbf{A}=\arg\min_{\mathbf{A}}\Big(\mathcal{L}_{\text{MSE}}(\mathbf{A},\bm{\theta}_{\text{STAE}})+\lambda_1\mathcal{L}_{\text{invariance}}(\mathbf{A},\mathbf{A}^{(t)})+\lambda_2\mathcal{L}_{\text{prior}}(\mathbf{A},\mathbf{A}^{\text{prior}})+\lambda_3\mathcal{L}_{\text{sparsity}}(\mathbf{A})+\lambda_4\mathcal{L}_{\text{discrete}}(\mathbf{A})\Big) eq. 9

The reconstruction term uses the candidate graph in place of the attention graph:

\mathcal{L}_{\text{MSE}}(\mathbf{A},\bm{\theta}_{\text{STAE}})=\sum_{t=w}^{N}\sum_{k=t-w+1}^{t}\big\|\hat{\mathbf{x}}^{(k)}-\mathbf{x}^{(k)}\big\|^{2}, \qquad \hat{\mathbf{X}}^{(k)}=f_{\text{STAE}}(\mathbf{X}^{(t)},\mathbf{A}) eq. 10

The invariance term penalises the L1 difference between the candidate graph and the correlation graph A^t = f_SSAM(X^t):

\mathcal{L}_{\text{invariance}}(\mathbf{A},\mathbf{A}^{(t)})=\sum_{i=1}^{n}\sum_{j=1}^{n}\big|\mathbf{A}_{ij}-\mathbf{A}^{t}_{ij}\big| eq. 11

The prior term is a masked cross-entropy. The mask M is 1 where the prior entry is 1 or 0, and 0 where it is NA (uncertain):

\mathcal{L}_{\text{prior}}(\mathbf{A},\mathbf{A}^{\text{prior}})=-\sum_{i=1}^{n}\sum_{j=1}^{n}\mathbf{M}_{ij}\Big(\mathbf{A}^{\text{prior}}_{ij}\log\mathbf{A}_{ij}+\big(1-\mathbf{A}^{\text{prior}}_{ij}\big)\log\big(1-\mathbf{A}_{ij}\big)\Big) eq. 12

The sparsity term is an L1 norm masked to the uncertain (NA) entries:

\mathcal{L}_{\text{sparsity}}(\mathbf{A})=\sum_{i=1}^{n}\sum_{j=1}^{n}\big(1-\mathbf{M}_{ij}\big)\mathbf{A}_{ij} eq. 13

The discreteness term is an element-wise binary entropy, which is smallest when every entry is near 0 or 1:

\mathcal{L}_{\text{discrete}}(\mathbf{A})=-\sum_{i=1}^{n}\sum_{j=1}^{n}\Big(\mathbf{A}_{ij}\log\mathbf{A}_{ij}+\big(1-\mathbf{A}_{ij}\big)\log\big(1-\mathbf{A}_{ij}\big)\Big) eq. 14

Step 3 removes the correlation module, fixes A, and fine-tunes the encoder-decoder on the MSE with the causal graph:

\bm{\theta}_{\text{STAE}}=\arg\min_{\bm{\theta}_{\text{STAE}}}\sum_{t=w}^{N}\sum_{k=t-w+1}^{t}\big\|\hat{\mathbf{x}}^{(k)}-\mathbf{x}^{(k)}\big\|^{2}, \qquad \hat{\mathbf{X}}^{(k)}=f_{\text{STAE}}(\mathbf{X}^{(t)},\mathbf{A}) eq. 15

Three-step training (pseudocode). This follows alg. 1 and eq. 7 to eq. 15.

Pseudocode
# Three-step causal graph structure learning  [alg. 1] [§III-C]
# Input:  normal training windows; prior adjacency (1, 0 or NA)
# Output: causal adjacency adj (n, n); trained encoder-decoder parameters

def train_causal_stae(windows, prior, lambdas, n_s1, n_s2, n_s3):
    # Step 1, pre-training: fit SSAM and STAE jointly  [§III-C1] [eq. 7]
    for epoch in range(n_s1):
        for batch in batches(windows):
            # Reconstruction uses the attention graph  [eq. 8]
            loss = mse_error(batch, causal_adj=None)
            update(params, grad(loss))
    # Step 2, causal graph learning: all parameters frozen  [§III-C2]
    adj = trainable_matrix(n, n)              # initial values not stated
    known_mask = prior != NA                  # 1 where prior is 1 or 0
    for epoch in range(n_s2):
        for batch in batches(windows):
            # Reconstruction with the candidate graph  [eq. 10]
            recon = mse_error(batch, causal_adj=adj)
            # Stay close to the correlation graph  [eq. 11]
            invariance = sum(abs(adj - attention_graph(batch)))
            # Agree with known prior links only  [eq. 12]
            prior_term = masked_cross_entropy(adj, prior, known_mask)
            # Penalise weight on uncertain (NA) entries  [eq. 13]
            sparsity = sum((1 - known_mask) * adj)
            # Push each entry towards 0 or 1  [eq. 14]
            discrete = binary_entropy(adj)
            # Weighted sum minimised over adj  [eq. 9]
            loss = (
                recon
                + lambdas[0] * invariance
                + lambdas[1] * prior_term
                + lambdas[2] * sparsity
                + lambdas[3] * discrete
            )
            update(adj, grad(loss))
    # Step 3, fine-tuning: drop SSAM, fix adj, train STAE  [§III-C3] [eq. 15]
    for epoch in range(n_s3):
        for batch in batches(windows):
            loss = mse_error(batch, causal_adj=adj)
            update(stae_params, grad(loss))
    return adj, stae_params

5. Monitoring §III-D. During offline modelling, the T² statistic uses the final encoder state at each time, and SPE sums the squared residuals over the window. Control limits come from kernel density estimation at a chosen significance level §III-D1. Online, a sample is normal only if both statistics are within their limits.

\mathrm{T}^{2}(t)=\big(\mathbf{h}^{(t)}-\bar{\mathbf{h}}\big)^{T}\Sigma^{-1}\big(\mathbf{h}^{(t)}-\bar{\mathbf{h}}^{(t)}\big) eq. 16

\mathrm{SPE}(t)=\sum_{k=t-w+1}^{t}\big(\mathbf{x}^{(k)}-\hat{\mathbf{x}}^{(k)}\big)^{T}\big(\mathbf{x}^{(k)}-\hat{\mathbf{x}}^{(k)}\big) eq. 17

\begin{cases} \text{Normal:} & \mathrm{T}^{2}(t_{\text{new}})\le\alpha_{\text{T2}}\ \text{and}\ \mathrm{SPE}(t_{\text{new}})\le\alpha_{\text{SPE}} \\ \text{Fault:} & \mathrm{T}^{2}(t_{\text{new}})>\alpha_{\text{T2}}\ \text{or}\ \mathrm{SPE}(t_{\text{new}})>\alpha_{\text{SPE}} \end{cases} eq. 18

Pseudocode
# Monitoring statistics at time t  [§III-D1] [eq. 16] [eq. 17] [eq. 18]
# Input:  latent (d_h,), window (w, n), recon (w, n), mean, cov, limits
# Output: fault flag, T2 and SPE values

def monitor(latent, window, recon, mean, cov, t2_limit, spe_limit):
    # Hotelling T2 on the final encoder state  [eq. 16]
    deviation = latent - mean
    t2 = deviation.T @ inverse(cov) @ deviation
    # Squared prediction error summed over the window  [eq. 17]
    residual = window - recon                 # (w, n)
    spe = sum(residual * residual)
    # Fault when either statistic exceeds its limit  [eq. 18]
    is_fault = t2 > t2_limit or spe > spe_limit
    return is_fault, t2, spe

6. Fault diagnosis §III-D2. The paper also proposes a root-cause procedure that is described but not evaluated in its experiments. Per-variable contributions are the squared residuals summed over the window eq. 19. Variables whose contribution exceeds the SPE limit are fault variables eq. 20. The causal adjacency is binarised with a threshold δ eq. 21. The paper then searches for a subgraph that covers all fault variables with as few normal variables as possible, and treats its source nodes as candidate root causes §III-D2.

\mathrm{VC}_{i}^{(t)}=\sum_{k=t-w+1}^{t}\big(x_{i}^{(k)}-\hat{x}_{i}^{(k)}\big)^{2} eq. 19

\mathcal{V}_{\text{fault}}=\big\{v_i\ \big|\ \mathrm{VC}_{i}^{(t)}>\alpha_{\text{SPE}},\ t\in[t_{\text{start}},\dots,t_{\text{stop}}]\big\} eq. 20

\tilde{\mathbf{A}}_{ij}=\begin{cases} 0, & \text{if}\ \mathbf{A}_{ij}\le\delta \\ 1, & \text{if}\ \mathbf{A}_{ij}>\delta \end{cases} eq. 21

Figures: the architecture is fig. 1, the GCLSTM unit fig. 2, the monitoring flowchart fig. 3, the TEP process diagram fig. 4. T² and SPE traces for fault 11 are in fig. 5 and fig. 6. The learned graphs are compared in fig. 7. No figure is reproduced in this card.

Hyperparameters

Values are as stated for the Tennessee Eastman process §IV-A unless noted. Nothing is stated for the air separation process.

NameValueWhereNotes
sliding window length w5§IV-ATEP only
hidden state dimension2§IV-Aper-node or global shape not stated
λ1 (invariance)0.02§IV-A eq. 9
λ2 (prior)0.08§IV-A eq. 9
λ3 (sparsity)0.01§IV-A eq. 9
λ4 (discreteness)0.03§IV-A eq. 9
batch size32§IV-A
learning rate, pre-training and fine-tuning0.05§IV-Aoptimizer not stated
learning rate, causal graph learning0.1§IV-Aoptimizer not stated
early stopping patience5§IV-Amonitored quantity not stated
KDE significance level0.01§IV-A §III-D1kernel and bandwidth not stated; whether it applies to both limits is not explicit
epochs N_S1, N_S2, N_S3not statedalg. 1
discretisation threshold δnot stated§III-D2 eq. 21
prior causal graphfrom reference wu2022data§IV-Amatrix not reproduced here
training data960 normal samples, 52 variables§IV-A
test data per fault960 samples, fault from sample 161§IV-A
W_Q, W_K, W_GC, W_FC shapesnot stated§III-B1 §III-B2
initial states and initial decoder inputnot stated§III-B2
optimizer, weight initialisationnot statedalg. 1
air separation settingsnot stated§IVnamed in abstract, no details

Results

Author-reported. Setup: Tennessee Eastman process (TEP) with all 52 variables, 960 normal training samples, and 21 fault scenarios of 960 samples each, with the fault introduced at sample 161 §IV-A. Metrics are fault detection rate (FDR), false alarm rate (FAR) and an F1-score that the paper says balances the two; the formula for F1 is not stated §IV. Baselines: AE, LSTM-AE, GAE-I (Pearson correlation graph), GAE-II (transfer-entropy graph), DGSTAE (SSAM graph with a spatial-temporal graph autoencoder), KDGCN and KG-GCBiGCN §IV. Hardware and the number of runs are not stated.

Headline numbers from tab. I:

  • CGSTAE F1-score 0.896. Next are DGSTAE 0.822, LSTM-AE 0.820, KG-GCBiGCN 0.814, AE 0.809, KDGCN 0.801, GAE-II 0.782 and GAE-I 0.746.
  • Average FDR 0.822 for CGSTAE, against 0.700 for the next highest (DGSTAE).
  • Average FAR 0.059 for CGSTAE, the highest of the eight. DGSTAE has the lowest, 0.012.

Full table, FDR and FAR per fault tab. I. Values are as printed; bold marks in the paper are omitted.

FaultAE FDRAE FARLSTM-AE FDRLSTM-AE FARGAE-I FDRGAE-I FARGAE-II FDRGAE-II FARDGSTAE FDRDGSTAE FARKDGCN FDRKDGCN FARKG-GCBiGCN FDRKG-GCBiGCN FARCGSTAE FDRCGSTAE FAR
10.9980.0630.9940.0450.9930.0060.9950.0130.9950.0390.9830.0210.9980.0190.9960.097
20.9890.0310.9840.0390.9830.0190.9880.0130.9800.0000.9730.0070.9880.0190.9850.039
30.0650.0440.0550.0130.0500.0380.0600.0750.0310.0190.0630.0790.1400.0810.1790.129
40.9960.0380.9990.0390.2360.0250.4690.0130.6740.0060.9810.0430.9440.0310.9990.071
50.3740.0380.3740.0390.2700.0250.2880.0130.2750.0060.3320.0430.9990.0310.9990.071
61.0000.0190.9990.0001.0000.0001.0000.0130.9990.0000.9880.0140.9930.0000.9990.032
71.0000.0500.9990.0190.9390.0061.0000.0130.9990.0000.9840.0001.0000.0190.9990.019
80.9810.0500.9750.0060.9730.0310.9750.0250.9800.0000.9630.0430.9790.0500.9840.065
90.0790.0690.0460.0520.0580.0380.0590.1560.0230.0580.0780.1290.1060.2130.1680.051
100.5090.0190.5040.0060.4780.0000.5900.0130.7430.0260.5250.0000.5410.0130.8800.019
110.7650.0810.8660.0060.4760.0130.5130.0190.6250.0000.8740.0000.4990.0190.9560.039
120.9900.0560.9940.0260.9850.0440.9850.0750.9940.0060.9910.0290.9860.0560.9980.110
130.9540.0310.9540.0130.9430.0000.9590.0130.9490.0000.9370.0000.9430.0190.9580.045
141.0000.0630.9980.0060.9990.0001.0000.0130.9980.0320.9880.0000.9950.0190.9990.032
150.0910.0380.0760.0650.1160.0060.0750.0130.0530.0260.1320.0140.1380.0060.2190.045
160.4540.0560.3680.0840.2700.2000.5610.2310.8510.0060.3420.1790.4100.2440.9130.120
170.9450.0560.9680.0190.8510.0190.8810.0060.8990.0000.9470.0210.8140.0310.9780.039
180.9100.0810.9040.0710.8960.0130.8990.0190.9000.0000.8960.0000.9160.0250.9190.090
190.2300.0310.5030.0130.1260.0130.1490.0130.5830.0000.1280.0000.2090.0190.6790.065
200.5650.0440.6330.0000.4930.0130.6710.0000.7750.0000.5700.0000.4730.0190.8140.000
210.5060.0560.4930.0390.4160.0310.4610.0380.3750.0260.4310.0710.4700.0190.6450.068
Average0.6860.0480.6990.0290.5980.0260.6460.0370.7000.0120.6720.0330.6920.0450.8220.059
F1-score0.8090.8200.7460.7820.8220.8010.8140.896

The paper's narrative also cites Fault 11 (CGSTAE detects it with both statistics, fig. 5 and fig. 6) and the learned graphs fig. 7. These are qualitative.

Paper vs code

No official code. Searched: the paper body (its only URL is the TEP dataset site), the arXiv metadata (no comment or link), and GitHub repository search for "CGSTAE", "Xiangrui Zhang process monitoring", and "causal graph spatial-temporal autoencoder process monitoring". All returned no repositories.

Pitfalls

  • Air separation is not reported. The abstract, the start of §IV and the conclusion name a real-world air separation process, but the paper contains no data, setup or results for it §IV. Do not expect that experiment to be reproducible from the paper.
  • Average FAR is the worst of the eight methods. The text says CGSTAE keeps "low false positives" §IV-A, but its average FAR of 0.059 is the highest in tab. I. Per-fault FARs of 0.129 (fault 3) and 0.110 (fault 12) are also high.
  • The F1-score cannot be recomputed. Its formula is not stated §IV. The card's own calculation: the harmonic mean of average FDR (0.822) and 1 − average FAR (0.941) is about 0.878, not 0.896, so F1 is probably computed another way.
  • Loss scale is ambiguous. Eqs. eq. 7, eq. 10 and eq. 15 sum over every window and step with no normalising factor. The LaTeX source contains a commented out normalised version (factor 1/((N−w+1)w)) at CGSTAE.tex line 220 that the compiled paper does not use. The λ weights were set against this scale, and whether batches are summed or averaged is not stated, so the balance between the MSE and the regularisers depends on that choice.
  • Parameter shapes are inferred. Q^T K is only n × n if W_Q and W_K are n × n; the paper says only "trainable weight matrices" §III-B1. The GC weight shape, the output shape of the gates, and whether the hidden state is per variable or global are not stated, and the hidden dimension of 2 §IV-A makes the choice matter.
  • Attention details differ from the usual form. The adjacency uses a sigmoid, not a softmax, and is scaled by √w (the window length), not by a feature dimension eq. 1.
  • A^(k) is defined only at time t. The GCLSTM equations index A by step k eq. 3 eq. 5, but A is defined per window at time t eq. 1. The reading that the same matrix is used for all steps of a window is an inference.
  • Constraints on A are missing. Eqs. eq. 12 and eq. 14 take logarithms of A and 1 − A, so A must lie in (0, 1). The paper does not say how this is enforced (for example by a sigmoid or clipping) or how A is initialised. Without clipping, log(0) is possible.
  • Invariance term time index. eq. 11 uses a single A^t with no sum over windows, so which window's correlation graph is used is not stated. Whether it is detached from gradients is also not stated.
  • Graph semantics. The paper says the causal graph is a "temporal stack" of causal relationships, that each node is a time series of a variable, and that no acyclicity constraint is imposed, so loops are allowed §III-C2. Yet it indexes A as n × n over variables eq. 9. Implement it as n × n, per the equations.
  • Sparsity applies to uncertain entries only. Because the mask M is 1 on known prior entries, eq. 13 penalises only NA entries. Reversing the mask is an easy mistake.
  • Mean notation in T². eq. 16 uses h̄ in the first factor and h̄^(t) in the second. The paper does not say what data estimate the mean and covariance, or whether the covariance is regularised.
  • KDE limits are underspecified. The kernel, bandwidth and whether the 0.01 significance level applies to both T² and SPE are not stated §IV-A §III-D1.
  • Diagnosis is not evaluated. The root-cause method §III-D2 has no experiment, the threshold δ is not given, and the subgraph search procedure is described only in words.
  • Training details are missing. The optimiser, the number of epochs, the early-stopping metric and the initial state are not stated alg. 1 §IV-A. The learning rates 0.05 and 0.1 are large for common optimisers, so the optimiser choice matters.
  • Single runs, no variance. The table gives one value per cell; the number of runs, seeds and spread are not stated tab. I.
  • Naming and title mismatches. arXiv metadata gives the title as "Graph Autoencoder for Process Monitoring", the TeX \title omits "for", and the running header uses the longer CGSTAE name. Figure file names say PCCGAE and TEGAE, while the captions say GAE-I and GAE-II fig. 7; that mapping is inferred. Contribution 1 repeats "spatial-temporal encoder-decoder module" where the correlation module seems meant §I.
  • Single dataset and single fault in figures. Only the TEP is evaluated in §IV, and the figures show fault 11 only fig. 5 fig. 6.

Lineage

  • Builds on: sequence-to-sequence learning §III-B2; the causal invariance principle, cited as peters2017elements and peters2016causal §III-A; KDE control limits, cited as zhang2023process §III-D1. No arXiv ids are given in the paper.
  • Compared against: AE, LSTM-AE, GAE-I, GAE-II, DGSTAE (described in §IV), KDGCN (cited as guo2023sensor) and KG-GCBiGCN (cited as dong2025knowledge) §IV.
  • Superseded by: not stated.

Source and license

Adapted from “Graph Autoencoder for Process Monitoring” by Xiangrui Zhang (arXiv:2602.03004), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors.