Year: 2020

Abstract:
Graph neural networks (GNNs) have been widely used for representation learning on graph data. However, there is limited understanding on how much performance GNNs actually gain from graph data. This paper introduces a context-surrounding GNN framework and proposes two smoothness metrics to measure the quantity and quality of information obtained from graph data. A new GNN model, called CS-GNN, is then designed to improve the use of graph information based on the smoothness values of a graph. CS-GNN is shown to achieve better performance than existing methods in different types of real graphs.

heading: 1 INTRODUCTION
text: Graphs are powerful data structures that allow us to easily express various relationships (i.e., edges) between objects (i.e., nodes). In recent years, extensive studies have been conducted on GNNs for tasks such as node classification and link predication. GNNs utilize the relationship information in graph data and significant improvements over traditional methods have been achieved on benchmark datasets (Kipf & Welling, 2017; Hamilton et al., 2017; Velickovic et al., 2018; Xu et al., 2019; Hou et al., 2019). Such breakthrough results have led to the exploration of using GNNs and their variants in different areas such as computer vision (Satorras & Estrach, 2018; Marino et al., 2017), natural language processing (Peng et al., 2018; Yao et al., 2019), chemistry (Duvenaud et al., 2015), biology (Fout et al., 2017), and social networks (Wang et al., 2018). Thus, understanding why GNNs can outperform traditional methods that are designed for Euclidean data is important. Such understanding can help us analyze the performance of existing GNN models and develop new GNN models for different types of graphs.
In this paper, we make two main contributions: (1) two graph smoothness metrics to help understand the use of graph information in GNNs, and (2) a new GNN model that improves the use of graph information using the smoothness values. We elaborate the two contributions as follows.
One main reason why GNNs outperform existing Euclidean-based methods is because rich information from the neighborhood of an object can be captured. GNNs collect neighborhood information with aggregators (Zhou et al., 2018), such as the mean aggregator that takes the mean value of neighbors’ feature vectors (Hamilton et al., 2017), the sum aggregator that applies summation (Duvenaud et al., 2015), and the attention aggregator that takes the weighted sum value (Velickovic et al., 2018). Then, the aggregated vector and a node’s own feature vector are combined into a new feature vector. After some rounds, the feature vectors of nodes can be used for tasks such as node classification. Thus, the performance improvement brought by graph data is highly related to the quantity and quality of the neighborhood information. To this end, we propose two smoothness metrics on node features and labels to measure the quantity and quality of neighborhood information of nodes. The metrics are used to analyze the performance of existing GNNs on different types of graphs.
In practice, not all neighbors of a node contain relevant information w.r.t. a specific task. Thus, neighborhood provides both positive information and negative disturbance for a given task. Simply aggregating the feature vectors of neighbors with manually-picked aggregators (i.e., users choose
a type of aggregator for different graphs and tasks by trial or by experience) often cannot achieve optimal performance. To address this problem, we propose a new model, CS-GNN, which uses the smoothness metrics to selectively aggregate neighborhood information to amplify useful information and reduce negative disturbance. Our experiments validate the effectiveness of our two smoothness metrics and the performance improvements obtained by CS-GNN over existing methods.

heading: 2 MEASURING THE USEFULNESS OF NEIGHBORHOOD INFORMATION
text: We first introduce a general GNN framework and three representative GNN models, which show how existing GNNs aggregate neighborhood information. Then we propose two smoothness metrics to measure the quantity and quality of the information that nodes obtain from their neighbors.

heading: 2.1 GNN FRAMEWORK AND MODELS
text: The notations used in this paper, together with their descriptions, are listed in Appendix A. We use G = {V, E} to denote a graph, where V and E represent the set of nodes and edges of G. We use ev,v′ ∈ E to denote the edge that connects nodes v and v′, and Nv = {v′ : ev,v′ ∈ E} to denote the set of neighbors of a node v ∈ V . Each node v ∈ V has a feature vector xv ∈ X with dimension d. Consider a node classification task, for each node v ∈ V with a class label yv , the goal is to learn a representation vector hv and a mapping function f(·) to predict the class label yv of node v, i.e., ŷv = f(hv) where ŷv is the predicted label.
GNNs are inspired by the Weisfeiler-Lehman test (Weisfeiler & Lehman, 1968; Shervashidze et al., 2011), which is an effective method for graph isomorphism. Similarly, GNNs utilize a neighborhood aggregation scheme to learn a representation vector hv for each node v, and then use neural networks to learn a mapping function f(·). Formally, consider the general GNN framework (Hamilton et al., 2017; Zhou et al., 2018; Xu et al., 2019) in Table 1 with K rounds of neighbor aggregation. In each round, only the features of 1-hop neighbors are aggregated, and the framework consists of two functions, AGGREGATE and COMBINE. We initialize h(0)v = xv . After K rounds of aggregation, each node v ∈ V obtains its representation vector h(K)v . We use h(K)v and a mapping function f(·), e.g., a fully connected layer, to obtain the final results for a specific task such as node classification.
Many GNN models have been proposed. We introduce three representative ones: Graph Convolutional Networks (GCN) (Kipf & Welling, 2017), GraphSAGE (Hamilton et al., 2017), and Graph Attention Networks (GAT) (Velickovic et al., 2018). GCN merges the combination and aggregation functions, as shown in Table 1, where A(·) represents the activation function and W is a learnable parameter matrix. Different from GCN, GraphSAGE uses concatenation ‘||’ as the combination function, which can better preserve a node’s own information. Different aggregators (e.g., mean, max pooling) are provided in GraphSAGE. However, GraphSAGE requires users to choose an aggregator to use for different graphs and tasks, which may lead to sub-optimal performance. GAT addresses this problem by an attention mechanism that learns coefficients of neighbors for aggregation. With the learned coefficients a(k−1)i,j on all the edges (including self-loops), GAT aggregates neighbors with a weighted sum aggregator. The attention mechanism can learn coefficients of neighbors in different graphs and achieves significant improvements over prior GNN models.

heading: 2.2 GRAPH SMOOTHNESS METRICS
text: GNNs usually contain an aggregation step to collect neighboring information and a combination step that merges this information with node features. We consider the context cv of node v as the node’s own information, which is initialized as the feature vector xv of v. We use sv to denote the surrounding of v, which represents the aggregated feature vector computed from v’s neighbors. Since the neighborhood aggregation can be seen as a convolution operation on a graph (Defferrard et al., 2016), we generalize the aggregator as weight linear combination, which can be used to express most existing aggregators. Then, we can re-formulate the general GNN framework as a context-surrounding framework with two mapping functions f1(·) and f2(·) in round k as:
c(k)vi = f1(c (k−1) vi , s (k−1) vi ), s (k−1) vi = f2( ∑ vj∈Nvi a (k−1) i,j · c (k−1) vj ). (1)
From equation (1), the key difference between GNNs and traditional neural-network-based methods for Euclidean data is that GNNs can integrate extra information from the surrounding of a node into its context. In graph signal processing (Ortega et al., 2018), features on nodes are regarded as signals and it is common to assume that observations contain both noises and true signals in a standard signal processing problem (Rabiner & Gold, 1975). Thus, we can decompose a context vector into two parts as c(k)vi = c̆ (k) vi + n̆ (k) vi , where c̆ (k) vi is the true signal and n̆ (k) vi is the noise.
Theorem 1. Assume that the noise n̆(k)vi follows the same distribution for all nodes. If the noise power of n̆(k)vi is defined by its variance σ2, then the noise power of the surrounding input∑
vj∈Nvi a (k−1) i,j · c (k−1) vj is ∑ vj∈Nvi (a (k−1) i,j ) 2 · σ2.
The proof can be found in Appendix B. Theorem 1 shows that the surrounding input has less noise power than the context when a proper aggregator (i.e., coefficient a(k−1)i,j ) is used. Specifically, the mean aggregator has the best denoising performance and the pooling aggregator (e.g., max-pooling) cannot reduce the noise power. For the sum aggregator, where all coefficients are equal to 1, the noise power of the surrounding input is larger than that of the context.

heading: 2.2.1 FEATURE SMOOTHNESS
text: We first analyze the information gain from the surrounding without considering the noise. In the extreme case when the context is the same as the surrounding input, the surrounding input contributes no extra information to the context. To quantify the information obtained from the surrounding, we present the following definition based on information theory. Definition 2 (Information Gain from Surrounding). For normalized feature space Xk = [0, 1]dk , if∑
vj∈Nvi a (k) i,j = 1, the feature space of ∑ vj∈Nvi a (k) i,j · c̆ (k) vj is also in Xk = [0, 1]dk . The probability density function (PDF) of c̆(k)vj over Xk is defined as C(k), which is the ground truth and can be estimated by nonparametric methods with a set of samples, where each sample point c̆(k)vi is sampled with probability |Nvi |/2|E|. Correspondingly, the PDF of ∑ vj∈Nvi a (k) i,j · c̆ (k) vj is S(k), which
can be estimated with a set of samples { ∑
vj∈Nvi a (k) i,j · c̆ (k) vj }, where each point is sampled with
probability |Nvi |/2|E|. The information gain from the surrounding in round k can be computed by Kullback–Leibler divergence (Kullback & Leibler, 1951) as
DKL(S (k)||C(k)) = ∫ Xk S(k)(x) · log S (k)(x) C(k)(x) dx.
The Kullback–Leibler divergence is a measure of information loss when the context distribution is used to approximate the surrounding distribution (Kurt, 2017). Thus, we can use the divergence to measure the information gain from the surrounding into the context of a node. When all the context vectors are equal to their surrounding inputs, the distribution of the context is totally the same with that of the surrounding. In this case, the divergence is equal to 0, which means that there is no extra information that the context can obtain from the surrounding. On the other hand, if the context and the surrounding of a node have different distributions, the divergence value is strictly positive. Note that in practice, the ground-truth distributions of the context and surrounding signals are unknown.
In addition, for learnable aggregators, e.g., the attention aggregator, the coefficients are unknown. Thus, we propose a metric λf to estimate the divergence. Graph smoothness (Zhou & Schölkopf, 2004) is an effective measure of the signal frequency in graph signal processing (Rabiner & Gold, 1975). Inspired by that, we define the feature smoothness on a graph.
Definition 3 (Feature Smoothness). Consider the condition of the first round, where c(0)v = xv , we define the feature smoothness λf over normalized space X = [0, 1]d as
λf = ∣∣∣∣∣∣∑v∈V (∑v′∈Nv (xv − xv′))2∣∣∣∣∣∣1 |E| · d ,
where || · ||1 is the Manhattan norm.
According to Definition 3, a larger λf indicates that the feature signal of a graph has higher frequency, meaning that the feature vectors xv and xv′ are more likely dissimilar for two connected nodes v and v′ in the graph. In other words, nodes with dissimilar features tend to be connected. Intuitively, for a graph whose feature sets have high frequency, the context of a node can obtain more information gain from its surrounding. This is because the PDFs (given in Definition 2) of the context and the surrounding have the same probability but fall in different places in space X . Formally, we state the relation between λf and the information gain from the surrounding in the following theorem. For simplicity, we let X = X0, d = d0, C = C(0) and S = S(0). Theorem 4. For a graph G with the set of features X in space [0, 1]d and using the mean aggregator, the information gain from the surrounding DKL(S||C) is positively correlated to its feature smoothness λf , i.e., DKL(S||C) ∼ λf . In particular, DKL(S||C) = 0 when λf = 0.
The proof can be found in Appendix C. According to Theorem 4, a large λf means that a GNN model can obtain much information from graph data. Note that DKL(S||C) here is under the condition when using the mean aggregator. Others aggregators, e.g., pooling and weight could have different DKL(S||C) values, even if the feature smoothness λf is a constant.

heading: 2.2.2 LABEL SMOOTHNESS
text: After quantifying the information gain with λf , we next study how to measure the effectiveness of information gain. Consider the node classification task, where each node v ∈ V has a label yv , we define vi ' vj if yvi = yvj . The surrounding input can be decomposed into two parts based on the node labels as∑
vj∈Nvi a (k−1) i,j c̆ (k−1) vj = ∑ vj∈Nvi I(vi'vj)a(k−1)i,j c̆ (k−1) vj + ∑ vj∈Nvi (1− I(vi'vj))a(k−1)i,j c̆ (k−1) vj , where I(·) is an indicator function. The first term includes neighbors whose label yvj is the same as yvi , and the second term represents neighbors that have different labels. Assume that the classifier has good linearity, the label of the surrounding input is shifted to ∑ vj∈Nvi a (k−1) i,j · yvj (Zhang et al., 2018), where the label yvj is represented as a one-hot vector here. Note that in GNNs, even if the context and surrounding of vi are combined, the label of vi is still yvi . Thus, for the node classification task, it is reasonable to consider that neighbors with the same label contribute positive information and other neighbors contribute negative disturbance. Definition 5 (Label Smoothness). To measure the quality of surrounding information, we define the label smoothness as
λl = ∑
evi,vj∈E
( 1− I(vi ' vj) ) /|E|.
According to Definition 5, a larger λl implies that nodes with different labels tend to be connected together, in which case the surrounding contributes more negative disturbance for the task. In other words, a small λl means that a node can gain much positive information from its surrounding. To use λl to qualify the surrounding information, we require labeled data for the training. When some graphs do not have many labeled nodes, we may use a subset of labeled data to estimate λl, which is often sufficient for obtaining good results as we show for the BGP dataset used in our experiments.
In summary, we propose a context-surrounding framework, and introduce two smoothness metrics to estimate how much information that the surrounding can provide (i.e., larger λf means more information) and how much information is useful (i.e., smaller λl means more positive information) for a given task on a given graph.

heading: 3 CONTEXT-SURROUNDING GRAPH NEURAL NETWORKS
text: In this section, we present a new GNN model, called CS-GNN, which utilizes the two smoothness metrics to improve the use of the information from the surrounding.

heading: 3.1 THE USE OF SMOOTHNESS FOR CONTEXT-SURROUNDING GNNS
text: The aggregator used in CS-GNN is weighted sum and the combination function is concatenation. To compute the coefficients for each of the K rounds, we use a multiplicative attention mechanism similar to Vaswani et al. (2017). We obtain 2|E| attention coefficients by multiplying the leveraged representation vector of each neighbor of a node with the node’s context vector, and applying the softmax normalization. Formally, each coefficient a(k)i,j in round k is defined as follows:
a (k) i,j =
exp ( A(p (k) vi · q (k) i,j ) )∑
vl∈Nvi exp
( A(p (k) vi · q (k) i,l ) ) , (2)
where p(k)vi = (W (k) p ·h(k)vi )>, q (k) i,j = p (k) vi −W (k) q ·h(k)vj , W (k) p and W (k) q are two learnable matrices.
To improve the use of the surrounding information, we utilize feature and label smoothness as follows. First, we use λl to drop neighbors with negative information, i.e., we set a (k) i,j = 0 if a (k) i,j is less than the value of the r-th (r = d2|E|λle) smallest attention coefficient. As these neighbors contain noisy disturbance to the task, dropping them is helpful to retain a node’s own features.
Second, as λf is used to estimate the quantity of information gain, we use it to set the dimension of p(k)vi as ddk · √ λfe, which is obtained empirically to achieve good performance. Setting the appropriate dimension is important because a large dimension causes the attention mechanism to fluctuate while a small one limits its expressive power.
Third, we compute the attention coefficients differently from GAT (Velickovic et al., 2018). GAT uses the leveraged representation vectorW (k) ·h(k)vj to compute the attention coefficients. In contrast, in equation (2) we use q(k)i,j , which is the difference of the context vector of node vi and the leveraged representation vector of neighbor vj . The definition of q (k) i,j is inspired by the fact that a larger λf indicates that the features of a node and its neighbor are more dissimilar, meaning that the neighbor can contribute greater information gain. Thus, using q(k)i,j , we obtain a larger/smaller a (k) i,j when the features of vi and its neighbor vj are more dissimilar/similar. For example, if the features of a node and its neighbors are very similar, then q(k)i,j is small and hence a (k) i,j is also small.
Using the attention coefficients, we perform K rounds of aggregations with the weighted sum aggregator to obtain the representation vectors for each node as
h(k)vi = A ( W (k) l · ( h(k−1)vi ∣∣∣∣∑ vj∈Nvi a (k−1) i,j · h (k−1) vj )) ,
where W (k)l is a learnable parameter matrix to leverage feature vectors. Then, for a task such as node classification, we use a fully connected layer to obtain the final results ŷvi = A(W · h (K) vi ), where W is a learnable parameter matrix and ŷvi is the predicted classification result of node vi.

heading: 3.2 SIDE INFORMATION ON GRAPHS
text: Real-world graphs often contain side information such as attributes on both nodes and edges, local topology features and edge direction. We show that CS-GNN can be easily extended to include rich side information to improve performance. Generally speaking, side information can be divided into two types: context and surrounding. Usually, the side information attached on nodes belongs to the context and that on edges or neighbors belongs to the surrounding. To incorporate the side information into our CS-GNN model, we use the local topology features as an example.
We use a method inspired by GraphWave (Donnat et al., 2018), which uses heat kernel in spectral graph wavelets to simulate heat diffusion characteristics as topology features. Specifically, we construct |V| subgraphs, G = {Gv1 , Gv2 ..., Gv|V|}, from a graph G = {V, E}, where Gvi is composed
of v and its neighbors within K hops (usually K is small, K = 2 as default in our algorithm), as well as the connecting edges. For each Gvi ∈ G, the local topology feature vector tvi of node vi is obtained by a method similar to GraphWave.
Since the topology feature vector tvi itself does not change during neighborhood aggregation, we do not merge it into the representation vector. In the attention mechanism, we regard tvi as a part of the context information by incorporating it into p(k)vi = (W (k) p · (h(k)vi ||tvi))>. And in the last fully connected layer, we use tvi to obtain the predicted class label ŷvi = A(W · (h (K) vi ||tvi)).

heading: 3.3 COMPARISON WITH EXISTING GNN MODELS
text: The combination functions of existing GNNs are given in Table 1. The difference between additive combination and concatenation is that concatenation can retain a node’s own feature. For the aggregation functions, different from GCN and GraphSAGE, GAT and CS-GNN improve the performance of a task on a given graph by an attention mechanism to learn the coefficients. However, CS-GNN differs from GAT in the following ways. First, the attention mechanism of CS-GNN follows multiplicative attention, while GAT follows additive attention. Second, CS-GNN’s attention mechanism utilizes feature smoothness and label smoothness to improve the use of neighborhood information as discussed in Section 3.1. This is unique in CS-GNN and leads to significant performance improvements over existing GNNs (including GAT) for processing some challenging graphs (to be reported in Section 4.2). Third, CS-GNN uses side information such as local topology features to further utilize graph structure as discussed in Section 3.2.

heading: 4 EXPERIMENTAL EVALUATION
text: We first compare CS-GNN with representative methods on the node classification task. Then we evaluate the effects of different feature smoothness and label smoothness on the performance of neural networks-based methods.

heading: 4.1 BASELINE METHODS, DATASETS, AND SETTINGS
text: Baseline. We selected three types of methods for comparison: topology-based methods, featurebased methods, and GNN methods. For each type, some representatives were chosen. The topologybased representatives are struc2vec (Ribeiro et al., 2017), GraphWave (Donnat et al., 2018) and Label Propagation (Zhu & Ghahramani, 2002), which only utilize graph structure. struc2vec learns latent representations for the structural identity of nodes by random walk (Perozzi et al., 2014), where node degree is used as topology features. GraphWave is a graph signal processing method (Ortega et al., 2018) that leverages heat wavelet diffusion patterns to represent each node and is capable of capturing complex topology features (e.g., loops and cliques). Label Propagation propagates labels from labeled nodes to unlabeled nodes. The feature-based methods are Logistic Regression and Multilayer Perceptron (MLP), which only use node features. The GNN representatives are GCN, GraphSAGE and GAT, which utilize both graph structure and node features.
Datasets. We used five real-world datasets: three citation networks (i.e., Citeseer, Cora (Sen et al., 2008) PubMed (Namata et al., 2012)), one computer co-purchasing network in Amazon (McAuley et al., 2015), and one Border Gateway Protocol (BGP) Network (Luckie et al., 2013). The BGP network describes the Internet’s inter-domain structure and only about 16% of the nodes have labels. Thus, we created two datasets: BGP (full), which is the original graph, and BGP (small), which was obtained by removing all unlabeled nodes and edges connected to them. The details (e.g., statistics and descriptions) of the datasets are given in Appendix D.
Settings. We use F1-Micro score to measure the performance of each method for node classification. To avoid under-fitting, 70% nodes in each graph are used for training, 10% for validation and 20% for testing. For each baseline method, we set their the parameters either as their default values or the same as in CS-GNN. For the GNNs and MLP, the number of hidden layers (rounds) was set as K = 2 to avoid over-smoothing. More detailed settings are given in Appendix E.
Note that GraphSAGE allows users to choose an aggregator. We tested four aggregators for GraphSAGE (details in Appendix F) and report the best result for each dataset in our experiments below.

heading: 4.2 PERFORMANCE RESULTS OF NODE CLASSIFICATION
text: Smoothness. Table 2 reports the two smoothness values of each dataset. Amazon has a much larger λf value (i.e., 89.67 × 10−2) than the rest, while PubMed has the smallest λf value. This implies that the feature vectors of most nodes in Amazon are dissimilar and conversely for PubMed. For label smoothness λl, BGP (small) has a fairly larger value (i.e., 0.71) than the other datasets, which means that 71% of connected nodes have different labels. Since BGP (full) contains many unlabeled nodes, we used BGP (small)’s λl as an estimation.
F1-Micro scores. Table 3 reports the F1-Micro scores of the different methods for the task of node classification. The F1-Micro scores are further divided into three groups. For the topologybased methods, Label Propagation has relatively good performance for the citation networks and the co-purchasing Amazon network, which is explained as follows. Label Propagation is effective in community detection and these graphs contain many community structures, which can be inferred from their small λl values. This is because a small λl value means that many nodes have the same class label as their neighbors, while nodes that are connected together and in the same class tend to form a community. In contrast, for the BGP graph in which the role (class) of the nodes is mainly decided by topology features, struc2vec and GraphWave give better performance. GraphWave ran out of memory (512 GB) on the larger graphs as it is a spectrum-based method. For the feature-based methods, Logistic Regression and MLP have comparable performance on all the graphs.
For the GNN methods, GCN and GraphSAGE have comparable performance except on the PubMed and BGP graphs, and similar results are observed for GAT and CS-GNN. The main reason is that PubMed has a small λf , which means that a small amount of information gain is obtained from the surrounding, and BGP has large λl, meaning that most information obtained from the surrounding is negative disturbance. Under these two circumstances, using concatenation as the combination function allows GraphSAGE and CS-GNN to retain a node’s own features. This is also why Logistic Regression and MLP also achieve good performance on PubMed and BGP because they only use the node features. However, for the other datasets, GAT and CS-GNN have considerably higher F1-Micro scores than all the other methods. Overall, CS-GNN is the only method that achieves competitive performance on all the datasets.
We further examine the effects of local topology features (LTF) on the performance. We report the results of CS-GNN without using LTF, denoted as CS-GNN (w/o LTF) in Table 3. The results show that using LTF does not significantly improve the performance of CS-GNN. However, the results do reveal the effectiveness of the smoothness metrics in CS-GNN, because the difference between
CS-GNN (w/o LTF) and GAT is mainly in the use of the smoothness metrics in CS-GNN’s attention mechanism. As shown in Table 3, CS-GNN (w/o LTF) still achieves significant improvements over GAT on PubMed (by improving the gain of positive information) and BGP (by reducing negative noisy information from the neighborhood).
Improvements over non-GNN methods. We also evaluate whether GNNs are always better methods, in other words, whether graph information is always useful. Table 4 presents the improvements of existing GNNs (i.e., GCN, GraphSAGE, GAT) and CS-GNN over the topology-based and feature-based methods, respectively. The improvements (in %) are calculated based on the average F1-Micro scores of each group of methods. The results show that using the topology alone, even if the surrounding neighborhood is considered, is not sufficient. This is true even for the BGP graphs for which the classes of nodes are mainly determined by the graph topology. Compared with featurebased methods, GNN methods gain more information from the surrounding, which is converted into performance improvements. However, for graphs with small λf and large λl, existing GNN methods fail to obtain sufficient useful information or obtain too much negative noisy information, thus leading to even worse performance than purely feature-based methods. In contrast, CS-GNN utilizes smoothness to increase the gain of positive information and reduce negative noisy information for a given task, thus achieving good performance on all datasets.

heading: 4.3 SMOOTHNESS ANALYSIS
text: The results in Section 4.2 show that GNNs can achieve good performance by gaining surrounding information in graphs with large λf and small λl. However, the experiments were conducted on different graphs and there could be other factors than just the smoothness values of the graphs. Thus, in this experiment we aim to verify the effects of smoothness using one graph only.
To adjust λf in a graph, we broadcast the feature vector of each node to its neighbors in rounds. In each round, when a node receives feature vectors, it updates its feature vector as the mean of its current feature vector and those feature vectors received, and then broadcast the new feature vector to its neighbors. If we keep broadcasting iteratively, all node features converge to the same value due to over-smoothness. To adjust λl, we randomly drop a fraction of edges that connect two nodes with different labels. The removal of such edges decreases the value of λl and allows nodes to gain more positive information from their neighbors. We used the Amazon graph for the evaluation because the graph is dense and has large λf .
Figure 1 reports the F1-Micro scores of the neural-network-based methods (i.e., MLP and the GNNs). Figure 1 (left) shows that as we broadcast from 20 to 28 rounds, λf also decreases accordingly. As λf decreases, the performance of the GNN methods also worsens due to over-smoothness. However, the performance of MLP first improves significantly and then worsens, and becomes the poorest at the end. This is because the GNN methods can utilize the surrounding information by their design but MLP cannot. Thus, the broadcast of features makes it possible for MLP to first attain the surrounding information. But after many rounds of broadcast, the effect of over-smoothness becomes obvious and MLP’s performance becomes poor. The results are also consistent with the fact that GNN models cannot be deep due to the over-smoothness effect. Figure 1 (right) shows that when λl decreases, the performance of the GNN methods improves accordingly. On the contrary, since MLP does not use surrounding information, dropping edges has no effect on its performance. In summary, Figure 1 further verifies that GNNs can achieve good performance on graphs with large λf and small λl, where they can obtain more positive information gain from the surrounding.

heading: 5 CONCLUSIONS
text: We studied how to measure the quantity and quality of the information that GNNs can obtain from graph data. We then proposed CS-GNN to apply the smoothness measures to improve the use of graph information. We validated the usefulness of our method for measuring the smoothness values of a graph for a given task and that CS-GNN is able to gain more useful information to achieve improved performance over existing methods.

heading: ACKNOWLEDGMENTS
text: We thank the reviewers for their valuable comments. We thank Mr. Ng Hong Wei for processing the BGP data. This work was supported in part by ITF 6904945 and GRF 14222816.

heading: A NOTATIONS
text: The notations used in the paper and their descriptions are listed in Table 5.

heading: B PROOF OF THEOREM 1
text: Proof. We use the variance of n̆(k−1)vj to measure the power of noise. Without loss of generality, we assume that the signal c̆(k−1)vj is uncorrelated to the noise n̆ (k−1) vj and noise is random, with a mean of zero and constant variance. If we define
Var ( n̆(k−1)vj ) = E [( n̆(k−1)vj )2] = σ2,
then after the weight aggregation, the noise power of ∑
vj∈Nvi a (k−1) i,j · c (k−1) vj is
Var (∑
vj∈Nvi a (k−1) i,j · n̆ (k−1) vj
) = E [(∑ vj∈Nvi a (k−1) i,j · n̆ (k−1) vj )2] = ∑
vj∈Nvi
( a (k−1) i,j σ )2 = σ2 ·
∑ vj∈Nvi ( a (k−1) i,j )2 .

heading: C PROOF OF THEOREM 4
text: Proof. For simplicity of presentation, let X = X0, d = d0, C = C(0) and S = S(0). For DKL(S||C), since the PDFs of C and S are unknown, we use a nonparametric way, histogram, to estimate the PDFs of C and S. Specifically, we uniformly divide the feature space X = [0, 1]d into rd bins {H1, H2, ...,Hrd}, whose length is 1r and dimension is d. To simplify the use of notations, we use |Hi|C and |Hi|S to denote the number of samples that are in bin Hi. Thus, we have
DKL(S||C) ≈ DKL(Ŝ||Ĉ)
= rd∑ i=1 |Hi|S 2|E| · log |Hi|S 2|E| |Hi|C 2|E|
= 1
2|E| · rd∑ i=1 |Hi|S · log |Hi|S |Hi|C
= 1 2|E| · ( rd∑
i=1 |Hi|S · log |Hi|S − rd∑ i=1 |Hi|S · log |Hi|C )
= 1 2|E| · ( rd∑
i=1 |Hi|S · log |Hi|S − rd∑ i=1 |Hi|S · log (|Hi|S + ∆i) ) ,
where ∆i = |Hi|C − |Hi|S . Regard ∆i as an independent variable, we consider the term∑rd i=1 |Hi|S · log (|Hi|S + ∆i) with second-order Taylor approximation at point 0 as
rd∑ i=1 |Hi|S · log (|Hi|S + ∆i) ≈ rd∑ i=1 |Hi|S · ( log |Hi|S + ln 2 |Hi|S ·∆i −
ln 2
2(|Hi|S)2 ·∆2i
) .
Note that the numbers of samples for the context and the surrounding are the same, where we have
rd∑ i=1 |Hi|C = rd∑ i=1 |Hi|S = 2 · |E|.
Thus, we obtain rd∑ i=1 ∆i = 0.
Therefore, the DKL(Ŝ||Ĉ) can be written as
DKL(S||C) ≈ DKL(Ŝ||Ĉ)
= 1 2|E| · ( rd∑
i=1 |Hi|S · log |Hi|S − rd∑ i=1 |Hi|S · log (|Hi|S + ∆i) )
≈ 1 2|E| ( rd∑ i=1 |Hi|S log |Hi|S − rd∑ i=1 |Hi|S ( log |Hi|S + ln 2 |Hi|S ∆i −
ln 2
2(|Hi|S)2 ∆2i
))
= 1
2|E| · rd∑ i=1 ( ln 2 2|Hi|S ∆2i − ln 2 ·∆i )
= ln 2
4|E| · rd∑ i=1 ∆2i |Hi|S ,
which is the Chi-Square distance between |Hi|C and |Hi|S . If we regard |Hi|S as constant, then we have: if ∆2i are large, the information gain DKL(S||C) tends to be large. Formally, consider the
samples of C as {xv : v ∈ V} and the samples of S as { 1|Nv| ∑
v′∈Nv xv′ : v ∈ V} with counts |Nv| of node v, we have the expectation and variance of their distance as
E [ |Nv| · xv − ∑ v′∈Nv xv′ ] = 0,
Var ( |Nv| · xv − ∑ v′∈Nv xv′ ) = E [( |Nv| · xv − ∑ v′∈Nv xv′ )2] ≥ 0.
For simplicity, for the distribution of the difference between the surrounding and the context, |Nv| · xv − ∑ v′∈Nv xv′ , we consider it as noises on the “expected” signal as the surrounding, 1 |Nv| ·∑
v′∈Nv xv′ , where the context xv is the “observed” signal. Apparently the power of the noise on the samples is positively correlated with the difference between their PDFs, which means that a large Var ( |Nv| · xv − ∑ v′∈Nv xv′ ) would introduce a large difference between |Hi|S and |Hi|C . Then, we obtain rd∑ i=1 ∆2i |Hi|S ∼ Var ( |Nv| · xv − ∑ v′∈Nv xv′ ) ,
then it is easy to obtain
DKL(S||C) ≈ ln 2
4|E| · rd∑ i=1 ∆2i |Hi|S ∼ Var ( |Nv| · xv − ∑ v′∈Nv xv′ ) .
Recall the definition of λf , if xvi and xvj are independent, we have
λf = ∣∣∣∣∣∣∑v∈V (∑v′∈Nv (xv − xv′))2∣∣∣∣∣∣1 |E| · d
= ∣∣∣∣∣∣∑v∈V (|Nv| · xv −∑v′∈Nv xv′)2∣∣∣∣∣∣1 |E| · d
= ∣∣∣∣∣∣Var(|Nv| · xv −∑v′∈Nv xv′)∣∣∣∣∣∣1 |V| · |E| · d
∼ Var ( |Nv| · xv − ∑ v′∈Nv xv′ ) .
Therefore, we obtain
DKL(S||C) ≈ ln 2
4|E| · rd∑ i=1 ∆2i |Hi|S ∼ Var ( |Nv| · xv − ∑ v′∈Nv xv′ ) ∼ λf .
If λf = 0, we have that all nodes have the same feature vector xv . Obviously, DKL(Ŝ||Ĉ) = 0.
D DATASETS
Table 6 presents some statistics of the datasets used in our experiments, including the number of nodes |V|, the number of edges |E|, the average degree, the dimension of feature vectors, the number
of classes, the feature smoothness λf and the label smoothness λl. The BGP (small) dataset was obtained from the original BGP dataset, i.e., BGP (full) in Table 6, by removing all unlabeled nodes and edges connected to them. Since BGP (full) contains many unlabeled nodes, we used BGP (small)’s λl as an estimation. As we can see in Table 6, the three citation networks are quite sparse (with small average degree), while the other two networks are denser. According to the feature smoothness, Amazon (computer) has much larger λf than that of the others, which means that nodes with dissimilar features tend to be connected. As for the label smoothness λl, the BGP network has larger value than that of the others, meaning that connected nodes tend to belong to different classes. A description of each of these datasets is given as follows.
• Citeseer (Sen et al., 2008) is a citation network of Machine Learning papers that are divided into 6 classes: {Agents, AI, DB, IR, ML, HCI}. Nodes represent papers and edges model the citation relationships.
• Cora (Sen et al., 2008) is a citation network of Machine Learning papers that divided into 7 classes: {Case Based, Genetic Algorithms, Neural Networks, Probabilistic Methods, Reinforcement Learning, Rule Learning, Theory}. Nodes represent papers and edges model the citation relationships.
• PubMed (Namata et al., 2012) is a citation network from the PubMed database, which contains a set of articles (nodes) related to diabetes and the citation relationships (edges) among them. The node features are composed of TF/IDF-weighted word frequencies, and the node labels are the diabetes type addressed in the articles.
• Amazon Product (McAuley et al., 2015) is a co-purchasing network derived from the Amazon platform. Nodes are computers and edges connect products that were bought together. Features are calculated from the product image, and labels are the categories of computers. We used the processed version by Alex Shchur in GitHub.
• Border Gateway Protocol (BGP) Network (Luckie et al., 2013) describes the Internet’s inter-domain structure, where nodes represent the autonomous systems and edges are the business relationships between nodes. The features contain basic properties, e.g., the location and topology information (e.g., transit degree), and labels means the types of autonomous systems. We used the dataset that was collected in 2018-12-31 and published in Center for Applied Internet Data Analysis.

heading: E PARAMETERS
text: For struc2vec and GraphWave, we used their default settings to obtain the node embeddings for all nodes since they are unsupervised. For struc2vec, we set their three optimization as “True”. The embedding dimension of struc2vec is 128 and that of GraphWave is 100. Then based on those embeddings, we put them in a logistic model implemented by (Perozzi et al., 2014), where the embeddings of the training set were used to train the logistic model and the embeddings of the test set were used to obtain the final F1-Micro score. Label Propagation is a semi-supervised algorithm, where nodes in the training set were regarded as nodes with labels, and those nodes in the validation set and test set were regarded as unlabeled nodes.
The feature-based methods and GNN methods used the same settings: the batch size was set as 512; the learning rate was set as 0.01; the optimizer was Adam. Except GraphSAGE, which set the epoch number as 10, all the other methods were implemented with the early stop strategy with the patience number set as 100. Other parameters were slightly different for different datasets but still the same for all methods. Specifically, for Citeseer and Cora, the dropout was set as 0.2, and the weight decay was set as 0.01. And the hidden number was set as 8. For PubMed, the dropout was set as 0.3, but the weight decay was set as 0. The hidden number was 16. For Amazon (computer), BGP (small) and BGP (full), the dropout was set as 0.3, and the weight decay was set as 0. The hidden number was 32. As for GAT and CS-GNN, the attention dropout was set as the same as the dropout. And the dimension of topology features in CS-GNN was set as 64. Note that the residual technique introduced in GAT was used for the GNN methods. As for the activation function in CS-GNN, ReLU was used for feature leveraging and ELU was used for the attention mechanism.

heading: F THE PERFORMANCE OF GRAPHSAGE WITH DIFFERENT AGGREGATORS
text: Table 7 reports the F1-Micro scores of GCN and GraphSAGE with four different aggregators: GCN, mean, LSTM and max-pooling. The results show that for GraphSAGE, except on PubMed and BGP, the four aggregators achieve comparable performance. The results of GCN and GraphSAGE-GCN are worse than the others for PubMed and the BGP graphs because of the small information gain (i.e., small λf ) of PubMed and the large negative disturbance (i.e., large λl) of BGP as reported in Table 3 and Section 4.2. As explained in Section 3.3, GCN uses additive combination merged with aggregation, where the features of each node are aggregated with the features of its neighbors. As a result, GCN has poor performance for graphs with small λf and large λl, because it merges the context with the surrounding with negative information for a given task. This is further verified by the results of GraphSAGE using the other three aggregators, which still have comparable performance on all the datasets. In Section 4, we report the best F1-Micro score among these four aggregators for each dataset as the performance of GraphSAGE.

heading: G THE KULLBACK–LEIBLER DIVERGENCE VS. MUTUAL INFORMATION
text: We use the Kullback–Leibler Divergence (KLD), instead of using Mutual Information (MI), to measure the information gain from the neighboring nodes in Section 2.2.1 because of the following reason. In an information diagram, mutual information I(X;Y ) can be seen as the overlap of two correlated variables X and Y , which is a symmetric measure. In contrast, DKL(X||Y ) can be seen as the extra part brought by X to Y , which is a measure of the non-symmetric difference between two probability distributions. Considering the node classification task, the information contributed by neighbors and the information contributed to neighbors are different (i.e., non-symmetric). Thus, we use the KLD instead of MI.
We remark that, although some existing GNN works (Velickovic et al., 2019; Chen et al., 2019) use MI in their models, their purposes are different from our work. MI can be written as I(X,Y ) = DKL(P (X,Y )||P (X) × P (Y )), where P (X,Y ) is the joint distribution of X and Y , and P (X), P (Y ) are marginal distributions of X and Y . From this perspective, we can explain the mutual information of X and Y as the information loss when the joint distribution is used to approximate the marginal distributions. However, this is not our purpose in node classification.

Review summaries:
The authors study how neighbor information on graphs can be used in Graph Neural Networks. It proposes measures on whether the data in neighboring nodes are useful in terms of labels or features. It also provides a new Graph Neural Network algorithm that is a modification of attention-based models incorporating the derived label and feature smoothness measures. The paper demonstrates the usefulness of these measures and algorithms with several different baselines from different families. The writing is mostly smooth, and the authors seem to provide enough detail of the experiments performed.

The paper proposes two graph smoothness metrics for measuring the usefulness of graph information. The feature smoothness indicates how much information can be gained by aggregating neighboring nodes while the label smoothness assesses the quality of this information. The authors show that Graph Neural Networks (GNNs) work best for tasks with high features smoothness and low label smoothness by utilizing information from surrounding nodes which also tends to have the same label. Based on these two metrics, the authors introduce a framework, called Context-Surrounding Graph Neural Network (CS-GNN), that utilizes important information from neighboring nodes of the same label while reduce the disturbance from neighboring nodes from different classes. The results demonstrate considerable improvement across 5 different tasks.