Year: 2019

Abstract:
Label Propagation (LPA) and Graph Convolutional Neural Networks (GCN) are both message passing algorithms on graphs. Both solve the task of node classification but LPA propagates node label information across the edges of the graph, while GCN propagates and transforms node feature information. However, while conceptually similar, theoretical relation between LPA and GCN has not yet been investigated. Here we study the relationship between LPA and GCN in terms of two aspects: (1) feature/label smoothing where we analyze how the feature/label of one node is spread over its neighbors; And, (2) feature/label influence of how much the initial feature/label of one node influences the final feature/label of another node. Based on our theoretical analysis, we propose an end-to-end model that unifies GCN and LPA for node classification. In our unified model, edge weights are learnable, and the LPA serves as regularization to assist the GCN in learning proper edge weights that lead to improved classification performance. Our model can also be seen as learning attention weights based on node labels, which is more task-oriented than existing feature-based attention models. In a number of experiments on real-world graphs, our model shows superiority over state-of-the-art GCN-based methods in terms of node classification accuracy.

text: Label Propagation (LPA) and Graph Convolutional Neural Networks (GCN) are both message passing algorithms on graphs. Both solve the task of node classification but LPA propagates node label information across the edges of the graph, while GCN propagates and transforms node feature information. However, while conceptually similar, theoretical relation between LPA and GCN has not yet been investigated. Here we study the relationship between LPA and GCN in terms of two aspects: (1) feature/label smoothing where we analyze how the feature/label of one node is spread over its neighbors; And, (2) feature/label influence of how much the initial feature/label of one node influences the final feature/label of another node. Based on our theoretical analysis, we propose an end-to-end model that unifies GCN and LPA for node classification. In our unified model, edge weights are learnable, and the LPA serves as regularization to assist the GCN in learning proper edge weights that lead to improved classification performance. Our model can also be seen as learning attention weights based on node labels, which is more task-oriented than existing feature-based attention models. In a number of experiments on real-world graphs, our model shows superiority over state-of-the-art GCN-based methods in terms of node classification accuracy.

heading: 1 INTRODUCTION
text: Consider the problem of node classification in a graph, where the goal is to learn a mappingM : V → L from nodes V to labels L. Solution to this problem is widely applicable to various scenarios, e.g., inferring income of users in a social network or classifying scientific articles in a citation network. Different from a generic machine learning problem where samples are independent from each other, nodes are connected by edges in the graph, which provide additional information and require more delicate modeling. To capture the graph information, researchers have mainly designed models on the assumption that labels and features vary smoothly over the edges of the graph. In particular, on the label side L, node labels are propagated and aggregated along edges in the graph, which is known as Label Propagation Algorithm (LPA) (Zhu et al., 2005; Zhou et al., 2004; Zhang & Lee, 2007; Wang & Zhang, 2008; Karasuyama & Mamitsuka, 2013; Gong et al., 2017; Liu et al., 2019a); On the node side V , node features are propagated along edges and transformed through neural network layers, which is known as Graph Convolutional Neural Networks (GCN) (Kipf & Welling, 2017; Hamilton et al., 2017; Li et al., 2018; Xu et al., 2018; Liao et al., 2019; Xu et al., 2019; Qu et al., 2019).
GCN and LPA are related in that they propagate features and labels on the two sides of the mapping M, respectively. However, the relationship between GCN and LPA has not yet been investigated. Specifically, what is the theoretical relationship between GCN and LPA, and how can they be combined to develop a more accurate model for node classification in graphs?
Here we study the theoretical relationship between GCN and LPA from two viewpoints: (1) Feature/label smoothing, where we show that the intuition behind GCN/LPA is smoothing features/labels of nodes across the edges of the graph, i.e., one node’s feature/label equals the weighted average of features/labels of its neighbors. We prove that if edge weights smooth the node features, they also smooth the node labels with guaranteed upper bound on the approximation error. And, (2) feature/label influence, where we quantify how much the initial feature/label of node vb influences
the output feature/label of node va in GCN/LPA by studying the Jacobian/gradient of node vb with respect to node va, and then we also prove their quantitative relationship.
Based on the above theoretical analysis, we propose a unified model GCN-LPA for node classification. We show that the key to improving the performance of GCN is to enable nodes within the same class/label to connect more strongly with each other by making edge weights/strengths trainable. Then we prove that increasing the strength of edges between the nodes of the same class is equivalent to increasing the accuracy of LPA’s predictions. Therefore, we can first learn the optimal edge weights by minimizing the loss of predictions in LPA, then plug the optimal edge weights into a GCN to learn node representations and do final classification. In GCN-LPA, we further combine the two steps together and train the whole model in an end-to-end fashion, where the LPA part serves as regularization to assist the GCN part in learning proper edge weights that benefit the separation of different classes. It is worth noticing that GCN-LPA can also be seen as learning attention weights for edges based on node label information, which requires less handcrafting and is more task-oriented than existing work that learns attention weights based on node feature similarity (Veličković et al., 2018; Thekumparampil et al., 2018; Zhang et al., 2018; Liu et al., 2019b). Experiments on five datasets indicate that our model outperforms state-of-the-art methods in terms of classification accuracy.

heading: 2 UNIFYING GCN AND LPA
text: In this section, we first formulate the node classification problem and briefly introduce LPA and GCN. We then prove their relationship from the viewpoints of smoothing and influence. Based on our theoretical analysis, we then propose a unified model GCN-LPA, and we also analyze the reason why our model performs better than GCN in node classification.

heading: 2.1 PROBLEM FORMULATION AND PRELIMINARIES
text: We begin by describing the problem of node classification on graphs and introducing notation. Consider a graph G = (V, A,X, Y ), where V = {v1, · · · , vn} is the set of nodes, A ∈ Rn×n is the adjacency matrix (self-loops are included), X is the feature matrix of nodes and Y is labels of nodes. aij (the ij-th entry of A) is the weight of the edge connecting vi and vj . N (v) denotes the set of immediate neighbors of node v in graph G. Each node vi has a feature vector xi which is the i-th row of X , while only the first m nodes have labels y1, · · · , ym from a label set L = {1, · · · , c}. The goal is to learn a mappingM : V → L and predict labels of unlabeled nodes. Label Propagation Algorithm. LPA assumes that two connected nodes are likely to have the same label, and thus it propagates labels iteratively along the edges. Let Y (k) = [y(k)1 , · · · , y (k) n ]> ∈ Rn×c be the soft label matrix in iteration k > 0, in which the i-th row y(k)>i denotes the predicted label distribution for node vi in iteration k. When k = 0, the initial label matrix Y (0) = [y (0) 1 , · · · , y (0) n ]> consists of one-hot label indicator vectors y(0)i for i = 1, · · · ,m (i.e., labeled nodes) or zero vectors otherwise (i.e., unlabeled nodes). Let D be the diagonal degree matrix for A with entries dii =∑
j aij . Then LPA (Zhu et al., 2005) in iteration k is formulated as the following two steps:
Y (k+1) = D−1A Y (k), (1)
y (k+1) i = y (0) i , ∀ i ≤ m. (2)
In Eq. (1), all nodes propagate their labels to their neighbors according to weights of edges. Then in Eq. (2), labels of all labeled nodes are reset to their initial values, because LPA wants to persist labels of nodes which are labeled so that unlabeled nodes do not overpower the labeled ones as the initial labels would otherwise fade away.
Graph Convolutional Neural Network. GCN is a multi-layer feedforward neural network that propagates and transforms node features across the graph. The layer-wise propagation rule of GCN is X(k+1) = σ(D− 1 2AD− 1 2X(k)W (k)), where W (k) is trainable weight matrix in the k-th layer, σ(·) is an activation function such as ReLU, and X(k) = [x(k)1 , · · · ,x (k) n ]> are the k-th layer node representations with X(0) = X . To align with the above LPA, we use D−1A as the normalized adjacency matrix instead of the symmetric one D− 1 2AD− 1 2 proposed by Kipf & Welling (2017).
Therefore, the feature propagation scheme of GCN in layer k is:
X(k+1) = σ(D−1AX(k)W (k)). (3)
Notice similarity between Eqs. (1) and (3). Next we shall study and uncover the relationship between the two equations.

heading: 2.2 FEATURE SMOOTHING AND LABEL SMOOTHING
text: The intuition behind both LPA and GCN is smoothing (Zhu et al., 2003; Li et al., 2018): In LPA, the final label of a node is the weighted average of labels of its neighbors: y(∞)i = 1 dii ∑ j∈N (i) aijy (∞) j ; in GCN, the final node representation is also the weighted average of representations of its neighbors if we assume σ is identity function and W (·) are identity matrices: x(∞)i = 1 dii ∑ j∈N (i) aijx (∞) j . Next we show the relationship between feature smoothing and label smoothing:
Theorem 1 (Relationship between feature smoothing and label smoothing) Suppose that the latent ground-truth mapping M : x → y from node features to node labels is differentiable and satisfies L-Lipschitz constraint, i.e., |M(x1) − M(x2)| ≤ L‖x1 − x2‖2 for any x1 and x2 (L is a constant). If the edge weights {aij} approximately smooth xi over its immediate neighbors with error i, i.e., xi = 1dii ∑ j∈N (i) aijxj + i, then the edge weights {aij} also
approximately smooth yi over its immediate neighbors with the following approximation error:∣∣yi − 1dii ∑j∈N (i) aijyj∣∣ ≤ L‖ i‖2 + o(maxj∈N (i)(‖xj − xi‖2)), where o(α) denotes a higher order infinitesimal than α.
Proof of Theorem 1 is in Appendix A. Theorem 1 indicates that label smoothing is theoretically guaranteed by feature smoothing. Note that if we treat edge weights {aij} learnable, then feature smoothing (i.e., i → 0) can be directly achieved by keeping node features xi fixed while setting {aij} appropriately, without resorting to feature propagation in a multi-layer GCN. Therefore, a simple approach to exploit this theorem would be to learn {aij} by reconstructing node feature xi from its neighbors, then use the learned {aij} to reconstruct node labels yi (Karasuyama & Mamitsuka, 2013). This is equivalent to first minimizing the difference between X(0) and X(1) by learning D−1A in a one-layer GCN where σ and W (0) are identity, then plug the learned D−1A in LPA and run it for one iteration.
As shown in Theorem 1, the approximation error of labels is dominated by L‖ i‖2. However, this error could be fairly large in practice because: (1) The number of immediate neighbors for a given node may be too small to reconstruct its features perfectly, especially in the case where node features are high-dimensional and sparse. For example, in a citation network where node features are one-hot bag-of-words vectors, the feature of one article can never be precisely reconstructed if none of its neighboring articles contains the specific word that appears in this article. As a result, ‖ i‖2 will be non-neglibible. This explains why it is beneficial to apply LPA and GCN for multiple iterations/layers in order to include information from farther away neighbors. (2) The ground-truth mapping M may not be sufficiently smooth due to the complex structure of latent manifold and possible noise, which fails to satisfy L-Lipschitz constraint. In other words, the constant L will be extremely large.

heading: 2.3 FEATURE INFLUENCE AND LABEL INFLUENCE
text: To address the above concerns and extend our analysis, we next consider GCN and LPA with multiple layers/iterations, and do not impose any constraint on the ground-truth mappingM. Consider two nodes va and vb in a graph. Inspired by Koh & Liang (2017) and Xu et al. (2018), we study the relationship between GCN and LPA in terms of influence, i.e., how the output feature/label of va will change if the initial feature/label of vb is varied slightly. Technically, the feature/label influence is measured by the Jacobian/gradient of the output feature/label of va with respect to the initial feature/label of vb. Denote x (k) a as the k-th layer representation vector of va in GCN, and xb as the initial feature vector of vb. We quantify the feature influence of vb on va as follows:
Definition 1 (Feature influence) The feature influence of node vb on node va after k layers of GCN is the L1-norm of the expected Jacobian matrix ∂x(k)a /∂xb: If (va, vb; k) = ∥∥E[∂x(k)a /∂xb]∥∥1. The normalized feature influence is then defined as Ĩf (va, vb; k) = If (va, vb; k)/ ∑ vi∈V If (va, vi; k).
We also consider the label influence of node vb on node va in LPA (this implies that va is unlabeled and vb is labeled). Since different label dimensions of y (·) i do not interact with each other in LPA, we assume that all yi and y (·) i are scalars within [0, 1] (i.e., a binary classification) for simplicity. Label influence is defined as follows:
Definition 2 (Label influence) The label influence of labeled node vb on unlabeled node va after k iterations of LPA is the gradient of y(k)a with respect to yb: Il(va, vb; k) = ∂y (k) a /∂yb.
The following theorem shows the relationship between feature influence and label influence:
Theorem 2 (Relationship between feature influence and label influence) Assume the activation function used in GCN is ReLU. Denote va as an unlabeled node, vb as a labeled node, and β as the fraction of unlabeled nodes. Then the label influence of vb on va after k iterations of LPA equals, in expectation, to the cumulative normalized feature influence of vb on va after k layers of GCN:
E [ Il(va, vb; k) ] = ∑k
j=1 βj Ĩf (va, vb; j). (4)
Proof of Theorem 2 is in Appendix B. Intuitively, Theorem 2 shows that if vb has high label influence on va, then the initial feature vector of vb will also affect the output feature vector of va to a large extent. Theorem 2 provides the theoretical guideline for designing our unified model in the next subsection.

heading: 2.4 THE UNIFIED MODEL
text: Before introducing the proposed model, we first rethink the GCN method and see what an ideal node representation should be like. Since we aim to classify nodes, the perfect node representation would be such that nodes with the same label are embedded close together, which would give a large separation between different classes. Intuitively, the key to achieve this goal is to enable nodes within the same class to connect more strongly with each other, so that they are pushed together by the GCN. We can therefore make edge strengths/weights trainable, then learn to increase the intra-class feature influence for each class i: ∑ va,vb:ya=i,yb=i
Ĩf (va, vb) by adjusting edge weights. However, this requires operating on Jacobian matrices with the size of d(0) × d(K) (d(0) and d(K) are the dimensions of initial and output features, respectively), which is impractical if initial node features are high-dimensional. Fortunately, we can turn to optimizing the intra-class label influence instead, i.e., ∑ va,vb:ya=i,yb=i
Il(va, vb), according to Theorem 2. We further show that, by the following theorem, the intra-class label influence for a given node va is proportional to the probability that va is classified correctly by LPA:
Theorem 3 (Relationship between label influence and LPA’s prediction) Consider a given node va and its label ya. If we treat node va as unlabeled, then the total label influence of nodes with label ya on node va is proportional to the probability that node va is classified as ya by LPA:∑
vb:yb=ya
Il(va, vb; k) ∝ Pr ( ŷlpaa = ya ) , (5)
where ŷlpaa is the predicted label of va using a k-iteration LPA.
Proof of Theorem 3 is in Appendix C. Theorem 3 indicates that, if edge weights {aij} maximize the probability that va is correctly classified by LPA, then they also maximize the intra-class label influence for node va. We can therefore first learn the optimal edge weights A∗ by minimizing the
loss of predicted labels by LPA:1
A∗ = argmin A Llpa(A) = argmin A
1
m ∑ va:a≤m J(ŷlpaa , ya), (6)
where J is the cross-entropy loss, ŷlpaa and ya are the predicted label distribution of va using LPA and the true one-hot label of va, respectively.2 a ≤ m means va is labeled. The optimal A∗ maximize the probability that each node is correctly labeled by LPA, thus also increasing the intra-class label influence (by Theorem 3) and intra-class feature influence (by Theorem 2). Then we can apply A∗ and the corresponding D∗ to a GCN to predict labels and learn optimal transformation matrices:
X(k+1) = σ(D∗−1A∗X(k)W (k)), k = 0, 1, · · · ,K − 1, (7)
W ∗ = argmin W Lgcn(W,A ∗) = argmin W
1
m ∑ va:a≤m J(ŷgcna , ya), (8)
where ŷgcna (which is the a-th row of X (K)) is the predicted label distribution of va using the GCN specified in Eq. (7).
In practice, it is generally better to combine the above two steps together and train the whole model in an end-to-end fashion:
W ∗, A∗ = argmin W,A Lgcn(W,A) + λLlpa(A), (9)
where λ is the balancing hyper-parameter. In this way, Llpa(A) serves as a regularization term that assists the learning of edge weights A, since it is hard for the GCN to learn both W and A simultaneously due to overfitting. The proposed GCN-LPA approach can also be seen as learning the importance of edges that can be used to reconstruct node labels accurately by LPA, then transferring this knowledge from label space to feature space for the GCN. From this perspective, GCN-LPA also connects to Theorem 1 except that the knowledge transfer is in the other direction.
It is also worth noticing how the optimalA∗ is configured. The principle here is that we do not modify the basic structure of the original graph (i.e., not adding or removing edges) but only adjusting weights of existing edges. This is equivalent to learning a positive mask matrix M for the adjacency matrixA and taking the Hadamard productM◦A = A∗. Each elementMij can be set as either a free variable or a function of the nodes at edge endpoints, for example, Mij = log ( exp(x>i Hxj) + 1
) where H is a learnable kernel matrix for measuring feature similarity.

heading: 2.5 ANALYSIS OF GCN-LPA MODEL BEHAVIOR
text: In this subsection, we show benefits of our unified model compared with GCN by analyzing properties of embeddings produced by the two models. We first analyze the update rule of GCN for node vi: x (k+1) i = σ (∑ vj∈N (vi) ãijx (k) j W (k) ) , where ãij = aij/dii is the normalized weight of edge (j, i). This formula can be decomposed into the following two steps: (1) In aggregation step, we calculate the aggregated representation h(k)i of all neighborhoods N (vi): h (k) i = ∑ vj∈N (vi) ãijx (k) j ; (2) In transformation step, the aggregated representation h(k)i is mapped to a new space by a transformation matrix and nonlinear function: x(k+1)i = σ ( h (k) i W (k) ) . We show by the following theorem that the aggregation step reduces the overall distance in the embedding space between the nodes that are connected in the graph:
Theorem 4 (Shrinking property in GCN) LetD(x) = 12 ∑ vi,vj ãij‖xi−xj‖22 be a distance metric between the embeddings x of nodes. Then we have D(h(k)) ≤ D(x(k)).
1Here the optimal edge weights A∗ share the same topology as the original graph G, meaning that we do not add or remove edges from G but only learning the weights of existing edges. See the end of this subsection for more discussion.
2Here we somewhat abuse the notations for simplicity, since in Theorem 3 the two notations represent label category rather than label distribution. But the subtle difference can be easily distinguished based on context.
(a) Karate club network with noisy edges (b) GCN on the original network (c) GCN-LPA on the original network (d) GCN on the noisy network (e) GCN-LPA on the noisy network
Figure 1: Node embeddings of Zachary’s karate club network trained on a node classification task (red vs. blue). Node coordinates in (b)-(e) are the embedding coordinates. Notice that GCN does not produce linearly separable embeddings ((b) vs. (c)), while GCN-LPA performs much better even in the presence of noisy edges ((d) vs. (e)). Additional visualizations are included in Appendix E.
Proof of Theorem 4 is in Appendix D. Theorem 4 indicates that the overall distance among connected nodes is reduced after taking one aggregation step, which implies that connected components in the graph “shrink” and nodes within each connected component get closer to each other in the embedding space. In an ideal case where edges only connect nodes with the same label, the aggregation step will push nodes within the same class together, which greatly benefits the transformation step that acts like a hyperplane W (k) for classification. However, two connected nodes may have different labels. These “noisy” edges will impede the formation of clusters and make the inter-class boundary less clear.
Fortunately, in GCN-LPA, edge weights are learned by minimizing the difference between groundtruth labels and labels reconstructed from multi-hop neighbors. This will force the model to increase weight/bandwidth of possible paths that connect nodes with the same label, so that labels can “flow” easily along these paths for the purpose of label reconstruction. In this way, GCN-LPA is able to identify potential intra-class edges and increase their weights to assist learning clustering structures.
To illustrate this, we apply a two-layer untrained GCN with randomly initialized transformation matrices to the well-known Zachary’s karate club network (Zachary, 1977) as shown in Figure 1a, which contains 34 nodes of 2 classes and 78 unweighted edges (grey solid lines). We then increase the weights of intra-class edges by ten times to simulate GCN-LPA. We find that GCN works well on this network (Figure 1b), but GCN-LPA performs even better than GCN because the node embeddings are completely linearly separable as shown in Figure 1c. To further justify our claim, we randomly add 20 “noisy” inter-class edges (grey dotted lines) to the original network, from which we observe that GCN is misled by noise and mixes nodes of two classes together (Figure 1d), but GCNLPA still distinguishes the two clusters (Figure 1e) because it is better at “denoising” undesirable edges based on the supervised signal of labels.

heading: 3 CONNECTION TO EXISTING WORK
text: Edge weights play a key role in graph-based node classification as well as representation learning. In this section, we discuss three lines of related work that learn edge weights adaptively.
Locally linear embedding (LLE) (Roweis & Saul, 2000) and its variants (Zhang & Wang, 2007; Kong et al., 2012) learn edge weights by constructing a linear dependency between a node and its neighbors, then use the learned edge weights to embed high-dimensional nodes into a lowdimensional space. Our work is similar to LLE in the aspect of transferring the knowledge of edge importance from one space to another, but the difference is that LLE is an unsupervised dimension reduction method that learns the graph structure based on local proximity only, while our work is semi-supervised and explores high-order relationship among nodes.
Classical LPA (Zhu et al., 2005; Zhou et al., 2004) can only make use of node labels rather than node features. In contrast, adaptive LPA considers node features by making edge weights learnable. Typical techniques of learning edge weights include adopting kernel functions (Zhu et al., 2003; Liu et al., 2019a) (e.g., aij = exp(− ∑ d(xid − xjd)2/σ2d) where d is dimensionality of features), minimizing neighborhood reconstruction error (Wang & Zhang, 2008; Karasuyama & Mamitsuka, 2013), using leave-one-out loss (Zhang & Lee, 2007), or imposing sparseness on edge weights
(Hong et al., 2009). However, in these LPA variants, node features are only used to assist learning the graph structure rather than explicitly mapped to node labels, which limits their capability in node classification. Another notable difference is that adaptive LPA learns edge weights by introducing the regularizations above, while our work takes LPA itself as regularization to learn edge weights.
Our method is also conceptually connected to attention mechanisms on graphs (Veličković et al., 2018; Thekumparampil et al., 2018; Zhang et al., 2018; Liu et al., 2019b), in which an attention weight αij is learned between node vi and vj . For example, αij = LeakyReLU(a>[Wxi||Wxj ]) in GAT (Veličković et al., 2018), αij = a · cos(Wxi,Wxj) in AGNN (Thekumparampil et al., 2018), αij = (W1xi)>W2xj in GaAN (Zhang et al., 2018), and αij = a> tanh(W1xi +W2xj) in GeniePath (Liu et al., 2019b), where a and W are trainable variables. A significant difference between these attention mechanisms and our work is that attention weights are learned based merely on feature similarity, while we propose that edge weights should be consistent with the distribution of labels on the graph, which requires less handcrafting of the attention function and is more taskoriented. Nevertheless, all the above formulas for calculating attentions can also be used in our model as the implementation of edge weights.

heading: 4 EXPERIMENTS
text: We evaluate our model and present its performance on five datasets including citation networks and coauthor networks. We also study the hyper-parameter sensitivity and provide training time analysis.

heading: 4.1 DATASETS
text: We use the following five datasets in our experiments:
Citation networks: We consider three citation network datasets (Sen et al., 2008): Cora, Citeseer, and Pubmed. In these datasets, nodes correspond to documents, edges correspond to citation links, and each node has a sparse bag-of-words feature vector as well as a class label. Coauthor networks: We also use two co-authorship networks (Shchur et al., 2018), Coauthor-CS and Coauthor-Phy, based on Microsoft Academic Graph from the KDD Cup 2016 challenge. Here nodes are authors and an edge indicates that two authors co-authored a paper. Node features represent paper keywords for each author’s papers, and class labels indicate most active fields of study for each author.
Statistics of the five datasets are shown in Table 1. We also calculate the intra-class edge rate (the fraction of edges that connect two nodes within the same class), which is significantly higher than inter-class edge rate in all networks. The finding supports our claim in Section 2.5 that node classification benefits from intra-class edges in a graph.

heading: 4.2 BASELINES
text: We compare against the following baselines in our experiments: Multi-layer Perceptron (MLP) and Logistic Regression (LR) are feature-based methods that do not consider the graph structure. Label Propagation (LPA) (Zhu et al., 2005), on the other hand, only consider the graph structure and ignore node features. The rest of baselines are GCN-based methods: Graph Convolutional Network (GCN) (Kipf & Welling, 2017) proposes a first-order approximation to spectral graph convolutions. Graph Attention Network (GAT) (Veličković et al., 2018) propose an attention mechanism to treat neighbors differently in the aggregation step. Jumping Knowledge Networks (JK-Net) (Xu et al., 2018) leverages different neighborhood ranges for each node to en-
able structure-aware representation. We use concat as the aggregator for JK-Net. Graph Sampling and Aggregation (GraphSAGE) (Hamilton et al., 2017) is a mini-batch implementation of GCN that uses neighborhood sampling strategy and different aggregation schemes. We use mean as the aggregator for GraphSAGE.

heading: 4.3 EXPERIMENTAL SETUP
text: Our experiments focus on the transductive setting where we only know labels of part of nodes but have access to the entire graph as well as features of all nodes.3 The ratio of training, validation, and test set are set as 6 : 2 : 2. The weight of each edge is treated as a free variable during training. We train our model for 200 epochs using Adam (Kingma & Ba, 2015) and report the test set accuracy when validation set accuracy is maximized. Each experiment is repeated three times and we report the mean and the 95% confidence interval. We initialize weights according to Glorot & Bengio (2010) and row-normalize input features. During training, we apply L2 regularization to the transformation matrices and use the dropout technique (Srivastava et al., 2014). The settings of all other hyper-parameters can be found in Appendix F.

heading: 4.4 RESULTS
text: The results of node classification are summarized in Table 2. Table 2 indicates that only using node features (MLP, LR) or graph structure (LPA) will lead to information loss and cannot fully exploit datasets in general. The results demonstrate that our proposed GCN-LPA model surpasses stateof-the-art GCN/GNN baselines. We note that JK-Net is a strong baseline on Cora, but it does not perform consistently well on other datasets.
We investigate the influence of the number of LPA iterations and the training weight of LPA loss term λ on the performance of classification. The results on Citeseer dataset are plotted in Figures 2 and 3, respectively, where each line corresponds to a given number of GCN layers in GCN-LPA. From Figure 2 we observe that the performance is boosted at first when the number of LPA iterations increases, then the accuracy stops increasing and decreases since a large number of LPA iterations will include more noisy nodes. Figure 3 shows that training without the LPA loss term (i.e., λ = 0) is more difficult than the case where λ = 1 ∼ 5, which justifies our aforementioned claim that it is
3The experimental setting here is the same as GCN (Kipf & Welling, 2017). But note that our method can be easily generalized to inductive case if implemented in a way similar to GraphSAGE (Hamilton et al., 2017).
hard for the GCN part to learn both transformation matrices W and edge weights A simultaneously without the assistance of LPA regularization.
To further show how much the LPA impacts the performance, we vary the ratio of labeled nodes in LPA from 100% to 0% during training, and report the result of acuracy on Citeseer dataset in Table 3. From Table 3 we observe that the performance of GCN-LPA gets worse when the ratio of labeled nodes in LPA decreases. In addition, using more labeled nodes in LPA also helps improve the model stability. Note that a ratio of 0% does not mean that GCN-LPA is equivalent to GCN (Kipf & Welling, 2017) because the edge weights in GCN-LPA is still trainable, which increases the risk of overfitting the training data.
We study the training time of GCN-LPA on random graphs. We use the one-hot identity vector as feature and 0 as label for each node. The size of training set and validation set is 100 and 200, respectively, while the rest is test set. The average number of neighbors for each node is set as 5, and the number of nodes is varied from one thousand to one million. We run GCN-LPA and GCN for 100 epochs on a Microsoft Azure virtual machine with 1 NVIDIA Tesla M60 GPU, 12 Intel Xeon CPUs (E5-2690 v3 @2.60GHz), and 128GB of RAM, using the same hyper-parameter setting as in Cora. The training time per epoch of GCN-LPA and GCN is presented in Figure 4. Our result shows that GCN-LPA requires only 9.2% extra training time on average compared to GCN.

heading: 5 CONCLUSION AND FUTURE WORK
text: In this paper, we studied the theoretical relationship between two types of well-known graph-based models for node classification, label propagation algorithm and graph convolutional neural networks, from the perspectives of feature/label smoothing and feature/label influence. We then propose a unified model GCN-LPA, which learns transformation matrices and edge weights simultaneously in GCN with the assistance of LPA regularizer. We also analyze why our unified model performs better than traditional GCN in node classification. Experiments on five datasets demonstrate that our model outperforms state-of-the-art baselines, and it is also highly time-efficient with respect to the size of a graph.
We point out two avenues of possible directions for future work. First, our proposed model focuses on transductive setting where all node features and the entire graph structure are given. An interesting problem is whether it can be applied to inductive setting where we have no access to test nodes during training. Second, the question of how to generalize the idea of our model to GNNs with different aggregation functions (e.g., concatenation or max-pooling) is also a promising direction.

heading: A PROOF OF THEOREM 1
text: Proof. Denote ãij = aij/dii as the normalized weight of edge (j, i). It is clear that ∑ j∈N (i) ãij = 1. Given thatM is differentiable, we perform a first-order Taylor expansion with Peano’s form of remainder at xi for
∑ j∈N (i) ãijyj :∑
j∈N (i)
ãijyj = ∑
j∈N (i)
ãijM(xj)
= ∑
j∈N (i)
ãij ( M(xi) +
∂M(xi) ∂x>
(xj − xi) + o(‖xj − xi‖2) )
=M(xi) + ∂M(xi) ∂x> ∑ j∈N (i) ãij(xj − xi) + ∑ j∈N (i) ãijo(‖xj − xi‖2)
= yi − ∂M(xi) ∂x>
i + ∑
j∈N (i)
ãijo(‖xj − xi‖2).
(10)
According to Cauchy-Schwarz inequality and L-Lipschitz property, we have∣∣∣∣∂M(xi)∂x> i ∣∣∣∣ ≤ ∥∥∥∥∂M(xi)∂x> ∥∥∥∥ 2 ‖ i‖2 ≤ L‖ i‖2. (11) Therefore, the approximation of yi is bounded by∣∣∣∣yi − ∑ j∈N (i) ãijyj
∣∣∣∣ =
∣∣∣∣∂M(xi)∂x> i − ∑ j∈N (i) ãijo(‖xj − xi‖2) ∣∣∣∣
≤ ∣∣∣∣∂M(xi)∂x> i ∣∣∣∣+ ∣∣∣∣ ∑ j∈N (i) ãijo(‖xj − xi‖2) ∣∣∣∣
≤ L‖ i‖2 + o ( max
j∈N (i) (‖xj − xi‖2)
) .
(12)

heading: B PROOF OF THEOREM 2
text: Before proving Theorem 2, we first give two lemmas that demonstrate the exact form of feature influence and label influence defined in this paper. The relationship between feature influence and label influence can then be deduced from their exact forms.
Lemma 1 Assume that the nonlinear activation function in GCN is ReLU. Let Pa→bk be a path [v(k), v(k−1), · · · , v(0)] of length k from node va to node vb, where v(k) = va, v(0) = vb, and v(i−1) ∈ N (v(i)) for i = k, · · · , 1. Then we have
Ĩf (va, vb; k) = ∑ Pa→bk 1∏ i=k ãv(i−1),v(i) , (13)
where ãv(i−1),v(i) is the normalized weight of edge (v(i), v(i−1)).
Proof. See Xu et al. (2018) for the detailed proof.
The product term in Eq. (13) is the probability of a given path Pa→bk . Therefore, the right hand side in Eq. (13) is the sum over probabilities of all possible paths of length k from va to vb, which is the probability that a random walk starting at va ends at vb after taking k steps.
Lemma 2 Let Ua→bj be a path [v(j), v(j−1), · · · , v(0)] of length j from node va to node vb, where v(j) = va, v(0) = vb, v(i−1) ∈ N (v(i)) for i = j, · · · , 1, and all nodes along the path are unlabeled except v(0). Then we have
Il(va, vb; k) = k∑ j=1 ∑ Ua→bj 1∏ i=j ãv(i−1),v(i) , (14)
where ãv(i−1),v(i) is the normalized weight of edge (v(i), v(i−1)).
To intuitively understand this lemma, note that there are two differences between Lemma 1 and Lemma 2: (1) In Lemma 1, Ĩf (va, vb; k) sums over all paths from va to vb of length k, but in Lemma 2, Il(va, vb; k) sums over all paths from va to vb of length no more than k. The is because in LPA, vb’s label is reset to its initial value after each iteration, which means that the label of vb serves as a constant signal that begins propagating in the graph again and again after each iteration. (2) In Lemma 1 we consider all possible paths from va to vb, but in Lemma 2, the paths are restricted to contain unlabeled nodes only. The reason here is the same as above: Since the labels of labeled nodes are reset to their initial values after each iteration in LPA, the influence of vb’s label will be absorbed in labeled nodes, and the propagation of vb’s label will be cut off at these nodes. Therefore, vb’s label can only flow to va along the paths with unlabeled nodes only. See Figure 5 for an illustrating example showing the label propagation in LPA.
Proof. As mentioned above, a significant difference between LPA and GCN is that all labeled nodes are reset to its original labels after each iteration in LPA. This implies that the initial label yb of node vb appears not only as y (0) b , but also as every y (j) b for j = 1, · · · , k − 1. Therefore, the influence of yb on y (k) a is the cumulative influence of y (j) b on y (k) a for j = 0, 1, · · · , k − 1:
Il(va, vb; k) = ∂y
(k) a
∂yb = k−1∑ j=0 ∂y (k) a ∂y (j) b . (15)
According to the updating rule of LPA, we have
∂y (k) a
∂y (j) b
= ∂ ∑ vz∈N (va) ãazy (k−1) z
∂y (j) b
= ∑
vz∈N (va)
ãaz ∂y
(k−1) z
∂y (j) b
. (16)
In the above equation, the derivative ∂y (k) a
∂y (j) b
is decomposed into the weighted average of ∂y (k−1) z
∂y (j) b
,
where vz traverses all neighbors of va. For those vz’s that are initially labeled, y (k−1) z is reset to
their initial labels in each iteration. Therefore, they are always constant and independent of y(j)b , meaning that their derivatives w.r.t. y(j)b are zero. So we only need to consider the terms where vz is an unlabeled node:
∂y (k) a
∂y (j) b
= ∑
vz∈N (va),z>m
ãaz ∂y
(k−1) z
∂y (j) b
, (17)
where z > m means vz is unlabeled. To intuitively understand Eq. (17), one can imagine that we perform a random walk starting from node va for one step, where the “transition probability” is the edge weights ã, and all nodes in this random walk are restricted to unlabeled nodes only. Note that we can further decompose every y(k−1)z in Eq. (17) in the way similar to what we do for y (k) a in Eq. (16). So the expansion in Eq. (17) can be performed iteratively until the index k decreases to j. This is equivalent to performing all possible random walks for k − j steps starting from va, where all nodes but the last in the random walk are restricted to be unlabeled nodes:
∂y (k) a
∂y (j) b = ∑ vz∈V ∑ Ua→zk−j  1∏ i=k−j ãv(i−1),v(i)  ∂y(j)z ∂y (j) b , (18)
where vz in the first summation term is the end node of a random walk, Ua→zk−j in the second summation term is an unlabeled-nodes-only path from va to vz of length k − j, and the product term is the probability of a given path Ua→zk−j . Consider the last term ∂y(j)z ∂y
(j) b
in Eq. (18). We know that ∂y (j) z
∂y (j) b
= 0
for all z 6= b and ∂y (j) z
∂y (j) b
= 1 for z = b, which means that only those random-walk paths that end
exactly at vb (i.e., the end node vz is exactly vb) count for the computation in Eq. (18). Therefore, we have
∂y (k) a
∂y (j) b = ∑ Ua→bk−j 1∏ i=k−j ãv(i−1),v(i) , (19)
where Ua→bk−j is a path from va to vb of length k − j containing only unlabeled nodes except vb. Substituting the right hand term of Eq. (15) with Eq. (19), we obtain that
Il(va, vb; k) = k−1∑ j=0 ∑ Ua→bk−j 1∏ i=k−j ãv(i−1),v(i) = k∑ j=1 ∑ Ua→bj 1∏ i=j ãv(i−1),v(i) . (20)
Now Theorem 2 can be proved by combining Lemma 1 and Lemma 2:
Proof. Suppose that whether a node is labeled or not is independent of each other for the given graph. Then we have
E [ Il(va, vb; k) ] =E  k∑ j=1 ∑ Ua→bj 1∏ i=j ãv(i−1),v(i)  = k∑ j=1 E ∑ Ua→bj 1∏ i=j ãv(i−1),v(i)  =
k∑ j=1 ∑ Pa→bj Pr ( Pa→bj is an unlabeled-nodes-only path ) 1∏ i=j ãv(i−1),v(i)
= k∑ j=1 ∑ Pa→bj βj 1∏ i=j ãv(i−1),v(i)
= k∑ j=1 βj Ĩf (va, vb; j).
(21)

heading: C PROOF OF THEOREM 3
text: Proof. Denote the set of labels as L. Since different label dimensions in y(·)a do not interact with each other when running LPA, the value of the ya-th dimension in y (·) a (denoted by y (·) a [ya]) comes only from the nodes with initial label ya. It is clear that
y(k)a [ya] = ∑
vb:yb=ya k∑ j=1 ∑ Ua→bj 1∏ i=j ãv(i−1),v(i) , (22)
which equals ∑
vb:yb=ya Il(va, vb; k) according to Lemma 2. Therefore, we have
Pr(ŷa = ya) = y (k) a [ya]∑
i∈L y (k) a [i]
∝ y(k)a [ya] = ∑
vb:yb=ya
Il(va, vb; k) (23)

heading: D PROOF OF THEOREM 4
text: In this proof we assume that the dimension of node representations is one, but note that the conclusion can be easily generalized to the case of multi-dimensional representations since the function D(x) can be decomposed into the sum of one-dimensional cases. In the following of this proof, we still use bold notations x(k)i and h (k) i to denote node representations, but keep in mind that they are scalars rather than vectors.
We give two lemmas before proving Theorem 4. The first one is about the gradient of D(x):
Lemma 3 h(k)i = x (k) i −
∂D(x(k))
∂x (k) i
.
Proof. x(k)i − ∂D(x(k))
∂x (k) i
= x (k) i − ∑ vj∈N (vi) ãij(x (k) i − x (k) j ) = ∑ vj∈N (vi) ãijx (k) j = h (k) i .
It is interesting to see from Lemma 3 that the aggregation step in GCN is equivalent to running gradient descent for one step with a step size of one. However, this is not able to guarantee that D(h(k)) ≤ D(x(k)) because the step size may be too large to reduce the value of D. The second lemma is about the Hessian of D(x):
Lemma 4 ∇2D(x) 2I , or equivalently, 2I −∇2D(x) is a positive semidefinite matrix. Proof. We first calculate the Hessian of D(x) = 12 ∑ vi,vj ãij‖xi − xj‖22:
∇2D(x) =  1− ã11 −ã12 · · · −ã1n −ã21 1− ã22 · · · −ã2n
... ...
. . . ...
−ãn1 −ãn2 · · · 1− ãnn  = I −D−1A. (24) Therefore, 2I − ∇2D(x) = I + D−1A. Since D−1A is Markov matrix (i.e., each entry is nonnegative and the sum of each row is one), its eigenvalues are within the range [-1, 1], so the eigenvalues of I + D−1A are within the range [0, 2]. Therefore, I + D−1A is a positive semidefinite matrix, and we have ∇2D(x) 2I . We can now prove Theorem 4:
Proof. Since D is a quadratic function, we perform a second-order Taylor expansion of D around x(k) and obtain the following inequality:
D(h(k)) =D(x(k)) +∇D(x(k))>(h(k) − x(k)) + 1 2 (h(k) − x(k))>∇2D(x)(h(k) − x(k))
=D(x(k))−∇D(x(k))>∇D(x(k)) + 1 2 ∇D(x(k))>∇2D(x)∇D(x(k)) ≤D(x(k))−∇D(x(k))>∇D(x(k)) +∇D(x(k))>∇D(x(k)) = D(x(k)).
(25)

heading: E MORE VISUALIZATION RESULTS ON KARATE CLUB NETWORK
text: Figure 6 illustrates more visualization of GCN and GCN-LPA on karate club network. In each subfigure, we vary the number of layers from 1 to 4 to examine how the learned representations evolve. The initial node features are one-hot identity vectors, and the dimension of hidden layers and output layer is 2. The transformation matrices are uniformly initialized within range [-1, 1]. We use sigmoid function as the nonlinear activation function. Comparing the four figures in each row, we conclude that the aggregation step and transformation step in GCN and GCN-LPA do benefit the separation of different classes. Comparing Figure 6a and 6c (or Figure 6b and 6d), we conclude that more inter-class edges will make the separation harder for GCN (or GCN-LPA). Comparing Figure 6a and 6b (or Figure 6c and 6d), we conclude that GCN-LPA is more noise-resistant than GCN, therefore, GCN-LPA can better differentiate classes and identify clustering substructures.

heading: F HYPER-PARAMETER SETTINGS
text: The detailed hyper-parameter settings for all datasets are listed in Table 4. In GCN-LPA, we use the same dimension for all hidden layers. Note that the number of GCN layers and the number of LPA iterations can actually be different since GCN and LPA are implemented as two independent modules. We use grid search to determine hyper-parameters on Cora, and perform fine-tuning on
other datasets, i.e., varying one hyper-parameter per time to see if the performance can be further improved. The search spaces for hyper-parameters are as follows:
• Dimension of hidden layers: {8, 16, 32}; • # GCN layers: {1, 2, 3, 4, 5, 6}; • # LPA iterations: {1, 2, 3, 4, 5, 6, 7, 8, 9}; • L2 weight: {10−7, 2 × 10−7, 5 × 10−7, 10−6, 2 × 10−6, 5 × 10−6, 10−5, 2 × 10−5, 5 ×
10−5, 10−4, 2× 10−4, 5× 10−4, 10−3}; • LPA weight (λ): {0, 1, 2, 5, 10, 15, 20}; • Dropout rate: {0, 0.1, 0.2, 0.3, 0.4, 0.5}; • Learning rate: {0.01, 0.02, 0.05, 0.1, 0.2, 0.5};

Review summaries:
The paper proposed an unified model for Label Propagation (LPA) and Graph Convolutional Neural Networks (GCN). It is shown how it is possible to infer the relationship between LPA and GCN in terms of label or feature smoothing (how label/feature does propagate over the neighbors) and label or feature influence over the other nodes. The results are given in terms of two theorems (whose proofs are in an appendix) which essentially state that the total label influence of nodes with a particular label “l” on a specific node is proportional to the probability that node is labelled as “l” by LPA. In practice, LPA acts as a regularizer to learn transformation matrices and edge weights simultaneously in GCN. By means of a simple joint loss (eq.8), the regularized training show that transductive learning with the joint model surpasses GCN/GNN baselines. 

This paper introduces a unified model which combines label propagation algorithm (LPA) and graph convolutional networks (GCNs) for node classification. The motivation of this combination is supported by two analysis on the feature/label smoothing and feature/label influence. The proposed GCN-LPA framework utilizeds LPA to adjust the edge weight A* through the label information. Then, this edge weight A* is used to transfer the knowledge from label information to feature information for enhancing the representation learning in GCN. An end-to-end  solution is proposed by treating the LPA process as regularization. Overall, the idea of unifying GCNs and LAP in an end-to-end fashion is interesting.