R ECYCLING M ODEL U PDATES IN F EDERATED L EARNING : A RE G RADIENT S UBSPACES L OW -R ANK ?
Anonymous authors
Paper under double-blind review
A BSTRACT
In this paper, we question the rationale behind propagating large numbers of parameters through a distributed system during federated learning.
We start by examining the rank characteristics of the subspace spanned by gradients across epochs (i.e., the gradient-space) in centralized model training, and observe that this gradient-space often consists of a few leading principal components accounting for an overwhelming majority ( 95 − 99% ) of the explained variance.
Motivated by this, we propose the "Look-back Gradient Multiplier" ( LBGM ) algorithm, which exploits this low-rank property to enable gradient recycling between model update rounds of federated learning, reducing transmissions of large parameters to single scalars for aggregation.
We analytically characterize the convergence behavior of LBGM , revealing the nature of the trade-off between communication savings and model performance.
Our subsequent experimental results demonstrate the improvement
LBGM obtains in communication overhead compared to conventional federated learning on several datasets and deep learning models.
Additionally, we show that
LBGM is a general plug-and-play algorithm that can be used standalone or stacked on top of existing sparsiﬁcation techniques for distributed model training.
I NTRODUCTION
Federated Learning (FL) (Koneˇcn ` y et al., 2016) has emerged as a popular distributed machine learning (ML) paradigm.
By having each device conduct local model updates, FL substitutes raw data transmissions with model parameter transmissions, promoting data privacy (Shokri & Shmatikov, 2015; Azam et al., 2021) and communication savings (Wang et al., 2020a).
At the same time, overparameterized neural networks (NN) are becoming ubiquitous in the ML models trained by
FL, e.g., in computer vision (Liu et al., 2016; Huang et al., 2017) and natural language processing (Brown et al., 2020; Liu et al., 2019a).
While NNs can have parameters in the range of a few million (VGG (Simonyan & Zisserman, 2014), ResNet (He et al., 2016)) to several billions (GPT- (Brown et al., 2020), Turing NLG (tur, 2020)), prior works have demonstrated that a majority of these parameters are often irrelevant (Frankle & Carbin, 2019; Liu et al., 2019b; Han et al., 2015; Li et al., 2017) in optimization and inference.
This presents an opportunity to reduce communication overhead by transmitting lighter representations of the model, conventionally achieved through compression/sparsiﬁcation techniques (Wang et al., 2018;
Alistarh et al., 2017; Vogels et al., 2019).
In this work, we investigate the “overparameterization” of NN training, through the lens of rank characteristics of the subspace spanned by the gradients (i.e., the gradient-space) generated during stochastic gradient descent (SGD).
We start with the fundamental question: can we observe the effect of overparameterization in NN optimization directly through the principal components analysis (PCA) of the gradients generated during SGD-based training?
And if so: can this property be used to reduce communication overhead in FL?
Our main hypothesis is that the subspaces spanned by gradients generated across SGD epochs are low-rank.
( H1)
This leads us to propose a technique that instead of propagating a million/billion-dimensional vector (i.e., gradient) over the system in each iteration of FL only requires propagating a single scalar in the majority of the iterations.
Our algorithm introduces a new class of techniques based on the concept of reusing/recycling device gradients over time.
Our main contributions can be summarized as follows:
• We demonstrate the low-rank characteristics of the gradient-space by directly studying its principal components for several NN models trained on various real-world datasets.
We show that
[Figure]
principal gradient directions (i.e., directions of principal components of the gradient-space) can
be approximated in terms of actual gradients generated during the model training process.
• Our insights lead us to develop the “Look-back Gradient Multiplier” ( LBGM ) algorithm to signiﬁcantly reduce the communication overhead in FL. LBGM recycles previously transmitted gradients to represent the newly-generated gradients at each device with a single scalar.
We further analytically investigate the convergence characteristics of this algorithm.
• Our experiments show the communication savings obtained via LBGM in FL both as a standalone solution and a plug-and-play method used with other gradient compression techniques, e.g., top-K. We further reveal that LBGM can be extended to distributed training, e
g., LBGM with SignSGD (Bernstein et al., 2018) substantially reduces communication overhead in multi-GPU systems.
A G RADIENT -S PACE O DYSSEY
We ﬁrst start by directly studying the principal component analysis (PCA) of the gradient-space of overparameterized NNs.
Given a centralized ML training task (e.g., classiﬁcation, regression, segmentation), we exploit principal component analysis (PCA) (Pearson, 1901) to answer the following: how many principal components explain the 99% and 95% variance (termed N 99- PCA and N 95- PCA , respectively; together N - PCA ) of all the gradients generated during model training?
We start with 4 different NN architectures: (i) fully-connected neural network (FCN), (ii) convolutional neural network (CNN), (iii) ResNet18 (He et al., 2016), and (iv) VGG19 (Simonyan &
Zisserman, 2014); trained on 2 datasets: CIFAR-10 (Krizhevsky et al., 2009) and CelebA (Liu et al., 2015), with classiﬁcation and regression tasks, respectively.
We then compute the N - PCA for each epoch by applying PCA on the set of gradients accumulated until that epoch (pseudo-code in
Algorithm 2 in Appendix D.1 ).
The results depicted in Fig.
1 agree with our hypothesis ( H1 ): both
N 99- PCA and N 95- PCA are signiﬁcantly lower than that the total number of gradients generated during model training, e.g., in Fig.
1 * the number of principal components (red and blue lines in top plots) are substantially lower (often as low as 10% of number of epochs, i.e., gradients generated) for both datasets.
In Appendix E.1 , we further ﬁnd that ( H1 ) holds in our experiments using several additional datasets: CIFAR-100 (Krizhevsky et al., 2009), MNIST (LeCun & Cortes, 2010), FMNIST (Xiao et al., 2017), CelebA (Liu et al., 2015), PascalVOC (Everingham et al., 2010), COCO (Lin et al., 2014); models: U-Net (Ronneberger et al., 2015), SVM (Cortes & Vapnik, 1995); and tasks: segmentation and regression.
Note that (especially on CIFAR-10) variations in N - PCA across models are not necessarily related to the model performance (CNN performs almost as well as ResNet18 but has much lower N - PCA ; Fig. 1 – columns 2 & 3) or complexity (CNN has more parameters than FCN but has lower N - PCA ; Fig. 1 – columns 1 & 2).
The fact that rank deﬁciency of the gradient-space is not a consequence of model complexity or performance suggests that the gradient-space of state-of-the-art large-scale ML models could be represented using a few principal gradient directions (PGD).
N-PCA and FL.
In an “ideal” FL framework, if both the server and the workers/devices have the PGDs, then the newly generated gradients can be transmitted by sharing their projections on the PGDs, i.e., the PGD multipliers (PGM).
PGMs and PGDs can together be used to reconstruct the device generated gradients at the server, dramatically reducing communication costs.
However, this setting is impractical since: (i) it is infeasible to obtain the PGDs prior to the training, and (ii) PCA is computationally intensive.
We thus look for an efﬁcient online approximation of the PGDs.
Overlap of Actual Gradients and N-PCA.
To approximate PGDs, we exploit an observation made in Fig.
1 (and further in Appendix E.1): N - PCA mostly remains constant over time, suggesting that the gradients change gradually across SGD epochs.
To further investigate this, in Fig.
2 (and further in Appendix E.2)
we plot the cosine similarity between PGDs and actual gradients as a heatmap.
† We observe that (i) the similarity of actual gradients to PGDs varies gradually over time and (ii) actual gradients have a high cosine similarity with one or more PGDs.
This leads to our second hypothesis:
PGDs can be approximated using a subset of gradients generated across SGD epochs .
( H2)
Look-back Gradients.
Our observations above suggest a signiﬁcant overlap among consecutive gradients generated during SGD epochs.
This is further veriﬁed in Fig.
3 (and in Appendix E.3 ‡ ), where we plot the pairwise cosine similarity of consecutive gradients generated during SGD epochs.
For example, consider the boxes marked B1, B2, and B3 in layer 1 (L#1 in Fig. 3).
Gradients in each box can be used to approximate other gradients within the box.
Also, interestingly, the number of such boxes that can be drawn is correlated with the corresponding number of PGDs.
Based on ( H2 ), we next propose our Look-back Gradient Multiplier ( LBGM ) algorithm that utilizes a subset of actual gradients, termed “look-back gradients”, to reuse/recycle gradients transmitted in FL.
L OOK - BACK G RADIENT M ULTIPLIER M ETHODOLOGY
Federated Learning (FL) considers a system of K workers/devices indexed 1 , ..., K , as shown in
Fig.
Each worker k possesses a local dataset D k with n k = |D
k | datapoints.
The goal of the system is to minimize the global loss function F ( · ) expressed through the following problem:
[Equation]
where M is the dimension of the model θ , ω k
= n k /N , N = (cid:80)
Kk =1 n k , and F k ( θ )
=
(cid:80) d ∈D k f k ( θ ; d ) /n
k is the local loss at worker k , with f k ( θ ; d ) denoting the loss function for data sample d given parameter vector θ .
FL tackles (1) via engaging the workers in local SGD model training on their own datasets.
The local models are periodically transferred to and aggregated at the main server after τ local updates, forming a global model that is used to synchronize the workers before starting the next round of local model training.
At the start of round t , each model parameter θ ( t, 0) k is initialized with the global model θ ( t ) .
Thereafter, worker k updates its parameters θ ( t,b ) k as: θ ( t,b +1)
k ← θ ( t,b ) k − η g k ( θ ( t,b ) k ) , where g k ( θ ( t,b ) k ) is the stochastic gradient at local step b , and η is the step size.
During a vanilla FL aggregation, the global model parameters are updated as θ ( t +1) ← θ ( t ) − η (cid:80)
Kk =1 ω k g ( t ) k , where g ( t ) k
= (cid:80) τ − 1 b =
g k ( θ ( t,b ) k ) is the accumulated stochastic gradient (ASG) at worker k .
More generally, this aggregation may be conducted over a subset of workers at time t .
We deﬁne ∇ F k ( θ ( t ) k )
=
(cid:80) τ − 1 b =0 ∇ F k ( θ ( t,b ) k ) and d ( t ) k
= g ( t ) k /τ as the corresponding accumulated true gradient and normalized ASG, respectively.
Indexing and Notations.
In superscripts with parenthesis expressed as tuples, the ﬁrst element denotes the global aggregation round while the second element denotes the local update round, e.g., g ( t,b ) k is the gradient at worker k at global aggregation round t at local update b .
Superscripts without parenthesis denote the index for look-back gradients, e.g., (cid:96) in ρ ( t ) ,(cid:96) k deﬁned below.
LBGM Algorithm.
LBGM (see Fig. 4) consists of three main steps: (i) workers initialize and propagate their look-back gradients (LBGs) to the server; (ii) workers estimate their look-back coefﬁcients (LBCs), i.e., the scalar projection of subsequent ASGs on their LBGs, and the look-back phase (LBP), i.e., the angle between the ASG and the LBG; and (iii) workers update their LBGs and propagate them to the server if the LBP passes a threshold, otherwise they only transmit the scalar LBC.
Thus, LBGM propagates only a subset of actual gradients generated at the devices to the server.
The intermediate global aggregation steps between two LBG propagation rounds only involve transfer of a single scalar , i.e., the LBC, from each worker, instead of the entire ASG vector.
In LBGM , the local model training is conducted in the same way as vanilla FL, while model aggregations at the server are conducted via the following rule:
[Equation]
where (cid:101) g ( t ) k is the approximation of worker k ’s accumulated stochastic gradient, given by Deﬁnition 1.
Deﬁnition 1.
(Gradient Approximation in LBGM )
Given the ASG g ( t ) k , and the LBG g (cid:96)k , the gradient approximation (cid:101) g ( t ) k recovered by the server is given by:
[Equation]
g
[Equation]
for (cid:13)(cid:13)(cid:13)
[Equation]
where LBC ρ ( t ) ,(cid:96) k
= (cid:104) g ( t ) k ,
g
(cid:96)k (cid:105) (cid:14) (cid:107) g
(cid:96)k (cid:107) 2 is the projection of the accumulated gradient g ( t ) k on the LBG g (cid:96) k , and LBP α ( t ) ,(cid:96) k denotes the angle between g ( t ) k and g (cid:96) k
(see Fig. 4(a)).
,(cid:96) k
= (cid:104) g ( t ) k ,
g
(cid:96)k (cid:105) / (cid:107) g
(cid:96)k (cid:107) 2 .
9: else (cid:46) updating the LBG 10:
Send actual gradient to the server: µ ( t )
k ← g ( t ) k .
Update worker-copy of LBG: g (cid:96)k ← g ( t ) k .
12: end if Global update at the aggregation server: 13: Initialize global parameter θ (0) and broadcast it across workers.
14: for t = 0 to ( T − 1) do 15:
Receive updates from workers { µ ( t ) k } Kk =1 .
Update global parameters: θ ( t +1) ← θ ( t ) − η (cid:80)
Kk =1 ω k (cid:104) s k · µ ( t )
k
· g (cid:96)k + (1 − s k ) · µ ( t ) k
(cid:105) , where s k is an indicator function given by, s k
= (cid:40) 1 , if µ ( t ) k is a scalar 0 , otherwise, i.e., if µ ( t ) k is a vector .
Update server-copy of LBGs: g (cid:96)k ← (1 − s k ) µ ( t ) k
+ ( s k ) g (cid:96)k , ∀ k .
18: end for
LBGM initializes the LBGs g (cid:96)k with the ﬁrst actual gradients propagated by the devices at t = 1 .
For the subsequent aggregations, each worker k shares only its LBC ρ ( t ) ,(cid:96) k with the server if the value of
LBP error sin 2 ( α ( t ) ,(cid:96) k ) is below a threshold, i.e., sin 2 ( α ( t ) ,(cid:96) k )
≤ δ threshold k , where δ threshold k ∈ [0 , 1] is a tunable parameter; otherwise it updates the LBG via transmitting the entire gradient to the server.
The details of LBGM are given in Algorithm 1.
We next conduct convergence analysis for LBGM .
Assumptions: It is presumed that the local loss functions are bounded below: min θ ∈ R M F k ( θ ) >
−∞ , ∀ k .
Let (cid:107) · (cid:107) denote the 2-norm.
Our analysis uses the following standard assumptions (Wang et al., 2020a; Friedlander & Schmidt, 2012; Hosseinalipour et al., 2020; Li et al.
; Stich, 2019):
Smoothness of Local Loss Functions: Local loss function F k : R M → R , ∀ k , is β -smooth:
[Equation]
SGD Characteristics: Local gradients g k ( θ ) , ∀ k , estimated by SGD are unbiased estimators of the true gradients ∇ F k ( θ ) , and have a bounded variance σ 2 ≥ 0 ; mathematically:
[Equation]
and
[Equation]
Bounded Dissimilarity of Local Loss Functions:
For any realization of weights { ω k ≥ 0 } Kk =1 , where (cid:80) Kk =1 ω k = 1 , there exist non-negative constants Υ 2 ≥ 1 and Γ 2 ≥ 0 such that
[Equation]
Theorem 1.
(General Convergence Characteristic of LBGM )
Assume A1 , A2 , A3 , and that ηβ ≤ min (cid:8) 1 / (2 τ ) , 1 / (cid:0) τ (cid:112) 2(1 + 4Υ 2 ) (cid:1)(cid:9) .
If the threshold value in step 7 of Algorithm 1 satisﬁes the condition δ threshold k ≤ ∆ 2 / (cid:107) d ( t ) k (cid:107) 2 , ∀ k , where ∆ 2 ≥ 0 is a constant, then after T rounds of global aggregations, the performance of LBGM is characterized by the following upper bound:
[Equation]
[Table]
[Equation]
[Table]
[Equation]
Proof.
The proof is provided in Appendix A.
The condition on δ threshold k and LBP error sin 2 ( α ( t ) ,(cid:96) k ) in the above theorem implies that to have a ﬁxed bound in (3), for a ﬁxed ∆ 2 , a larger gradient norm (cid:107) d ( t )
k (cid:107) 2 is associated with a tighter condition on the LBP error sin 2 ( α ( t ) ,(cid:96) k ) and δ threshold k .
This is intuitive because a larger gradient norm corresponds to a larger estimation error when the gradient is recovered at the server for a given LBP (see Fig. 4).
In practice, since the gradient norm (cid:107) d ( t ) k (cid:107) 2 does not grow to inﬁnity during model training, the condition on LBP error in Theorem 1, i.e., sin 2 ( α ( t ) ,
[Equation]
k ) ≤ ∆ 2 / (cid:107) d
[Equation]
t ) k (cid:107) 2 , can always be satisﬁed for any ∆ 2 ≥ 0 , since transmitting actual gradients of worker k makes α ( t ) ,(cid:96) k
= 0 .
Given the general convergence behavior in Theorem 1, we next obtain a speciﬁc choice of step size and an upper bound on ∆ 2 for which LBGM approaches a stationary point of the global loss function (1).
Corollary 1.
(Convergence of LBGM to a Stationary Point)
Assuming the conditions of Theorem 1, if ∆ 2 ≤ η , where η = 1 / √ τT , then LBGM converges to a stationary point of the global loss function, with the convergence bound characterized below:
[Equation]
Proof.
The proof is provided in Appendix B.
Considering the deﬁnition of ∆ 2 in Theorem 1 and the condition imposed on it in Corollary 1, the LBP error (i.e., sin 2 ( α ( t ) ,(cid:96) k ) ) should satisfy (cid:107) d ( t ) k (cid:107) 2 sin 2 ( α ( t ) ,(cid:96) k ) ≤ η = 1 / √ τT for LBGM to reach a stationary point of the global loss.
Since (cid:107) d ( t ) k (cid:107) 2 is bounded during the model training, this condition on the LBP error can always be satisﬁed by tuning the frequency of the full (actual) gradient transmission, i e., updating the LBG as in lines 10&11 of Algorithm 1.
Speciﬁcally, since the correlation across consecutive gradients is high and drops as the gradients are sampled from distant epochs (see Fig. 3), a low value of the LBP error can be obtained via more frequent LBG transmissions to the server.
Main Takeaways from Theorem 1, Corollary and Algorithm 1:
Recovering Vanilla-FL Bound:
In (3), if the LBGs are always propagated by all the devices, we have α ( t ) ,(cid:96) k
= 0 , ∀ k , and thus ∆ 2 = 0 satisﬁes the condition on the LBP error.
Then, (3) recovers the bound for vanilla
FL (Wang et al., 2020a; Stich, 2019; Wang & Joshi, 2018).
Recovering Centralized SGD Bound: In (3), if the LBGs are always propagated by all the devices, i.e., ∆ 2 = 0 , the local dataset sizes are equal, i.e., w k = 1 /K, ∀ k , and τ = 1 , then (3) recovers the bound for centralized SGD, e.g., see Friedlander & Schmidt (2012).
Unifying Algorithm 1 and Theorem 1: The value of ∆ 2 in (3) is determined by the value of the LBP error sin 2 ( α ( t ) ,(cid:96) k ) , which is also reﬂected in step 7 of Algorithm 1.
This suggests that the performance improves when the allowable threshold on sin 2 ( α ( t ) ,(cid:96) k ) is decreased (i.e., smaller ∆ 2 ), which is the motivation behind introducing the tunable threshold δ threshold k in our algorithm.
Effect of LPB Error on Convergence: As the value of sin 2 ( α ( t ) ,(cid:96) k ) increases, the term in (3) containing ∆ 2 will start diverging (it can become the same order as the gradient (cid:107) d ( t ) k (cid:107) 2 ).
The condition in Corollary
1 on ∆ 2 avoids this scenario, achieving convergence to a stationary point.
Performance vs. Communication Overhead Trade-off: Considering step 7 of Algorithm 1, increasing the tolerable threshold on the LBP error increases the chance of transmitting a scalar (i.e., LBC) instead of the entire gradient to the server from each worker, leading to communication savings.
However, as seen in Theorem 1 and the condition on ∆ 2 in Corollary 1, the threshold on the LBP error cannot be increased arbitrarily since the LBGM may show diverging behavior.
[Figure] [Figure]
E XPERIMENTS
Model Settings.
We run experiments on several NN models and datasets.
Speciﬁcally, we consider:
S1: CNN on FMNIST, MNIST, CelebA and CIFAR-10, S2: FCN on FMNIST and MNIST, and
S3: ResNet18 on FMNIST, MNIST, CelebA, CIFAR-10 and CIFAR-100 for both independently and identically distributed (iid) and non-iid data distributions.
We present results of S1 (on non-iid data) in this section and defer the rest (including S1 on iid data and U-Net on PascalVOC) to Appendix F.
Properties Studied.
We speciﬁcally focus on four properties of LBGM : P1: the beneﬁts of gradient recycling by LBGM as a standalone algorithm , P2: the effect of δ threshold k on LBGM from Theorem 1,
P3: practical capabilities of LBGM as a general plug-and-play algorithm that can be stacked on top of other gradient compression techniques in FL training, and ﬁnally P4: generalizability of LBGM to distributed learning frameworks, e.g., multi-processor or multi-GPU ML systems.
Baselines.
For P1 and P2 , we compare LBGM with vanilla FL.
For P3 , we stack LBGM on top of top-K and ATOMO (Wang et al., 2018), two state-of-the-art techniques for sparsiﬁcation and low-rank approximation-based gradient compression, respectively.
For P4 , we stack LBGM on top of SignSGD (Bernstein et al., 2018), a state-of-the-art method in gradient compression for distributed learning.
Implementation Details.
We consider an FL system consisting of 100 workers.
We consider both the iid and non-iid data distributions among the workers.
Under the iid setting, each worker has training data from all the labels, while under the non-iid setting each worker has training data only from a subset of all labels (e.g., from 3 of 10 classes in MNIST/FMNIST).
The workers train with mini-batch sizes ranging from 128 to 512 based on the choice of dataset.
We implement LBGM with uniform δ threshold k across workers.
We also use error feedback (Karimireddy et al., 2019) as standard only if top-K sparsiﬁcation is used in the training.
The FL system is simulated using PyTorch (Paszke et al., 2019) and PySyft (Ryffel et al., 2018) and trained on a 48GB Tesla-P100 GPU with 128GB RAM.
All of our code and hyperparameters are available at https://github.com/PairML/LBGM .
Appendix C.2 details the process of hyperparameter selection for the baselines.
Complexity.
Compared to other gradient compression techniques, the processing overhead introduced by LBGM is negligible.
Considering Algorithm 1, the calculation of LBCs and LBP errors involves inner products and division of scalars, while reconstruction of LBG-based gradient approximations at the server is no more expensive than the global aggregation step: since the global aggregation step requires averaging of local model parameters, it can be combined with gradient reconstruction.
This also holds for LBGM as a plug-and-play algorithm, as top-K and ATOMO (Wang et al., 2018) introduce considerable computation overhead.
In particular, LBGM has O ( M ) complexity, where M is the dimension of the NN parameter, which is inexpensive to plug on top of top-K
( O ( M log M ) ),
ATOMO (Wang et al., 2018)
( O ( M 2 ) ), and SignSGD (Bernstein et al., 2018)
( O ( M ) ) methods.
The corresponding space complexity of LBGM for the server and devices is discussed in Appendix C.1.
LBGM as a Standalone Algorithm.
We ﬁrst evaluate the effect of gradient recycling by LBGM in
FL.
Fig.
5 depicts the accuracy/loss values (top row) and total ﬂoating point parameters transferred
[Figure]
over the system (middle row) across training epochs for δ threshold k = 0 . 2 , ∀ k on diferent datasets.
The parameters transferred indicates the communication overhead, leading to a corresponding performance vs. efﬁciency tradeoff (bottom row).
For each dataset, we observe that LBGM reduces communication overhead on the order of 10 7 ﬂoating point parameters per worker.
Similar results on other datasets and NN models are deferred to Appendix F.1.
We also consider LBGM under device sampling (see
Algorithm 3 in Appendix D.2) and present the results in Appendix F.5, which are qualitatively similar.
Effect of δ threshold k
on Accuracy vs. Communication Savings.
In Fig.
5, the drops in accuracy for the corresponding communication savings are small except for on CIFAR-10.
The 14% reduction in accuracy here is a result of the hyperparameter setting δ threshold k = 0 .
As noted in takeaway 3 in
Sec. 3, a decrease in the allowable threshold on the LBP error improves the accuracy; the effect of threshold value is controlled by changing δ threshold k values in Algorithm 1.
Thus, we can improve the accuracy by lowering δ threshold k : for δ threshold k = 0 .
05 , the accuracy drops by 4% only while still retaining a communication saving of 55% , and for δ threshold k = 0 .
01 , we get a 22% communication saving for a negligible drop in accuracy (by only 0 .
In Fig.
6, we analyze LBGM under different δ threshold k values for different datasets.
A drop in model performance can be observed as we increase δ threshold k , which is accompanied by an increase in communication savings.
This is consistent with takeaway 5 from Sec.
3, i.e., while a higher threshold requires less frequent updates of the LBGs, it reduces the convergence speed.
Refer to Appendix F.2 for additional results.
[Figure]
LBGM as a Plug-and-Play Algorithm.
For the plug-and-play setup, LBGM follows the same steps as in Algorithm 1, with the slight modiﬁcation that the output of gradient compression techniques, top-K and ATOMO, are used in place of accumulated gradients g ( t ) k and LBGs g
(cid:96)k , ∀ k .
In Fig.
7, we see that LBGM adds on top of existing communication beneﬁts of both top-K and
ATOMO, on the order of 10 6 and 10 5 ﬂoating point parameters shared per worker, respectively ( 30 − 70% savings across the datasets).
The bottom row shows the accuracy/loss improvements that can be obtained for the same number of parameters transferred.
While top-K and ATOMO compress gradients through approximation, they do not alter the underlying low-rank characteristics of the gradient-space.
LBGM exploits this property to obtain substantial communication savings on top of these algorithms.
Refer to Appendix F.3 for additional experiments.
Generalizability of LBGM to Distributed Training.
LBGM can be applied to more general distributed gradient computation settings, e.g., multi-core systems.
While heterogeneous (non-iid) data distributions are not as much of a consideration in these settings as they are in FL (since data can be transferred/allocated across nodes), there is research interest in minimizing parameter exchange among nodes to reduce communication latency.
SignSGD
(Bernstein et al., 2018) is known to reduce the communication requirements by several order of magnitude by converting ﬂoating-point parameters to sign bit communication.
In Fig.
8, we apply LBGM as a plug-and-play addition on top of SignSGD and ﬁnd that LBGM further reduces the overall bits transferred by SignSGD on the order of 10 7 bits ( 60 − 80% savings across the datasets).
Refer to Appendix F.4 for additional experiments.
R ELATED W ORK
NN Overparameterization Analysis.
Several prior works on NN overparameterization have focused on Hessian-based analysis.
Sagun et al.
(2016; 2017) divide the eigenspace of the Hessians into two parts: bulk and edges, and show that increasing network complexity only affects the bulk component.
Ghorbani et al.
(2019) argues that the existence of large isolated eigenvalues in the Hessian eigenspace is correlated with slow convergence.
Gur-Ari et al.
(2018) studies the overlap of gradients with
Hessians and shows the Hessian edge space remains invariant during training, and thus that SGD occurs in low-rank subspaces.
Gur-Ari et al.
(2018) also suggest that the edge space cardinality is equal to the number of classiﬁcation classes, which does not align with our observations in Sec. 2.
In contrast to these, our work explores the low-rank property by studying the PCA of the gradient-space directly.
Li et al.
(2021), a contemporary of ours, employs the spectral decomposition of the NN gradient space to improve centralized SGD training time.
Our methodology based on Hypothesis ( H2 ) is more suitable for FL since having the resource-constrained workers/devices execute spectral decomposition as a component of the training process would add signiﬁcant computational burden.
The partitioning of the gradient subspace has also been observed in the domain of continual learning (Chaudhry et al., 2020; Saha et al., 2020).
However, the subspace addressed in continual learning is the one spanned by gradient with respect to data samples for the ﬁnal model, which is different than the subspace we consider, i.e., the subspace of gradient updates generated during SGD epochs.
Gradient Compression.
Gradient compression techniques can be broadly categorized into (i) sparsiﬁcation (Wangni et al., 2018;
Sattler et al., 2019), (ii) quantization (Seide et al., 2014;
Alistarh et al., 2017), and (iii) low-rank approximations (Wang et al., 2018; Vogels et al., 2019; Albasyoni et al., 2020; Haddadpour et al., 2021).
Our work falls under the third category, where prior works have aimed to decompose large gradient matrices as an outer product of smaller matrices to reduce communication cost.
This idea was also proposed in Kone ˇ cn ` y et al.
(2016), one of the pioneering works in FL.
While these prior works study the low-rank property in the context of gradient compression during a single gradient transfer step, our work explores the low rank property of the gradients generated across successive gradient epochs during FL.
Existing techniques for gradient compression can also beneﬁt from employing LBGM during FL, as we show in our experiments for top-K, ATOMO, and SignSGD.
Model Compression.
Model compression techniques have also been proposed to reduce NN complexity, e.g., model distillation (Ba & Caruana, 2014; Hinton et al., 2015), model pruning (LeCun et al., 1990; Hinton et al., 2015), and parameter clustering (Son et al., 2018; Cho et al., 2021).
(Li et al., 2020) extends the lottery ticket hypothesis to the FL setting.
These methods have the potential to be employed in conjunction with LBGM to reduce the size of the LBGs stored at the server.
FL Communication Efﬁciency.
Other techniques have focused on reducing the aggregation frequency in FL.
Hosseinalipour et al.
Lin et al.
(2021) use peer-to-peer local network communication, while SloMo (Wang et al., 2020b) uses momentum to delay the global aggregations.
D ISCUSSION & C ONCLUSIONS
In this paper, we explored the effect of overparameterization in NN optimization through the PCA of the gradient-space, and employed this to optimize the accuracy vs. communication tradeoff in FL.
We proposed the LBGM algorithm, which uses our hypothesis that PGDs can be approximated using a subset of gradients generated across SGD epochs, and recycles previously generated gradients at the devices to represent the newly generated gradients.
LBGM reduces communication overhead in FL by several orders of magnitude by replacing the transmission of gradient parameter vectors with a single scalars from each device.
We theoretically characterized the convergence behavior of LBGM algorithm and experimentally substantiated our claims on several datasets and models.
Furthermore, we showed that LBGM can be extended to further reduce latency of communication in large distributed training systems by plugging LBGM on top of other gradient compression techniques.
More generally, our work gives a novel insight to designing a class of techniques based on “Look-back Gradients” that can be used in distributed machine learning systems to enhance communication savings.
Appendix Table of Contents
A Proof of Theorem
A.1 Condition on Learning Rate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
B Proof of Corollary
C Additional Discussions
C.1 LBGM Storage Considerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
C.2 Hyperparameter Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
D Additional Pseudocodes
D.1 Pseudocode for Preliminary Experiments . . . . . . . . . . . . . . . . . . . . . . . . . . . .
D.2 Pseudocode for Device
Sampling Experiments . .
E
Additional Preliminary Experiments
E.1 PCA Component Progression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
E.2 Overlap of Actual and Principal Gradient . . . . . . . . . . . . . . . . . . . . . . . . . . . .
E.3 Similarity among Consecutive Generated Gradients . . . . . . . . . . . . . . . . . . . . . . .
F Additional LBGM Experiments
F.1 LBGM as a Standalone Algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
F.2 Effect of δ threshold k on LBGM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
F.3 LBGM as a Plug-and-Play Algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
A P ROOF OF T HEOREM
We start by introducing a lemma, that is used prominently throughout the analysis that follows.
Lemma 1.
For a sequence of vectors { a i } Ni =1 , such that E (cid:2) a i | a
i − 1 , a i − 2 , · · · , a 1 (cid:3) = 0 , ∀ i ,
E 
[Equation]
N (cid:88) i =
[Equation]
(cid:13)(cid:13)(cid:13)(cid:13)(cid:13)
[Equation]
(cid:88) i =
[Equation]
(cid:104) (cid:107) a i (cid:107)
[Equation]
(cid:105)
[Equation]
( L2)
Proof.
[Equation]
Using the law of total expectation, assuming i < j , we get
[Equation]
which completes the proof.
Next, we deﬁne a few auxiliary variables that would be referenced in the proof later: as deﬁned in the main text, g ( t ) k
= (cid:80) τ
[Equation]
1 b =
g k ( θ ( t,b )
[Equation]
) is the accumulated stochastic gradient at worker k , where b ranging from 0 to τ − 1 denotes the rounds of local updates.
Using Assumption ( A2 ), error in stochastic gradient approximation g k ( θ ( t,b ) k ) can be deﬁned as (cid:15) ( t,b ) k
= g k ( θ ( t,b ) k ) − ∇ F k ( θ ( t,b ) k ) .
Consequently, we can write the stochastic gradient as g k ( θ ( t,b ) k )
[Equation]
t
[Equation]
) k where ∇ F k ( θ ( t,b ) k ) is the true gradient.
From Assumption ( A2 ) it follows that
[Equation]
We also introduce the normalized stochastic gradient d ( t ) k given by
[Equation]
where we deﬁne
Cumulative Average of the true gradient: h ( t ) k
= 1 τ
[Equation] [Equation]
Cumulative Average of the SGD error: (cid:15) ( t ) k
[Equation]
Next, we evaluate the ﬁrst and second moment of normalized SGD error, (cid:15) ( t ) k as follows
[Equation]
where (11) uses Assumption ( A2 ) and (12) uses Lemma 1.
Now we can proceed to the proof of Theorem 1.
We start with the update rule of LBGM , where a round of global update is given by
[Equation]
where (cid:101) g ( t ) k is the approximate gradient shared by worker k with the server and (cid:101) d ( t ) k is given by
[Equation]
where d (cid:96)k = g (cid:96)k /τ is the normalized stochastic gradient w.r.t.
the last LBG shared by worker k .
Also, from the trigonometric relationship shown in Fig. 4, we have,
[Equation]
Similar to d ( t ) k from (8), d (cid:96)k can be split into the cumulative average of true look-back gradient h (cid:96)k and the corresponding cumulative average of SGD error (cid:15) (cid:96)k , given by
[Equation]
[Equation]
From Assumption ( A1 ), the global loss function is β smooth, which implies:
[Equation]
[Equation]
Taking expectation over (cid:15) ( t,
[Equation]
We evaluate Z 1 as follows
[Equation]
−
[Equation]
19) where Z 1 , 1 is given by,
[Equation]
[Equation]
(cid:13)(cid:13)(cid:13)(cid:13)(cid:13) 2  
[Equation]
(20) where ( i ) follows from (16) and ( ii ) uses 2 (cid:104) a , b (cid:105)
= (cid:107) a (cid:107) 2 + (cid:107) b (cid:107) 2 − (cid:107) a − b (cid:107) 2 for any two real vectors a and b .
We next upper bound the term Z 1 , 2 (although Z 1 , 2 has a negative sign in (19), Zalso appears with a negative sign in (18) which allows us to do the upper bound) as follows
[Equation]

[Equation]
(21) where ( i ) follows from (cid:104) a, b (cid:105) ≤ (1 / 4) (cid:107) a (cid:107) 2 + (cid:107) b (cid:107) 2 (result of Cauchy-Schwartz and Young’s inequalities).
Substituting (20) and (21) back in (19), we get
[Equation]
We next bound the term Z 2 in (18) as follows
[Equation]
where Z 2 , 1 is given by,
[Equation]
(24) where ( i ) follows from (8), ( ii ) uses Jensen’s inequality: (cid:107) (cid:80)
Kk =1 ω k a k (cid:107) 2 ≤ (cid:80) Kk
=1 ω k (cid:107) a k (cid:107) 2 , s.t.
(cid:80)
Kk =1 ω k = 1 , and ( iii ) uses (12).
Plugging (24) back into (23), we get
Z 2 ≤ 2 E 
[Equation]
(cid:18) d ( t ) k − (cid:101) d ( t ) k (cid:19)(cid:13)(cid:13)(cid:13)(cid:13)(cid:13) 2   .
Substituting (22) and (25) back in (18), we get
E (cid:104) F ( θ ( t +1) )
(cid:105) − F ( θ ( t ) )
≤ − τη 4 (cid:13)(cid:13)(cid:13) ∇ F ( θ ( t ) )
(cid:13)(cid:13)(cid:13) 2 − τη 2 E   (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)
K (cid:88) k
= ω k h ( t ) k (cid:13) (cid:13)(cid:13)(cid:13)(cid:13) 2   + τη 2 E  
(cid:13)(cid:13)(cid:13)(cid:13)(cid:13) ∇ F ( θ ( t ) ) −
K (cid:88) k
= ω k h ( t ) k (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) 2   + τη E   (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)
K (cid:88) k
= ω k (cid:18)
d
( t ) k − (cid:101) d ( t ) k
(cid:19)(cid:13)(cid:13)(cid:13)(cid:13)(cid:13) 2   + τ 2 η 2 β E  
(cid:13)(cid:13)(cid:13)(cid:13)(cid:13)
K (cid:88) k
= ω k h ( t ) k (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) 2   + τη 2 βσ 2 + τ 2 η 2 β E  
(cid:13)(cid:13)(cid:13)(cid:13)(cid:13)
K (cid:88) k
= ω k (cid:18)
d
( t ) k − (cid:101) d ( t ) k
(cid:19)(cid:13)(cid:13)(cid:13)(cid:13)(cid:13) 2   =
− τη 4 (cid:13)(cid:13)(cid:13) ∇ F ( θ ( t ) )
(cid:13)(cid:13)(cid:13) 2 − τη 2 (1 − 2 τηβ ) E  
(cid:13) (cid:13)(cid:13)(cid:13)(cid:13)
K (cid:88) k
= ω k h ( t ) k (cid:13) (cid:13)(cid:13)(cid:13)(cid:13) 2   + τη 2 E  
(cid:13) (cid:13)(cid:13)(cid:13)(cid:13) ∇ F ( θ ( t ) )
−
K (cid:88) k
= ω k h ( t ) k (cid:13) (cid:13)(cid:13)(cid:13)(cid:13) 2   + τη (1 + τηβ )
E   (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)
K (cid:88) k
= ω k (cid:18)
d
( t ) k − (cid:101) d ( t ) k
(cid:19)(cid:13)(cid:13)(cid:13)(cid:13)(cid:13) 2   + τη 2 βσ 2 .
Choosing τηβ ≤ 1 / 2 , implies that − τη 2 (1 − 2 τηβ ) ≤ 0 and 1 + τηβ ≤ 3 / 2 < 2 , which results in simpliﬁcation of (26) as:
[Equation]
where ( i ) follows from Jensen’s inequality (cid:107) (cid:80)
Kk =1 ω k a k (cid:107) 2 ≤ (cid:80) Kk
=1 ω k (cid:107) a k (cid:107) 2 , s
[Equation]
t. (cid:80) Kk =1 ω k
=and θ ( t ) k
= θ ( t ) , ∀ k due to local synchronization.
Now Z 3 can be bounded as follows:
[Equation]

[Equation]

[Equation]
[Table]
[Equation]
(28) where ( i ) uses (14), ( ii ) uses LBGM deﬁnition from ( D1 ), ( iii ) uses the fact that d ( t ) k
= g (cid:96)k /τ , ( iv ) uses (cid:104) a, b (cid:105)
= (cid:107) a (cid:107)(cid:107) b (cid:107) cos( α )
[Equation]
and ( v ) follows from the condition in the theorem.
Substituting (28) back in (27), we get
[Equation]
where Z 4 is given by,
[Equation] [Equation]
Also, using the local update rule θ ( t,b ) k ← θ ( t, 0) k − η (cid:80) b − 1 s =
g k ( θ ( t,s ) k ) , where θ ( t,b ) k is the model parameter obtained at the b -th local iteration of the global round t at device k , we get:
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
where ( i ) uses Cauchy-Schwartz inequality and ( ii ) uses Lemma 1 and Cauchy-Schwartz inequality.
Also note that
[Equation]
Taking the cumulative sum of both hand sides of Z 5 from (31) over all batches, i
[Equation]
e., 1 τ (cid:80) τ − 1 b =
[Equation]
and using (32)
[Equation]
we get:
[Equation]
Furthermore, term Z 6 can be bounded as follows:
[Equation]
(34) where ( i ) uses Cauchy-Schwartz inequality and ( ii ) uses ( A1 ).
Replacing Z 6 in (33) using (34)
[Equation]
we get:
[Equation]
Note that Z 5 , which is originally deﬁned in (31), appears both in the left hand side (LHS) and right hand side (RHS) of the above expression.
Rearranging the terms in the above inequality yields:
[Equation]
Deﬁning H = 2 η 2 β 2 τ ( τ − 1) , the above inequality can be re-written to evaluate Z 4 ,
[Equation]
Taking a weighted sum from the both hand sides of the above inequality across all the workers and using ( A3 )
[Equation]
we get:
[Equation]
where ( i ) follows from ( A3 ) and θ ( t )
k
= θ ( t ) , ∀ k since computation occurs at the instance of global aggregation.
Next, plugging (38) back in (29), we get:
[Equation]
If H ≤ 1 1+2 α Υ 2 for some constant α > 1 , then it follows that
[Equation]
Choosing α = 2 we can simplify the above expression as follows:
[Equation]
Rearranging the terms in the above inequality and taking the average across all aggregation rounds from the both hand sides, yields:
[Equation]
where we used the fact that F is bounded below
[Equation]
since F k -s are presumed to be bounded below
[Equation]
and
F (cid:63) ≤ F ( θ ) , ∀ θ ∈ R M .
This completes the proof of Theorem
[Equation]
A. C ONDITION ON L EARNING R ATE
From the two conditions on the learning rate used in the analysis above
[Equation]
we have
[Equation]
We can further tighten the second constraint as,
[Equation] [Equation]
Combining the two we have,
[Equation]
B P ROOF OF C OROLLARY
Using (41) we have:
[Equation]
Next, using the assumption in the corollary statement
[Equation]
we have ∆ 2 ≤ η .
We then can upper bound the RHS of (46) to get:
[Equation]
Choosing η = (cid:113) 1 τT , we get,
[Equation]
We can write the above expression as,
[Equation]
This completes the proof for Corollary 1.
C A DDITIONAL D ISCUSSIONS C. LBGM S TORAGE C ONSIDERATIONS
As discussed in Section 3, LBGM requires both server and workers to store the last copy of the workers’ look-back gradient (LBG).
While storing a single LBG (same size as the model) at each device might be trivial since the space complexity increases by a constant factor (i.e., the space complexity increases from O ( M ) to O (2 M )
=
O ( M ) where M is the model size), storage of
LBGs at the server might require more careful considerations since it scales linearly with the number of devices (i.e., space complexity increases from O ( M ) to O ( KM ) where M is the model size and
K is the number of workers).
Thus, the storage requirements can scale beyond memory capabilities of an aggregation server for a very large scale federated learning systems.
We, therefore propose the following solutions for addressing the storage challenge:
• Storage Ofﬂoading.
In a large scale federated learning system, it is realistic to assume network hierarchy Hosseinalipour et al.
, e
g., base stations, edge servers, cloud servers, etc.
In such cases the storage burden can be ofﬂoaded and distributed across the network hierarchy where the LBGs of the devices are stored.
• LBG Compression.
If the LBGM is applied on top of existing compression techniques such as Top-K, ATOMO, etc., the size of LBGs to be stored at the server also gets compressed which reduces the storage burden.
Alternatively, we could use parameter clustering techniques (Son et al., 2018; Cho et al., 2021) to reduce LBG size at the server.
• LBG Clustering.
In a very large scale federated learning system, say with a billion workers, it’s unrealistic to assume that all the billion clients have very different LBGs given the low rank hypothesis ( H1 ) and possible local data similarities across the workers.
It should therefore be possible to cluster the LBGs at the server into a smaller number of centroids and only saving the centroids of the clusters instead of saving all the LBGs of the devices individually.
The centroids can be
broadcast across the devices to update the local version of the LBGs
. C. H YPERPARAMETER T UNING
Most of the compression/communication savings baselines operate on a tradeoff between communication savings and accuracy.
For hyperparameter selection, we ﬁrst optimize the hyperparameters for the base algorithm such that we achieve the best possible communication saving subject to constraint that accuracy does not fall off much below the corresponding vanilla federated learning approach.
For example, we optimize the value of K in top-K sparsiﬁcation by changing K in orders of 10, i.e. K = 10% , K = 1% , K = 0 .
1% , etc.
and choose the value that gives the best tradeoff between the ﬁnal model accuracy and communication savings (this value is generally around
K = 10% ).
Similarly, for ATOMO we consider rank-1, rank-2, and rank-3 approximations.
While rank-1 approximation gives better communication savings, the corresponding accuracy falls off sharply.
Rank-3 approximation gives only a marginal accuracy beneﬁt over rank-2 approximation but adds considerably more communication burden.
Thus we use rank-2 approximations in ATOMO.
In the plug-and-play evaluations, the LBGM algorithm is applied on top of the base algorithms once their hyperparameters are tuned as a ﬁnal step to show the additional beneﬁts we can attain by exploiting the low-rank characteristic of the gradient subspace.
Our chosen hyperparameters can be found in our code repository: https://github.com/PairML/LBGM .
D A DDITIONAL P SEUDOCODES D. P SEUDOCODE FOR P RELIMINARY E XPERIMENTS
In this Appendix, we provide a psuedocode for generating the preliminary experimental results in
Sec. 2.
The actual implementation of the following function calls used in the pseudocode can be found in the listed ﬁles of our code repository: https://github.com/PairML/LBGM :
• get _ num _ PCA _ components : implemented in function estimate _ optimal _ ncomponents , ﬁle: src / common / nb _ utils .
py of the repository.
In summary
, we stack the accumulated gradients over the epochs an perform singular value decomposition, after which we do the standard analysis
for estimating the number of components explaining a given amount of variance in the datasets.
Speciﬁcally, we count the number of singular values that account for the 99% and 95% of the aggregated singular values.
• get _ PCA _ components : implemented in function pca _ transform , ﬁle: src / common / nb _ utils .
py of the repository.
In summary, we stack the accumulated gradients over the epochs an perform singular value decomposition, after which we do the standard analysis for recovering the principal components explaining a given amount of variance in the datasets.
Speciﬁcally, we recover the left singular vectors corresponding the singular values that account for the 99% and 95% of the aggregated singular values.
• cosine _ similarity : implemented using functions sklearn .
preprocessing .
normalize and numpy .
dot , such that cosine _ similarity ( a , b ) = normalize ( a ) .
dot ( normalize ( b )) where a and b are numpy .
array , where normalize performs the vector normalization and dot is the standard vector dot product.
• plot _ 1 , plot _ 2 , and plot _ 3 : implemented in ﬁles src / viz / prelim _ 1 .
py , src / viz / prelim _ 2 .
py , and src / viz / prelim _ 3 .
py respectively.
B minibatches epoch 9:
Sample a minibatch of datapoints B from dataset D .
Compute g ( t,b ) =
(cid:80) d ∈B ∇ f ( θ ( t,b ) ; d ) / |B| .
Update parameter: θ ( t,b +1) ← θ ( t,b ) − η · g ( t,b ) .
Accumulate gradient: g ( t ) ← g ( t ) + g ( t,b ) .
13: end for 14:
Set θ ( t +1) ← θ ( t,B ) .
15: actual _ grads .
append ( g ( t ) )
(cid:46) append accumulated gradient to store 16:
pca95 _ store .
append ( get _ num _ PCA _ components ( actual _ grads , variance = 0 . 95 )) 17: pca99 _ store .
append ( get _ num _ PCA _ components ( actual _ grads variance = 0 . 99 )) 18: end for 19: plot _
( pca95 _ store , pca99 _ store ) (cid:46)
20: principal _ grads = get _ PCA _ components ( actual _ grads , variance = 0 . 99 ) 21: heatmap =
zeros ( len ( actual _ grads ) , len ( principal _ grads )) 22: for i = 0 to len ( actual _ grads ) − 1 do 23: for j = 0 to len ( principal _ grads ) − 1 do 24: heatmap [ i , j ] = cosine _ similarity ( actual _ grads [ i ] , principal _ grads [ j ]) 25: end for 26: end for 27: plot _ 2 ( heatmap )
(cid:46) plot overlap of actual and principal gradients 28: heatmap =
zeros ( len ( actual _ grads ) , len ( actual _ grads )) 29: for i = 0 to len ( actual _ grads ) − 1 do 30: for j = i to len ( actual _ grads ) − 1 do 31: heatmap [ i
[Table]
j ]
[Table]
heatmap [ j
[Table]
i ] = cosine _ similarity
[Table]
_ grads [ i ]
[Table]
_ grads [ j ]
[Table] [Table]
D. P SEUDOCODE FOR D EVICE S AMPLING E XPERIMENTS
The pseudocode for LBGM with device sampling is given below.
The process is largely similar to
Algorithm 1, except modiﬁcations in the global aggregation strategy.
During global aggregation the server samples a subset K (cid:48) of all the available clients and receives updates from only those clients for aggregation as shown in line 15-17 of the Algorithm 3.
In terms of the effect of sampling on the unsampled devices, as long as an unsampled device that joins at a later step of the training have a fairly good look-back gradient (i.e., its newly generated gradient are close to its look-back gradient (LBG)), there is no need for transmission of the entire parameter vector.
This would often happen in practice unless the device engages in model training after a very long period of inactivity, in which case it would need to transmit its updated LBG before engaging in LBGM communication savings.
( t,b ) k − η · g ( t,b ) k , and accumulate gradient: g ( t )
k ← g ( t ) k
+ g ( t,b ) k . 5: end for 6: Calculate the LBP error: sin 2 ( α ( t ) ,(cid:96) k ) = 1 − (cid:16) (cid:104) g
( t ) k , g (cid:96)k (cid:105) (cid:14)(cid:0) (cid:107) g
( t ) k (cid:107) ×
(cid:107) g
(cid:96)k (cid:107) (cid:1)(cid:17)7: if sin 2 ( α ( t ) ,(cid:96) k ) ≤ δ threshold k
then (cid:46) checking the LBP error 8:
Send scalar LBC to the server: µ ( t ) k ← ρ ( t ) ,(cid:96)
k
= (cid:104) g ( t ) k ,
g
(cid:96)k (cid:105) / (cid:107) g
(cid:96)k (cid:107) 2 .
9: else (cid:46) updating the LBG 10:
Send actual gradient to the server: µ ( t )
k ← g ( t ) k .
Update worker-copy of LBG: g (cid:96)k ← g ( t ) k .
12: end if Global update at the aggregation server: 13: Initialize global parameter θ (0) and broadcast it across workers.
14: for t = 0 to ( T
1) do 15: sample set of indices K (cid:48) , a random subset from the pool of devices { 1 , 2 , ..., K } .
Receive updates from workers { µ ( t ) k } k ∈ K (cid:48) .
Update
[Table]
( t ) k
(cid:105) , where s k is an indicator function given by, s k
= (cid:40) 1 , if µ ( t ) k is a scalar 0 , otherwise, i.e., if µ ( t ) k is a vector .
Update server-copy of look-back gradients (LBGs): g (cid:96)k ← (1 − s k ) µ ( t ) k
+ ( s k ) g (cid:96)k , ∀ k ∈ K (cid:48) .
19: end for
E A DDITIONAL P RELIMINARY E XPERIMENTS
We next present the additional experiments performed to test hypotheses, ( H1 ) & ( H2 ).
As mentioned in Section 2, we study the rank-characteristics of centralized training using SGD on multiple datasets:
FMNIST, MNIST, CIFAR-10, CelebA, COCO, and PascalVOC, and model architectures: CNN, FCN,
Resnet18, VGG19, and U-Net.
Section E.1 presents experiments complementary to the one presented in Fig.
1, while Section E.2 & E.3 present experiments complementary to those presented in Fig. 2, & 3, respectively.
Please follow the hyperlinks for the ease of navigating through the ﬁgures.
E. PCA C OMPONENT P ROGRESSION
Together with Fig.
1, Figs.
10-13 show that both N99-PCA and N95-PCA are signiﬁcantly lower than that the total number of gradients calculated during model training irrespective of model/dataset/learning task for multiple datasets and models which all agree with ( H1 ).
Speciﬁcally, the principal gradients (i.e., red and blue lines in the top row of the plots) are substantially lower (often as low as 10% of number of epochs, i.e., gradients generated) in these experiments.
Refer below for the details of the ﬁgures.
Fig.
9 repeats the experiment conducted in Fig.
1 on CIFAR-100 using FCN, CNN, Resnet18, & VGG19.
Fig.
10 repeats the experiment conducted in Fig.
1 on MNIST using FCN, CNN, Resnet18, & VGG19.
Fig.
11 repeats the experiment conducted in Fig.
1 on FMNIST using FCN, CNN, Resnet18, & VGG19.
Fig.
12 repeats the experiment conducted in Fig.
1 on CIFAR-10, FMNIST, and MNIST using SVM, suggesting that we can use LBGM for classic classiﬁers that are not necessary neural networks.
Fig.
13 repeats the experiment conducted in Fig.
1 on COCO, and PascalVOC using U-Net.
E. O VERLAP OF A CTUAL AND P RINCIPAL G RADIENT
Next, we perform experiments summarized in Fig.
14-35 to further validate our observation in Fig.
2: (i) cosine similarity of actual gradients with principal gradients varies gradually over time, and (ii) actual gradients have a high cosine similarity with one or more of the principal gradients.
Refer below for the details of the ﬁgures.
Each subplot is marked with #L, the layer number of the neural network, and #elem, the number of elements in each layer.
In the plots with dense heatmaps (a large number of gradients in along x and y axis) for larger models such as Fig.
14, it is harder to observe the overlap among the actual gradient and the PCA gradients.
However, we can still notice the number of prinicipal components (along y axis) is substantially lower than the total number of epochs gradients (along y axis).
A better picture of gradient overlap with other gradients can still be seen in corresponding inter-gradient overlap plot in Fig.
36, which is consistent with the corresponding PCA progression shown in Fig.
Note that the lesser number of prinicipal gradient directions (e.g., CNN in Fig.
1) implies a higher overlap among the generated gradients (e.g., CNN in Fig. 3), while a larger number of PGDs (e.g., VGG19 in Fig. 1) implies a lower overlap among generated gradients (e.g., VGG19 in Fig. 40).
Fig.
14 repeats the experiment conducted in Fig.
2 on CelebA using VGG19.
Fig.
15 repeats the experiment conducted in Fig.
2 on CelebA using Resnet18.
Fig.
16 repeats the experiment conducted in Fig.
2 on CelebA using FCN.
Fig.
17 repeats the experiment conducted in Fig.
2 on CelebA using CNN.
Fig.
18 repeats the experiment conducted in Fig.
2 on CIFAR-10 using VGG19.
Fig.
19 repeats the experiment conducted in Fig.
2 on CIFAR-10 using Resnet18.
Fig.
20 repeats the experiment conducted in Fig.
2 on CIFAR-10 using FCN.
Fig.
21 repeats the experiment conducted in Fig.
2 on CIFAR-10 using CNN.
Fig.
22 repeats the experiment conducted in Fig.
2 on CIFAR-100 using VGG19.
Fig.
23 repeats the experiment conducted in Fig.
2 on CIFAR-100 using Resnet18.
Fig.
24 repeats the experiment conducted in Fig.
2 on CIFAR-100 using FCN.
Fig.
25 repeats the experiment conducted in Fig.
2 on CIFAR-100 using CNN.
Fig.
26 repeats the experiment conducted in Fig.
2 on FMNIST using VGG19.
Fig.
27 repeats the experiment conducted in Fig.
2 on FMNIST using Resnet18.
Fig.
28 repeats the experiment conducted in Fig.
2 on FMNIST using FCN.
Fig.
29 repeats the experiment conducted in Fig.
2 on FMNIST using CNN.
Fig.
30 repeats the experiment conducted in Fig.
2 on MNIST using VGG19.
Fig.
31 repeats the experiment conducted in Fig.
2 on MNIST using Resnet18.
Fig.
32 repeats the experiment conducted in Fig.
2 on MNIST using FCN.
Fig.
33 repeats the experiment conducted in Fig.
2 on MNIST using CNN.
Fig.
34 repeats the experiment conducted in Fig.
2 on PascalVOC using U-Net. 22.
Fig.
35 repeats the experiment conducted in Fig.
2 on COCO using U-Net.
E. S IMILARITY AMONG C ONSECUTIVE G ENERATED G RADIENTS
Furthermore, we perform experiments summarized in Fig.
Together with Fig.
3, these experiments show that there is a signiﬁcant overlap of consecutive gradients generated during SGD iterations which further substantiates ( H2 ) and bolsters our main idea
that “gradients transmitted in
FL can be recycled/reused to represent the gradients generated in the subsequent iterations” .
Refer below for the details of the ﬁgures.
Fig.
36 repeats the experiment conducted in Fig.
3 on CelebA using VGG19.
Fig.
37 repeats the experiment conducted in Fig.
3 on CelebA using Resnet18.
Fig.
38 repeats the experiment conducted in Fig.
3 on CelebA using FCN.
Fig.
39 repeats the experiment conducted in Fig.
3 on CelebA using CNN.
Fig.
40 repeats the experiment conducted in Fig.
3 on CIFAR-10 using VGG19.
Fig.
41 repeats the experiment conducted in Fig.
3 on CIFAR-10 using Resnet18.
Fig.
42 repeats the experiment conducted in Fig.
3 on CIFAR-10 using FCN.
Fig.
43 repeats the experiment conducted in Fig.
3 on CIFAR-10 using CNN.
Fig.
44 repeats the experiment conducted in Fig.
3 on CIFAR-100 using VGG19.
Fig.
45 repeats the experiment conducted in Fig.
3 on CIFAR-100 using Resnet18.
Fig.
46 repeats the experiment conducted in Fig.
3 on CIFAR-100 using FCN.
Fig.
47 repeats the experiment conducted in Fig.
3 on CIFAR-100 using CNN.
Fig.
48 repeats the experiment conducted in Fig.
3 on FMNIST using VGG19.
Fig.
49 repeats the experiment conducted in Fig.
3 on FMNIST using Resnet18.
Fig.
50 repeats the experiment conducted in Fig.
3 on FMNIST using FCN.
Fig.
51 repeats the experiment conducted in Fig.
3 on FMNIST using CNN.
Fig.
52 repeats the experiment conducted in Fig.
3 on MNIST using VGG19.
Fig.
53 repeats the experiment conducted in Fig.
3 on MNIST using Resnet18.
Fig.
54 repeats the experiment conducted in Fig.
3 on MNIST using FCN.
Fig.
55 repeats the experiment conducted in Fig.
3 on MNIST using CNN.
Fig.
56 repeats the experiment conducted in Fig.
3 on PascalVOC using U-Net. 22.
Fig.
57 repeats the experiment conducted in Fig.
3 on COCO using U-Net.
F A DDITIONAL LBGM E XPERIMENTS
In this section, we present complimentary experiments to the properties studies in Section 4 of the main text.
In particular, we show that our observations hold for datasets: CIFAR-10, CIFAR-100,
CelebA, FMNIST, and MNIST.
We also present results when using shallower models FCN or deeper models Resnet18 different from CNNs.
Section F.1 gives further evidence of utility of LBGM as a standalone solution.
Section F.2 lists ﬁgures that summarize the effect of changing δ threshold k on model performance for mentioned datasets and models.
In Section F.3 we list ﬁgures that summarize additional experiments to support the observations made in Fig.
7 and Section F.4 lists ﬁgures for additional experiments corresponding to the observations made in Fig.
Finally, Section F.5 presents results on LBGM algorithm corresponding to the case wherein 50% of clients are randomly sampled during global aggregation.
Since the two layer FCN considered is a simple classiﬁer, it does not perform well on complex datasets such as CIFAR-10, CIFAR-100, and CelebA.
Thus, the respective results are omitted for FCN on these complicated datasets and the performance of FCN is only studied for MNIST and FMNIST datasets.
Similarly, the 4-layer CNN architecture does not perform well on CIFAR-100 dataset and hence the corresponding results are ommited.
We also present results using U-Net architecture for semantic segmentation on PascalVOC dataset.
F. LBGM AS A S TANDALONE A LGORITHM .
Fig.
58 shows the result of repeating the experiment conducted in Fig.
5 (CNNs on non-iid data distribution) on CNNs for iid data distribution for datasets CIFAR-10, FMNIST
and MNIST, and U-Net for segmentation for dataset PascalVOC. 2.
Fig.
59 shows the result of repeating the experiment conducted in Fig.
5 (CNNs on non-iid data distribution) on FCNs for both non-iid and iid data distributions on datasets FMNIST and MNIST.
Fig.
60 shows the result of repeating the experiment conducted in Fig.
5 (CNNs on non-iid data distribution) on Resnet18s for non-iid data distribution on datasets CelebA, CIFAR-10,
CIFAR-100, FMNIST, and MNIST using a setup similar to that of Wang et al.
F. E FFECT OF δ threshold k ON LBGM .
Fig.
61 shows the result of repeating the experiment conducted in Fig.
6 (CNNs on non-iid data distribution) on CNNs for iid data distribution for datasets CIFAR-10, FMNIST, and MNIST, and
U-Net for segmentation for dataset PascalVOC.
Fig.
62 shows the result of repeating the experiment conducted in Fig.
6 (CNNs on non-iid data distribution) on FCNs for both non-iid and iid data distributions on datasets FMNIST and MNIST.
Fig.
63 shows the result of repeating the experiment conducted in Fig.
6 (CNNs on non-iid data distribution) on Resnet18s for non-iid data distribution on datasets CelebA, CIFAR-10 and
CIFAR-100 using a setup similar to that of Wang et al.
F. LBGM AS A P LUG - AND -P LAY A LGORITHM .
Fig.
64 shows the result of repeating the experiment conducted in Fig.
7 (CNNs on non-iid data distribution) on CNNs for iid data distribution for datasets CIFAR-10, FMNIST, and MNIST.
Fig.
65 shows the result of repeating the experiment conducted in Fig.
7 (CNNs on non-iid data distribution) on FCNs for both non-iid and iid data distributions on datasets FMNIST and MNIST.
Fig.
66 shows the result of repeating the experiment conducted in Fig.
7 (CNNs on non-iid data distribution) on Resnet18s for non-iid data distribution on datasets CelebA, CIFAR-10 and
CIFAR-100 using a setup similar to that of Wang et al.
F. G ENERALIZABILITY
Fig.
67 shows the result of repeating the experiment conducted in Fig.
8 (CNNs on non-iid data distribution) on CNNs for iid data distribution for datasets CIFAR-10, FMNIST, and MNIST.
Fig.
68 shows the result of repeating the experiment conducted in Fig.
8 (CNNs on non-iid data distribution) on FCNs for both non-iid and iid data distributions on datasets FMNIST and MNIST.
Fig.
69 shows the result of repeating the experiment conducted in Fig.
8 (CNNs on non-iid data distribution) on Resnet18s for non-iid data distribution on datasets CelebA, CIFAR-10 and
CIFAR-100 using a setup similar to that of Wang et al.
F. LBGM UNDER C LIENT S AMPLING .
We present results with LBGM under client sampling in this subsection.
The results are qualitatively similar to those presented in Sec.
4 under “ LBGM as Standalone Algorithm”.
For example, our results on the MNIST dataset for 50% client participation shows a 35% and 55% improvement in communication efﬁciency for only 0 .
2% and 4% drop in accuracy for the corresponding i.i.d and non-i.i.d cases (see column 1 of Fig.
71&70 respectively).
Fig.
70 shows the result of repeating the experiment conducted in Fig.
5 (CNNs on non-iid data distribution) under 50% client sampling using CNNs for non-iid data distribution for datasets CIFAR-10, FMNIST
and MNIST
and regression for dataset CelebA. 2.
Fig.
71 shows the result of repeating the experiment conducted in Fig.
(CNNs on non-iid data distribution) under 50% client sampling using CNNs for iid data distribution for datasets CIFAR-10, FMNIST, and MNIST
[Figure]
[Figure]
[Figure]
[Figure]
[Figure]
[Figure]
[Figure]
[Figure]
[Figure] [Figure] [Figure]
[Figure] [Figure]
[Figure] [Figure]
[Figure]
[Figure]
[Figure] [Figure]