Title: GraphPatcher: Mitigating Degree Bias for Graph Neural Networks via Test-time Augmentation
Venue: NeurIPS 2023
Accepted: yes
Keywords: Graph neural network

Test-time Augmentation
Abstract: Recent studies have shown that graph neural networks (GNNs) exhibit strong biases towards the node degree: they usually perform satisfactorily on high-degree nodes with rich neighbor information but struggle with low-degree nodes. Existing works tackle this problem by deriving either designated GNN architectures or training strategies specifically for low-degree nodes. Though effective, these approaches unintentionally create an artificial out-of-distribution scenario, where models mainly or even only observe low-degree nodes during the training, leading to a downgraded performance for high-degree nodes that GNNs originally perform well at. In light of this, we propose a test-time augmentation framework, namely GraphPatcher, to enhance test-time generalization of any GNNs on low-degree nodes. Specifically, GraphPatcher iteratively generates virtual nodes to patch artificially created low-degree nodes via corruptions, aiming at progressively reconstructing target GNN's predictions over a sequence of increasingly corrupted nodes. Through this scheme, GraphPatcher not only learns how to enhance low-degree nodes (when the neighborhoods are heavily corrupted) but also preserves the original superior performance of GNNs on high-degree nodes (when lightly corrupted). Additionally, GraphPatcher is model-agnostic and can also mitigate the degree bias for either self-supervised or supervised GNNs. Comprehensive experiments are conducted over seven benchmark datasets and GraphPatcher consistently enhances common GNNs' overall performance by up to 3.6% and low-degree performance by up to 6.5%, significantly outperforming state-of-the-art baselines. The source code is publicly available at https://github.com/jumxglhf/GraphPatcher.

GRAPHPATCHER: Mitigating Degree Bias for Graph Neural Networks via Test-time Augmentation

Abstract

Recent studies have shown that graph neural networks (GNNs) exhibit strong biases towards the node degree: they usually perform satisfactorily on high-degree nodes with rich neighbor information but struggle with low-degree nodes. Existing works tackle this problem by deriving either designated GNN architectures or training strategies specifically for low-degree nodes. Though effective, these approaches unintentionally create an artificial out-of-distribution scenario, where models mainly or even only observe low-degree nodes during the training, leading to a downgraded performance for high-degree nodes that GNNs originally perform well at. In light of this, we propose a test-time augmentation framework, namely GRAPHPATCHER, to enhance test-time generalization of any GNNs on low-degree nodes. Specifically, GRAPHPATCHER iteratively generates virtual nodes to patch artificially created low-degree nodes via corruptions, aiming at progressively reconstructing target GNN's predictions over a sequence of increasingly corrupted nodes. Through this scheme, GRAPHPATCHER not only learns how to enhance low-degree nodes (when the neighborhoods are heavily corrupted) but also preserves the original superior performance of GNNs on high-degree nodes (when lightly corrupted). Additionally, GRAPHPATCHER is model-agnostic and can also mitigate the degree bias for either self-supervised or supervised GNNs. Comprehensive experiments are conducted over seven benchmark datasets and GRAPHPATCHER consistently enhances common GNNs' overall performance by up to 3.6% and low-degree performance by up to 6.5%, significantly outperforming state-of-the-art baselines. The source code is publicly available at https://github.com/jumxglhf/GraphPatcher .

1 Introduction

Graph Neural Networks (GNNs) have gained significant popularity as a powerful approach for learning representations of graphs, achieving state-of-the-art performance on various predictive tasks, such as node classification [22, 38, 9], link prediction [50, 53], and graph classification [43, 47, 11]. These tasks further form the archetypes of many real-world applications, such as recommendation systems [45, 3], predicative user behavior models [31, 52], and molecular property prediction [51, 48].

While existing GNNs are highly proficient at capturing information from rich neighborhoods (i.e., high-degree nodes), recent studies [13, 25, 36, 55] have revealed a significant performance degradation of GNNs when dealing with nodes that have sparse neighborhoods (i.e., low-degree nodes). This observation can be attributed to the fact that GNNs make predictions based on the distribution of node neighborhoods [27]. According to this line of theory, GNNs struggle with low-degree nodes due to the limited amount of available neighborhood information, which may not be able to precisely depict the learned distributions. Empirically, as shown in Figure 1, the classification accuracy of GCN [22] proportionally decays as the node degree decreases, resulting in a performance gap of ∼ 20% accuracy. Furthermore, the sub-optimal performance of GNNs on low-degree nodes can be

Node Degree vs. Accuracy across SoTA

0

100

200

300

400

500

600

60

65

70

75

80

85

90

1~2

3~4

5~6

7~8

9~10

50

150

250

350

450

70

75

80

85

90

95

100

1~2

3~4

5~6

7~8

9~10

GCN

TuneUp

Tail-GNN

ColdBrew

GraphPatcher

# of Nodes

Acc (%)

# of Nodes

Degree

Acc (%)

# of Nodes

Degree

Graph: Citeseer

GCN Overall

GCN Overall

aggravated by the power-law degree distribution commonly observed in real-world graphs, where the number of low-degree nodes significantly exceeds that of high-degree nodes [36].

To bridge this gap, several frameworks have been proposed to specifically improve GNNs' performance on low-degree nodes [36, 25, 13, 55, 49]. These frameworks either introduce designated architectures or training strategies specifically for low-degree nodes. For examples, Tail-GNN [25] enhances latent representations of low-degree nodes by incorporating high-degree structural information; whereas Coldbrew [55] retrieves a set of existing nodes as virtual neighbors for low-degree nodes. However, these approaches suffer from two significant drawbacks. Firstly, while benefiting low-degree nodes, they inadvertently create an artificial out-of-distribution scenario during training [42], where models primarily observe low-degree nodes, leading to a downgraded performance for high-degree nodes that GNNs originally perform well on. Secondly, deploying these frameworks often requires changing model architectures, which can be impractical in real-world scenarios where the original models are well-trained due to the expensive re-training cost (on large-scale graphs) and the shared usage of it across different functionalities in production.

In light of these drawbacks, we propose a test-time augmentation framework for GNNs, namely GRAPHPATCHER. Given a well-trained GNN, GRAPHPATCHER mitigates the degree bias by patching corrupted ego-graphs with multiple generated virtual neighbors. Notably, GRAPHPATCHER not only enhances the performance of low-degree nodes but also maintains (sometimes improves) GNNs performance on high-degree nodes. This behavior is empirically important because practitioners can universally apply GRAPHPATCHER to all nodes without, like previous works, manually discovering a degree threshold that differentiates the low- and high-degree nodes. To achieve so, we first generate a sequence of ego-graphs corrupted with increasing strengths. Then, GRAPHPATCHER recursively generates multiple virtual nodes to patch the mostly corrupted graph, such that the frozen GNN gives similar predictions for the patched graph and the corresponding corrupted ego-graph in the sequence. Through this scheme, GRAPHPATCHER not only learns how to patch low-degree nodes (i.e., heavily corrupted) but also maintains GNNs original superior performance on high-degree nodes (i.e., lightly corrupted). As a test-time augmentation framework, GRAPHPATCHER is parameterized in parallel with the target GNN. Hence, GRAPHPATCHER is model-agnostic and requires no updates on the target GNN, enabling practitioners to easily utilize it as a plug-and-play module to existing well-established infrastructures. Overall, our contributions are summarized as:

We study a more practical setting of degree biases on graphs, where both the performances on low- and high-degree nodes are considered. In this case, a good framework is required to not only improve the performance over low-degree nodes but also maintain the original superior performance over high-degree nodes. We evaluate existing frameworks in this setting and observe that many of them trade off performance on high-degree nodes for that on low-degree nodes.

To mitigate degree biases, we propose GRAPHPATCHER, a novel test-time augmentation framework for graphs. Given a well-trained GNN, GRAPHPATCHER iteratively generates multiple virtual nodes and uses them to patch the original ego-graphs. These patched ego-graphs not only improve GNNs' performance on low-degree nodes but also maintains that over high-degree nodes. Moreover, GRAPHPATCHER is applied at the testing time for GNNs, a plug-and-play module that is easily applicable to existing well-established infrastructures.

We conduct extensive evaluation of GRAPHPATCHER along with six state-of-the-art frameworks that mitigate degree biases on seven benchmark datasets. GRAPHPATCHER consistently enhances the overall performance by up to 3.6% and low-degree performance by up to 6.5% of multiple GNNs, significantly outperforming state-of-the-art baselines.

2 Related Works

Graph Neural Networks . Graph Neural Networks (GNNs) have become one of the most popular paradigms for learning representations over graphs [22, 38, 9, 43, 23, 17, 4]. GNNs aim at mapping the input nodes into low-dimensional vectors, which can be further utilized to conduct either graphlevel or node-level tasks. Most GNNs explore a layer-wise message passing scheme, where a node iteratively extracts information from its first-order neighbors, and information from multi-hop neighbors can be captured by stacked layers. They achieved state-of-the-art performance on various tasks, such as node classification [22, 44, 12, 35], link prediction [50, 53, 8], node clustering [2, 37], etc. These tasks further form the archetypes of many real-world applications, such as recommendation systems [45, 3], predictive user behavior models [31, 52], question answering [18], and molecular property prediction [51, 48, 7, 24].

Degree Bias underlying GNNs . Recent studies have shown that GNNs exhibit strong biases towards the node degree: they usually perform satisfactorily over high-degree nodes with rich neighbor information but suffer over low-degree nodes [13, 25, 36, 55]. Existing frameworks that mitigate degree biases derive either designated architectures or training strategies specifically for low-degree nodes. For instance, Tail-GNN [25] enhances low-degree nodes' latent representations by injecting high-degree structural information learned from high-degree nodes; Coldbrew [55] retrieves a set of existing nodes as virtual neighbors for low-degree nodes; TuneUp [13] fine-tunes the well-trained GNNs with pseudo labels and heavily corrupted graphs. Though effective for low-degree nodes, they unintentionally create an artificial out-of-distribution scenario [42], where models only observe low-degree nodes during the training, leading to downgraded performance for high-degree nodes that GNNs originally perform well at.

Test-time Augmentation . While data augmentations during the training phase have become one of the essential ingredients for training machine learning models [54], the augmentation applied during the testing time is far less studied, especially for the graph learning community. It has been moderately researched in the computer vision field, aimed at improving performance or mitigating uncertainties [34, 21, 41, 1]. They usually corrupt the same sample by different augmentation approaches and aggregate the model's predictions on all corrupted samples. Whereas in the graph community, GTrans [15] proposes a test-time enhancement framework, where the node feature and graph topology are modified at the test time to mitigate potential out-of-distribution scenarios.

3 Methodology

3.1 Preliminary

In this work, we specifically focus on the node classification task. Let G = ( V, E ) denote a graph, where V is the set of | V | = N nodes and E ⊆ V × V is the set of | E | edges between nodes. X ∈ R N × d represents the feature matrix, with i -th row representing node v i 's d -dimensional feature vector. Y ⊆ { 0 , 1 } N × C denotes the label matrix, where C is the number of total classes. And Y ( L ) denotes the label matrix for training nodes. We denote the ego-graph of node v i is defined as G ( v i ) = ( V i , E i ) with V i = N k ( v i ) , where N k ( v i ) stands for all nodes within the k -hop neighborhood of v i including itself and E i refers to the edges in-between N k ( v i ) . A well-trained GNN f g ( · ; θ ) : G → R N × C parameterized by θ takes G as input and maps every node in G to a C -dimensional class distribution. Formally, we define test-time node patching as the following:

Definition 1 (Test-time Node Patching) . Given a GNN f g ( · ; θ ) and a graph G, a test-time node patching framework f ( · ; ϕ ) : G → G takes G and outputs the patched graph ˆ G with generated nodes and edges, such that the performance of f g over nodes in G is enhanced when ˆ G is utilized:

where L refers to the loss function evaluating the GNN (e.g., cross-entropy or accuracy).

In this work, we aim at mitigating the degree bias via test-time node patching. To achieve so, two challenges need to be addressed: (1) how to optimize and formulate f ( · ; ϕ ) , such that the graphs patched by f ( · ; ϕ ) enhance the performance of f g ( · ; θ ∗ ) over low-degree nodes; and (2) how to derive a unified learning scheme that allows f ( · ; ϕ ) to not only improve low-degree nodes but also maintain the GNN's original superiority over high-degree nodes.

Increasing Corruption Strength

Original Ego-graph

(Low-degree case)

(High-degree case)

Intermediate Ego-graph

1

GraphPatcher

1

2

GraphPatcher

GraphPatcher

1

2

3

Real Neighbor

Patching Node

Feed-forward

Gradient Descent

Patching from the most

corrupted graph

Target GNN

𝑓(•; 𝜽

)

≈

KL Divergence Matching

Target GNN

𝑓(•; 𝜽

)

≈

KL Divergence Matching

Target GNN

𝑓(•; 𝜽

)

≈

KL Divergence Matching

3.2 The Proposed Framework: GRAPHPATCHER

Our proposed GRAPHPATCHER is a test-time augmentation framework for GNNs to mitigate their degree biases. As shown in Figure 2, GRAPHPATCHER is presented a sequence of ego-graphs corrupted by increasing strengths. Starting from the most corrupted graphs, GRAPHPATCHER iteratively generates patching nodes to augment the anchor nodes. Compared with the corrupted graphs next in the hierarchy, the patched graphs should allow the target GNN to deliver similar outputs. Through this scheme, GRAPHPATCHER not only learns how to patch low-degree nodes while preserving the superior performance over high-degree nodes.

3.2.1 Patching Ego-graphs via Prediction Reconstruction

In order to patch low-degree nodes, a straightforward approach is to corrupt high-degree nodes into low-degree nodes, and allowing the learning model to patch the corrupted nodes to restore their original properties [25, 13]. However, patching low-degree nodes not only affects their own representations but also those of their neighbors due to the message-passing mechanism of GNNs as well as the non-i.i.d. property of nodes in a graph. Besides, modeling over the entire graphs requires the learning model to consider all potential circumstances, whose overheads grow quadratically w.r.t. the number of nodes. Consequently, it becomes challenging to simultaneously determine both features and neighbors of the patching nodes given the entire graph.

To reduce the complexity of the optimization process, instead of working over the entire graph, we conduct node patching over ego-graphs and regard each ego-graph as an i.i.d. sample of the anchor node [56, 19]. For each node v i , we have f g ( G ; θ )[ v i ] = f g ( G ( v i ); θ )[ v i ] if k equals to the number of layers in f g ( · ; θ ) . To further simplify the optimization process, we directly wire the generated virtual nodes to the anchor node (i.e., the generated virtual nodes are the first-order neighbors of the anchor node). This implementation is simple yet effective, because we no longer consider the location to place the patching node: any modification that affects the latent representation of the anchor node can be achieved by patching nodes (with different features) directly to the anchor nodes.

We start explaining GRAPHPATCHER by the most basic case where we only conduct node patching once. Specifically, given the a trained GNN f g ( · ; θ ∗ ) , an anchor node v i , and a corruption function T ( · ; t ) with strength t (i.e., first-order neighbor dropping with probability t to simulate a low-degree

scenario), that is, G ′ ( v i ) = ( V ′ ( v i ) , E ′ ( v i )) = T ( G ( v i ) , t ) . GRAPHPATCHER f ( · ; ϕ ) takes the corrupted ego-graph G ′ ( v i ) as input and outputs the augmented ego-graph ˆ G ( v i ) with a patching node v p and its feature x p , which is directly connected to v i . That is,

where e ( i,p ) refers to the edge connecting v i and v p and V ′ ( v i ) and E ′ ( v i ) refer to the nodes and edges in G ′ ( v i ) , respectively. To optimize f ( · : ϕ ) such that f g ( · ; θ ∗ ) gives similar predictions to ˆ G ′ ( v i ) and G ( v i ) , we minimize the Kullback-Leibler divergence between the frozen GNN's predictions on these two ego-graphs, which is defined as:

where KL-Div ( y 1 , y 2 ) = ( y 1 + ϵ ) · ( log( y 2 + ϵ ) -log( y 1 + ϵ ) ) 1 with ϵ > 0 and V tr refers to the set of anchor nodes for training. Intuitively, the reconstruction process above enforces GRAPHPATCHER to remedy the corrupted neighborhood caused by T ( · ; t ) via adding a patching node directly to the anchor node. It is philosophically similar to the existing works (e.g., TuneUp [13] and Tail-GNN [25]), where models gain better generalization over low-degree nodes via the corrupted high-degree nodes. Empirically, we observe that this branch of approaches can effectively enhance performance over lowdegree nodes. Though promising, according to our empirical studies, it falls short on the high-degree node that original GNNs perform well at. This phenomenon may be attributed to the unintentially created out-of-distribution scenario [42], wherein models primarily encounter nodes with low degrees during the training. Consequently, the performance of GNNs, which is typically proficient with high-degree nodes, is adversely affected and downgraded.

3.2.2 Iterative Patching to Mitigate Degree Bias

In this work, we emphasize that: mitigating degree bias should not focus specifically on the low-degree nodes: trading off performance on high-degree nodes for that on low-degree nodes simply creates a new bias towards high-degree nodes . Therefore, besides enhancing the performance on low-degree nodes, maintaining GNN's original superiority on high-degree nodes is equally critical. This behavior is empirically desirable because practitioners can universally apply GRAPHPATCHER to all nodes without, like previous works do, manually discovering the degree threshold that differentiates the lowand high-degree nodes. Furthermore, the fact that these frameworks are applicable only to low-degree nodes indicates a lack of robustness: further remedying a neighborhood that is informative enough to deliver a good classification result should not jeopardize the performance.

To mitigate the degree bias, we propose a novel training scheme for GRAPHPATCHER such that it observes both low- and high-degree nodes simultaneously during the optimization. Specifically, given a node v i , we firstly create a sequence of M corrupted ego-graphs of v i , denoted as S ( v i ) = [ G ′ ( v i ) m = T ( G ( v i ) , t m )] M m =1 , with decreasing corruption strength (i.e., ∀ m,n ∈ { 1 , . . . , M } , t m > t n if m < n ). Instead of the one-step patching to match the prediction on the original egograph as described in Section 3.2.1, GRAPHPATCHER traverses S ( v i ) and recursively patches the corrupted ego-graph to match the target GNN's prediction on the ego-graph next in the sequence. As also illustrated in Figure 2, this optimization process is formulated as:

where ˆ G ( v i ) m = ( ˆ V m , ˆ E m ) with ˆ V m = V ′ 1 ( v i ) ∪ { v p } m p =1 , ˆ E m = E ′ 1 ( v i ) ∪ { e ( i,p ) } m p =1 , and ˆ G ( v i ) 0 = G ′ ( v i ) 1 .

The one-step patching described in Section 3.2.1 remedies low-degree anchor nodes directly to the distributions of high-degree nodes. During this process, the model does not observe distributions of high-degree nodes and hence delivers sub-optimal performance. Therefore, we design GRAPHPATCHER to be an iterative multi-step framework. At each step, it takes the previously patched

ego-graph as input and further remedies the partially patched ego-graph to match the GNN's prediction on the ego-graph next in the sequence. This scheme enables GRAPHPATCHER to learn to patch low-degree nodes in early steps when the ego-graphs are heavily corrupted (e.g., low-degree case in Figure 2) and maintain the original performance in later steps when ego-graphs are lightly corrupted (e.g., high-degree case in Figure 2). Specifically, at the m -th patching step, the currently patched ego-graph ˆ G ( v i ) m reflects the neighbor distribution of ego-graphs corrupted by a specific strength of t m +1 . GRAPHPATCHER takes ˆ G ( v i ) m as input and further generates another patching node v m +1 to approach the neighbor distribution of ego-graphs corrupted by a slightly weaker strength of t m +2 . This process iterates until GRAPHPATCHER traverses S ( v i ) . Intuitively, the incorporation of v m +1 enriches the neighbor distribution by an amount of t m +2 -t m +1 corruption strength. This optimization scheme allows GRAPHPATCHER to observe neighbor distributions with varying corruption strengths and makes our proposal applicable to both low- and high-degree nodes.

However, the target distribution at each step (i.e., f g ( G ′ ( v i ) m +1 ; θ ) [ v i ] in Equation (4)) is not deterministic due to the stochastic nature of the corruption function T . Given an ego-graph G ( v i ) and a corruption strength t , one can at most generate ( | V i | (1 -t ) | V i | ) different corrupted ego-graphs. With a large corruption strength (e.g., ego-graphs early in the sequence S ( v i ) ), two corrupted ego-graphs generated by the same exact priors might exhibit completely different topologies. Such differences could bring high variance to the supervision signal and instability to the optimization process. To alleviate the issue above, at each step we sample L ego-graphs with the same corruption strength and let GRAPHPATCHER approximate multiple predictions over them, formulated as:

where ˆ G ( v i ) m = f ( ˆ G ( v i ) m -1 ; ϕ ) and G ′ ( v i ) l m +1 refers to one of the L target corrupted ego-graphs that GRAPHPATCHER aims to approximate at the m -th step. This approach allows GRAPHPATCHER to patch the anchor node towards a well-approximated region where its high-degree counterparts should locate, instead of one point randomly sampled from this region.

With M -1 virtual nodes patched to the ego-graph, we further ask GRAPHPATCHER to generate a last patching node to ˆ G ( v i ) M -1 and enforce the resulted graph ˆ G ′ ( v i ) M to match the GNN's prediction on the original ego-graph. The last patching node could be regarded as a slack variable to complement minor differences between the original and the least corrupted ego-graphs, formulated as:

where ˆ G ( v i ) M = f ( ˆ G ( v i ) M -1 ; ϕ ) . L recon (Equation (6)) also prevents GRAPHPATCHER from overfitting to the low-degree nodes and enforces GRAPHPATCHER to maintain the target GNN's performance over high-degree nodes, since only marginal distribution modification should be expected with this last patching node. Hence, GRAPHPATCHER is optimized by a linear combination of the above two objectives (i.e., arg min ϕ L patch + L recon ).

3.2.3 Theoretical Analysis

As shown in Equation (5), one of the important factors that contribute to the success of GRAPHPATCHER is sampling multiple ego-graphs with the same corruption strength. The following theorem shows that the error is bounded w.r.t. the number of sampled ego-graphs L .

Theorem 1. Assuming the parameters of GRAPHPATCHER are initialized from the set P β = { ϕ : || ϕ -N ( 0 | ϕ | ; 1 | ϕ | ) || F < β } where β > 0 , with probability at least 1 -δ for all ϕ ∈ P β , the error

The proof of Theorem 1 is provided in Appendix C. From the above theorem, we note that without the sampling strategy (i.e., L = 1 ), the generalization error depends only on the number of parameters (i.e., | ϕ | ) given the same objective function, which could lead to high variance to the supervision signal and instability to the optimization process. According to this theorem and our empirical observation, an affordable value of L (e.g., L = 10 ) delivers stable results across datasets.

4 Experiments

4.1 Experimental Setting

Datasets . We conduct comprehensive experiments on seven real-world benchmark datasets that are broadly utilized by the graph community, including Cora , Citeseer , Pubmed , Wiki.CS , Amazon-Photo , Coauthor-CS , ogbn-arxiv , Actor , and Chameleon [44, 28, 12, 33]. This list of datasets covers graphs with distinctive characteristics (i.e., graphs with different domains and dimensions) to fully evaluate the effectiveness of GRAPHPATCHER. The detail of these datasets can be found in Appendix A.

Baselines . We compare GRAPHPATCHER with six state-of-the-art graph learning frameworks from three branches. The first branch specifically aims at enhancing the performance on low-degree nodes, including TAIL-GNN [25], COLBBREW [55], and TUNEUP [13]. The second branch consists of frameworks that focus on handling out-of-distribution scenarios, including EERM [42] and GTRANS [15]. We list this branch of frameworks as baselines because the sub-optimal performance of GNNs over low-degree nodes could be regarded as an out-of-distribution scenario. As GRAPHPATCHER is a test-time augmentation framework, the last branch of baseline includes DROPEDGE, which is a data augmentation framework employed during training.

Evaluation Protocol . We evaluate all models using the node classification task [22, 38], quantified by the accuracy score. For datasets with publicly avaiable (i.e., ogbn-arxiv , Cora , Citeseer , and Pubmed ), we employ their the provided splits for the model training and testing. Whereas for other datasets, we create a random 10 % /10 % /80 % split for the training/validation/testing split, to simulate a semi-supervised learning setting. All reported performance is averaged over 10 independent runs with different random seeds. Both mean values and standard deviations for the performances of all models are reported. Besides mitigating the degree bias for supervised GNNs, GRAPHPATCHER is also applicable to self-supervised GNNs. To evaluate the model performance for them, we apply GRAPHPATCHER and TUNEUP to state-of-the-art self-supervised GNNs including DGI [39], GRACE [57], and PARETOGNN [20]. We only compare our proposal with TUNEUP since other frameworks require specific model architectures and hence do not apply to self-supervised GNNs.

Hyper-parameters . We use the optimal settings on all baselines given by the authors for the shared datasets and a simple two-layer GCN [22] as the backbone model architecture for all applicable baselines. Hyper-parameters we tune for GRAPHPATCHER include learning rate, hidden dimension, the augmentation strength at each step, and the total amount of patching steps with details described in Appendix B. Besides, all of our models are trained on a single RTX3090 with 24GB VRAM; additional hardware information can also be found in the appendix.

4.2 Performance Comparison with Baselines

We compare GRAPHPATCHER with six state-of-the-art frameworks that mitigate the degree bias problem and the performances of all models are shown in Table 1. Firstly we notice that the problem of degree bias is quite serious across datasets for GCN. The performances on low-degree nodes are ∼ 10% lower than those over high-degree nodes. Comparing GCN with COLBBREW, TAILGNN, and TUNEUP, we can observe that frameworks that focus specifically on low-degree nodes can usually enhance GNN's performance over the lower percentile (e.g., 1.2% accuracy gain on Cora by TUNEUP, 0.74% on Citeseer by COLBBREW, 1.38% on Pubmed by TAIL-GNN, etc.). However, these frameworks fall short on the high-degree nodes and sometimes perform worse than the vanilla GCN (e.g., -2.7% accuracy degradation on Cora by TAIL-GNN, -11.42% on Wiki.CS by COLBBREW, and -2.5% on Amazon Photo by TUNEUP). This phenomenon could result from that they unintentionally create an artificial out-of-distribution scenario, where they only observe low-degree nodes during the training, leading to downgraded performance for high-degree nodes that GNNs originally perform well at. Comparing GCN with GTRANS and EERM, we observe that they deliver similar performances as the vanilla GCN does, indicating that frameworks targeting out-ofdistribution scenarios cannot mitigate degree biases. Comparing GRAPHPATCHER with all baselines, we notice that our proposed GRAPHPATCHER consistently improves the low-degree performance with an average improvement gain of 2.23 accuracy score. Besides, unlike other frameworks that have downgraded performance over high-degree nodes, GRAPHPATCHER can maintain GCN's original high-degree superiority, due to our iterative node patching. On average, GRAPHPATCHER improves GCN's overall performance by a 1.4 accuracy score across datasets.

We further apply GRAPHPATCHER to other GNN architectures (i.e., GraphSAGE [9] and GAT [38]) and compare its performance to TUNEUP. We only compare with TUNEUP since other baselines explore specific model architectures that do not allow a different backbone. From Table 2, we can observe that the issue of degree bias still exists on GAT and GraphSAGE with a performance gap between low- and high-degree nodes around ∼ 10%. Both TUNEUP and GRAPHPATCHER can improve the performance over low-degree nodes. Specifically, TUNEUP on average improves 0.27 low-degree accuracy for GraphSAGE and 0.40 for GAT across datasets; whereas GRAPHPATCHER improves 1.13 for GraphSAGE and 1.66 for GAT, outperforming TUNEUP by a large margin.

4.3 Performance of GRAPHPATCHER for Self-supervised GNNs

To fully demonstrate the effectiveness of GRAPHPATCHER, we also apply our proposal to self-supervised GNNs, as shown in Table 3. We can observe that self-supervised learning can mitigate degree bias by itself, proved by smaller gaps between lowand high-degree nodes than those of semi-supervised GNNs. Combined with GRAPHPATCHER, the degree biases can be further without sacrificing GNN's original superiority over high-degree nodes. On average, GRAPHPATCHER can enhance the low-degree performance of these three selfsupervised GNNs by 1.78, 0.74, and 1.36 accuracy scores respectively.

4.4 Effectiveness of GRAPHPATCHER for Enhancing SoTA Method

We apply GRAPHPATCHER to GRAND [5], a strong GNN that utilizes a random propagation strategy to perform graph data augmentation and significantly improve the node classification performance. The performance improvement brought by GRAPHPATCHER is shown in Table 4. We observe that GRAPHPATCHER can still consistently improve the node classification for GRAND. Specifically, on low-degree nodes, GRAPHPATCHER can improve 1.40, 2.23, and 4.20 accuracy score on Cora , Citeseer , and Pubmed , respectively. Overall, GRAPHPATCHER further enhances the SoTA perfor-

Method

Citeseer

Pubmed

LOW-DEGREE NODES (LOWER PERCENTILE)

GRAND

80.18

±

0

.

64

70.57

±

0

.

68

80.48

±

0

.

14

+GRAPHPATCHER

81.58

±

0

.

45

72.73

±

0

.

29

84.68

±

0

.

29

HIGH-DEGREE NODES (UPPER PERCENTILE)

GRAND

88.32

±

0

.

75

79.64

±

0

.

86

83.53

±

0

.

52

+GRAPHPATCHER

88.92

±

0

.

18

79.54

±

0

.

13

84.43

±

0

.

21

OVERALL PERFORMANCE

GRAND

85.22

±

0

.

80

74.90

±

0

.

77

82.30

±

0

.

41

+GRAPHPATCHER

85.90

±

0

.

44

76.10

±

0

.

38

84.20

±

0

.

26

mance on these three datasets, with an outstanding accuracy score of 85.90, 76.10, and 84.20. The significant gain from GRAPHPATCHER indicates that the effectiveness brought by the test-time augmentation is not overlapped with the data augmentation during the training.

4.5 Performance w.r.t. the Number of Patching Nodes

To investigate the necessity of patching multiple nodes, we conduct experiments over the number of patching nodes at the test time. As shown in Figure 3, we notice that the overall performance gradually increments as the number of patching nodes increases, demonstrating that multiple patching nodes are required to remedy the incomplete neighborhood of low-degree nodes. Besides, we discover that the performance of GRAPHPATCHER saturates with around four nodes patched, which aligns with our training procedure, where the length of the ego-graph sequence is at most five. Experiments concerning the number of patching nodes during the optimization and the number of sampled ego-graphs per corruption strength (i.e., M and L in Equation (5)) can be found in Appendix B.

5 Discussion w.r.t. Diffusion Models

Both diffusion models and GRAPHPATCHER conduct multiple corruptions to training samples with increasing strengths and generate examples in an iterative fashion. This scheme is conceptually inspired by heat diffusion from physics. However, the motivations behind them are different, where diffusion models focus on the generation quality (i.e., fidelity to the original data distribution) but ours

81

82.5

84

1

2

3

4

5

Original Perf.

79

80.5

82

1

2

3

4

5

Original Perf.

Pubmed

71

72

73

1

2

3

4

5

Original Perf.

Arxiv

aims at the results brought by our generated nodes (i.e., the performance improvement). Specifically, diffusion models [10, 32] aim at learning the probability distribution of the data and accordingly generating examples following the learned distribution. Their goal is to generate samples that follow the original data distribution, agnostic of any other factor like the target GNN we have in our scenario. Whereas for GRAPHPATCHER, we aim at generating nodes to ego-nets such that the target GNN models deliver better predictions when the node degree is low. We mostly care about performance improvement and the generated node may be very different from the original nodes in the graph.

6 Discussion w.r.t. Generation Methods for Graph

Most graph generation frameworks (including those using diffusion models) explore iterative generation schemes to synthesize real graphs [58, 46, 6, 30, 16, 40]. They improve the generation quality and focus on applications such as molecule design, protein design, and program synthesis. Though GRAPHPATCHER also generates patching nodes for ego-graphs, ours is a different research direction than these methods. We do not focus on whether or not the generated patching nodes are faithful to the original data distribution, as long as the low-degree performance is enhanced and the high-degree performance is maintained. Another relevant work named GPT-GNN [14] explores an iterative node generation for pre-training, which also falls under the category of maintaining the original data distribution. In summary, GRAPHPATCHER is relevant to these frameworks in the sense that it generates nodes to add to ego-graphs. However, our proposal is motivated by a different reason and we aim at the performance improvement brought by generated nodes in downstream tasks.

7 Conclusion

We study the problem of degree bias underlying GNNs and accordingly propose a test-time augmentation framework, namely GRAPHPATCHER. GRAPHPATCHER iteratively patches ego-graphs with its generated virtual nodes to remedy the incomplete neighborhood. Through our designated optimization scheme, GRAPHPATCHER not only patches low-degree nodes but also maintains GNN's original superior performance over high-degree nodes. Comprehensive experiments are conducted over seven benchmark datasets and our proposal can consistently enhance GNN's overall performance by up to 3.6% and low-degree performance by up to 6.5%, outperforming all baselines by a large margin. Besides, GRAPHPATCHER can also mitigate the degree bias issue for self-supervised GNNs. When applied to graph learning methods with state-of-the-art performance (i.e., GRAND), GRAPHPATCHER can further improve the SoTA performance by a large margin, indicating that the effectiveness brought by the test-time augmentation is not overlapped with existing inductive biases.

Limitation and Broader Impact

One limitation is the additional overhead entailed by generating ego-graphs. To address this limitation, we generate all ego-graphs before the optimization to avoid duplicated computations. This operation takes more hard-disk storage, which is relatively cheap compared with computational resources. Furthermore, we observe no ethical concern entailed by our proposal, but we note that both ethical or unethical applications based on graphs may benefit from the effectiveness of our work. Care should be taken to ensure socially positive and beneficial results of machine learning algorithms.

References

Murat Seckin Ayhan and Philipp Berens. Test-time data augmentation for estimation of heteroscedastic aleatoric uncertainty in deep neural networks. In Medical Imaging with Deep Learning , 2018.

Filippo Maria Bianchi, Daniele Grattarola, and Cesare Alippi. Spectral clustering with graph neural networks for graph pooling. In Procs. of ICML , 2020.

Wenqi Fan, Yao Ma, Qing Li, Yuan He, Eric Zhao, Jiliang Tang, and Dawei Yin. Graph neural networks for social recommendation. In Procs. of WWW , 2019.

Yujie Fan, Mingxuan Ju, Chuxu Zhang, and Yanfang Ye. Heterogeneous temporal graph neural network. In Procs. of SDM , 2022.

Wenzheng Feng, Jie Zhang, Yuxiao Dong, Yu Han, Huanbo Luan, Qian Xu, Qiang Yang, Evgeny Kharlamov, and Jie Tang. Graph random neural networks for semi-supervised learning on graphs. Procs. of NeurIPS , 2020.

Nikhil Goyal, Harsh Vardhan Jain, and Sayan Ranu. Graphgen: A scalable approach to domain-agnostic labeled graph generation. In Procs. of WWW , 2020.

Zhichun Guo, Chuxu Zhang, Wenhao Yu, John Herr, Olaf Wiest, Meng Jiang, and Nitesh V Chawla. Few-shot graph learning for molecular property prediction. In Procs. of WWW , 2021.

Zhichun Guo, William Shiao, Shichang Zhang, Yozen Liu, Nitesh V Chawla, Neil Shah, and Tong Zhao. Linkless link prediction via relational distillation. In Procs. of ICML , 2023.

William L Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Procs. of NeurIPS , 2017.

Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. Procs. of NeurIPS , 2020.

Weihua Hu, Bowen Liu, Joseph Gomes, Marinka Zitnik, Percy Liang, Vijay Pande, and Jure Leskovec. Strategies for pre-training graph neural networks. In Procs. of ICLR , 2019.

Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. In Procs. of NeurIPS , 2020.

Weihua Hu, Kaidi Cao, Kexin Huang, Edward W Huang, Karthik Subbian, and Jure Leskovec. Tuneup: A training strategy for improving generalization of graph neural networks. arXiv , 2022.

Ziniu Hu, Yuxiao Dong, Kuansan Wang, Kai-Wei Chang, and Yizhou Sun. Gpt-gnn: Generative pre-training of graph neural networks. In Procs. of KDD , 2020.

Wei Jin, Tong Zhao, Jiayuan Ding, Yozen Liu, Jiliang Tang, and Neil Shah. Empowering graph representation learning with test-time graph transformation. In Procs. of ICLR , 2023.

Jaehyeong Jo, Seul Lee, and Sung Ju Hwang. Score-based generative modeling of graphs via the system of stochastic differential equations. In Procs. of ICML , 2022.

Mingxuan Ju, Shifu Hou, Yujie Fan, Jianan Zhao, Yanfang Ye, and Liang Zhao. Adaptive kernel graph neural network. In Procs. of AAAI , 2022.

Mingxuan Ju, Wenhao Yu, Tong Zhao, Chuxu Zhang, and Yanfang Ye. Grape: Knowledge graph enhanced passage reader for open-domain question answering. In Findings of EMNLP , 2022.

Mingxuan Ju, Yujie Fan, Chuxu Zhang, and Yanfang Ye. Let graph be the go board: gradientfree node injection attack for graph neural networks via reinforcement learning. In Procs. of AAAI , 2023.

Mingxuan Ju, Tong Zhao, Qianlong Wen, Wenhao Yu, Neil Shah, Yanfang Ye, and Chuxu Zhang. Multi-task self-supervised graph neural networks enable stronger task generalization. In Procs. of ICLR , 2023.

Ildoo Kim, Younghoon Kim, and Sungwoong Kim. Learning loss for test-time augmentation. Procs. of NeurIPS , 2020.

Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In Procs. of ICLR , 2016.

Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. In Procs. of ICLR , 2019.

Gang Liu, Tong Zhao, Eric Inae, Tengfei Luo, and Meng Jiang. Semi-supervised graph imbalanced regression. In Procs. of KDD , 2023.

Zemin Liu, Trung-Kien Nguyen, and Yuan Fang. Tail-gnn: Tail-node graph neural networks. In Procs. of SIGKDD , 2021.

Philip M Long and Hanie Sedghi. Generalization bounds for deep convolutional neural networks. In Procs. of ICLR , 2020.

Yao Ma, Xiaorui Liu, Neil Shah, and Jiliang Tang. Is homophily a necessity for graph neural networks? In Procs. of ICLR , 2022.

Julian McAuley, Rahul Pandey, and Jure Leskovec. Inferring networks of substitutable and complementary products. In Procs. of SIGKDD , 2015.

Mehryar Mohri, Afshin Rostamizadeh, and Ameet Talwalkar. Foundations of machine learning . MIT press, 2018.

Chenhao Niu, Yang Song, Jiaming Song, Shengjia Zhao, Aditya Grover, and Stefano Ermon. Permutation invariant graph generation via score-based generative modeling. In Procs. of AISTATS , 2020.

Aditya Pal, Chantat Eksombatchai, Yitong Zhou, Bo Zhao, Charles Rosenberg, and Jure Leskovec. Pinnersage: Multi-modal user embedding framework for recommendations at pinterest. In Procs. of SIGKDD , 2020.

Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björn Ommer. High-resolution image synthesis with latent diffusion models. In Procs. of CVPR , 2022.

Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina EliassiRad. Collective classification in network data. AI magazine , 2008.

Divya Shanmugam, Davis Blalock, Guha Balakrishnan, and John Guttag. Better aggregation in test-time augmentation. In Procs. of CVPR , 2021.

William Shiao, Uday Singh Saini, Yozen Liu, Tong Zhao, Neil Shah, and Evangelos E Papalexakis. Carl-g: Clustering-accelerated representation learning on graphs. Procs. of KDD , 2023.

Xianfeng Tang, Huaxiu Yao, Yiwei Sun, Yiqi Wang, Jiliang Tang, Charu Aggarwal, Prasenjit Mitra, and Suhang Wang. Investigating and mitigating degree-related biases in graph convoltuional networks. In Procs. of CIKM , 2020.

Anton Tsitsulin, John Palowitch, Bryan Perozzi, and Emmanuel Müller. Graph clustering with graph neural networks. arXiv , 2020.

Petar Veliˇ ckovi´ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. In Procs. of ICLR , 2017.

Petar Velickovic, William Fedus, William L Hamilton, Pietro Liò, Yoshua Bengio, and R Devon Hjelm. Deep graph infomax. In Procs. of ICLR , 2019.

Clement Vignac, Igor Krawczuk, Antoine Siraudin, Bohan Wang, Volkan Cevher, and Pascal Frossard. Digress: Discrete denoising diffusion for graph generation. In Procs. of ICLR , 2022.

Guotai Wang, Wenqi Li, Michael Aertsen, Jan Deprest, Sébastien Ourselin, and Tom Vercauteren. Aleatoric uncertainty estimation with test-time augmentation for medical image segmentation with convolutional neural networks. Neurocomputing , 2019.

Qitian Wu, Hengrui Zhang, Junchi Yan, and David Wipf. Handling distribution shifts on graphs: An invariance perspective. In Procs. of ICLR , 2022.

Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In Procs. of ICLR , 2018.

Zhilin Yang, William Cohen, and Ruslan Salakhudinov. Revisiting semi-supervised learning with graph embeddings. In Procs. of ICML , 2016.

Rex Ying, Ruining He, Kaifeng Chen, Pong Eksombatchai, William L Hamilton, and Jure Leskovec. Graph convolutional neural networks for web-scale recommender systems. In Procs. of SIGKDD , 2018.

Jiaxuan You, Rex Ying, Xiang Ren, William Hamilton, and Jure Leskovec. Graphrnn: Generating realistic graphs with deep auto-regressive models. In Procs. of ICML , 2018.

Yuning You, Tianlong Chen, Yongduo Sui, Ting Chen, Zhangyang Wang, and Yang Shen. Graph contrastive learning with augmentations. In Procs. of NeurIPS , 2020.

Yuning You, Tianlong Chen, Yang Shen, and Zhangyang Wang. Graph contrastive learning automated. In Procs. of ICML , 2021.

Sukwon Yun, Kibum Kim, Kanghoon Yoon, and Chanyoung Park. Lte4g: Long-tail experts for graph neural networks. In Procs. of CIKM , 2022.

Muhan Zhang and Yixin Chen. Link prediction based on graph neural networks. In Procs. of NeurIPS , 2018.

Zaixi Zhang, Qi Liu, Hao Wang, Chengqiang Lu, and Chee-Kong Lee. Motif-based graph self-supervised learning for molecular property prediction. Procs. of NeurIPS , 2021.

Tong Zhao, Tianwen Jiang, Neil Shah, and Meng Jiang. A synergistic approach for graph anomaly detection with pattern mining and feature learning. IEEE Transactions on Neural Networks and Learning Systems , 2021.

Tong Zhao, Gang Liu, Daheng Wang, Wenhao Yu, and Meng Jiang. Learning from counterfactual links for link prediction. In Procs. of ICML , 2022.

Tong Zhao, Wei Jin, Yozen Liu, Yingheng Wang, Gang Liu, Stephan Günnemann, Neil Shah, and Meng Jiang. Graph data augmentation for graph machine learning: A survey. IEEE DEBULL , 2023.

Wenqing Zheng, Edward W Huang, Nikhil Rao, Sumeet Katariya, Zhangyang Wang, and Karthik Subbian. Cold brew: Distilling graph node representations with incomplete or missing neighborhoods. In Procs. of ICLR , 2021.

Qi Zhu, Carl Yang, Yidan Xu, Haonan Wang, Chao Zhang, and Jiawei Han. Transfer learning of graph neural networks with ego-graph information maximization. In Procs. of NeurIPS , 2021.

Yanqiao Zhu, Yichen Xu, Feng Yu, Qiang Liu, Shu Wu, and Liang Wang. Deep Graph Contrastive Representation Learning. In ICML Workshop on Graph Representation Learning and Beyond , 2020.

Yanqiao Zhu, Yuanqi Du, Yinkai Wang, Yichen Xu, Jieyu Zhang, Qiang Liu, and Shu Wu. A survey on deep graph generation: Methods and applications. In Procs. of LOG , 2022.

A Dataset Description

We evaluate our proposed GRAPHPATCHER as well as other frameworks that mitigate the degree bias problem on seven real-worlds datasets spanning various fields such as citation network and merchandise network. Their statistics are shown in Table 5. For Cora , Citeseer and, Pubmed , we explore the community acknowledged public splits (i.e., fixed 20 nodes per class for training, 500 nodes for validation, and 1000 nodes for testing); whereas for ogbn-arxiv , we use the API from Open Graph Benchmark (OGB) 2 and explore the provided splits. For Wiki.CS , Amazon-Photo , and Coauthor-CS , we randomly select 10% nodes for training, another 10% for validation, and the remaining 80% for testing. We use the API from Deep Graph Library (DGL) 3 to load all datasets.

B GRAPHPATCHER Configuration and Experiment on Hyper-parameters

B.1 GRAPHPATCHER Configuration

The architecture of GRAPHPATCHER consists of two parts; the first part is a 2-layer GCN encoder that takes an ego-graph as input and vectorizes its nodes and the second part is an MLP that takes the representation of the anchor node and outputs the generated feature for the virtual patching node.

To ensure the reproducibility, we also provide the detailed hyper-parameter configurations of GRAPHPATCHER for all datasets, as shown in Table 6. Besides, we use an early stopping strategy to decide the number of optimization steps, where the optimization stops if the validation loss stops decreasing for two consecutive steps.

B.2 Experiment on Hyper-parameters

The hyper-parameters we tune for GRAPHPATCHER include the number of patching nodes during the testing time, learning rate, hidden dimension, the augmentation strength at each step, and the total amount of patching steps. Experiments w.r.t. the number of patching nodes during the testing time has been showcased in Figure 3 and here we also append the results for the other four datasets, as shown in Figure 4. We observe similar trends as the aforementioned three datasets exhibit, where the

77

77.5

78

78.5

1

2

3

4

5

70

71

72

1

2

3

4

5

80

80.5

81

81.5

1

2

3

4

5

88

88.5

89

89.5

1

2

3

4

5

Wiki.CS

Citeseer

Co.CS

Am. Photo

Original Perf.

Original Perf.

Original Perf.

Original Perf.

65

70

75

80

85

90

arxiv

Pubmed

1.00E-03

5.00E-04

1.00E-04

5.00E-05

Acc(%)

(a) Accuracy w.r.t. learning rate

65

70

75

80

85

90

arxiv

Pubmed

64

128

256

1024

65

70

75

80

85

90

arxiv

Pubmed

0.1

0.2

0.3

0.4

Acc(%)

Acc(%)

Acc(%)

65

70

75

80

85

90

arxiv

Pubmed

1

5

10

20

(d) Accuracy w.r.t. # of sampled graphs

performance of GRAPHPATCHER improves as the number of patching nodes increases and the gain saturates with 4 to 5 nodes patched.

We also conduct experiments w.r.t. learning rate, hidden dimension, the augmentation strength at each step, and the total amount of patching steps during the training. We tune the hidden dimension by conducting a grid search over common selections of [64, 128, 256, 1024] hidden units; we tune the learning rate similarly by searching over [1e-3, 5e-4, 1e-4, 5e-5]; and we tune the augmentation strength by searching over [0.1, 0.2, 0.3, 0.4].

The hidden dimension refers to the intermediate dimension of the 2-layer GCNs of GRAPHPATCHER. GRAPHPATCHER is constructed by a 2-layer GCN and features for virtual nodes are generated by a following multi-layer perceptron with the same hidden dimension. To reduce the search complexity, we explore an arithmetic sequence for the augmentation strength (i.e., the difference between any two consecutive strengths is the same) and set the total amount of patching steps during the training to ⌊ 1 t ⌋ . For instance, an augmentation strength of 0 . 3 would lead to a 3-step training with augmentation strength of 0.3, 0.6, and 0.9 respectively. GRAPHPATCHER's sensitivity to these hyper-parameters is shown in Figure 5. Specifically, in Figure 5.(a) we can observe that across datasets, a large learning rate (i.e., 1e-3) leads to sub-optimal performance and GRAPHPATCHER achieves the best performance with a learning rate of 1e-4. We also investigate GRAPHPATCHER's sensitivity to the number of

hidden dimensions (i.e., the model size). In Figure 5.(b), we notice that for large graphs like Arxiv , the performance gradually increases as the model size enlarges. And for small and medium graphs like Cora and Pubmed , the performance saturates with a hidden dimension of 128. Besides, in Figure 5.(c) we study GRAPHPATCHER's performance w.r.t. the augmentation strength (which can also be interpreted as the number of patching steps as described previously). We can observe that, for small and medium graphs, strong augmentation strength leads to better performance, due to the sparsity of the graph structures. Whereas for large graphs, small augmentation strength delivers good performance. Furthermore, to prove the effectiveness of our proposed training scheme with multiple ego-graphs, we train GRAPHPATCHER with different numbers of sampled graphs (i.e., L in Equation (5)), with the performance shown in Figure 5.(d). We can observe that without our proposed sampling strategy (i.e., the first column with L = 1 ), the performance of GRAPHPATCHER degrades significantly. As the number of sampled graphs gradually increases, the performance keeps improving and saturates with L = 10 , empirically proving the effectiveness of the exploration of multiple ego-graphs for the same corruption strength.

B.3 Hardware and Software Configuration

We conduct experiments on a server having one RTX3090 GPU with 24 GB VRAM. The CPU we have on the server is an AMD Ryzen 3990X with 128GB RAM. The software we use includes DGL 1.9.0 and PyTorch 1.11.0. As for the baseline models that we compare GRAPHPATCHER with, we explore the implementations provided by code repositories listed as follows:

TAIL-GNN [25]: https://github.com/shuaiOKshuai/Tail-GNN .

COLBBREW [55]: https://github.com/amazon-science/gnn-tail-generalization .

EERM [42]: https://github.com/qitianwu/GraphOOD-EERM .

GTRANS [15]L https://github.com/ChandlerBang/GTrans .

DGI [39]: https://github.com/dmlc/dgl/tree/master/examples/pytorch/dgi .

GRACE [57]: https://github.com/dmlc/dgl/tree/master/examples/pytorch/grace .

PARETOGNN [20]: https://github.com/jumxglhf/ParetoGNN .

We sincerely appreciate the authors of these works for open-sourcing their valuable code and researchers at DGL for providing reliable implementations of these models. For TUNEUP [13], since the authors have not released the code yet, we manually implement it by ourselves, with a similar performance as reported in its original paper.

C Proof to Theorem 1

Here we re-state Theorem 1 before diving into its proof:

Theorem 1. Assuming the parameters of GRAPHPATCHER are initialized from the set P β = { ϕ : || ϕ -N ( 0 | ϕ | ; 1 | ϕ | ) || F < β } where β > 0 , with probability at least 1 -δ , for all ϕ ∈ P β , the error bound (i.e., E ( L patch ) -L patch ) is O ( β √ | ϕ | L + √ log(1 /β ) L ) .

Proof. To prove Theorem 1, we need the following lemma, which has been broadly utilized in the literature of generalization error bound [26, 29].

Lemma 1. Suppose a set P of functions is ( B,d ) -Lipschitz parameterized for B > 0 and d ∈ N with input from a distribution D and output in (0 , 1) . There exist a constant c such that for all n ∈ N , for any δ > 0 , if S is obtained by sampling n times independently from D , with probability at least 1 -δ , for all B and f ∈ P , we have:

In order to prove E ( L patch ) - L patch is O ( β √ | ϕ | L + √ log(1 /β ) L ) , we need to show that L patch is Lipschitz continuous. L patch, as discussed in Section 3.2.1, is a regularized cross-entropy formulated

as ( y 1 + ϵ ) · ( log( y 2 + ϵ ) -log( y 1 + ϵ ) ) . In this work, y 1 and y 2 refers to the prediction distribution (i.e., 0 < y 1 < 1 ) delivered by the GNN we aim at improving. Hence, we need to show that for given a specific y 1 , for any two y a 2 , y b 2 ∈ { y ′ 2 : 0 < y ′ 2 < 1 } and K ∈ R + , we have

Given the fact that log( · ) is strictly concave, Equation (10) holds and hence L patch is Lipschitz continuous. We can then directly apply Lemma 1 to show that Theorem 1 holds.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper addresses the issue of degree bias in node classification, which refers to the poorer performance of Graph Neural Network (GNN) models on nodes with lower degrees compared to the average level. While previous works have attempted to mitigate this bias, they often trade off the performance on higher-degree nodes for improvements on low-degree nodes. In light of this, the authors propose GraphPatcher, a method that introduces virtual nodes during the test phase to tackle this problem. To make the approach computationally feasible, the authors limit the search space to 1-order neighbors and devise an iterative procedure to repair a series of corrupted ego graphs by adding one virtual node at each step. Additionally, the authors provide theoretical results that establish the relationship between the number of sampled ego graphs and the accuracy of the estimated patching loss. The proposed GraphPatcher is extensively evaluated through experiments, demonstrating its effectiveness in addressing the degree bias issue.\n\nSTRENGTHS:\n1. The paper is well-written, allowing readers to easily grasp the core ideas and delve into the authors' detailed explanations.\n\n2. The motivation behind the proposed GraphPatcher is well-founded, as it intuitively aims to enhance overall performance rather than compromising it through trade-offs.\n\n4. The empirical evaluations consistently demonstrate the effectiveness of GraphPatcher, with statistically significant improvements observed. Furthermore, the increasing number of patched virtual nodes correlates with increasingly noticeable enhancements, providing strong support for the rationale behind the iterative procedure designed for GraphPatcher.\n\nWEAKNESSES:\n1. While the theoretical analysis provided in the paper is logically sound, its relevance to the community's primary concern of reducing the generalization risk of the original GNN model is unclear. Consequently, the presented theoretical results may not be perceived as a significant contribution.\n\n2. Although the experiments in the paper are well-designed, there is room for improvement in terms of comprehensiveness. For instance, the inclusion of more visually informative figures/tables showcasing the improvements across different degree levels would enhance the clarity of the results. Additionally, comparisons on heterophilic graphs would provide a more comprehensive evaluation. It is also important to consider evaluating the efficiency of GraphPatcher since it introduces additional computational overhead.\n\nQUESTIONS:\nWhen working with graph samplers that are necessary for training on large graphs, whether we need a larger/smaller L?\n\nLIMITATIONS:\nNone", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-06-28"}

comments: SUMMARY:
This paper addresses degree bias in node classification. The authors show that current methods suffer performance degradation for high-degree nodes. Thus, they freeze the original GNN and train GraphPatcher to enhance low-degree nodes with node patching in the testing stage. In the experiments, they demonstrate that their approach significantly improves performance without performance drop in high-degree nodes on various homophilous graphs.

STRENGTHS:
- They exhibit that the existing approaches suffer performance drops in high-degree nodes.
- Their method improves performance without performance degradation in high-degree nodes.

WEAKNESSES:
- [W1] From my understanding, it seems difficult to train in a node-parallel manner with a single large graph, as the graphs used by each node differ, unlike vanilla GNN training. Then, I’m concerned that training GraphPatcher might take an excessively long time.
- [W2] The validation is only conducted on homophilous graphs.
- [W3] I found that there is a performance drop for high-degree nodes on CiteSeer in Table 1. Is there any reason for this phenomenon?

QUESTIONS:
- Following [W1], could you provide the comparison with baselines from the perspective of the training time (including vanilla GNN)? Also, it would be better to show memory usage in GPU when training GraphPatcher and baselines.
- Following [W2], could you provide a performance comparison on heterophilous graphs?

LIMITATIONS:
As the authors mentioned, the additional computational cost might be considerable.
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 2
DATE: 2023-07-03

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper introduces GraphPatcher, a novel test-time augmentation framework designed to mitigate degree bias in graph neural networks (GNNs). Degree bias causes GNNs to perform well with high-degree nodes (rich neighbor information) and poorly with low-degree nodes. Current strategies tend to focus on low-degree nodes during training, which can compromise performance on high-degree nodes. To overcome this, GraphPatcher creates virtual nodes to progressively 'patch' low-degree nodes, enhancing performance without sacrificing the capabilities of GNNs on high-degree nodes. The framework is model-agnostic, applicable to self-supervised or supervised GNNs, and shows significant improvement in overall and low-degree node performance across multiple benchmark datasets.\n\nSTRENGTHS:\n- I like the reasoning of the paper, which makes the proposed method well motivated and natural.\n- The proposed method is more \"adaptive\" to both low-degree and high-degree nodes, without special treatments that is only for low degree node. The iterative patching sounds like denoising diffusion models, which is interesting.\n- There are enough details for reproducibility and the code is attached to the supplementary.\n\nWEAKNESSES:\n**Concern About Weak Model Performances**: Though the experiment results show the GraphPatcher sometimes is more accurate than the baselines, it is less convincing because the baselines does not look strong enough. For example, for citation networks like Cora, Citeseer and Pubmed, the SOTA accuracy are much better than the best performance shown in Table 1. I recommend the authors to check https://paperswithcode.com/area/graphs for SOTA performances.\n\nIt is very important because there are non-negligible accuracy gaps. For example, for Citeseer, there are a lot of models achieved more than 80% accuracy, but in Table 1, the best model achieved only around 71% accuracy. Same for Cora (90% vs 84%), Pubmed (91% vs 81%).\n\nI feel it would be better that the authors can evaluate the GraphPatcher on some SOTA models and evaluate the effect (improvement) of the proposed graph patching methods, rather than demonstrating improvements over some well-established models that is proposed years ago. It is crucial to understand the real-world value of the proposed methods in this fast-moving community.\n\nQUESTIONS:\n**Some Connections to Iterative Graph Generation And Diffusion Models**: The proposed GraphPatcher is conceptually to iterative graph generation framework, only the training objective is different. The way KL-divergence is used is also similar to a lot of graph generation methods. It is recommended to consider the connection to the graph generation works to see what can be adopted. I feel an autoregressive model like autoregressive transformer or LSTM can be a good candidate for generating the sequence of patched node. The main idea is that it could be possible to know when to stop (predict stop token). \n\nThe recent works on graph generation using diffusion models could also be a very relevant. These are just some random thoughts, I will appreciate the thoughts from the authors on how this could relate to this work, and maybe adding some future directions into the discussion section if it is indeed relevant.\n\nLIMITATIONS:\nNo limitations are left unaddressed.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-04"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper proposes GRAPHPATCHER, a test-time augmentation framework for graphs, to mitigate the degree biases in Graph Neural Networks. GRAPHPATCHER adopts a corruption function with increasing strength to simulate low-degree ego-graphs from a high-degree one. From the most corrupted graph, it then iteratively generates virtual nodes to the anchor node, such that the frozen GNN model behaves similarly given the currently patched graph or the corrupted graph next in the hierarchy. The authors then examine the effectiveness on seven real-world benchmark datasets, and observe that GRAPHPATCHER enhances the low-degree performance up to 6.5%, when enhancing the overall performance by up to 3.6% at the same time.\n\nSTRENGTHS:\n1. The proposed GRAPHPATCHER avoids creating an artificial out-of-distribution scenario when focusing only on low-degree nodes, and hence avoids significantly sacrificing the performance on high-degree nodes. \n2. The modelling and optimization are conducted through aligning the ego-graph sequence and its reconstruction. The test-time augmentation framework avoids changing model architectures and the expensive re-training cost. The structure is simple with good performance.\n\nWEAKNESSES:\n1. The way GRAPHPATCHER patches the corrupted ego-graph (adding one node and the corresponding edge at a time) might limit the expressive ability of the model, as it could be difficult for this strategy to reflect more complex structures between the anchor node's neighbors.\n2. The continuous corruption and patching on ego-graph share some similarities to the diffusion model. It would be more insightful if the theory behind the methodology and the similarity/dissimilarity with the diffusion model are discussed.\n3. In the experimental part, Tail-GNN performs worse than GCN in almost all cases. Even for the low-degree nodes, Tail-GNN cannot always beat GCN, which is unexpected since Tail-GNN is specially designed for low-degree nodes. If there is a problem with the baseline tuning, some conclusions cannot be well supported (e.g., Tail-GNN falls short on the high-degree nodes). This also affects the convincingness of the superiority of GRAPHPATHCER over baselines.\n4. It is claimed that the chosen datasets cover graphs with distinctive characteristics, but all datasets used are homophilic ones. It is expected to have more experiments on heterophilic datasets. Since heterophilic graphs often have more complex topologies, they are more susceptible to node adding and dropping.\n\nOther minor issues:\nTypo in row 8: \"orizinally\".\n\nQUESTIONS:\nPlease refer to the weaknesses part.\n\nLIMITATIONS:\nThe paper has properly addressed the limitations of the proposed method. One limitation is the additional computational cost entailed by generating ego-graphs. The authors provide solutions to mitigate the problem.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-07-05"}