Paper deep dive
Node-level Graph Neural Architecture Search Framework
Lintao Yanga, Sirui Lia, Yaqing Wang, Pietro Liò, Xu Shen, Baisong Liu, Chengbin Peng
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%
Last extracted: 10/8/2026, 7:28:58 AM
Summary
The paper introduces N-GNAS, a Node-Level Graph Neural Architecture Search framework that automatically selects appropriate GNN architectures and node selection operations for different subsets of nodes. This approach addresses the limitations of traditional GNAS methods that apply uniform operations, thereby mitigating over-smoothing issues. N-GNAS incorporates a contrastive learning loss to enhance feature separation and demonstrates superior performance on node and graph classification tasks across eight datasets.
Entities (10)
Relation Signals (9)
N-GNAS → uses → Contrastive Learning Loss
confidence 95% · N-GNAS also introduces a contrastive learning loss to separate sample features from different categories
N-GNAS → achieveshighaccuracyon → CiteSeer
confidence 92% · it achieves an accuracy rate of 78.26% on the CiteSeer dataset
N-GNAS → includesinsearchspace → GAT
confidence 90% · Table 1: ... fG2 GAT
N-GNAS → includesinsearchspace → GraphSAGE
confidence 90% · Table 1: ... fG3 GraphSAGE
N-GNAS → includesinsearchspace → GIN
confidence 90% · Table 1: ... fG4 GIN
N-GNAS → includesinsearchspace → GCN
confidence 90% · Table 1: Some popular graph neural network operation within our search space... fG1 GCN
N-GNAS → includesinsearchspace → GatedGCN
confidence 90% · Table 1: ... fG5 GatedGCN
N-GNAS → mitigates → Over-smoothing
confidence 90% · N-GNAS also introduces a contrastive learning loss... which can also effectively alleviate the over-smoothing issue
N-GNAS → outperforms →
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:In recent years, Graph Neural Networks (GNNs) and architecture search frameworks have gained extensive application in non-Euclidean data processing, attributable to their superior capacity in managing unstructured data. Nevertheless, traditional approaches typically apply uniform convolution operations to all nodes, regardless of their varying structural and feature characteristics, which can undermine model performance and result in over-smoothing issues as the number of layers increases. To overcome this limitation, in this work, we propose a \textbf{N}ode-Level \textbf{G}raph \textbf{N}eural \textbf{A}rchitecture \textbf{S}earch (N-GNAS) algorithm. It can automatically choose an appropriate network architecture for each subset of nodes when updating node features. N-GNAS also introduces a contrastive learning loss to separate sample features from different categories and vice versa. In experiments conducted on eight datasets for node and graph classification, our methodology outperforms current leading GNAS techniques and traditional human-designed GNNs. For example, it achieves an accuracy rate of 78.26\% on the CiteSeer dataset.
Tags
Links
- Source: https://arxiv.org/abs/2610.09297v1
- Canonical: https://arxiv.org/abs/2610.09297v1
Trouble viewing inline? Open PDF directly →
Full Text
55,358 characters extracted from source content.
Expand or collapse full text
Node-level Graph Neural Architecture Search Framework Lintao Yang 2211100291@nbu.edu.cn Sirui Li 2411100282@nbu.edu.cn Yaqing Wang 2511100088@nbu.edu.cn Pietro Liò Pietro.Lio@cl.cam.ac.uk Xu Shen 196003572@nbu.edu.cn Baisong Liu liubaisong@nbu.edu.cn Chengbin Peng pengchengbin@nbu.edu.cn Abstract In recent years, Graph Neural Networks (GNNs) and architecture search frameworks have gained extensive application in non-Euclidean data processing, attributable to their superior capacity in managing unstructured data. Nevertheless, traditional approaches typically apply uniform convolution operations to all nodes, regardless of their varying structural and feature characteristics, which can undermine model performance and result in over-smoothing issues as the number of layers increases. To overcome this limitation, in this work, we propose a Node-Level Graph Neural Architecture Search (N-GNAS) algorithm. It can automatically choose an appropriate network architecture for each subset of nodes when updating node features. N-GNAS also introduces a contrastive learning loss to separate sample features from different categories and vice versa. In experiments conducted on eight datasets for node and graph classification, our methodology outperforms current leading GNAS techniques and traditional human-designed GNNs. For example, it achieves an accuracy rate of 78.26% on the CiteSeer dataset. keywords Graph Neural Networks ,Graph Neural Architecture Search ,Graph Representation Learning †credit: Conceptualization; Formal analysis; Writing – original draft; Methodology; Writing – review & editing†credit: Conceptualization; Formal analysis; Writing – original draft; Methodology; Writing – review & editing†credit: Investigation; Validation; Writing – review & editing†credit: Investigation; Software; Resources†credit: Methodology; Writing – original draft; Investigation†credit: Writing – review & editing; Supervision; Resources†credit: Formal analysis; Methodology; Resources; Supervision; Project administration; Writing – review & editing†corresponding: Corresponding author†These authors contributed equally to this work. 1 Introduction Graphs are an essential representation of data structure that can describe various relationships and structures, which has been a pivotal area of investigation for many years. Graph neural networks (GNNs) [1, 18] are a kind of neural network model specially designed to deal with graph structure data. They extract features of graph data by learning relationships from nodes and edges. They can perform many graph learning tasks, such as node classification [37], link prediction [19, 22, 25], and graph classification [41]. Despite the success of GNNs [20, 38, 32, 26, 6, 44], huge challenges remain. For example, a specific graph neural architecture can usually only fit some graph learning tasks on certain datasets, and even for these datasets, lots of human expertise and trials are typically needed to optimize the graph neural architecture. Thus, it undoubtedly requires significant computational investments and professional skills. Inspired by Neural Architecture Search (NAS) on CNNs [52], Graph Neural Architecture Search (GNAS) [13] techniques have been further proposed to search for the best GNN automatically. For example, in the beginning, GraphNAS [14] pioneered this research field by using reinforcement learning to design graph neural architectures and proposing a novel weight-sharing strategy to reduce the number of parameters to effectively select graph neural network components such as attention functions and attention heads. For heterogeneous graphs, HGNAS [15] designs a new search space by utilizing popular heterogeneous graph neural networks such as RGCN [30] and MAGNN [12], and proposes different kinds of message encoding and aggregation methods. SANE [17] introduces a differentiable gradient graph neural architecture search method [24] to explore feature aggregation strategies. ARGNP [4] introduces a relation-aware message passing strategy into the search space, to optimize the learning of node and relational information. However, traditional GNAS methods usually perform a uniform operation over different nodes, which is inappropriate as nodes in a real-world graph can usually encompass various types with diverse characteristics. Meanwhile, performing the same number of graph neural network operations on each node may result in excessive averaging of node features across the entire graph, reducing differentiation between different nodes and causing the problem of over-smoothing [31]. To address this challenge, in this work, we propose a node level Graph Neural Architecture Search (N-GNAS) framework, which can adaptively apply different GNN operations for different nodes and alleviate over-smoothing. Figure 1 illustrates the graph neural network model that has been generated using the N-GNAS algorithm. This study represents the first effort to apply GNAS to optimize node-level operations within graph neural networks. The primary contributions of this research are outlined as follows: 1. We propose a node-level search framework that can automatically select the optimal graph neural network (GNN) architecture for different node subsets based on their unique characteristics. Unlike traditional GNN or GNAS approaches, which apply uniform convolution operations to all nodes, this is the first to achieve node-level optimization for more precise and effective learning. 2. We propose a contrastive learning loss into GNAS to separate sample features from different categories and vice versa, which can also effectively alleviate the over-smoothing issue commonly observed in traditional deep GNNs. 3. Extensive evaluations across diverse graph learning tasks have demonstrated that our approach surpasses conventional GNAS and manually crafted GNN methods in performance. Figure 1: An example of a graph neural network discovered by N-GNAS. Part I illustrates an L-layer architecture. Part I demonstrates the search space across three stages, and Part I provides an example of search outcomes. Each layer comprises two stages: node selection operation search and graph neural network operation search, denoted by the symbols S and G with subscripts reflecting their diversity. Every layer comprises an input cell, an output cell, and operation cells. In this example, seven cells and five operation are used in the first and the second stage respectively. The variable X denotes the respective features obtained from these cells, with subscripts distinguishing stages and superscripts defining layers and cells. Links indicate possible operations. 2 Related Work 2.1 Recent Advances In Graph Neural Networks Graph Neural Networks (GNNs) is a type of deep learning model used for processing graph-structured data [18, 16, 35, 41] that can learn representations for nodes and graphs and can perform various tasks such as node classification, graph classification, link prediction, and so on. GNN operations can aggregate node information, and GNNs can be divided into two categories: spectral-based GNNs [18] and spatial-based GNNs [35]. Spectral-based GNNs learn node representations by spectral decomposition of graphs. Specifically, for a graph, the eigen-decomposition of its Laplacian matrix is computed, and these eigenvectors are then used as node representations. Defferrard et al. [9] approximate spectral filters using Chebyshev polynomials to reduce the complexity of matrix decomposition. GCN [18] optimized upon this by simplifying the previous method through local first-order approximations. JK-Net [42] improves node representations by adaptively aggregating nodes from different locations. SGC [40] simplifies GCN by removing non-linear activation functions and feature extraction as a feature preprocessing operation. Spatial-based GNNs directly utilize the neighborhood information to learn node representations, which update node features simply by aggregating information within the local neighborhood of each node and do not require expensive graph spectral decomposition. For example, GraphSAGE [16] is a framework that leverages both node feature information and node structural information. The feature information is sampled and aggregated from the local neighborhood of nodes to obtain node embeddings. The structural information is learned by employing trainable aggregation functions. GAT [35] introduces a masked self-attention mechanism to assign different weights for different node representations. GatedGCN [2] replaces the recursive definition of GNNs with gated edges and residuality, employing gate mechanisms to determine whether information should propagate from one node to another and utilizing residual connections to enable the network to learn features of graph data at deeper levels. 2.2 Graph Neural Architecture Search The objective of NAS is to autonomously identify the most effective neural architecture tailored for specific datasets through a systematic optimization process [52]. Traditionally, the design of neural network architectures is conducted manually, a process that is not only laborious but also time-consuming [24]. To overcome this limitation, NAS can automatically discover suitable network architectures for predefined tasks. Similar to NAS on CNNs and RNNs, NAS on graph has been proposed [17, 4]. For example, there are GNAS based on reinforcement learning (RL) [52, 14, 51], GNAS based on evolutionary algorithms (EA) [23, 33, 36, 49], GNAS based on gradient descent (GD) [24, 17, 5, 39], etc. These algorithms can not only automatically search the network structure but also avoid the ”subjective” bias of the designer for the network structure. In search space design, prevailing approaches are generally categorized into two main paradigms: component-based and architecture-based methods [30]. The component-based search method targets a predefined set of components, such as aggregation operations, their respective weights, and combination mechanisms. It aims to optimize each module by fine-tuning its attributes and configurations. In contrast, architecture-based search involves a broader exploration scope, including elements like network depth and integrating different modules, to identify the optimal configuration for the entire network’s structure [50]. Futhermore, DSS [21] further improves search efficiency by adaptively pruning the search space during the search process. Nevertheless, these approaches overlook the diversity of node attributes and solely rely on cross-entropy as the loss function. Unlike heterogeneous GNN methods [30, 12, 15] that rely on predefined type information and manual metapaths, our approach automatically determines node-level operations from learned features and structures without requiring any type annotations, making it applicable to both homogeneous and heterogeneous graphs in a fully data-driven manner. Based on these insights, we propose an approach for the node-level graph neural architecture search. 3 METHODOLOGY 3.1 Notations In this work, we define G as a graph of n nodes, with V representing the set of nodes within G. We denote the node features by ∈ℝn×dVX∈R^n×d_V, where dVd_V indicates the dimension of node features. Specifically, the u-th row of X, corresponding to node u is denoted as xux_u. We use N(v)N(v) to denote the one-hop neighbors of a node v in G. We use A∈ℝn×nA∈R^n× n and D∈ℝn×nD∈R^n× n to represent the adjacency matrix and the degree matrix of this graph. Thus, the structural relationships and the node features in graph G can be represented by an adjacency matrix A and a feature matrix X. 3.2 Search Space Architecture Design Traditional GNAS applies the same number of graph neural networks to all nodes in the graph, which cannot adapt well to the diversified characteristics of different nodes, thus limiting the expressive power of the graph neural network model. In this work, we propose applying varying numbers of graph neural networks to different nodes based on their characteristics and needs. For example, by considering node features, positions, and local structures, we tailor the number of graph neural networks to enhance the model’s expressive capacity. Without loss of generality, we assume that the network architecture consists of L layers. Each layer consists of node selection operations and graph neural network operations, except that Layer 1 and Layer L are usually linear and classification layers, respectively. We use in(l)X_in^(l) and out(l)X_out^(l) to represent the input and the output of the l-th layer respectively. Thus, in(1)X_in^(1) is the input graph and out(L)X_out^(L) is the network output, and in(l)=out(l−1)X^(l)_in=X^(l-1)_out, for l∈2,3,…,Ll∈ \2,3,…,L \. Each layer encompasses two stages. The first is to select nodes for further processing, and the second is to search for optimal graph neural network operations for selected nodes. Hence, the search space can be represented by a directed acyclic graph (DAG). Cells are defined as the fundamental elements within the search space, and links represent the connections between these cells. For the l-th layer, a vector X→S(l,i)∈ℝ1×n X_S^(l,i)∈R^1× n to represents the node information score in the i-th cells corresponding to the i-th scoring strategy in the first stage, and a matrix G(l,i)∈ℝn×nX_G^(l,i)∈R^n× n represents the feature embedding corresponding to the i-th graph neural network operation in the second stage. There is a total of n1n_1 and n2n_2 cells for corresponding stages. In each stage, an operation depicted by a directed link S(l,i)S^(l,i) or G(l,i)G^(l,i) extracts features from its input cell and stores the results in its output cell. The framework is as shown in Figure 1. 3.2.1 Stage I: Node Selection Operations. Before applying a graph neural network operation in each layer, we propose different scoring approaches and ensemble them to compute a soft gating vector, where each entry indicates the extent to which a node should undergo further GNN processing. Without loss of generality, for the l-th layer and the i-th scoring approach, node information score X→S(l,i) X_S^(l,i) are obtained after applying an operation S(l,i)S^(l,i) on the input cell in(l)X_in^(l). After assembling these scoring approaches, nodes with higher scores are assigned larger gate values, allowing them to contribute more to the subsequent GNN stage, while nodes with lower scores are mostly routed through residual connections. Node scoring approaches consider node features, positions, and structures, and we discuss each in detail as follows. (1) Feature Projection fS1f_S_1: From the perspective of node features, we calculate the score for each node by employing a learnable feature projection vector W(l)W^(l) as follows: fS1(in(l)) f_S_1(X_in^(l)) =W(l)⋅in(l). =W^(l)·X_in^(l). (1) (2) Multi-layer Perceptron fS2f_S_2: We also employ a Multi-Layer Perceptron (MLPMLP) to obtain a score vector for the entire feature matrix for the score calculation as follows: fS2(in(l)) f_S_2(X_in^(l)) =MLP(in(l)). =MLP(X_in^(l)). (2) (3) Local Position Score fS3f_S_3: Regarding node positions, we can consider local and global aspects. The local position score is computed by generating a random walk matrix that quantifies the likelihood of each node reaching other nodes within the graph. The score of each node is obtained by summing each column of the random walk matrix: M M =D⋅A, =D· A, (3) fS3(in(l)) f_S_3(X_in^(l)) =[∑jnMj,1,∑jnMj,2,⋯,∑jnMj,n]. = [ _j^nM_j,1, _j^nM_j,2,·s, _j^nM_j,n ]. (4) (4) Global Position Score fS4f_S_4: The global position score is derived using the distance matrix P∈ℝn×nP∈R^n× n between nodes, in which each column indicates the distance from each node to every other node and can be computed by the Floyd–Warshall [11] algorithm or approximated by more efficient methods for large graphs. The score for each node is obtained by summing elements of each column in the matrix as follows: fS4(in(l)) f_S_4(X_in^(l)) =[∑jnPj,1,∑jnPj,2,⋯,∑jnPj,n]. = [ _j^nP_j,1, _j^nP_j,2,·s, _j^nP_j,n ]. (5) (5) Local Structural Feature Score fS5f_S_5: We also use node structural features for scoring. Local structure information is directly obtained from the degree matrix as follows: fS5(in(l))=[D1,1,D2,2,⋯,Dn,n]. f_S_5(X_in^(l))= [D_1,1,D_2,2,·s,D_n,n ]. (6) (6) Relative Structural Feature Score fS6f_S_6: Relative structural feature scores leverage node features from neighborhoods and are obtained by aggregating their feature projection scores fS1(in(l))f_S_1(X_in^(l)), rather than simply the number of neighbors as follows: ψ ψ =fS1(in(l)), =f_S_1(X_in^(l)), (7) fS6(in(l)) f_S_6(X_in^(l)) =[∑j∈N(v1)ψj,∑j∈N(v2)ψj,⋯,∑j∈N(vn)ψj]. = [ _j∈ N(v_1) _j, _j∈ N(v_2) _j,·s, _j∈ N(v_n) _j ]. (8) (7) Attention-based Structural Feature Score fS7f_S_7: Adaptive Structure Aware Pooling (ASAPASAP) [28] can compute node attentions to divide nodes in a graph into different local clusters. Thus, we propose to use this attention information as node scores as follows: fS7(in(l))=ASAP(in(l)). f_S_7(X_in^(l))=ASAP(X_in^(l)). (9) We use X→S(l,i) X_S^(l,i) to represent the scores obtained from these scoring approaches: X→S(l,i) X_S^(l,i) =Norm(fSi(in(l))),i∈1,2,…,7. =Norm(f_S_i(X_in^(l))),\ i∈ \1,2,…,7 \. (10) An activation function σ is applied on the ensemble of these scores to compute the node mask vector X^S(l)∈ℝ1×n X_S^(l)∈R^1× n of the l-th layer based on that from the last layer, namely, X^S(l−1) X_S^(l-1): X^S(l) X_S^(l) =σ(∑iαS(l,i)X→S(l,i))⊙X^S(l−1), =σ( _i _S^(l,i) X_S^(l,i)) X_S^(l-1), (11) where αS(l,i) _S^(l,i) is a scalar representing the weight of the i-th operation, ⊙ is an element-wise multiplication operation, and σ(⋅)σ(·) is the sigmoid function ensuring each entry lies in (0,1)(0,1). Thus, X^S(l)∈(0,1)n X_S^(l)∈(0,1)^n serves as a continuous soft gating vector of the l-th layer, where the j-th entry indicates the degree to which node j should be processed by subsequent GNN operations. A value close to 11 means the node is strongly selected, while a value close to 00 means its features mostly pass through via the residual connection in Eq. (13). This continuous relaxation keeps the entire framework fully differentiable without requiring any hard discretization during training. After obtaining X^S(l) X_S^(l), we zero out the corresponding columns in the feature matrix in(l)X_in^(l) row by row to obtain S(l)X_S^(l) for further processing: S(l)=X^S(l)⊙in(l), _S^(l)= X_S^(l) _in^(l), (12) where broadcasting is used in ⊙ to extend a vector to match the dimensions required for matrix multiplication. 3.2.2 Stage I: Graph Neural Network Operations. In the second stage, each cell also connects with the cell S(l)X_S^(l) and stores the results obtained from different graph neural network operations. We can select the optimal graph neural network operation for the current layer by analyzing the final results, thus gaining advantages in graph neural architecture search. Different graph neural network operations have distinct advantages over different tasks and datasets. In this work, several widely used GNNs are included in the search space to enhance the model performance, as shown in Table 1, where each operation fGif_G_i is fed by a graph and the corresponding feature matrix, and returns the resulted feature matrix. Table 1: Some popular graph neural network operation within our search space. Def. denotes different graph neural network operations. Operation denotes the corresponding concrete graph neural network operation respectively. Def. Operation fG1f_G_1 GCN [18] fG2f_G_2 GAT [35] fG3f_G_3 GraphSAGE [16] fG4f_G_4 GIN [41] fG5f_G_5 GatedGCN [2] Therefore, the objective function can be expressed as follows: XG(l,i)=fGi(S(l))+(1−X^S(l))⋅in(l), X_G^(l,i)=f_G_i(X_S^(l))+(1- X_S^(l))·X_in^(l), (13) where the term (1−X^S(l))⋅in(l)(1- X_S^(l))·X_in^(l) acts as a residual connection: nodes with low gate values are directly carried over without further GNN processing, which helps alleviate over-smoothing. Through node-level graph neural network operation selection, we can obtain the final node features G(l)X_G^(l) for each layer: G(l)=∑1≤i<5αG(l,i)XG(l,i). _G^(l)= _1≤ i<5 _G^(l,i)X_G^(l,i). (14) where αG(l,i) _G^(l,i) denotes the scalar weight for the i-th operation. 3.2.3 Stage I: Readout Operations For Graph Classification Tasks. Although for node classification tasks, node feature matrix G(l)X_G^(l) can be directly used for subsequent classification tasks, for graph classification tasks, it is necessary to perform a Readout operation [46] to summarize the obtained feature matrix. In this stage, we discuss the latter case. We include common Readout operations such as GLOBAL_MEAN, GLOBAL_MAX, GLOBAL_SUM, GLOBAL_SORT, GLOBAL_ATT, and ZERO in the search space to explore the best Readout method for each layer, aiming to obtain better global graph features. An example of this procedure is depicted in Figure 2. Figure 2: The specific process of N-GNAS in graph classification task. Select Node refers to the process of searching for node selection operations. In contrast, Search GNNs indicates the process of searching for graph neural network operations. A Readout operation is required for the result of each layer, and the Readout result is used as the output of the current layer. 3.3 Search Strategy Design In this part, we discuss the loss functions and the search strategies. 3.3.1 Loss Function The loss functions are composed of two parts: a traditional cross-entropy (CE) fit of the training data and a proposed contrastive learning (CL) Loss to balance model performance and alleviate the problem of over-smoothing. Cross-entropy (CE) Loss. The metric of cross-entropy [8] is frequently utilized in classification problems. When a model’s objective is to minimize this loss, it aligns the predictions more closely with the actual labels, thereby improving its predictive performance. They commonly gauge the disparity between model predictions and actual labels. By minimizing the cross-entropy loss, the model can better fit the training data and enhance accuracy in classification tasks. The cross-entropy loss in our context is defined as follows: Lce=−∑i=1Nyilogy^i+(1−yi)log(1−y^i)N, L_ce=- _i=1^Ny_i y_i+(1-y_i) (1- y_i)N, (15) where yiy_i and y^i y_i represent the ground-truth label and the predicted label of sample i, respectively, N represents the number of nodes in node classification tasks or the number of graphs in graph classification tasks, respectively. Contrastive Learning (CL) Loss. Recent studies highlight the importance of over-smoothing issues in model performance. Thus, besides the CE loss, we propose a contrastive learning loss. While such losses have been adapted in computer vision or GNN, they have seldom been used in GNAS. We propose contrasting the positive and negative samples with a sampling strategy to enhance node-level feature learning. Specifically, we randomly select M samples from the training set and use mim_i to represent the iith sample, which represents the node feature of the i-th node in node classification tasks or the global graph feature of the i-th graph in graph classification tasks. We use cosine similarity to measure the distance between sample i and sample j as follows: cos(mi,mj) cos(m_i,m_j) =mi⋅mj‖mi‖⋅‖mj‖, = m_i· m_j||m_i||·||m_j||, (16) sim(mi,mj) sim(m_i,m_j) =exp(cos(mi,mj)τ), =exp( cos(m_i,m_j)τ), (17) where exp()exp() is the exponential function, τ is a temperature parameter. A pair of samples with the same ground-truth label is considered a positive sample pair, and vice versa, so we can obtain the positive and the negative distances. pos pos =∑i=1M∑j=1Mδyi=yjsim(mi,mj), = _i=1^M _j=1^M _y_i=y_jsim(m_i,m_j), (18) neg neg =∑i=1M∑j=1Mδyi≠yjsim(mi,mj). = _i=1^M _j=1^M _y_i≠ y_jsim(m_i,m_j). (19) where δyi=yj _y_i=y_j equals 11 if yi=yjy_i=y_j, and δyi=yj _y_i=y_j equals 00 otherwise. pospos denotes the contribution of positive samples, and negneg represents the contribution of negative samples. Finally, the loss function is Lcl L_cl =−pospos+neg. =- pospos+neg. (20) It enhances the similarity between positive samples and reduces the similarity between negative samples. Total Loss. Therefore, the final loss function L can be written as L=Lce+Lcl. L=L_ce+L_cl. (21) 3.3.2 Search Strategy Similar to numerous other GNAS methodologies, we utilize the Differentiable Architecture Search (DARTS) [24, 17] to investigate the designed search space. By leveraging a continuous relaxation strategy, DARTS facilitates the conversion of the discrete architecture into a format amenable to gradient-based optimization. In our DAG-based search space, edges connect pairs of cells, and each edge carries a set of candidate operations. For an edge connecting cell p to cell q in layer l, the output is computed as follows: o¯(p,q)(X)=∑o∈(l,p,q)exp(αo(l,p,q))∑o′∈(l,p,q)exp(αo′(l,p,q))o(X), o^(p,q)(X)= _o ^(l,p,q) ( _o^(l,p,q)) _o ^(l,p,q) ( _o ^(l,p,q))\ o(X), (22) where αo(l,p,q)∈ℝ _o^(l,p,q) is a learnable scalar quantifying the contribution of candidate operation o on edge (p,q)(p,q). Crucially, p and q index **cells in the DAG supernetwork** (e.g., the input cell, operation cells, and output cell), not nodes in the original input graph. In the first stage, each operation cell i is directly connected from the input cell to the output cell, forming a star topology. Consequently, the general DARTS weight αo(l,p,q) _o^(l,p,q) reduces to the simpler layer-operation notation αS(l,i) _S^(l,i) used in Eq. (11). Similarly, in the second stage, it reduces to αG(l,i) _G^(l,i) in Eq. (14). The task of architecture search is thus simplified to learning the continuous variables αS(l,i) _S^(l,i) and αG(l,i) _G^(l,i), a problem that can be effectively tackled using DARTS. 3.3.3 Discretization and Final Architecture Once the search phase is complete, the continuous architecture weights are converted into a discrete architecture before retraining. Following the standard DARTS protocol [24], for each layer l, we select the operation with the largest weight and discard all others: iS(l) i_S^(l) =argmaxiαS(l,i),iG(l)=argmaxiαG(l,i), = _i _S^(l,i), i_G^(l)= _i _G^(l,i), (23) where iS(l)i_S^(l) denotes the selected node scoring strategy and iG(l)i_G^(l) denotes the selected graph neural network operation for the l-th layer. This yields a fixed, layer-specific architecture that is then retrained from scratch using the standard training procedure described in Section 4. By deriving a discrete architecture in this manner, we retain the flexibility of the continuous search while producing a compact and efficient model for deployment. 3.4 Interpretability and Explainability In graph learning, interpretable models are those that can provide human-understandable mechanisms to make predictions [47], while results by explainable models are understandable by post hoc explanation techniques [43]. Our proposed approach enhances interpretability by learning a soft gating vector for each layer from seven different scoring perspectives, where each entry indicates how much a node contributes to subsequent GNN processing. By assigning low gate values to nodes that require less further processing, the proposed approach can effectively reduce over-smoothing and enhance discrimination power. For visualization purposes, we binarize the continuous gate values with a threshold of 0.50.5 to highlight which nodes are strongly selected (gate >0.5>0.5, shown in red) versus weakly selected (gate ≤0.5≤ 0.5, shown in green), as detailed in the experiments. In short, the explicit soft gating mechanism provides valuable insights into improving neural network architectures, offering a controllable and effective information filtering mechanism for GNNs, thereby optimizing the learning and information propagation process across deep layers. 4 Experiments 4.1 Experimental setting Datasets and Tasks. We evaluated our approach on two task categories—graph classification and node classification—utilizing eight different datasets: Cora, CiteSeer, PubMed, D&D, PROTEINS, IMDB-MULTI, COX2, and MR. The Cora, CiteSeer, and PubMed datasets are publication citation networks where nodes represent documents and edges denote citations, adhering to the standard train/validation/test split proposed by Yang et al [45]. The D&D and PROTEINS datasets encode protein structures, with nodes representing amino acids and edges formed if the distance between them is less than 6 angstroms. The IMDB-MULTI dataset focuses on movie collaborations, detailing actor/actress and genre information sourced from IMDB, where nodes correspond to actors/actresses and edges indicate their co-appearance in movies. The COX2 dataset includes 467 cyclooxygenase-2 (COX-2) inhibitors, where these compounds are classified based on their activity levels as either active or inactive against human recombinant enzymes in vitro. The MR dataset consists of movie reviews for binary sentiment classification, featuring 5331 positive and 5331 negative reviews, each represented as a single sentence. In these graphs, nodes denote unique words, and edges represent co-occurrences of word pairs within a fixed-size sliding window. Detailed information about the eight datasets can be found in Table 2. Table 2: Statistics of the datasets used in the experiments. For node classification tasks, the terms ”Nodes” and ”Edges” correspond to the cumulative count of nodes and all edges within the datasets. Conversely, ”Nodes” and ”Edges” signify the mean number of nodes and edges across the graphs for graph classification tasks. Task Dataset Graphs Nodes Edges Features Classes Node Classification Cora - 2708 10556 1433 7 Citeseer - 3327 9104 3703 6 PubMed - 19717 88648 500 3 Graph Classification D&D 1178 384.3 715.7 89 2 PROTEINS 1113 39.1 72.8 3 2 IMDB-MULTI 1500 13 65.9 0 3 COX2 467 41.2 43.5 3 2 MR 10654 19.5 73.5 300 2 Compared Methods. We conduct a comparative analysis of N-GNAS against manually crafted GNN architectures and existing NAS methods. The manually crafted baselines encompass: GCN [18], GIN [41], GraphSAGE [16], GAT [35], SGC [40], alongside more powerful baselines such as PNA [7], AP-GCN [34], and DGCNN [48]. Our experiments utilize the widely recognized, open-source library PyTorch Geometric (PyG) [10], which facilitates the implementation of diverse GNN models. We conduct training for each baseline five times across various datasets, using the optimal hyperparameters specified in the paper. We present the mean accuracy and variability measure to assess the models’ evaluative performance. Furthermore, we compare with a suite of GNAS baselines, including (I) GraphNAS [14], an RL-based method incorporating a parameter-sharing scheme. (I) SNAG [51], an RL-based GNAS method emphasizing the combination of nodes and layers. (I) SANE [17], a GD-based method that operates on a search space comprising the combination of nodes and layers along with skip-connections (IV) PAS [39], a GD-based GNAS method approach that integrates Aggregation, Pooling, Readout, and Merge components. (V) Genetic-GNN [33], an EA-based GNAS method that dynamically adapts the interplay between the GNN model structure and hyperparameters through an alternating evolutionary process, aiming to find the optimal combination of GNN model structure and hyperparameters. (VI) KEGNAS [36], a knowledge‑aware EA-based GNAS method that transfers prior knowledge from NAS‑Bench‑Graph[27] via a knowledge model and a deep multi‑output Gaussian process (DMOGP) to warm‑start an evolutionary algorithm for optimizing accuracy and model size. (VII) DFG-NAS [49], an EA-based GNAS method concentrating on macro-architecture design, involves integrating and organizing propagation and transformation operations into GNNs to optimize GNN architectures. (VIII) ExGNAS[29], an explainable Graph NAS method based on Monte‑Carlo tree search that improves interpretability via a simple search space and decision‑traceable architecture selection. Searching setting. In our implementation of N-GNAS, we delineate a two-stage search space within each layer, comprising seven and five operational cells, respectively, denoted by nc=7,5n_c=7,5. To ensure experimental consistency, the depth of our model is consistently set to two layers. We allocate half of the available training data for the search process for validation purposes. We adopt DARTS as our search strategy, where the operation weights, architecture parameters, and the corresponding optimizer are configured similarly to previous works [17, 51]. Furthermore, we initiate the architecture search with distinct random seeds on eight diverse datasets, each employing a 2-layer GNN model throughout 100 epochs. The batch size is standardized to 64, and the node feature dimensionality is upscaled to 64. Through this sequence of eight architectural searches, we successfully identify the premier architectural configuration on most datasets, with the top-1 architecture prevailing on seven datasets and the top-2 on one remaining dataset. Training setting. In the training phase, we follow the configurations employed in earlier studies [3], which encompass data splitting, optimizer selection, feature dimension adjustment, batch normalization, and the inclusion of residual connections. In particular, we employed the Adam optimizer with an initial learning rate 1e-5 for different datasets. To alleviate overfitting, a dropout rate of 0.2 was used. We conducted five repetitions of the top-1 architecture identified on the validation dataset, each for 400 epochs, using a batch size of 64. Ultimately, We reported the average performance and standard deviation of the top-1 architecture on the validation dataset. All experiments used a single NVIDIA GeForce RTX 3090 GPU (with 24GB memory, CUDA version 11.2). 4.2 Results and Analysis Results on node classification task. Cora originates from machine learning papers across various disciplines, CiteSeer is sourced from academic papers in computer science, and PubMed encompasses research content from multiple biomedical domains. These datasets are commonly employed for node classification tasks. The main reason is that current manually crafted and NAS methods in architecture design consider using the same number of graph neural networks for each node, leading to over-smoothing. Table 3 and Figure 3 present the results of the node classification task on the Cora, CiteSeer, and PubMed datasets. Our node classification performance surpasses current models, showing a 1.3% increase in test accuracy, highlighting our approach’s efficacy. Table 3: Node classification task accuracy on the Cora, CiteSeer, and PubMed datasets. The top three are emphasized by first, second, and third. Methods Cora CiteSeer PubMed GCN [18] 86.09±0.50 74.64±0.20 88.96±0.29 GIN [41] 85.68±0.61 73.40±0.14 88.23±0.28 GraphSAGE [16] 85.66±0.52 74.59±0.63 89.21±0.29 GAT [35] 85.92±0.72 74.26±0.13 88.67±0.19 SGC [40] 85.31±0.86 72.94±0.98 88.40±0.25 PNA [7] 85.06±0.72 75.06±0.61 87.18±0.30 manually crafted AP-GCN [34] 86.75±0.29 75.64±0.75 89.79±0.26 GraphNAS [14] 86.69±0.71 76.32±0.61 87.93±0.16 SNAG [51] 84.99±1.04 75.94±1.27 88.44±0.25 SANE [17] 86.40±0.38 76.72±0.98 89.34±0.31 Genetic-GNN [33] 86.99±0.60 77.29±0.72 89.37±0.26 KEGNAS [36] 82.44±0.23 71.05±0.22 78.24±0.36 DFG-NAS [49] 87.42±0.42 77.04±0.68 89.73±0.20 ExGNAS [29] 88.50±0.01 74.7±0.02 89.3±0.10 NAS N-GNAS 88.59±0.63 78.26±0.42 90.27±0.48 Results on graph classification task. Our model’s performance in graph classification tasks was assessed through experiments conducted on the D&D, PROTEINS, IMDB-MULTI, COX2, and MR datasets. The results in Table 4 show that our model achieves excellent results in this domain, similar to the node classification tasks. Compared to manually crafted and NAS methods, our model outperforms the baselines by 0.7% on the D&D dataset and by 0.6% on the PROTEINS dataset. Table 4: Graph classification task accuracy on the D&D, PROTEINS, IMDB-MULTI, COX2, and MR datasets. The top three are emphasized by first, second, and third. Methods D&D PROTEINS IMDB-MULTI COX2 MR GCN [18] 76.98±4.43 72.94±1.82 50.25±3.42 78.68±1.92 75.62±0.85 GIN [41] 73.95±2.98 73.68±2.78 50.04±2.75 80.52±3.41 76.05±0.74 GraphSAGE [16] 76.78±4.06 72.58±2.43 49.62±4.58 79.63±2.63 76.85±0.63 GAT [35] 75.14±2.84 74.29±1.69 49.85±3.65 81.16±3.64 76.92±1.02 manually crafted DGCNN [48] 76.66±4.03 73.28±3.16 49.63±3.73 80.16±3.23 77.06±0.68 GraphNAS [14] 73.56±2.47 73.12±4.27 47.23±4.59 78.91±2.37 76.37±2.17 SNAG [51] 74.46±2.69 71.98±3.42 49.38±1.79 79.32±2.74 76.23±2.61 SANE [17] 73.62±3.82 72.23±3.86 49.92±3.71 80.04±2.62 77.27±2.12 PAS [39] 77.46±3.68 74.85±2.93 50.07±2.94 82.16±3.95 76.72±2.29 NAS N-GNAS 78.03±3.64 75.30±3.27 51.62±3.51 81.29±4.17 78.27±1.95 Figure 3: Results of various methods on the Cora, CiteSeer, and PubMed datasets. Different colors represent different methods. It can be found that our work achieves the best results on both datasets Figure 4: Performance of the model with different numbers of layers. Different colors represent different methods. It can be found that our work achieves the best results on both datasets (a) the first layer (b) the second layer Figure 5: Node selection results obtained by the first and the second layer of graph neural networks optimized with N-GNAS. Red nodes (gate value >0.5>0.5) are strongly selected for GNN processing, while green nodes (gate value ≤0.5≤ 0.5) mostly bypass GNN operations via residual connections. Discussion of different layers. As illustrated in Figure 4, we investigate the performance of our method on the Cora and PubMed datasets across various layers. We compared N-GNAS with several baselines, including GCN, GAT, SANE, and DFG-NAS, in terms of accuracy for different numbers of layers. As depicted in Figure 4, we conclude that GNAS’s performance remains stable as the layers’ depth increases, outperforming other baselines. However, the performance of the baselines relative to N-GNAS is lower, and it decreases as the depth increases, indicating the occurrence of over-smoothing issues in these baselines. Therefore, N-GNAS can simultaneously consider model performance and alleviate over-smoothing problems. Explainability of the search results. We conducted comprehensive experiments to explain the results on the Cora dataset, as illustrated in Figure 5. The first layer of the obtained network determined by N-GNAS uses the fifth metric, the local structural feature scoring, as the node selection metric, and thus, the selected nodes in red are typical with larger degrees, as shown in Figure 5a. In the second layer, the fourth metric, the global position scoring, is used as the node selection metric, indicating that more central nodes with shorter overall distances to others are more likely to be selected, as shown in Figure 5b. These results demonstrated the explainability. Moreover, the prediction quality benefits directly from this mechanism: as shown in Table 5, the accuracy gap between N-GNAS and its variant without node selection widens from 1.58% (1 layer) to 4.19% (5 layers), confirming that the learned gating structure becomes increasingly critical for maintaining discriminative predictions in deeper models. The explainability can also be perceived from the ablation study, as shown in Table 5. Over-smoothing can significantly deteriorate model effectiveness in traditional GNNs as the number of layers increases. Nevertheless, the N-GNAS framework mitigates the negative impact of increased layer depth on performance, which indicates that it reduces the over-smoothing by only using selected nodes for further processing. Table 5: Performance of N-GNAS with varying layers on the Cora dataset. We present the test accuracy results for N-GNAS without Node Selection Operations and for N-GNAS with these operations. Cora Layer Stage I N-GNAS 1 76.93±0.49 78.51±1.13 2 86.36±1.12 88.59±0.63 3 84.43±0.71 87.92±0.68 4 82.71±0.83 85.43±0.66 5 79.57±0.55 83.76±0.47 Ablation study. An ablation study was carried out to showcase the efficacy of our custom-designed search space and loss function. Table 6 compares N-GNAS against two baseline models: (1) Random: randomly selecting one architecture without neural architecture search, and (2) LceL_ce: using only the cross-entropy loss LceL_ce in the loss function while turning off LclL_cl. For models that did not utilize our search space and instead employed a randomly chosen fixed architecture, the accuracy decreased by 1.8-4.6%. This decrease is attributed to the inability of the model to assign appropriate graph neural network counts to different nodes without using the proper Node-wise optimal convolution selection operation and Graph convolution, leading to performance degradation. For models that did not employ LclL_cl and only used LceL_ce, the accuracy decreased by 1.8-2.5%. This decrease is because not using LclL_cl only considers the model’s performance while ignoring the over-smoothing issue, posing a risk of over-smoothing. These ablation studies indicate the effectiveness of our designed search space and loss function. Table 6: Ablation study on search space and loss function. Methods Cora CiteSeer PubMed Random 85.74 74.63 88.62 LceL_ce 86.94 76.52 87.98 N-GNAS 88.59 78.26 90.27 5 Conclusion This work proposes an innovative N-GNAS model for graph neural architecture search. This framework is distinguished by its adaptability and generality, featuring a dynamic search space for the optimal count of graph neural networks. It facilitates the discovery of superior GNN configurations by integrating node-wise optimal convolution selection and graph neural network operation. A novel loss function has been engineered to balance model performance challenges and the over-smoothing phenomenon. It demonstrates strong competitiveness against manually crafted GNNs across various tasks. Furthermore, a two-phase search approach is presented to enhance search efficiency. Broad experimental results spanning multiple graph learning tasks demonstrate the effectiveness of our method, with graphical illustrations of the outcomes reinforcing widely accepted insights. References [1] P. W. Battaglia, J. B. Hamrick, V. Bapst, A. Sanchez-Gonzalez, V. Zambaldi, M. Malinowski, A. Tacchetti, D. Raposo, A. Santoro, R. Faulkner, et al. (2018) Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261. Cited by: §1. [2] X. Bresson and T. Laurent (2017) Residual gated graph convnets. arXiv preprint arXiv:1711.07553. Cited by: §2.1, Table 1. [3] S. Cai, L. Li, J. Deng, B. Zhang, Z. Zha, L. Su, and Q. Huang (2021) Rethinking graph neural architecture search from message-passing. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 6657–6666. Cited by: §4.1. [4] S. Cai, L. Li, X. Han, J. Luo, Z. Zha, and Q. Huang (2022) Automatic relation-aware graph network proliferation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 10863–10873. Cited by: §1, §2.2. [5] J. Chen, J. Gao, Z. Wu, R. Al-Sabri, and B. M. Oloulade (2024) Decoupled differentiable graph neural architecture search. Information Sciences 673, p. 120700. External Links: ISSN 0020-0255, Document Cited by: §2.2. [6] Y. Chen, J. You, J. He, Y. Lin, Y. Peng, C. Wu, and Y. Zhu (2023) SP-gnn: learning structure and position information from graphs. Neural Networks 161, p. 505–514. Cited by: §1. [7] G. Corso, L. Cavalleri, D. Beaini, P. Liò, and P. Veličković (2020) Principal neighbourhood aggregation for graph nets. Advances in Neural Information Processing Systems 33, p. 13260–13271. Cited by: §4.1, Table 3. [8] P. De Boer, D. P. Kroese, S. Mannor, and R. Y. Rubinstein (2005) A tutorial on the cross-entropy method. Annals of operations research 134, p. 19–67. Cited by: §3.3.1. [9] M. Defferrard, X. Bresson, and P. Vandergheynst (2016) Convolutional neural networks on graphs with fast localized spectral filtering. Advances in neural information processing systems 29. Cited by: §2.1. [10] M. Fey and J. E. Lenssen (1903) Fast graph representation learning with pytorch geometric. arxiv 2019. arXiv preprint arXiv:1903.02428. Cited by: §4.1. [11] R. W. Floyd (1962) Algorithm 97: shortest path. Communications of the ACM 5 (6), p. 345–345. Cited by: §3.2.1. [12] X. Fu, J. Zhang, Z. Meng, and I. King (2020) Magnn: metapath aggregated graph neural network for heterogeneous graph embedding. In Proceedings of The Web Conference 2020, p. 2331–2341. Cited by: §1, §2.2. [13] J. Gao, J. Chen, B. M. Oloulade, R. Al-Sabri, T. Lyu, J. Zhang, and Z. Li (2023) Commgnas: unsupervised graph neural architecture search for community detection. IEEE Transactions on Emerging Topics in Computing. Cited by: §1. [14] Y. Gao, H. Yang, P. Zhang, C. Zhou, and Y. Hu (2021) Graph neural architecture search. In International joint conference on artificial intelligence, Cited by: §1, §2.2, §4.1, Table 3, Table 4. [15] Y. Gao, P. Zhang, Z. Li, C. Zhou, Y. Liu, and Y. Hu (2021) Heterogeneous graph neural architecture search. In 2021 IEEE International Conference on Data Mining (ICDM), p. 1066–1071. Cited by: §1, §2.2. [16] W. Hamilton, Z. Ying, and J. Leskovec (2017) Inductive representation learning on large graphs. Advances in neural information processing systems 30. Cited by: §2.1, §2.1, Table 1, §4.1, Table 3, Table 4. [17] Z. Huan, Y. Quanming, and T. Weiwei (2021) Search to aggregate neighborhood for graph neural network. In 2021 IEEE 37th International Conference on Data Engineering (ICDE), p. 552–563. Cited by: §1, §2.2, §3.3.2, §4.1, §4.1, Table 3, Table 4. [18] T. N. Kipf and M. Welling (2016) Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907. Cited by: §1, §2.1, §2.1, Table 1, §4.1, Table 3, Table 4. [19] A. Kumar, S. S. Singh, K. Singh, and B. Biswas (2020) Link prediction techniques, applications, and performance: a survey. Physica A: Statistical Mechanics and its Applications 553, p. 124289. Cited by: §1. [20] X. Li, Q. Xu, Z. Xu, H. Zhang, and L. Xu (2023) Graph reconfigurable pooling for graph representation learning. IEEE Transactions on Emerging Topics in Computing 12 (1), p. 139–149. Cited by: §1. [21] Y. Li, Z. Wen, Y. Wang, and C. Xu (2021) One-shot graph neural architecture search with dynamic search space. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 35, p. 8510–8517. External Links: Document Cited by: §2.2. [22] D. Liben-Nowell and J. Kleinberg (2003) The link prediction problem for social networks. In Proceedings of the twelfth international conference on Information and knowledge management, p. 556–559. Cited by: §1. [23] H. Liu, K. Simonyan, O. Vinyals, C. Fernando, and K. Kavukcuoglu (2017) Hierarchical representations for efficient architecture search. arXiv preprint arXiv:1711.00436. Cited by: §2.2. [24] H. Liu, K. Simonyan, and Y. Yang (2018) Darts: differentiable architecture search. arXiv preprint arXiv:1806.09055. Cited by: §1, §2.2, §3.3.2, §3.3.3. [25] L. Lü and T. Zhou (2011) Link prediction in complex networks: a survey. Physica A: statistical mechanics and its applications 390 (6), p. 1150–1170. Cited by: §1. [26] R. Miao, K. Zhou, Y. Wang, N. Liu, Y. Wang, and X. Wang (2024) Rethinking independent cross-entropy loss for graph-structured data. arXiv preprint arXiv:2405.15564. Cited by: §1. [27] Y. Qin, Z. Zhang, X. Wang, Z. Zhang, and W. Zhu (2022) NAS-bench-graph: benchmarking graph neural architecture search. Advances in Neural Information Processing Systems 35, p. 54–69. Cited by: §4.1. [28] E. Ranjan, S. Sanyal, and P. Talukdar (2020) Asap: adaptive structure aware pooling for learning hierarchical graph representations. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 34, p. 5470–5477. Cited by: §3.2.1. [29] Y. Sasaki (2025) Explainable graph neural architecture search via monte-carlo tree search. In 2025 IEEE International Conference on Big Data (BigData), Vol. , p. 752–757. External Links: Document Cited by: §4.1, Table 3. [30] M. Schlichtkrull, T. N. Kipf, P. Bloem, R. Van Den Berg, I. Titov, and M. Welling (2018) Modeling relational data with graph convolutional networks. In The Semantic Web: 15th International Conference, ESWC 2018, Heraklion, Crete, Greece, June 3–7, 2018, Proceedings 15, p. 593–607. Cited by: §1, §2.2, §2.2. [31] X. Shen, P. Lio, L. Yang, R. Yuan, Y. Zhang, and C. Peng (2024) Graph rewiring and preprocessing for graph neural networks based on effective resistance. IEEE Transactions on Knowledge and Data Engineering. Cited by: §1. [32] X. Shen, Y. Wang, K. Zhou, S. Pan, and X. Wang (2024) Optimizing ood detection in molecular graphs: a novel approach with diffusion models. arXiv preprint arXiv:2404.15625. Cited by: §1. [33] M. Shi, Y. Tang, X. Zhu, Y. Huang, D. Wilson, Y. Zhuang, and J. Liu (2022) Genetic-gnn: evolutionary architecture search for graph neural networks. Knowledge-Based Systems 247, p. 108752. Cited by: §2.2, §4.1, Table 3. [34] I. Spinelli, S. Scardapane, and A. Uncini (2021) Adaptive propagation graph convolutional network. IEEE transactions on neural networks and learning systems 32 (10), p. 4755–4760. Cited by: §4.1, Table 3. [35] P. Veličković, G. Cucurull, A. Casanova, A. Romero, P. Lio, and Y. Bengio (2017) Graph attention networks. arXiv preprint arXiv:1710.10903. Cited by: §2.1, §2.1, Table 1, §4.1, Table 3, Table 4. [36] C. Wang, J. Zhao, L. Li, L. Jiao, F. Liu, X. Liu, and S. Yang (2025) Knowledge-aware evolutionary graph neural architecture search. Knowledge-Based Systems 309, p. 112810. External Links: ISSN 0950-7051, Document, Link Cited by: §2.2, §4.1, Table 3. [37] X. Wang, H. Ji, C. Shi, B. Wang, Y. Ye, P. Cui, and P. S. Yu (2019) Heterogeneous graph attention network. In The world wide web conference, p. 2022–2032. Cited by: §1. [38] Y. Wang, W. Wang, Y. Chang, C. Tsai, T. Kuo, C. Wu, C. Ho, and H. Hu (2023) TCAM-gnn: a tcam-based data processing strategy for gnn over sparse graphs. IEEE Transactions on Emerging Topics in Computing. Cited by: §1. [39] L. Wei, H. Zhao, Z. He, and Q. Yao (2023) Neural architecture search for gnn-based graph classification. ACM Transactions on Information Systems. Cited by: §2.2, §4.1, Table 4. [40] F. Wu, A. Souza, T. Zhang, C. Fifty, T. Yu, and K. Weinberger (2019) Simplifying graph convolutional networks. In International conference on machine learning, p. 6861–6871. Cited by: §2.1, §4.1, Table 3. [41] K. Xu, W. Hu, J. Leskovec, and S. Jegelka (2018) How powerful are graph neural networks?. arXiv preprint arXiv:1810.00826. Cited by: §1, §2.1, Table 1, §4.1, Table 3, Table 4. [42] K. Xu, C. Li, Y. Tian, T. Sonobe, K. Kawarabayashi, and S. Jegelka (2018) Representation learning on graphs with jumping knowledge networks. In International conference on machine learning, p. 5453–5462. Cited by: §2.1. [43] H. Xuanyuan, P. Barbiero, D. Georgiev, L. C. Magister, and P. Liò (2023) Global concept-based interpretability for graph neural networks via neuron analysis. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 37, p. 10675–10683. Cited by: §3.4. [44] G. Xue, M. Zhong, T. Qian, and J. Li (2024) PSA-gnn: an augmented gnn framework with priori subgraph knowledge. Neural Networks 173, p. 106155. Cited by: §1. [45] Z. Yang, W. Cohen, and R. Salakhudinov (2016) Revisiting semi-supervised learning with graph embeddings. In International conference on machine learning, p. 40–48. Cited by: §4.1. [46] Z. Ying, J. You, C. Morris, X. Ren, W. Hamilton, and J. Leskovec (2018) Hierarchical graph representation learning with differentiable pooling. Advances in neural information processing systems 31. Cited by: §3.2.3. [47] H. Yuan, H. Yu, S. Gui, and S. Ji (2022) Explainability in graph neural networks: a taxonomic survey. IEEE transactions on pattern analysis and machine intelligence 45 (5), p. 5782–5799. Cited by: §3.4. [48] M. Zhang, Z. Cui, M. Neumann, and Y. Chen (2018) An end-to-end deep learning architecture for graph classification. In Proceedings of the AAAI conference on artificial intelligence, Vol. 32. Cited by: §4.1, Table 4. [49] W. Zhang, Z. Lin, Y. Shen, Y. Li, Z. Yang, and B. Cui (2022) Deep and flexible graph neural architecture search. In International Conference on Machine Learning, p. 26362–26374. Cited by: §2.2, §4.1, Table 3. [50] Z. Zhang, X. Wang, and W. Zhu (2021) Automated machine learning on graphs: a survey. arXiv preprint arXiv:2103.00742. Cited by: §2.2. [51] H. Zhao, L. Wei, and Q. Yao (2020) Simplifying architecture search for graph neural network. arXiv preprint arXiv:2008.11652. Cited by: §2.2, §4.1, §4.1, Table 3, Table 4. [52] B. Zoph and Q. V. Le (2016) Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578. Cited by: §1, §2.2.