Escaping Saddle Points in Distributed Newton’s Method with Communication Efficiency and Byzantine Resilience

Motivated by the real-world applications such as recommendation systems, image recognition, and conversational AI, it has become crucial to implement learning algorithms in a distributed fashion. In a commonly used framework, namely data-parallelism, large data-sets are distributed among several worker machines for parallel processing. In many applications, like Federated Learning (FL) [Konečnỳ et al.(2016)Konečnỳ, McMahan, Ramage, and Richtárik], data is stored in user devices such as mobile phones and personal computers. In a standard distributed framework, several worker machines perform local computations and communicate to the center machine (a parameter server), and the center machine aggregates and broadcasts the information iteratively.

In this setting, it is well-known that one of the major challenges is to tackle the behavior of the Byzantine machines [Lamport et al.(1982)Lamport, Shostak, and Pease]. This can happen owing to software or hardware crashes, poor communication link between the worker and the center machine, stalled computations, and even co-ordinated or malicious attacks by a third party. In this setup, it is generally assumed (see [Yin et al.(2018)Yin, Chen, Kannan, and Bartlett, Blanchard et al.(2017)Blanchard, Mhamdi, Guerraoui, and Stainer] that a subset of worker machines behave completely arbitrarily even in a way that depends on the algorithm used and the data on the other machines, thereby capturing the unpredictable nature of the errors.

Another critical challenge in this distributed setup is the communication cost between the worker and the center machine. The gains we obtain by parellelization of the task among several worker machines often get bottle-necked by the communication cost between the worker and the center machine. In applications like Federated learning, this communication cost is directly linked with the (internet) bandwidth of the users and thus resource constrained. It is well known that in-terms of the number of iterations, second order methods (like Newton and its variants) outperform their competitor; the first order gradient based methods. In this work, we simultaneously handle the Byzantine and communication cost aspects of distributed optimization for non-convex functions.

In this paper, we focus on optimizing a non-convex loss function $f(.)$ in a distributed optimization framework. We have $m$ worker machines, out of which $\alpha$ fraction may behave in a Byzantine fashion, where $\alpha<\frac{1}{2}$. Optimizing a loss function in a distributed setup has gained a lot of attention in recent years [Alistarh et al.(2018a)Alistarh, Allen-Zhu, and Li, Blanchard et al.(2017)Blanchard, Mhamdi, Guerraoui, and Stainer, Feng et al.(2014)Feng, Xu, and Mannor, Chen et al.(2017)Chen, Su, and Xu]. However, most of these approaches either work when $f(.)$ is convex, or provide weak guarantees in the non-convex case (for example: zero gradient points, maybe a saddle point).

In order to fit complex machine learning models, one often requires to find local minima of a non-convex loss $f(.)$, instead of critical points only, which may include several saddle points. Training deep neural networks and other high-capacity learning architectures [Soudry and Carmon(2016), Ge et al.(2017)Ge, Jin, and Zheng] are some of the examples where finding local minima is crucial. [Ge et al.(2017)Ge, Jin, and Zheng, Kawaguchi(2016)] shows that the stationary points of these problems are in fact saddle points and far away from any local minimum, and hence designing efficient algorithm that escapes saddle points is of interest. Moreover, [Jain et al.(2017)Jain, Jin, Kakade, and Netrapalli, Sun et al.(2016)Sun, Qu, and Wright] argue that saddle points can lead to highly sub-optimal solutions in many problems of interest. This is amplified in high dimension as shown in [Dauphin et al.(2014)Dauphin, Pascanu, Gulcehre, Cho, Ganguli, and Bengio], and becomes the main bottleneck in training deep neural nets. Furthermore, a line of recent work [Sun et al.(2016)Sun, Qu, and Wright, Bhojanapalli et al.(2016)Bhojanapalli, Neyshabur, and Srebro, Sun et al.(2017)Sun, Qu, and Wright], shows that for many non-convex problems, it is sufficient to find a local minimum. In fact, in many problems of interest, all local minima are global minima (e.g., dictionary learning [Sun et al.(2017)Sun, Qu, and Wright], phase retrieval [Sun et al.(2016)Sun, Qu, and Wright], matrix sensing and completion [Bhojanapalli et al.(2016)Bhojanapalli, Neyshabur, and Srebro, Ge et al.(2017)Ge, Jin, and Zheng], and some of neural nets [Kawaguchi(2016)]). Also, in [Choromanska et al.(2015)Choromanska, Henaff, Mathieu, Arous, and LeCun], it is argued that for more general neural nets, the local minima are as good as global minima.

The issue of local minima convergence becomes non-trivial in the presence of Byzantine workers. Since we do not assume anything on the behavior of the Byzantine workers, it is certainly conceivable that by appropriately modifying their messages to the center, they can create fake local minima that are close to the saddle point of the loss function $f(.)$, and these are far away from the true local minima. This is popularly known as the saddle-point attack (see [Yin et al.(2019)Yin, Chen, Kannan, and Bartlett]), and it can arbitrarily destroy the performance of any non-robust learning algorithm. Hence, our goal is to design an algorithm that escapes saddle points of $f(.)$ in an efficient manner as well as resists the saddle-point attack simultaneously. The complexity of such an algorithm emerges from the the interplay between non-convexity of the loss function and the behavior of the Byzantine machines.

The problem of saddle point avoidance in the context of non-convex optimization has received considerable attention in the past few years. In the seminal paper of [Jin et al.(2017)Jin, Ge, Netrapalli, Kakade, and Jordan], a (first order) gradient descent based approach is proposed. A few papers [Xu et al.(2017)Xu, Jin, and Yang, Allen-Zhu and Li(2017)] following the above use various modifications to obtain saddle point avoidance guarantees. A Byzantine robust first order saddle point avoidance algorithm is proposed by Yin et al. [Yin et al.(2019)Yin, Chen, Kannan, and Bartlett], and probably is the closest to this work. In [Yin et al.(2019)Yin, Chen, Kannan, and Bartlett], the authors propose a repeated check-and-escape type of first order gradient descent based algorithm. First of all, being a first order algorithm, the convergence rate is quite slow (the rate for gradient decay is $1/\sqrt{T}$, where $T$ is the number of iterations). Moreover, implementation-wise, the algorithm presented in [Yin et al.(2019)Yin, Chen, Kannan, and Bartlett] is computation heavy, and takes potentially many iterations between the center and the worker machines. Hence, this algorithm is not efficient in terms of the communication cost.

In this work, we consider a variation of the famous cubic-regularized Newton algorithm of Nesterov and Polyak [Nesterov and Polyak(2006)], which efficiently escapes the saddle points of a non-convex function by appropriately choosing a regularization and thus pushing the Hessian towards a positive semi-definite matrix. The primary motivation behind this choice is the faster convergence rate compared to first order methods, which is crucial in terms of communication efficiency in applications like Federated Learning. Indeed, the rate of gradient decay is $\frac{1}{T^{2/3}}$.

We consider a distributed variant of the cubic regularized Newton algorithm. In this scheme, the center machine asks the workers to solve an auxiliary function and return the result. Note that the complexity of the problem is partially transferred to the worker machines. It is worth mentioning that in most distributed optimization paradigm, including Federated Learning, the workers posses sufficient compute power to handle this partial transfer of compute load, and in most cases, this is desirable [Konečnỳ et al.(2016)Konečnỳ, McMahan, Ramage, and Richtárik]. The center machine aggregates the solution of the worker machines and takes a descent step. Note that, unlike gradient aggregation, the aggregation of the solutions of the local optimization problems is a highly non-linear operation. Hence, it is quite non-trivial to extend the centralized cubic regularized algorithm to a distributed one. The solution to the cubic regularization even lacks a closed form solution unlike the second order Hessian based update or the first order gradient based update. The analysis is carried out by leveraging the first order and second order stationary conditions of the auxiliary function solved in each worker machines.

In addition to this, we simulateneously use (i) a $\delta$-approximate compressor (defined shortly) to compress the message send from workers to center to gain further communication reduction and (ii) a simple norm-based thresholding to robustify against adversarial attacks. Norm based thresholding is a standard trick for Byzantine resilience as featured in [Ghosh et al.(2020a)Ghosh, Maity, Kadhe, Mazumdar, and Ramchandran, Ghosh et al.(2020b)Ghosh, Maity, and Mazumdar]. However, since the local optimization problem lacks a closed form solution, using norm-based trimming is also technical challenging in this case. We now list our contributions.

In this section, we describe a communication efficient and Byzantine robust distributed cubic Newton algorithm that can avoid saddle point by meeting the condition second order stationary point and thus converge to a local minima for non-convex loss function. Starting with initialization $\mathbf{x}_{0}$, the center machine broadcasts the parameter to the worker machines. At $k$-th iteration, the $i$-th worker machine solves a cubic-regularized auxiliary loss function based on its local data:

where $M>0,\gamma>0$ are parameter choose suitably and $\mathbf{g}_{i,t},\mathbf{H}_{i,t}$ are the gradient and Hessian of the local loss function $f_{i}$ computed on data $(S_{i})$ stored in the worker machine.

After solving the problem described in (1), each worker machine applies compression operator $Q$ as defined in Definition 1.1 on update $\mathbf{s}_{i,k+1}$. The application of the compression on the update is to minimize the communication cost.

Moreover, we also consider that $\alpha(<\frac{1}{2})$ fraction of the worker machines are Byzantine in nature. We denote the set of Byzantine worker machines by $\mathcal{B}$ and the set of the rest of the good machines as $\mathcal{M}$. In each iteration, the good machines send the compressed update of solution of the sub-cubic problem described in equation  (1) and the Byzantine machines can send any arbitrary values or intentionally disrupt the learning algorithm with malicious updates. Moreover, in the non-convex optimization problems, one of the more complicated and important issue is to avoid saddle points which can yield highly sub-optimal results. In the presence of Byzantine worker machines, they can be in cohort to create a fake local minima and drive the algorithm into sub-optimal region. Lack of any robust measure towards these type of intentional and unintentional attacks can be catastrophic to the learning procedure as the learning algorithm can get stuck in such sub-optimal point. To tackle such Byzantine worker machines, we employ a simple process called norm based thresholding.

After receiving all the updates from the worker machines, the central machine outputs a set $\mathcal{U}$ which consists of the indexes of the worker machines with smallest norm. We choose the size of the set $\mathcal{U}$ to be $(1-\beta)m$. Hence, we ‘trim’ $\beta$ fraction of the worker machine so that we can control the iterated update by not letting the worker machines with large norm participate and diverge the learning process. We denote the set of trimmed machine as $\mathcal{T}$. We choose $\beta>\alpha$ so that at least one of the good machines gets trimmed. In this way, the norm of the all the updates in the set $\mathcal{U}$ is bounded by at least the largest norm of the good machines.

Notice that the $\delta$-approximate compressor is used to minimize the cost of communication and the norm based thresholding is used to mitigate the effect of the Byzantine machines. The central machine updates the parameter, with step-size $\eta_{k}$ as $\mathbf{x}_{k+1}=\mathbf{x}_{k}+\eta_{k}\frac{1}{|\mathcal{U}_{t}|}\sum_{i\in\mathcal{U}_{t}}Q(\mathbf{s}_{i,k+1})$.

First we show that our algorithm indeed escapes saddle point with a toy example. We choose a $2$ dimensional example: $\min_{w\in\mathbb{R}^{2}}[f_{1}(w)+f_{2}(w)]$ where $f_{1}(w)=w_{1}^{2}-w_{2}^{2}$ and $f_{2}(w)=2w_{1}^{2}-2w_{2}^{2}$ (Here $w_{i}^{2}$ denotes the $i$-th coordinate of $w^{2}$. This problem is the sum of two non-convex function and has a saddle point at $(0,0)$. In Figure  1 (left most) we observe that our algorithm escapes the saddle point $(0,0)$, with random initialization.

Next, we validate our algorithm on benchmark LIBSVM ([Chang and Lin(2011)]) data-set in both convex and non-convex problems. We choose the following loss functions: (a) Logistic loss:$\min_{\mathbf{w}\in\mathbb{R}^{d}}\frac{1}{n}\sum_{i}\log\left(1+\exp(-y_{i}\mathbf{x}_{i}^{T}\mathbf{w})\right)+\frac{\lambda}{2n}\|\mathbf{w}\|^{2}$, and (b) Non-convex robust linear regression: $\min_{\mathbf{w}\in\mathbb{R}^{d}}\frac{1}{n}\sum_{i}\log\left(\frac{(y_{i}-\mathbf{w}^{T}\mathbf{x}_{i})^{2}}{2}+1\right)$, where $\mathbf{w}\in\mathbb{R}^{d}$ is the parameter, $\{\mathbf{x}_{i}\}_{i=1}^{n}\in\mathbb{R}^{d}$ are the feature vectors and $\{\mathbf{y}_{i}\}_{i=1}^{n}\in\{0,1\}$ are the corresponding labels. We choose ‘a9a’($d=123,n\approx 32K$, we split the data into $70/30$ and use as training/testing purpose) and ‘w8a’(training data $d=300,n\approx 50K$ and testing data $d=300,n\approx 15K$ ) classification datasets and partition the data in 20 different worker machines.

First, we demonstrate Algorithm 1 in the presence of Byzantine machines and compressed update. For compression, each worker applies compression operator of QSGD [Alistarh et al.(2017a)Alistarh, Grubic, Li, Tomioka, and Vojnovic]. For a given vector $\mathbf{x}\in\mathbb{R}^{d},[Q(\mathbf{x})]_{i}=\|\mathbf{x}\|_{2}\text{sign}(\mathbf{x}_{i})\times\text{Ber}(|\mathbf{x}_{i}|/\|x\|_{2})$ for all $i\in[d]$. In this work, we consider the following four Byzantine attacks: (1) ‘Gaussian Noise attack’: where the Byzantine worker machines add Gaussian noise to the update. (2) ‘Random label attack’: where the Byzantine worker machines train and learn based on random labels instead of the proper labels. (3) ‘Flipped label attack’: where (for Binary classification) the Byzantine worker machines flip the labels of the data and learn based on wrong labels. (4) ‘Negative update attack’: where the Byzantine workers computes the update $\mathbf{s}$ (here solves the sub-problem in Eq. (1)) and communicates $-c*\mathbf{s}$ with $c\in(0,1)$ making the direction of the update opposite of the actual one. In Figure  2, we plot the function value of the robust linear regression problem for ’flipped labels‘ and ’negative update‘ attacks with compressed update for both ‘w8a’ and ‘a9a’ dataset. We choose the parameters $\lambda=1,M=10$, learning rate $\eta_{k}=1$, $\alpha=\{.1,.15,.2\}$ and $\beta=\alpha+\frac{2}{m}$, where number of worker machines $m=20$. The results with Gaussian and random labels attacks are shown in Appendix.

In this part, we establish some useful facts and lemmas. Next, we provide analysis of Theorems 3.3.