GRExplainer: TGNN Explanation Framework

• The paper introduces GRExplainer, a universal framework unifying node sequence abstraction for both snapshot-based and event-based TGNN explanation.
• It leverages a two-level generative RNN and retained-matrix formalism to synthesize structurally coherent subgraph explanations efficiently.
• Empirical results on six datasets demonstrate up to 98% runtime reduction and significant gains in fidelity and sparsity over previous methods.

GRExplainer is a universal, efficient, and user-friendly post-hoc explanation framework for Temporal Graph Neural Networks (TGNNs), designed to produce interpretable and coherent explanations for both snapshot-based and event-based dynamic graphs. By unifying the abstraction of graph input as node sequences, leveraging generative recurrent neural network modeling, and emphasizing efficiency and output cohesion, GRExplainer addresses major limitations of prior TGNN explanation methods regarding generality, computational tractability, and user accessibility (Li et al., 28 Dec 2025).

1. Motivation and Core Challenges

Explainability is critical for the deployment of TGNNs in domains such as fraud detection, social recommendation, and network security due to the black-box nature of deep models and the need for robust, trustworthy decision making. Previous TGNN explainers exhibit three significant drawbacks:

• Type specificity: Most tools are tailored to either discrete-time (snapshot-based) or continuous-time (event-based) TGNNs, hindering cross-model applicability.
• Computational inefficiency: Edge-level perturbation and search-based methods (e.g., MCTS) have costs scaling at least linearly with the number of edges, making them impractical for large-scale, high-frequency graphs.
• Lack of structural cohesion and accessibility: Outputs often comprise disconnected nodes or edges and frequently require prior knowledge about model structure or desired explanation size, increasing user burden and decreasing interpretability (Li et al., 28 Dec 2025).

2. Node Sequence Unification and Retained-Matrix Formalism

GRExplainer abstracts local subgraphs as "node sequences," forming a unified feature representation:

$$S = \bigl[(v_1,t_1),\,(v_2,t_2),\,\dots,\,(v_n,t_n)\bigr]$$

• For snapshot-based inputs, nodes are ordered by breadth-first search (BFS) and timestamps $t_i$ set to a fixed timeslot index.
• For event-based (continuous-time) graphs, $t_i$ represents true interaction timestamps, and nodes are sorted temporally.

The "retained-matrix" $A_{\text{retained}}$ constrains allowed node connections for the generative process, ensuring output subgraph connectivity and limiting redundancy. Formally,

$$A_{\text{retained}}(r,s) = \begin{cases} 1, & (v_r, v_s)\in E_{\text{subgraph}} \wedge \mathrm{rank}(v_r) \leq \min\{M, \mathrm{rank}(v_s)\} \ 0, & \text{otherwise} \end{cases}$$

where $M$ is set to match the maximal BFS-layer width observed in the subgraph. This formulation is crucial for scalability and supports both graph types (Li et al., 28 Dec 2025).

3. Generative RNN Architecture for Explanation Synthesis

GRExplainer employs a two-level generative recurrent neural network (RNN) architecture:

• Graph-level RNN ($f_{\mathrm{rnn}}$): A GRU cell processes sequential adjacency (retained) matrices and computes hidden states $h^1_{i,1...}$ per time step/node.
• Edge-level RNN ($f_{\mathrm{output}}$): Another GRU, conditioned on $h^1_{i,1}$ and seeded with random noise $x_i$, predicts binary adjacency vectors $S_i \in \{0,1\}^{i-1}$.
• An MLP layer transforms each $S_i$ into edge probability logits $P_{\mathrm{edge}}^{(i)} \in [0,1]^{i-1}$, generating the subgraph explanation.

The generative semantics follow:

$$p(S_i\mid S_{<i}) = \prod_{j=1}^{i-1} p(S_{i,j} \mid S_{i,<j}, S_{<i})$$

This model automatically enforces structural connectivity and enables explanation of arbitrary TGNN predictions in a differentiable, user-free manner (i.e., without requiring manual parameter tuning) (Li et al., 28 Dec 2025).

4. Loss Function, Optimization, and Algorithmic Workflow

Training of the generative explainer uses a binary cross-entropy objective augmented with two regularization terms:

$$\mathcal{L} = \lambda_{\mathrm{size}} \sum A_{\mathrm{sub}} - \lambda_{\mathrm{weight}}|\hat y - y|$$

• The $\sum A_{\mathrm{sub}}$ term penalizes explanation size, promoting sparsity.
• The fidelity term $|\hat y - y|$ enforces that the TGNN’s output on the explanation subgraph $\hat y$ matches its prediction on the original input $y$.
• Hyperparameters $\lambda_{\mathrm{size}}$ and $\lambda_{\mathrm{weight}}$ control regularization strength.

Algorithmically, the process involves:

1. Extracting a local subgraph and node sequence $S$, building $A_{\mathrm{retained}}$.
2. Unrolling the RNN to compute edge probabilities and assemble $G_{\mathrm{sub}}$.
3. Backpropagating $\mathcal{L}$ to update network parameters.

Separate templates are specified for both snapshot- and event-based TGNNs, but the same underlying generative approach and loss apply (Li et al., 28 Dec 2025).

5. Computational Complexity and Comparative Efficiency

GRExplainer achieves per-instance time complexity $O(MN)$, where $N$ is the number of nodes in the extracted subgraph and $M$ is the maximal BFS-layer width. This is a major improvement over existing approaches (e.g., MCTS, edge perturbation) that exhibit $\Omega(|E|)$ or worse complexity. Empirical results indicate up to $16\times$ faster inference compared to the fastest prior method on the Mooc dataset and up to $98\%$ runtime reduction on event graphs, supporting application to large-scale, high-frequency temporal graphs (Li et al., 28 Dec 2025).

6. Empirical Results, Metrics, and Cohesion

Evaluation on six real-world datasets (Reddit-Binary, Bitcoin-Alpha, Bitcoin-OTC for snapshots; Reddit, Wikipedia, Mooc for event-based) with EvolveGCN, TGAT, and TGN as target TGNNs demonstrates:

• Generality: Applicability to all major TGNN architectures and graph formats.
• Fidelity and Sparsity: As measured by FID+ and AUFSC, GRExplainer provides superior explanation quality—up to $299\%$ (AUFSC, TGN) and $35\,440\%$ (FID+, TGN) over type-matched baselines.
• Cohesiveness: Explanations form connected subgraphs, consistently outscoring competitors on connectivity metrics.
• User-friendliness: No reliance on prior knowledge of model parameters or desired explanation size; explanations are generated directly via the trained model (Li et al., 28 Dec 2025).

A summary of empirical highlights:

Dataset/Model	AUFSC Gain	FID+ Gain	Speed-up
EvolveGCN	60.3%	194%	—
TGAT	283%	10,125%	Up to 98%
TGN	299%	35,440%	Up to 98%
Mooc (Event)	—	—	16× faster

7. Limitations and Prospective Directions

GRExplainer currently generates explanations at the instance level (per-prediction). Global or class-level explanation remains open. Whole-graph classification tasks may involve higher computational overhead, suggesting the value of node selection or summarization extensions. The present architecture is limited to homogeneous node and edge types; generalizing to heterogeneous dynamic graphs will likely require type-aware modeling. Extensions toward multi-task settings and other dynamic graph variations are promising directions (Li et al., 28 Dec 2025).

---

GRExplainer represents the first TGNN explanation framework general across input type and model, leveraging sequence-based unification and generative RNNs with strong fidelity, connectivity, and efficiency guarantees (Li et al., 28 Dec 2025).