ADC-GNN: Adaptive Dual-level Collaborative Graph Neural Networks for Graph Classification

1 Introduction

Graph-based machine learning methods such as Graph Neural Networks (GNNs) and Graph Transformers (GTs) have been demonstrated as powerful tools for analyzing graph structured data associated with complex interactions. Typical instances include molecular property prediction [Stokes et al., 2020; Fout et al., 2017], link prediction of physical systems [Sanchez-Gonzalez et al., 2018], social network analysis [Hamilton et al., 2017; Wu et al., 2020], etc. Most existing methods take nodes as fundamental computational units and capture local information through iterative node-wise message passing [Kipf and Welling, 2017; Bai et al., 2023] or long-range dependencies through pairwise attention [Ying et al., 2021; Ramp´aˇsek et al., 2022].

∗Corresponding Authors: Lu Bai

However, real-world graphs often exhibit higher-level structural semantics beyond individual nodes and edges. For instance, in molecular graphs, functional groups represent stable and reusable chemical substructures that largely determine molecular properties; in social networks, recurring community structures convey macroscopic functionalities. Such high-level structures can be viewed as certain forms of graph structural patterns characterized by larger receptive fields, stronger semantic stability, and reusability across graph instances, which are difficult to explicitly and efficiently capture and exploit using node-level interactions alone.

Existing methods that incorporate high-level structural information can be roughly divided into two main categories. The first category relies on pre-computed structural rules to construct high-level structures [Morris et al., 2019; Gao et al., 2022], such as manually defined substructures [Bevilacqua et al., 2022; Ai et al., 2024] or graph partitions [He et al., 2023]. The resulting high-level structures are then encoded as highlevel representations for downstream prediction. While these approaches enhance structural modeling to some extent, the resulting high-level structures remain fixed once constructed and are independent of downstream tasks and node features. As a result, such approaches struggle to adaptively capture optimal high-level structures relevant to the task, which in turn limits flexibility and generalization.

The second category induces high-level structures from node representations through learnable aggregation mechanisms. These include pooling or coarsening approaches [Ying et al., 2018; Ranjan et al., 2020; Song et al., 2024; Bai et al., 2024], which form coarse-grained graph structures by learned node clustering or selection, as well as methods that introduce learnable global latent units or prototypes [Baek et al., 2021; Vincent-Cuaz et al., 2022], associating nodes with high-level representations based on similarity measures such as attention, distance metrics, or optimal transport, etc. Although more flexible, these methods typically follow an unidirectional paradigm in which high-level representations are constructed bottom-up from node features [Bianchi and Lachi, 2023]. In this setting, high-level structures act as compressed summaries of node representations for pooling or readout, rather than an independent representation level with its own semantics that can provide global contextual information to inform or constrain node representation learning. Consequently, the interaction between fine-grained node-level representations and high-level structural semantics remains limited, hindering effective collaborative optimization across representation levels.

Based on the above observations, we argue that high-level structural semantics should be modeled as an explicit and learnable intermediate representation level that not only aggregates node information but also feeds back to guide node representation learning. This calls for a bidirectional information flow between node-level and high-level representations, enabling adaptive construction of high-level semantics while providing global contextual guidance to node updates.

To this end, we propose a novel Adaptive Dual-level Collaborative Graph Neural Network (ADC-GNN), a collaborative framework that learns graph information at both the node level and the high-level in a parallel and interactive manner. Specifically, at the node level, the ADC-GNN employs standard message passing to preserve the sparse topology and fine-grained structural information of the original graph. At the high level, it introduces a set of globally learnable latent prototypes that serve as stable semantic references shared across graph instances. To bridge the two representation levels, the ADC-GNN adopts a relaxed Sinkhorn algorithm [Chizat et al., 2018] to compute dynamic soft assignment relationships between node representations and global prototypes. The resulting assignment matrix is used to construct adaptive high-level representations. This optimaltransport-based assignment mechanism provides a differentiable and non-collapsing way to model node-prototype interactions, enabling effective dual-level collaborative modeling.

Moreover, instead of constructing a high-level adjacency matrix, we directly apply a self-attention encoder to model interactions among high-level representations. Because the number of high-level units is much smaller than the number of nodes, this design significantly reduces computational and storage costs while maintaining strong expressive capacity. More importantly, after high-level interactions, the learned assignment relationships are used to project high-level information back to node representations. Consequently, each node integrates both local topological information and global semantic context. These enriched node representations then guide subsequent rounds of node-level propagation and highlevel structure construction,forming a closed-loop, bidirectional optimization process between the two representation levels. In summary, our contributions are as follows.

• We propose a dual-level collaborative graph neural network framework that models high-level structures as explicit, learnable, and shared latent prototypes, establishing a closed-loop interaction between node-level and

high-level representations.

• We introduce a relaxed Sinkhorn-based node-prototype assignment mechanism to alleviate assignment collapse, together with an efficient high-level interaction scheme, enabling adaptive and computationally scalable duallevel modeling in an end-to-end manner.
• Extensive experiments on multiple graph classification datasets demonstrate that the proposed ADC-GNN consistently outperforms existing methods with favorable computational efficiency and robustness.

2 RelatedWorks

2.1 Modeling and Utilizing High-level Structure

Extracting pre-computed substructures from the original graph is a commom way to incorporate high-level structural information. For instance, ESAN [Bevilacqua et al., 2022] aggregates predefined equivariant subgraphs and Graph ViTMixer [He et al., 2023] adopts the METIS algorithm to partition graphs into substructures that are treated as patches for high-level representation modeling. A more flexible class of methods learns high-level structures directly from node representations through pooling or coarsening mechanisms. DiffPool [Ying et al., 2018] introduces a learnable soft assignment matrix to cluster nodes into coarse groups and progressively build hierarchical graph representations. Other approaches, such as GMT [Baek et al., 2021], leverages attention mechanisms to aggregate node features into global multiset representations.

Remarks. Although these GNNs can effectively incorporate high-level information, they still suffer from some theoretical drawbacks. First, the fixed modeling approaches depend on the pre-detected substructures. Therefore, they cannot adaptively identify the optimal substructures for specific downstream tasks. Second, the modeling process of adaptive approaches is unstable and prone to the collapse problems, where the learned assignment matrix degenerates into trivial solutions [Ying et al., 2018; Bianchi et al., 2020]. Moreover, The bottom-up paradigm they follow hinders the reverse guidance of information interaction among these nodes, which does not fully utilize high-level information.

2.2 Sinkhorn Algorithm and Balanced Assignment

The Sinkhorn algorithm was originally proposed to approximate optimal transport solutions [Genevay et al., 2018; Mena et al., 2018; Chizat et al., 2018]. In graph representation learning, Sinkhorn has been used to compute transport plans as alternatives to the attention mechanisms [Chen et al., 2020], to measure distances between graphs and templates, also as feature descriptors [Vincent-Cuaz et al., 2022], or to define losses for graph coarsening [Ma and Chen, 2021].

Remarks. Not for distance computation or explicit graph matching, our approach adopts Sinkhorn as an intra-layer normalization strategy. By leveraging its doubly stochastic constraints, Sinkhorn regularizes the node-prototype assignment matrix and prevents collapse to a few prototypes, thereby enabling stable bidirectional information flow between nodelevel and high-level semantic representations.

3 Definitions of the Proposed ADC-GNN

3.1 Preliminaries

Graph Notations Let G = (V, E) ∈ G be a graph with node set V and edge set E, where |V| = N and |E| = M. Let A ∈ RN×N denote the adjacency matrix of G, and X(0) ∈ RN×c0 denote its initial node feature matrix.

High-level Structural Information High-level structural information refers to graph patterns beyond individual nodes and edges, such as coarse-grained groups or substructures. In this paper, it is instantiated as learnable latent units, which derive their representation from the set of nodes composed to them. For a graph G at layer l,we define it as

where S(l) ∈ RN×K denotes the node-to-unit assignment matrix, capturing the composition of high-level structures, and Z(l) h ∈ RK×d denotes the interacted high-level representations, capturing their content and dependencies.

3.2 Dual-level Collaborative ConvolutionModule

The Dual-level Collaborative Convolution (DCC) module is the core component of ADC-GNN, designed to enable bidirectional and collaborative information exchange between fine-grained node-level representations and high-level representations. The whole stage has three procedures exhibited by Figure 1. First, an adaptive assignment between nodes and a set of learnable prototypes is learned, mapping the nodelevel representations and the high-level representations. Second, high-level representations are constructed based on the learned assignments and they can interact globally to capture macroscopic dependencies. Third, the interacted high-level contexts are injected back into node representations guided by the same assignments. These are fused with node representations obtained through node-level message passing to produce the final result. Together, these stages form a closedloop collaborative update mechanism between node-level and high-level representations.

Procedure A: Node-level to High-level Assignment

Given the input graph at the l-th layer G(l) = (X(l) ,A), where X(l) ∈ RN×d denotes the node feature matrix and d is the feature dimension. We introduce a set of prototype vectors P ∈ RK×d , where K denotes the number of prototypes. Each prototype pk is a globally learnable parameter vector, rather than being computed from pre-defined graph rules or obtained by node clustering algorithms. It serves as a potential high-level semantic reference that adaptively aggregates nodes with similar attributes.

To measure the similarity between nodes and prototypes, we first compute a scaled cosine similarity matrix M ∈ RN×K as

where ¯xi and ¯ pk denote the ℓ2-normalized node feature x(l) i and prototype vector pk, respectively. The value Mik represents their logit score. The temperature parameter ϵ controls the smoothness of the assignment. As ϵ → 0, the assignment approaches a hard assignment, while a larger ϵ leads to a more uniform distribution.

Our goal is to learn an assignment matrix S ∈ RN×K that satisfies two requirements, i.e., a) each node should be reasonably matched to its most similar prototypes; and b) assignment collapse should be avoided, where most nodes are assigned to only a few prototypes, resulting in redundant or degenerated high-level semantics. To this end, we adopt a Sinkhorn algorithm based on log-domain iterations and incorporate soft load-balancing constraints to enhance numerical stability and encourage balanced prototype utilization.

Specifically, we initialize the log-assignment matrix as H(0) = M. At the t-th iteration, we first perform row normalization over the prototype dimension of H(t) ∈ RN×K , ensuring that the assignment weights of each node across all prototypes sum to one as follows

Next, we employ a soft load-balancing constraint along the prototype dimension. We define the current log mass of the k-th prototype µ(t) k and its target log mass ˆµ(t) as

Here, ˆµ(t) corresponds to the target assignment under the assumption of approximately balanced prototype masses. The assignment matrix is then smoothly adjusted according to the discrepancy between the current and target masses

where τ ∈ (0, 1] controls the strength of the load-balancing constraint. This update does not enforce strict equality of prototype masses; instead, it softly encourages balanced assignments across prototypes, alleviating assignment collapse.

After T iterations, the final log-assignment matrix is mapped back to the probability space, yielding the soft nodeto-prototype assignment matrix as

The resulting matrix S encodes the affinity between each node and each prototype, thereby providing the basis for subsequent high-level representation construction and node-level context injection.

Procedure B: High-level Representation Construction and Interaction

After obtaining the soft assignment matrix S, we construct concrete high-level representations and conduct their global interactions. Specifically, the initial representation of each graph in high-level space is obtained by aggregating node features as

This operation can be regarded as an adaptive weighted pooling scheme that compresses node-level information into K compact high-level feature vectors.

However, the aggregated features Zagg are isolated from each other at this stage and lack an understanding of dependencies among high-level units. Different from nodelevel representations whose interactions are constrained by the topology of the original graph, we do not explicitly construct an adjacency structure among high-level units. In fact, the adjacency relationship of these units is a dense graph that is almost fully connected. Therefore, we can model their pairwise interactions directly. We employ a standard Transformer block consisting of multi-head self-attention (MSA) and a feed-forward network (FFN) to perform global information exchange as follows

where Win ∈ Rd×d′ is a learnable projection matrix and we set d′ = d in this work. LN(·) denotes layer normalization, MSA(·) computes semantic correlations among highlevel units and performs global aggregation, ˜Z is an intermediate representation, and FFN(·) denotes a position-wise feed-forward network.

Each high-level unit can adaptively aggregate information from all other units according to semantic relevance. The resulting representation Zh ∈ RK×d encodes global contextual information over the entire graph. Since K ≪ N, the computational complexity of this interaction is O(K2 ), effectively avoiding the prohibitive cost of node-level self-attention.

Procedure C: High-level to Node-level Context Injection

After interacting at the high level, we further inject Zh back into the node level as semantic context, enabling node representations to explicitly perceive the semantics of their associated high-level structures. This process relies on the learned soft node-prototype assignment matrix S from Section 3.2 procedure A, that is,Xh = SZh ∈ RN×d . (12)

Since Sik measures the degree to which the i-th node is associated with the k-th prototype, it also naturally defines the projection weights from the high-level semantic back to the node. As a result, Xh provides each node with global contextual information aligned with its role.

Meanwhile, a standard node-level message passing operation is performed to capture fine-grained local information, yielding node representations Xn ∈ RN×d as

where GNN(·) can be instantiated by any graph neural network convolution operation, such as GIN or GCN.

Considering that different nodes may rely on high-level context to different extents, for example, structurally central nodes may emphasize local connectivity. In contrast, bridging nodes may benefit more from global semantics. We introduce a learnable gating coefficient α to dynamically regulate the fusion ratio as below

where ∥ denotes feature concatenation, Wg ∈ R2d×d and bg ∈ Rd are parameters of the gating network, σ(·) is the Sigmoid activation function, and ⊙ denotes element-wise multiplication. The fused representation Xout is then used as the input to the next convolutional layer.

Through this design, the ADC-GNN forms a complete closed loop. Specifically, node representations firstly construct globally interacted high-level structures, and the results are then fed back to refine node representations.

3.3 Overall Architecture

In this section, we present the overall architecture of the proposed ADC-GNN. As shown in Figure 2, the ADC-GNN consists of three sequential stages, i.e., initialization, collaborative encoding, and graph readout.

Given an input graph G with initial node features X(0) , we first map the node features into a continuous embedding space and apply a standard GNN layer for initialization,

This initialization step injects basic local structural information into node representations, providing a stable foundation for subsequent feature based assignment and high-level semantic construction.

In the second stage, we alternately stack standard nodelevel GNN layers and Dual-level Collaborative Convolution (DCC) modules. Formally, the node representation update at the l-th layer is defined as

Each DCC module performs bidirectional refinement between node-level and high-level representations, serving as the core unit for dual-level collaborative evolution. The alternating stacking strategy enables this collaboration to be progressively propagated across network depth while maintaining computational efficiency. Residual connections [He et al., 2016] are applied at each layer to stabilize deep training. In addition, an SE layer [Hu et al., 2018] is employed after each DCC module to recalibrate feature channels and enhance discriminative capacity.

As the network deepens, node representations update from both local structural information and global semantic context, which in turn yields richer and appropriate node-prototype assignments in subsequent DCC modules.

Finally, after L layers of collaborative encoding, the final node representations X(L) are aggregated via global sum pooling to obtain a graph-level representation g ∈ Rd as

which is then used for downstream graph classification tasks.

3.4 Complexity Analysis

We analyze the computational complexity of a single Duallevel Collaborative Convolution (DCC) module in the ADCGNN. Let the input graph contain N nodes and E edges, with K high-level prototypes and Sinkhorn iteration count T. At the node level, the DCC module employs a standard GNN for local message passing, whose time complexity scales linearly with the number of edges as O(E), consistent with conventional GNN models. In the assignment procedures, computing the similarity matrix requires O(NK) operations, while T Sinkhorn iteration costs O(TNK). Since T is typically set to a small constant (e.g., 2-3), the overall complexity of this stage is O(NK). In the high-level interaction procedures, self-attention among the K high-level units incurs a time complexity of O(K2 ). Given that K ≪ N, this design effectively avoids the quadratic complexity associated with node-level Transformers. Combining the above components, the overall time complexity of a single DCC module is O(E + NK + K2 ).

In terms of space complexity, the ADC-GNN adopts sparse storage at the node level and additionally maintains the nodeprototype assignment matrix S ∈ RN×K and the high-level representations. The extra space complexity is therefore O(NK +K). Consequently, the ADC-GNN introduces explicit global modeling capability while maintaining favorable computational and memory efficiency.

4 Experiments

In this section, we conduct extensive experiments to evaluate the performance of ADC-GNN. Specifically, we aim to: 1) verify its effectiveness on standard graph-classification benchmarks from TUDataset; 2) assess its generalization ability and long-range dependency modeling capability on more challenging OGB and LRGB datasets; 3) analyze its runtime efficiency; 4) perform ablation studies to justify the necessity of each module in the ADC-GNN; 5) analyze the performance of different assignment strategies; 6) discuss the selection of the number of prototypes and its implications and 7) provide visualizations to qualitatively demonstrate the effectiveness of our design.

Datasets and Experimental Setups We evaluate our method on 1) Five publicly available graph-classification datasets from TUDataset, including three biochemica datasets and two social interaction datasets; 2) ogbg-molhiv from the Open Graph Benchmark (OGB) [Hu et al., 2020]; 3) Peptides-func from the Long-Range Graph Benchmark (LRGB) [Dwivedi et al., 2022b]. Basic dataset statistics are summarized in the headers of Tables 1 and 2.

For the proposed ADC-GNN, we perform hyperparameter tuning using a grid search strategy. Specifically, the number of layers is selected from the range of 1 to 7. The temperature parameter ϵ is searched in [0.01, 0.2] with a step size of 0.02; the number of Sinkhorn iterations t is chosen from [2, 3]; and the load-balancing relaxation coefficient τ is tuned in [0.05, 0.1, 0.2, 0.3, 0.6, 0.8]. The number of high-level prototypes in each DCC module is selected from [32, 16, 8] for all datasets, and we use orthogonal initialization to ensure its initial diversity. All experiments are conducted on NVIDIA RTX 3090 GPUs with 24GB of RAM. The additional implementation details are available in our project repository 1 .

4.1 Comparisons on the TUDataset

We compare the proposed ADC-GNN with 12 graph classification methods, including 2 classic node-level messagepassing models 1) GCN [Kipf and Welling, 2017], 2) GIN [Xu et al., 2019]; 6 models related to our proposed method 1) GMT [Baek et al., 2021], 2) GSAPool-MID [Liu et al., 2023], 3) DiffPool [Ying et al., 2018], 4) ASAP [Ranjan et al., 2020], 5) SEP-G [Wu et al., 2022], 6) ClusterGT [Huang et al., 2024]; and 4 the latest outstanding models Table 2: Results on OGB and LRGB benchmarks. Best results are highlighted in bold. "-" indicates the result is not reported. AR denotes Average Rank.

1 https://github.com/Volento/ADC-GNN

1) GKNN GL [Cosmo et al., 2025], 2) ENAHPool [Zhao et al., 2025], 3) AEGK(A) [Bai et al., 2025], 4) UnionSNN [Xu et al., 2024]. In our experiments, to ensure a fair comparison, we perform 10-fold cross-validation and repeat each experiment ten times, reporting the mean classification accuracy along with its standard error. For datasets with node labels, we adopt one-hot encodings of the node labels as initial node features; for datasets without node labels, we use node degrees as initial features. GIN [Xu et al., 2019] is chosen as the node-level convolutional backbone of ADC-GNN.

Results andAnalyses. The experimental results on the TUDataset are reported in Table 1. As can be seen, the proposed ADC-GNN outperforms the remaining models significantly. Specifically, except for PROTEINS, our ADC-GNN achieved the best classification performance. This validates that the proposed architecture can yield powerful multi-scale graph representations adaptively and is suitable for varying datasets.

4.2 Comparisons on the OGB and LRGB

We compare our ADC-GNN with a set of recent representative methods, including 1) GraphGPS [Ramp´aˇsek et al., 2022], 2) Graph-MIP-Mixer [He et al., 2023], 3) GRIT [Ma et al., 2023], 4) Subgraphormer [Bar-Shalom et al., 2024], 5) Graph-Mamba [Wang et al., 2024], 6) GIN+ [Luo et al., 2025], and 7) GatedGCN+PE+VNG [Southern et al., 2025]. Due to the characteristics of the datasets, we follow the setup of GIN+ [Luo et al., 2025], which adopts GINE, an edge-aware extension of GIN [Hu et al., 2020], as the node-level convolutional backbone and uses the concatenation of atom features and Random Walk Structural Encoding (RWSE) [Dwivedi et al., 2022a] as the initial node features. The model is constrained to approximately 500K parameters. We report the mean performance and standard deviation over five different runs.

Results and Analyses. As shown in Table 2, our model exhibits strong competitiveness, particularly on the dataset requiring long-range dependencies. This advantage stems from our high-level mechanism, where nodes that are distant in the original graph are compressed into high-level units and can exchange information directly. The refined high-level information is then injected back to the original nodes to guide subsequent message passing, thereby naturally enhancing long-range communication.

4.3 Runtime Efficiency Comparison

Table 3 reports the runtime results on ogbg-molhiv, where all models are evaluated on n NVIDIA A100 GPUs for fair comparison. Due to the additional high-level module, our model is slightly slower than plain GIN, but remains faster than other transformer-based models, indicating competitive efficiency.

4.4 The Ablation Study

To investigate the contribution of each component in our ADC-GNN, we design three ablation variants, namely the ADC-GNN-NoS, ADC-GNN-NoA, and ADC-GNN-NoH. In the ADC-GNN-NoS, we remove the Sinkhorn constraint and allow potential assignment collapse. In the ADC-GNN-NoA, we construct the high-level adjacency matrix Ah = S⊤AS and perform standard message passing on the high-level graph instead of the original attention mechanism. In the ADC-GNN-NoH, we entirely remove the high-level module. We evaluate the full model and all variants under the same hyperparameter settings. As shown in Table 4, removing any component leads to performance degradation, indicating that all designs jointly contribute to the effectiveness of our proposed ADC-GNN.

4.5 The Analysis of Assignment Strategies

We further analyze the effect of the node-prototype assignment strategies on the collapse problem. We replace the assignment module in ADC-GNN with three representative alternatives, including 1) DMoN-style collapse regularization [Tsitsulin et al., 2023], 2) MinCut-style orthogonality regularization [Bianchi et al., 2020], and 3) unconstrained Softmax. For the assignment matrix S ∈ RN×K , we define the normalized usage mass of the k-th prototype as mk = 1N ∑Ni=1 Sik. Based on mk, we use three diagnostic metrics to measure prototype utilization,

where Rempty measures the ratio of inactive prototypes, δ = 0.1/K, Hproto characterizes the overall balance of prototype usage, and Mmax indicates whether the assignment mass is overly concentrated on a small number of prototypes. An ideal assignment mechanism should avoid empty prototypes and excessive concentration, while maintaining sufficiently clear node-prototype preferences.

As shown in Figure 3, unconstrained Softmax leads to a higher empty-prototype ratio and a larger maximum prototype mass, suggesting that row-wise normalization alone is insufficient to regulate global prototype usage. DMoN and MinCut regularization mitigate collapse to some extent, but they may still suffer from skewed prototype usage or overly uniform assignments during training. In contrast, the relaxed Sinkhorn assignment maintains a lower emptyprototype ratio, a moderate maximum prototype mass, and stable prototype-usage entropy, while also achieving the best classification performance. These results indicate that the relaxed Sinkhorn assignment provides a more reliable routing mechanism for bidirectional information exchange and contributes to the final results.

4.6 Sensitivity to the Number of Prototypes

To study the effect of high-level prototype numbers on ADCGNN, we varied the number of prototypes while keeping other hyperparameters fixed. All experiments used four layers (two DCC layers) with consistent prototypes per layer. Table 5 shows the performance. Note that the results may differ from those reported in Table 1 due to different settings. Our main observation is that the model is robust to the prototype number within a practical range, with performance varying but not dramatically. Since prototypes are learned endto-end, the model can adaptively redistribute semantic roles across them. We find that a moderate number of prototypes strikes a good balance between performance and efficiency, with values up to 64 sufficient for most datasets.

4.7 The Visualization Evaluation

In our visualization analysis, we focus on two aspects: 1) the node-to-prototype assignment results in each DCC layer, to understand how high-level units are composed of underlying nodes; 2) the fusion patterns between high-level information and node-level information across different layers. Figure 4 presents the visualization of a graph instance from the PROTEINS dataset after 50 training epochs, with two DCC layers, located on Layer 1 and Layer 3, respectively.

As shown in Figure 4(a), the color intensity indicates the assignment weight of each node to the high-level prototype.

Figure 4: Visualization of the DCC module for a sample graph.

We observe that each node exhibits a relatively clear preference toward specific prototypes, and all prototypes are effectively utilized. It means assignment collapse or uniform distribution across prototypes does not happen, and the model has learned a good correspondence relationship.

Regarding the injection of high-level information into nodes, Figure 4(b) illustrates that different nodes rely on highlevel information to varying degrees. For this graph, the importance ratio of high-level information to node information is approximately 4:6, which suggests that node-level features and high-level representations in our ADC-GNN collaboratively contribute to the final graph representation.

5 Conclusions

In this paper, we have proposed a GNN method, namely ADC-GNN, for graph classification. By introducing learnable high-level prototypes and a relaxed Sinkhorn-based assignment mechanism, we have shown that ADC-GNN derives rich high-level representations for each node and reintegrates them into the node-level features to generate enhanced node representations, thereby collaboratively capturing both global and local information across multiple levels. Moreover, the model enhances long-range information exchange while maintaining favorable computational efficiency. Experimental results demonstrate the effectiveness of ADC-GNN for graph classification.

Acknowledgments

This work is supported by National Natural Science Foundation of China (No. 62576371, 62576198 and 62536006), and the Open Project Foundation of Key Laboratory of Computation Intelligence and Chinese Information Processing of Ministry of Education and Key Laboratory of Data Intelligence and Cognitive Computing of Shanxi Province.