C OMBINING N EURAL N ETWORKS WITH P ERSONALIZED P AGE R ANK FOR C LASSIFICATION ON G RAPHS
Anonymous authors
Paper under double-blind review
A BSTRACT
Neural message passing algorithms for semi-supervised classiﬁcation on graphs have recently achieved great success.
However, these methods only consider nodes that are a few propagation steps away and the size of this utilized neighborhood cannot be easily extended.
In this paper, we use the relationship between graph convolutional networks (GCN) and PageRank to derive an improved propagation scheme based on personalized PageRank.
We utilize this propagation procedure to construct personalized propagation of neural predictions (PPNP) and its approximation, APPNP.
Our model’s training time is on par or faster and its number of parameters on par or lower than previous models.
It leverages a large, adjustable neighborhood for classiﬁcation and can be combined with any neural network.
We show that this model outperforms several recently proposed methods for semi-supervised classiﬁcation on multiple graphs in the most thorough study done so far for GCN-like models.
I NTRODUCTION
Graphs are ubiquitous in the real world and its description through scientiﬁc models.
They are used to study the spread of information, to optimize delivery, to recommend new books, to suggest friends, or to ﬁnd a party’s potential voters.
Deep learning approaches have achieved great success on many important graph problems such as link prediction (Grover & Leskovec, 2016; Bojchevski et al., 2018), graph classiﬁcation (Duvenaud et al., 2015; Niepert et al., 2016; Gilmer et al., 2017) and semi-supervised node classiﬁcation (Yang et al., 2016; Kipf & Welling, 2017).
There are many approaches for leveraging deep learning algorithms on graphs.
Node embedding methods use random walks or matrix factorization to directly train individual node embeddings, often without using node features and usually in an unsupervised manner, i.e. without leveraging node classes (Perozzi et al., 2014; Tang et al., 2015; Nandanwar & Murty, 2016; Grover & Leskovec, 2016;
Qiu et al., 2018; Faerman et al., 2018).
Many other approaches use both graph structure and node features in a supervised setting.
Examples for these include spectral graph convolutional neural networks (Bruna et al., 2014; Defferrard et al., 2016), message passing (or neighbor aggregation) algorithms (Kearnes et al., 2016; Kipf & Welling, 2017; Hamilton et al., 2017; Pham et al., 2017;
Monti et al., 2017; Gilmer et al., 2017), and neighbor aggregation via recurrent neural networks (Scarselli et al., 2009; Li et al., 2016; Dai et al., 2018).
Among these categories, the class of message passing algorithms has garnered particular attention recently.
Several works have been aimed at improving the basic neighborhood aggregation scheme by using attention mechanisms (Kearnes et al., 2016; Hamilton et al., 2017; Veliˇckovi´c et al., 2018), random walks (Abu-El-Haija et al., 2018a;
Ying et al., 2018; Li et al., 2018), edge features (Kearnes et al., 2016; Gilmer et al., 2017; Schlichtkrull et al., 2018) and making it more scalable on large graphs (Chen et al., 2018;
Ying et al., 2018).
However, all of these methods only use the information of a very limited neighborhood for each node.
Increasing the size of the neighborhood used by the algorithm, i.e. its range, however, is not trivial since neighborhood aggregation in this scheme is essentially a type of Laplacian smoothing and too many layers lead to oversmoothing (Li et al., 2018).
Xu et al.
(2018) highlighted the same problem by establishing a relationship between the message passing algorithm termed Graph Convolutional
Network (GCN) by Kipf & Welling (2017) and a random walk.
Using this relationship we can see that GCN converges to this random walk’s limit distribution as the number of layers increases.
This limit distribution is a property of the graph as a whole and does not take the random walk’s starting (root) node into account.
As such it is unsuited to describe the root node’s neighborhood.
Hence, the quality of this aggregation procedure necessarily deteriorates for a high number of layers (or aggregation/propagation steps) since we approach the limit distribution.
To solve this issue, in this paper, we ﬁrst highlight the inherent connection between the limit distribution and PageRank (Page et al., 1998).
We then propose an algorithm that utilizes a propagation scheme derived from personalized PageRank instead.
This algorithm adds a chance of teleporting back to the root node, which ensures that the score encodes the local neighborhood for every root node (Page et al., 1998).
The teleport probability allows us to balance the needs of preserving locality (i.e. staying close to the root node to avoid oversmoothing) and leveraging the information from a large neighborhood.
We show that this propagation scheme permits the use of far more (in fact, inﬁnitely many) propagation steps without leading to oversmoothing.
Moreover, while propagation and classiﬁcation are inherently intertwined in message passing schemes, our proposed algorithm separates the neural network from the propagation scheme.
This allows us to achieve a much higher range without changing the neural network, whereas in the message passing scheme every additional propagation step would require an additional layer.
It also permits the independent development of the propagation algorithm and the neural network generating predictions from node features.
That is, we can combine any state-of-the-art prediction method with our propagation scheme.
We even found that adding our propagation scheme signiﬁcantly improves the accuracy of networks that have been trained without using any graph information.
Our model achieves state-of-the-art results while requiring fewer parameters and less training time compared to most competing models, with a computational complexity that is linear in the number of edges.
We show these results in the most thorough study (including signiﬁcance testing) of message passing models using graphs with text-based features that has been done so far.
G RAPH CONVOLUTIONAL NETWORKS AND THEIR LIMITED RANGE
We ﬁrst introduce our notation and explain the problem our model solves.
Let G =
( V, E ) be a graph with nodes V and edges E .
Let n denote the number of nodes and m the number of edges.
The nodes are described by the feature matrix X ∈ R n × f , with the number of features f per node, and the class (or label) matrix Y ∈ R n × c , with the number of classes c .
The graph G is described by the adjacency matrix A ∈ R n × n .
˜
A =
A + I n denotes the adjacency matrix with added self-loops.
One simple and widely used message passing algorithm for semi-supervised classiﬁcation is the
Graph Convolutional Network (GCN).
In the case of two message passing layers its equation is
[Equation]
where Z ∈ R n × c are the predicted node labels,
ˆ˜ A = ˜ D − 12 ˜
A ˜ D − 12 is the symmetrically normalized adjacency matrix with self-loops, with the diagonal degree matrix ˜ D ij = (cid:80) k
˜
A ik δ ij , and W 0 and
W 1 are trainable weight matrices (Kipf & Welling, 2017).
With two GCN-layers, only neighbors in the two-hop neighborhood are considered.
There are essentially two reasons why a message passing algorithm like GCN can’t be trivially expanded to use a larger neighborhood.
First, aggregation by averaging causes oversmoothing if too many layers are used.
It, therefore, loses its focus on the local neighborhood (Li et al., 2018).
Second, most common aggregation schemes use learnable weight matrices in each layer.
Therefore, using a larger neighborhood necessarily increases the depth and number of learnable parameters of the neural network (the second aspect can be circumvented by using weight sharing, which is typically not the case, though).
However, the required neighborhood size and neural network depth are two completely orthogonal aspects.
This ﬁxed relationship is a strong limitation and leads to bad compromises.
We will start by concentrating on the ﬁrst issue.
Using a randomization assumption for the ReLU activations, Xu et al.
(2018) have shown that for a k -layer GCN the inﬂuence score of node x on y , I ( x, y ) =
(cid:80) i (cid:80)
j ∂ Z yi ∂ X xj , is proportional in expectation to a slightly
[Figure]
h
[Figure]
h
[Figure]
hhh
[Figure]
α α
[Figure]
Hence, the information of node x spreads to node y in a random walk-like manner.
If we take the limit k → ∞ and the graph is irreducible and aperiodic, this random walk probability distribution P rw’ ( x → y, k ) converges to the limit (or stationary) distribution
P lim ( → y ) .
This distribution can be obtained by solving the equation π lim = ˆ˜
Aπ lim .
Obviously, the result only depends on the graph as a whole and is independent of the random walk’s starting (root) node x .
This global property is therefore unsuitable for describing the root node’s neighborhood.
P ERSONALIZED PROPAGATION OF NEURAL PREDICTIONS
From message passing to personalized PageRank.
We can solve the problem of lost focus by recognizing the connection between the limit distribution and PageRank (Page et al., 1998).
The only differences between these two are the added self-loops and the adjacency matrix normalization in ˆ˜ A .
Original PageRank is calculated via π pr =
A rw π pr , with A rw =
AD − 1 .
Having made this connection we can now consider using a variant of PageRank that takes the root node into account –
personalized PageRank (Page et al., 1998).
We deﬁne the root node x via the teleport vector i x , which is a one-hot indicator vector.
Our adaptation of personalized PageRank can be obtained for node x using the recurrent equation π ppr ( i x ) =
(1 − α ) ˆ˜
Aπ ppr ( i x )+ α i x , with the teleport (or restart) probability α ∈ (0 , 1] .
By solving this equation, we obtain
[Equation]
Introducing the teleport vector i x allows us to preserve the node’s local neighborhood even in the limit distribution.
In this model the inﬂuence score of root node x on node y , I ( x, y ) , is proportional to the y -th element of our personalized PageRank π ppr ( i x ) .
This value is different for every root node.
How fast it decreases as we move away from the root node can be adjusted via α .
By substituting the indicator vector i x with the unit matrix I n we obtain our fully personalized PageRank matrix Π ppr
= α ( I n − (1 − α ) ˆ˜
A ) − 1 , whose element ( yx ) speciﬁes the inﬂuence score of node x on node y , I ( x, y )
∝ Π ( yx ) ppr .
Note that due to symmetry Π ( yx ) ppr
= Π ( xy ) ppr , i.e. the inﬂuence of x on y is equal to the inﬂuence of y on x .
Also, this inverse always exists since 1 1 − α > 1 and therefore can’t be an eigenvalue of ˆ˜ A (see Appendix A).
Personalized propagation of neural predictions (PPNP).
To utilize the above inﬂuence scores for semi-supervised classiﬁcation we generate predictions for each node based on its own features and then propagate them via our fully personalized PageRank scheme to generate the ﬁnal predictions.
This is the foundation of personalized propagation of neural predictions.
PPNP’s model equation is
[Equation]
where X is the feature matrix and f θ a neural network with parameter set θ generating the predictions
As a consequence, PPNP separates the neural network used for generating predictions from the propagation scheme.
This separation additionally solves the second issue mentioned above: the depth of the neural network is now fully independent of the propagation algorithm.
As we saw when connecting GCN to PageRank, personalized PageRank can effectively use even inﬁnitely many neighborhood aggregation layers, which is clearly not possible in the classical message passing framework.
Furthermore, the separation gives us the ﬂexibility to use any method for generating predictions, e.g. deep convolutional neural networks for graphs of images.
While generating predictions and propagating them happen consecutively during inference, it is important to note that the model is trained end-to-end .
That is, the gradient ﬂows through the propagation scheme during backpropagation (implicitly considering inﬁnitely many neighborhood aggregation layers).
Adding these propagation effects signiﬁcantly improves the model’s accuracy.
Efﬁciency analysis.
Directly calculating the fully personalized PageRank matrix Π ppr , is computationally inefﬁcient and results in a dense R n × n matrix.
Using this matrix would lead to a computational complexity and memory requirement of O ( n 2 ) for training and inference.
To solve this issue, reconsider the equation Z
= α
( I n − (1 − α ) ˆ˜ A ) − 1 H .
Instead of viewing this equation as a combination of a dense fully personalized PageRank matrix with the prediction matrix, we can also view it as a variant of topic-sensitive PageRank, with each class corresponding to one topic (Haveliwala, 2002).
In this view every column of H deﬁnes an (unnormalized) distribution over nodes that acts as a teleport set.
Hence, we can approximate PPNP via an approximate computation of topic-sensitive PageRank.
Approximate personalized propagation of neural predictions (APPNP).
More precisely, APPNP achieves linear computational complexity by approximating topic-sensitive PageRank via power iteration.
While PageRank’s power iteration is connected to the regular random walk, the power iteration of topic-sensitive PageRank is related to a random walk with restarts.
Each power iteration (random walk/propagation) step of our topic-sensitive PageRank variant is, thus, calculated via
[Equation]
where the prediction matrix H acts as both the starting vector and the teleport set, K deﬁnes the number of power iteration steps and k ∈ [0 , K − 1] .
Note that this method retains the graph’s sparsity and never constructs an R n × n matrix.
The convergence of this iterative scheme can be shown by investigating the resulting series (see Appendix B).
Note that the propagation scheme of this model does not require any additional parameters to train – as opposed to models like GCN, which require more parameters for each additional propagation layer.
We can therefore propagate very far with very few parameters.
Our experiments show that this ability is indeed very beneﬁcial (Section 6).
A similar model expressed in the message passing framework would therefore not be able to achieve the same level of performance.
The reformulation of PPNP via ﬁxed-point iterations illustrates a connection to the graph neural network (GNN) model (Scarselli et al., 2009).
While the latter uses a learned ﬁxed-point iteration, our approach uses a ﬁxed one and applies a (learned) feature transformation before propagation.
In both PPNP and APPNP, the size of the neighborhood inﬂuencing each node can be adjusted via the teleport probability α .
The freedom to choose α allows us to adjust the model for different types of networks, since varying graph types require the consideration of different neighborhood sizes, as shown in Section 6 and described by Grover & Leskovec (2016) and Abu-El-Haija et al.
(2018b).
R ELATED WORK
Several works have tried to improve the training of message passing algorithms and increase the neighborhood available at each node by adding skip connections (Li et al., 2016; Pham et al., 2017;
Hamilton et al., 2017; Ying et al., 2018).
One recent approach combined skip connection with aggregation schemes (Xu et al., 2018).
However, the range of all of these models is still limited,
[Table]
as apparent in the low number of message passing layers used.
While it is possible to add skip connections in the neural network used by our algorithm, this would not inﬂuence the propagation scheme.
Our approach to solving the range problem is therefore unrelated to these models.
Li et al.
(2018) facilitated training by combining message passing with co- and self-training.
The improvements achieved by this combination are similar to results reported with other semi-supervised classiﬁcation models (Buchnik & Cohen, 2018).
Note that most algorithms, including ours, can be improved using self- and co-training.
However, each additional step used by these methods corresponds to a full training cycle and therefore signiﬁcantly increases the training time.
E XPERIMENTAL SETUP
Recently, many experimental evaluations have suffered from experimental bias by using varying training setups, from superﬁcial statistical evaluation, and from overﬁtting.
The latter is caused by experiments only using a single training/validation/test split, by not distinguishing clearly between the validation and test set, and by ﬁnetuning hyperparameters to each dataset or even data split.
Message-passing algorithms are very sensitive to both data splits and weight initialization (as clearly shown by our evaluation).
Thus, a carefully designed evaluation protocol is extremely important.
Our work aims to establish such a thorough evaluation protocol.
First, we run each experimenttimes on multiple random splits and initializations.
Second, we split the data into a visible and a test set, which do not change.
The test set was only used once to report the ﬁnal performance; and in particular, has never been used to perform hyperparameter and model selection.
To further prevent overﬁtting we use the same number of layers and hidden units, dropout rate d , L 2 regularization parameter λ , and learning rate l across datasets, since all datasets are scientiﬁc networks and use bag-of-words as features.
To prevent experimental bias we optimized the hyperparameters of all models individually on the same setup using a grid search on C ITESEER and C ORA -ML and use the same early stopping criterion across models.
Finally, to ensure the statistical robustness of our experimental setup, we calculate conﬁdence intervals via bootstrapping and report the p-values of a paired t -test for our main claims.
To our knowledge, this is the most rigorous study on GCN-like models which has been done so far on graphs having text-based features.
More details about the experimental setup are provided in Appendix C.
Datasets.
We use four text-classiﬁcation datasets for evaluation.
C ITESEER (Sen et al., 2008),
C ORA -ML (McCallum et al., 2000) and P UB M ED (Namata et al., 2012) are citation graphs, where each node represents a paper and the edges represent citations between them.
We further introduce the M ICROSOFT
A CADEMIC graph, where edges represent co-authorship.
We use the largest connected component of each graph.
All graphs use a bag-of-words representation of the papers’ abstracts as features.
Table 1 reports the dataset statistics.
Baseline models.
We use ﬁve state-of-the-art models as baselines: GCN (Kipf & Welling, 2017), network of GCNs (N-GCN)
(Abu-El-Haija et al., 2018a), graph attention networks (GAT) (Veliˇckovi´c et al., 2018), bootstrapped (self-trained) feature propagation (bt.
FP)
(Buchnik & Cohen, 2018) and jumping knowledge networks with concatenation (JK) (Xu et al., 2018).
For GCN we also show the results of the (unoptimized) vanilla version (V. GCN) to demonstrate the strong impact of early stopping and hyperparameter optimization.
We describe the optimized hyperparameters of all models in Appendix D.
Model hyperparameters.
To ensure a fair model comparison we used a neural network for PPNP that is structurally very similar to GCN and has the same number of parameters.
We use two layers with h =
64 hidden units.
We apply L 2 regularization with λ = 0 .
005 on the weights of the ﬁrst layer and use dropout with dropout rate d = 0 .
5 on both layers and the adjacency matrix.
For
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
G C N G C N
N - G
C N G A T J K
B t .
F P
PP N
P
A PP
N P
PubMed
V .
G
C N G C N
N - G
C N G A T J K
B t .
F P
PP N
P
A PP
N P
MS Academic
APPNP, adjacency dropout is resampled for each power iteration step.
For propagation we use the teleport probability α = 0 .
1 and K = 10 power iteration steps for APPNP.
We use α = 0 . 2 on the M ICROSOFT A CADEMIC graph due to its structural difference (see Figure 5 and its discussion). The combination of this shallow neural network with a comparatively high number of power iteration steps achieved the best results during hyperparameter optimization (see Appendix H).
R ESULTS
Overall accuracy.
The results for the accuracy (micro F1-score) are summarized in Table 2.
Similar trends are observed for the macro F1-score (see Appendix E).
Both models signiﬁcantly outperform the state-of-the-art baseline models on all datasets.
Our rigorous setup might understate the improvements achieved by PPNP and APPNP – this result is statistically signiﬁcant p < 0 .
05 , as tested via a paired t -test (see Appendix F).
This thorough setup furthermore shows that the advantages reported by recent works practically vanish when training is harmonized, hyperparameters are properly optimized and multiple data splits are considered.
A simple GCN with optimized hyperparameters outperforms several recently proposed models on our setup.
Figure 2 shows how broad the accuracy distribution of each model is.
This is caused by both random initialization and different data splits (train / early stopping / test).
This demonstrates how crucial a statistically rigorous evaluation is for a conclusive model comparison.
Moreover, it shows the sensitivity (robustness) of each method, e.g. PPNP, APPNP and GAT typically have lower variance.
Training time per epoch.
We report the average training time per epoch in Table 3.
We decided to only compare the training time per epoch since all hyperparameters were solely optimized for accuracy and the used early stopping criterion is very generous.
Obviously, (exact) PPNP can only be applied to moderately sized graphs, while APPNP scales to large data.
On average, APPNP is around 25 % slower than GCN due to its higher number of matrix multiplications.
It scales similarly with graph size as GCN and is therefore signiﬁcantly faster than other more sophisticated models like GAT.
This is observed even though our implementation improved GAT’s training time roughly by a factor of 2 compared to the reference implementation.
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
PPNP’s dominance increases further for smaller training set sizes.
Training set size.
Since the labeling rate is often very small for real world datasets, investigating how the models perform with a small number of training samples is very important.
Figure 3 shows how the number of training nodes per class n train impacts the achieved accuracy on C ORA -ML.
The results on the other datasets can be found in Appendix G.
The dominance of PPNP and APPNP becomes speciﬁcally clear for small training sets.
This can be attributed to their higher range, which allows them to better propagate the information further away from the (few) training nodes.
Number of power iteration steps.
Figure 4 shows how the accuracy depends on the number of power iteration steps for two different propagation schemes.
The ﬁrst mimics the standard propagation as known from GCNs (i.e. taking α = 0 in APPNP).
As clearly shown the performance breaks down as we increase the number of power iteration steps K (since we approach the global PageRank solution).
However, when using the power of personalized propagation (here with α = 0 . 1 ) the accuracy increases and converges to the solution of (exact) PPNP with inﬁnitely many propagation steps, thus demonstrating the personalized propagation principle is indeed beneﬁcial.
As also shown in the ﬁgure, it is enough to use a moderate number of power iterations (e.g. K = 10 ) to approximate the exact PPNP solution.
Teleport probability α .
Figure 5 shows how the accuracy on the validation set is affected by the hyperparameter α .
While the optimum differs slightly for every dataset, we consistently found a teleport probability of around α ∈ [0 . 05 , 0 . 2] to perform best.
This probability should be adjusted for the dataset under investigation, since different graphs exhibit different neighborhood structures (Grover & Leskovec, 2016; Abu-El-Haija et al., 2018b).
Neural network without propagation.
PPNP and APPNP are trained end-to-end, with the propagation scheme affecting (i) the neural network f θ during training, and (ii) the classiﬁcation decision during inference.
Investigating how the model performs without propagation shows if and how valu- [Figure] APPNP ( α = 0 . 1 ). [Figure]
[Figure]
able this addition is.
Figure 6 shows how propagation affects both training and inference. ”
Never” denotes the case where no propagation is used; essentially we train and apply a standard multilayer perceptron (MLP)
f
θ using the features only. ”
Training” denotes the case where we use APPNP during training to learn f θ ; at inference time, however, only f θ is used to predict the class labels.
”Inference”, in contrast, denotes the case where f θ is trained without APPNP (i.e. standard MLP on features); this pretrained network with ﬁxed weights, however, is then used within APPNP during inference time.
Finally, ”Inf. & Training” denotes the regular APPNP, which always uses propagation.
The best results are achieved with regular APPNP, which validates our approach.
However, on most datasets the classiﬁcation accuracy decreases surprisingly little when propagation is only performed during inference.
Skipping propagation during training can signiﬁcantly reduce training time for large graphs, since all nodes can be handled independently.
Furthermore, this shows that our model can be combined with pretrained neural networks that do not incorporate any graph information and still signiﬁcantly improve their accuracy.
Moreover, Figure 6 shows that only applying propagation during training can also lead to large improvements.
This suggests that our model should be able to handle cases of online and inductive learning where only the features and not the neighborhood information of an incoming (previously unobserved) node are available.
C ONCLUSION
In this paper we have introduced personalized propagation of neural predictions (PPNP) and a fast approximation, APPNP.
We derived this model by considering the relationship between GCN and
PageRank and extending it to personalized PageRank.
This model solves the limited range problem inherent in many message passing models without introducing any additional parameters.
It uses the information from a large, adjustable neighborhood for classifying each node and is computationally efﬁcient.
This model outperforms several modern methods for semi-supervised classiﬁcation on multiple graphs in the most thorough study which has been done for GCN-like models so far.
For future work we it would be interesting to combine PPNP with more complex neural networks used e.g. in computer vision or natural language processing.
Furthermore, faster or incremental approximations of personalized PageRank (Bahmani et al., 2010; 2011; Lofgren et al., 2014) and more sophisticated propagation schemes would also beneﬁt the method.
A E XISTENCE OF Π PPR
The matrix
[Equation]
(5) exists iff the determinant det ( I n − (1 − α )
ˆ˜ A ) (cid:54) = 0 , which is the case iff det ( ˆ˜ A − 1 1 − α I n ) (cid:54) = 0 , i.e. iff 1 1 − α is not an eigenvalue of ˆ˜ A .
This value is always larger than 1 since the teleport probability α ∈ (0 , 1] .
Furthermore, the symmetrically normalized matrix ˆ˜
A has the same eigenvalues as the row-stochastic matrix ˜
A rw .
This can be shown by multiplying the eigenvalue equation ˆ˜
Av = λ v with ˜ D − 12 from left and substituting w = ˜ D − 12 v .
However, the largest eigenvalue of a rowstochastic matrix is 1, as can be proven using the Gershgorin circle theorem.
Hence, 1 1 − α can’t be an eigenvalue and Π ppr always exists.
B C ONVERGENCE OF APPNP
APPNP uses the iterative equation
[Equation]
After the k -th propagation step, the resulting predictions are
[Equation]
If we take the limit k → ∞ the left term tends to 0 and the right term becomes a geometric series.
The series converges since α ∈ (0 , 1] and ˆ˜
A is symmetrically normalized and therefore det ( ˆ˜ A ) ≤ 1 , resulting in
[Equation]
which is the equation for calculating (exact) PPNP.
C E XPERIMENTAL DETAILS
[Figure]
The sampling procedure is illustrated in Figure 7.
The data is ﬁrst split into a visible and a test set.
For the visible set 1500 nodes were sampled for the citation graphs and 5000 for M ICROSOFT
A CADEMIC .
The test set contains all remaining nodes.
We use three different label sets in each experiment: A training set of 20 nodes per class, an early stopping set of 500 nodes and either a validation or test set.
The validation set contains the remaining nodes of the visible set.
We use 20 random seeds for determining the splits.
These seeds are drawn once and ﬁxed across runs to facilitate comparisons.
We use one set of seeds for the validation splits and a different set for the test splits.
Each experiment is run with 5 random initializations on each data split, leading to a total of 100 runs per experiment.
The early stopping criterion uses a patience of p = 100 and an (unreachably high) maximum of n = 10 000 epochs.
The patience is reset whenever either the accuracy increases or the loss decreases on the early stopping set.
We choose the parameter set achieving the highest accuracy and break ties by selecting the lowest loss on this set.
This early stopping strategy was inspired by GAT (Veli ˇ ckovi ´ c et al., 2018).
We used TensorFlow (Mart´ın Abadi et al., 2015) for all experiments except bootstrapped feature propagation.
All uncertainties and conﬁdence intervals correspond to a conﬁdence level of 95 % and were calculated by bootstrapping with 1000 samples.
We use the Adam optimizer with a learning rate of l = 0 .
01 and cross-entropy loss for all models (Kingma & Ba, 2015).
Weights are initialized as described in Glorot & Bengio (2010).
The feature matrix is L 1 normalized per row.
D B ASELINE HYPERPARAMETERS
Vanilla GCN uses the original settings of two layers with h = 16 hidden units, no dropout on the adjacency matrix, L 2 regularization parameter λ
= 5 × 10 − 4 and the original early stopping with a maximum of 200 steps and a patience of 10 steps based on the loss.
The optimized GCN uses two layers with h = 64 hidden units, dropout on the adjacency matrix with d = 0 .
5 and L 2 regularization parameter λ = 0 .
N-GCN uses h = 16 hidden units, R = 4 heads per random walk length and random walks of up to K − 1 = 4 steps.
It uses L 2 regularization on all layers with λ
= 1 × 10 − 5 and the attention variant for merging the predictions (Abu-El-Haija et al., 2018a).
Note that this model effectively uses RKh = 320 hidden units, which is 5 times as many as the optimized GCN model, GAT and
PPNP use.
For GAT we use the (well optimized) original hyperparameters, except the L 2 regularization parameter λ = 0 .
001 and learning rate l = 0 .
As opposed to the original paper, we do not use different hyperparameters on P UB M ED , as described in our experimental setup.
Bootstrapped feature propagation uses a return probability of α = 0 .
2 , 10 propagation steps,bootstrapping (self-training) steps with r = 0 .
1 n training nodes added per step.
We add the training nodes with the lowest entropy on the predictions.
The number of nodes added per class is based on the class proportions estimated using the predictions.
Note that this model does not include any stochasticity in its initialization.
We therefore only run it once per train/early stopping/test split.
For the jumping knowledge networks we use the concatenation variant with three layers and h =hidden units per layer.
We apply L 2 regularization with λ = 0 .
001 on all layers and perform dropout with d = 0 .
5 on all layers but not on the adjacency matrix
[Table]
E F1 SCORE
[Table]
CADEMIC
[Table]
see efﬁciency analysis in Section 3)
F P AIRED t - TEST
[Table] [Table]
[Figure] [Figure]
[Figure]
H N UMBER OF NEURAL NETWORK LAYERS
[Figure]