IGLU: E FFICIENT GCN T RAINING VIA L AZY U P -
DATES ssrajan@microsoft.
A BSTRACT
Training multi-layer Graph Convolution Networks (GCN) using standard SGD techniques scales poorly as each descent step ends up updating node embeddings for a large portion of the graph.
Recent attempts to remedy this sub-sample the graph that reduce compute but introduce additional variance and may offer suboptimal performance.
This paper develops the IGLU method that caches intermediate computations at various GCN layers thus enabling lazy updates that signiﬁcantly reduce the compute cost of descent.
IGLU introduces bounded bias into the gradients but nevertheless converges to a ﬁrst-order saddle point under standard assumptions such as objective smoothness.
Benchmark experiments show that IGLU offers up to 1.2% better accuracy despite requiring up to 88% less compute.
I NTRODUCTION
The Graph Convolution Network (GCN) model is an effective graph representation learning technique.
Its ability to exploit network topology offers superior performance in several applications such as node classiﬁcation (Kipf & Welling, 2017), recommendation systems (Ying et al., 2020) and program repair (Yasunaga & Liang, 2020).
However, training multi-layer GCNs on large and dense graphs remains challenging due to the very aggregation operation that enables GCNs to adapt to graph topology – a node’s output layer embedding depends on embeddings of its neighbors in the previous layer which recursively depend on embeddings of their neighbors in the previous layer, and so on.
Even in GCNs with 2-3 layers, this prompts back propagation on loss terms for a small mini-batch of nodes to update a large multi-hop neighborhood causing mini-batch SGD techniques to scale poorly.
Efforts to overcome this problem try to limit the number of nodes that receive updates as a result of a back-propagation step Chiang et al.
Hamilton et al.
; Zeng et al.
This is done either by sub-sampling the neighborhood or clustering (it is important to note the distinction between nodes sampled to create a mini-batch and neighborhood sampling done to limit the neighborhood of the mini-batch that receives updates).
Variance reduction techniques Chen et al.
(2018a) attempt to reduce the additional variance introduced by neighborhood sampling.
However, these techniques often require heavy subsampling in large graphs resulting in poor accuracy due to insufﬁcient aggregation.
They also do not guarantee unbiased learning or rigorous convergence guarantees.
See Section 2 for a more detailed discussion on the state-of-the-art in GCN training.
Our Contributions : This paper presents IGLU, an efﬁcient technique for training GCNs based on lazy updates.
An analysis of the gradient structure in GCNs reveals the most expensive component of the back-propagation step initiated at a node to be (re-)computation of forward-pass embeddings for its vast multi-hop neighborhood.
Based on this observation, IGLU performs back-propagation with signiﬁcantly reduced complexity using intermediate computations that are cached at regular intervals.
This completely avoids neighborhood sampling and is a stark departure from the state-of-the-art.
IGLU is architecture-agnostic and can be readily implemented on a wide range of GCN architectures.
Avoiding neighborhood sampling also allows IGLU to completely avoid variance artifacts and offer provable convergence to a ﬁrst-order stationary point under standard assumptions.
In experiments,
IGLU offered superior accuracies and accelerated convergence on a range of benchmark datasets.
R ELATED W ORKS
(Bruna et al., 2014; Defferrard et al., 2016; Kipf & Welling, 2017) introduced the GCN architecture for transductive learning on graphs.
Later works extended to inductive settings and explored architectural variants such as the GIN (Xu et al., 2019).
Much effort has focused on speeding-up GCN training.
Sampling Based Approaches : The neighborhood sampling strategy e.g. GraphSAGE (Hamilton et al., 2017) limits compute by restricting back-propagation updates to a sub-sampled neighborhood of a node.
Layer sampling strategies such as FastGCN (Chen et al., 2018b), LADIES (Zou et al., 2019) and ASGCN (Huang et al., 2018) instead sample nodes at each GCN layer using importance sampling to reduce variance and improve connectivity among sampled nodes.
FastGCN uses the same sampling distribution for all layers and struggles to maintain connectivity unless large batch-sizes are used.
LADIES uses a per-layer distribution conditioned on nodes sampled for the succeeding layer.
ASGCN uses a linear model to jointly infer node importance weights.
Recent works such as Cluster-GCN (Chiang et al., 2019) and GraphSAINT (Zeng et al., 2020) propose subgraph sampling creating mini-batches out of subgraphs and restricting back-propagation to nodes within the subgraph.
To avoid losing too many edges, large mini-batch sizes are used.
Cluster-GCN performs graph clustering and chooses multiple clusters per mini-batch (reinserting any edges cutting across clusters in a mini-batch) whereas GraphSAINT samples large subgraphs directly using random walks.
Bias and Variance : Sampling techniques introduce bias as non-linear activations in the GCN architecture make it difﬁcult to offer unbiased estimates of the loss function. Zeng et al.
(2020) offer unbiased estimates if non-linearities are discarded.
Sampling techniques also face increased variance for which variance-reduction techniques have been proposed such as VR-GCN (Chen et al., 2018a), MVS-GNN (Cong et al., 2020) and AS-GCN (Huang et al., 2018).
VR-GCN samples nodes at each layer whose embeddings are updated and uses stale embeddings for the rest, offering variance elimination in the limit under suitable conditions.
MVS-GNN handles variance due to mini-batch creation by performing importance weighted sampling to construct mini-batches.
The Bandit Sampler (Liu et al., 2020) formulates variance reduction as an adversarial bandit problem.
Other Approaches:
Recent approaches decouple propagation from prediction as a pre-processing step e.g. PPRGo (Bojchevski et al., 2020), APPNP (Klicpera et al., 2019) and SIGN (Frasca et al., 2020).
APPNP makes use of the relationship between the GCNs and PageRank to construct improved propagation schemes via personalized PageRank.
PPRGo extends APPNP by approximating the dense propagation matrix via the push-ﬂow algorithm.
SIGN proposes inception style pre-computation of graph convolutional ﬁlters to speed up training and inference.
GNNAutoScale (Fey et al., 2021) builds on VR-GCN and makes use of historical embeddings for scaling GNN training to large graphs.
IGLU in Context of Related Work : IGLU avoids neighborhood sampling entirely and instead speeds-up learning using stale computations.
Intermediate computations are cached and lazily updated at regular intervals e.g. once per epoch.
We note that IGLU’s caching is distinct and much more aggressive (e.g. lasting an entire epoch) than the internal caching performed by popular frameworks such as TensorFlow and PyTorch (where caches last only a single iteration).
Refreshing these caches in bulk offers IGLU economies of scale.
IGLU incurs no sampling variance but incurs bias due to the use of stale computations.
Fortunately, this bias is provably bounded, and can be made arbitrarily small by adjusting the step length and refresh frequency of the stale computations.
IGLU: EFF I CIENT G CN TRAINING VIA L AZY U PDATES
Problem Statement : Consider the problem of learning a GCN architecture on an undirected graph
G ( V , E ) with each of the N nodes endowed with an initial feature vector x 0 i ∈ R d 0 , i ∈ V .
X 0 ∈
R n × d 0 denotes the matrix of these initial features stacked together.
N ( i ) ⊂
V denotes the set of neighbors of node i .
A denotes the (normalized) adjacency matrix of the graph.
A multi-layer GCN architecture uses a parameterized function at each layer to construct a node’s embedding for the next layer using embeddings of that node as well as those of its neighbors.
Speciﬁcally
[Equation]
where E k denotes the parameters of k -th layer.
For example, a classical GCN layer is given by
[Equation]
where E k is simply the matrix W k ∈ R
d k − 1 × d k and d k is the embedding dimensionality at the k th layer.
IGLU supports more involved architectures including residual connections, virtual nodes, layer normalization, batch normalization, etc (see Appendix A.5).
We will use E k to collectively refer to all parameters of the k th layer e.g. offset and scale parameters in a layer norm operation, etc.
X k ∈ R n × d k will denote the matrix of k th layer embeddings stacked together, giving us the handy shorthand X k = f
( X k − 1 ; E k ) .
Given a K -layer GCN and a multi-label/multi-class task with C labels/classes, a fully-connected layer W K +1 ∈ R d K × C and activation functions such as sigmoid or softmax are used to get predictions that are fed into the task loss.
IGLU does not require the task loss to decompose over the classes.
The convergence proofs only require a smooth training objective.
Neighborhood Explosion : To understand the reasons behind neighborhood explosion and the high cost of mini-batch based SGD training, consider a toy univariate regression problem with unidimensional features and a 2-layer GCN with sigmoidal activation i.e. K = 2 and C = {+
+}
= d 0 = d 1 = d 2 .
This GCN is parameterized by w 1 , w 2 , w 3 ∈ R and offers the output ˆ y i =
w 3 σ (cid:0) z 2 i (cid:1) where z 2 i = (cid:80) j
∈V
A ij w 2 x 1 j ∈ R .
In turn, we have x 1 j = σ (cid:0) z 1 i (cid:1) where z 1 i = (cid:80) j (cid:48)
∈V A jj (cid:48)
w 1 x 0 j (cid:48) ∈ R and x 0 j (cid:48)
∈ R are the initial features of the nodes.
Given a task loss (cid:96) : R × R → R + e.g. least squares, denoting (cid:96) (cid:48)
i = (cid:96) (cid:48) (ˆ y i , y i ) gives us
[Equation]
The nesting of the summations is conspicuous and indicates the neighborhood explosion: when seeking gradients in a K -layer GCN on a graph with average degree m , up to an m K − 1 -sized neighborhood of a node may be involved in the back-propagation update initiated at that node.
Note that the above expression involves terms such as σ (cid:48)
( z 2 i ) , σ (cid:48)
( z 1 j ) . Since the values of z 2 i , z 1 j etc change whenever the model i.e. (cid:8) w 1 , w 2 , w 3 (cid:9) receives updates, for a fresh mini-batch of nodes, terms such as σ (cid:48) ( z 2 i ) , σ (cid:48)
( z 1 j ) need to be computed afresh if the gradient is to be computed exactly.
Performing these computations amounts to doing forward pass operations that frequently involve a large neighborhood of the nodes of the mini-batch.
Sampling strategies try to limit this cost by directly restricting the neighborhood over which such forward passes are computed.
However, this introduces both bias and variance into the gradient updates as discussed in Section 2.
IGLU instead lazily updates various incomplete gradient (deﬁned below) and node embedding terms that participate in the gradient expression.
This completely eliminates sampling variance but introduces a bias due to the use of stale terms.
However, this bias provably bounded and can be made arbitrarily small by adjusting the step length and frequency of refreshing these terms.
Lazy Updates for GCN Training : Consider an arbitrary GCN architecture with the following structure: for some parameterized layer functions we have X k = f
( X k − 1 ; E k ) where E k denotes the collection of all parameters of the k th layer e.g. weight matrices, offset and scale parameters used in layer norm operations, etc.
X k ∈ R N × d k denotes the matrix of k th layer embeddings stacked together and X 0 ∈ R N × d 0 are the initial features.
For a K -layer GCN on a multi-label/multi-class task with C labels/classes, a fully-connected layer W K +1 ∈ R d K × C is used to offer predictions ˆ y i
=
( W K +1 ) (cid:62) x
Ki ∈ R C .
We use the shorthand ˆ Y ∈ R N × C to denote the matrix where the predicted outputs ˆ y i for all the nodes are stacked.
We assume a task loss function (cid:96) : R C × R C × R + and use the abbreviation (cid:96) i :=
(cid:96) (ˆ y i , y i ) .
The loss function need not decompose over the classes and can thus be assumed to include activations such as softmax that are applied over the predictions ˆ y i .
Let L =
(cid:80) i ∈V (cid:96) i denote the training objective.
The convergence proofs assume that L is smooth.
𝐸 𝑘 𝐸 𝑘+ 𝑋 𝑘− 𝑋 𝑘 𝑋 𝑘+ 𝛂 𝑘− 𝛂 𝑘 𝛂 𝑘+ 𝑋
𝑘 = 𝑓 𝑋 𝑘−1 ;𝐸 𝑘 , 𝛂 𝑘 = 𝜕 𝛂 𝑘+1 ⊙𝑋 𝑘+
𝜕𝑋 𝑘 (b) (c) 𝐸GraphSAINT
𝑋 𝑘− 𝑋 𝑘
Dropout
Graph Conv
ReLU
Layer Norm
[Figure]
Motivation : We deﬁne the the loss derivative matrix G =
[ g ic ] ∈ R N × C with g ic :=
∂(cid:96)
i ∂ ˆ y ic .
As the proof of Lemma 1 (see Appendix C) shows, the loss derivative with respect to parameters E k at any layer has the form ∂ L ∂E
k
= (cid:80) Nj =
[Equation]
d k p =1 (cid:16)(cid:80) [Equation] ∈V (cid:80) [Equation]
∈ [ C ] g ic · ∂ ˆ y ic ∂X kjp (cid:17) ∂X kjp ∂E k . Note that the partial derivatives ∂X kjp ∂E k can be computed for any node using only embeddings of its neighbors in the ( k − 1) th layer i.e. X k − 1 thus avoiding any neighborhood explosion.
This means that neighborhood explosion must be happening while computing the terms encapsulated in the round brackets.
Let us formally recognize these terms as incomplete gradients .
The notation ∂P∂Q (cid:12)(cid:12)(cid:12) R denotes the partial derivative of P w.r.t Q while keeping R ﬁxed i.e. treated as a constant.
Deﬁnition 1.
For any layer k ≤ K , deﬁne its incomplete task gradient to be ααα k
[Equation]
The following lemma completely characterizes the loss gradients and also shows that the incomplete gradient terms ααα k , k ∈ [ K ] can be efﬁciently computed using a recursive formulation that also does not involve any neighborhood explosion [Equation]
Lemma 1.
The following results hold whenever the task loss
L is differentiable:
For the ﬁnal fully-connected layer we have
[Equation]
as for any k ∈ [ K ] and any parameter E k in the k th layer, ∂ L ∂E k
[Equation]
For the ﬁnal layer, we have ααα K =
G ( W K +1 )
(cid:62) as well as for any k < K , we have
[Equation]
Lemma 1 establishes a recursive deﬁnition of the incomplete gradients using terms such as ∂X k +1 iq ∂X kjp that concern just a single layer.
Thus, computing ααα k for any k ∈ [ K ] does not involve any neighborhood explosion since only the immediate neighbors of a node need be consulted.
Lemma 1 also shows that if ααα k are computed and frozen, the loss derivatives ∂ L ∂E k only involve additional computation of terms such as ∂X kip ∂E k which yet again involve a single layer and do not cause neighborhood explosion.
This motivates lazy updates to α α α k , X k values in order to accelerate back-propagation.
However, performing lazy updates to both ααα k , X k offers suboptimal performance.
Hence IGLU adopts two variants described in Algorithms 1 and 2.
The backprop variant * keeps embeddings X k stale for an entire epoch but performs eager updates to ααα k .
The inverted variant on the other hand keeps the incomplete gradients ααα k stale for an entire epoch but performs eager updates to X k .
Input: GCN G , initial features X 0 , task loss L 1: Initialize model parameters E k , k ∈
[ K ] , W K + 2: while not converged do 3:
Do a forward pass to compute X k for all k ∈
[ K ] as well as ˆ Y 4:
Compute G then ∂ L ∂W K +1 using Lemma 1 (1) and update W K +1 ← W K +1 − η · ∂ L ∂W K + 5:
Compute ααα K using G , W K +1 , Lemma 1 (2) 6: for k = K . . .
2 do 7:
Compute ∂ L ∂E k using ααα k , X k , Lemma 1 (1) 8:
Update E k ← E k − η · ∂ L ∂E k 9:
Update ααα k using ααα k +1 using Lemma 1 (2) 10: end for 11: end while
Input: GCN G , initial features X 0 , task loss L 1: Initialize model parameters E k , k ∈ [ K ] , W K + 2: Do an initial forward pass to compute X k , k ∈ [ K ] 3: while not converged do 4:
Compute ˆ Y , G and ααα k for all k ∈
[ K ] using
Lemma 1 (2) 5: for k = 1 . . .
K do 6:
Compute ∂ L ∂E k using ααα k , X k , Lemma 1 (1) 7:
Update E k ← E k − η · ∂ L ∂E k 8:
Update X k ← f ( X k − 1 ; E k ) 9: end for 10:
Compute ∂ L ∂W K +1 using Lemma 1 (1) and use it to update W K +1 ← W K
+1 − η · ∂
[Table]
[Table]
while
SGD Implementation : Update steps in the algorithms (steps 4, 8 in Algorithm 1 and steps 7, 10 in
Algorithm 2) are described as a single gradient step over the entire graph to simplify exposition – in practice, these steps are implemented using mini-batch SGD.
A mini-batch of nodes S is sampled and task gradients are computed w.r.t ˆ L S =
(cid:80) i ∈ S (cid:96) i alone instead of L .
Contribution : As noted in Section 2, IGLU uses caching in a manner fundamentally different from frameworks such as PyTorch or TensorFlow which use short-lived caches and compute exact gradients unlike IGLU that computes gradients faster but with bounded bias.
Moreover, unlike techniques such as VR-GCN that cache only node embeddings, IGLU instead offers two variants and the variant that uses inverted order of updates (Algorithm 2) and caches incomplete gradients usually outperforms the backprop variant of IGLU (Algorithm 1) that caches node embeddings.
Theoretical Analysis : Conditioned on the stale parameters (either ααα k or X k depending on which variant is being executed), the gradients used by IGLU to perform model updates (steps 4, 8 in
Algorithm 1 and steps 7, 10 in Algorithm 2) do not have any sampling bias.
However, the staleness itself training bias.
However, by controlling the step length η and the frequency with which the stale parameters are updated, this bias can be provably controlled resulting in guaranteed convergence to a ﬁrst-order stationary point.
The detailed statement and proof are presented in Appendix C.
Theorem 2 (IGLU Convergence (Informal)) .
Suppose the task objective L has O (1) -Lipschitz gradients and IGLU is executed with small enough step lengths η for model updates (steps 4, 8 in
Algorithm 1 and steps 7, 10 in Algorithm 2), then within T iterations, IGLU ensures:
(cid:107)∇L(cid:107) 2 2 ≤ O (cid:16) 1 /T 2 3 (cid:17) if update steps are carried out on the entire graph in a full
batch. (cid:107)∇L(cid:107) 22 ≤ O (cid:16) 1 / √ T (cid:17) if update steps are carried out using mini-batch SGD.
This result holds under minimal assumptions of objective smoothness and boundedness that are standard Chen et al.
(2018a)
; Cong et al.
(2020), yet offers convergence rates comparable to those offered by standard mini-batch SGD.
However, whereas works such as (Chen et al., 2018a) assume bounds on the sup-norm i.e. L ∞ norm of the gradients, Theorem 2 only requires an L 2 norm bound.
Note that objective smoothness requires the architecture to use smooth activation functions.
However,
IGLU offers similar performance whether using non-smooth activations e.g. ReLU or smooth ones e.g. GELU (see Appendix B.7) as is also observed by other works (Hendrycks & Gimpel, 2020).
E MPIRICAL E VALUATION
IGLU was compared to state-of-the-art (SOTA) baselines on several node classiﬁcation benchmarks in terms of test accuracy and convergence rate.
The inverted order of updates was used for IGLU as it was found to offer superior performance in ablation studies.
Datasets and Tasks: The following ﬁve benchmark tasks were used: (1) Reddit (Hamilton et al., 2017): predicting the communities to which different posts belong, (2) PPI-Large (Hamilton et al., 2017): classifying protein functions in biological protein-protein interaction graphs, (3) Flickr (Zeng et al., 2020): image categorization based on descriptions and other properties, (4) OGBN-Arxiv (Hu et al., 2020): predicting paper-paper associations, and (5) OGBN-Proteins
(Hu et al., 2020): categorizing meaningful associations between proteins.
Training-validation-test splits and metrics were used in a manner consistent with the original release of the datasets: speciﬁcally ROC-AUC was used for OGBN-Proteins and micro-F1 for all other datasets.
Dataset descriptions and statistics are presented in Appendix B.
The graphs in these tasks varied signiﬁcantly in terms of size (from 56K nodes in PPI-Large to 232K nodes in Reddit), density (from average degree 13 in OGBN-Arxiv to 597 in OGBN-Proteins) and number of edges (from 800K to 39 Million).
They require diverse information to be captured and a variety of multi-label and multi-class node classiﬁcation problems to be solved thus offering extensive evaluation.
Baselines: IGLU was compared to state-of-the-art algorithms, namely - GCN (Kipf & Welling, 2017),
GraphSAGE (Hamilton et al., 2017), VR-GCN (Chen et al., 2018a), Cluster-GCN (Chiang et al., 2019) and GraphSAINT (Zeng et al., 2020) (using the Random Walk Sampler which was reported by the authors to have the best performance).
The mini-batched implementation of GCN provided by
GraphSAGE authors was used since the implementation released by (Kipf & Welling, 2017) gave run time errors on all datasets.
GraphSAGE and VRGCN address the neighborhood explosion problem by sampling neighborhood subsets, whereas ClusterGCN and GraphSAINT are subgraph sampling techniques.
Thus, our baselines include neighbor sampling, layer-wise sampling, subgraph sampling and no-sampling methods.
We recall that IGLU does not require any node/subgraph sampling.
IGLU was implemented in TensorFlow and compared with TensorFlow implementations of the baselines released by the authors.
Due to lack of space, comparisons with the following additional baselines is provided in Appendix B.2: LADIES (Zou et al., 2019), L2-GCN (You et al., 2020), AS-GCN (Huang et al., 2018), MVS-GNN (Cong et al., 2020), FastGCN (Chen et al., 2018b), SIGN (Frasca et al., 2020), PPRGo (Bojchevski et al., 2020) and Bandit Sampler (Liu et al., 2020).
Architecture : We note that all baseline methods propose a speciﬁc network architecture along with their proposed training strategy.
These architectures augment the standard GCN architecture (Kipf & Welling, 2017) e.g. using multiple non-linear layers within each GCN layer, normalization and concatenation layers, all of which can help improve performance.
IGLU being architectureagnostic can be readily used with all these architectures.
However, for the experiments, the network architectures proposed by VR-GCN and GraphSAINT was used with IGLU owing to their consistent performance across datasets as demonstrated by (Chen et al., 2018a; Zeng et al., 2020).
Both architectures were considered and results for the best architecture are reported for each dataset.
Detailed Setup.
The supervised inductive learning setting was considered for all ﬁve datasets as it is more general than the transductive setting that assumes availability of the entire graph during training.
The inductive setting also aligns with real-world applications where graphs can grow over time (Hamilton et al., 2017).
Experiments on PPI-Large, Reddit and Flickr used 2 Layer GCNs for all methods whereas OGBN-Proteins and OGBN-Arxiv used 3 Layer GCNs for all methods as prescribed in the original benchmark (Hu et al., 2020).
Further details are provided in Appendix A.1.
Model Selection and Hyperparameter Tuning.
Model selection was done for all methods based on their validation set performance.
Each experiment was run ﬁve times with mean and standard deviation in test performance reported in Table 1 along with training times.
Although the embedding dimension varies across datasets, they are same for all methods for any dataset.
For IGLU, GraphSAGE and
VR-GCN, an exhaustive grid search was done over general hyperparameters such as batch size, learning rate and dropout rate (Srivastava et al., 2014).
In addition, method-speciﬁc hyperparameter sweeps were also carried out that are detailed in Appendix A.4.
4. R ESULTS
For IGLU, the VR-GCN architecture performed better for Reddit and OGBN-Arxiv datasets while the GraphSAINT architecture performed better on the remaining three datasets.
All baselines were extensively tuned on the 5 datasets and their performance reported in their respective publications was either replicated closely or else improved.
Test accuracies are reported in Table 1 and convergence [Table] [Figure]
IGLU offers signiﬁcant improvements in convergence rate over baselines across diverse datasets.
plots are shown in Figure 2.
Additionally, Table 1 also reports the absolute accuracy gain of IGLU over the best baseline.
The % speedup offered by IGLU is computed as follows: let the highest validation score obtained by the best baseline be v 1 and t 1 be the time taken to reach that score.
Let the time taken by IGLU to reach v 1 be t 2 .
Then,
[Equation]
The wall clock training time in Figure 2 is strictly the optimization time for each method and excludes method-speciﬁc overheads such as pre-processing, sampling and sub-graph creation that other baselines incur.
This is actually a disadvantage to IGLU since its overheads are much smaller.
The various time and memory overheads incurred by all methods are summarized in Appendix A. and memory requirements for IGLU are discussed in Appendix A.3.
Performance on Test Set and Speedup Obtained: Table 1 establishes that IGLU signiﬁcantly outperforms the baselines on PPI-Large, Flickr, OGBN-Proteins and OGBN-Arxiv and is competitive with best baselines on Reddit.
On PPI-Large, IGLU improves accuracy upon the best baseline (VRGCN) by over 1.2 % while providing speedups of upto 88 %, i.e., IGLU is about 8 × faster to train than VR-GCN.
On OGBN-Proteins, IGLU improves accuracy upon the best baseline (GraphSAINT) by over 2.6 % while providing speedup of 11 %.
On Flickr, IGLU offers 0.98 % improvement in [Figure] accuracy while simultaneously offering upto 45 % speedup over the previous state-of-the-art method
GraphSAINT.
Similarly on Arxiv, IGLU provides 0.84 % accuracy improvement over the best baseline GraphSAINT while offering nearly 14 % speedup.
On Reddit, an 8.1 % speedup was observed in convergence to a high validation score of 0.955 while the ﬁnal performance is within a standard deviation of the best baseline.
The OGBN-Proteins and OGBN-Arxiv datasets were originally benchmarked in the transductive setting, with the entire graph information made available during training.
However, we consider the more challenging inductive setting yet IGLU outperforms the best transductive baseline by over 0.7 % for Proteins while matching the best transductive baseline for
Arxiv (Hu et al., 2020).
It is important to note that OGBN-Proteins is an atypical dataset because the graph is highly dense.
Because of this, baselines such as ClusterGCN and GraphSAINT that drop a lot of edges while creating subgraphs show a deterioration in performance.
ClusterGCN encounters into a runtime error on this dataset (denoted by (cid:107) in the table), while GraphSAINT requires a very large subgraph size to achieve reasonable performance.
Convergence Analysis : Figure 2 shows that IGLU converges faster to a higher validation score than other baselines.
For PPI-Large, while Cluster-GCN and VR-GCN show promising convergence in the initial stages of training, they stagnate at a much lower validation score in the end whereas IGLU is able to improve consistently and converge to a much higher validation score.
For Reddit, IGLU’s ﬁnal validation score is marginally lower than GraphSAINT but IGLU offers rapid convergence in the early stages of training.
For OGBN-Proteins, Flickr and OGBN-Arxiv, IGLU demonstrates a substantial improvement in both convergence and the ﬁnal performance on the test set.
4. A BLATION STUDIES
Effect of the Order of Updates.
IGLU offers the ﬂexibility of using either the backprop order of updates or the inverted order of updates as mentioned in Section 3.
Ablations were performed on the Reddit and OGBN-Proteins datasets to analyse the effect of the different orders of updates.
Figureoffers epoch-wise convergence for the same and shows that the inverted order of updates offers faster and more stable convergence in the early stages of training although both variants eventually converge to similar validation scores.
It is notable that keeping node embeddings stale (backprop order) offered inferior performance since techniques such as VR-GCN (Chen et al., 2018a) that also keep node embeddings stale. IGLU offers the superior alternative of keeping incomplete gradients stale instead.
Analysis of Degrees of Staleness.
The effect of frequency of updates to the incomplete gradients ( ααα k ) on the performance and convergence of IGLU was analyzed.
This ablation was conducted keeping all the other hyperparameters ﬁxed.
In the default setting, αα α k values were updated only once per epoch (referred to as frequency 1).
Two other update schemes were also considered: a) update the ααα k values every two epochs (referred to as frequency 0.5), and b) update the ααα k values twice within an epoch (referred to as frequency 2).
To clarify, ααα k values are the most fresh with update frequencyand most stale with update frequency 0.5.
This ablation study was performed on the PPI-Large dataset and each variant was trained for 200 epochs.
Table 2 summarizes the results doing model selection and Figure 4 plots the convergence of these variants.
Figure 4b shows that on PPI-Large, the default [Figure] update frequency 1 has the best convergence on the validation set, followed by update frequency 0.5.
Both update frequency 1 and 0.5 massively outperform update frequency 2.
Figure 4a shows that IGLU with update frequency 2 has the lowest training loss but poor validation performance, indicating overﬁtting to the training dataset.
We observe from this ablation that updating embeddings prematurely can cause unstable training resulting in convergence to a suboptimal solution.
However, not refreshing the ααα k values frequently enough can delay convergence to a good solution.
[Table]
Additional Ablations and Experiments: Due to lack of space, the following additional ablations and experiments are described in the appendices: a) Ablation on degrees of staleness for the backprop order of updates in Appendix B.8,
b) Experiments demonstrating IGLU’s scalability to deeper networks and larger datasets in Appendices B.3 and B.4 respectively, and c) Experiments demonstrating IGLU’s applicability and architecture-agnostic nature in Appendices B.5 and B.6.
D ISCUSSION AND F UTURE W ORK
This paper introduced IGLU, a novel method for training GCN architectures that uses biased gradients based on cached intermediate computations to speed up training signiﬁcantly.
The gradient bias is shown to be provably bounded so overall convergence is still effective (see Theorem 2).IGLU’s performance was validated on several datasets where it signiﬁcantly outperformed SOTA methods in terms of accuracy and convergence speed.
Ablation studies conﬁrmed that IGLU is robust to its few hyperparameters enabling a near-optimal choice.
Exploring other possible variants of IGLU, in particular reducing variance due to mini-batch SGD, sampling nodes to further speed-up updates, and exploring alternate staleness schedules are interesting future directions.
On a theoretical side, it would be interesting to characterize properties of datasets and loss functions that inﬂuence the effect of lazy updates on convergence.
Having such a property would allow practitioners to decide whether to execute IGLU with lazier updates or else reduce the amount of staleness.
Exploring applicationand architecture-speciﬁc variants of IGLU is also an interesting direction.
R EPRODUCIBILITY S TATEMENT
Efforts have been made to ensure that results reported in this paper are reproducible.
Theoretical Clarity : Section 3 discusses the problem setup and preliminaries and describes the proposed algorithm.
Detailed proofs are provided in Appendix C due to lack of space.
Experimental Reproducibility : Section 4 and Appendices A and B contain information needed to reproduce the empirical results, namely datasets statistics and data source, data pre-processing, implementation details for IGLU and the baselines including architectures, hyperparameter search spaces and the best hyperparameters corresponding to the results reported in the paper.
Code Release : An implementation of IGLU can be found at the following URL https://github.com/sdeepaknarayanan/iglu
E THICS S TATEMENT
This paper presents IGLU, a novel technique to train GCN architectures on large graphs that outperforms state of the art techniques in terms of prediction accuracy and convergence speed.
The paper does not explore any sensitive applications and the experiments focus primarily on publicly available benchmarks of scientiﬁc (e.g. PPI) and bibliographic (e.g. ArXiv) nature do not involve any user studies or human experimentation. A CKNOWLEDGMENTS
The authors are thankful to the reviewers for discussions that helped improve the content and presentation of the paper.
A PPENDIX
This appendix is segmented into three key parts.
Section A discusses additional implementation details.
In particular, method-speciﬁc overheads are discussed in detail and detailed hyper-parameter settings for IGLU and the main baselines reported in Table 1 are provided.
A key outcome of this analysis is that IGLU has the least overheads as compared to the other methods.
We also provide the methodology for incorporating architectural modiﬁcations into IGLU, provide a detailed comparison with caching based methods and provide a more detailed descriptions of the algorithms mentioned in the main paper.
Section B reports dataset statistics, provides comparisons with additional baselines (not included in the main paper due to lack of space) and provides experiments on scaling to deeper models and larger graphs as mentioned in Section 4.2 in the main paper.
It also provides experiments for the applicability of IGLU across settings and architectures, using smooth activation functions, continued ablation on degrees of staleness and optimization on the train set.
The key outcome of this discussion is that IGLU scales well to deeper models and larger datasets, and continues to give performance boosts with state-of-the-art even when compared to these additional baselines.
Experimental evidence also demonstrates IGLU’s ability to generalize easily to a different setting and architecture, perform equivalently with smooth activation functions and achieve lower training losses faster compared to all the baselines across datasets.
Section C gives detailed proofs of Lemma 1 and the convergence rates offered by IGLU.
It is shown that under standard assumptions such as objective smoothness, IGLU is able to offer both the standard rate of convergence common for SGD-style algorithms, as well as a fast rate if full-batch GD is performed.
A A DDITIONAL I MPLEMENTATION D ETAILS
We recall from Section 4.1 that the wall-clock time reported in Figure 2 consists of strictly the optimization time for each method and excludes method-speciﬁc overheads.
This was actually a disadvantage for IGLU since its overheads are relatively mild.
This section demonstrates that other baselines incur much more signiﬁcant overheads whereas IGLU does not suffer from these large overheads.
When included, it further improves the speedups that IGLU provides over baseline methods.
A. H ARDWARE
We implement IGLU in TensorFlow 1.15.2 and perform all experiments on an NVIDIA V
GPU (32 GB Memory) and Intel Xeon CPU processor (2.6 GHz).
We ensure that all baselines are experimented with the exact same hardware.
A. T IME AND M EMORY O VERHEADS FOR V ARIOUS M ETHODS
We consider three main types of overheads that are incurred by different methods.
This includes pre-processing overhead that is one-time, recurring overheads and additional memory overhead.
We describe each of the overheads in the context of the respective methods below.
GraphSAGE - GraphSAGE recursively samples neighbors at each layer for every minibatch.
This is done on-the-ﬂy and contributes to a signiﬁcant sampling overhead.
Since this overhead is incurred for every minibatch, we categorize this under recurring overhead.
We aggregate this overhead across all minibatches during training.
GraphSAGE does not incur preprocessing or additional memory overheads.
VRGCN - Similar to GraphSAGE, VRGCN also recursively samples neighbors at each layer for every minibatch on-the-ﬂy.
We again aggregate this overhead across all minibatches during training.
VRGCN also stores the stale/historical embeddings that are learnt for every node at every layer.
This is an additional overhead of O ( NKd ) , where K is the number of layers, N is the number of nodes in the graph and d = 1 K (cid:80) k ∈
[ K ] d k is the average embedding dimensionality across layers.
ClusterGCN - ClusterGCN creates subgraphs and uses them as minibatches for training.
For the creation of these subgraphs, ClusterGCN performs graph clustering using the highly optimized METIS tool † .
This overhead is a one-time overhead since graph clustering is done before training and the same subgraphs are (re-)used during the whole training process.
We categorize this under preprocessing overhead.
ClusterGCN does not incur any recurring or additional memory overheads.
GraphSAINT - GraphSAINT, similar to ClusterGCN creates subgraphs to be used as minibatches for training.
We categorize this minibatch creation as the preprocessing overhead for GraphSAINT.
However, unlike ClusterGCN, GraphSAINT also periodically creates new subgraphs on-the-ﬂy.
We categorize this overhead incurred in creating new subgraphs as recurring overhead.
GraphSAINT does not incur any additional memory overheads.
IGLU - IGLU creates mini-batches only once using subsets of nodes with their full neighborhood information which is then reused throughout the training process.
In addition to this, IGLU requires initial values of both the incomplete gradients α α α k and the X k embeddings (Step 3 and ﬁrst part of Step 4 in Algorithm 1 and Step 2 and Step 4 in Algorithm 2) before optimization can commence.
We categorize these two overheads - mini-batch creation and initializations of ααα k ’s and X k embeddings as IGLU’s preprocessing overhead and note that IGLU does not have any recurring overheads .
IGLU does incur an additional memory
[Table] [Table]
N/A 19.2s
O ( NKd )
ClusterGCN 54.0s
N/A N/A
GraphSAINT 6.7s
N/A N/A
IGLU 3.5s (I) + 5.7s (MB)= 9.2s (T)
N/A
O ( NKd ) overhead since it needs to store the incomplete gradients ααα k ’s in the inverted variant and the embeddings X k in the backprop variant. However, note that the memory occupied by X k for a layer k is the same as that occupied by ααα k for that layer (see Deﬁnition 1). Thus, for both its variants, IGLU incurs an additional memory overhead of O ( NKd ) , where K is the number of layers, N is the number of nodes in the graph and d = 1 K (cid:80) k ∈ [ K ] d k is the average embedding dimensionality across layers.
Tables 3 and 4 report the overheads incurred by different methods on the OGBN-Proteins and Reddit datasets (the largest datasets in terms of edges and nodes respectively).
ClusterGCN runs into a runtime error on the Proteins dataset (denoted by || in the table) . N/A stands for Not Applicable in the tables. In the tables, speciﬁcally for IGLU, pre-processing time is the sum of initialization time required to pre-compute ααα k , X k and mini-batch creation time. We also report the individual overhead for both initialization and mini-batch creation for IGLU.
The total pre-processing time for IGLU is denoted by T, overheads incurred for initialization by I and overheads incurred for mini-batch creation by MB.
For IGLU, the minibatch creation code is currently implemented in Python, while GraphSAINT uses a highly optimized C++ implementation.
Speciﬁcally for the Reddit dataset, the number of subgraphs that GraphSAINT samples initially is sufﬁcient and it does not incur any recurring overhead.
However, on Proteins, GraphSAINT samples 200 subgraphs every 18 epochs, once the initially sampled subgraphs are used, leading to a sizeable recurring overhead. [Figure]
Discussion on OGBN - Proteins: Figure 5 summarizes the total overheads for all the methods.
On the OGBN-Proteins dataset, IGLU incurs ∼ 2 × less overhead than GraphSAINT, the best baseline, while incurring as much as ∼ 7 . 8 × less overhead than VRGCN and ∼ 4 .
7 × less overhead than GraphSAGE.
It is also important to note that these overheads are often quite signiﬁcant as compared to the optimization time for the methods and can add to the overall experimentation time.
For experiments on the OGBN-Proteins dataset, VRGCN’s total overheads equal 46.25% of its optimization time, GraphSAINT’s overheads equal 19.63% of its optimization time, GraphSAGE’s overhead equal 9.52% of its optimization time.
However IGLU’s total overheads equal only 5.59% of its optimization time which is the lowest out of all methods.
Upon re-computing the speedup provided by IGLU using the formula deﬁned in equation (1), but this time with overheads included, it was observed that IGLU offered an improved speedup of 16.88% (the speedup was only 11.05% when considering only optimization time).
Discussion on Reddit:
On the Reddit dataset, IGLU incurs upto ∼ 2 .
1 × less overhead than
VRGCN and upto ∼ 4 .
5 × less overhead than GraphSAGE.
However, IGLU incurs marginally higher overhead ( ∼ 1 . 4 × ) than GraphSAINT.
This can be attributed to the non-optimized minibatch creation routine currently used by IGLU compared to a highly optimized and parallelized implementation in
C++ used by GraphSAINT.
This is an immediate avenue for future work.
Nevertheless, VRGCN’s total overhead equals 15.41% of its optimization time, GraphSAINT’s overhead equals 43.41% of its optimization time, GraphSAGE’s overhead equals 31.25% of its optimization time, ClusterGCN’s overhead equals 41.02% of its optimization time while IGLU’s overhead equals 44.09% of its optimization time.
Whereas the relative overheads incurred by IGLU and GraphSAINT in comparison to optimization time may seem high for this dataset, this is because the actual optimization times for these methods are rather small, being just 15.43 and 20.86 seconds for GraphSAINT and IGLU respectively in comparison to the other methods such as VRGCN, ClusterGCN and GraphSAGE whose optimization times are 124s, 131s and 133s respectively, almost an order of magnitude larger than that of IGLU.
A. M EMORY A NALYSIS FOR IGLU
While IGLU requires storing stale variables which can have additional memory costs, for most scenarios with real world graphs, saving these stale representations on modern GPUs are quite reasonable.
We provide examples of additional memory usage required for two of the large datasets - Reddit and Proteins in Table
and we observe that IGLU requires only 150MB and 260MB of additional GPU memory.
Even for a graph with 1 million nodes, the additional memory required would only be ∼ 2.86GB which easily ﬁt on modern GPUs.
For even larger graphs, CPU-GPU interfacing can be used.
CPU and GPU interfacing for data movement is a common practice in [Table] training machine learning models and hence a potential method to mitigate the issue of limited memory availability in settings with large datasets.
This has been explored by many works for dealing with large datasets in the context of GCNs, such as VR-GCN (Chen et al., 2018a) for storing historical activations in main memory (CPU).
Such an interfacing is an immediate avenue of future work for
IGLU
[Table]
[Table]
We observe that IGLU enjoys signiﬁcant speedups and improvements in training cost across datasets as compared to the baselines as a result of using stale variables.
Additionally, since IGLU requires training just a single layer at a time, there is scope for further reduction in memory usage by using only the variables required for the current layer and by re-using the computation graphs across layers, and therefore making IGLU even less memory expensive.
A. H YPERPARAMETER C ONFIGURATIONS FOR IGLU AND BASELINES
Table 5 summarizes the source URLs and commit stamps using which baseline methods were obtained for experiments.
The Adam optimizer Kingma & Ba (2015) was used to train IGLU and all the baselines until convergence for each of the datasets.
A grid search was performed over the other hyper-parameters for each baseline which are summarized below:
GraphSAGE : Learning Rate - {0.01, 0.001}, Batch Size - {512, 1024, 2048}, Neighborhood Sampling Size - {25, 10, 5}, Aggregator - {Mean, Concat} 2.
VRGCN : Batch Size - {512, 1000, 2048}, Degree - {1, 5, 10}, Method - {CV, CVD}, Dropout - {0, 0.2, 0.5} 3.
ClusterGCN :
Learning Rate - {0.01, 0.001, 0.005}, Lambda - {-1, 1, 1e-4}, Number of Clusters - {5, 50, 500, 1000, 1500, 5000}, Batch Size - {1, 5, 50, 100, 500}, Dropout - {0, 0.1, 0.3, 0.5} 4.
GraphSAINT-RW : Aggregator - {Mean, Concat}, Normalization - {Norm, Bias}, Depth - {2, 3, 4}, Root Nodes - {1250, 2000, 3000, 4500, 6000}, Dropout - {0.0, 0.2, 0.5}
A. I NCORPORATING R ESIDUAL C ONNECTIONS , B ATCH N ORMALIZATION AND V IRTUAL N ODES IN IGLU
General-purpose techniques such as BatchNorm and skip/residual connections, and GCN-speciﬁc advancements such as bi-level aggregation using virtual nodes offer performance boosts.
The current implementation of IGLU already incorporates normalizations as described in Sections 3 and 4.
Below we demonstrate how all these aforementioned architectural variations can be incorporated into IGLU with minimal changes to Lemma 1 part 2.
Remaining guarantees such as those offered by Lemmapart 1 and Theorem 2 remain unaltered but for changes to constants.
Incorporating BatchNorm into IGLU : As pointed out in Section 3, IGLU assumes a general form of the architecture, speciﬁcally
[Equation]
where f includes the aggregation operation such as using the graph Laplacian, weight matrices and any non-linearity.
This naturally allows operations such as normalizations (LayerNorm, BatchNorm etc) to be carried out.
For instance, the f function for BatchNorm with a standard GCN would look like the following
[Equation]
where σ denotes a non-linearity like the sigmoid, Γ k ∈ R d k × d k is a diagonal matrix and βββ k ∈ R d k is a vector, and µµµ kB ,
ννν kB ∈ R d k are vectors containing the dimension-wise mean and variance values over a mini-batch B (division while computing ˆ z ki is performed element-wise).
The parameter E k is taken to collect parameters contained in all the above operations i.e. E k = (cid:8) W k , Γ k ,βββ k (cid:9) in the above example ( µµµ kB ,ννν kB are computed using samples in a mini-batch itself).
Downstream calculations in
Deﬁnition 1 and Lemma 1 continue to hold with no changes.
Incorporating Virtual Nodes into IGLU : Virtual nodes can also be seamlessly incorporated simply by re-parameterizing the layer-wise parameter E k .
We are referring to (Pei et al., 2020)
[Pei et al ICLR 2020] for this discussion.
Let R be the set of relations and let N g ( · ) , N s ( · ) denote graph neighborhood and latent-space neighborhood functions respectively.
A concrete example is given below to illustrate how virtual nodes can be incorporated.
We note that operations like BatchNorm etc can be additionally incorporated and alternate aggregation operations e.g. concatenation can be used instead.
[Equation]
where τ denotes the relationship indicator, A ij denotes the graph edge weight between nodes i and j and T ij denotes their geometric similarity in latent space.
Note that g ( k,r ) i , s ( k,r ) i corresponds to embeddings of the virtual nodes in the above example.
To implement the above, the parameter E k can be taken to collect the learnable parameters contained in all the above operations i.e. E k = (cid:8)
L kg , L ks , W k (cid:9) in the above example.
Downstream calculations in Deﬁnition 1 and Lemma 1 continue to hold as is with no changes.
Incorporating Skip/Residual Connections into IGLU :
The architecture style presented in Section 3 does not directly allow skip connections but they can be incorporated readily with no change to
Deﬁnition 1 and minor changes to Lemma 1.
Let us introduce the notation k
→ m to denote a direct forward (skip) connection directed from layer k to some layer m > k .
In a purely feed-forward style architecture, we would only have connections of the form k
→ k + 1 .
The following gives a simple example of a GCN with a connection that skips two layers, speciﬁcally ( k − 2) → k .
[Equation]
where f includes the aggregation operation with the graph Laplacian, the transformation weight matrix and any non-linearity.
Deﬁnition 1 needs no changes to incorporate such architectures.
Part 1 of Lemma 1 also needs no changes to address such cases.
Part 2 needs a simple modiﬁcation as shown below
Lemma 3 (Lemma 1.2 adapted to skip connections) .
For the ﬁnal layer, we continue to have (i.e. no change) ααα K = G ( W K +1 ) (cid:62) .
For any k < K , we have ααα k
[Equation]
Note that as per the convention established in the paper, (cid:80) m : k → m ∂ ( ααα m (cid:12) X m ) ∂X k (cid:12)(cid:12)(cid:12) all ααα m s.t. k
→ m implies that while taking the derivatives, ααα m values are ﬁxed (treated as a constant) for all m > k such that k → m .
This “conditioning” is important since ααα m also indirectly depends on X k if m > k .
Proof of Lemma 1.2 adapted to skip connections : We consider two cases yet again and use
Deﬁnition 1 that tells us that
[Equation]
Case 1 ( k = K ): Since this is the top-most layer and there are no connections going ahead let alone skipping ahead, the analysis of this case remains unchanged and continues to yield α K =
G ( W K +1 ) (cid:62) .
Case 2 ( k < K ): Using Deﬁnition 1 and incorporating all layers to which layer k has a direct or skip connection gives us
[Equation]
Rearranging the terms gives us
[Equation]
l ∈V d m (cid:88)
[Equation]
where we simply used Deﬁnition 1 in the second step.
However, the resulting term simply gives us α kjp =
(cid:80) m : k
→ m ∂ ( ααα m (cid:12) X m ) ∂X kjp (cid:12)(cid:12)(cid:12) all ααα m s.t. k
→ m which conditions on, or treats as a constant, the term ααα m for all m > k such that k
→ m according to our notation convention.
This ﬁnishes the proof of part 2 adapted to skip connections.
A. C OMPARISON OF IGLU WITH VR-GCN, MVS-GNN AND GNNA UTO S CALE
We highlight the key difference between IGLU and earlier works that cache intermediate results for speeding up GNN training below.
A.6. VRGCN V / S IGLU
Update of Cached Variables : VR-GCN (Chen et al., 2018a) caches only historical embeddings, and while processing a single mini-batch these historical embeddings are updated for a sampled subset of the nodes.
In contrast IGLU does not update any intermediate results after processing each mini-batch.
These are updated only once per epoch, after all parameters for individual layers have been updated.
Update of Model Parameters : VR-GCN’s backpropagation step involves update of model parameters of all layers after each mini-batch.
In contrast IGLU updates parameters of only a single layer at a time.
Variance due to Sampling : VR-GCN incurs additional variance due to neighborhood sampling which is then reduced by utilizing historical embeddings for some nodes and by computing exact embeddings for the others.
IGLU does not incur such variance since IGLU uses all the neighbors.
A.6. MVS-GNN V / S IGLU
MVS-GNN (Cong et al., 2020) is another work that caches historical embeddings.
It follows a nested training strategy wherein ﬁrstly a large batch of nodes are sampled and mini-batches are further created from this large batch for training.
MVS-GNN handles variance due to this mini-batch creation by performing importance weighted sampling to construct mini-batches.
Update of Cached Variables and Variance due to Sampling: Building upon VR-GCN, to reduce the variance in embeddings due to its sampling of nodes at different layers, MVS-GNN caches only embeddings and uses historical embeddings for some nodes and recompute the embeddings for the others.
Similar to VR-GCN, these historical embeddings are updated as and when they are part of the mini-batch used for training.
As discussed above, IGLU does not incur such variance since IGLU uses all the neighbors.
Update of Model Parameters: Update of model parameters in MVS-GNN is similar to that of VR-GCN, where backpropagation step involves update of model parameters of all layers for each mini-batch.
As described already, IGLU updates parameters of only a single layer at a time.
A.6. GNNA UTO S CALE V / S IGLU
GNNAutoScale (Fey et al., 2021) extends the idea of caching historical embeddings from VR-GCN and provides a scalable solution.
Update of intermediate representations and model parameters: While processing a minibatch of nodes, GNNAutoScale computes the embeddings for these nodes at each layer while using historical embeddings for the immediate neighbors outside the current minibatch.
After processing each mini-batch, GNNAutoScale updates the historical embeddings for nodes considered in the mini-batch.
Similar to VR-GCN and MVS-GNN, GNNAutoScale updates all parameters at all layers while processing a mini-batch of nodes.
In contrast IGLU does not update intermediate results (intermediate representations in Algorithm 1 and incomplete gradients in Algorithm 2) after processing each minibatch.
In fact, these are updated only once per epoch, after all parameters for individual layers have been updated.
Partitioning: GNNAutoScale relies on the METIS clustering algorithm for creating minibatches that minimize inter-connectivity across batches.
This is done to minimize access to historical embeddings and reduce staleness.
This algorithm tends to bring similar nodes together, potentially resulting in the distributions of clusters being different from the original dataset.
This may lead to biased estimates of the full gradients while training using minibatch SGD as discussed in Section 3.2, Page 5 of Cluster-GCN (Chiang et al., 2019).
IGLU does not rely on such algorithms since it’s parameter updates are concerned with only a single layer and also avoids potential additional bias.
of IGLU
with GNNAutoScale: Both of the methods avoid a neighborhood sampling step, thereby avoiding additional variance due to neighborhood sampling and making use of all the edges in the graph.
Both IGLU and GNNAutoScale propose methods to reduce the neighborhood explosion problem, although in fundamentally different manners.
GNNAutoScale does so by pruning the computation graph by using historical embeddings for neighbors across different layers.
IGLU on the other hand restricts the parameter updates to a single layer at a time by analyzing the gradient structure of GNNs therefore alleviating the neighborhood explosion problem.
A.6. S UMMARY OF IGLU’ S T ECHNICAL N OVELTY AND C ONTRAST WITH C ACHING BASED RELATED WORKS
To summarize, IGLU is fundamentally different from these methods that cache historical embeddings in that it changes the entire training procedure of GCNs in contrast with the aforementioned caching based methods as follows:
• The above methods still follow standard SGD style training of GCNs in that they update the model parameters at all the layers after each mini-batch.
This is very different from IGLU’s parameter updates that concern only a single layer while processing a mini-batch.
• IGLU can cache either incomplete gradients or embeddings which is different from the other approaches that cache only embeddings.
This provides alternate approaches for training GCNs and we demonstrate empirically that caching incomplete gradients, in fact, offers superior performance and convergence.
• Unlike GNNAutoScale and VR-GCN that update some of the historical embeddings after each mini-batch is processed, IGLU’s caching is much more aggressive and the stale variables are updated only once per epoch , after all parameters for all layers have been updated.
• Theoretically, we provide good convergence rates and bounded bias even while using stale gradients , which has not been discussed in any prior works.
These are the key technical novelties of our proposed method and they are a consequence of a careful understanding of the gradient structure of GCN’s themselves
. A.6. E MPIRICAL C OMPARISON WITH GNNA UTO S CALE
We provide an empirical comparison of IGLU with GNNAutoScale and summarize the results in
Table 7 and Figure 6.
It is important to note that the best results for GNNAutoScale as reported by the authors in the paper, correspond to varying hyperparameters such as number of GNN layers and different embedding dimensions across methods, datasets and architectures.
However, for the experiments covered in the main paper, we use 2 layer settings for PPI-Large, Flickr and Reddit andlayer settings for OGBN-Arxiv and OGBN-Proteins datasets consistently for IGLU and the baseline methods, as motivated by literature.
We also ensure that the embedding dimensions are uniform across IGLU and the baselines.
Therefore, to ensure a fair comparison, we perform additional experiments with these parameters for GNNAutoScale set to values that are consistent with our experiments for IGLU and the baselines.
We train GNNAutoScale with three variants, namely GCN,
GCNII (Chen et al., 2020) and PNA (Corso et al., 2020) and report the results for each of the variant.
We also note here that GNNAutoScale was implemented in PyTorch (Paszke et al., 2019) while
IGLU was implemented in TensorFlow (Abadi et al., 2016).
While this makes a wall-clock time comparison unsuitable as discussed in Appendix B.2, we still provide a wall-clock time comparison for completeness.
We also include the best performance numbers for GNNAutoScale on these datasets (as reported by the authors in Table 5, Page 9 of the GNNAutoScale paper) across different architectures.
Note that we do not provide comparisons on the OGBN-Proteins dataset since we ran into errors while trying to incorporate the dataset into the ofﬁcial implementation of GNNAutoScale.
Results: Figure 6 provides convergence plots comparing IGLU with the different architectures of
GNNAutoScale and Table 7 summarizes the test performance on PPI-Large, Flickr, Reddit and OGBNArxiv (transductive) datasets.
From the table, we observe that IGLU offers competitive performance compared to the GCN variant of GAS for the majority of the datasets.
We also observe from Figure 6 that IGLU offers signiﬁcant improvements in training time with rapid early convergence on the validation set.
We note that more complex architectures such as GCNII and PNA offer improvements in performance to GNNAutoScale.
IGLU being architecture agnostic can be incorporated with these architectures for further improvements in performance.
We leave this as an avenue for future work.
[Table]
[Table]
[Figure]
[Table]
[Figure] [Table] [Figure] A. D ETAILED D ESCRIPTION OF A LGORITHMS 1 AND
We present Algorithms 1 and 2 again below (as Algorithms 3 and 4 respectively) with details of each step.
IGLU: backprop order Algorithm 3 implements the IGLU algorithm in its backprop variant.
Node embeddings X k , k ∈ [ K ] are calculated and kept stale.
They are not updated even when model parameters E k , k ∈
[ K ] get updated during the epoch.
On the other hand, the incomplete task gradients ααα k , k ∈ [ K ] are kept refreshed using the recursive formulae given in Lemma 1.
For sake of simplicity, the algorithm been presented with staleness duration of one epoch i.e. X k are refreshed at the beginning of each epoch.
Variants employing shorter or longer duration of staleness can be also explored simply by updating X k , k ∈
[ K ] say twice in an epoch or else once every two epochs.
Input: GCN G , initial features X 0 , task loss L 1: Initialize model parameters E k , k ∈ [ K ] , W K + 2: for epoch = 1 , 2 , . . .
do 3: for k = 1 . . .
K do 4:
Refresh X k ← f ( X k − 1 ; E k ) //
X k will be kept stale till next epoch 5: end for 6: ˆ Y ← X K W K + // Predictions 7:
G ← (cid:104) ∂(cid:96)
i ∂ ˆ y ic (cid:105) N × C //
The loss derivative matrix 8:
Compute ∂ L ∂W K +1 ← ( X K ) (cid:62) G //
Using Lemma 1.1 here 9:
Update W K +1 ← W K +1 − η · ∂ L ∂W K + 10:
Refresh ααα K ← G ( W K +1 ) (cid:62) //
Using Lemma 1.2 here 11: for k = K . . .
2 do 12:
Compute ∂ L ∂E k ← ∂ ( ααα k (cid:12) X k )
∂E k (cid:12)(cid:12)(cid:12) ααα k , //
Using Lemma 1.1 here
[Table]
// Using Lemma 1.2 here 15: [Table] [Table]
IGLU: inverted order Algorithm 4 implements the IGLU algorithm in its inverted variant. Incomplete task gradients ααα k , k ∈ [ K ] are calculated once at the beginning of every epoch and kept stale. They are not updated even when node embeddings X k , k ∈ [ K ] get updated during the epoch.
On the other hand, the node embeddings X k , k ∈ [ K ] are kept refreshed.
For sake of simplicity, the algorithm been presented with staleness duration of one epoch i.e. ααα k are refreshed at the beginning of each epoch.
Variants employing shorter or longer durations of staleness can be also explored simply by updating ααα k say twice in an epoch or else once every two epochs.
This has been explored in Section 4.2 (see paragraph on "Analysis of Degrees of Staleness.").
A. OGBN-P ROTEINS : V ALIDATION PERFORMANCE AT A MINI - BATCH LEVEL
The performance analysis in the main paper was plotted at a coarse granularity of an epoch.
We refer to an epoch as one iteration of steps 6 to 18 (both inclusive) in Algorithm 4.
For a ﬁner analysis of
IGLU’s performance on the OGBN-Proteins dataset, we measure the Validation ROC-AUC at the granularity of a mini-batch.
As mentioned in the “SGD Implementation" paragraph in Page 5 below the algorithm description in the main paper, steps 14 and 18 in Algorithm 4 are implemented using mini-batch SGD.
Recall that OGBN-Proteins used a 3 layer GCN.
For the proteins dataset we have ∼ 170 mini-batches for training.
We update the parameters for each layer using all the mini-batches from the layer closest to the input to the layer closest to the output as detailed in Algorithm 4.
To generate predictions, we compute partial forward passes after the parameters of each layer is updated. We plot the validation ROC-AUC as the ﬁrst epoch progresses in Figure 7. We observe that when the layer closest to the input is trained (Layer 1 in the ﬁgure), IGLU has an ROC-AUC close to 0.5 on the validation set. Subsequently once the second layer (Layer 2 in the ﬁgure) is trained, we observe that the validation ROC-AUC improves from around ∼ 0.51 to ∼ 0.57 and ﬁnally once the layer closest to the output is trained (Layer 3 in the ﬁgure), the ROC-AUC progresses quickly to a high validation
ROC-AUC of ∼ 0.81.
In the ﬁgure in the main paper the high validation score reﬂects the result at the end of the ﬁrst epoch.
Training the GCN using a total of ∼ 510 minibatches ( ∼ 170 per layer) approximately takes 5 seconds as depicted in Figure 2 in the main paper.
Input: GCN G , initial features X 0 , task loss L 1: Initialize model parameters E k , k ∈ [ K ] , W K + 2: for k = 1 . . .
K do 3:
X k ← f ( X k − 1 ; E k ) //
Do an initial forward pass 4: end for 5: for epoch
= 1 , 2 , . . .
do 6: ˆ Y ← X K W K +
Predictions 7:
G ← (cid:104) ∂(cid:96)
i ∂ ˆ y ic (cid:105) N × C //
The loss derivative matrix // Use Lemma 1.2 to refresh ααα k , k ∈
[ K ] .
Refresh ααα K ← G ( W K +1 ) (cid:62) 9: for k = K . . .
2 do 10:
Refresh ααα k − 1 ← ∂ ( ααα k (cid:12) X k ) ∂X k − 1 (cid:12)(cid:12)(cid:12) ααα k 11: end for //
These ααα k , k ∈
[ K ] will now be kept stale till next epoch 12: for k = 1 . . .
K do 13:
Compute ∂ L ∂E k ← ∂ ( ααα k (cid:12) X k )
∂E k (cid:12)(cid:12)(cid:12) ααα k , //
Using Lemma 1.1 here 14:
Update E k ← E k − η · ∂ L ∂E k 15:
Refresh X k ← f ( X k − 1 ; E k ) 16: end for 17:
Compute ∂ L ∂W K +1 ← ( X K ) (cid:62) G //
Using Lemma 1.1 here 18:
Update W K +1 ← W K +1 − η ·
[Figure]
19: end for
[Figure]
We depict the
Validation granularity
We observe that the Validation ROC-AUC begins with a value close to 0.5 and quickly reaches an
ROC-AUC of 0.81 by the end of the ﬁrst epoch.
As mentioned in the text, Proteins uses a 3 layer
GCN and each layer processes ∼ 170 mini-batches.
B D ATASET S TATISTICS AND A DDITIONAL E XPERIMENTAL R ESULTS B. D ATASET S TATISTICS
Table 8 provides details on the benchmark node classiﬁcation datasets used in the experiments.
The following ﬁve benchmark datasets were used to empirically demonstrate the effectiveness of
IGLU: predicting the communities to which different posts belong in Reddit ‡ (Hamilton et al., 2017), classifying protein functions across various biological protein-protein interaction graphs in ‡ http://snap.stanford.edu/graphsage/reddit.zip [Table] [Table]
[Table]
[Table] [Table] [Table] [Table]
B. C OMPARISON WITH ADDITIONAL B ASELINES
In addition to the baselines mentioned in Table [Table] Table 9 compares IGLU to LADIES (Zou et al., 2019), L2-GCN
(You et al., 2020), AS-GCN (Huang et al., 2018), MVS-GNN (Cong et al., 2020),
FastGCN
(Chen et al., 2018b), SIGN (Frasca et al., 2020), PPRGo (Bojchevski et al., 2020) and Bandit
Sampler’s (Liu et al., 2020) performance on the test set.
However, a wall-clock time comparison with these methods is not provided since the author implementations of LADIES, L2GCN, MVS-GNN and
SIGN are in PyTorch (Paszke et al., 2019) which has been shown to be less efﬁcient than Tensorﬂow (Chiang et al., 2019; Abadi et al., 2016) for GCN applications.
Also, the ofﬁcial AS-GCN, FastGCN and Bandit Sampler implementations released by the authors were for 2 layer models only, whereas some datasets such as Proteins and Arxiv require 3 layer models for experimentation.
Attempts to generalize the code to a 3 layer model ran into runtime errors, hence the missing results are denoted by ** in Table 9 and these methods are not considered for a timing analysis.
MVS-GNN also runs into a runtime error on the Proteins dataset denoted by ||.
IGLU continues to signiﬁcantly outperform all additional baselines on all the datasets.
[Table]
[Table]
B. T IMING A NALYSIS FOR SCALING TO MORE LAYERS
To compare the scalability and performance of different algorithms for deeper models
[Table]
models with 2, 3 and 4 layers were trained for IGLU and the baseline methods. IGLU was observed to offer a
[Table]
[Table]
epoch time that scaled roughly linearly with the number of layers as well as offer the highest gain in test performance as the number of layers was increased .
B.3. P ER E POCH T RAINING T IME
Unlike neighbor sampling methods like VRGCN and GraphSAGE, IGLU does not suffer from the neighborhood explosion problem as the number of layers increases, since IGLU updates involve only a single layer at any given time.
We note that GraphSAINT and ClusterGCN also do not suffer from the neighborhood explosion problem directly since they both operate by creating GCNs on subgraphs.
However, these methods may be compelled to select large subgraphs or else suffer from poor convergence.
To demonstrate IGLU’s effectiveness in solving the neighborhood explosion problem, the per-epoch training times are summarized as a function of the number of layers in Table 10 on the Proteins dataset.
A comparison with ClusterGCN could not be provided as since it ran into runtime errors on this dataset.
In Table 10, while going from 2 to 4 layers, GraphSAINT was observed to require ∼ 1 .
6 × more time per epoch while IGLU required ∼ 2 .
3 × more time per epoch, with both methods scaling almost linearly with respect to number of layers as expected.
However, GraphSAGE suffered a ∼ 62 × increase in time taken per epoch in this case, suffering from the neighborhood explosion problem.
VRGCN ran into a run-time error for the 4 layer setting (denoted by || in Table 10).
Nevertheless, even while going from 2 layers to 3 layers, VRGCN and GraphSAGE are clearly seen to suffer from the neighborhood explosion problem, resulting in an increase in training time per epoch of almost ∼ 9 .
4 × and ∼ 5 .
6 × respectively.
[Figure] We note that the times for GraphSAINT in Table 10 are signiﬁcantly smaller than those of IGLU even though earlier discussion reported IGLU as having the fastest convergence.
However, there is no contradiction – GraphSAINT operates with very large subgraphs, with each subgraph having almost 10 % of the nodes of the entire training graph ( ∼ 10000 nodes in a minibatch), while IGLU operates with minibatches of size 512, resulting in IGLU performing a lot more gradient updates within an epoch, as compared with GraphSAINT.
Consequently, IGLU also takes fewer epochs to converge to a better solution than GraphSAINT , thus compensating for the differences in time taken per epoch.
B.3. T EST C ONVERGENCE AUC
This section explores the effect of increasing the number of layers on convergence rate, optimization time, and ﬁnal accuracy, when scaling to larger number of layers.
To jointly estimate the efﬁciency of a method in terms of wall clock time and test performance achieved, the area under the test convergence plots (AUTC) for various methods was computed.
A method that converged rapidly and that too to better performance levels would have a higher AUTC than a method that converges to suboptimal values or else converges very slowly.
To fairly time all methods, each method was offered time that was triple of the time it took the best method to reach its highest validation score.
Deﬁning the cut-off time this way ensures that methods that may not have rapid early convergence still get a fair chance to improve by having better ﬁnal performance, while also simultaneously penalizing methods that may have rapid early convergence but poor ﬁnal performance.
We rescale the wall clock time to be between 0 and 1, where 0 refers to the start of training while 1 refers to the cut-off time.
Results: Figure 8 summarizes the AUTC values.
IGLU consistently obtains higher AUC values than all methods for all number of layers demonstrating its stability, rapid convergence during early phases of training and ability to generalize better as compared to other baselines.
GraphSAGE suffered from neighborhood explosion leading to increased training times and hence decreased AUC values as the number of layers increase.
VR-GCN also suffered from the same issue, and additionally ran into a run-time error for 4 layer models.
Test Performance with Increasing Layers: Table 11 summarizes the ﬁnal test performances for different methods, across different number of layers.
The performance for some methods is inconsistent as the depth increases whereas IGLU consistently outperforms all the baselines in this case as well with gains in performance as we increase the number of layers hence making it an attractive technique to train deeper GCN models .
B. S CALABILITY TO L ARGER D ATASETS : OGBN - P RODUCTS
To demonstrate the ability of IGLU to scale to very large datasets [Table] we performed experiments on the
OGBN-Products dataset (Hu et al., 2020), one of the largest datasets in the OGB collection, with its statistics summarized in Table 12. [Table] [Table]
To demonstrate scalability
[Table]
we conducted experiments in the transductive setup since this setup involves using the full graph.
In addition
[Table]
this was the original setup in which the dataset was benchmarked, therefore allowing for a direct comparison with the baselines (results taken from
Table 4 in OGB (Hu et al., 2020) and Table 6 in SIGN (Frasca et al., 2020)).
We summarize the performance results in the Table 13, reporting Micro-F1 as the metric.
We however do not provide timing comparisons with the baseline methods since IGLU is implemented in TensorFlow while the baselines in the original benchmark Hu et al.
(2020) are implemented in PyTorch.
This therefore renders a direct comparison of wall-clock time unsuitable.
Please refer to Appendix B.2 for more details.
We observe that IGLU is able to scale to the OGBN-Products dataset with over 2.4 million nodes and outperforms all of the baseline methods.
B. A PPLICABILITY OF IGLU IN THE TRANSDUCTIVE SETTING : OGBN-A RXIV AND OGBN-P ROTEINS
In addition to the results in the inductive setting reported in the main paper, we perform additional experiments on the OGBN-Arxiv and OGBN-Proteins dataset in the transductive setting to demonstrate
IGLU’s applicability across inductive and transductive tasks and compare the performance of IGLU to that of transductive baseline methods in Table 14 (results taken from OGB (Hu et al., 2020)).
[Table]
We observe that even in the transductive setting, IGLU outperforms the baseline methods on both the
OGBN-Arxiv and OGBN-Proteins datasets.
B. A RCHITECTURE AGNOSTIC NATURE OF IGLU
To demonstrate the applicability of IGLU to a wide-variety of architectures, we perform experiments on IGLU with Graph Attention Networks (GAT) (Veliˇckovi´c et al., 2018), GCN (Kipf & Welling, 2017) and GraphSAGE (Hamilton et al., 2017) based architectures and summarize the results for the same in Table 15 and 16 respectively as compared to these baseline methods.
We use the Cora,
Citeseer and Pubmed datasets as originally used in Veliˇckovi´c et al.
(2018) for comparison with the
GAT based architecture and the OGBN-Arxiv dataset for comparison with GCN and GraphSAGE based architectures (baseline results as originally reported in (Hu et al., 2020)). [Table]
[Table] We observe that the IGLU+GAT, IGLU+GCN and IGLU+GraphSAGE outperforms the baseline methods across datasets, thereby demonstrating the architecture agnostic nature of IGLU.
B. E XPERIMENTS U SING A S MOOTH A CTIVATION F UNCTION : GELU
To understand the effect of using non-smooth vs smooth activation functions on IGLU, we perform experiments using the GELU (Hendrycks & Gimpel, 2020) activation function which is a smooth function and in-line with the objective smoothness assumptions made in Theorem 2.
[Equation]
We compare the performance of IGLU using ReLU and GELU on all the 5 datasets in the main paper and summarize the results in Table 17.
[Table]
We observe that IGLU is able to enjoy very similar performance across both GELU and ReLU as the activation functions, thereby justifying the practicality of our smoothness assumptions.
B. A NALYSIS ON D EGREE OF S TALENESS : B ACKPROP O RDER OF U PDATES
To understand the effect of more frequent updates in the backprop variant, we performed additional experiments using the backprop variant on the PPI-Large dataset and varied the frequency of updates, the results of which are reported in Table 18 for a single run.
We ﬁx the hyperparameters and train for 200 epochs.
We observe that more frequent updates help stabilize training better.
We also observe that update frequencies 1 and 2 perform competitively, and both signiﬁcantly outperform update frequency 0.5.
[Table]
However we note that with higher update frequency, we incur an additional computational cost since we need to re-compute embeddings more frequently.
We believe that both improved stability and competitive performance can be attributed to the fresher embeddings, which are otherwise kept stale within an epoch in this order of updates.
The experiment with frequency 0.5 has a slower convergence and comparatively poor performance as expected
[Figure]
B.
[Figure]
Figure 9 provides train loss curves for all datasets and methods in Table 1.
IGLU is able to achieve a lower training loss faster compared to all the baselines across datasets.
C T HEORETICAL P ROOFS
In this section we provide a formal restatement of Theorem 2 as well as its proof.
We also provide the proof of Lemma 1 below.
C. P ROOF FOR L EMMA
Proof of Lemma 1 We consider the two parts of Lemma 1 separately and consider two cases while proving each part.
For each part, Case 1 pertains to the ﬁnal layer and Case 2 considers intermediate layers.
Clariﬁcation about some Notation in the statements of Deﬁnition 1 and Lemma 1 : The notation ∂ ( G (cid:12) ˆ Y ) ∂X kjp (cid:12)(cid:12)(cid:12) G is meant to denote the partial derivative w.r.t X kjp but while keeping G ﬁxed i.e. treated as a constant or being “conditioned upon” (indeed both G and ˆ Y depend on X kjp but the deﬁnition keeps G ﬁxed while taking derivatives).
Similarly, in Lemma 1 part 1, ααα k is ﬁxed (treated as a constant) in the derivative in the deﬁnition of ∂ L /∂E k and in part 2, ααα k +1 is ﬁxed (treated as a constant) in the derivative in the deﬁnition of ααα k .
Recalling some Notation for sake of completeness : We recall that x ki is the k -th layer embedding of node i .
y i is the C -dimensional ground-truth label vector for node
i and ˆ y
i is the C -dimensional predicted score vector for node i .
K is total number of layers in the GCN.
L i denotes the loss on the i -th node and L denotes the total loss summed over all nodes.
d k is the embedding dimensionality after the k -th layer.
Proof of Lemma 1.1 We analyze two cases
Case 1 ( k = K i.e. ﬁnal layer): Recall that the predictions for node i are obtained as ˆ y i
=
( W K +1 ) (cid:62) x
Ki .
Thus we have
[Equation]
Now, ∂ L i ∂
ˆ y
ic =
g ic by deﬁnition.
If we let w K +1 c denote the c -th column of the d k × C matrix W K +1 , then it is clear that ˆ y ic depends only on w K +1 c and x K i .
Thus, we have
[Equation]
where e c is the c -th canonical vector in C -dimensions with 1 at the c -th coordinate and 0 everywhere else.
This gives us
[Equation]
Case 2 ( k < K i.e. intermediate layers):
We recall that X k stacks all k -th layer embeddings as an
N × d k matrix and X k = f
( X k − 1 ; E k ) where E k denotes the parameters (weights, offsets, scales) of the k-th layer.
Thus we have
[Equation]
As before, ∂ L ∂ ˆ y ic = g ic by deﬁnition and we have
[Equation]
This gives us
[Equation]
where we used the deﬁnition of α kjp in the second step and used a “conditional” notation to get the third step.
We reiterate that ∂ ( ααα k (cid:12) X k ) ∂E
k (cid:12)(cid:12)(cid:12) ααα k implies that ααα k is ﬁxed (treated as a constant) while taking the derivative.
This “conditioning” is critical since ααα k also depends on E k .
This concludes the proof.
Proof of Lemma 1.2 : We consider two cases yet again and use Deﬁnition 1 that tells us that
[Equation]
Case 1 ( k = K ): Since ˆ y i =
( W K +1 ) (cid:62) x
Ki , we know that ˆ y ic depends only on x Ki and w K +1 c where as before, w K +1 c is the c -th column of the matrix W K +1 .
This gives us ∂ ˆ y ic ∂X Kjp =
if i (cid:54) = j and
[Equation]
=
[Equation]
Kpc if i = j where w Kpc is the ( p, c ) -th entry of the matrix W K +1 (or in other words, the p -th coordinate of the vector w K +1 c ). This tells us that
[Equation]
which gives us ααα K
= G ( W K +1 ) (cid:62) .
Case 2 ( k < K ):
By Deﬁnition 1 we have
[Equation]
Rearranging the terms gives us
[Equation]
where we simply used Deﬁnition 1 in the second step.
However, the resulting term is simply
[Equation]
which conditions on, or treats as a constant, the term ααα k +
according to our notation convention.
This ﬁnishes the proof of part 2.
C. S TATEMENT OF C ONVERGENCE G UARANTEE
The rate for full-batch updates, as derived below, is O (cid:16) 1 T 23 (cid:17) .
This fast rate offered by full-batch updates is asymptotically superior to the O (cid:16) 1 √ T (cid:17) rate offered by mini-batch SGD updates.
This is due to the additional variance due to mini-batch construction that mini-batch SGD variants have to incur.
Theorem 4 (IGLU Convergence (Final)) .
Suppose the task loss function L has H -smooth and an architecture that offers bounded gradients and Lipschitz gradients as quantiﬁed below, then if IGLU in its inverted variant (Algorithm 2) is executed with step length η and a staleness count of τ updates per layer as in steps 7, 10 in Algorithm 2, then within T iterations, we must have
(cid:107)∇L(cid:107) 22 ≤ O (cid:16) 1 /T 23 (cid:17) if model update steps are carried out on the entire graph in a full-batch with step length η
= O (cid:16) 1 /T 13 (cid:17) and τ = O (1) .
(cid:107)∇L(cid:107) 22 ≤ O (cid:16) 1 / √ T (cid:17) if model update steps are carried out using mini-batch SGD with step length η
= O (cid:16) 1 / √ T (cid:17) and τ = O (cid:16) T 1 4 (cid:17) .
It is curious that the above result predicts that when using mini-batch SGD, a non-trivial amount of staleness ( τ = O (cid:16) T 14 (cid:17) as per the above result) may be optimal and premature refreshing of embeddings/incomplete gradients may be suboptimal as was also seen in experiments reported in
Table 2 and Figure 4.
Our overall proof strategy is the following
Step 1 : Analyze how lazy updates in IGLU affect model gradients 2.
Step 2 : Bound the bias in model gradients in terms of staleness due to the lazy updates 3.
Step 3 :
Using various properties such as smoothness and boundedness of gradients, obtain an upper bound for the bias in the gradients in terms of number of iterations since last update 4.
Step 4 : Use the above to establish the convergence guarantee
We will show the results for the variant of IGLU that uses the inverted order of updates as given in
Algorithm 2.
A similar proof technique will also work for the variant that uses the backprop order of updates.
Also, to avoid clutter, we will from hereon assume that a normalized total loss function is used for training i.e. L = 1 N (cid:80) i ∈V (cid:96) i where N = |V| is the number of nodes in the training graph.
C. S TEP 1: P ARTIAL S TALENESS AND ITS E FFECT ON M ODEL G RADIENTS
A peculiarity of the inverted order of updates is that the embeddings X k , k ∈
[ K ] are never stale in this variant.
To see this, we use a simple inductive argument.
The base case of X 0 is obvious – it is never stale since it is never meant to be updated.
For the inductive case, notice how, the moment any parameter E k is updated in step 7 of Algorithm 2 (whether by mini-batch SGD or by full-batch GD), immediately thereafter in step 8 of the algorithm, X k is updated using the current value of X k −and E k .
Since by induction X k − 1 never has a stale value, this shows that X k is never stale either, completing the inductive argument.
This has an interesting consequence: by Lemma 1, we have ∂ L ∂E k
= 1 N ∂ ( ααα k (cid:12) X k )
∂E k (cid:12)(cid:12)(cid:12) ααα k (notice the additional 1 /N term since we are using a normalized total loss function now).
However, as ∂ ( ααα k (cid:12) X k ) ∂E k (cid:12)(cid:12)(cid:12) ααα k is completely deﬁned given E k ,ααα k and X k − 1 and by the above argument, X k − 1 never has a stale value.
This shows that the only source of staleness in ∂ L ∂E k is the staleness in values of the incomplete task gradient ααα k .
Similarly, it is easy to see that the only source of staleness in
[Equation]
=
[Equation]
G is the staleness in G .
The above argument is easily mirrored for the backprop order of updates where an inductive argument similar to the one used to argue above that X k values are never stale in the inverted update variant, would show that the incomplete task gradient ααα k values are never stale in the backprop variant and the only source of staleness in ∂ L ∂E k would then be the staleness in the X k values.
C. S TEP 2: R ELATING THE B IAS IN M ODEL G RADIENTS TO S TALENESS
The above argument allows us to bound the bias in model gradients as a result of lazy updates.
To avoid clutter, we will present the arguments with respect to the E k parameter.
Similar arguments would hold for the W K +1 parameter as well.
Let ˜ ααα k ,ααα k denote the stale and actual values of the incomplete task gradient relevant to E k .
Let (cid:102) ∂
L ∂E k
= ∂
(˜ ααα k (cid:12) X k ) ∂E k (cid:12)(cid:12)(cid:12) ˜
ααα k be the stale gradients used by
IGLU in its inverted variant to update E k and similarly let ∂ L ∂E k
= ∂ ( ααα k (cid:12) X k ) ∂E
k (cid:12)(cid:12)(cid:12) ααα k be the true gradient that could have been used had there been no staleness.
We will abuse notation and let the vectorized forms of these incomplete task gradients be denoted by the same symbols i.e. we stretch the matrix ααα k ∈ R N × d k into a long vector denoted also by ααα k ∈ R N · d k .
Let dim( E k ) denote the number of dimensions in the model parameter E k (recall that
E k can be a stand-in for weight matrices, layer norm parameters etc used in layer k of the GCN).
Similarly, we let Z kjp ∈ R dim( E k ) , j ∈ [ N ] ,
p ∈
[ d k ] denote the vectorized form of the gradient ∂X kip ∂E k and let Z k ∈ R N · d k × dim( E k ) denote the matrix with all these vectors Z kjp stacked up.
As per the above notation, it is easy to see that the vectorized form of the model gradient is given by
[Equation]
The 1 /N term appears since we are using a normalized total loss function.
This also tells us that
[Equation]
where σ max ( Z k ) is the largest singular value of the matrix Z k .
C. S TEP 3: S MOOTHNESS AND B OUNDED G RADIENTS TO B OUND G RADIENT B IAS
The above discussion shows how to bound the bias in gradients in terms of staleness in the incomplete task gradients.
However, to utilize this relation, we assume that the loss function L is
H -smooth which is a standard assumption in literature.
We will also assume that the network offers bounded gradients.
Speciﬁcally, for all values of model parameters E k , k ∈ [ K ] , W K +1 we have [Table]
[Table] [Table] ∂X k +1 ∂X k (cid:13)(cid:13)(cid:13) 2 , (cid:13)(cid:13)
ααα k (cid:13)(cid:13) 2 ≤ B .
For sake of simplicity, we will also assume the same bound on parameters e.g. (cid:13)(cid:13) W K (cid:13)(cid:13) 2 ≤ B .
Assuming bounded gradients and bounded parameters is also standard in literature.
However, whereas works such as Chen et al.
(2018a) assume bounds on the sup-norm i.e. L ∞ norm of the gradients, our proofs only require an L 2 norm bound.
We will now show that if the model parameters ˜ E k , k ∈
[ K ] , ˜ W K +1 undergo gradient updates to their new values E k , k ∈
[ K ] , W K +1 and the amount of travel is bounded by r > 0 i.e. (cid:13)(cid:13)(cid:13) ˜
E k − E k (cid:13)(cid:13)(cid:13) 2 ≤ r , then we have (cid:13)(cid:13)(cid:13)
˜
ααα k − ααα k (cid:13)(cid:13)(cid:13) 2 ≤ I k · r where ˜ ααα k ,ααα k are the incomplete task gradients corresponding to respectively old and new model parameter values
and I k depends on various quantities such as the smoothness parameter and the number of layers in the network.
Lemma 1 (part 2) tells us that for the ﬁnal layer, we have ααα K =
G ( W K +1 )
(cid:62) as well as for any k < K , we have ααα k = ∂
( ααα k +1 (cid:12) X k +1 )
∂X k (cid:12)(cid:12)(cid:12) ααα
k +1 .
We analyze this using an inductive argument.
Case 1: k = K (Base Case):
In this case we have
[Equation]
Now , the travel condition
tells us that
(cid:13)(cid:13)(cid:13)
˜ W K +1 − W K +1 (cid:13)(cid:13)(cid:13) ≤ r boundedness tells us that (cid:107) G (cid:107) 2 , (cid:13)(cid:13)(cid:13)
˜ W K +1 (cid:13)(cid:13)(cid:13) 2 ≤ B .
Also, since the loss function is H -smooth, the task gradients are H -Lipschitz which implies along with the travel condition that (cid:13)(cid:13)(cid:13)
˜ G − G (cid:13)(cid:13)(cid:13) 2 ≤ H · r .
Put together this tells us that
[Equation]
telling us that I K ≤ ( H + 1) B . 2.
Case 2: k < K (Inductive Case):
In this case, let ˜ X k and X k denote the embeddings with respect to the old and new parameters respectively.
Then we have
[Equation]
˜ ααα k + − ∂ ( ααα k +1 (cid:12)
X k +1 )
∂X k (cid:12)(cid:12)(cid:12)(cid:12) ααα k + = ∂
(˜ ααα k +1 (cid:12) ˜
X k +1 )
∂ ˜ X k (cid:12)(cid:12)(cid:12)(cid:12)(cid:12) ˜ ααα k + − ∂
( ααα k +1 (cid:12) ˜
X k +1 )
∂
{+˜ X k (cid:12)(cid:12)(cid:12)(cid:12)(cid:12) ααα k +
+}
(cid:124) (cid:123)(cid:122) (cid:125) ( P )
+
∂ ( ααα k +1 (cid:12) ˜
X k +1 )
∂ ˜ X k (cid:12) (cid:12)(cid:12)(cid:12)(cid:12)
ααα k + − ∂
( ααα k +1 (cid:12) X k +1 ) ∂X k (cid:12)(cid:12)(cid:12)(cid:12) ααα k + (cid:124) (cid:123)(cid:122) (cid:125) ( Q ) By induction we have (cid:13)(cid:13)(cid:13) ˜
ααα k +1 − ααα k +
(cid:13)(cid:13)(cid:13) 2 ≤ I k +1 · r and bounded gradients tells us (cid:13)(cid:13)(cid:13) ∂
˜ X k +1 ∂
˜ X k (cid:13)(cid:13)(cid:13) 2 ≤ B giving us (cid:107) ( P ) (cid:107) 2 ≤
I k +1 B · r .
To analyze the term (cid:107) ( Q ) (cid:107) 2 , recall that we have X k
+1 =
f
( X k ; E k +1 )
and since the overall task loss is H smooth, so must be the function f .
Abusing notation to let H denote the Lipschitz constant of the network gives us (cid:13) (cid:13) (cid:13) ˜
X k − X k (cid:13) (cid:13) (cid:13) 2 ≤ H · r .
Then we have ∂ ( ˜ X k +1 )
[Equation]
Applying smoothness, we have (cid:107) ( M ) (cid:107) 2 ≤ H 2 · r as well as (cid:107) ( N ) (cid:107) 2 ≤ H · r .
Together with bounded gradients that gives us (cid:13)(cid:13)
ααα k +1 (cid:13)(cid:13)
2 ≤ B , we have (cid:107) ( Q ) (cid:107) 2 ≤ BH ( H + 1) · r .
Together, we have
[Equation]
telling us that
I k ≤ B ( H ( H + 1) + I k +1 ) .
The above tells us that in Algorithm 2, suppose the parameter update steps i.e. step 7 and stepare executed by effecting τ mini-batch SGD steps or else τ full-batch GD steps each time, with step length η , then the amount of travel in any model parameter is bounded above by τηB i.e.
(cid:13)(cid:13)(cid:13) ˜
E k − E k (cid:13)(cid:13)(cid:13) 2 ≤ τηB and so on.
Now, incomplete task gradients ααα k are updated only after model parameters for all layers have been updated once and the algorithm loops back to step 6.
Thus,
Lipschitzness of the gradients tells us that the staleness in the incomplete task gradients, for any k ∈ [ K ] , is upper bounded by
[Equation]
where we take I = max k ≤ K I k for sake of simplicity.
Now, since (cid:13)(cid:13)(cid:13)(cid:13) ∂X kip ∂E k
[Equation]
≤ B as gradients are bounded, we have σ max ( Z k ) ≤ N · d k B .
Then, combining with the result in Equation (2) gives us
[Equation]
Taking in contributions of gradients of all layers and the ﬁnal classiﬁer layer gives us the bias in the total gradient using triangle inequality as
[Equation]
where d max = max k ∈ K
d k is the maximum embedding dimensionality of any layer.
[Equation]
Let us analyze convergence in the case when updates are made using mini-batch SGD in steps 7, 10 of Algorithm 2.
The discussion above establishes an upper bound on the absolute bias in the gradients.
However, our proofs later require a relative bound which we tackle now.
Let us decide to set the step length to η = 1 C √ T for some constant C > 0 that will be decided later and also set some value φ < 1 .
Then two cases arise
Case 1 : The relative gradient bias is too large i.e. τη · IB 2 d max ( K + 1) > φ · [Equation]
In this case we are actually done since we get
[Equation]
i
e. we are already at an approximate ﬁrst-order stationary point.
Case 2 : The relative gradient bias is small i.e. τη · IB 2 d max ( K + 1) ≤ φ · (cid:107)∇L(cid:107) 2 .
In this case we satisfy the relative bias bound required by Lemma (part 2) with δ = φ .
This shows that either Case 1 happens in which case we are done or else Case 2 keeps applying which means that Lemma 5 (part 2) keeps getting its prerequisites satisﬁed.
If Case 1 does not happen for T steps, then Lemma 5 (part 2) assures us that we will arrive at a point where
[Equation]
where L 0 , L ∗ are respectively the initial and optimal values of the loss function which we recall is H -smooth and σ 2 is the variance due to mini-batch creation and we set η = 1 C √ T .
Setting
C = [Equation]
∗ ) tells us that within T steps, either we will achieve
[Equation]
or else we will achieve
[Equation]
Setting τ =
[Equation]
[Equation]
balances the two quantities in terms of their dependence on T (module absolute constants such as φ ).
Note that as expected, as the quantities I, B, d max , K increase, the above limit on τ goes down i.e. we are able to perform fewer and fewer updates to the model parameters before a refresh is required.
This concludes the proof of Theorem 4 for the second case.
C. S TEP 4 ( II ): C ONVERGENCE G UARANTEE ( FULL - BATCH GD)
In this case we similarly have either the relative gradient bias to be too large in which case we get
[Equation]
or else we satisfy the relative bias bound required by Lemma 5 (part 1) with δ = φ .
This shows that either Case 1 happens in which case we are done or else Case 2 keeps applying which means that
Lemma 5 (part 1) keeps getting its prerequisites satisﬁed.
If Case 1 does not happen for T steps, then
Lemma 5 (part 1) assures us that we will arrive at a point where
[Equation]
In this case, for a given value of τ , setting η = (cid:16)
[Equation]
13 gives us that within T iterations, we must achieve
[Equation]
In this case, it is prudent to set τ = O (1) so as to not deteriorate the convergence rate.
This concludes the proof of Theorem 4 for the ﬁrst case.
C. G ENERIC C ONVERGENCE R ESULTS
Lemma 5 (First-order Stationarity with a Smooth Objective) .
Let f : ΘΘΘ → R be an H -smooth objective over model parameters θ ∈ ΘΘΘ that is being optimized using a gradient oracle and the following update for step length η :
[Equation]
Let θθθ ∗ be an optimal point i.e. θθθ ∗ ∈ arg min θθθ ∈ ΘΘΘ f ( θθθ ) .
Then, the following results hold depending on the nature of the gradient oracle:
If a non-stochastic gradient oracle with bounded bias is used i e. for some δ ∈ (0 , 1) , for all t , we have g t = ∇ f
( θθθ t ) +∆∆∆ t where (cid:107) ∆∆∆ t (cid:107) 2 ≤ δ · (cid:107)∇ f ( θθθ t ) (cid:107)
and if the step length satisﬁes η ≤ (1 − δ ) 2 H (1+ δ 2 ) , then for any T > 0 , for some t ≤ T we must have
[Equation]
If a stochastic gradient oracle is used with bounded bias i.e. for some δ ∈ (0 , 1) , for all t , we have E [ | g t θθθ t ] = ∇ f ( θθθ t ) + ∆∆∆ t where (cid:107) ∆∆∆ t (cid:107) 2 ≤ δ · (cid:107)∇ f ( θθθ t ) (cid:107) 2 , as well as bounded variance i.e. for all t , we have E (cid:104) | (cid:107) g t − ∇ f [Equation]
−
[Equation]
t (cid:107) [-2 
 θ θ θ-]22 θθθ t (cid:105) ≤ σ 2 and if the step length satisﬁes η ≤
[Equation] 2 H (1+ δ 2 ) , as well as η = [Equation] √ T for some C > 0 , then for any T >
[Equation]
for some t ≤ T we must have
[Equation]
Proof (of Lemma 5).
To prove the ﬁrst part, we notice that smoothness of the objective gives us
[Equation]
Since we used the update θθθ t +1 =
θθθ t − η · g t
and we have g t = ∇ f
( θθθ t ) + ∆∆∆ t , the above gives us
[Equation]
Now, the Cauchy-Schwartz inequality along with the bound on the bias gives us − η ·(cid:104)∇ f ( θθθ t ) , ∆∆∆ t (cid:105) ≤ ηδ · (cid:107)∇ f ( θθθ t ) (cid:107) 22 as well as (cid:107)∇ f
[Equation]
[Equation]
f
[Equation]
θθθ t ) (cid:107) 22 .
Using these gives us
[Equation]
since we chose η ≤ [Equation] 2 H (1+ δ 2 ) .
Reorganizing, taking a telescopic sum over all t , using f ( θθθ T +1 ) ≥ f ( θθθ ∗ ) and making an averaging argument tells us that since we set , for any T > 0 , it must be the case that for some t ≤ T , we have
[Equation]
This proves the ﬁrst part.
For the second part, we yet again invoke smoothness to get
[Equation]
Since we used the update θθθ t +1 =
θθθ t − η · g t , the above gives us
[Equation]
Taking conditional expectations on both sides gives us
E
[Equation]
|
[Equation]
[Equation]
≤
[Equation] ∇ [Equation] Now, the Cauchy-Schwartz inequality along with the bound on the bias gives us − η ·(cid:104)∇ f ( θθθ t ) , ∆∆∆ t (cid:105) ≤ ηδ · (cid:107)∇ f ( θθθ t ) (cid:107) 22 as well as (cid:107)∇ f ( θθθ t ) + ∆∆∆ t (cid:107) 22 ≤ 2(1 + δ 2 ) · (cid:107)∇ f ( θθθ t ) (cid:107) 22 .
Using these and applying a total expectation gives us
[Equation]
[Equation] where the second step follows since we set η ≤ [Equation] −
[Equation] 1+ [Equation] Reorganizing, taking a telescopic sum over all t , using f ( θθθ T +1 ) ≥ f ( θθθ ∗ ) and making an averaging argument tells us that for any T > 0 , it must be the case that for some t ≤ T , we have
[Equation]
However, since we also took care to set η = [Equation] T , we get
[Equation]
which proves the second part and ﬁnishes the proof.