D EEP G RADIENT C OMPRESSION : R EDUCING THE C OMMUNICATION B ANDWIDTH FOR D ISTRIBUTED T RAINING
Anonymous authors
Paper under double-blind review
A BSTRACT
Large-scale distributed training requires signiﬁcant communication bandwidth for gradient exchange that limits the scalability of multi-node training, and requires expensive high-bandwidth network infrastructure.
The situation gets even worse with distributed training on mobile devices (federated learning), which suffers from higher latency, lower throughput, and intermittent poor connections.
In this paper, we ﬁnd 99.9% of the gradient exchange in distributed SGD are redundant, and propose Deep Gradient Compression (DGC) to greatly reduce the communication bandwidth.
To preserve accuracy during this compression, DGC employs four methods: momentum correction, local gradient clipping, momentum factor masking, and warm-up training.
We have applied Deep Gradient Compression to image classiﬁcation, speech recognition, and language modeling with multiple datasets including Cifar10, ImageNet, Penn Treebank, and Librispeech Corpus.
On these scenarios, Deep Gradient Compression achieves a gradient compression ratio from 270 × to 600 × without losing accuracy, cutting the gradient size of
ResNet-50 from 97MB to 0.35MB, and for DeepSpeech from 488MB to 0.74MB.
Deep gradient compression enables large-scale distributed training on inexpensive commodity 1Gbps Ethernet and facilitates distributed training on mobile.
I NTRODUCTION
Large-scale distributed training improves the productivity of training deeper and larger models (Chilimbi et al., 2014;
Xing et al., 2015; Moritz et al., 2015; Zinkevich et al., 2010).
Synchronous stochastic gradient descent (SGD) is widely used for distributed training.
By increasing the number of training nodes and taking advantage of data parallelism, the total computation time of the forward-backward passes on the same size training data can be dramatically reduced.
However, gradient exchange is costly and dwarfs the savings of computation time (Li et al., 2014; Wen et al., 2017), especially for recurrent neural networks (RNN) where the computation-to-communication ratio is low.
Therefore, the network bandwidth becomes a signiﬁcant bottleneck for scaling up distributed training.
This bandwidth problem gets even worse when distributed training is performed on mobile devices, such as federated learning (McMahan et al., 2016; Koneˇcn`y et al., 2016).
Training on mobile devices is appealing due to better privacy and better personalization (Google, 2017), but a critical problem is that those mobile devices suffer from even lower network bandwidth, intermittent network connections, and expensive mobile data plan.
Deep Gradient Compression (DGC) solves the communication bandwidth problem by compressing the gradients, as shown in Figure 1.
To ensure no loss of accuracy, DGC employs momentum correction and local gradient clipping on top of the gradient sparsiﬁcation to maintain model performance.
DGC also uses momentum factor masking and warmup training to overcome the staleness problem caused by reduced communication.
We empirically veriﬁed Deep Gradient Compression on a wide range of tasks, models, and datasets:
CNN for image classiﬁcation (with Cifar10 and ImageNet), RNN for language modeling (with Penn
Treebank) and speech recognition (with Librispeech Corpus).
These experiments demonstrate that gradients can be compressed up to 600 × without loss of accuracy, which is an order of magnitude higher than previous work (Aji & Heaﬁeld, 2017).
[Figure]
R ELATED W ORK
Researchers have proposed many approaches to overcome the communication bottleneck in distributed training.
For instance, asynchronous SGD accelerates the training by removing gradient synchronization and updating parameters immediately once a node has completed back-propagation (Dean et al., 2012; Recht et al., 2011; Li et al., 2014).
Gradient quantization and sparsiﬁcation to reduce communication data size are also extensively studied.
Gradient Quantization Quantizing the gradients to low-precision values can reduce the communication bandwidth.
Seide et al.
(2014) proposed 1-bit SGD to reduce gradients transfer data size and achieved 10 × speedup in traditional speech applications.
Alistarh et al.
(2016) proposed another approach called QSGD which balance the trade-off between accuracy and gradient precision.
Similar to QSGD, Wen et al.
(2017) developed TernGrad which uses 3-level gradients.
Both of these works demonstrate the convergence of quantized training, although TernGrad only examined CNNs and QSGD only examined the training loss of RNNs.
There are also attempts to quantize the entire model, including gradients.
DoReFa-Net
(Zhou et al., 2016) uses 1-bit weights with 2-bit gradients.
Gradient Sparsiﬁcation Strom (2015) proposed threshold quantization to only send gradients larger than a predeﬁned constant threshold.
However, the threshold is hard to choose in practice.
Therefore, Dryden et al.
(2016) chose a ﬁxed proportion of positive and negative gradient updates separately, and Aji & Heaﬁeld (2017) proposed Gradient Dropping to sparsify the gradients by a single threshold based on the absolute value.
To keep the convergence speed, Gradient Dropping requires adding the layer normalization(Lei Ba et al., 2016).
Gradient Dropping saves 99% of gradient exchange while incurring 0.3% loss of BLEU score on a machine translation task.
Concurrently,
Chen et al.
(2017) proposed to automatically tunes the compression rate depending on local gradient activity, and gained compression ratio around 200 × for fully-connected layers and 40 × for convolutional layers with negligible degradation of top-1 accuracy on ImageNet dataset.
Compared to the previous work, DGC pushes the gradient compression ratio to up to 600 × for the whole model (same compression ratio for all layers).
DGC does not require extra layer normalization, and thus does not need to change the model structure.
Most importantly, Deep Gradient
Compression results in no loss of accuracy.
D EEP G RADIENT C OMPRESSION 3. G RADIENT S PARSIFICATION
We reduce the communication bandwidth by sending only the important gradients (sparse update).
We use the gradient magnitude as a simple heuristics for importance: only gradients larger than a threshold are transmitted.
To avoid losing information, we accumulate the rest of the gradients locally.
Eventually, these gradients become large enough to be transmitted.
Thus, we send the large gradients immediately but eventually send all of the gradients over time, as shown in Algorithm 1.
The encode () function packs the 32-bit nonzero gradient values and 16-bit run lengths of zeros.
[Figure]
Input: init parameters w = { w [0] , w [1] , · · · , w [ M ] } 1: G k ←2: for t = 0 , 1 , · · · do 3:
G kt ← G kt − 1 4: for i = 1 , · · · , b do 5:
Sample data x from χ 6:
G kt ← G kt + 1 Nb (cid:79) f
( x ; w t ) 7: end for 8: for j = 0 , · · · , M do 9:
Select threshold: thr ← s % of (cid:12)(cid:12) G kt [ j ] (cid:12)(cid:12) 10:
Mask ← (cid:12)(cid:12) G kt [ j ] (cid:12)(cid:12) > thr 11: (cid:101) G kt
[ j ] ← G kt [ j ] (cid:12) Mask 12:
G kt [ j ] ← G kt [ j ] (cid:12) ¬ Mask 13: end for 14:
All-reduce G kt : G t ← (cid:80) Nk
=1 encode ( (cid:101) G kt ) 15: w t +1 ← SGD ( w t , G t ) 16: end for
[Figure]
The insight is that the local gradient accumulation is equivalent to increasing the batch size over time.
Let F ( w ) be the loss function which we want to optimize.
Synchronous Distributed SGD performs the following update with N training nodes in total:
[Equation]
where χ is the training dataset, w are the weights of a network, f ( x, w ) is the loss computed from samples x ∈ χ , η is the learning rate, N is the number of training nodes, and B k,t for 1 ≤ k < N is a sequence of N minibatches sampled from χ at iteration t , each of size b .
Consider the weight value w ( i ) of i -th position in ﬂattened weights w .
After T iterations, we have
[Equation]
Equation (2) shows that local gradient accumulation can be considered as increasing the batch size from Nb to NbT (the second summation over τ ), where T is the length of the sparse update interval between two iterations at which the gradient of w ( i ) is sent.
Learning rate scaling (Goyal et al., 2017) is a commonly used technique to deal with large minibatch.
It is automatically satisﬁed in Equation (2) where the T in the learning rate ηT and batch size NbT are canceled out.
3. I MPROVING THE L OCAL G RADIENT A CCUMULATION
Without care, the sparse update will greatly harm convergence when sparsity is extremely high (Chen et al., 2017).
For example, Algorithm 1 incurred more than 1.0% loss of accuracy on the
Cifar10 dataset, as shown in Figure 3(a).
We ﬁnd momentum correction and local gradient clipping can mitigate this problem.
Momentum Correction Momentum SGD is widely used in place of vanilla SGD.
However, Algorithm 1 doesn’t directly apply to SGD with the momentum term, since it ignores the discounting factor between the sparse update intervals.
Distributed training with vanilla momentum SGD on N training nodes follows (Qian, 1999),
[Equation]
where m is the momentum, N is the number of training nodes, and (cid:79) k,t = 1 Nb (cid:80) x ∈B k,t (cid:79)
f
( x, w t ) .
Consider the weight value w ( i ) of i -th position in ﬂattened weights w .
After T iterations, the change in weight value w ( i ) shows as follows,
[Equation]
Directly applying the equation (3) to the sparse gradient scenario with local gradient accumulation on node k gives:
[Equation]
where the ﬁrst term is the local gradient accumulation.
Once the accumulation result v k,t is larger than a threshold, it will pass hard thresholding in the sparse () function, and be encoded and get sent over the network in the second term.
The change in weight value w ( i ) after the sparse update interval T becomes,
[Equation]
The disappearance of the accumulated discounting factor (cid:80) T − 1 τ =
m τ in Equation (6) compared to (4) leads to the loss of convergence performance.
It is illustrated in Figure 2(a), where Equation (4) drives the optimization from point A to point B , but with local gradient accumulation, Equation (4) goes to point C .
When the gradient sparsity is high, the update interval T dramatically increases, and thus the signiﬁcant side effect will harm the model performance.
To avoid this error, we need momentum correction on top of Equation (5) to make sure the sparse update is equivalent to the dense update as in Equation (3).
If we regard the velocity u t in Equation (3) as ”gradient”, the second term of Equation (3) can be considered as the vanilla SGD for the ”gradient” u t .
The local gradient accumulation is proved to be effective for the vanilla SGD in Section 3.1.
Therefore, we can locally accumulate the velocity u t instead of the real gradient (cid:79) k,t to migrate Equation (5) to approach Equation (3):
[Equation]
where the ﬁrst two terms are the corrected local gradient accumulation, and the accumulation result v k,t is used for the subsequent sparsiﬁcation and communication.
By this simple change in the local accumulation, we can deduce the accumulated discounting factor (cid:80) T − 1 τ =
m τ in Equation (4) from
Equation (7), as shown in Figure 2(b).
We refer to this migration as the momentum correction .
It is a tweak to the update equation, it doesn’t incur any hyper parameter.
Beyond the vanilla momentum SGD, we also look into Nesterov momentum SGD in Appendix B, which is similar to momentum SGD.
Local Gradient Clipping Gradient clipping is widely adopted to avoid the exploding gradient problem (Bengio et al., 1994).
The method proposed by Pascanu et al.
(2013) rescales the gradients whenever the sum of their L2-norms exceeds a threshold.
This step is conventionally executed after gradient aggregation from all nodes.
Because we accumulate gradients over iterations on each node independently, we perform the gradient clipping locally before adding the current gradient G t to previous accumulation ( G t − 1 in Algorithm 1).
As explained in Appendix C, we scale the threshold by N − 1 / 2 , the current node’s fraction of the global threshold if all N nodes had identical gradient distributions.
In practice, we ﬁnd that the local gradient clipping behaves very similarly to the vanilla gradient clipping in training, which suggests that our assumption might be valid in real-world data.
As we will see in Section 4, momentum correction and local gradient clipping help improve the word error rate from 14.1% to 12.9% on the AN4 corpus, while training curves follow the momentum
SGD more closely.
[Table]
3. O VERCOMING THE S TALENESS E FFECT
Because we delay the update of small gradients, when these updates do occur, they are outdated or stale .
In our experiments, most of the parameters are updated every 600 to 1000 iterations when gradient sparsity is 99.9%, which is quite long compared to the number of iterations per epoch.
Staleness can slow down convergence and degrade model performance.
We mitigate staleness with momentum factor masking and warm-up training.
Momentum Factor Masking Mitliagkas et al.
(2016) discussed the staleness caused by asynchrony and attributed it to a term described as implicit momentum .
Inspired by their work, we introduce momentum factor masking , to alleviate staleness.
Instead of searching for a new momentum coefﬁcient as suggested in Mitliagkas et al.
(2016), we simply apply the same mask to both the accumulated gradients v k,t and the momentum factor u k,t in Equation (7):
[Equation]
This mask stops the momentum for delayed gradients, preventing the stale momentum from carrying the weights in the wrong direction.
Warm-up Training In the early stages of training, the network is changing rapidly, and the gradients are more diverse and aggressive.
Sparsifying gradients limits the range of variation of the model, and thus prolongs the period when the network changes dramatically.
Meanwhile, the remaining aggressive gradients from the early stage are accumulated before being chosen for the next update, and therefore they may outweigh the latest gradients and misguide the optimization direction.
The warm-up training method introduced in large minibatch training (Goyal et al., 2017) is helpful.
During the warm-up period, we use a less aggressive learning rate to slow down the changing speed of the neural network at the start of training, and also less aggressive gradient sparsity, to reduce the number of extreme gradients being delayed.
Instead of linearly ramping up the learning rate during the ﬁrst several epochs, we exponentially increase the gradient sparsity from a relatively small value to the ﬁnal value, in order to help the training adapt to the gradients of larger sparsity.
As shown in Table 1, momentum correction and local gradient clipping improve the local gradient accumulation, while the momentum factor masking and warm-up training alleviate the staleness effect.
On top of gradient sparsiﬁcation and local gradient accumulation, these four techniques make up the Deep Gradient Compression (pseudo code in Appendix D), and help push the gradient compression ratio higher while maintaining the accuracy.
[Table]
E XPERIMENTS 4. E XPERIMENT S ETTINGS
We validate our approach on three types of machine learning tasks: image classiﬁcation on Cifar and ImageNet, language modeling on Penn Treebank dataset
[Table]
and speech recognition on AN4 and
Librispeech corpus.
The only hyper-parameter introduced by Deep Gradient Compression is the warm-up training strategy.
In all experiments related to DGC, we rise the sparsity in the warm-up period as follows: 75%, 93.75%, 98.4375%, 99.6%, 99.9% (exponentially increase till 99.9%).
We evaluate the reduction in the network bandwidth by the gradient compression ratio as follows,
Gradient Compression Ratio = size (cid:2) encode (cid:0) sparse ( G k ) (cid:1)(cid:3) /size (cid:2) G k (cid:3) where G k is the gradients computed on the training node k .
Image Classiﬁcation We studied ResNet-110 on Cifar10, AlexNet and ResNet-50 on ImageNet.
Cifar10 consists of 50,000 training images and 10,000 validation images in 10 classes (Krizhevsky & Hinton, 2009), while ImageNet contains over 1 million training images and 50,000 validation images in 1000 classes (Deng et al., 2009).
We train the models with momentum SGD following the training schedule in Gross & Wilber (2016).
The warm-up period for DGC is 4 epochs out of out of 164 epochs for Cifar10 and 4 epochs 90 epochs for ImageNet Dataset.
Language Modeling The Penn Treebank corpus (PTB) dataset consists of 923,000 training, 73,000 validation and 82,000 test words (Marcus et al., 1993).
The vocabulary we select is the same as the one in Mikolov et al.
We adopt the 2-layer LSTM language model architecture with 1500 hidden units per layer (Press & Wolf, 2016), tying the weights of encoder and decoder as suggested in Inan et al.
and using vanilla SGD with gradient clipping, while learning rate decays when no improvement has been made in validation loss.
The warm-up period is 1 epoch out of 40 epochs.
Speech Recognition
The AN4 dataset contains 948 training and 130 test utterances (Acero, 1990) while Librispeech corpus contains 960 hours of reading speech (Panayotov et al., 2015).
We use
DeepSpeech architecture without n-gram language model, which is a multi-layer RNN following a stack of convolution layers (Hannun et al., 2014).
We train a 5-layer LSTM of 800 hidden units per layer for AN4, and a 7-layer GRU of 1200 hidden units per layer for LibriSpeech, with Nesterov momentum SGD and gradient clipping, while learning rate anneals every epoch.
The warm-up period for DGC is 1 epoch out of 80 epochs.
4. R ESULTS AND A NALYSIS
We ﬁrst examine Deep Gradient Compression on image classiﬁcation task.
Figure 3(a) and 3(b) are the Top-1 accuracy and training loss of ResNet-110 on Cifar10 with 4 nodes.
The gradient sparsity
[Figure]
Training
[Table]
[Figure]
[Table]
(Wen et al., 2017)
[Table] [Table]
AlexNet
[Table]
) (+
[Table] [Table]
Gradient
[Table] [Table]
[Table] [Table]
597 × Compression (+
[Table]
The learning curve of Gradient Dropping (Aji & Heaﬁeld, 2017) (red) is worse than the baseline due to gradient staleness.
With momentum correction (yellow), the learning curve converges slightly faster, and the accuracy is much closer to the baseline.
With momentum factor masking and warmup training techniques (blue), gradient staleness is eliminated, and the learning curve closely follows the baseline.
Table 2 shows the detailed accuracy.
The accuracy of ResNet-110 is fully maintained while using Deep Gradient Compression.
When scaling to the large-scale dataset, Figure 3(c) and 3(d) show the learning curve of ResNetwhen the gradient sparsity is 99.9%.
The accuracy fully matches the baseline.
An interesting observation is that the top-1 error of training with sparse gradients decreases faster than the baseline with the same training loss.
Table 3 shows the results of AlexNet and ResNet-50 training on ImageNet with 4 nodes.
We compare the gradient compression ratio with Terngrad (Wen et al., 2017) on AlexNet (ResNet is not studied in Wen et al.
Deep Gradient Compression gives 75 × better compression than Terngrad with no loss of accuracy.
For ResNet-50, the compression ratio is slightly lower (277 × vs. 597 × ) with a slight increase in accuracy.
[Figure] [Figure]
[Table]
Rate
[Table]
[Figure]
Compression
[Table]
Ratio
[Table]
clean
[Table]
other
Size
Ratio
[Table] [Table]
Gradient
[Table] [Table]
[Table] [Table]
[Table]
Compression
[Table]
For language modeling, Figure 4 shows the perplexity and training loss of the language model trained with 4 nodes when the gradient sparsity is 99.9%.
The training loss with Deep Gradient
Compression closely match the baseline, so does the validation perplexity.
From Table 4, Deep
Gradient Compression compresses the gradient by 462 × with a slight reduction in perplexity.
For speech recognition, Figure 5 shows the word error rate (WER) and training loss curve of 5-layer
LSTM on AN4 Dataset with 4 nodes when the gradient sparsity is 99.9%.
The learning curves show the same improvement acquired from techniques in Deep Gradient Compression as for the image network.
Table 4 shows word error rate (WER) performance on LibriSpeech test dataset, where test-clean contains clean speech and test-other noisy speech.
The model trained with Deep Gradient
Compression gains better recognition ability on both clean and noisy speech, even when gradients size is compressed by 608 × .
S YSTEM A NALYSIS AND P ERFORMANCE
Implementing DGC requires gradient top- k selection.
Given the target sparsity ratio of 99.9%, we need to pick the top 0.1% largest over millions of weights.
Its complexity is O ( n ) , where n is the number of the gradient elements (Cormen, 2009).
We propose to use sampling to reduce top- k selection time.
We sample only 0.1% to 1% of the gradients and perform top- k selection on the samples to estimate the threshold for the entire population.
If the number of gradients exceeding the threshold is far more than expected, a precise threshold is calculated from the already-selected
[Figure]
[Figure] [Figure]
Training Speedup
[Figure]
GPU cluster with 1Gbps Ethernet
[Figure]
cluster with 10Gbps Ethernet
[Figure]
[Figure] [Figure]
gradients.
Hierarchically calculating the threshold signiﬁcantly reduces top- k selection time.
In practice, total extra computation time is negligible compared to network communication time which is usually from hundreds of milliseconds to several seconds depending on the network bandwidth.
We use the performance model proposed in Wen et al.
(2017) to perform the scalability analysis, combining the lightweight proﬁling on single training node with the analytical communication modeling.
With the all-reduce communication model (Rabenseifner, 2004; Bruck et al., 1997), the density of sparse data doubles at every aggregation step in the worst case.
However, even considering this effect, Deep Gradient Compression still signiﬁcantly reduces the network communication time, as implied in Figure 6.
Figure 6 shows the speedup of multi-node training compared with single-node training.
Conventional training achieves much worse speedup with 1Gbps (Figure 6(a)) than 10Gbps Ethernet (Figure 6(b)).
Nonetheless, Deep Gradient Compression enables the training with 1Gbps Ethernet to be competitive with conventional training with 10Gbps Ethernet.
For instance, when training AlexNet with 64 nodes, conventional training only achieves about 30 × speedup with 10Gbps Ethernet (Apache, 2016), while with DGC, more than 40 × speedup is achieved with only 1Gbps Ethernet.
From the comparison of Figure 6(a) and 6(b), Deep Gradient Compression beneﬁts even more when the communication-to-computation ratio of the model is higher and the network bandwidth is lower.
C ONCLUSION
Deep Gradient Compression (DGC) compresses the gradient by 270-600 × for a wide range of CNNs and RNNs.
To achieve this compression without slowing down the convergence, DGC employs momentum correction, local gradient clipping, momentum factor masking and warm-up training.
We further propose hierarchical threshold selection to speed up the gradient sparsiﬁcation process.
Deep
Gradient Compression reduces the required communication bandwidth and improves the scalability of distributed training with inexpensive, commodity networking infrastructure
A S YNCHRONOUS D ISTRIBUTED S TOCHASTIC G RADIENT D ESCENT
In practice, each training node performs the forward-backward pass on different batches sampled from the training dataset with the same network model.
The gradients from all nodes are summed up to optimize their models.
By this synchronization step, models on different nodes are always the same during the training.
The aggregation step can be achieved in two ways.
One method is using the parameter servers as the intermediary which store the parameters among several servers (Dean et al., 2012).
The nodes push the gradients to the servers while the servers are waiting for the gradients from all nodes.
Once all gradients are sent, the servers update the parameters, and then all nodes pull the latest parameters from the servers.
The other method is to perform the All-reduce operation on the gradients among all nodes and to update the parameters on each node independently (Goyal et al., 2017), as shown in Algorithm 2 and Figure 7.
In this paper, we adopt the latter approach by default.
[Figure]
Input: Dataset χ
Input: minibatch size b per node
Input: the number of nodes N
Input: Optimization Function SGD
Input: Init parameters w = { w [0] , · · · , w [ M ] } 1: for t = 0 , 1 , · · · do 2:
G kt ←3: for i = 1 , · · · , B do 4:
Sample data x from χ 5:
G kt ← G kt + 1 Nb (cid:79) f
( x ; w t ) 6: end for 7:
All-reduce G kt : G t ← (cid:80) Nk
=1 G kt 8: w t +1 ← SGD ( w t , G t ) 9: end for
B G RADIENT SPARSIFICATION WITH N ESTROV MOMENTUM CORRECTION
The conventional update rule for Nesterov momentum SGD (Nesterov, 1983) follows, u t
+1 =
mu t +
N (cid:88) k
= ( (cid:79) k,t ) , w t +1 =
w t − η ( m · u t +1 + (cid:79) t ) (8) where m is the momentum, N is the number of training nodes, and (cid:79) k,t = 1 Nb (cid:80) x ∈B k,t (cid:79) f
( x, w t ) .
Before momentum correction, the sparse update follows, v k,t +
[Equation]
= v
[Equation] [Equation]
+ (cid:79) k,t , u t +1 =
mu t +
N (cid:88) k
= sparse ( v k,t +1 ) , w t +1 =
w t − ηu t + (9)
After momentum correction sharing the same methodology with Equation (7), it becomes, u k,t +1 = mu k,t + (cid:79) k,t , v k,t +1 = v k,t +( m · u k,t +1 + (cid:79) k,t ) , w t +1 =
w t − η
N (cid:88) k
= sparse ( v k,t +1 ) (10)
C L OCAL G RADIENT C LIPPING
When training the recurrent neural network with gradient clipping, we perform the gradient clipping locally before adding the current gradient G kt to previous accumulation G kt − 1 in Algorithm 1.
Denote the origin threshold for the gradients L2-norm ||
G
|| 2 as thr G , and the threshold for the local gradients L2-
Assuming all N training nodes have independent identical gradient distributions with the variance σ 2 , the sum of gradients from all nodes have the variance Nσ 2 .
Therefore,
[Equation]
Thus, We scale the threshold by N − 1 / 2 , the current node’s fraction of the global threshold,
[Equation]
D D EEP G RADIENT C OMPRESSION A LGORITHM
[Table]
¬ Mask 18:
U kt [ j ] ← U kt
[ j ] (cid:12)
¬ Mask 19: end for 20:
All-reduce : G t ← (cid:80) N k
=1 encode ( (cid:101) G kt ) 21: θ
t +1 ← SGD ( θ t , G t ) 22: end for
SGD on node
Input: dataset χ Input: minibatch size b per node
Input: momentum m Input: the number of nodes N
Input: optimization function SGD Input: initial parameters w = { w [0] , · · · , w [ M ] } 1: U k ← 0 , V k ←2: for t = 0 , 1 , · · · do 3:
G k ←4: for i = 1 , · · · , b do 5:
Sample data x from χ 6:
G kt ← G kt + 1 Nb (cid:79) f
( x ; θ t ) 7: end for 8: if Gradient Clipping then 9:
G kt ← Local Gradient Clipping ( G kt ) 10: end if 11:
U kt ← m · (cid:0) U kt − 1 + G kt (cid:1) 12:
V kt ← V kt − 1 + U kt
+ G kt 13: for j = 0 , · · · , M do 14: thr ← s % of (cid:12)(cid:12) V kt [ j ] (cid:12)(cid:12) 15:
Mask ← (cid:12)(cid:12) V kt
[ j ] (cid:12)(cid:12) > thr 16: (cid:101) G kt
[ j ] ← V kt
[ j ] (cid:12) Mask 17:
V kt
[ j ] ← V kt [ j ] (cid:12)
¬ Mask 18:
U kt [ j ] ← U kt
[ j ] (cid:12)
¬ Mask 19: end for 20:
All-reduce : G t
[Table]