Disentangled Graph Representation Based on Prototype Subgraph Neural Network

Abstract

While graph representation learning methods have been successfully applied to various graph data mining tasks, they typically couple graph information into an unstructured holistic representation. This makes it difficult to explicitly identify substructures with specific functionalities within the graph and lacks the ability to mine discriminative prototype structures that can be shared across graphs. To address these challenges, this paper proposes Prototype Subgraph Disentangled Graph Neural Network (PSDGNN). It explicitly disentangles node features into multiple independent latent factor groups through latent factor decomposition and prototype alignment mechanisms. A subgraph generator then converts these factors into factor subgraphs to model latent semantic substructures. Furthermore, learnable prototype subgraphs are introduced to represent foundational structural patterns shared across graphs. Through similarity matching and mutual information minimization objectives, the model aligns factor subgraphs with corresponding prototypes in structural semantics. Experimental results demonstrate superior performance over existing baseline methods across seven public datasets. The model provides intuitive, structured explanations for classification decisions through visualizable factor subgraphs and prototype subgraphs, significantly enhancing interpretability and generalization capabilities.

1. Introduction

Graph data, as a prevalent form of non-Euclidean data, are widely present across numerous real-world domains, including transportation networks [1], citation networks [2], biological protein interactions [3], and knowledge graphs [4]. To extract valuable insights from these complex graph datasets, graph representation learning has emerged. Its main objective is to map nodes, subgraphs, or entire graphs onto low-dimensional embedding spaces while maximally preserving their topological structure, node attributes, and rich semantic information [5]. The learned low-dimensional vector representations serve as effective features that significantly empower downstream machine learning tasks such as node classification [6], link prediction [7], and graph classification [8]. Consequently, graph representation learning has become one of the key technologies in graph data mining [9].

With recent advances in deep learning, graph neural networks (GNNs) [10] have achieved significant success in graph representation learning. GNNs aim to extend convolutional operations from conventional domains to arbitrary topologies and unordered structures, including space-based methods [11,12] and spectrum-based methods [13,14]. Currently, most GNNs are essentially flat, as they propagate node information solely through edges and obtain graph representations by globally summarizing node representations. These aggregation methods include averaging across all nodes [15], adding virtual nodes [16], or using connectedness layers [17] or convolutional layers [18]. However, many real-world graph objects (such as molecules and proteins) are composed of reusable, functionally specific substructures (e.g., functional groups and structural motifs) [19], which can be regarded as factor subgraphs. Existing methods often couple this factor information into holistic, unstructured graph-level representations during the learning process, leading to limitations in model interpretability, generalization ability, and sensitivity to discriminative substructures. Without understanding the principles behind predictions, these black-box models cannot be fully trusted or widely applied in critical fields such as medical diagnosis. Furthermore, model interpretation facilitates model debugging and error analysis.

To enhance interpretability, researchers have begun exploring subgraph-based graph neural networks. These methods can explain node or graph classification predictions from GNNs trained using different strategies, broadly falling into two categories. On one hand, some methods enhance model interpretability by integrating graph kernels with graph neural networks [20,21,22]. This is achieved by comparing a set of learnable hidden subgraphs with the input graph to obtain the final graph embedding representation. However, the size and number of hidden subgraphs require manual tuning, and they cannot detect key subgraphs of arbitrary size and shape without explicit subgraph-level annotations. On the other hand, some approaches integrate subgraph information into the message-passing mechanism of graph neural networks [23,24,25], with the main objective of mining critical subgraphs reflecting intrinsic graph properties. These methods rely on optimization decision theory to ensure interpretability of generated subgraphs [26]. These methods typically rely on information from only a single type of subgraph. However, since a graph’s properties may be influenced by more than one subgraph, it is not possible to simply compress the information in the graph into a single graph. For example, the properties of a chemical molecule may be determined by multiple functional groups [27].

Although existing subgraph-based neural networks demonstrate strong performance and enhance the interpretability of GNNs, current approaches primarily suffer from two main limitations:

(1)

Insufficient Structural Disentanglement Capability: Node features learned by mainstream GNNs and graph autoencoders are typically holistic vectors, making it difficult to explicitly decompose and identify latent substructures or factors with distinct semantics within the graph (e.g., representing different functional groups in molecular graphs or distinct community patterns in social networks). This coupling hinders the model’s deep understanding of the underlying principles of graph composition.

(2)

Lack of Prototyping and Generalization Capabilities: Many graph classification models directly classify whole-graph features without mining reusable “prototype subgraph structures” shared across graphs. This hinders models from capturing the most discriminative structural patterns at the category level, resulting in weak generalization and interpretability when data are scarce or when dealing with heterogeneous graphs.

To address these challenges, this paper proposes Prototype Subgraph Disentangled Graph Neural Network, a graph representation learning framework based on latent factor decomposition and prototype alignment. Our key idea is to explicitly disentangle learned node features into multiple independent latent factors and align these factors with a set of learnable, discriminative prototype subgraph structures. Specifically, the model first acquires node features via a graph autoencoder and then innovatively partitions these features into several independent latent factor groups based on dimensionality. Each factor group is transformed into a factor subgraph through a subgraph generator, explicitly modeling latent internal substructures. Furthermore, we introduce a set of learnable prototype subgraphs, each representing a fundamental structural pattern shared across graphs. We design a factor–prototype one-to-one correspondence and similarity matching mechanism, supplemented by a mutual information maximization objective, to encourage learned factors to align structurally and semantically with their most similar prototypes. The main contributions of this work can be summarized as follows:

(1)

We propose a factor subgraph disentangled mechanism that explicitly models and decomposes latent semantic substructures within graphs by partitioning node features into multiple groups and constructing factor subgraphs, thereby enhancing model interpretability.

(2)

We design a prototype alignment and consistency learning paradigm. By introducing learnable prototype subgraphs and aligning decomposed factors with discriminative prototype subgraphs through similarity matching and factor subgraph mutual information loss, we learn category-sensitive, generalizable subgraph structures.

(3)

Experiments on multiple public benchmark datasets demonstrate that our model not only achieves superior classification performance compared with existing baseline methods but also provides intuitive, structured explanations for classification decisions through the visual disentanglement of factor subgraphs and prototype subgraphs.

It is worth noting that recent advances in large language model (LLM)-based graph reasoning and graph-aware intelligent agents have shown emerging potential in complex graph data analysis. These methods typically rely on the accurate identification and representation of semantic substructures within graphs. However, existing LLM and agent-based approaches still face limitations in structural interpretability and the efficient modeling of crossgraph sharable prototype structures. The proposed factor subgraph disentanglement and prototype alignment mechanism in this paper is expected to provide a structured and interpretable subgraph representation paradigm for these directions, thereby complementing the graph understanding capabilities of large models and intelligent agents in terms of interpretability and structural generalization.

This paper is organized as follows: In Section 2, we review some work related to subgraph neural networks and the combination of graph kernels and GNNs. Section 3 introduces some implementation details regarding PSDGNN. In Section 4, we conduct a series of experiments to evaluate the performance of PSDGNN. Finally, we conclude the paper in Section 5.

2. Related Work

2.1. Subgraph Neural Networks

To enhance the structural discriminative capability of GNNs and understand their decision-making processes, some studies have attempted to incorporate subgraph information into the message-passing process or utilize subgraphs to construct graph representations. On one hand, incorporating subgraph information can enhance GNN interpretability. For instance, to address the issue of requiring predefined sizes and shapes in subgraph extraction, Li et al. [25] proposed a novel adaptive subgraph neural network (AdaSNN) to identify dominant subgraphs influencing prediction outcomes in graph data. AdaSNN leverages a reinforcement learning-based subgraph detection module that adaptively extracts dominant subgraphs without prior knowledge. To enhance GNN interpretability from a graph representation learning perspective, Qin et al. [28] introduced the MultiNet local subgraph convolution module. This module adaptively partitions each input graph into multiple subgraph views and applies numerous subgraph-specific, view-dependent convolution operations to constrain the propagation range of node information within the original global graph structure. This approach not only mitigates oversmoothing but also generates more discriminative local node representations. On the other hand, enhancing the expressive power of GNNs is another approach. Wang et al. [29] proposed a subgraph-aware neural network that incorporates subgraph identifiers into the original node label propagation process. This identification mechanism encodes the complete structural information of neighborhood subgraphs, enabling its expressive capability to surpass 1-WL in certain scenarios. This method indirectly enhances graph representation capabilities from a local perspective but fails to improve the global representation power of the graph. Current efforts explore prototype learning for global graph representations. For instance, Zhu et al. [30] proposed a graph neural network model for structural labeling and interaction modeling. Its key idea involves computing a set of end-to-end optimizable substructure prototypes, enabling any input graph to be projected onto these local structural representations for global characterization. Bevilacqua et al. [31] introduced a novel framework called Equivariant Subgraph Aggregation Network (EQAN). This approach enhances the expressive power of graph neural networks by representing each graph as a set of subgraphs derived from predefined policies and processing them using an appropriate equivariant architecture. Bouritsas [32] proposed a graph substructure network based on a topology-aware message-passing scheme using substructure encoding, primarily by incorporating subgraph counts into the message-passing process.

Table 1. Summary of subgraph neural networks and comparison with PSDGNN (“✓” in the table indicates that the graph embedding model possesses the corresponding capability).

Graph Embedding Model	Subgraph Awareness	Subgraph Diversity	Crossgraph Prototype Sharing	Subgraph Generation Method
[25]	✓			k-Hop subgraph
[28]	✓	✓		Parameterized learning
[29]	✓			k-Hop subgraph
[30]	✓	✓		k-Hop subgraph
[31]		✓		k-Hop subgraph
[32]		✓		Predefined subgraph
PSDGNN (ours)	✓	✓	✓	Parameterized learning

compares our method, PSDGNN, with these approaches across several dimensions, including subgraph awareness, subgraph diversity, crossgraph prototype sharing, and subgraph generation methods.

2.2. Combination of Graph Kernels and GNNs

Graph kernels and GNNs can be integrated within the same model framework. On one hand, graph kernels possess robust structural representation capabilities [33]; on the other, GNNs can learn node representations even in the absence of domain-specific expertise. Their fusion enables complementary advantages. The most widely adopted graph kernel in this field is the random walk kernel. Representative works include the following: Lei et al. [34] mapped input graphs to kernel space by comparing them against reference objects. However, their reference objects lacked structural information, potentially failing to capture graph structure. Chen et al. [35] proposed GCKN, which computes the similarity between paths starting from nodes in the graph and a set of prototype paths using a random walk kernel, and this similarity serves as the embedding representation of the nodes, enabling each node to carry information about local graph substructures. However, GCKN employs random walk sampling for node paths, introducing randomness. In contrast, the model presented here generates subgraphs based on the original graph information, enabling the capture of richer topological structures. Nikolentzos et al. [21] introduced RWGNN, which achieves differentiability of the random walk kernel through a direct product graph. This method calculates the similarity between a batch of trainable hidden graphs and the input graph as the final graph representation, enhancing model transparency. However, it only supports single-layer models and lacks effective representation of local information. To explore further integration of graph kernels with GNNs, Cosmo et al. [36] extended other graph kernels into this hidden graph framework. Subgraphs are constructed by sampling node neighborhoods, and graph kernels compute the similarity between these subgraphs and the hidden graph to update node embeddings. However, the non-differentiability of some graph kernels significantly increases the computational cost of training hidden graphs, limiting their application on large-scale graphs.

3. Methodology

The proposed PSDGNN framework, as shown in Figure 1, provides a brief introduction to the model architecture.

Problem Formulation. A graph can be represented as $G=(V,X,A)$, where $V=\{v_1,v_2,\cdots ,v_N\}$ is a set of nodes and $X\in R^{N\times d}$ denotes the node feature matrix. The number of nodes is denoted by N, and the dimension of the node features is d. A denotes the adjacency matrix of the graph. The graphs studied in this paper are all unweighted undirected graphs. For the graph supervised classification task, given a dataset $(\mathcal{G},\mathcal{Y})=\{(G_1,y_1),(G_2,y_2),\cdots ,(G_n,y_n)\}$, where $y_i\in \mathcal{Y}$ denotes the label of $G_i\in \mathcal{G}$, the objective of the graph classification task is to learn the mapping function from the graph $\mathcal{G}$ to the label $\mathcal{Y}$. This paper employs one-hot encoding to process discrete labels. As an illustration, the three labels $1,2,3$ correspond to the three-dimensional vectors $(1,0,0)$, $(0,1,0)$, and $(0,0,1)$, respectively. In addition, we summarize the main notations in

Table 2. Main notations in this paper.

Notation	Definition
G	Graph.
$V,X$	Node set and node attribute matrix.
A	Adjacent matrix.
$\mathcal{G},\mathcal{Y}$	Graph dataset and its label.
A	Adjacent matrix.
$Z^{\left(l\right)},W^{(l-1)}$	Output of the l-th encoder layer and weight matrix of the $l-1$-th layer.
$A_c,X_c$	Reconstructed adjacency matrix and node attribute matrix.
$z_m,p^{\left(m\right)}$	The m-th latent factor and attention mask matrix.
$\tau ,c_l$	Temperature parameter in concrete distribution and Gumbel noise term.
$S{G}_m,P{G}_m$	The m-th factor subgraph and prototype subgraph.
${G_m}^{\times },{A_m}^{\times }$	Direct product graph of $S{G}_m$ and $P{G}_m$ and its adjacency matrix.
$M,P$	Number of prototype graphs and path length of random walk.
${\mathcal{L}}_{GraphVAE},{\mathcal{L}}_{factor},{\mathcal{L}}_{CE}$	GraphVAE reconstruction loss, factor mutual information loss and factor mutual information loss.
$\alpha ,\beta$	Weight hyperparameter for ${\mathcal{L}}_{GraphVAE}$ and ${\mathcal{L}}_{factor}$.

.

3.1. Representation Disentangled Module

Given a graph $g=(V,X,A)$, we use a graph variational autoencoder (GraphVAE) to learn m disentangled latent factors $Z^{\left(l\right)}=\{z_1,z_2,\cdots z_m\}$, where $z_m\in R^{n\times \tilde{d}}$, $\tilde{d}=d\left(l\right)/m$ and $d\left(l\right)$ denotes the dimension of the lth hidden layer. These latent factors originate from the grouping of node features. Our improved GraphVAE employs a basic graph convolutional network (GCN) as the graph encoder, for which the output of the l-th layer is given by

$$Z^{\left(l\right)}=\sigma \left(\tilde{A}{Z}^{(l-1)}{W}^{(l-1)}\right)$$

(1)

where A denotes the normalized adjacency matrix; $\tilde{A}=A+I$, where I is the identity matrix; D is the diagonal matrix of node degrees; and $\sigma$ is the Sigmoid activation function.

In the decoder of the improved GraphVAE, we employ separate heads: a multi-layer perceptron for reconstructing X and a linear inner-product decoder for recovering A. Specifically, we define the graph reconstruction as

$$A_c=\sigma \left(Z^{\left(l\right)}{\left(Z^{\left(l\right)}\right)}^T\right)$$

(2)

$$X_c=MLP\left(Z^{\left(l\right)}\right)$$

(3)

where $A_c$ is the reconstructed adjacency matrix and $X_c$ denotes the reconstructed node features. Our multi-head GraphVAE aims to minimize reconstruction error while maximizing the compression of latent variables Z. The objective is formulated as follows:

$$\begin{array}{c}{\mathcal{L}}_{GraphVAE}=E\left[\Vert X-X_{\mathcal{C}}{\Vert }_F\right]+E\left[\Vert A-A_{\mathcal{C}}{\Vert }_F\right]\\ -E\left[D_{KL}\left[q\left(Z\right|A,X)\Vert p(Z)\right]\right]\end{array}$$

(4)

where ${∥·∥}_F$ denotes the Frobenius norm and $q(Z\left|A\right.,X)$ represents the graph encoder. Furthermore, to ensure independence among latent factors, for graph representations, the mutual information (MI) between them reaches a minimum value of 0 when $p(z_i,z_j)=p\left(z_i\right)p\left(z_j\right)$, indicating that $z_i$ and $z_j$ are mutually independent. Thus, minimizing the MI between them encourages factor representations to learn information from different aspects of the graph. Recently, several MI upper bounds [37] have been introduced to minimize MI. However, estimating these MI upper bounds across m graph representations requires $m(m-1)$ estimations, leading to significantly higher computational costs, especially when m is large. To mitigate this issue, since orthogonality is a specific instance of linear independence, we relax the orthogonality constraint for minimizing MI. This approach has also been proven effective in many previous studies [38]. The factor independence loss is defined as follows:

$${\mathcal{L}}_{factor}=\left|Z^{\left(l\right)}{\left(Z^{\left(l\right)}\right)}^T-I\right|$$

(5)

where $\left|·\right|$ denotes the L1 norm and I represents the identity matrix. The complete algorithm of the representation disentangling module is shown in Algorithm 1.

Algorithm 1 Representation disentangling module of PSDGNN

1: Input: Graph $G=(V,X,A)$, number of latent factors m, number of encoder layers L   2: Output: Latent factors $Z^{\left(L_{enc}\right)}=\{z_1,z_2,\dots ,z_m\}$, reconstructed adjacency $A_c$, reconstructed features $X_c$   3: Compute normalized adjacency matrix $\tilde{A}\leftarrow A+I$   4: Initialize $Z^{\left(0\right)}\leftarrow X$   5: for $l=1$ to L do   6:     GCN encoding using Equation (1)   7: end for   8: Set $Z\leftarrow Z^{\left(L_{enc}\right)}\in {\mathbb{R}}^{N\times d\left(l\right)}$   9: Split Z into m equal parts along the feature dimension: $d\left(l\right)=m\times \tilde{d}$ 10: for $i=1$ to m do 11:     $z_i\leftarrow Z[:,(i-1)·\tilde{d}+1:i·\tilde{d}]$                                                                                        ▹i-th latent factor 12: end for 13: Reconstruct adjacency matrix using Equation (2) 14: Reconstruct node features using Equation (3) 15: Compute ${\mathcal{L}}_{GraphVAE}$ Equation (4) 16: Compute ${\mathcal{L}}_{factor}$ using Equation (5)

3.2. Factor Subgraph Generation Module

The workflow of the factor subgraph generation module is illustrated in Figure 2. Based on the previously obtained latent factors, we compute the probabilities for each edge in the factor subgraph. First, we learn to compute the inner product of each factor subgraph, where each entry represents an edge selection probability. Then, using the Sigmoid function, we obtain the attention mask $p^{\left(m\right)}\in R^{n\times n}$ for the m-th edge in the factor subgraph, ensuring that ${p_{ij}}^{\left(m\right)}\in [0,1]$, where ${p_{ij}}^{\left(m\right)}$ denotes the probability of selecting the edge between node $v_i$ and node $v_j$. $P\left(m\right)$ is calculated as follows:

$$p^{\left(m\right)}=\sigma \left(z_m{z_m}^T\right)$$

(6)

Subsequently, we binarize $p^{\left(m\right)}$ to obtain the edge assignment $S^{\left(m\right)}\in {\{0,1\}}^{n\times n}$. To ensure that the gradient ${p_{ij}}^{\left(m\right)}$ is computable, we employ the Gumbel–Softmax reparameterization trick [39] to update the edge assignment. However, if we directly apply the Gumbel–Softmax function to $S^{\left(m\right)}$, we can only select an edge from every n consecutive edges. To ensure that sufficient edges are continuous, we reshape $p^{\left(m\right)}$ into an L-dimensional matrix and then apply binarization. We utilize the Gumbel–Softmax method to generate the edge assignment $S^{\left(m\right)}$. This guarantees that at least an edge is selected from every L continuous edges. Here, the l-th edge sample probability of the L-dimensional sample vector is defined as

$${{\widehat{p}}_l}^{\left(m\right)}={\displaystyle \frac{exp((log{p_l}^{\left(m\right)}+c_l)/\tau )}{{\sum }_{i=1}^{L}exp((log{p_i}^{\left(m\right)}+c_i)/\tau )}}$$

(7)

$$c_l=-log(-log{U}_l),U_l=Uniform(0,1)$$

(8)

where $\tau$ is the temperature of the concrete distribution, ${p_l}^{\left(m\right)}$ denotes the edge selection probability for the l-th group after partitioning, ${{\widehat{p}}_l}^{\left(m\right)}$ is the sample probability, and $c_l$ is generated from the $Gumbel(0,1)$ distribution. Thus, based on this process, L can determine the size of each potential subgraph $SG$, and we can retain $n\times n/k$ edges. Then, we transform $S^{\left(m\right)}$ into an $n\times n$ matrix. Finally, extract the factor subgraph $S{G}_m$ via $A_{S{G}_m}=A\odot S^{\left(m\right)}$, whose node feature is $X_{S{G}_m}=MLP\left(Z_m\right)$, where ⊙ denotes element-wise multiplication. A and $A_{S{G}_m}$ represent the adjacency matrices of the input graph and the m-th factor subgraph, respectively. This yields the entire set of potential factor subgraphs $SG=(S{G}_1,S{G}_2,\cdots S{G}_m)$.

3.3. Prototype Kernel Embedding Module

Recent prototype-based GNNs implicitly represent prototype subgraphs by defining a set of learnable graph embedding vectors, which compromises their inherent interpretability. Therefore, we aim to explicitly define prototype subgraphs. To achieve this, we propose using a random walk graph kernel to explicitly explore graph topology. Our prototype kernel embedding module introduces learnable prototype subgraphs parameterized by trainable adjacency matrices. Formally, our module comprises a set $PG=(P{G}_1,P{G}_2,\cdots P{G}_M)$ of prototype subgraphs of equal size for each factor subgraph $P{G}_m=(A_{P{G}_m},X_{P{G}_m})$. Each prototype subgraph is parameterized as a less-parametric undirected graph, which corresponds one-to-one with the previously obtained factor subgraph via subscripting. These prototype subgraphs are expected to learn prototype structures that aid in distinguishing available classes. Inspired by the fact that random walk kernels quantify similarity between two graphs based on the number of common walks, we compare each factor subgraph with its corresponding prototype subgraph equipped with differentiable functions derived from random walk kernels.

Specifically, given a factor subgraph $S{G}_m=(A_{S{G}_m},X_{S{G}_m})$ and its corresponding prototype subgraph $P{G}_m=(A_{P{G}_m},X_{P{G}_m})$, their direct product graph ${G_m}^{\times }$ has an adjacency matrix ${A_m}^{\times }=A_{S{G}_m}\otimes A_{P{G}_m}$, where ⊗ denotes the Kronecker product between two matrices. It can be observed that a random walk on ${G_m}^{\times }$ can be interpreted as a simultaneous walk on graphs $S{G}_m$ and $P{G}_m$ [40]. Considering that the traditional random walk kernel computes all matched walk pairs between two graphs, the number of matched walks when traversing nodes on both $S_{G_m}$ and $P_{G_m}$ is equivalent to the number of matched walks in the adjacency matrix of ${G_m}^{\times }$, denoted ${A_m}^{\times }$ of ${G_m}^{\times }$, when traversing nodes on $S{G}_m$ and $P{G}_m$ simultaneously. Therefore, the random walk kernel for P steps between $S{G}_m$ and P that computes all simultaneous random walks is defined as

$$K_m^{\left(P\right)}(S{G}_m,P{G}_m)={\displaystyle \sum _{p=0}^P}{w}_p{u}^T{A_m}^{\times }u$$

(9)

where $u=vec\left(X_{S{G}_m}{X_{P{G}_m}}^T\right)$ denotes the one-dimensional vector resulting from unfolding the similarity matrix of node features between $S{G}_m$ and $P{G}_m$ into a vector. $w_p$ denotes the positive weight. To simplify computation, we only calculate the number of steps with a common length of P on the two comparison graphs:

$$K_m^{\left(P\right)}(S{G}_m,P{G}_m)=u^T{A_m}^{\times }u$$

(10)

Then, given a set of factor subgraphs $\mathrm{SG}=(S{G}_1,S{G}_2,\cdots S{G}_m)$ and a set of prototype subgraphs $PG=(P{G}_1,P{G}_2,\cdots P{G}_M)$, we calculate the similarity between the factor subgraph and the atomic graph according to the subscript correspondence:

$$K_m=K^{\left(p\right)}(S{G}_m,P{G}_m)$$

(11)

Unlike traditional graph kernels where both graphs are fixed, our scenario requires the prototype graph to be learnable. The kernel computes a joint similarity that integrates two complementary types:

(1)

Walk-based topological similarity. Captured by the direct product graph adjacency matrix ${A_m}^{\times }=A_{S{G}_m}\otimes A_{P{G}_m}$, where $A_{P{G}_m}$ is learnable. This term measures structural alignment by counting common walk sequences of length P.

(2)

Feature-guided similarity. Encoded by $u=vec\left(X_{S{G}_m}{X_{P{G}_m}}^T\right)$, where $X_{P{G}_m}$ is also learnable. This term weights each walk by the similarity of node features between the two graphs.

The final graph embedding representation is obtained as $H_G=[K_1,K_2,\cdots K_m]\in R^m$ and ultimately implemented through a multi-layer perceptron to accomplish the graph classification task.

3.4. Model Optimization

The final component of PSDGNN takes the similarity representation of factor subgraphs and atomic graphs as input, outputting the predicted probability for each class: $\widehat{y}=f\left(H_G\right)$, where the function f is an MLP followed by a Softmax layer. For optimization, cross-entropy loss is employed to measure classification loss:

$${\mathcal{L}}_{CE}={\displaystyle \frac{1}{N}}\sum _i-[y_{i}log\left({\widehat{y}}_i\right)+(1-y_i)log(1-{\widehat{y}}_i)]$$

(12)

where N denotes the number of graphs and $y_i$ represents true label.

Combined with the previous image encoder loss and factor mutual information loss, the final optimization objective of PSDGNN is

$$\mathcal{L}={\mathcal{L}}_{CE}+\alpha {\mathcal{L}}_{GraphVAE}+\beta {\mathcal{L}}_{factor}$$

(13)

where $\alpha$ and $\beta$ are hyperparameters that adjust the weights of the loss function. The complete algorithm of PSDGNN is shown in Algorithm 2.

Algorithm 2 Training process of PSDGNN

Input: $G=\{g_1,g_2,\cdots ,g_n\}$; $g=(V,E,X)$; Number of factor subgraphs m; Number of layers l; Number of epochs $E_{max}$ Output: Predicted label $\widehat{Y}\in R^C$ of the graph   1: Initialize the adjacency matrix $A_{P{G}_m}$ and feature matrix $X_{P{G}_m}$ of the prototype subgraph.   2: Encoding node features using Equation (1) to obtain $Z^l$   3: Decompose $Z^l$ into m latent factors based on the feature dimension   4: Reconstruct the graph using Equations (2) and (3).   5: for  $t=1,2,\cdots ,E_{max}$  do   6:     for $i=1,2,\cdots ,m$ do   7:         Calculate the edge mask matrix $p^{\left(i\right)}$ using Equation (6)   8:         Reshape the edge mask matrix into an L-dimensional matrix   9:         Select $n\times n/k$ edges using Equations (7) and (8) 10:         The factor subgraph is generated by $A_{S{G}_i}=A\odot S^{\left(i\right)}$                        ▹ Generate factor subgraph via element-wise masking 11:         The similarity $K_i$ between factor subgraph ${SG}_m$ and prototype subgraph $P{G}_m$ is calculated by Equation (11)                                                                                                                               ▹ Concatenate similarities into graph embedding 12:     end for 13:     Generate predicted graph label $\widehat{Y}$ for the graph using MLP and Softmax. 14:     Calculate the overall loss $\mathcal{L}$ by Equation (13) 15:     Update parameters by descending $\mathcal{L}$                                                              ▹ End-to-end optimization via backpropagation 16: end for

3.5. Complexity Analysis

In this section, we will analyze the computational complexity and consumption of PSDGNN. The overall time complexity and memory complexity of one graph of PSDGNN are respectively $O(LN\overline{d}d+m{N}^2(P+\tilde{d}))$ and $O(Nd+m{N}^2)$, where N denotes the number of nodes, $\overline{d}$ is the average node degree, d is the hidden dimension and m is the number of factors. Specifically, the time complexity and memory complexity of the representation disentangled module are $O(LN\overline{d}d+N^{2}d)$ and $O(Nd+N^2)$. The factor subgraph generation module takes $O\left(m{N}^2\tilde{d}\right)$ and $O\left(m{N}^2\right)$ in terms of time complexity and memory complexity, respectively. For the prototype kernel embedding module, time complexity and memory complexity are $O\left(m{N}^{2}P\right)$ and $O\left(m{N}^2\right)$.

3.6. Discussion

Identifiability of latent factor decomposition. A limitation of the proposed factor decomposition is that without additional constraints, the decomposition of node features into m latent factors $Z^{\left(l\right)}=\{z_1,z_2,\cdots z_m\}$ is not strictly identifiable. In general, any invertible transformation applied to the latent factors can produce an equivalent reconstruction, a common challenge in disentangled representation learning. To address this from a practical perspective, PSDGNN incorporates two mechanisms that promote factor uniqueness and disentanglement:

(1)

Factor mutual information loss (${\mathcal{L}}_{factor}$). Following prior work on mutual information-based disentanglement [37,38], we minimize the mutual information among different factor subgraphs. This encourages each factor to capture distinct, non-redundant structural patterns, reducing the degrees of freedom in the decomposition space and promoting a form of practical identifiability.

(2)

One-to-one prototype alignment. Each factor subgraph $S{G}_m$ is forced to align with a dedicated learnable prototype subgraph $P{G}_m$ through the random walk kernel similarity. This additional supervision signal anchors each factor to a specific structural prototype, further constraining the decomposition space. While the prototype–factor mapping is one-to-one, overlapping substructures in the original graph are not discarded. Instead, they are captured through the composition of multiple prototypes in the later factor aggregation stage. For example, in a molecular graph with overlapping functional groups (e.g., a benzene ring fused with a pyrrole ring), different prototypes activate for different subregions, and the factor representation aggregates these prototype activations to form a holistic representation. The one-to-one constraint applies to the mapping definition, not to the activation pattern—a single node or edge can contribute to multiple prototypes, and multiple prototypes can jointly represent overlapping semantics.

4. Experiments

In this section, we first describe the experimental setup and present graph classification experiments conducted on seven real-world benchmark datasets to evaluate the performance of the proposed method. Next, we explore the stability and convergence of model training. Subsequently, ablation experiments are performed to demonstrate the effectiveness of the various modules in our framework, and parameter sensitivity experiments are carried out to empirically examine the influence of different hyperparameters. Finally, we present a visualization analysis to investigate PSDGNN’s encoding variability and interpretability.

4.1. Experiments on Benchmark Datasets

Datasets. The seven benchmark datasets used in this study are among the most commonly used public datasets in graph classification. These datasets exhibit significant diversity in graph size, node feature richness, and number of classes, enabling comprehensive evaluation of PSDGNN’s generalization ability and robustness across different scenarios, and they are widely recognized as standard evaluation benchmarks in the community, covering three representative domains, chemical compounds, biological proteins, and social networks, as detailed in

Table 3. Statistic of datasets.

Field	Dataset	Number	Class	Avg. Nodes	Node Features
Chemical compounds	MUTAG	188	2	17	7
	NCI1	4110	2	29	37
Biological proteins	PTC	344	2	14	19
	DD	1178	2	284	18
	PROTEINS	1113	2	39	3
Social networks	IMDB-B	1000	2	19	-
	IMDB-M	1500	3	13	-

. Seven benchmark datasets were utilized in the experiments. For the chemical compound datasets, MUTAG [19], NCI1 [41], and PTC [42] were selected. MUTAG classifies nitro-containing molecules as mutagenic or non-mutagenic aromatic or heteroaromatic compounds. NCI1 screens compounds for activity against non-small-cell lung cancer, while PTC predicts carcinogenicity in rodents. For biological protein datasets, PROTEINS [43] and DD [44] were selected, both designed for enzyme classification tasks. The PROTEINS and DD datasets were used to determine whether protein molecules belong to the enzyme class. For the social network dataset, IMDB-B [45] and IMDB-M [45] were selected. The IMDB datasets originate from the Internet Movie Database and represent movie collaboration networks. This task involves classifying actor subgraphs into corresponding movie genres.

Baseline. This paper selects several representative benchmark methods for graph classification tasks, including graph kernels, graph neural networks, and hybrid approaches combining both, to demonstrate the superior performance of PSDGNN. Traditional graph kernel methods include WL kernel [46], RetGK [47], AEGK [48], and DSP-I [49], while graph neural network models include GIN [10], SLIM [30], AdaSNN [25], SEKGIN [50], and HA-SCN [51]. Recently proposed hybrid approaches are KerGNN [22], GKNN [36], and GCKSVM [52]. To ensure experimental fairness, comparisons are conducted under identical hardware configurations and default parameter settings.

Parameter settings. The model learning rate is set to 0.01 by default, with a batch size of 32 graphs and 400 iterations. Cross-validation is performed 10 times to estimate the model’s classification accuracy. The number of factor subgraphs is set to 16, the path length for the random walk kernel is 3, and graph pooling defaults to summation. When processing the dataset, the social network dataset uses node degree as the node feature.

Experimental environment. All experiments in this paper are conducted using an NVIDIA RTX 4090D GPU with 24GB of VRAM. The operating system is Ubuntu 16.04.1 LTS 64-bit, and the CPU model is Xeon^® Platinum 8481C. Code implementation utilizes Python 3.10, with the deep learning framework being PyTorch 2.2.1.

To evaluate the performance of PSDGNN, its graph classification accuracy is compared with 10 benchmark methods across seven graph datasets. The results are presented in

Table 4. Summary of experimental results: “Classification accuracy in each dataset”.

Method	MUTAG	PTC	PROTEINS	DD	NCI1	IMDB-B	IMDB-M
WL	90.4 ± 5.7	59.9 ± 4.3	75.0 ± 3.1	79.4 ± 0.3	86.0 ± 1.8	73.8 ± 3.9	50.9 ± 3.8
RetGK	90.3 ± 1.1	62.5 ± 1.6	75.8 ± 0.6	81.6 ± 0.3	80.4 ± 0.2	71.9 ± 1.0	47.7 ± 0.3
AEGK	90.4 ± 0.6	59.4 ± 0.4	75.1 ± 0.3	77.8 ± 0.3	-	-	-
DSP-I	91.0 ± 7.5	67.5.9 ± 7.2	76.8 ± 4.3	-	86.2 ± 1.7	76.0 ± 4.7	52.1 ± 2.7
GIN	89.4 ± 5.6	64.6 ± 7.0	76.2 ± 2.8	77.6 ± 2.9	82.7 ± 1.7	75.1 ± 5.1	52.3 ± 2.8
SLIM	93.3 ± 3.3	72.4 ± 6.9	77.5 ± 4.3	79.2 ± 2.6	80.5 ± 2.0	77.2 ± 2.1	53.4 ± 4.0
AdaSNN	87.2 ± 5.0	60.2 ± 6.4	76.5 ± 2.6	-	-	74.2 ± 2.5	51.9 ± 4.7
SEKGIN	96.9 ± 3.6	75.7 ± 6.4	81.7 ± 2.5	-	-	80.3 ± 3.2	56.1 ± 3.0
HA-SCN	90.1 ± 1.4	63.2 ± 1.5	76.3 ± 0.3	79.3 ± 0.4	-	73.2 ± 0.4	49.9 ± 0.6
KerGNN	88.7 ± 2.1	64.3 ± 3.1	76.5 ± 3.9	78.9 ± 3.5	82.8 ± 1.8	74.4 ± 4.3	51.6 ± 3.1
GCKSVM	88.7 ± 7.6	67.7 ± 5.4	74.5 ± 3.9	-	-	75.4 ± 2.1	53.9 ± 2.8
GKNN	85.7 ± 2.7	60.1 ± 1.9	75.3 ± 1.1	76.8 ± 4.3	71.5 ± 1.2	69.9 ± 1.4	53.5 ± 2.2
PSDGNN	94.6 ± 3.2	76.3 ± 2.9	83.5 ± 3.2	84.9 ± 1.5	86.4 ± 3.2	81.4 ± 4.3	56.3 ± 3.5

, where the best result on each dataset is highlighted in bold, the second-best result is underlined, and “-” indicates that results for that method could not be obtained on that dataset. As shown in Table 2, PSDGNN demonstrates significant performance advantages on six datasets, except MUTAG. Compared with graph kernel-based methods (e.g., WL, RetGK, and AEGK), PSDGNN achieves notably higher accuracy, confirming its robust subgraph structure modeling capability. SEKGCN, a subgraph-based graph neural network, achieves the second-best overall performance among all benchmark methods, underscoring the importance of subgraph encoding. PSDGNN outperforms SEKGCN because it leverages community subgraph information, whereas SEKGCN relies on fixed neighborhood subgraphs. Compared with kernel-based methods like GKNN, KerGIN, and GCKSVM, PSDGNN also demonstrates superior classification accuracy. It achieves average accuracy improvements of 8% and 10% on MUTAG and PTC, respectively, indicating that incorporating community subgraph information into graph embedding representations can enhance the performance of graph neural networks. Figure 3 shows the results of PSDGNN across ten-fold cross-validation on seven datasets.

4.2. Ablation Analysis

Module Ablation: To investigate the impact of individual modules on performance, we also conducted ablation studies to evaluate the potential contributions of various components within PSDGNN. Specifically, we compared three variants of PSDGNN: the original model w/o GraphVAE (PSDGNN without the modified GraphVAE), w/o PG (PSDGNN without the prototype subgraph module and prototype kernel embedding module), and GNN (PSDGNN without the modified GraphVAE, with the factor subgraph generation module and the prototype kernel embedding module). Notably, the w/o GraphVAE variant omits the decoding component and model optimization of the enhanced GraphVAE algorithm. As shown in Figure 4a, our ablation study reveals that PSDGNN consistently outperforms the model w/o PG across all datasets, which suggests that prototype subgraphs help models capture typical features relevant to classification. Furthermore, PSDGNN outperforms the model w/o GraphVAE. This may be because GraphVAE is capable of learning meaningful, interpretable latent representations of graphs.

Loss Ablation: To investigate the impact of various loss functions on performance, an ablation study was conducted. Specifically, we compared two variants of PSDGNN: the original model w/o GraphVAE Loss (removing the GraphVAE loss function), w/o Factor Loss (removing the factor mutual information loss function), and GNN (PSDGNN without GraphVAE modifications, retaining the original subgraph module and the original kernel embedding module). The results of the ablation study are shown in Figure 4b. Compared with the original model (PSDGNN), the classification accuracy of the variant w/o GraphVAE Loss decreased by approximately 2%. This is because GraphVAE loss helps preserve critical structural information in the input graph, preventing information loss. Compared with the original model (PSDGNN), the version w/o Factor Loss resulted in a classification accuracy decrease of approximately 1%. This is because factor loss enforces independence between different latent variables, ensuring that each factor subgraph corresponds to a unique and non-redundant connectivity pattern.

Effect of Independence Constraints on Graph Classification: In

Table 5. Classification accuracy of different independence constraint methods on seven graph classification benchmarks (bold: best; underlined: runner-up).

Independence Constraint Method	MUTAG	PTC	PROTEINS	DD	NCI1	IMDB-B	IMDB-M
HSIC	92.9 ± 4.1	73.4 ± 3.4	79.8 ± 2.7	82.3 ± 3.2	85.3 ± 2.9	79.8 ± 4.2	53.6 ± 3.1
Distance Correlation	89.1 ± 2.5	69.2 ± 1.5	75.3 ± 0.3	79.5 ± 2.7	83.4 ± 3.3	77.3 ± 2.8	52.9 ± 3.6
Factor MI	94.6 ± 3.2	76.3 ± 2.9	83.5 ± 3.2	84.9 ± 1.5	86.4 ± 3.2	81.4 ± 4.3	56.3 ± 3.5

, we evaluate three representative paradigms for feature independence constraints: HSIC (kernel-based), distance correlation (distance-based), and factor mutual information (Factor MI) (information-theoretic). Factor MI consistently achieves the best or runner-up performance across all seven datasets, demonstrating the superiority of information-theoretic independence constraints for graph-structured data. HSIC performs competitively on MUTAG (92.9%) and PTC (73.4%), ranking second in most cases, validating kernel-based methods as strong baselines, while distance correlation yields relatively conservative results, suggesting that distance-based independence measures may be less sensitive to structural dependencies in graphs. Based on these results, we adopt Factor MI as the default independence constraint. Although alternative disentanglement strategies such as contrastive objectives (e.g., InfoNCE) or independence-promoting regularizers (e.g., Total Correlation penalty) show potential, the consistent and dominant performance of Factor MI across the seven benchmarks justifies its selection. Exploring these alternatives in graph representation learning remains an interesting direction for future work.

Comparison with Attention-Based Soft Matching. To validate the design choice of strict prototype alignment, we implemented an alternative approach in which each factor graph is matched with all prototype graphs via an attention mechanism. As shown in Figure 5, strict alignment consistently outperforms the attention mechanism variant across all seven datasets, with an average improvement of 2–4%. We attribute this to two key reasons. First, strict alignment maintains a clear one-to-one correspondence between factor subgraphs and prototype subgraphs, which is crucial to decoupling—each factor is forced to align with a distinct structural prototype, preventing the attention mechanism from blending multiple prototypes into a single factor, thereby preserving interpretability at the factor level. Second, attention-based variants introduce additional parameters and optimization complexity, which may lead to overfitting, particularly on smaller datasets such as MUTAG and PTC, where the performance gap is most pronounced. Therefore, we retain strict prototype alignment as the default mechanism in our framework.

4.3. Parameter Sensitivity Analysis

Number of Factor Subgraphs M: When constructing factor subgraphs, the hyperparameter M is introduced to control the number of feature groupings for nodes. To achieve optimal model performance, experiments were conducted with different values of M. As shown in Figure 6, graph classification experiments were performed with M ranging from 2 to 12 in increments of 0.2. Experimental results indicate the following: On the MUTAG, PROTEINS, IMDB-B, and IMDB-M datasets, classification accuracy peaks when M is approximately 4, while on the PTC and NCI1 datasets, the highest accuracy is achieved when M is approximately 6. In summary, the optimal range for the parameter is between 4 and 8. This is primarily because the features of nodes in different datasets contain varying amounts of information; an excessively large value of M introduces noise and weakens the discriminative power of the factor subgraph, while an excessively small value of M prevents the model from fully capturing factor subgraphs at different levels, thereby reducing the representational capacity of the factor subgraph.

Number of Graph Encoder Layers: To investigate the impact of encoder layer count on experimental performance, we examined how graph classification accuracy evolves across training epochs for PSDGNN’s GraphVAE module with varying graph encoder layers across six datasets. As shown in Figure 7, with layer sizes ranging from 1 to 4, across all datasets, the best performance was achieved with two layers. When the number of layers exceeded two, the accuracy of graph classification began to decline. This is determined by the graph structure: when the number of layers is excessive, the aggregated information from the neighborhoods of individual nodes becomes too similar, leading to a decrease in the model’s classification accuracy. This phenomenon, commonly observed in message-passing neural networks, is known as the oversmoothing problem. However, the introduction of the factor subgraph mutual information loss function into this model confers a degree of resistance to oversmoothing. Consequently, while the number of layers increases, the decline in accuracy is less pronounced.

Weighting Hyperparameters in Loss Functions: During model optimization, this paper introduces hyperparameters $\alpha$ and $\beta$ representing the weights for GraphVAE loss and factor mutual information loss, respectively. This experiment investigates how varying these hyperparameters affects classification accuracy across three graph classification datasets. As shown in Figure 8, on the MUTAG dataset, the highest classification accuracy is achieved when $\alpha =0.6$ and $\beta =0.2$. On the DD dataset, the highest classification accuracy is achieved when $\alpha =0.2$ and $\beta =1.0$. On the Pubmed dataset, the highest classification accuracy is achieved when $\alpha$ is set to 0.2 and $\beta$ is set to 0.6. This indicates that the two loss functions can provide PSDGNN with self-supervised information, thereby enabling the subgraph representation to distinguish between different graph instances. The proposed subgraph disentangled mechanism can extract different key information from various types of datasets through these two loss functions.

The Path Length P of the Random Walk Kernel: For the prototype kernel embedding module, we utilize random walk kernels to compute the similarity between factor subgraphs and prototype subgraphs. To investigate the impact of path length P for different random walk kernels on model performance, we evaluated PSDGNN with varying path lengths P across six datasets. As shown in Figure 9, on the MUTAG, PTC, PROTEINS, and NCI1 datasets, PSDGNN performs best when $P=2$ or $P=3$, whereas on the IMDB-B and IMDB-M datasets, PSDGNN performs best when $P=4$. This suggests that the optimal path length in social networks has a higher order than that in bioinformatics graphs. It is reasonable because the diameters of most of the basic functional blocks in molecules are around 2 to 3 and long-range dependency also plays an important role in social networks.

The Size of the Prototype Subgraph: In our framework, each learnable prototype subgraph is parameterized by a trainable adjacency matrix and a trainable feature matrix, with the prototype subgraph size matching that of the factor subgraph. To investigate the impact of different prototype subgraph sizes on model performance, we conducted experiments with the number of prototype subgraphs ranging from 2 to 16. As shown in Figure 10, the optimal prototype size varies substantially across datasets, reflecting differences in graph complexity and structural diversity. For small molecular graphs such as MUTAG and PTC, which have average node counts of 17 and 19 respectively, the best performance is achieved with a prototype size of 4. Smaller prototypes (e.g., size 2) lack sufficient capacity to capture discriminative functional groups such as nitro groups or aromatic rings, while larger prototypes (e.g., size 8 or above) introduce spurious structures that lead to overfitting. For medium-sized graphs including PROTEINS and IMDB-B, which have average node counts of 20 to 25, the optimal prototype size increases to 6. This larger capacity allows the model to capture more complex structural motifs, such as secondary protein structures or dense collaboration communities. For the largest datasets in our study—DD, NCI1, and IMDB-M—where average node counts range from 30 to nearly 70, the optimal prototype size ranges from 8 to 10. These larger prototypes are necessary to encode the diverse and elaborate topological patterns present in large molecular compounds, protein enzymes, and multi-genre movie collaboration networks. Notably, when the prototype size is increased beyond 12, performance degrades consistently across all datasets due to increased model complexity and sparsity in the similarity matching between factor subgraphs and prototypes. Conversely, when the prototype size is too small (e.g., size 2), the prototypes lack sufficient expressive power to capture the distinguishing substructures of each class.

4.4. Visualization Analysis

To assess the discriminative power of PSDGNN, we use t-SNE to project the high-dimensional graph embeddings into 2D space. As shown in Figure 11, the embeddings of different classes form well-separated clusters on MUTAG, PROTEINS, and DD, indicating that PSDGNN successfully learns class-discriminative representations.

To illustrate the disentanglement process more clearly, we present an example of the factor subgraph generated by PSDGNN. Figure 12 shows the original disentangled factor subgraph. After setting the coefficient threshold on the original graph, the edges of the disentangled factor subgraph are visually highlighted with different colors. For instance, in the MUTAG dataset, the task is to predict the mutagenicity of a molecule against a set of nitroaromatic compounds in Salmonella typhimurium. We can observe that different parts of the molecular graph play distinct roles in the prediction. This also demonstrates the reliability of our generated factor subgraph when obtaining a disentangled graphical representation.

5. Conclusions

This paper proposes Prototype Subgraph Disentangled Graph Neural Network (PSDGNN), which enhances interpretability by decomposing input graph features into latent factor subgraphs and aligning them with learnable prototype subgraph via stochastic tour kernels. Concurrently, it introduces factor mutual information loss to encourage learning distinct latent connectivity patterns across factor subgraphs, thereby improving model generalization.

Experimental results on seven public benchmark datasets demonstrate that PSDGNN consistently outperforms existing methods, achieving competitive performance across all datasets. Notably, PSDGNN achieves a 5.5% accuracy improvement over the best baseline on DD and a 4.2% improvement on IMDB-B, validating the effectiveness of its disentanglement and prototype alignment mechanisms. On average, PSDGNN outperforms traditional graph kernels by 8–10% and GNN-based methods by 3–5% on challenging datasets. Beyond accuracy, PSDGNN provides structured interpretability through visualizable factor subgraphs and prototype subgraphs, and effectively mitigates the oversmoothing problem in GNNs.

Future work will focus on exploring composition methods based on other graph kernel approaches and investigating the model’s potential applications in other graph tasks, such as node classification and link prediction. In addition, the structured factor subgraphs disentangled by our method have the potential to provide interpretable substructure priors for large-model-based graph reasoning tasks. Exploring the integration of factor subgraphs with large models is a promising direction for future work.