Distributed Byzantine Tolerant Stochastic Gradient Descent in the Era of Big Data
Richeng Jin Xiaofan He Huaiyu Dai











Distributed Byzantine Tolerant Stochastic Gradient Descent in the Era of Big Data
    Richeng Jin
Department of ECE 

North Carolina State University

rjin2@ncsu.edu
Xiaofan He
Electronic Information School 

Wuhan University

xiaofanhe@whu.edu.cn
Huaiyu Dai
Department of ECE 

North Carolina State University

hdai@ncsu.edu
    December 30, 2023
===================================================================================================================================================================================================================================================


The recent advances in sensor technologies and smart devices enable the collaborative collection of a sheer volume of data from multiple information sources. As a promising tool to efficiently extract useful information from such big data, machine learning has been pushed to the forefront and seen great success in a wide range of relevant areas such as computer vision, health care, and financial market analysis. To accommodate the large volume of data, there is a surge of interest in the design of distributed machine learning, among which stochastic gradient descent (SGD) is one of the mostly adopted methods. Nonetheless, distributed machine learning methods may be vulnerable to Byzantine attack, in which the adversary can deliberately share falsified information to disrupt the intended machine learning procedures. In this work, two asynchronous Byzantine tolerant SGD algorithms are proposed, in which the honest collaborative workers are assumed to store the model parameters derived from their own local data and use them as the ground truth. The proposed algorithms can deal with an arbitrary number of Byzantine attackers and are provably convergent. Simulation results based on a real-world dataset are presented to verify the theoretical results and demonstrate the effectiveness of the proposed algorithms.

This work was supported in part by the US National Science Foundation under Grants ECCS-1444009 and CNS-1824518.



§ INTRODUCTION

With the proliferation of sensors and smart devices, the past decade has witnessed the blowout growth in the size of the daily generated data. For example, according to <cit.>, the world produces around 2.5 quintillion bytes of data per day in 2014. Also, as predicted by Cisco, there will be around 11.6 billion mobile devices by the year 2020 and a smartphone will generate 4.4 gigabytes data per month on average <cit.>. Facing such a data deluge, distributed machine learning is anticipated to play an essential role because of its ability to exploit the collective computation power of the local smart/sensing devices, thereby leading to enhanced big data analytics <cit.>. Specifically, distributed machine learning mechanisms have several advantages over its centralized counterpart in big data related applications. Firstly, decentralization offers better scalability, and thus facilitates large-scale machine learning applications in practice. Secondly, it eliminates the burdensome process of moving the large amount of data from the distributed devices to a central unit <cit.> as well as the difficulty of storing the excessive amount of data in a single machine <cit.>.

In the existing literature of distributed machine learning, the workers are usually assumed to be honest and perform perfectly well (i.e., not making any mistake in calculation and information transmission). However, in practice, some of the workers may share wrong information due to system malfunction or software bugs. Also, some of them may even be compromised by an adversary and deliberately share falsified information to mislead the other co-workers. As is shown in <cit.> and <cit.>, even a single Byzantine worker can severely disrupt the convergence of distributed gradient descent algorithms. This problem becomes more critical in big data applications, since the large number of data collection devices (i.e., the workers in machine learning applications) and the sheer volume of the collected data make it extremely challenging, if not impossible, to ensure perfect trustworthiness in data sharing and processing.

There have been some recent works <cit.> on Byzantine tolerant distributed machine learning algorithms, and most of them focus on stochastic gradient descent (SGD), which is one of the classic and widely adopted distributed machine learning algorithm with good scalability. However, most of them only consider the synchronous setting. This may lead to a waste of computation resources, since the workers with better computation capability have to wait for the other slower workers. In addition, most existing methods can deal with only a limited number of Byzantine workers. Moreover, they all assume a parameter server to coordinate the collaboration among the workers, which may be vulnerable to the single point of failure (SPOF).

To better accommodate the need of big data analytics, two asynchronous distributed Byzantine tolerant SGD algorithms that can deal with an arbitrary number of Byzantine workers are proposed in this work. Particularly, in the proposed algorithms, the workers are allowed to maintain their own local model parameters, which eliminates the need for a shared parameter server as in the existing literature. Also, in this setting, the workers do not need to wait for the latest broadcast model parameter from the parameter server and can proactively fetch the current learning results from the other (possibly Byzantine) co-workers at any time, thereby fulfilling asynchronous learning.[We note that the proposed algorithms indeed introduce some communication overhead. However, it can also be implemented with a parameter server which maintains and updates the local models for the workers. In this case, the communication overhead is similar to the existing methods in the literature mentioned above. Nonetheless, it may be vulnerable to SPOF.] The two proposed algorithms correspond to two different scenarios, respectively. In the first scenario, it is assumed that an upper-bound p of the number of Byzantine workers is known. To defend the Byzantine attack in this case, each worker takes an average of the N-p model parameters that are closest to its own and then performs a gradient descent update step based on this average value. In the second scenario, no prior knowledge about the number of Byzantine workers is assumed. In this case, each worker first accepts the model parameters that potentially lead to lower empirical risk based on its evaluation over the local training samples. Then, the worker takes an average over the accepted model parameters and performs a gradient descent update step accordingly. Both of the proposed algorithms are provably convergent.

The remainder of this article is organized as follows. Section <ref> reviews preliminaries and notations used in this work. The problem is formulated and presented in Section <ref>. The proposed algorithms are presented in Section <ref>. The effectiveness of the proposed algorithms is examined through simulations in Section <ref>. Related works are discussed in Section <ref>. Conclusions and future works are presented in Section <ref>.



§ PRELIMINARIES AND NOTATIONS

In this section, we start by reviewing some important definitions. Suppose that there is a training data set 𝒮={(x_1,y_1),⋯,(x_n,y_n)} with n training instances randomly sampled from a sample space 𝒵 = 𝒳×𝒴, where 𝒳 is a space of feature vectors and 𝒴 is a label space. Let 𝒲⊆ℝ^d be a hypothesis space of the model parameter equipped with the standard inner product and 2-norm ||·||. Given a prediction model h(w) ∈ℱ: 𝒳→𝒴 which is parameterized by w ∈𝒲, the goal is to learn a good model parameter w. The prediction accuracy is measured by a loss function f: 𝒲×𝒵→ℝ.Given a hypothesis w ∈𝒲 and a training sample (x_i,y_i) ∈𝒮, we have a loss f(w,(x_i,y_i)). SGD <cit.> is a commonly used optimization algorithm, which aims to minimize the empirical risk F(w) = 1/n∑_i=1^nf(w,(x_i,y_i)) over the training data set 𝒮 of n samples. For simplicity, let f_i(w)=f(w,(x_i,y_i)) for fixed 𝒮. In each iteration, given a training sample (x_t,y_t), SGD updates the hypothesis w_t as follows:

    w_t+1 = G_f_t,η_t = w_t - η_t∇ f_t(w_t),

in which η_t is the learning rate and ∇ f_t(w_t) = ∇ f(w_t,(x_t,y_t)) is the gradient.

To facilitate later discussion on convergence, some definitions related to the loss function are presented as follows.






Let g:𝒲→ℝ be a function:


  * g is convex if for any u,v ∈𝒲, 

g(u) ≥ g(v)+<∇ g(v),u-v>

  * g is L-Lipschitz if for any u,v ∈𝒲, 

||g(u)-g(v)|| ≤ L||u-v||

  * g is λ-strongly convex if for any u,v ∈𝒲, 

g(u)≥ g(v)+<∇ g(v),u-v> + λ/2||u-v||^2






§ PROBLEM FORMULATION

In this work, a network 𝒩={1,⋯,N} consisting of N collaborative workers, each storing a portion of a dataset, is considered. It is assumed that each worker i stores and updates its own local model parameter w^i_t which will be used for their own classification tasks. In addition, asynchronous update is assumed in this work, where each worker can start its next update step immediately once the previous step finishes. Particularly, as is frequently done in the literature (e.g., <cit.>), the time steps are modeled as the ticking of local clocks governed by Poisson processes. It is assumed that each worker has a clock that ticks with a rate 1 Poisson process. Thus, the inter-tick times at each worker are rate 1 exponentials, independent across workers and over time. In addition, there is a master clock which ticks whenever a local processor clock ticks and the time is discretized according to the master clock ticks (since these are the only time that the local models are updated). In this sense, the master clock ticks according to a rate N Poisson process and the local clock i that causes each master clock tick is an independently and identically distributed (i.i.d.) random variable drawn from 𝒩. At iteration step t (when there have been t-1 total update steps for all the workers), a worker i sends requests and fetches the local model parameters from all the other workers (i.e., w^j_t, ∀ j ∈𝒩/{i}) and updates its local models based on the shared model parameters and its local dataset. In this work, it is assumed that up to p workers are Byzantine which behave arbitrarily and can share any information. Furthermore, the Byzantine workers are assumed to be aware of the local model parameters from the honest workers since they can also send requests to them. Let ℬ and ℋ denote the sets of Byzantine workers and honest workers, respectively. After fetching, worker i will receive


    w^j_t =
     w^j_t,    if j ∈ℋ,
    any w ∈𝒲,    if j ∈ℬ.


The goal of this work is to design robust SGD algorithms that can tolerant any number of Byzantine attackers (i.e., p can be any integer in [0,N-1]).




§ PROPOSED ALGORITHMS

In this section, the proposed algorithms are presented. In particular, depending on whether the upper bound p of the number of Byzantine workers is known or not, two scenarios are considered. It is assumed that whenever a worker responds to a request and sends its model parameter to others, the shared information will arrive on time. In this case, all the Byzantine workers will choose to share something upon requests, since they can be easily identified if the others fail to receive information from them.



 §.§ Scenario 1: p is known

The main steps of the proposed algorithm are given in Algorithm <ref>. The main idea is that the local model parameter stored by worker i (i.e., w^i_t) can serve as the ground truth, based on which the received shared model parameters (i.e., w^j_t, ∀ j ∈𝒩/{i}) can be filtered. Specifically, given the upper bound p of the number of Byzantine workers, accepting the N-p-1 model parameters which are closest to an honest worker's own model parameter will intuitively help filter out the wrong information shared by the Byzantine workers.


Note that since each worker i compares the received information with its own local model parameter by measuring the distance between the model parameters, naturally one possible attack against the proposed mechanism for the Byzantine workers is to add some random noise to the model parameter (i.e., w^i_t) of the worker that sends the request and then send the resulting perturbed result back to the requester. Note that in order to pass the accepting condition in Algorithm 1 (i.e., step 4), the Byzantine workers tend to modify the requester's model parameter moderately (otherwise it will be filtered out). Therefore, in the following analysis on Algorithm <ref>, it is assumed that for any w^j_t from worker j accepted by worker i at time t, it satisfies w^j_t=w^i_t+ϵ, with 𝔼[||ϵ||]=0 and 𝔼[||ϵ||^2] ≤σ^2, in which σ is a positive real number. Nonetheless, we note that the proposed algorithm works well on other types of attacks too.


Suppose that the loss function f is λ-strongly convex. At each iteration t, assume that worker i can sample a random gradient ∇ f_𝒮_t^i(w_t+1/2^i) that satisfies 𝔼[∇ f_𝒮_t^i(w_t+1/2^i)]=𝔼[∇ F(w_t+1/2^i)] and ||∇ f_𝒮_t^i(w)||^2 ≤ G^2 for any w and 𝒮_t^i. Then running Algorithm <ref> with the time model as described, with a constant step size η, we have

    ∑_l=1^N-p𝔼[||w_t+1^l-w^*||^2] ≤ (1-2ηλ/N-p)^t∑_l=1^N-p𝔼[||w_0^l-w^*||^2]
       +(1-2ηλ)σ^2+η^2G^2/2ηλ.





Without loss of generality, we assume that the first N-p workers are honest while the last p workers are Byzantine. Then we have

    ∑_l=1^N-p𝔼[||w_t+1^l-w^*||^2] = N-p-1/N-p[∑_l=1^N-p𝔼[||w_t^l-w^*||^2]] + 
       1/N-p∑_l=1^N-p[𝔼[||w_t+1/2^l-η∇ f_𝒮_t^l(w_t+1/2^l)-w^*||^2]].


For any l∈ℋ, we have


    𝔼[||w_t+1/2^l-η∇ f_𝒮_t^l(w_t+1/2^l)-w^*||^2]
       = 𝔼[||w_t+1/2^l-w^*||^2] + η^2𝔼[||∇ f_𝒮_t^l(w_t+1/2^l)||^2]
       - 2η𝔼[<w_t+1/2^l-w^*,∇ f_𝒮_t^l(w_t+1/2^l)>].

According to the strongly convexity of the loss function,


    𝔼[<w_t+1/2^l-w^*,∇ f_𝒮_t^l(w_t+1/2^l)>]
       = 𝔼[<w_t+1/2^l-w^*,∇ F(w_t+1/2^l)>] ≥λ𝔼[||w_t+1/2^l-w^*||^2].

As a result,

    𝔼[||w_t+1/2^l-η∇ f_𝒮_t^l(w_t+1/2^l)-w^*||^2]
       ≤(1-2ηλ)𝔼[||w_t+1/2^l-w^*||^2] + η^2𝔼[||∇ f_𝒮_t^l(w_t+1/2^l)||^2].

Note that w_t+1/2^l = w^l_t+∑_m ∈𝒜_t^lw^m_t/N-p, we have

    𝔼[||w_t+1/2^l-w^*||^2] ≤1/N-p[𝔼[||w_t^l-w^*||^2] 
       +∑_m ∈𝒜_t^l𝔼[||w_t^m-w^*||^2]] ≤𝔼[||w_t^l-w^*||^2] + N-p-1/N-pσ^2.


Plugging (<ref>) and (<ref>) into (<ref>), we obtain


    ∑_l=1^N-p𝔼[||w_t+1^l-w^*||^2] ≤N-p-1/N-p[∑_l=1^N-p𝔼[||w_t^l-w^*||^2]] 
       +1/N-p∑_l=1^N-p[(1-2ηλ)𝔼[||w_t^l-w^*||^2]
       +(1-2ηλ)(N-p-1)/N-pσ^2+η^2G^2]
       ≤∑_l=1^N-p(1-2ηλ/N-p)𝔼[||w_t^l-w^*||^2]+η^2G^2/N-p
       +(1-2ηλ)/(N-p)σ^2.


Therefore,

    ∑_l=1^N-p𝔼[||w_t+1^l-w^*||^2] ≤ (1-2ηλ/N-p)^t∑_l=1^N-p𝔼[||w_0^l-w^*||^2]
       +(1-2ηλ)σ^2+η^2G^2/2ηλ.




Theorem <ref> indicates that the local model parameters converge to a ball around the optimal solution, whose radius is upper bounded by a variable depending on the noise added to the shared model parameters from the Byzantine workers.




 §.§ Scenario 2: p is unknown

Note that in practice, the upper bound of the number of Byzantine workers may not be available for the honest workers, an algorithm that does not require any prior knowledge about p is developed in this subsection. The main steps of the proposed algorithm are given in Algorithm <ref>. The main difference with Algorithm <ref> is the conditions of accepting a shared model parameter. In this case, the filtering criteria in Algorithm <ref> cannot be used since p in unknown. Therefore, (<ref>) is proposed to prevent the workers from accepting model parameters that are too far away from their local model parameters. However, the performance induced by condition (<ref>) depends on the threshold parameter δ. If δ is too large, condition (<ref>) cannot filter out the Byzantine workers when the total number of iterations is limited. If δ is too small, all the legit workers may be filtered, which renders the collaboration ineffective. With such consideration, condition (<ref>) is proposed to further improve the performance of Algorithm 2, especially for large δ. In particular, (<ref>) indicates that if worker i performs a stochastic gradient update based on the shared model parameter w_t^j from worker j, its own local parameter model w_t^i is not in the direction of this update and therefore w_t^j is supposed to be closer to the optimal w^*. In addition, (<ref>) is the sufficient condition for ∑_k ∈𝒮_t^i[f_k(w_t^i)-f_k(w_t^j)]≥ 0 when the loss function f is convex, which essentially means that the model parameter shared by worker j is likely to be better than the local one.

The convergence of Algorithm <ref> is given as follows.

Suppose that the loss function f is λ-strongly convex with L-Lipschitz gradients. At each iteration t, assume that worker i can sample a random gradient ∇ f_𝒮_t^i(w_t+1/2^i) that satisfies 𝔼[∇ f_𝒮_t^i(w_t+1/2^i)]=𝔼[∇ F(w_t+1/2^i)]. Then running Algorithm <ref> with the time model as described, with a constant step size 0 ≤η≤2/λ+L, we have

    ∑_l=1^N-p𝔼[||w_t+1^l-w^*||] 
       ≤ (1-ηλ L/(N-p)(λ+L))^t∑_l=1^N-p𝔼[||w_0^l-w^*||]
       +(1-ηλ L/λ+L)δ/(N-p)∑_k=0^t(1-ηλ L/(N-p)(λ+L))^(t-k)/k+1.





Without loss of generality, we assume that the first N-p workers are honest while the last p workers are Byzantine. Then, we have

    ∑_l=1^N-p𝔼[||w_t+1^l-w^*||] = N-p-1/N-p[∑_l=1^N-p𝔼[||w_t^l-w^*||]] + 
       1/N-p∑_l=1^N-p[𝔼[||w_t+1/2^l-η∇ f_𝒮_t^l(w_t+1/2^l)-w^*||]].


For any l∈ℋ, we have


    𝔼[||w_t+1/2^l-η∇ f_𝒮_t^l(w_t+1/2^l)-w^*||^2]
       = 𝔼[||w_t+1/2^l-w^*||^2] + η^2𝔼[||∇ f_𝒮_t^l(w_t+1/2^l)||^2]
       - 2η𝔼[<w_t+1/2^l-w^*,∇ f_𝒮_t^l(w_t+1/2^l)>].

According to the strongly convexity of the loss function,

    𝔼[<w_t+1/2^l-w^*,∇ f_𝒮_t^l(w_t+1/2^l)>]
       ≥λ L/λ + L𝔼[||w_t+1/2^l-w^*||^2] + 1/λ+L||∇ f_𝒮_t^l(w_t+1/2^l)||^2.

As a result,

    𝔼[||w_t+1/2^l-η∇ f_𝒮_t^l(w_t+1/2^l)-w^*||^2]
       ≤ (1-2ηλ L/λ +L)𝔼[||w_t+1/2^l-w^*||^2] 
       + (η^2-2η/λ+L)𝔼[||∇ f_𝒮_t^l(w_t+1/2^l)||^2].


Note that when η≤2/λ+L, the second term in (<ref>) is negative and therefore,

    𝔼[||w_t+1/2^l-η∇ f_𝒮_t^l(w_t+1/2^l)-w^*||^2]
       ≤(1-2ηλ L/λ +L)𝔼[||w_t+1/2^l-w^*||^2].

Since √(1-2x)≤ 1-x when 1-2x > 0, we have

    𝔼[||w_t+1/2^l-η∇ f_𝒮_t^l(w_t+1/2^l)-w^*||]
       ≤(1-ηλ L/λ +L)𝔼[||w_t+1/2^l-w^*||].

In addition, according to (<ref>),

    𝔼[||w_t+1/2^l-w^*||]
       =𝔼[||w^l_t+∑_m ∈𝒜_t^lw^m_t/|𝒜_t^l|+1-w^*||] 
       ≤1/|𝒜_t^l|+1[𝔼[||w^l_t-w^*||] + ∑_m ∈𝒜_t^l𝔼[||w^m_t-w^*||]]
       ≤𝔼[||w^l_t-w^*||] + δ/t+1.

Then,

    ∑_l=1^N-p𝔼[||w_t+1^l-w^*||] 
       ≤∑_l=1^N-p(1-ηλ L/(N-p)(λ+L))𝔼[||w_t^l-w^*||]
       +(1-ηλ L/λ+L)δ/(N-p)(t+1).

As a result,

    ∑_l=1^N-p𝔼[||w_t+1^l-w^*||] 
       ≤∑_l=1^N-p(1-ηλ L/(N-p)(λ+L))^t𝔼[||w_0^l-w^*||]
       +(1-ηλ L/λ+L)δ/(N-p)∑_k=0^t(1-ηλ L/(N-p)(λ+L))^(t-k)/k+1.






According to (<ref>), the convergence of the local model parameters of the honest workers is immediate. In particular, the term induced by the bound given in (<ref>) decreases as the number of iterations increases and will finally vanish to 0. In addition, we note that although condition (<ref>) can guarantee the convergence of Algorithm <ref>, an appropriate δ should be determined for good performance. However, the choice of δ may depend on not only the specific dataset, but also the number of workers, which makes it hard to find a suitable δ in practice. This problem is solved by condition (<ref>), which preserves good performance even when we set δ arbitrarily large.









§ SIMULATION RESULTS

In this section, we present the simulation results to demonstrate the effectiveness of the proposed algorithms. In particular, the real public dataset MNIST <cit.> is used. MNIST is a widely used computer vision dataset which consists of 70,000 28×28 pixel images of handwritten digits from 0 to 9. The dataset is divided into a training subset of size 60,000 and a testing subset of size 10,000. It is assumed that there are 50 workers in total (i.e., N=50) and all of them randomly select M training samples from the training dataset and test their local model parameters using the testing subset after training. It is assumed that every worker builds a softmax regression model locally and runs one epoch (and therefore a larger local dataset results in more training iterations). During the training process, the local clocks of the workers are governed by the asynchronous model discussed in Section <ref>. In addition, we assumed that the Byzantine workers train their own local model parameters independently and send requests to others but never use the information from others when they perform gradient descent steps.

To evaluate the effectiveness of the proposed algorithms, the average accuracy of the final local model parameters of all the legit workers is examined and compared with three baseline mechanisms. In the “Non-collaborative" case, the honest workers independently train their local model parameters and do not collaborate at all; in the “All honest" case, all the workers are supposed to be honest; for the baseline “Krum", we implement the algorithm proposed in <cit.>. In addition, three types of attacks are considered. In the “Add noise" attack, the Byzantine attackers add a random Gaussian noise with zero mean and a variance of 0.1 to the local model parameters of the workers that send requests; in the “Random" attack, the Byzantine attackers generate and share a random vector with each element drawn from a uniform distribution in [0,1]; in the “Inverse" attack, the Byzantine attackers share the opposite value of their own local model parameters.




















































































 §.§ The Performance of the Proposed Algorithms against Different Attacks

In this subsection, the performance of the proposed algorithms against different attacks is examined. In particular, in the “All honest" case, it is assumed that the total number of honest workers is the same as the other examined mechanisms (i.e., if p=5, then there are N-p=45 workers). For the implementation of Algorithm <ref>, we present the results ignoring (<ref>) and the choice of δ will be discussed in Section <ref>. It can be observed from Figs. <ref>-<ref> that both Algorithm <ref> and Algorithm <ref> perform better than the “Non-collaborative" case and the “Krum" counterpart against the "Add noise" attack. In particular, “Krum" performs even worse than the “Non-collaborative" case since it only utilizes one of the gradients shared by all the workers and therefore discards useful information from most of the legit workers. In addition, for Algorithm <ref>, it is assumed that the exact number of Byzantine workers is known, and therefore it achieves almost the same performance as that in the “All honest" counterpart, which can be considered as the optimal case. When p is small, Fig. <ref> and Fig. <ref> show that Algorithm <ref> is about 2% worse than Algorithm <ref> in terms of testing accuracy. This is because the condition given in (<ref>) may filter out some useful information from the honest workers. However, when the number of Byzantine workers is large (i.e., p=45 in the simulation), the performance of Algorithm <ref> is comparable to that of Algorithm <ref> and the “All honest" counterpart.

Figs. <ref>-<ref> and Figs. <ref>-<ref> show the performance of the proposed algorithms against the “Random" attack and the “Inverse" attack, respectively. It can be observed the proposed algorithms outperform the “Non-collaborative" and “Krum" counterparts, which further verifies their effectiveness.






 §.§ The Impact of Knowledge about p on Algorithm 1

Note that in the previous discussion, it is assumed that the exact number of Byzantine workers is known in the implementation of Algorithm <ref>. In practice, however, such an assumption is rarely valid. Fig. <ref> shows the performance of Algorithm <ref> under “Random" attack when the estimated number of Byzantine workers (i.e., the p used in Algorithm <ref>) is different from the actual one, in the case that each worker has 600 training samples. It can be seen that when the actual number of Byzantine workers exceeds the estimated one, the performance of Algorithm <ref> degrades quickly. On the other hand, an accurate estimated p can lead to better performance. For example, Algorithm <ref> with an estimated p=25 performs better than the estimated p=45 counterpart when there are less than 25 Byzantine workers. We note that when the number of local training samples is large enough, assuming a large p does not degrade the performance much since the workers can afford to discard useful information from some of the legit workers. However, an accurate estimate of p can be essential when the workers have only a limited number of training samples.



 §.§ The Impact of Different Bound δ on Algorithm 2

Fig. <ref> and Fig. <ref> show the performance of Algorithm <ref> under “Random" attack with different bound δ, in the case that there are 25 and 45 Byzantine attackers respectively. In particular, N is the total number of workers and R satisfies ||w|| ≤ R, ∀ w∈𝒲. It can be seen that a smaller bound may lead to worse performance since more useful information may be filtered out. In fact, the optimal choice of δ may depend on the specific datasets, attacks and the number of Byzantine workers and it can be computationally expensive to obtain. However, Fig. <ref> and Fig. <ref> show that if we remove the bound δ (or equivalently set δ to arbitrarily large), the performance of Algorithm <ref> is only around 2% worse than the “All honest" case.[Similar results can be observed for other scenarios and are omitted in the interest of space.]









§ RELATED WORKS

There have been many prior works on Byzantine tolerant SGD algorithms. In particular, <cit.> proposes a geometric median based aggregation rule to calculate the gradient used for parameter update, given all the gradients received from the workers. In <cit.>, given the total number of workers N and the number of Byzantine workers p, for each worker i and its gradient ∇ f^i, the parameter server first selects a set V_i that contains the N-p-2 closest gradients to ∇ f^i. Then a score s_i is computed for each worker i, which measures how close its gradient is to the gradients in V_i (i.e., s_i=∑_j∈ V_i||∇ f^i-∇ f^j||^2). Finally, the worker with the minimum score is selected and its gradient is used for parameter update. <cit.> considers generalized Byzantine attackers which attack certain elements of the gradient vectors instead of the whole gradient vectors and proposes modified median based aggregation rules. <cit.> proposes coordinate-wise median and coordinate-wise trimmed mean based aggregation rules for gradient selection. <cit.> tries to identify the good workers by comparing their shared gradients with the medians and use the gradient information from the good workers for parameter update. However, the algorithms proposed in <cit.> become incompetent when more than half of the workers are Byzantine. In addition, synchronous settings are assumed (i.e., the workers with better computation capability have to wait for the other slower workers) in these works, which leads to waste of computation resources. <cit.> proposes an asynchronous Byzantine tolerant SGD algorithm. Particularly, it consists of a Byzantine-resilient filter and a frequency filter to determine whether a (possibly outdated) gradient should be accepted or not. However, it can only deal with up to 1/3 Byzantine workers. In <cit.>, it is assumed that the parameter server has a small portion of dataset locally, which is used to compute a noisy version of the true gradient. After receiving the gradients from the workers, the parameter server compares them with the local noisy gradients and decides to accept them if the difference is within a threshold. In this sense, the algorithm proposed in <cit.> can deal with an arbitrary number of Byzantine workers and therefore is the most relevant one to this work. However, it still requires a parameter server to collect the gradients and therefore may be vulnerable to the single point of failure. In addition, it requirs to manually set the threshold, which depends on specific datasets. Finally, only synchronous scenarios are considered in <cit.>.





























§ CONCLUSIONS AND FUTURE WORKS

Considering that most of the Byzantine tolerant SGD algorithms in the literature are either synchronous or robust against a limited number of Byzantine workers, two asynchronous distributed Byzantine tolerant SGD algorithms that can deal with an arbitrary number of Byzantine workers are proposed in this work. The convergence analysis for both algorithms is provided and the simulation results show that the proposed algorithms work well against all types of the examined Byzantine attacks. Since the proposed algorithms only consider the current shared information to decide whether to accept them or not, considering the usage of past information for performance improvement remains our future work.


IEEEtran 

