Z ENO ++: R OBUST F ULLY A SYNCHRONOUS SGD
Anonymous authors
Paper under double-blind review
A BSTRACT
We propose Zeno++, a new robust asynchronous Stochastic Gradient Descent (SGD) procedure which tolerates Byzantine failures of the workers.
In contrast to previous work, Zeno++ removes some unrealistic restrictions on workerserver communications, allowing for fully asynchronous updates from anonymous workers, arbitrarily stale worker updates, and the possibility of an unbounded number of Byzantine workers.
The key idea is to estimate the descent of the loss value after the candidate gradient is applied, where large descent values indicate that the update results in optimization progress.
We prove the convergence of
Zeno++ for non-convex problems under Byzantine failures.
Experimental results show that Zeno++ outperforms existing approaches.
I NTRODUCTION
Synchronous training and asynchronous training are the two most common paradigms of distributed machine learning.
On the one hand, synchronous training requires, periodically, the global updates at the server to be blocked until all the workers respond.
In contrast, for asynchronous training, the server updates the global model immediately after a worker responds.
Theoretical and experimental analysis (Dutta et al., 2018) suggests that synchronous training is more stable with less noise, but can also be slowed down by the global barrier across all the workers.
Asynchronous training is generally faster, but needs to address instability and noisiness due to staleness.
In this paper, we focus on asynchronous training.
We study the security of distributed asynchronous Stochastic Gradient Descent (SGD) in a centralized worker-server architecture, also known as the Parameter Server (or PS) architecture.
In the PS architecture, there are server nodes and worker nodes.
When combined with an asynchronous SGD approach, each worker pulls the global model from the servers, estimates the gradients using the local portion of the training data, then sends the gradient estimates to the servers.
The servers update the model as soon as a new gradient is received from any worker.
The security of machine learning has gained increasing attention in recent years.
In particular, tolerance to Byzantine failures (Blanchard et al., 2017; Chen et al., 2017; Yin et al., 2018;
Feng et al., 2014; Su and Vaidya, 2016a;b; Xie et al., 2018b; Alistarh et al., 2018; Cao and Lai, 2018) has become an important topic in the distributed machine learning literature.
Byzantine failures are well-studied for the distributed systems (Lamport et al., 1982a).
However, in distributed machine learning, Byzantine failures have unique properties.
In brief, the goal of Byzantine workers is to prevent convergence of the model training.
By construction, Byzantine failures (Lamport et al., 1982b) assume the worst case, i.e., the Byzantine workers can behave arbitrarily.
Such failures may be caused by a variety of reasons including but not limited to: hardware/software bugs, vulnerable communication channels, poisoned datasets, or malicious attackers.
To make things worse, groups of
Byzantine workers can collude, potentially resulting in more harmful attacks.
It is also clear that as the worst case, Byzantine failures generalize benign failures such as hardware or software errors.
Unlike previous work (Damaskinos et al., 2018), we tackle Byzantine tolerance in a more general scenario.
The Byzantine tolerance of asynchronous SGD is challenging in this case because of:
• Asynchrony.
The lack of synchrony incurs additional noise for the stochastic gradients.
Such noise makes it more difﬁcult to distinguish the Byzantine gradients from the benign ones, especially as Byzantine behavior may exacerbate staleness.
• Unpredictable successive updates.
The lack of synchronous scheduling makes it possible for the server to receive updates from Byzantine workers successively.
Thus, even in the standard scenario,
where less than half of the workers are Byzantine, the server can be suffocated by successive Byzantine gradients.
• Unbounded number of Byzantine workers.
For the Byzantine tolerance in fully asynchronous training, the assumption of a bounded number of Byzantine workers is meaningless.
In Byzantinetolerant synchronous training (Blanchard et al., 2017; Chen et al., 2017; Yin et al., 2018; Xie et al., 2018b;a), the servers can compare the candidate gradients with each other, and utilize the majority assumption to ﬁlter out the harmful gradients, or use robust aggregation to bound the error.
However, such strategies are infeasible in asynchronous training, since there is nothing to compare to or aggregate.
Aggregating the successive gradients is also meaningless since the successive gradients could all be pushed by the same Byzantine worker.
Furthermore, although most of the previous work (Blanchard et al., 2017; Chen et al., 2017; Yin et al., 2018; Feng et al., 2014; Su and Vaidya, 2016a;b; Alistarh et al., 2018; Cao and Lai, 2018) assumes a majority of honest workers, this requirement is not guaranteed to be satisﬁed in practice.
The key idea of our approach is to estimate the descent of the loss value after the candidate gradient is applied to the model parameters, based on the Byzantine-tolerant synchronous SGD algorithm,
Zeno (Xie et al., 2018b).
Intuitively, if the loss value decreases, the candidate gradient is likely to result in optimization progress.
For computational efﬁciency, we also propose a lazy update.
To the best of our knowledge this paper is the ﬁrst to theoretically and empirically study Byzantinetolerant fully asynchronous SGD with anonymous workers, and potentially an unbounded number of
Byzantine workers.
In summary, our contributions are:
• We propose Zeno++, a new approach for Byzantine-tolerant fully asynchronous SGD with anonymous workers.
• We show that Zeno++ tolerates Byzantine workers without any limit on either the staleness or the number of Byzantine workers.
• We prove the convergence of Zeno++ for non-convex problems.
• Experimental results validate that 1) existing algorithms may fail in practical scenarios, and 2) Zeno++ gracefully handles such cases.
R ELATED WORK
Most of the existing Byzantine-tolerant SGD algorithms focus on synchronous training.
Chen et al.
(2017); Su and Vaidya (2016a;b); Yin et al.
; Xie et al.
(2018a) use robust statistics (Huber, 2011) including the geometric median, coordinate-wise median, and trimmed mean as Byzantinetolerant aggregation rules.
Blanchard et al.
; Mhamdi et al.
(2018) propose Krum and its variants, which select the candidates with minimal local sum of Euclidean distances.
Alistarh et al.
(2018) utilize historical information to identify harmful gradients.
Chen et al.
(2018) use coding theory and majority voting to recover correct gradients.
Most of these synchronous algorithms assume that most of the workers are non-Byzantine.
However, in practice, there are no guarantees that the number of Byzantine workers can be controlled.
Xie et al.
(2018b)
; Cao and Lai (2018) propose synchronous SGD algorithms for an unbounded number of Byzantine workers.
Recent years have witnessed an increasing number of large-scale machine learning algorithms, including asynchronous SGD (Zinkevich et al., 2009; Lian et al., 2018; Zheng et al., 2017; Zhou et al., 2018).
Damaskinos et al.
(2018) proposed Kardam, which to our knowledge is the only prior work to address Byzantine-tolerant asynchronous training.
Kardam utilizes the Lipschitzness of the gradients to ﬁlter out outliers.
However, Kardam assumes a threat model much weaker than ours.
The major differences in the threat model are listed as follows:
• Veriﬁcation of worker identity.
Unlike Kardam, we do not require verifying the identities of the workers when the server receives gradients.
Kardam uses the so-called empirical Lipschitz coefﬁcient , to test the benignity of the gradient sent by a speciﬁc worker.
Such a mechanism keeps the record of the
empirical Lipschitz coefﬁcient of each worker.
Thus, whenever a gradient is received, the Kardam server must be able to identify the identity/index of the worker.
However, since Byzantine workers can behave arbitrarily, they can fake their identities/indices when sending gradients to the servers.
Thus, Kardam assumes a threat model much weaker than the traditional
Byzantine failure/threat model.
Note that for synchronous training, the server can partially counter the index spooﬁng attack by simply ﬁltering out all the gradients with duplicated indices.
However, such an approach is infeasible for asynchronous training.
• Bounded staleness of workers/limit of successive gradients.
Unlike Kardam, we do not require bounded staleness of the workers.
Kardam requires that the number of gradients successively received from a single worker is bounded above.
To be more speciﬁc, on the server, any sequence of successively received gradients of length 2 q + 1 must contain at least q + 1 gradients from honest workers.
However, in real-world asynchronous training, such an assumption is very difﬁcult to satisfy.
• A majority of honest workers.
Unlike Kardam, we do not require a majority of honest workers.
Kardam requires that the number of Byzantine workers is less than one-third of the total number of workers – much stronger restriction than the standard setting that allows for the number of Byzantine workers to be up to 50% of the total number of workers.
Zeno++ further extends this guarantee to allow for not only 50%, but also a majority of Byzantine workers.
M ODEL
We consider the following optimization problem:
[Equation]
where F ( x ) =m
[Equation]
i ∈ [ m ] E z i ∼D i f ( x ; z i ) , for ∀ i ∈ [ m ] , z
i is sampled from the local data D i on the i th device.
We solve this problem in a distributed manner with m workers.
Each worker trains the model on local data.
In each iteration, the i th worker will sample n independent data points from the dataset D i , and compute the gradient of the local empirical loss F i ( x ) = 1 n (cid:80) nj =1 f ( x ; z i,j ) , ∀ i ∈ [ m ] , where z i,j ∼ D
i is the j th sampled data on the i th worker.
When there are no Byzantine failures, the servers update the model whenever a new gradient is received:
[Equation]
When there are Byzantine failures, g τ can be replaced by arbitrary value (Damaskinos et al., 2018).
Formally, we deﬁne the threat model as follows.
Deﬁnition 1.
(Threat Model).
When the server receives a gradient estimator ˜ g τ , it is either correct or Byzantine.
If sent by a Byzantine worker, ˜ g τ is assigned arbitrary value.
If sent by an honest worker, the correct gradient is 1 n (cid:80) nj =1 ∇ f ( x τ ; z i
[Equation]
j ) , τ ≤ t, i ∈ [ m ] .
Thus, we have
[Equation]
a
[Equation]
We assume that q out of m workers are Byzantine, where q ≤ m .
Furthermore, the indices of
Byzantine workers can change across different iterations.
[Table]
M ETHODOLOGY
In this section, we introduce Zeno++ , a Byzantine-tolerant asynchronous SGD algorithm based on inner-product validation.
Zeno++ is a computationally efﬁcient version of its prototype: Zeno+ .
4. Z ENO +
Like Zeno (Xie et al., 2018b), we compute a score for each candidate gradient estimator by using the stochastic zero-order oracle.
However, in contrast to the existing synchronous SGD with majority- based aggregation methods, we need a hard threshold to decide whether a gradient is accepted, as sorting is not meaningful in asynchronous settings.
This descent score is described next.
Deﬁnition 2.
(Stochastic Descent Score (Xie et al., 2018b))
Denote f s ( x ) = 1 n s (cid:80) n s j =1 f ( x ; z j ) , where z j ’s are i.i.d.
samples drawn from S , where S (cid:54) =
D i , ∀ i ∈ [ m ] , and n s is the batch size of f s ( · ) .
For any gradient estimator (correct or Byzantine) g , model parameter x , learning rate γ , and a constant weight ρ > 0 , we deﬁne its stochastic descent score as follows:
[Equation]
Remark 1.
Note that we assume that the dataset S for computing f s ( · ) is different from the training dataset, e.g., can be a separated validation dataset.
In other words, S (cid:54) =
D 1 (cid:54) = · ·
[Equation]
(cid:54) =
[Equation]
(cid:54) =
[Equation]
The score deﬁned in Deﬁnition 2 is composed of two parts: the estimated descent of the loss function, and the magnitude of the update.
The score increases when the estimated descent of the loss function, f s ( x ) − f s ( x − γg ) , gets larger.
We penalize the score by − ρ (cid:107) g (cid:107) 2 , so that the change of the model parameter will not be too large.
A large descent suggests faster convergence.
Observe that even when a gradient is Byzantine, a small magnitude indicates that it will be less harmful to the model.
Using the stochastic descent score , we can set a hard threshold parameterized by (cid:15) to ﬁlter out candidate gradients with relatively small scores.
The detailed algorithm is outlined in Algorithm 1.
Algorithm 1 Zeno+
Server: 1: x 0 ← rand () , t ←(cid:46)
Initialization 2: repeat 3:
Randomly sample z j ∼ S , ∀ j ∈ [ n s ] to compute f s (Note: S (cid:54) =
D 1 (cid:54) = · · · (cid:54) =
D m ) 4:
Receive ˜ g from an arbitrary worker 5:
Normalize g = c
˜
g
such that (cid:107) g (cid:107)
=
(cid:107)∇ f s ( x t − 1 ) (cid:107) 2 , c >6: if Score γ,ρ ( g, x t − 1 ) ≥ − γ(cid:15) then 7: x t ← x t − 1 − γg , t ← t +8: end if 9: until Convergence
Worker i = 1 , . . .
, m : 1: function W ORKER ( HONEST ) 2: repeat 3:
Pull x τ from the server 4:
Draw random samples
z i,j ∼ D i , ∀ j ∈ [ n ] , compute ˜
g ← 1 n (cid:80) j ∈ [ n ] ∇ f ( x τ ; z i,j ) 5:
Push ˜ g to the server 6: until Convergence 7: end function 4.
[Equation]
Calculating the stochastic descent score for every candidate gradient can be computationally expensive.
To reduce the computation overhead, we approximate it by its ﬁrst-order Taylor’s expansion.
Deﬁnition 3.
(Approximated Stochastic Descent Score)
Denote f s ( x ) = 1 n s (cid:80) n s j =1 f ( x ; z j ) , where z j ’s are i.i.d.
samples drawn from S , where S (cid:54) =
D i , ∀ i ∈ [ m ] , and n s is the batch size of f s ( · ) .
For any gradient estimator (correct or Byzantine) g , model parameter x , learning rate γ , and a constant weight ρ > 0 , we approximate its stochastic descent score as follows:
[Equation]
, g
[Equation]
−
[Equation]
g
[Equation]
In brief, Zeno++ is a computationally efﬁcient version of Zeno+ which uses this approximated stochastic descent score , combined with lazy updates.
The detailed algorithm is shown in Algorithm 2.
Compared to Zeno , we highlight several new techniques in Zeno++ (Algorithm 2), specially designed for asynchronous training: 1) re-scaling the candidate gradient (Line 6); 2) ﬁrst-order
Taylor’s expansion (Line 7); 3) hard threshold instead of comparison with the others (Line 7); 4) lazy update for reducing the computation overhead (Line 9).
Before moving forward, we wish to highlight several practical remarks for Zeno++ :
• Preparing the validation dataset for Zeno++: The dataset S used for calculating v (the validation gradient of Zeno++ ) can be collected in many ways.
It can be a separate validation dataset provided by a trusted third party.
Another reasonable choice is that, a group of trusted workers can upload local data perturbed by additional noise (to help protect the users’ privacy).
Typically, the validation dataset is small and different from the training dataset, thus can only be used to validate the gradients, and cannot be directly used for training, as shown in Section 6.
• Scheduling ZenoUpdater ( x ) :
ZenoUpdater ( x ) updates v in the background.
It will only be triggered when the global model x t is updated and the server is idle.
Another scheduling strategy is to trigger ZenoUpdater ( x ) after every k iterations.
Thus, k is the upper bound of the delay of v .
A reasonable choice is k = m , so that ideally v is updated after all the m workers respond.
• Computational efﬁciency: We can reduce the computation overhead of the Zeno++ server by decreasing the mini-batch size n s , or the frequency of the activation of ZenoUpdater ( x ) .
However, doing so will potentially incur larger noise for v , which makes a trade-off.
Algorithm
+
Server: 1: x 0 ← rand () , t ←(cid:46)
Initialization 2: repeat 3: repeat 4:
Receive ˜ g from an arbitrary worker 5:
Read v with lock ( v may be from an old version of x : v = ∇ f s ( x τ ) , τ ≤ t − 1 ) 6:
Normalize g = c
˜
g
such that (cid:107) g (cid:107)
= (cid:107) v (cid:107) 2 , c >7: until γ (cid:104) v, g (cid:105)
− ρ (cid:107) g (cid:107) 2 ≥ − γ(cid:15) 8: x t ← x t − 1 − γg , t ← t
+9:
Lazy update of v : Run non-blocking ZenoUpdater ( x t ) , if idle, or after every k iterations 10: until Convergence 11: function Z ENO U PDATER ( x ) 12:
Randomly sample z j ∼ S , ∀ j ∈ [ n s ] to compute f s (Note: S (cid:54) =
D 1 (cid:54) = · · · (cid:54) =
D m ) 13:
Write with lock: v ← ∇ f s ( x ) = 1 n s (cid:80) n s j =1 ∇ f ( x ; z j ) 14: end function
Worker i = 1 , . . .
, m : 1: function W ORKER ( HONEST ) 2: repeat 3:
Pull x τ from the server 4:
Draw random samples
z i,j ∼ D i , ∀ j ∈ [ n ] , compute ˜
g ← 1 n (cid:80) j ∈ [ n ] ∇ f ( x τ ; z i,j ) 5:
Push ˜ g to the server 6: until Convergence 7: end function
T HEORETICAL GUARANTEES
In this section, we prove the convergence of Zeno++ (Algorithm 2) under Byzantine failures.
We start with deﬁnitions used in the convergence analysis.
Deﬁnition 4.
(Smoothness) Differentiable f ( x ) satisﬁes L -smoothness if there exists L > 0 such that ∀ x, y , f ( y ) − f ( x ) ≤
(cid:104)∇ f ( x ; z ) , y − x (cid:105)
+ L 2 (cid:107) y − x (cid:107) 2 .
Deﬁnition 5.
(Polyak-Łojasiewicz (PL) inequality)
Differentiable f ( x ) satisﬁes the PL inequality (Polyak, 1963) if there exists µ > 0 , such that ∀ x : f ( x ) − f ( x ∗ ) ≤ 12 µ (cid:107)∇ f ( x ) (cid:107) 2 .
5. C ONVERGENCE GUARANTEES
We prove the convergence of Algorithm 2 for non-convex problems with the following assumption.
Assumption 1.
(Bounded server delay) For Zeno++ , we assume that the delay of the validation gradient v is upper-bounded.
Without loss of generality, suppose the current model is x t , and v = ∇ f s ( x τ ) , where τ ≤ t .
We assume that for ∀ t , t − τ ≤ k .
Remark 2.
Zeno++ does not require bounded delay for the workers.
The bounded delay requirement in Assumption 1 is only for the validation gradient v on the server, not for the workers.
We ﬁrst analyze the convergence of functions that satisfy the PL inequality.
Theorem 1.
Assume that F ( x ) and f s ( x ) are L -smooth and satisfy the PL inequality.
Assume that for ∀ x , the correct gradients and validation gradients are upper-bounded: (cid:107)∇ F ( x ) (cid:107) 2 ≤
V 1 , (cid:107)∇ f s ( x ) (cid:107) 2 ≤ V 1 , and the validation gradients are always non-zero and lower-bounded: (cid:107)∇ f s ( x ) (cid:107) 2 ≥ V 2 , where 0 < V 2 ≤ V 1 .
Furthermore, we assume that the validation set is close to the training set, which implies bounded variance: E (cid:2) (cid:107)∇ f s ( x ) − ∇ F ( x ) (cid:107) 2 (cid:3) ≤ V 3 , ∀ x .
Taking γ < min(1 , 1 L ) and ρ ≥ α √ γV 1 2 µV 2 , after T global updates, Algorithm 2 converges to a global optimum:
[Equation]
Remark 3.
The assumption of the lower bounded gradient (cid:107)∇ f s ( x ) (cid:107) 2 ≥ V 2 is necessary.
We need ∇ f s ( x ) (cid:54) = 0 , so that the normalization in Line 6 and inner product in Line 7 of Algorithm 2 are feasible.
In practice, if we have a mini-batch with zero gradient ∇ f s ( x ) = 0 on server, we can simply draw additional samples and add them to the mini-batch, until such gradient is non-zero.
For general smooth but non-convex functions, we have the following convergence guarantee.
Theorem 2.
Assume that F ( x ) and f s ( x ) are L -smooth and potentially non-convex.
Assume that for ∀ x , the true gradients and validation gradients are upper-bounded: (cid:107)∇ F ( x ) (cid:107) 2 ≤ V 1 , (cid:107)∇ f s ( x ) (cid:107) 2 ≤
V 1 , and the validation gradients are always non-zero and lower-bounded: (cid:107)∇ f s ( x ) (cid:107) 2 ≥ V 2 , where 0 < V 2 ≤ V 1 .
Furthermore, we assume that the validation set is close to the training set, which implies bounded variance: E (cid:2) (cid:107)∇ f s ( x ) − ∇ F ( x ) (cid:107) 2 (cid:3) ≤ V 3 , ∀ x .
Taking γ < min(1 , 1 L ) and ρ ≥ α √ γV 1 V 2 , after T global updates, Algorithm 2 converges to a critical point:
[Equation]
Furthermore, if we take γ = 1 LT , then we have E [ (cid:80)
[Equation]
∈
[Equation] [Equation]
Remark 4.
ρ controls the trade-off between the acceptance ratio and the convergence rate.
Large positive ρ makes the convergence faster, but fewer candidate gradients pass the test of Zeno++ .
Small positive ρ increases the acceptance ratio, but may also potentially slow down the convergence or incur larger variance.
We use α > 0 to bridge ρ to the convergence rate and the variance.
Larger α makes ρ larger, which improves the convergence rate, but also enlarges the variance.
Using non-zero (cid:15) potentially results in negative thresholds, which enlarges the acceptance ratio, but also increases the false negative ratio (the ratio of Byzantine gradients that are not ﬁltered out by Zeno++ ).
E XPERIMENTS
In this section, we evaluate the proposed algorithm, Zeno++ .
Note that we do not evaluate the prototype algorithm Zeno+ , since its computation overhead is too large for practical settings.
Due to the space limitation, zoomed ﬁgures and additional experiments (including evaluation on an additional label-ﬂipping attack, and testing the sensitivity to hyperparameters) are presented in the appendix.
6. D ATASETS AND EVALUATION METRICS
We conduct experiments on the benchmark CIFAR-10 image classiﬁcation dataset (Krizhevsky and
Hinton, 2009), which is composed of 50k images for training and 10k images for testing.
We use a convolutional neural network (CNN) with 4 convolutional layers followed by 2 fully connected layers.
The detailed network architecture can be found in our submitted source code (will be released upon publication).
In the 50k images for training, we randomly extracted 2.5k of them as the validation set for Zeno++ , the remaining are randomly partitioned onto all the workers.
In each experiment, we launch 10 worker processes.
We repeat each experiment 10 times and take the average.
Each experiment is composed of 200 epochs, where each epoch is a full pass of the training dataset.
We simulate asynchrony by drawing random delay from a uniform distribution in the range of [0 , k w ] , where k w is the maximum worker delay (different from the maximum server delay k of Zeno++ ).
We use top-1 accuracy on the testing set and the cross-entropy loss function on the training set as the evaluation metrics.
We also report the false positive rate (FP), which is the ratio of correct gradients that are recognized as Byzantine and ﬁltered out by Zeno++ or the Kardam baseline.
6.1. B ASELINES
We use the asynchronous SGD without failures/attacks as the gold standard, which is referred to as
AsyncSGD without attack .
Since Kardam is the only previous work on Byzantine-tolerant asynchronous SGD, we use it as the baseline.
One may conjecture that Zeno++ is analogous to training on the validation data.
To explore this, we consider training only on S – assumed to be clean data on the server, i.e., update the model only using v = ∇ f s ( x ) on the server, without using any workers.
We call this baseline Server-only .
We ﬁne-tune the learning rate and show the best results of Server-only .
6. N O ATTACK
We ﬁrst test the convergence when there are no attacks.
In all the experiments, we take the learning rate γ = 0 .
1 , mini-batch size n = n s = 128 , ρ = 0 .
002 , (cid:15) = 0 .
1 , k = 10 .
For Kardam , we take q = 2 (i.e. here Kardam assumes that there are 2 Byzantine workers).
The result is shown in
Figure 1.
Zeno++ converges a little bit slower than AsyncSGD , but faster than Kardam , especially when the worker delay is large.
When k w = 10 , Zeno++ converges much faster than Kardam.
Server-only performs badly on both training and testing data.
[Figure] [Figure]
6. S IGN - FLIPPING ATTACK
We test the Byzantine-tolerance to the “sign-ﬂipping” attack, which was proposed in Damaskinos et al.
In such attacks, the Byzantine workers send − 10 ∇ f ( x ) instead of the correct gradient ∇ f ( x ) to the server.
In all the experiments, we take the learning rate γ = 0 .
1 , mini-batch size n = n s = 128 , ρ = 0 .
002 , (cid:15) = 0 .
1 , k = 10 .
The result is shown in Figure 2, with different number of Byzantine workers q .
It is shown that when q = 4 , Zeno++ converges slightly slower than AsyncSGD without attacks, and much faster than Kardam .
Actually, we observe that Kardam fails to make progress when the worker delay is large.
When the number of Byzantine workers gets larger ( q = 8 ), the convergence of Zeno++ gets slower, but it still makes reasonable progress, while AsyncSGD and
Kardam fail.
Note that Kardam performs even worse than Server-only , which means that
Kardam is not even as good as training on a single honest worker.
Thus, when there are Byzantine workers, distributed training with Kardam is meaningless.
6. D ISCUSSION
Kardam performs surprisingly badly in our experiments.
The experiments in Damaskinos et al.
(2018) focus on dampening staleness when there are no Byzantine failures.
For Byzantine tolerance,
Damaskinos et al.
(2018) only reports that Kardam ﬁlters out 100% of the Byzantine gradients, which matches the results in our experiments.
However, we observe that in addition to ﬁltering out 100% of the Byzantine gradients, Kardam also ﬁlters nearly 100% of the correct gradients.
In Figure 2, we
[Figure] [Figure]
[Figure] [Figure]
[Figure] [Figure]
[Figure] [Figure]
[Figure] [Figure]
[Figure]
report that the false positive rate of Kardam is nearly 99%, which makes the convergence extremely slow.
To make things worse, Kardam does not even perform as good as Server-only , which makes the distributed training with Kardam totally meaningless.
One reason why Kardam performs badly is that we use a more general threat model in this paper, which does not guarantee an important assumption of Kardam , namely “any sequence of successively received gradients of length 2 q +must contain at least q + 1 gradients from honest workers”.
It is clear that this assumption is quite strong, as in an asynchronous setting, Byzantine workers can easily send long sequences of erroneous responses.
Our approach does not depend on such a strong assumption.
In all the experiments, Zeno++ converges faster than the baselines when there are Byzantine failures.
Although the convergence of Zeno++ is slower than AsyncSGD when there are no attacks, we ﬁnd that it provides a reasonable trade-off between security and convergence speed.
In general, larger worker delay k w and more Byzantine workers q add more error and noise to the gradients, which slows down the convergence, because there are fewer valid gradients for the server to use.
Zeno++ can ﬁlter out most of the harmful gradients at the cost of FP ≈ 50% .
Note that Server-only is an extreme case that only uses the server and the validation dataset to train the model in a non-distributed manner, which will not be affected by Byzantine workers.
However, only using the validation data is not enough for training, as shown in Figure 1.
Similarly in practice, we can use a small dataset separated from the training data for cross-validation, but will never directly train the model only on such validation dataset.
Furthermore, as shown in Figure 2,
Zeno++ performs much better than Server-only .
Thus, we can draw to the conclusion that
Zeno++ is efﬁciently training the model on the honest workers in a distributed manner, which is not equivalent to training on the validation dataset only.
On average, the server computes n s k = 12 .
8 gradients in each iteration, since the validation gradient v of Zeno++ is updated after every k = 10 iterations.
Thus, the workload on the server is much smaller than a worker.
Furthermore, since we can parallelize the workload on the server and workers, the computation overhead of v can be hidden, so that Zeno++ can beneﬁt from distributed training.
C ONCLUSION
We propose a novel Byzantine-tolerant fully asynchronous SGD algorithm: Zeno++.
The algorithm provably converges.
Our empirical results show good performance compared to previous work.
In future work, we will explore variations of our approach for other settings such as federated learning.
Appendix A P ROOFS A. Z ENO ++
We ﬁrst analyze the convergence of the functions whose gradients grow as a quadratic function of sub-optimality.
Theorem 1.
Assume that F ( x ) and f s ( x ) have L -smoothness and PL inequality (potentially nonconvex).
Assume that for ∀ x , the true gradients and stochastic gradients are upper-bounded: (cid:107)∇ F ( x ) (cid:107) 2 ≤ V 1 , (cid:107)∇ f s ( x ) (cid:107) 2 ≤ V 1 , and the stochastic gradients for Zeno testing are always non-zero and lower-bounded: (cid:107)∇ f s ( x ) (cid:107) 2 ≥ V 2 , where 0 < V 2 ≤ V 1 .
Furthermore, we assume that the validation set is close to the training set, which implies bounded variance:
E
[Equation]
, ∀ x .
Taking γ < min(1 , 1 L ) and ρ ≥ α √ γV 1 2 µV 2 , after T global updates,
Algorithm 2 converges to a global optimum:
[Equation]
Proof.
If any gradient estimator g passes the test of Zeno++
[Equation]
then we have
[Equation]
where τ ≤ t − 1 .
Thus, we have
[Equation]
2 can be upper-bounded using L -smoothness and the bounded delay:
[Equation]
Again
[Equation]
using smoothness
[Equation]
taking ρ ≥ α √ γV 1 2 µV
[Equation]
we have
[Equation]
x
[Equation]
F (
[Equation] [Equation]
By telescoping and taking total expectation, after T global updates, we have
[Equation]
For general smooth but non-convex functions, we have the following convergence guarantee.
Theorem 2.
Assume that F ( x ) and f s ( x ) are L -smooth and potentially non-convex.
Assume that for ∀ x , the true gradients and stochastic gradients are upper-bounded: (cid:107)∇ F ( x ) (cid:107) 2 ≤ V 1 , (cid:107)∇ f s ( x ) (cid:107) 2 ≤ V 1 , and the stochastic gradients for Zeno testing are always non-zero and lowerbounded: (cid:107)∇ f s ( x ) (cid:107) 2 ≥ V 2 , where 0 < V 2 ≤ V 1 .
Furthermore, we assume that the validation set is close to the training set, which implies bounded variance: E (cid:2) (cid:107)∇ f s ( x ) − ∇ F ( x ) (cid:107) 2 (cid:3) ≤ V 3 , ∀ x .
Taking γ < min(1 , 1 L ) and ρ ≥ α √ γV 1 V 2 , after T global updates, Algorithm 2 converges to a critical point:
[Equation]
Furthermore, if we take γ = 1 LT , then we have
[Equation]
Proof.
Similar to Theorem 1, we have
[Equation]
Using smoothness
[Equation]
taking ρ ≥ α √ γV 1 V 2 , we have
[Equation]
Thus, we have
[Equation]
By telescoping and taking total expectation
[Equation]
after T global updates
[Equation]
we have
[Equation]
Furthermore
[Equation]
if we take γ = 1 LT
[Equation]
then we have
[Equation]
Theorem 3.
Assume that F ( x ) and f s ( x ) have L -smoothness has µ -strong convexity.
Assume that for ∀ x , the true gradients and stochastic gradients are upper-bounded: (cid:107)∇ F ( x ) (cid:107) 2 ≤ V 1 , (cid:107)∇ f s ( x ) (cid:107) 2 ≤ V 1 , and the stochastic gradients for Zeno testing are always non-zero and lowerbounded: (cid:107)∇ f s ( x ) (cid:107) 2 ≥ V 2 , where 0 < V 2 ≤ V 1 .
Furthermore, we assume that the validation set is close to the training set, which implies bounded variance: E (cid:2) (cid:107)∇ f s ( x ) − ∇ F ( x ) (cid:107) 2 (cid:3) ≤ V 3 , ∀ x .
Taking γ < min(1 , 1 L ) and ρ ≥ α √ γV 1 2 µV 2 − µγ 2 2 , after T global updates, Algorithm 1 converges to a global optimum:
[Equation]
Proof.
Using µ -strong convexity, we have
[Equation]
Note that (cid:107)∇ f s ( x
[Equation]
F ( x ) (cid:107) 2 ≥ V 2 V 1 .
Thus, we have
[Equation]
Then, we have
[Equation]
Taking the expectation on both sides
[Equation]
we have
[Equation]
Using L -smoothness, conditional on x , we have
[Equation]
Again, using µ -strong convexity, we have
[Equation]
Thus, we have
[Equation]
Taking x t − 1 = x , and x t = x − γg , we have
[Equation]
Take ρ ≥ α √ γV 1 2 µV 2 − µγ 2 2 , we have
[Equation]
By telescoping and taking total expectation, after T global updates, we have
[Equation]
B A DDITIONAL EXPERIMENTS B. N O ATTACK
We ﬁrst test the convergence when there are no attacks.
In all the experiments, we take the learning rate γ = 0 .
1 , mini-batch size n = n s = 128 , ρ = 0 .
002 , (cid:15) = 0 .
1 , k = 10 .
For Kardam , we take q = 2 ( Kardam pretends that there are 2 Byzantine workers).
The result is shown in Figure 3.
We can see that Zeno++ converges a little bit slower than AsyncSGD , but faster than Kardam , especially when the worker delay is large.
When k w = 10 , Zeno++ converges much faster than
Kardam.
[Figure]
B. S IGN - FLIPPING ATTACK
We test the Byzantine-tolerance to “sign-ﬂipping” attack, which is proposed in Damaskinos et al.
In such attacks, the Byzantine workers send − 10 ∇ f ( x ) instead of the correct gradient ∇ f ( x ) to the server.
In all the experiments, we take the learning rate γ = 0 .
1 , mini-batch size n = n s = 128 , ρ = 0 .
002 , (cid:15) = 0 .
1 , k = 10 .
The result is shown in Figure 4 and 5, with different number of
Byzantine workers q .
B. L ABEL - FLIPPING ATTACK
We test the Byzantine tolerance to the label-ﬂipping attacks.
When such kind of attacks happen, the workers compute the gradients based on the training data with “ﬂipped" labels, i.e., any label ∈ { 0 , . .
, 9 } , is replaced by 9 − label .
Such kind of attacks can be caused by data poisoning or software failures.
In all the experiments, we take the learning rate γ = 0 .
1 , mini-batch size n = n s = 128 , ρ = 0 .
002 , (cid:15) = 0 .
1 , k = 10 .
The result is shown in Figure 6 and 7, with different number of
Byzantine workers q .
B. S ENSITIVITY TO HYPERPARAMETERS
In Figure 8 and 9, we show how the hyperparameters ρ , (cid:15) , and k affect the convergence.
In general,
Zeno++ is insensitive to (cid:15) .
Larger ρ and k slow down the convergence.
[Figure]
(a) Top-1 Accuracy on Testing Set, k w = 5 .
Global Epoch
Lo ss
AsyncSGD without attack
AsyncSGD
Kardam, FP=98.
Zeno++, FP=47.
Server-only (b) Cross Entropy on Training Set, k w = 5 .
[Figure]
Global Epoch
[Figure]
(c) Top-1 Accuracy on Testing Set, k w = 15 .
Global Epoch
[Figure]
Lo ss
AsyncSGD without attack
AsyncSGD
Kardam, FP=99.
Zeno++, FP=56.
Server-only (d) Cross Entropy on Training Set, k w = 15 .
[Figure]
(a)
[Figure]
Accuracy on Testing Set, k w = 5 .
[Figure]
Global Epoch
[Figure]
Lo ss
AsyncSGD without attack
AsyncSGD
Kardam, FP=99.
Zeno++, FP=52.
Server-only (b) Cross Entropy on Training Set, k w = 5 .
[Figure] [Figure]
Global Epoch
Lo ss
AsyncSGD without attack
AsyncSGD
Kardam, FP=99.
Zeno++, FP=60.
Server-only
[Figure] [Figure]
[Figure]
Top-1 Accuracy on Testing Set, k w = 5 .
Global Epoch
Lo ss
AsyncSGD without attack
AsyncSGD
Kardam, FP=97.
Zeno++, FP=41.
Server-only (
[Figure]
, k w = 5 .
[Figure]
Global Epoch
[Figure]
(c) Top-1 Accuracy on Testing Set, k w = 15 .
Global Epoch
Lo ss
AsyncSGD without attack
AsyncSGD
Kardam, FP=99.
Zeno++, FP=48.
Server-only
[Figure] [Figure]
[Figure] [Figure]
[Figure]
Global Epoch
[Figure]
AsyncSGD
[Figure]
attack
AsyncSGD
Kardam, FP=99.
Zeno++, FP=33.
Server-only
[Figure] [Figure]
op
[Figure]
cc
[Figure]
Global
[Figure]
Kardam
[Figure]
10 -      # o f g l oba l epo c
h s = =0.
=0.
k     #
o f g l ob a l epo c
h s =0.
=0.
n s     #
[Figure]
f g l oba l epo c h s q= q=
ON CIFAR-  We test the Byzantine-tolerance on ResNet20 v1 (https://keras.io/examples/cifar10_resnet/) and
CIFAR-10 dataset.
We show the top-1 accuracy on the testing set.
In Figure 11, we show the convergence when there are no attacks.
Zeno++ converges as good as
AsyncSGD .
In Figure 12, we show the convergence when there are sign-ﬂipping attacks.
In Figure 13 and 14, we test Zeno++ with 2 different types of random attacks.
In Figure 13, for any correct gradient g , if selected to be Byzantine, any element of g will be replaced by a IID random value drawn from a Gaussian distribution with 0 mean and 5 variance, while in Figure 14, any element of Byzantine g will be added by a IID random value drawn from a Gaussian distribution with 0 mean and 5 variance.
Global Epoch 0.
T op -
[Figure]
cc
[Figure]
r a cy
AsyncSGD without attack
Kardam, [Equation] =99.
[Equation]
Global Epoch 0.
T o pa cc u r a cy
AsyncSGD without attack
AsyncSGD
[Equation]
[Equation]
workers are Byzantine. ρ = 0 .
00005 , (cid:15) = 0 , k = 15 for Zeno++ . B. LSTM ON W IKI T EXT -  We test the Byzantine-tolerance on LSTM-based language model.
The model is from https://github.com/salesforce/awd-lstm-lm (Merity et al., 2017; 2018), trained on WikiText-2 dataset.
We use 600 hidden units per layer.
We show the perplexity (the smaller the better) on the testing set.
Global Epoch 0.
T opa cc u r a cy
AsyncSGD without attack
AsyncSGD
Kardam, FP=99.
Zeno++, FP=43.
Global Epoch 0.
T opa cc u r a cy
AsyncSGD without attack
AsyncSGD
Kardam, FP=99.
Zeno++, FP=45.
In Figure 15, we show the convergence when there are no attacks.
Zeno++ converges as good as
AsyncSGD .
In Figure 16 and 17, we show the convergence when there are sign-ﬂipping attacks, with different number of Byzantine workers.
Global Epoch
P e r p l e x i t y
AsyncSGD without attack
Kardam, FP=89.
Zeno++, FP=11.
Global Epoch
P e r p l e x i t y
AsyncSGD without attack
AsyncSGD
Kardam, FP=99.
Zeno++, FP=16.
Global Epoch
P e r p l e x i t y
AsyncSGD without attack
AsyncSGD
Kardam, FP=99.
Zeno++, FP=24.