M EASURING AND I MPROVING THE U SE OF G RAPH I NFORMATION IN G RAPH N EURAL N ETWORKS
Anonymous authors
Paper under double-blind review
A BSTRACT
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.
I NTRODUCTION
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 classiﬁcation and link predication. GNNs utilize the relationship information in graph data and signiﬁcant 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).
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 classiﬁcation.
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 speciﬁc 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.
M EASURING THE U SEFULNESS OF N EIGHBORHOOD I NFORMATION
We ﬁrst 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.
2. GNN F RAMEWORK AND M ODELS
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 e v,v (cid:48)
∈ E to denote the edge that connects nodes v and v (cid:48) , and N v = { v (cid:48) : e v,v (cid:48) ∈ E} to denote the set of neighbors of a node v ∈ V .
Each node v ∈ V has a feature vector x v ∈ X with dimension d .
Consider a node classiﬁcation task, for each node v ∈ V with a class label y v , the goal is to learn a representation vector h v and a mapping function f ( · ) to predict the class label y v of node v , i.e., ˆ y v
= f ( h v ) where ˆ y v is the predicted label.
[Table]
[Table]
[Equation]
[Table] [Equation] [Table] 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 h v 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 = x v .
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 ﬁnal results for a speciﬁc task such as node classiﬁcation.
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 coefﬁcients of neighbors for aggregation.
With the learned coefﬁcients 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 coefﬁcients of neighbors in different graphs and achieves signiﬁcant improvements over prior GNN models.
2. G RAPH S MOOTHNESS M ETRICS
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 c v of node v as the node’s own information, which is initialized as the feature vector x v of v .
We use s v 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 f 1 ( · ) and f 2 ( · ) in round k as:
[Equation]
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 ) v i = ˘ c ( k ) v i + ˘ n ( k ) v i , where ˘ c ( k ) v
i is the true signal and ˘ n ( k ) v
i is the noise.
Theorem 1.
Assume that the noise ˘ n ( k ) v i follows the same distribution for all nodes.
If the noise power of ˘ n ( k ) v i is deﬁned by its variance σ 2 , then the noise power of the surrounding input (cid:80) [Equation] j [Equation]
i [Equation] − [Equation]
is (cid:80)
[Equation]
[Equation]
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., coefﬁcient a ( k − 1) i,j ) is used.
Speciﬁcally, 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 coefﬁcients are equal to 1 , the noise power of the surrounding input is larger than that of the context.
2.2. F EATURE S MOOTHNESS
We ﬁrst 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 deﬁnition based on information theory.
Deﬁnition 2 (Information Gain from Surrounding) .
For normalized feature space X k = [0 , 1] d k , if (cid:80) v j ∈N vi a ( k ) i,j = 1 , the feature space of (cid:80) v j ∈N vi a ( k ) i,j · ˘ c ( k ) v j is also in X k = [0 , 1] d k .
The probability density function (PDF) of ˘ c ( k ) v j over X k is deﬁned 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 ) v i is sampled with probability |N
v i | / 2 |E| .
Correspondingly, the PDF of (cid:80) v j ∈N vi a ( k ) i,j · ˘ c ( k ) v j is S ( k ) , which can be estimated with a set of samples { (cid:80) v j ∈N vi a ( k ) i,j · ˘ c ( k ) v j } , where each point is sampled with probability
|N
v i | / 2 |E| .
The information gain from the surrounding in round k can be computed by
Kullback–Leibler divergence (Kullback & Leibler, 1951) as
[Equation]
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 coefﬁcients are unknown.
Thus, we propose a metric λ f to estimate the divergence.
Graph smoothness (Zhou & Sch¨olkopf, 2004) is an effective measure of the signal frequency in graph signal processing (Rabiner & Gold, 1975).
Inspired by that, we deﬁne the feature smoothness on a graph.
Deﬁnition 3 ( Feature Smoothness ) .
Consider the condition of the ﬁrst round, where c (0) v = x v , we deﬁne the feature smoothness λ f over normalized space X =
[0 , 1] d as
[Equation]
[Table]
[Equation] where || · || 1 is the Manhattan norm.
According to Deﬁnition 3, a larger λ f indicates that the feature signal of a graph has higher frequency , meaning that the feature vectors x v and x v (cid:48) are more likely dissimilar for two connected nodes v and v (cid:48) 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 Deﬁnition 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 =
X
0 , d = d 0 , 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 D KL ( S || C ) is positively correlated to its feature smoothness λ f , i.e., D KL ( S || C ) ∼ λ f .
In particular, D KL ( S || C ) =
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 D KL ( S || C ) here is under the condition when using the mean aggregator.
Others aggregators, e.g., pooling and weight could have different
D KL ( S || C ) values, even if the feature smoothness λ f is a constant.
2.2. L ABEL S MOOTHNESS
After quantifying the information gain with λ f , we next study how to measure the effectiveness of information gain.
Consider the node classiﬁcation task, where each node v ∈ V has a label y v , we deﬁne v i (cid:39) v j if y v i
=
y v j .
The surrounding input can be decomposed into two parts based on the node labels as
[Equation]
where I ( · ) is an indicator function.
The ﬁrst term includes neighbors whose label y v j is the same as y v i , and the second term represents neighbors that have different labels.
Assume that the classiﬁer has good linearity, the label of the surrounding input is shifted to (cid:80) v j ∈N vi a ( k − 1) i,j · y v j (Zhang et al., 2018), where the label y v j is represented as a one-hot vector here.
Note that in GNNs, even if the context and surrounding of v i are combined, the label of v i is still y v i .
Thus, for the node classiﬁcation task, it is reasonable to consider that neighbors with the same label contribute positive information and other neighbors contribute negative disturbance.
Deﬁnition 5 ( Label Smoothness ) .
To measure the quality of surrounding information, we deﬁne the label smoothness as
[Equation]
According to Deﬁnition 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 sufﬁcient 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.
C ONTEXT -S URROUNDING G RAPH N EURAL N ETWORKS
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.
3. T HE U SE OF S MOOTHNESS FOR C ONTEXT -S URROUNDING GNN S
The aggregator used in CS-GNN is weighted sum and the combination function is concatenation .
To compute the coefﬁcients for each of the K rounds, we use a multiplicative attention mechanism similar to Vaswani et al.
We obtain 2 |E| attention coefﬁcients 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 coefﬁcient a ( k ) i,j in round k is deﬁned as follows:
[Equation]
, (2) where p ( k ) v i =
( W ( k ) p · h ( k ) v i ) (cid:62) , q ( k ) i,j = p ( k ) v
i − W ( k ) q · h ( k ) v j , 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 = (cid:100) 2 |E| λ l (cid:101) )
smallest attention coefﬁcient.
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 ) v i as (cid:100)
d k · (cid:112) λ f (cid:101) , which is obtained empirically to achieve good performance.
Setting the appropriate dimension is important because a large dimension causes the attention mechanism to ﬂuctuate while a small one limits its expressive power.
Third, we compute the attention coefﬁcients differently from GAT (Velickovic et al., 2018). GAT uses the leveraged representation vector W ( k ) · h ( k ) v j to compute the attention coefﬁcients. In contrast, in equation (2) we use q ( k ) i,j , which is the difference of the context vector of node v i and the leveraged representation vector of neighbor v j .
The deﬁnition 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 v i and its neighbor v j 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 coefﬁcients, we perform K rounds of aggregations with the weighted sum aggregator to obtain the representation vectors for each node as
[Equation]
where W ( k ) l is a learnable parameter matrix to leverage feature vectors.
Then, for a task such as node classiﬁcation, we use a fully connected layer to obtain the ﬁnal results ˆ y
[Equation]
= A ( W · h ( K ) v i ) , where W is a learnable parameter matrix and ˆ y v i is the predicted classiﬁcation result of node v i .
3. S IDE I NFORMATION ON G RAPHS
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.
Speciﬁcally, we construct |V| subgraphs, G = { G v 1 , G v 2 ..., G v |V| } , from a graph G = {V , E} , where G v i 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 G v i ∈ G , the local topology feature vector t v i of node
v i is obtained by a method similar to GraphWave.
Since the topology feature vector t v i itself does not change during neighborhood aggregation, we do not merge it into the representation vector.
In the attention mechanism, we regard t v i as a part of the context information by incorporating it into p ( k ) v i =
( W ( k ) p · ( h ( k ) v
i || t v i ))
(cid:62) .
And in the last fully connected layer, we use t v i to obtain the predicted class label ˆ y v i
=
A ( W · ( h ( K ) v
i || t v i )) .
3. C OMPARISON WITH E XISTING GNN M ODELS
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 coefﬁcients.
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 signiﬁcant 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.
E XPERIMENTAL E VALUATION
We ﬁrst compare CS-GNN with representative methods on the node classiﬁcation task.
Then we evaluate the effects of different feature smoothness and label smoothness on the performance of neural networks-based methods.
4. B ASELINE M ETHODS , D ATASETS , AND S ETTINGS
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 ﬁve 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 classiﬁcation.
To avoid under-ﬁtting, 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.
4. P ERFORMANCE R ESULTS OF N ODE C LASSIFICATION
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.
[Table]
F1-Micro scores.
Table 3 reports the F1-Micro scores of the different methods for the task of node classiﬁcation.
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. [Table]
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 signiﬁcantly 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 signiﬁcant 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 sufﬁcient.
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 sufﬁcient 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. [Table]
[Figure]
4. S MOOTHNESS A NALYSIS
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
[Figure]
Thus [Figure]
in this experiment we aim to verify the effects of smoothness using one graph only
[Figure]
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 2 0 to 2 8 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 ﬁrst improves signiﬁcantly 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 ﬁrst 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 veriﬁes 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.
C ONCLUSIONS
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.
A N OTATIONS
The notations used in the paper and their descriptions are listed in Table 5.
[Table]
B P ROOF OF T HEOREM
Proof.
We use the variance of ˘ n ( k − 1) v j to measure the power of noise.
Without loss of generality, we assume that the signal ˘ c ( k − 1) v j is uncorrelated to the noise ˘ n ( k − 1) v j and noise is random, with a mean of zero and constant variance.
If we deﬁne
[Equation]
then after the weight aggregation, the noise power of (cid:80) v j ∈N vi a ( k − 1) i,j
[Equation]
Var
[Equation]
C P ROOF OF T HEOREM
Proof.
For simplicity of presentation, let X
=
X
0 , d = d 0 , C = C (0) and S = S (0) .
For
D KL ( 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 .
Speciﬁcally, we uniformly divide the feature space X =
[0 , 1] d into r d bins { H 1 , H 2 , ..., H r d } , whose length is 1 r and dimension is d .
To simplify the use of notations, we use | H i | C and | H i | S to denote the number of samples that are in bin H i .
Thus, we have
[Equation]
where ∆ i = | H i | C − | H i | S .
Regard ∆ i as an independent variable, we consider the term (cid:80) r d i =
| H i | S · log ( | H i | S + ∆ i ) with second-order Taylor approximation at point 0 as
[Equation]
Note that the numbers of samples for the context and the surrounding are the same, where we have
[Equation]
Thus
[Equation]
we obtain
[Equation]
Therefore
[Equation]
the D KL ( ˆ S
|| ˆ C ) can be written as
[Equation]
which is the Chi-Square distance between | H i | C and | H i | S .
If we regard | H i | S as constant, then we have: if ∆ 2 i are large, the information gain D KL ( S || C ) tends to be large.
Formally, consider the samples of C as { x v : v ∈ V} and the samples of S as { 1 |N v | (cid:80) v (cid:48) ∈N v x v
[Equation]
: v ∈ V} with counts |N v | of node v , we have the expectation and variance of their distance as
[Equation]
For simplicity, for the distribution of the difference between the surrounding and the context, |N v | · x v − (cid:80) v (cid:48) ∈N v x v (cid:48) , we consider it as noises on the “expected” signal as the surrounding, 1 |N v | · (cid:80) v (cid:48) ∈N v x v (cid:48) , where the context x v 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 (cid:0) |N v | · x v − (cid:80) v (cid:48) ∈N
[Equation]
x
[Equation]
(cid:1) would introduce a large difference between | H i | S and | H i | C .
Then, we obtain
[Equation]
then it is easy to obtain
[Equation]
d
[Equation]
Recall the deﬁnition of λ f , if x v i and x v j are independent, we have
[Equation]
Therefore, we obtain
[Equation]
[Table]
[Equation]
If λ f =
[Table]
we have that all nodes have the same feature vector x v .
Obviously
[Table]
D KL ( ˆ S
|| ˆ C )
= 0 .
D D ATASETS
[Table]
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 .
E P ARAMETERS
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 ﬁnal 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.
Speciﬁcally, for Citeseer and Cora, the dropout was set as 0 . 2 , and the weight decay was set as 0 .
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.
[Table]
F T HE P ERFORMANCE OF G RAPH SAGE WITH D IFFERENT A GGREGATORS
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 veriﬁed 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.
G T HE K ULLBACK –L EIBLER D IVERGENCE VS . M UTUAL I NFORMATION
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, D KL ( 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 classiﬁcation 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 ) =
D KL ( 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 classiﬁcation.